MdeModulePkg/Core/Pei/PeiMain/PeiMain.c

   1 /** @file
   2   Pei Core Main Entry Point
   3
   4 Copyright (c) 2006 - 2017, 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   PeiFreePages,
  69 };
  70
  71 /**
  72   Shadow PeiCore module from flash to installed memory.
  73
  74   @param PrivateData    PeiCore's private data structure
  75
  76   @return PeiCore function address after shadowing.
  77 **/
  78 PEICORE_FUNCTION_POINTER
  79 ShadowPeiCore (
  80   IN PEI_CORE_INSTANCE  *PrivateData
  81   )
  82 {
  83   EFI_PEI_FILE_HANDLE  PeiCoreFileHandle;
  84   EFI_PHYSICAL_ADDRESS EntryPoint;
  85   EFI_STATUS           Status;
  86   UINT32               AuthenticationState;
  87
  88   PeiCoreFileHandle = NULL;
  89
  90   //
  91   // Find the PEI Core in the BFV
  92   //
  93   Status = PrivateData->Fv[0].FvPpi->FindFileByType (
  94                                        PrivateData->Fv[0].FvPpi,
  95                                        EFI_FV_FILETYPE_PEI_CORE,
  96                                        PrivateData->Fv[0].FvHandle,
  97                                        &PeiCoreFileHandle
  98                                        );
  99   ASSERT_EFI_ERROR (Status);
 100
 101   //
 102   // Shadow PEI Core into memory so it will run faster
 103   //
 104   Status = PeiLoadImage (
 105               GetPeiServicesTablePointer (),
 106               *((EFI_PEI_FILE_HANDLE*)&PeiCoreFileHandle),
 107               PEIM_STATE_REGISTER_FOR_SHADOW,
 108               &EntryPoint,
 109               &AuthenticationState
 110               );
 111   ASSERT_EFI_ERROR (Status);
 112
 113   //
 114   // Compute the PeiCore's function address after shaowed PeiCore.
 115   // _ModuleEntryPoint is PeiCore main function entry
 116   //
 117   return (PEICORE_FUNCTION_POINTER)((UINTN) EntryPoint + (UINTN) PeiCore - (UINTN) _ModuleEntryPoint);
 118 }
 119
 120 /**
 121   This routine is invoked by main entry of PeiMain module during transition
 122   from SEC to PEI. After switching stack in the PEI core, it will restart
 123   with the old core data.
 124
 125   @param SecCoreDataPtr  Points to a data structure containing information about the PEI core's operating
 126                          environment, such as the size and location of temporary RAM, the stack location and
 127                          the BFV location.
 128   @param PpiList         Points to a list of one or more PPI descriptors to be installed initially by the PEI core.
 129                          An empty PPI list consists of a single descriptor with the end-tag
 130                          EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST. As part of its initialization
 131                          phase, the PEI Foundation will add these SEC-hosted PPIs to its PPI database such
 132                          that both the PEI Foundation and any modules can leverage the associated service
 133                          calls and/or code in these early PPIs
 134   @param Data            Pointer to old core data that is used to initialize the
 135                          core's data areas.
 136                          If NULL, it is first PeiCore entering.
 137
 138 **/
 139 VOID
 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       // Fixup for PeiService's address
 213       //
 214       SetPeiServicesTablePointer ((CONST EFI_PEI_SERVICES **)&OldCoreData->Ps);
 215
 216       //
 217       // Initialize libraries that the PEI Core is linked against
 218       //
 219       ProcessLibraryConstructorList (NULL, (CONST EFI_PEI_SERVICES **)&OldCoreData->Ps);
 220
 221       //
 222       // Update HandOffHob for new installed permanent 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 MemoryBaseAddress in memory allocation HOBs
 237       //
 238       ConvertMemoryAllocationHobs (OldCoreData);
 239
 240       //
 241       // We need convert the PPI descriptor's pointer
 242       //
 243       ConvertPpiPointers (SecCoreData, OldCoreData);
 244
 245       //
 246       // After the whole temporary memory is migrated, then we can allocate page in
 247       // permanent memory.
 248       //
 249       OldCoreData->PeiMemoryInstalled = TRUE;
 250
 251       //
 252       // Indicate that PeiCore reenter
 253       //
 254       OldCoreData->PeimDispatcherReenter = TRUE;
 255
 256       if (PcdGet64(PcdLoadModuleAtFixAddressEnable) != 0 && (OldCoreData->HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME)) {
 257         //
 258         // if Loading Module at Fixed Address is enabled, allocate the PEI code memory range usage bit map array.
 259         // Every bit in the array indicate the status of the corresponding memory page available or not
 260         //
 261         OldCoreData->PeiCodeMemoryRangeUsageBitMap = AllocateZeroPool (((PcdGet32(PcdLoadFixAddressPeiCodePageNumber)>>6) + 1)*sizeof(UINT64));
 262       }
 263
 264       //
 265       // Shadow PEI Core. When permanent memory is avaiable, shadow
 266       // PEI Core and PEIMs to get high performance.
 267       //
 268       OldCoreData->ShadowedPeiCore = (PEICORE_FUNCTION_POINTER) (UINTN) PeiCore;
 269       if ((HandoffInformationTable->BootMode == BOOT_ON_S3_RESUME && PcdGetBool (PcdShadowPeimOnS3Boot))
 270           || (HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME && PcdGetBool (PcdShadowPeimOnBoot))) {
 271         OldCoreData->ShadowedPeiCore = ShadowPeiCore (OldCoreData);
 272       }
 273
 274       //
 275       // PEI Core has now been shadowed to memory.  Restart PEI Core in memory.
 276       //
 277       OldCoreData->ShadowedPeiCore (SecCoreData, PpiList, OldCoreData);
 278
 279       //
 280       // Should never reach here.
 281       //
 282       ASSERT (FALSE);
 283       CpuDeadLoop();
 284
 285       UNREACHABLE ();
 286     }
 287
 288     //
 289     // Memory is available to the PEI Core and the PEI Core has been shadowed to memory.
 290     //
 291     CopyMem (&NewSecCoreData, SecCoreDataPtr, sizeof (NewSecCoreData));
 292     SecCoreData = &NewSecCoreData;
 293
 294     CopyMem (&PrivateData, OldCoreData, sizeof (PrivateData));
 295
 296     CpuIo = (VOID*)PrivateData.ServiceTableShadow.CpuIo;
 297     PciCfg = (VOID*)PrivateData.ServiceTableShadow.PciCfg;
 298
 299     CopyMem (&PrivateData.ServiceTableShadow, &gPs, sizeof (gPs));
 300
 301     PrivateData.ServiceTableShadow.CpuIo  = CpuIo;
 302     PrivateData.ServiceTableShadow.PciCfg = PciCfg;
 303   }
 304
 305   //
 306   // Cache a pointer to the PEI Services Table that is either in temporary memory or permanent memory
 307   //
 308   PrivateData.Ps = &PrivateData.ServiceTableShadow;
 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 libraries that the PEI Core is linked against
 317   //
 318   ProcessLibraryConstructorList (NULL, (CONST EFI_PEI_SERVICES **)&PrivateData.Ps);
 319
 320   //
 321   // Initialize PEI Core Services
 322   //
 323   InitializeMemoryServices   (&PrivateData,    SecCoreData, OldCoreData);
 324   if (OldCoreData == NULL) {
 325     //
 326     // Initialize PEI Core Private Data Buffer
 327     //
 328     PrivateData.PpiData.PpiListPtrs  = AllocateZeroPool (sizeof (PEI_PPI_LIST_POINTERS) * PcdGet32 (PcdPeiCoreMaxPpiSupported));
 329     ASSERT (PrivateData.PpiData.PpiListPtrs != NULL);
 330     PrivateData.Fv                   = AllocateZeroPool (sizeof (PEI_CORE_FV_HANDLE) * PcdGet32 (PcdPeiCoreMaxFvSupported));
 331     ASSERT (PrivateData.Fv != NULL);
 332     PrivateData.Fv[0].PeimState      = AllocateZeroPool (sizeof (UINT8) * PcdGet32 (PcdPeiCoreMaxPeimPerFv) * PcdGet32 (PcdPeiCoreMaxFvSupported));
 333     ASSERT (PrivateData.Fv[0].PeimState != NULL);
 334     PrivateData.Fv[0].FvFileHandles  = AllocateZeroPool (sizeof (EFI_PEI_FILE_HANDLE) * PcdGet32 (PcdPeiCoreMaxPeimPerFv) * PcdGet32 (PcdPeiCoreMaxFvSupported));
 335     ASSERT (PrivateData.Fv[0].FvFileHandles != NULL);
 336     for (Index = 1; Index < PcdGet32 (PcdPeiCoreMaxFvSupported); Index ++) {
 337       PrivateData.Fv[Index].PeimState     = PrivateData.Fv[Index - 1].PeimState + PcdGet32 (PcdPeiCoreMaxPeimPerFv);
 338       PrivateData.Fv[Index].FvFileHandles = PrivateData.Fv[Index - 1].FvFileHandles + PcdGet32 (PcdPeiCoreMaxPeimPerFv);
 339     }
 340     PrivateData.UnknownFvInfo        = AllocateZeroPool (sizeof (PEI_CORE_UNKNOW_FORMAT_FV_INFO) * PcdGet32 (PcdPeiCoreMaxFvSupported));
 341     ASSERT (PrivateData.UnknownFvInfo != NULL);
 342     PrivateData.CurrentFvFileHandles = AllocateZeroPool (sizeof (EFI_PEI_FILE_HANDLE) * PcdGet32 (PcdPeiCoreMaxPeimPerFv));
 343     ASSERT (PrivateData.CurrentFvFileHandles != NULL);
 344     PrivateData.FileGuid             = AllocatePool (sizeof (EFI_GUID) * PcdGet32 (PcdPeiCoreMaxPeimPerFv));
 345     ASSERT (PrivateData.FileGuid != NULL);
 346     PrivateData.FileHandles          = AllocatePool (sizeof (EFI_PEI_FILE_HANDLE) * (PcdGet32 (PcdPeiCoreMaxPeimPerFv) + 1));
 347     ASSERT (PrivateData.FileHandles != NULL);
 348   }
 349   InitializePpiServices      (&PrivateData,    OldCoreData);
 350
 351   //
 352   // Update performance measurements
 353   //
 354   if (OldCoreData == NULL) {
 355     PERF_START (NULL, "SEC", NULL, 1);
 356     PERF_END   (NULL, "SEC", NULL, 0);
 357
 358     //
 359     // If first pass, start performance measurement.
 360     //
 361     PERF_START (NULL,"PEI",    NULL, 0);
 362     PERF_START (NULL,"PreMem", NULL, 0);
 363
 364   } else {
 365     PERF_END   (NULL,"PreMem",  NULL, 0);
 366     PERF_START (NULL,"PostMem", NULL, 0);
 367   }
 368
 369   //
 370   // Complete PEI Core Service initialization
 371   //
 372   InitializeSecurityServices (&PrivateData.Ps, OldCoreData);
 373   InitializeDispatcherData   (&PrivateData,    OldCoreData, SecCoreData);
 374   InitializeImageServices    (&PrivateData,    OldCoreData);
 375
 376   //
 377   // Perform PEI Core Phase specific actions
 378   //
 379   if (OldCoreData == NULL) {
 380     //
 381     // Report Status Code EFI_SW_PC_INIT
 382     //
 383     REPORT_STATUS_CODE (
 384       EFI_PROGRESS_CODE,
 385       (EFI_SOFTWARE_PEI_CORE | EFI_SW_PC_INIT)
 386       );
 387
 388     //
 389     // If SEC provided the PpiList, process it.
 390     //
 391     if (PpiList != NULL) {
 392       ProcessPpiListFromSec ((CONST EFI_PEI_SERVICES **) &PrivateData.Ps, PpiList);
 393     }
 394   } else {
 395     //
 396     // Try to locate Temporary RAM Done Ppi.
 397     //
 398     Status = PeiServicesLocatePpi (
 399                &gEfiTemporaryRamDonePpiGuid,
 400                0,
 401                NULL,
 402                (VOID**)&TemporaryRamDonePpi
 403                );
 404     if (!EFI_ERROR (Status)) {
 405       //
 406       // Disable the use of Temporary RAM after the transition from Temporary RAM to Permanent RAM is complete.
 407       //
 408       TemporaryRamDonePpi->TemporaryRamDone ();
 409     }
 410
 411     //
 412     // Alert any listeners that there is permanent memory available
 413     //
 414     PERF_START (NULL,"DisMem", NULL, 0);
 415     Status = PeiServicesInstallPpi (&mMemoryDiscoveredPpi);
 416
 417     //
 418     // Process the Notify list and dispatch any notifies for the Memory Discovered PPI
 419     //
 420     ProcessNotifyList (&PrivateData);
 421
 422     PERF_END (NULL,"DisMem", NULL, 0);
 423   }
 424
 425   //
 426   // Call PEIM dispatcher
 427   //
 428   PeiDispatcher (SecCoreData, &PrivateData);
 429
 430   if (PrivateData.HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME) {
 431     //
 432     // Check if InstallPeiMemory service was called on non-S3 resume boot path.
 433     //
 434     ASSERT(PrivateData.PeiMemoryInstalled == TRUE);
 435   }
 436
 437   //
 438   // Measure PEI Core execution time.
 439   //
 440   PERF_END (NULL, "PostMem", NULL, 0);
 441
 442   //
 443   // Lookup DXE IPL PPI
 444   //
 445   Status = PeiServicesLocatePpi (
 446              &gEfiDxeIplPpiGuid,
 447              0,
 448              NULL,
 449              (VOID **)&TempPtr.DxeIpl
 450              );
 451   ASSERT_EFI_ERROR (Status);
 452
 453   if (EFI_ERROR (Status)) {
 454     //
 455     // Report status code to indicate DXE IPL PPI could not be found.
 456     //
 457     REPORT_STATUS_CODE (
 458       EFI_ERROR_CODE | EFI_ERROR_MAJOR,
 459       (EFI_SOFTWARE_PEI_CORE | EFI_SW_PEI_CORE_EC_DXEIPL_NOT_FOUND)
 460       );
 461     CpuDeadLoop ();
 462   }
 463
 464   //
 465   // Enter DxeIpl to load Dxe core.
 466   //
 467   DEBUG ((EFI_D_INFO, "DXE IPL Entry\n"));
 468   Status = TempPtr.DxeIpl->Entry (
 469                              TempPtr.DxeIpl,
 470                              &PrivateData.Ps,
 471                              PrivateData.HobList
 472                              );
 473   //
 474   // Should never reach here.
 475   //
 476   ASSERT_EFI_ERROR (Status);
 477   CpuDeadLoop();
 478
 479   UNREACHABLE ();
 480 }