EFIAPI GetFspInfoHeader ( VOID ) { return GetFspGlobalDataPointer()->FspInfoHeader; }
/** This function gets FSP Phase StatusCode. @retval StatusCode **/ UINT32 EFIAPI GetPhaseStatusCode ( VOID ) { return GetFspGlobalDataPointer()->StatusCode; }
/** This function sets the FSP info header pointer. @param[in] FspInfoHeader FSP info header pointer **/ VOID EFIAPI SetFspInfoHeader ( FSP_INFO_HEADER *FspInfoHeader ) { GetFspGlobalDataPointer()->FspInfoHeader = FspInfoHeader; }
/** This function gets FSP API calling mode. @retval API calling mode **/ UINT8 EFIAPI GetFspApiCallingMode ( VOID ) { return GetFspGlobalDataPointer()->ApiMode; }
/** This function gets FSP API calling index. @retval API calling index **/ UINT8 EFIAPI GetFspApiCallingIndex ( VOID ) { return GetFspGlobalDataPointer()->ApiIdx; }
EFIAPI GetFspEntryStack ( VOID ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); return (VOID*)(FspData->CoreStack + CONTEXT_STACK_OFFSET(ApiParam[0])); }
EFIAPI GetFspUpdDataPointer ( VOID ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); return FspData->UpdDataPtr; }
EFIAPI GetFspPlatformDataPointer ( VOID ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); return FspData->PlatformData.DataPtr; }
EFIAPI GetFspSiliconInitUpdDataPointer ( VOID ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); return FspData->SiliconInitUpdPtr; }
EFIAPI GetFspInfoHeaderFromApiContext ( VOID ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); return (FSP_INFO_HEADER *)(*(UINT32 *)(UINTN)(FspData->CoreStack + CONTEXT_STACK_OFFSET(FspInfoHeader))); }
/** This function gets back the FSP API first parameter passed by the bootloader. @retval ApiParameter FSP API first parameter passed by the bootloader. **/ UINT32 EFIAPI GetFspApiParameter ( VOID ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); return *(UINT32 *)(UINTN)(FspData->CoreStack + CONTEXT_STACK_OFFSET(ApiParam[0])); }
/** This function sets FSP API calling mode. @param[in] Mode API calling mode **/ VOID EFIAPI SetFspApiCallingMode ( UINT8 Mode ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); FspData->ApiMode = Mode; }
/** This function sets the platform specific data pointer. @param[in] PlatformData FSP platform specific data pointer. **/ VOID EFIAPI SetFspPlatformDataPointer ( IN VOID *PlatformData ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); FspData->PlatformData.DataPtr = PlatformData; }
/** This function sets FSP Phase StatusCode. @param[in] Mode Phase StatusCode **/ VOID EFIAPI SetPhaseStatusCode ( UINT32 StatusCode ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); FspData->StatusCode = StatusCode; }
/** This function set the API status code returned to the BootLoader. @param[in] ReturnStatus Status code to return. **/ VOID EFIAPI SetFspApiReturnStatus ( IN UINT32 ReturnStatus ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); *(UINT32 *)(UINTN)(FspData->CoreStack + CONTEXT_STACK_OFFSET(Eax)) = ReturnStatus; }
/** This function sets the FSP API parameter in the stack. @param[in] Value New parameter value. **/ VOID EFIAPI SetFspApiParameter ( IN UINT32 Value ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); *(UINT32 *)(UINTN)(FspData->CoreStack + CONTEXT_STACK_OFFSET(ApiParam)) = Value; }
/** This function sets FSP API calling mode. @param[in] Index API calling index **/ VOID EFIAPI SetFspApiCallingIndex ( UINT8 Index ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); FspData->ApiIdx = Index; }
/** This function sets the FSP continuation function parameters in the stack. @param[in] Value New parameter value to set. @param[in] Index Parameter index. **/ VOID EFIAPI SetFspContinuationFuncParameter ( IN UINT32 Value, IN UINT32 Index ) { FSP_GLOBAL_DATA *FspData; FspData = GetFspGlobalDataPointer (); *(UINT32 *)(UINTN)(FspData->CoreStack + CONTEXT_STACK_OFFSET(ApiParam) + (Index + 1) * sizeof(UINT32)) = Value; }
/** Switch the current stack to the previous saved stack. @param[in] NewStack The new stack to be switched. @return OldStack After switching to the saved stack, this value will be saved in eax before returning. **/ UINT32 SwapStack ( IN UINT32 NewStack ) { FSP_GLOBAL_DATA *FspData; UINT32 OldStack; FspData = GetFspGlobalDataPointer (); OldStack = FspData->CoreStack; FspData->CoreStack = NewStack; return OldStack; }
/** This function gets FSP CAR size. **/ UINT32 EFIAPI GetFspCarSize ( VOID ) { FSP_GLOBAL_DATA *FspData; UINT32 CarSize; FspData = GetFspGlobalDataPointer (); CarSize = FspData->PlatformData.CarSize; if (FspData->PlatformData.CarBase == 0) { CarSize = PcdGet32(PcdTemporaryRamSize); } return CarSize; }
/** This function sets the UPD data pointer. @param[in] UpdDataPtr UPD data pointer. **/ VOID EFIAPI SetFspUpdDataPointer ( IN VOID *UpdDataPtr ) { FSP_GLOBAL_DATA *FspData; // // Get the FSP Global Data Pointer // FspData = GetFspGlobalDataPointer (); // // Set the UPD pointer. // FspData->UpdDataPtr = UpdDataPtr; }
/** This function sets the FspMemoryInit UPD data pointer. @param[in] MemoryInitUpdPtr FspMemoryInit UPD data pointer. **/ VOID EFIAPI SetFspMemoryInitUpdDataPointer ( IN VOID *MemoryInitUpdPtr ) { FSP_GLOBAL_DATA *FspData; // // Get the FSP Global Data Pointer // FspData = GetFspGlobalDataPointer (); // // Set the FspMemoryInit UPD pointer. // FspData->MemoryInitUpdPtr = MemoryInitUpdPtr; }
/** This function sets the FspSiliconInit UPD data pointer. @param[in] SiliconInitUpdPtr FspSiliconInit UPD data pointer. **/ VOID EFIAPI SetFspSiliconInitUpdDataPointer ( IN VOID *SiliconInitUpdPtr ) { FSP_GLOBAL_DATA *FspData; // // Get the FSP Global Data Pointer // FspData = GetFspGlobalDataPointer (); // // Set the FspSiliconInit UPD data pointer. // FspData->SiliconInitUpdPtr = SiliconInitUpdPtr; }
/** 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; }
/** Set FSP measurement point timestamp. @param[in] Id Measurement point ID. @return performance timestamp. **/ UINT64 EFIAPI SetFspMeasurePoint ( IN UINT8 Id ) { FSP_GLOBAL_DATA *FspData; // // Bit [55: 0] will be the timestamp // Bit [63:56] will be the ID // FspData = GetFspGlobalDataPointer (); if (FspData->PerfIdx < sizeof(FspData->PerfData) / sizeof(FspData->PerfData[0])) { FspData->PerfData[FspData->PerfIdx] = AsmReadTsc (); ((UINT8 *)(&FspData->PerfData[FspData->PerfIdx]))[7] = Id; } return FspData->PerfData[(FspData->PerfIdx)++]; }
/** 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)); if (GetFspGlobalDataPointer ()->FspMode == FSP_IN_API_MODE) { /// /// 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); } }
/** FSP notify phase PEI module entry point @param[in] FileHandle Not used. @param[in] PeiServices General purpose services available to every PEIM. @retval EFI_SUCCESS The function completes successfully @retval EFI_OUT_OF_RESOURCES Insufficient resources to create database **/ EFI_STATUS FspNotifyPhasePeimEntryPoint ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; VOID *OldDxeIplPpi; EFI_PEI_PPI_DESCRIPTOR *OldDescriptor; DEBUG ((DEBUG_INFO | DEBUG_INIT, "The entry of FspNotificationPeim\n")); if (GetFspGlobalDataPointer ()->FspMode == FSP_IN_API_MODE) { // // Locate old DXE IPL PPI // Status = PeiServicesLocatePpi ( &gEfiDxeIplPpiGuid, 0, &OldDescriptor, &OldDxeIplPpi ); ASSERT_EFI_ERROR (Status); // // Re-install the DXE IPL PPI to wait for notify // Status = PeiServicesReInstallPpi (OldDescriptor, &mInstallDxeIplPpi); ASSERT_EFI_ERROR (Status); } else { Status = PeiServicesInstallPpi (&gFspReadyForNotifyPhasePpi); ASSERT_EFI_ERROR (Status); } return EFI_SUCCESS; }
/** This function sets the context switching stack to a new stack frame. @param[in] NewStackTop New core stack to be set. **/ VOID EFIAPI SetFspCoreStackPointer ( IN VOID *NewStackTop ) { FSP_GLOBAL_DATA *FspData; UINT32 *OldStack; UINT32 *NewStack; UINT32 StackContextLen; FspData = GetFspGlobalDataPointer (); StackContextLen = sizeof(CONTEXT_STACK) / sizeof(UINT32); // // Reserve space for the ContinuationFunc two parameters // OldStack = (UINT32 *)FspData->CoreStack; NewStack = (UINT32 *)NewStackTop - StackContextLen - 2; FspData->CoreStack = (UINT32)NewStack; while (StackContextLen-- != 0) { *NewStack++ = *OldStack++; } }
/** 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")); } }