[mirror_edk2.git] / MdeModulePkg / Core / Pei / PeiMain / PeiMain.c

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