/** Main entry point to last PEIM. This function finds DXE Core in the firmware volume and transfer the control to DXE core. @param[in] This Entry point for DXE IPL PPI. @param[in] PeiServices General purpose services available to every PEIM. @param[in] HobList Address to the Pei HOB list. @return EFI_SUCCESS DXE core was successfully loaded. @return EFI_OUT_OF_RESOURCES There are not enough resources to load DXE core. **/ EFI_STATUS EFIAPI DxeLoadCore ( IN CONST EFI_DXE_IPL_PPI *This, IN EFI_PEI_SERVICES **PeiServices, IN EFI_PEI_HOB_POINTERS HobList ) { EFI_STATUS Status; DEBUG ((DEBUG_INFO | DEBUG_INIT, "FSP HOB is located at 0x%08X\n", HobList)); // // End of PEI phase signal // Status = PeiServicesInstallPpi (&gEndOfPeiSignalPpi); ASSERT_EFI_ERROR (Status); // // Give control back to BootLoader after FspInit // DEBUG ((DEBUG_INFO | DEBUG_INIT, "FSP is waiting for NOTIFY\n")); FspInitDone (); // // BootLoader called FSP again through NotifyPhase // FspWaitForNotify (); // // Give control back to the boot loader framework caller // DEBUG ((DEBUG_INFO | DEBUG_INIT, "============= PEIM FSP is Completed =============\n\n")); SetFspApiReturnStatus(EFI_SUCCESS); SetFspMeasurePoint (FSP_PERF_ID_API_NOTIFY_RDYBOOT_EXIT); Pei2LoaderSwitchStack(); // // Should not come here // while (TRUE) { DEBUG ((DEBUG_ERROR, "No FSP API should be called after FSP is DONE!\n")); SetFspApiReturnStatus(EFI_UNSUPPORTED); Pei2LoaderSwitchStack(); } return EFI_SUCCESS; }
/** This function handle NotifyPhase API call from the BootLoader. It gives control back to the BootLoader after it is handled. If the Notification code is a ReadyToBoot event, this function will return and FSP continues the remaining execution until it reaches the DxeIpl. **/ VOID FspWaitForNotify ( VOID ) { EFI_STATUS Status; UINT32 NotificationValue; UINT32 NotificationCount; UINT8 Count; NotificationCount = 0; while (NotificationCount < sizeof(mFspNotifySequence) / sizeof(UINT32)) { Count = (UINT8)((NotificationCount << 1) & 0x07); SetFspMeasurePoint (FSP_PERF_ID_API_NOTIFY_POSTPCI_ENTRY + Count); NotificationValue = ((NOTIFY_PHASE_PARAMS *)(UINTN)GetFspApiParameter ())->Phase; DEBUG ((DEBUG_INFO, "FSP Got Notification. Notification Value : 0x%08X\n", NotificationValue)); if (mFspNotifySequence[NotificationCount] != NotificationValue) { // // Notify code does not follow the predefined order // DEBUG ((DEBUG_INFO, "Unsupported FSP Notification Value\n")); SetFspApiReturnStatus(EFI_UNSUPPORTED); } else { // // Process Notification and Give control back to the boot loader framework caller // Status = FspNotificationHandler (NotificationValue); DEBUG ((DEBUG_INFO, "FSP Notification Handler Returns : 0x%08X\n", Status)); SetFspApiReturnStatus(Status); if (!EFI_ERROR(Status)) { NotificationCount++; SetFspApiReturnStatus(EFI_SUCCESS); if (NotificationValue == EnumInitPhaseReadyToBoot) { break; } } } SetFspMeasurePoint (FSP_PERF_ID_API_NOTIFY_POSTPCI_EXIT + Count); Pei2LoaderSwitchStack(); } // // Control goes back to the PEI Core and it dispatches further PEIMs. // DXEIPL is the final one to transfer control back to the boot loader. // }
/** This function transfer control to the ContinuationFunc passed in by the BootLoader. **/ VOID EFIAPI FspInitDone ( VOID ) { FSP_INIT_PARAMS *FspInitParams; if (GetFspApiCallingMode() == 0) { // // FspInit API is used, so jump into the ContinuationFunc // FspInitParams = (FSP_INIT_PARAMS *)GetFspApiParameter (); // // Modify the parameters for ContinuationFunc // SetFspContinuationFuncParameter(EFI_SUCCESS, 0); SetFspContinuationFuncParameter((UINT32)GetHobList(), 1); // // Modify the return address to ContinuationFunc // SetFspApiReturnAddress((UINT32)FspInitParams->ContinuationFunc); // // Give control back to the boot loader framework caller after FspInit is done // It is done throught the continuation function // SetFspMeasurePoint (FSP_PERF_ID_API_FSPINIT_EXIT); } else { // // FspMemoryInit API is used, so return directly // // // This is the end of the FspSiliconInit API // Give control back to the boot loader // DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspSiliconInitApi() - End\n")); SetFspApiReturnStatus (EFI_SUCCESS); } Pei2LoaderSwitchStack(); }
/** This function waits for FSP notify. @param This Entry point for DXE IPL PPI. @param PeiServices General purpose services available to every PEIM. @param HobList Address to the Pei HOB list. @return EFI_SUCCESS This function never returns. **/ EFI_STATUS EFIAPI WaitForNotify ( IN CONST EFI_DXE_IPL_PPI *This, IN EFI_PEI_SERVICES **PeiServices, IN EFI_PEI_HOB_POINTERS HobList ) { EFI_STATUS Status; DEBUG ((DEBUG_INFO | DEBUG_INIT, "FSP HOB is located at 0x%08X\n", HobList)); // // End of PEI phase signal // Status = PeiServicesInstallPpi (&gEndOfPeiSignalPpi); ASSERT_EFI_ERROR (Status); // // Give control back to BootLoader after FspSiliconInit // DEBUG ((DEBUG_INFO | DEBUG_INIT, "FSP is waiting for NOTIFY\n")); FspSiliconInitDone2 (EFI_SUCCESS); // // BootLoader called FSP again through NotifyPhase // FspWaitForNotify (); if (GetFspGlobalDataPointer ()->FspMode == FSP_IN_API_MODE) { // // Should not come here // while (TRUE) { DEBUG ((DEBUG_ERROR, "No FSP API should be called after FSP is DONE!\n")); SetFspApiReturnStatus (EFI_UNSUPPORTED); Pei2LoaderSwitchStack (); } } return EFI_SUCCESS; }
/** This function returns control to BootLoader after TempRamExitApi. @param[in] Status return status for the TempRamExitApi. **/ VOID EFIAPI FspTempRamExitDone2 ( IN EFI_STATUS Status ) { // // Convert to FSP EAS defined API return codes // switch (Status) { case EFI_SUCCESS: case EFI_INVALID_PARAMETER: case EFI_UNSUPPORTED: case EFI_DEVICE_ERROR: break; default: DEBUG ((DEBUG_INFO | DEBUG_INIT, "TempRamExitApi() Invalid Error - [Status: 0x%08X]\n", Status)); Status = EFI_DEVICE_ERROR; // Force to known error. break; } // // This is the end of the TempRamExit API // Give control back to the boot loader // DEBUG ((DEBUG_INFO | DEBUG_INIT, "TempRamExitApi() - [Status: 0x%08X] - End\n", Status)); SetFspMeasurePoint (FSP_PERF_ID_API_TEMP_RAM_EXIT_EXIT); PERF_END_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_TEMP_RAM_EXIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_TEMP_RAM_EXIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); do { SetFspApiReturnStatus (Status); Pei2LoaderSwitchStack (); if (Status != EFI_SUCCESS) { DEBUG ((DEBUG_ERROR, "!!!ERROR: TempRamExitApi() - [Status: 0x%08X] - Error encountered during previous API and cannot proceed further\n", Status)); } } while (Status != EFI_SUCCESS); SetPhaseStatusCode (FSP_STATUS_CODE_SILICON_INIT); SetFspMeasurePoint (FSP_PERF_ID_API_FSP_SILICON_INIT_ENTRY); PERF_START_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_SILICON_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_SILICON_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); DEBUG ((DEBUG_INFO | DEBUG_INIT, "SiliconInitApi() - Begin\n")); }
/** This function updates the return status of the FSP API with requested reset type and returns to Boot Loader. @param[in] FspResetType Reset type that needs to returned as API return status **/ VOID EFIAPI FspApiReturnStatusReset ( IN UINT32 FspResetType ) { volatile BOOLEAN LoopUntilReset; LoopUntilReset = TRUE; DEBUG ((DEBUG_INFO, "FSP returning control to Bootloader with reset required return status %x\n",FspResetType)); /// /// Below code is not an infinite loop.The control will go back to API calling function in BootLoader each time BootLoader /// calls the FSP API without honoring the reset request by FSP /// do { SetFspApiReturnStatus ((EFI_STATUS)FspResetType); Pei2LoaderSwitchStack (); DEBUG ((DEBUG_ERROR, "!!!ERROR: FSP has requested BootLoader for reset. But BootLoader has not honored the reset\n")); DEBUG ((DEBUG_ERROR, "!!!ERROR: Please add support in BootLoader to honor the reset request from FSP\n")); } while (LoopUntilReset); }
/** This function returns control to BootLoader after TempRamExitApi. **/ VOID EFIAPI FspTempRamExitDone ( VOID ) { // // This is the end of the TempRamExit API // Give control back to the boot loader // SetFspMeasurePoint (FSP_PERF_ID_API_TEMP_RAM_EXIT_EXIT); DEBUG ((DEBUG_INFO | DEBUG_INIT, "TempRamExitApi() - End\n")); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_TEMP_RAM_EXIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); SetFspApiReturnStatus (EFI_SUCCESS); Pei2LoaderSwitchStack (); SetPhaseStatusCode (FSP_STATUS_CODE_SILICON_INIT); SetFspMeasurePoint (FSP_PERF_ID_API_FSP_SILICON_INIT_ENTRY); DEBUG ((DEBUG_INFO | DEBUG_INIT, "SiliconInitApi() - Begin\n")); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_SILICON_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); }
/** This function returns control to BootLoader after MemoryInitApi. @param[in,out] HobListPtr The address of HobList pointer. **/ VOID EFIAPI FspMemoryInitDone ( IN OUT VOID **HobListPtr ) { // // Calling use FspMemoryInit API // Update HOB and return the control directly // if (HobListPtr != NULL) { *HobListPtr = (VOID *) GetHobList (); } // // This is the end of the FspMemoryInit API // Give control back to the boot loader // SetFspMeasurePoint (FSP_PERF_ID_API_FSP_MEMORY_INIT_EXIT); DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspMemoryInitApi() - End\n")); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_MEMORY_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); SetFspApiReturnStatus (EFI_SUCCESS); Pei2LoaderSwitchStack (); // // The TempRamExitApi is called // if (GetFspApiCallingIndex () == TempRamExitApiIndex) { SetPhaseStatusCode (FSP_STATUS_CODE_TEMP_RAM_EXIT); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_TEMP_RAM_EXIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); SetFspMeasurePoint (FSP_PERF_ID_API_TEMP_RAM_EXIT_ENTRY); DEBUG ((DEBUG_INFO | DEBUG_INIT, "TempRamExitApi() - Begin\n")); } else { SetFspMeasurePoint (FSP_PERF_ID_API_FSP_SILICON_INIT_ENTRY); DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspSiliconInitApi() - Begin\n")); SetPhaseStatusCode (FSP_STATUS_CODE_SILICON_INIT); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_SILICON_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); } }
/** This function transfer control back to BootLoader after FspSiliconInit. **/ VOID EFIAPI FspSiliconInitDone ( VOID ) { // // This is the end of the FspSiliconInit API // Give control back to the boot loader // SetFspMeasurePoint (FSP_PERF_ID_API_FSP_SILICON_INIT_EXIT); DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspSiliconInitApi() - End\n")); PERF_END_EX (&gFspPerformanceDataGuid, "EventRec", NULL, 0, 0x907F); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); SetFspApiReturnStatus (EFI_SUCCESS); Pei2LoaderSwitchStack(); PERF_START_EX (&gFspPerformanceDataGuid, "EventRec", NULL, 0, 0x6000); }
/** This function handle NotifyPhase API call from the BootLoader. It gives control back to the BootLoader after it is handled. If the Notification code is a ReadyToBoot event, this function will return and FSP continues the remaining execution until it reaches the DxeIpl. **/ VOID FspWaitForNotify ( VOID ) { EFI_STATUS Status; UINT32 NotificationValue; UINT32 NotificationCount; UINT8 Count; NotificationCount = 0; while (NotificationCount < sizeof(mFspNotifySequence) / sizeof(UINT32)) { Count = (UINT8)((NotificationCount << 1) & 0x07); SetFspMeasurePoint (FSP_PERF_ID_API_NOTIFY_POST_PCI_ENTRY + Count); if (NotificationCount == 0) { SetPhaseStatusCode (FSP_STATUS_CODE_POST_PCIE_ENUM_NOTIFICATION); PERF_START_EX (&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_POST_PCIE_ENUM_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_POST_PCIE_ENUM_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); } else if (NotificationCount == 1) { SetPhaseStatusCode (FSP_STATUS_CODE_READY_TO_BOOT_NOTIFICATION); PERF_START_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_READY_TO_BOOT_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_READY_TO_BOOT_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); } else if (NotificationCount == 2) { SetPhaseStatusCode (FSP_STATUS_CODE_END_OF_FIRMWARE_NOTIFICATION); PERF_START_EX (&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_END_OF_FIRMWARE_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_END_OF_FIRMWARE_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); } NotificationValue = ((NOTIFY_PHASE_PARAMS *)(UINTN)GetFspApiParameter ())->Phase; DEBUG ((DEBUG_INFO | DEBUG_INIT, "NotifyPhaseApi() - Begin [Phase: %08X]\n", NotificationValue)); if (mFspNotifySequence[NotificationCount] != NotificationValue) { // // Notify code does not follow the predefined order // DEBUG ((DEBUG_INFO, "Unsupported FSP Notification Value\n")); Status = EFI_UNSUPPORTED; } else { // // Process Notification and Give control back to the boot loader framework caller // Status = FspNotificationHandler (NotificationValue); if (!EFI_ERROR(Status)) { NotificationCount++; } } DEBUG ((DEBUG_INFO | DEBUG_INIT, "NotifyPhaseApi() - End [Status: 0x%08X]\n", Status)); SetFspMeasurePoint (FSP_PERF_ID_API_NOTIFY_POST_PCI_EXIT + Count); if ((NotificationCount - 1) == 0) { PERF_END_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_POST_PCIE_ENUM_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_POST_PCIE_ENUM_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); } else if ((NotificationCount - 1) == 1) { PERF_END_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_READY_TO_BOOT_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_READY_TO_BOOT_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); } else if ((NotificationCount - 1) == 2) { PERF_END_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_END_OF_FIRMWARE_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_END_OF_FIRMWARE_NOTIFICATION | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); } do { SetFspApiReturnStatus(Status); Pei2LoaderSwitchStack(); if (Status != EFI_SUCCESS) { DEBUG ((DEBUG_ERROR, "!!!ERROR: NotifyPhaseApi() [Phase: %08X] - Failed - [Status: 0x%08X]\n", NotificationValue, Status)); } } while (Status != EFI_SUCCESS); } // // Control goes back to the PEI Core and it dispatches further PEIMs. // DXEIPL is the final one to transfer control back to the boot loader. // }
/** This function returns control to BootLoader after MemoryInitApi. @param[in] Status return status for the MemoryInitApi. @param[in,out] HobListPtr The address of HobList pointer, if NULL, will get value from GetFspApiParameter2 () **/ VOID EFIAPI FspMemoryInitDone2 ( IN EFI_STATUS Status, IN OUT VOID **HobListPtr ) { FSP_GLOBAL_DATA *FspData; // // Calling use FspMemoryInit API // Update HOB and return the control directly // if (HobListPtr == NULL) { HobListPtr = (VOID **)GetFspApiParameter2 (); } if (HobListPtr != NULL) { *HobListPtr = (VOID *) GetHobList (); } // // Convert to FSP EAS defined API return codes // switch (Status) { case EFI_SUCCESS: case EFI_INVALID_PARAMETER: case EFI_UNSUPPORTED: case EFI_DEVICE_ERROR: case EFI_OUT_OF_RESOURCES: break; default: DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspMemoryInitApi() Invalid Error [Status: 0x%08X]\n", Status)); Status = EFI_DEVICE_ERROR; // Force to known error. break; } // // This is the end of the FspMemoryInit API // Give control back to the boot loader // DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspMemoryInitApi() - [Status: 0x%08X] - End\n", Status)); SetFspMeasurePoint (FSP_PERF_ID_API_FSP_MEMORY_INIT_EXIT); FspData = GetFspGlobalDataPointer (); 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); 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); 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); PERF_END_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_MEMORY_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_MEMORY_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_EXIT); do { SetFspApiReturnStatus (Status); Pei2LoaderSwitchStack (); if (Status != EFI_SUCCESS) { DEBUG ((DEBUG_ERROR, "!!!ERROR: FspMemoryInitApi() - [Status: 0x%08X] - Error encountered during previous API and cannot proceed further\n", Status)); } } while (Status != EFI_SUCCESS); // // The TempRamExitApi is called // if (GetFspApiCallingIndex () == TempRamExitApiIndex) { SetPhaseStatusCode (FSP_STATUS_CODE_TEMP_RAM_EXIT); SetFspMeasurePoint (FSP_PERF_ID_API_TEMP_RAM_EXIT_ENTRY); PERF_START_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_TEMP_RAM_EXIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_TEMP_RAM_EXIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); DEBUG ((DEBUG_INFO | DEBUG_INIT, "TempRamExitApi() - Begin\n")); } else { SetPhaseStatusCode (FSP_STATUS_CODE_SILICON_INIT); SetFspMeasurePoint (FSP_PERF_ID_API_FSP_SILICON_INIT_ENTRY); PERF_START_EX(&gFspPerformanceDataGuid, "EventRec", NULL, 0, FSP_STATUS_CODE_SILICON_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); REPORT_STATUS_CODE (EFI_PROGRESS_CODE, FSP_STATUS_CODE_SILICON_INIT | FSP_STATUS_CODE_COMMON_CODE | FSP_STATUS_CODE_API_ENTRY); DEBUG ((DEBUG_INFO | DEBUG_INIT, "FspSiliconInitApi() - Begin\n")); } }