MdeModulePkg/Core/Pei/PeiMain/PeiMain.c

   1 /*++
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   PeiMain.c
  15
  16 Abstract:
  17
  18   Pei Core Main Entry Point
  19
  20 Revision History
  21
  22 --*/
  23
  24 #include <PeiMain.h>
  25
  26 //
  27 //CAR is filled with this initial value during SEC phase
  28 //
  29 #define INIT_CAR_VALUE 0x5AA55AA5
  30
  31 static EFI_PEI_PPI_DESCRIPTOR mMemoryDiscoveredPpi = {
  32   (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  33   &gEfiPeiMemoryDiscoveredPpiGuid,
  34   NULL
  35 };
  36
  37 //
  38 // Pei Core Module Variables
  39 //
  40 //
  41 static EFI_PEI_SERVICES  mPS = {
  42   {
  43     PEI_SERVICES_SIGNATURE,
  44     PEI_SERVICES_REVISION,
  45     sizeof (EFI_PEI_SERVICES),
  46     0,
  47     0
  48   },
  49   PeiInstallPpi,
  50   PeiReInstallPpi,
  51   PeiLocatePpi,
  52   PeiNotifyPpi,
  53
  54   PeiGetBootMode,
  55   PeiSetBootMode,
  56
  57   PeiGetHobList,
  58   PeiCreateHob,
  59
  60   PeiFvFindNextVolume,
  61   PeiFfsFindNextFile,
  62   PeiFfsFindSectionData,
  63
  64   PeiInstallPeiMemory,
  65   PeiAllocatePages,
  66   PeiAllocatePool,
  67   (EFI_PEI_COPY_MEM)CopyMem,
  68   (EFI_PEI_SET_MEM)SetMem,
  69
  70   PeiReportStatusCode,
  71   PeiResetSystem,
  72
  73   NULL,
  74   NULL,
  75
  76   PeiFfsFindFileByName,
  77   PeiFfsGetFileInfo,
  78   PeiFfsGetVolumeInfo,
  79   PeiRegisterForShadow
  80 };
  81
  82 EFI_STATUS
  83 EFIAPI
  84 PeiCore (
  85   IN CONST EFI_SEC_PEI_HAND_OFF        *SecCoreData,
  86   IN CONST EFI_PEI_PPI_DESCRIPTOR      *PpiList,
  87   IN VOID                              *Data
  88   )
  89 /*++
  90
  91 Routine Description:
  92
  93   The entry routine to Pei Core, invoked by PeiMain during transition
  94   from SEC to PEI. After switching stack in the PEI core, it will restart
  95   with the old core data.
  96
  97 Arguments:
  98
  99   SecCoreData          - Points to a data structure containing information about the PEI core's operating
 100                          environment, such as the size and location of temporary RAM, the stack location and
 101                          the BFV location.
 102   PpiList              - Points to a list of one or more PPI descriptors to be installed initially by the PEI core.
 103                          An empty PPI list consists of a single descriptor with the end-tag
 104                          EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST. As part of its initialization
 105                          phase, the PEI Foundation will add these SEC-hosted PPIs to its PPI database such
 106                          that both the PEI Foundation and any modules can leverage the associated service
 107                          calls and/or code in these early PPIs
 108   Data                 - Pointer to old core data that is used to initialize the
 109                          core's data areas.
 110
 111 Returns:
 112
 113   This function never returns
 114   EFI_NOT_FOUND        - Never reach
 115
 116 --*/
 117 {
 118   PEI_CORE_INSTANCE                                     PrivateData;
 119   EFI_STATUS                                            Status;
 120   PEI_CORE_TEMP_POINTERS                                TempPtr;
 121   UINT64                                                mTick;
 122   PEI_CORE_INSTANCE                                     *OldCoreData;
 123   EFI_PEI_CPU_IO_PPI                                    *CpuIo;
 124   EFI_PEI_PCI_CFG2_PPI                                  *PciCfg;
 125
 126   mTick = 0;
 127   OldCoreData = (PEI_CORE_INSTANCE *) Data;
 128
 129   if (PerformanceMeasurementEnabled()) {
 130     if (OldCoreData == NULL) {
 131       mTick = GetPerformanceCounter ();
 132     }
 133   }
 134
 135   //
 136   // For IPF in CAR mode the real memory access is uncached,in InstallPeiMemory()
 137   //  the 63-bit of address is set to 1.
 138   //
 139   SWITCH_TO_CACHE_MODE (OldCoreData);
 140
 141   if (OldCoreData != NULL) {
 142     CopyMem (&PrivateData, OldCoreData, sizeof (PEI_CORE_INSTANCE));
 143
 144     CpuIo = (VOID*)PrivateData.ServiceTableShadow.CpuIo;
 145     PciCfg = (VOID*)PrivateData.ServiceTableShadow.PciCfg;
 146
 147     CopyMem (&PrivateData.ServiceTableShadow, &mPS, sizeof (mPS));
 148
 149     PrivateData.ServiceTableShadow.CpuIo  = CpuIo;
 150     PrivateData.ServiceTableShadow.PciCfg = PciCfg;
 151   } else {
 152     ZeroMem (&PrivateData, sizeof (PEI_CORE_INSTANCE));
 153     PrivateData.Signature = PEI_CORE_HANDLE_SIGNATURE;
 154     CopyMem (&PrivateData.ServiceTableShadow, &mPS, sizeof (mPS));
 155   }
 156
 157   PrivateData.PS = &PrivateData.ServiceTableShadow;
 158
 159   //
 160   // Initialize libraries that the PeiCore is linked against
 161   // BUGBUG: The FileHandle is passed in as NULL.  Do we look it up or remove it from the lib init?
 162   //
 163   ProcessLibraryConstructorList (NULL, &PrivateData.PS);
 164
 165   InitializeMemoryServices (&PrivateData, SecCoreData, OldCoreData);
 166
 167   InitializePpiServices (&PrivateData, OldCoreData);
 168
 169   //
 170   // Save PeiServicePointer so that it can be retrieved anywhere.
 171   //
 172   SetPeiServicesTablePointer(&PrivateData.PS);
 173
 174   if (OldCoreData != NULL) {
 175
 176     PERF_END (NULL,"PreMem", NULL, 0);
 177     PERF_START (NULL,"PostMem", NULL, 0);
 178
 179     //
 180     // The following code dumps out interesting cache as RAM usage information
 181     // so we can keep tabs on how the cache as RAM is being utilized.  The
 182     // DEBUG_CODE_BEGIN macro is used to prevent this code from being compiled
 183     // on a debug build.
 184     //
 185     DEBUG_CODE_BEGIN ();
 186       UINTN  *StackPointer;
 187       UINTN  StackValue;
 188
 189       StackValue = INIT_CAR_VALUE;
 190       for (StackPointer = (UINTN *) OldCoreData->MaxTopOfCarHeap;
 191            ((UINTN) StackPointer < ((UINTN) OldCoreData->BottomOfCarHeap + OldCoreData->SizeOfCacheAsRam))
 192            && StackValue == INIT_CAR_VALUE;
 193            StackPointer++) {
 194         StackValue = *StackPointer;
 195       }
 196
 197       DEBUG ((EFI_D_INFO, "Total Cache as RAM:    %d bytes.\n", OldCoreData->SizeOfCacheAsRam));
 198       DEBUG ((EFI_D_INFO, "  CAR stack ever used: %d bytes.\n",
 199         ((UINTN) OldCoreData->TopOfCarHeap - (UINTN) StackPointer)
 200         ));
 201       DEBUG ((EFI_D_INFO, "  CAR heap used:       %d bytes.\n",
 202         ((UINTN) OldCoreData->HobList.HandoffInformationTable->EfiFreeMemoryBottom -
 203         (UINTN) OldCoreData->HobList.Raw)
 204         ));
 205     DEBUG_CODE_END ();
 206
 207     //
 208     // Alert any listeners that there is permanent memory available
 209     //
 210
 211     PERF_START (NULL,"DisMem", NULL, 0);
 212     Status = PeiServicesInstallPpi (&mMemoryDiscoveredPpi);
 213     PERF_END (NULL,"DisMem", NULL, 0);
 214
 215   } else {
 216
 217     //
 218     // Report Status Code EFI_SW_PC_INIT
 219     //
 220     REPORT_STATUS_CODE (
 221       EFI_PROGRESS_CODE,
 222       EFI_SOFTWARE_PEI_CORE | EFI_SW_PC_INIT
 223       );
 224
 225     PERF_START (NULL,"PEI", NULL, mTick);
 226     //
 227     // If first pass, start performance measurement.
 228     //
 229     PERF_START (NULL,"PreMem", NULL, mTick);
 230
 231     //
 232     // If SEC provided any PPI services to PEI, install them.
 233     //
 234     if (PpiList != NULL) {
 235       Status = PeiServicesInstallPpi (PpiList);
 236       ASSERT_EFI_ERROR (Status);
 237     }
 238   }
 239
 240   InitializeSecurityServices (&PrivateData.PS, OldCoreData);
 241
 242   InitializeDispatcherData (&PrivateData, OldCoreData, SecCoreData);
 243
 244   //
 245   // Install Pei Load File PPI.
 246   //
 247   InitializeImageServices (&PrivateData, OldCoreData);
 248
 249   //
 250   // Call PEIM dispatcher
 251   //
 252   PeiDispatcher (SecCoreData, &PrivateData);
 253
 254   //
 255   // Check if InstallPeiMemory service was called.
 256   //
 257   ASSERT(PrivateData.PeiMemoryInstalled == TRUE);
 258
 259   PERF_END (NULL, "PostMem", NULL, 0);
 260
 261   Status = PeiServicesLocatePpi (
 262              &gEfiDxeIplPpiGuid,
 263              0,
 264              NULL,
 265              (VOID **)&TempPtr.DxeIpl
 266              );
 267   ASSERT_EFI_ERROR (Status);
 268
 269   DEBUG ((EFI_D_INFO, "DXE IPL Entry\n"));
 270   Status = TempPtr.DxeIpl->Entry (
 271                              TempPtr.DxeIpl,
 272                              &PrivateData.PS,
 273                              PrivateData.HobList
 274                              );
 275
 276   ASSERT_EFI_ERROR (Status);
 277
 278   return EFI_NOT_FOUND;
 279 }
 280