IntelFsp2Pkg/Library/BaseFspPlatformLib/FspPlatformNotify.c

   1 /** @file
   2
   3   Copyright (c) 2014 - 2016, Intel Corporation. All rights reserved.<BR>
   4   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 **/
  13
  14 #include <PiPei.h>
  15 #include <Library/PeiServicesLib.h>
  16 #include <Library/PeiServicesTablePointerLib.h>
  17 #include <Library/BaseLib.h>
  18 #include <Library/BaseMemoryLib.h>
  19 #include <Library/PcdLib.h>
  20 #include <Library/DebugLib.h>
  21 #include <Library/HobLib.h>
  22 #include <Library/FspSwitchStackLib.h>
  23 #include <Library/FspCommonLib.h>
  24 #include <Guid/EventGroup.h>
  25 #include <FspEas.h>
  26 #include <FspStatusCode.h>
  27 #include <Protocol/PciEnumerationComplete.h>
  28 #include <Library/ReportStatusCodeLib.h>
  29 #include <Library/PerformanceLib.h>
  30 extern EFI_GUID gFspPerformanceDataGuid;
  31
  32 EFI_PEI_PPI_DESCRIPTOR      mPeiPostPciEnumerationPpi = {
  33   (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  34   &gEfiPciEnumerationCompleteProtocolGuid,
  35   NULL
  36 };
  37
  38 EFI_PEI_PPI_DESCRIPTOR      mPeiReadyToBootPpi = {
  39   (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  40   &gEfiEventReadyToBootGuid,
  41   NULL
  42 };
  43
  44 EFI_PEI_PPI_DESCRIPTOR      mPeiEndOfFirmwarePpi = {
  45   (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  46   &gFspEventEndOfFirmwareGuid,
  47   NULL
  48 };
  49
  50 UINT32  mFspNotifySequence[] = {
  51   EnumInitPhaseAfterPciEnumeration,
  52   EnumInitPhaseReadyToBoot,
  53   EnumInitPhaseEndOfFirmware
  54 };
  55
  56 /**
  57   Install FSP notification.
  58
  59   @param[in] NotificationCode  FSP notification code
  60
  61   @retval EFI_SUCCESS            Notify FSP successfully
  62   @retval EFI_INVALID_PARAMETER  NotificationCode is invalid
  63
  64 **/
  65 EFI_STATUS
  66 EFIAPI
  67 FspNotificationHandler (
  68   IN  UINT32     NotificationCode
  69   )
  70 {
  71   EFI_STATUS                Status;
  72
  73   Status   = EFI_SUCCESS;
  74
  75   switch (NotificationCode) {
  76   case EnumInitPhaseAfterPciEnumeration:
  77     //
  78     // Do POST PCI initialization if needed
  79     //
  80     DEBUG ((DEBUG_INFO | DEBUG_INIT, "FSP Post PCI Enumeration ...\n"));
  81     PeiServicesInstallPpi (&mPeiPostPciEnumerationPpi);
  82     break;
  83
  84   case EnumInitPhaseReadyToBoot:
  85     //
  86     // Ready To Boot
  87     //
  88     DEBUG ((DEBUG_INFO| DEBUG_INIT, "FSP Ready To Boot ...\n"));
  89     PeiServicesInstallPpi (&mPeiReadyToBootPpi);
  90     break;
  91
  92   case EnumInitPhaseEndOfFirmware:
  93     //
  94     // End of Firmware
  95     //
  96     DEBUG ((DEBUG_INFO| DEBUG_INIT, "FSP End of Firmware ...\n"));
  97     PeiServicesInstallPpi (&mPeiEndOfFirmwarePpi);
  98     break;
  99
 100   default:
 101     Status = EFI_INVALID_PARAMETER;
 102     break;
 103   }
 104
 105   return Status;
 106 }
 107
 108 /**
 109   This function transfer control back to BootLoader after FspSiliconInit.
 110
 111   @param[in] Status return status for the FspSiliconInit.
 112
 113 **/
 114 VOID
 115 EFIAPI
 116 FspSiliconInitDone2 (
 117   IN EFI_STATUS Status
 118   )
 119 {
 120   //
 121   // Convert to FSP EAS defined API return codes
 122   //
 123   switch (Status) {
 124     case EFI_SUCCESS:
 125     case EFI_INVALID_PARAMETER:
 126     case EFI_UNSUPPORTED:
 127     case EFI_DEVICE_ERROR:
 128       break;
 129     default:
 130       DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspSiliconInitApi() Invalid Error - [Status: 0x%08X]\n", Status));
 131       Status = EFI_DEVICE_ERROR;  // Force to known error.
 132       break;
 133   }
 134   //
 135   // This is the end of the FspSiliconInit API
 136   // Give control back to the boot loader
 137   //
 138   SetFspMeasurePoint (FSP_PERF_ID_API_FSP_SILICON_INIT_EXIT);
 139   DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspSiliconInitApi() - [Status: 0x%08X] - End\n", Status));
 140   PERF_END_EX (&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_SILICON_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 141   REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 142   do {
 143     SetFspApiReturnStatus (Status);
 144     Pei2LoaderSwitchStack ();
 145     if (Status != EFI_SUCCESS) {
 146       DEBUG ((DEBUG_ERROR, "!!!ERROR: FspSiliconInitApi() - [Status: 0x%08X] - Error encountered during previous API and cannot proceed further\n", Status));
 147     }
 148   } while (Status != EFI_SUCCESS);
 149 }
 150
 151 /**
 152   This function returns control to BootLoader after MemoryInitApi.
 153
 154   @param[in] Status return status for the MemoryInitApi.
 155   @param[in,out] HobListPtr The address of HobList pointer, if NULL, will get value from GetFspApiParameter2 ()
 156 **/
 157 VOID
 158 EFIAPI
 159 FspMemoryInitDone2 (
 160   IN EFI_STATUS Status,
 161   IN OUT VOID   **HobListPtr
 162   )
 163 {
 164   FSP_GLOBAL_DATA   *FspData;
 165   //
 166   // Calling use FspMemoryInit API
 167   // Update HOB and return the control directly
 168   //
 169   if (HobListPtr == NULL) {
 170     HobListPtr = (VOID **)GetFspApiParameter2 ();
 171   }
 172   if (HobListPtr != NULL) {
 173     *HobListPtr = (VOID *) GetHobList ();
 174   }
 175   //
 176   // Convert to FSP EAS defined API return codes
 177   //
 178   switch (Status) {
 179     case EFI_SUCCESS:
 180     case EFI_INVALID_PARAMETER:
 181     case EFI_UNSUPPORTED:
 182     case EFI_DEVICE_ERROR:
 183     case EFI_OUT_OF_RESOURCES:
 184       break;
 185     default:
 186       DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspMemoryInitApi() Invalid Error [Status: 0x%08X]\n", Status));
 187       Status = EFI_DEVICE_ERROR;  // Force to known error.
 188       break;
 189   }
 190   //
 191   // This is the end of the FspMemoryInit API
 192   // Give control back to the boot loader
 193   //
 194   DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspMemoryInitApi() - [Status: 0x%08X] - End\n", Status));
 195   SetFspMeasurePoint (FSP_PERF_ID_API_FSP_MEMORY_INIT_EXIT);
 196   FspData = GetFspGlobalDataPointer ();
 197   PERF_START_EX(&gFspPerformanceDataGuid, "EventRec", NULL, (FspData->PerfData[0] & FSP_PERFORMANCE_DATA_TIMER_MASK), FSP_STATUS_CODE_TEMP_RAM_INIT | FSP_STATUS_CODE_COMMON_CODE| FSP_STATUS_CODE_API_ENTRY);
 198   PERF_END_EX(&gFspPerformanceDataGuid, "EventRec", NULL, (FspData->PerfData[1] & FSP_PERFORMANCE_DATA_TIMER_MASK), FSP_STATUS_CODE_TEMP_RAM_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 199   PERF_START_EX(&gFspPerformanceDataGuid, "EventRec", NULL, (FspData->PerfData[2] & FSP_PERFORMANCE_DATA_TIMER_MASK), FSP_STATUS_CODE_MEMORY_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 200   PERF_END_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_MEMORY_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 201   REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_MEMORY_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 202   do {
 203     SetFspApiReturnStatus (Status);
 204     Pei2LoaderSwitchStack ();
 205     if (Status != EFI_SUCCESS) {
 206       DEBUG ((DEBUG_ERROR, "!!!ERROR: FspMemoryInitApi() - [Status: 0x%08X] - Error encountered during previous API and cannot proceed further\n", Status));
 207     }
 208   } while (Status != EFI_SUCCESS);
 209
 210   //
 211   // The TempRamExitApi is called
 212   //
 213   if (GetFspApiCallingIndex () == TempRamExitApiIndex) {
 214     SetPhaseStatusCode (FSP_STATUS_CODE_TEMP_RAM_EXIT);
 215     SetFspMeasurePoint (FSP_PERF_ID_API_TEMP_RAM_EXIT_ENTRY);
 216     PERF_START_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_TEMP_RAM_EXIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 217     REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_TEMP_RAM_EXIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 218     DEBUG ((DEBUG_INFO | DEBUG_INIT, "TempRamExitApi() - Begin\n"));
 219   } else {
 220     SetPhaseStatusCode (FSP_STATUS_CODE_SILICON_INIT);
 221     SetFspMeasurePoint (FSP_PERF_ID_API_FSP_SILICON_INIT_ENTRY);
 222     PERF_START_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_SILICON_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 223     REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_SILICON_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 224     DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspSiliconInitApi() - Begin\n"));
 225   }
 226 }
 227
 228 /**
 229   This function returns control to BootLoader after TempRamExitApi.
 230
 231   @param[in] Status return status for the TempRamExitApi.
 232
 233 **/
 234 VOID
 235 EFIAPI
 236 FspTempRamExitDone2 (
 237   IN EFI_STATUS Status
 238   )
 239 {
 240   //
 241   // Convert to FSP EAS defined API return codes
 242   //
 243   switch (Status) {
 244     case EFI_SUCCESS:
 245     case EFI_INVALID_PARAMETER:
 246     case EFI_UNSUPPORTED:
 247     case EFI_DEVICE_ERROR:
 248       break;
 249     default:
 250       DEBUG ((DEBUG_INFO | DEBUG_INIT, "TempRamExitApi() Invalid Error - [Status: 0x%08X]\n", Status));
 251       Status = EFI_DEVICE_ERROR;  // Force to known error.
 252       break;
 253   }
 254   //
 255   // This is the end of the TempRamExit API
 256   // Give control back to the boot loader
 257   //
 258   DEBUG ((DEBUG_INFO | DEBUG_INIT, "TempRamExitApi() - [Status: 0x%08X] - End\n", Status));
 259   SetFspMeasurePoint (FSP_PERF_ID_API_TEMP_RAM_EXIT_EXIT);
 260   PERF_END_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_TEMP_RAM_EXIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 261   REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_TEMP_RAM_EXIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 262   do {
 263     SetFspApiReturnStatus (Status);
 264     Pei2LoaderSwitchStack ();
 265     if (Status != EFI_SUCCESS) {
 266       DEBUG ((DEBUG_ERROR, "!!!ERROR: TempRamExitApi() - [Status: 0x%08X] - Error encountered during previous API and cannot proceed further\n", Status));
 267     }
 268   } while (Status != EFI_SUCCESS);
 269   SetPhaseStatusCode (FSP_STATUS_CODE_SILICON_INIT);
 270   SetFspMeasurePoint (FSP_PERF_ID_API_FSP_SILICON_INIT_ENTRY);
 271   PERF_START_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_SILICON_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 272   REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_SILICON_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 273   DEBUG ((DEBUG_INFO | DEBUG_INIT, "SiliconInitApi() - Begin\n"));
 274 }
 275
 276 /**
 277   This function handle NotifyPhase API call from the BootLoader.
 278   It gives control back to the BootLoader after it is handled. If the
 279   Notification code is a ReadyToBoot event, this function will return
 280   and FSP continues the remaining execution until it reaches the DxeIpl.
 281
 282 **/
 283 VOID
 284 FspWaitForNotify (
 285   VOID
 286   )
 287 {
 288   EFI_STATUS                 Status;
 289   UINT32                     NotificationValue;
 290   UINT32                     NotificationCount;
 291   UINT8                      Count;
 292
 293   NotificationCount = 0;
 294   while (NotificationCount < sizeof(mFspNotifySequence) / sizeof(UINT32)) {
 295
 296     Count = (UINT8)((NotificationCount << 1) & 0x07);
 297     SetFspMeasurePoint (FSP_PERF_ID_API_NOTIFY_POST_PCI_ENTRY + Count);
 298
 299     if (NotificationCount == 0) {
 300       SetPhaseStatusCode (FSP_STATUS_CODE_POST_PCIE_ENUM_NOTIFICATION);
 301       PERF_START_EX (&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_POST_PCIE_ENUM_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 302       REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_POST_PCIE_ENUM_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 303     } else if (NotificationCount == 1) {
 304       SetPhaseStatusCode (FSP_STATUS_CODE_READY_TO_BOOT_NOTIFICATION);
 305       PERF_START_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_READY_TO_BOOT_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 306       REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_READY_TO_BOOT_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 307     } else if (NotificationCount == 2) {
 308       SetPhaseStatusCode (FSP_STATUS_CODE_END_OF_FIRMWARE_NOTIFICATION);
 309       PERF_START_EX (&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_END_OF_FIRMWARE_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 310       REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_END_OF_FIRMWARE_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY);
 311     }
 312
 313     NotificationValue = ((NOTIFY_PHASE_PARAMS *)(UINTN)GetFspApiParameter ())->Phase;
 314     DEBUG ((DEBUG_INFO | DEBUG_INIT, "NotifyPhaseApi() - Begin  [Phase: %08X]\n", NotificationValue));
 315     if (mFspNotifySequence[NotificationCount] != NotificationValue) {
 316       //
 317       // Notify code does not follow the predefined order
 318       //
 319       DEBUG ((DEBUG_INFO, "Unsupported FSP Notification Value\n"));
 320       Status = EFI_UNSUPPORTED;
 321     } else {
 322       //
 323       // Process Notification and Give control back to the boot loader framework caller
 324       //
 325       Status = FspNotificationHandler (NotificationValue);
 326       if (!EFI_ERROR(Status)) {
 327         NotificationCount++;
 328       }
 329     }
 330
 331     DEBUG ((DEBUG_INFO | DEBUG_INIT, "NotifyPhaseApi() - End  [Status: 0x%08X]\n", Status));
 332     SetFspMeasurePoint (FSP_PERF_ID_API_NOTIFY_POST_PCI_EXIT + Count);
 333
 334     if ((NotificationCount - 1) == 0) {
 335       PERF_END_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_POST_PCIE_ENUM_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 336       REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_POST_PCIE_ENUM_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 337     } else if ((NotificationCount - 1) == 1) {
 338       PERF_END_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_READY_TO_BOOT_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 339       REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_READY_TO_BOOT_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 340     } else if ((NotificationCount - 1) == 2) {
 341       PERF_END_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_END_OF_FIRMWARE_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 342       REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_END_OF_FIRMWARE_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT);
 343     }
 344     do {
 345       SetFspApiReturnStatus(Status);
 346       Pei2LoaderSwitchStack();
 347       if (Status != EFI_SUCCESS) {
 348         DEBUG ((DEBUG_ERROR, "!!!ERROR: NotifyPhaseApi() [Phase: %08X] - Failed - [Status: 0x%08X]\n", NotificationValue, Status));
 349       }
 350     } while (Status != EFI_SUCCESS);
 351   }
 352
 353   //
 354   // Control goes back to the PEI Core and it dispatches further PEIMs.
 355   // DXEIPL is the final one to transfer control back to the boot loader.
 356   //
 357 }
 358
 359 /**
 360   This function transfer control back to BootLoader after FspSiliconInit.
 361
 362 **/
 363 VOID
 364 EFIAPI
 365 FspSiliconInitDone (
 366   VOID
 367   )
 368 {
 369   FspSiliconInitDone2 (EFI_SUCCESS);
 370 }
 371
 372 /**
 373   This function returns control to BootLoader after MemoryInitApi.
 374
 375   @param[in,out] HobListPtr The address of HobList pointer.
 376 **/
 377 VOID
 378 EFIAPI
 379 FspMemoryInitDone (
 380   IN OUT VOID   **HobListPtr
 381   )
 382 {
 383   FspMemoryInitDone2 (EFI_SUCCESS, HobListPtr);
 384 }
 385
 386 /**
 387   This function returns control to BootLoader after TempRamExitApi.
 388
 389 **/
 390 VOID
 391 EFIAPI
 392 FspTempRamExitDone (
 393   VOID
 394   )
 395 {
 396   FspTempRamExitDone2 (EFI_SUCCESS);
 397 }