MdeModulePkg/Core/Pei/PeiMain/PeiMain.c

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