自学教程：C++ GetFspGlobalDataPointer函数代码示例

EFIAPIGetFspInfoHeader (  VOID  ){  return  GetFspGlobalDataPointer()->FspInfoHeader;}

/**  This function gets FSP Phase StatusCode.  @retval StatusCode**/UINT32EFIAPIGetPhaseStatusCode (  VOID  ){  return  GetFspGlobalDataPointer()->StatusCode;}

/**  This function sets the FSP info header pointer.  @param[in] FspInfoHeader   FSP info header pointer**/VOIDEFIAPISetFspInfoHeader (  FSP_INFO_HEADER *FspInfoHeader  ){  GetFspGlobalDataPointer()->FspInfoHeader = FspInfoHeader;}

/**  This function gets FSP API calling mode.  @retval API calling mode**/UINT8EFIAPIGetFspApiCallingMode (  VOID  ){  return  GetFspGlobalDataPointer()->ApiMode;}

/**  This function gets FSP API calling index.  @retval API calling index**/UINT8EFIAPIGetFspApiCallingIndex (  VOID  ){  return  GetFspGlobalDataPointer()->ApiIdx;}

EFIAPIGetFspEntryStack (  VOID  ){  FSP_GLOBAL_DATA  *FspData;  FspData  = GetFspGlobalDataPointer ();  return (VOID*)(FspData->CoreStack + CONTEXT_STACK_OFFSET(ApiParam[0]));}

EFIAPIGetFspUpdDataPointer (  VOID  ){  FSP_GLOBAL_DATA  *FspData;  FspData  = GetFspGlobalDataPointer ();  return FspData->UpdDataPtr;}

EFIAPIGetFspPlatformDataPointer (  VOID  ){  FSP_GLOBAL_DATA  *FspData;  FspData  = GetFspGlobalDataPointer ();  return FspData->PlatformData.DataPtr;}

EFIAPIGetFspSiliconInitUpdDataPointer (  VOID  ){  FSP_GLOBAL_DATA  *FspData;  FspData  = GetFspGlobalDataPointer ();  return FspData->SiliconInitUpdPtr;}

EFIAPIGetFspInfoHeaderFromApiContext (  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.**/UINT32EFIAPIGetFspApiParameter (  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**/VOIDEFIAPISetFspApiCallingMode (  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.**/VOIDEFIAPISetFspPlatformDataPointer (  IN VOID   *PlatformData  ){  FSP_GLOBAL_DATA  *FspData;  FspData  = GetFspGlobalDataPointer ();  FspData->PlatformData.DataPtr = PlatformData;}

/**  This function sets FSP Phase StatusCode.  @param[in] Mode     Phase StatusCode**/VOIDEFIAPISetPhaseStatusCode (  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.**/VOIDEFIAPISetFspApiReturnStatus (  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.**/VOIDEFIAPISetFspApiParameter (  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**/VOIDEFIAPISetFspApiCallingIndex (  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.**/VOIDEFIAPISetFspContinuationFuncParameter (  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.**/UINT32SwapStack (  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.**/UINT32EFIAPIGetFspCarSize (  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.**/VOIDEFIAPISetFspUpdDataPointer (  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.**/VOIDEFIAPISetFspMemoryInitUpdDataPointer (  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.**/VOIDEFIAPISetFspSiliconInitUpdDataPointer (  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_STATUSEFIAPIWaitForNotify (  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.**/UINT64EFIAPISetFspMeasurePoint (  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**/VOIDEFIAPIFspApiReturnStatusReset (  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_STATUSFspNotifyPhasePeimEntryPoint (  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.**/VOIDEFIAPISetFspCoreStackPointer (  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 ()**/VOIDEFIAPIFspMemoryInitDone2 (  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"));  }}