IntelFsp2WrapperPkg/Library/BaseFspWrapperApiLib/FspWrapperApiLib.c

   1 /** @file
   2   Provide FSP API related function.
   3
   4   Copyright (c) 2014 - 2022, Intel Corporation. All rights reserved.<BR>
   5   SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9 #include <PiPei.h>
  10
  11 #include <Library/FspWrapperApiLib.h>
  12 #include <Library/BaseLib.h>
  13 #include <Library/BaseMemoryLib.h>
  14
  15 /**
  16   Wrapper for a thunk to transition from long mode to compatibility mode to execute 32-bit code and then transit back to
  17   long mode.
  18
  19   @param[in] Function     The 32bit code entry to be executed.
  20   @param[in] Param1       The first parameter to pass to 32bit code.
  21   @param[in] Param2       The second parameter to pass to 32bit code.
  22
  23   @return EFI_STATUS.
  24 **/
  25 EFI_STATUS
  26 Execute32BitCode (
  27   IN UINT64  Function,
  28   IN UINT64  Param1,
  29   IN UINT64  Param2
  30   );
  31
  32 /**
  33   Wrapper to execute 64-bit code directly from long mode.
  34
  35   @param[in] Function     The 64bit code entry to be executed.
  36   @param[in] Param1       The first parameter to pass to 64bit code.
  37   @param[in] Param2       The second parameter to pass to 64bit code.
  38
  39   @return EFI_STATUS.
  40 **/
  41 EFI_STATUS
  42 Execute64BitCode (
  43   IN UINT64  Function,
  44   IN UINT64  Param1,
  45   IN UINT64  Param2
  46   );
  47
  48 /**
  49   Find FSP header pointer.
  50
  51   @param[in] FlashFvFspBase Flash address of FSP FV.
  52
  53   @return FSP header pointer.
  54 **/
  55 FSP_INFO_HEADER *
  56 EFIAPI
  57 FspFindFspHeader (
  58   IN EFI_PHYSICAL_ADDRESS  FlashFvFspBase
  59   )
  60 {
  61   UINT8  *CheckPointer;
  62
  63   CheckPointer = (UINT8 *)(UINTN)FlashFvFspBase;
  64
  65   if (((EFI_FIRMWARE_VOLUME_HEADER *)CheckPointer)->Signature != EFI_FVH_SIGNATURE) {
  66     return NULL;
  67   }
  68
  69   if (((EFI_FIRMWARE_VOLUME_HEADER *)CheckPointer)->ExtHeaderOffset != 0) {
  70     CheckPointer = CheckPointer + ((EFI_FIRMWARE_VOLUME_HEADER *)CheckPointer)->ExtHeaderOffset;
  71     CheckPointer = CheckPointer + ((EFI_FIRMWARE_VOLUME_EXT_HEADER *)CheckPointer)->ExtHeaderSize;
  72     CheckPointer = (UINT8 *)ALIGN_POINTER (CheckPointer, 8);
  73   } else {
  74     CheckPointer = CheckPointer + ((EFI_FIRMWARE_VOLUME_HEADER *)CheckPointer)->HeaderLength;
  75   }
  76
  77   CheckPointer = CheckPointer + sizeof (EFI_FFS_FILE_HEADER);
  78
  79   if (((EFI_RAW_SECTION *)CheckPointer)->Type != EFI_SECTION_RAW) {
  80     return NULL;
  81   }
  82
  83   CheckPointer = CheckPointer + sizeof (EFI_RAW_SECTION);
  84
  85   return (FSP_INFO_HEADER *)CheckPointer;
  86 }
  87
  88 /**
  89   Call FSP API - FspNotifyPhase.
  90
  91   @param[in] NotifyPhaseParams Address pointer to the NOTIFY_PHASE_PARAMS structure.
  92
  93   @return EFI status returned by FspNotifyPhase API.
  94 **/
  95 EFI_STATUS
  96 EFIAPI
  97 CallFspNotifyPhase (
  98   IN NOTIFY_PHASE_PARAMS  *NotifyPhaseParams
  99   )
 100 {
 101   FSP_INFO_HEADER   *FspHeader;
 102   FSP_NOTIFY_PHASE  NotifyPhaseApi;
 103   EFI_STATUS        Status;
 104   BOOLEAN           InterruptState;
 105
 106   FspHeader = (FSP_INFO_HEADER *)FspFindFspHeader (PcdGet32 (PcdFspsBaseAddress));
 107   if (FspHeader == NULL) {
 108     return EFI_DEVICE_ERROR;
 109   }
 110
 111   NotifyPhaseApi = (FSP_NOTIFY_PHASE)((UINTN)FspHeader->ImageBase + FspHeader->NotifyPhaseEntryOffset);
 112   InterruptState = SaveAndDisableInterrupts ();
 113   if ((FspHeader->ImageAttribute & IMAGE_ATTRIBUTE_64BIT_MODE_SUPPORT) == FSP_IA32) {
 114     Status = Execute32BitCode ((UINTN)NotifyPhaseApi, (UINTN)NotifyPhaseParams, (UINTN)NULL);
 115   } else {
 116     Status = Execute64BitCode ((UINTN)NotifyPhaseApi, (UINTN)NotifyPhaseParams, (UINTN)NULL);
 117   }
 118
 119   SetInterruptState (InterruptState);
 120
 121   return Status;
 122 }
 123
 124 /**
 125   Call FSP API - FspMemoryInit.
 126
 127   @param[in]  FspmUpdDataPtr Address pointer to the FSP_MEMORY_INIT_PARAMS structure.
 128   @param[out] HobListPtr     Address of the HobList pointer.
 129
 130   @return EFI status returned by FspMemoryInit API.
 131 **/
 132 EFI_STATUS
 133 EFIAPI
 134 CallFspMemoryInit (
 135   IN VOID   *FspmUpdDataPtr,
 136   OUT VOID  **HobListPtr
 137   )
 138 {
 139   FSP_INFO_HEADER  *FspHeader;
 140   FSP_MEMORY_INIT  FspMemoryInitApi;
 141   EFI_STATUS       Status;
 142   BOOLEAN          InterruptState;
 143
 144   FspHeader = (FSP_INFO_HEADER *)FspFindFspHeader (PcdGet32 (PcdFspmBaseAddress));
 145   if (FspHeader == NULL) {
 146     return EFI_DEVICE_ERROR;
 147   }
 148
 149   FspMemoryInitApi = (FSP_MEMORY_INIT)((UINTN)FspHeader->ImageBase + FspHeader->FspMemoryInitEntryOffset);
 150   InterruptState   = SaveAndDisableInterrupts ();
 151   if ((FspHeader->ImageAttribute & IMAGE_ATTRIBUTE_64BIT_MODE_SUPPORT) == FSP_IA32) {
 152     Status = Execute32BitCode ((UINTN)FspMemoryInitApi, (UINTN)FspmUpdDataPtr, (UINTN)HobListPtr);
 153   } else {
 154     Status = Execute64BitCode ((UINTN)FspMemoryInitApi, (UINTN)FspmUpdDataPtr, (UINTN)HobListPtr);
 155   }
 156
 157   SetInterruptState (InterruptState);
 158
 159   return Status;
 160 }
 161
 162 /**
 163   Call FSP API - TempRamExit.
 164
 165   @param[in] TempRamExitParam    Address pointer to the TempRamExit parameters structure.
 166
 167   @return EFI status returned by TempRamExit API.
 168 **/
 169 EFI_STATUS
 170 EFIAPI
 171 CallTempRamExit (
 172   IN VOID  *TempRamExitParam
 173   )
 174 {
 175   FSP_INFO_HEADER    *FspHeader;
 176   FSP_TEMP_RAM_EXIT  TempRamExitApi;
 177   EFI_STATUS         Status;
 178   BOOLEAN            InterruptState;
 179
 180   FspHeader = (FSP_INFO_HEADER *)FspFindFspHeader (PcdGet32 (PcdFspmBaseAddress));
 181   if (FspHeader == NULL) {
 182     return EFI_DEVICE_ERROR;
 183   }
 184
 185   TempRamExitApi = (FSP_TEMP_RAM_EXIT)((UINTN)FspHeader->ImageBase + FspHeader->TempRamExitEntryOffset);
 186   InterruptState = SaveAndDisableInterrupts ();
 187   if ((FspHeader->ImageAttribute & IMAGE_ATTRIBUTE_64BIT_MODE_SUPPORT) == FSP_IA32) {
 188     Status = Execute32BitCode ((UINTN)TempRamExitApi, (UINTN)TempRamExitParam, (UINTN)NULL);
 189   } else {
 190     Status = Execute64BitCode ((UINTN)TempRamExitApi, (UINTN)TempRamExitParam, (UINTN)NULL);
 191   }
 192
 193   SetInterruptState (InterruptState);
 194
 195   return Status;
 196 }
 197
 198 /**
 199   Call FSP API - FspSiliconInit.
 200
 201   @param[in] FspsUpdDataPtr Address pointer to the Silicon Init parameters structure.
 202
 203   @return EFI status returned by FspSiliconInit API.
 204 **/
 205 EFI_STATUS
 206 EFIAPI
 207 CallFspSiliconInit (
 208   IN VOID  *FspsUpdDataPtr
 209   )
 210 {
 211   FSP_INFO_HEADER   *FspHeader;
 212   FSP_SILICON_INIT  FspSiliconInitApi;
 213   EFI_STATUS        Status;
 214   BOOLEAN           InterruptState;
 215
 216   FspHeader = (FSP_INFO_HEADER *)FspFindFspHeader (PcdGet32 (PcdFspsBaseAddress));
 217   if (FspHeader == NULL) {
 218     return EFI_DEVICE_ERROR;
 219   }
 220
 221   FspSiliconInitApi = (FSP_SILICON_INIT)((UINTN)FspHeader->ImageBase + FspHeader->FspSiliconInitEntryOffset);
 222   InterruptState    = SaveAndDisableInterrupts ();
 223   if ((FspHeader->ImageAttribute & IMAGE_ATTRIBUTE_64BIT_MODE_SUPPORT) == FSP_IA32) {
 224     Status = Execute32BitCode ((UINTN)FspSiliconInitApi, (UINTN)FspsUpdDataPtr, (UINTN)NULL);
 225   } else {
 226     Status = Execute64BitCode ((UINTN)FspSiliconInitApi, (UINTN)FspsUpdDataPtr, (UINTN)NULL);
 227   }
 228
 229   SetInterruptState (InterruptState);
 230
 231   return Status;
 232 }