PeiPcdLib.c

Go to the documentation of this file.

 
#include <PiPei.h>
 
#include <Ppi/Pcd.h>
#include <Ppi/PiPcd.h>
#include <Ppi/PcdInfo.h>
#include <Ppi/PiPcdInfo.h>
 
#include <Library/PeiServicesLib.h>
#include <Library/PcdLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
 
PCD_PPI  *
GetPcdPpiPointer (
  VOID
  )
{
  EFI_STATUS  Status;
  PCD_PPI     *PcdPpi;
 
  Status = PeiServicesLocatePpi (&gPcdPpiGuid, 0, NULL, (VOID **)&PcdPpi);
  ASSERT_EFI_ERROR (Status);
 
  return PcdPpi;
}
 
EFI_PEI_PCD_PPI *
GetPiPcdPpiPointer (
  VOID
  )
{
  EFI_STATUS       Status;
  EFI_PEI_PCD_PPI  *PiPcdPpi;
 
  Status = PeiServicesLocatePpi (&gEfiPeiPcdPpiGuid, 0, NULL, (VOID **)&PiPcdPpi);
  ASSERT_EFI_ERROR (Status);
 
  return PiPcdPpi;
}
 
GET_PCD_INFO_PPI *
GetPcdInfoPpiPointer (
  VOID
  )
{
  EFI_STATUS        Status;
  GET_PCD_INFO_PPI  *PcdInfoPpi;
 
  Status = PeiServicesLocatePpi (&gGetPcdInfoPpiGuid, 0, NULL, (VOID **)&PcdInfoPpi);
  ASSERT_EFI_ERROR (Status);
 
  return PcdInfoPpi;
}
 
EFI_GET_PCD_INFO_PPI *
GetPiPcdInfoPpiPointer (
  VOID
  )
{
  EFI_STATUS            Status;
  EFI_GET_PCD_INFO_PPI  *PiPcdInfoPpi;
 
  Status = PeiServicesLocatePpi (&gEfiGetPcdInfoPpiGuid, 0, NULL, (VOID **)&PiPcdInfoPpi);
  ASSERT_EFI_ERROR (Status);
 
  return PiPcdInfoPpi;
}
 
UINTN
EFIAPI
LibPcdSetSku (
  IN UINTN  SkuId
  )
{
  GetPiPcdPpiPointer ()->SetSku (SkuId);
 
  return SkuId;
}
 
UINT8
EFIAPI
LibPcdGet8 (
  IN UINTN  TokenNumber
  )
{
  return (GetPcdPpiPointer ())->Get8 (TokenNumber);
}
 
UINT16
EFIAPI
LibPcdGet16 (
  IN UINTN  TokenNumber
  )
{
  return (GetPcdPpiPointer ())->Get16 (TokenNumber);
}
 
UINT32
EFIAPI
LibPcdGet32 (
  IN UINTN  TokenNumber
  )
{
  return (GetPcdPpiPointer ())->Get32 (TokenNumber);
}
 
UINT64
EFIAPI
LibPcdGet64 (
  IN UINTN  TokenNumber
  )
{
  return (GetPcdPpiPointer ())->Get64 (TokenNumber);
}
 
VOID *
EFIAPI
LibPcdGetPtr (
  IN UINTN  TokenNumber
  )
{
  return (GetPcdPpiPointer ())->GetPtr (TokenNumber);
}
 
BOOLEAN
EFIAPI
LibPcdGetBool (
  IN UINTN  TokenNumber
  )
{
  return (GetPcdPpiPointer ())->GetBool (TokenNumber);
}
 
UINTN
EFIAPI
LibPcdGetSize (
  IN UINTN  TokenNumber
  )
{
  return (GetPcdPpiPointer ())->GetSize (TokenNumber);
}
 
UINT8
EFIAPI
LibPcdGetEx8 (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
 
  return (GetPiPcdPpiPointer ())->Get8 (Guid, TokenNumber);
}
 
UINT16
EFIAPI
LibPcdGetEx16 (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
 
  return (GetPiPcdPpiPointer ())->Get16 (Guid, TokenNumber);
}
 
UINT32
EFIAPI
LibPcdGetEx32 (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
 
  return (GetPiPcdPpiPointer ())->Get32 (Guid, TokenNumber);
}
 
UINT64
EFIAPI
LibPcdGetEx64 (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
  return (GetPiPcdPpiPointer ())->Get64 (Guid, TokenNumber);
}
 
VOID *
EFIAPI
LibPcdGetExPtr (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
 
  return (GetPiPcdPpiPointer ())->GetPtr (Guid, TokenNumber);
}
 
BOOLEAN
EFIAPI
LibPcdGetExBool (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
  return (GetPiPcdPpiPointer ())->GetBool (Guid, TokenNumber);
}
 
UINTN
EFIAPI
LibPcdGetExSize (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
  return (GetPiPcdPpiPointer ())->GetSize (Guid, TokenNumber);
}
 
RETURN_STATUS
EFIAPI
LibPcdSet8S (
  IN UINTN  TokenNumber,
  IN UINT8  Value
  )
{
  return (GetPcdPpiPointer ())->Set8 (TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSet16S (
  IN UINTN   TokenNumber,
  IN UINT16  Value
  )
{
  return (GetPcdPpiPointer ())->Set16 (TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSet32S (
  IN UINTN   TokenNumber,
  IN UINT32  Value
  )
{
  return (GetPcdPpiPointer ())->Set32 (TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSet64S (
  IN UINTN   TokenNumber,
  IN UINT64  Value
  )
{
  return (GetPcdPpiPointer ())->Set64 (TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetPtrS (
  IN       UINTN  TokenNumber,
  IN OUT   UINTN  *SizeOfBuffer,
  IN CONST VOID   *Buffer
  )
{
  ASSERT (SizeOfBuffer != NULL);
 
  if (*SizeOfBuffer > 0) {
    ASSERT (Buffer != NULL);
  }
 
  return (GetPcdPpiPointer ())->SetPtr (TokenNumber, SizeOfBuffer, (VOID *)Buffer);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetBoolS (
  IN UINTN    TokenNumber,
  IN BOOLEAN  Value
  )
{
  return (GetPcdPpiPointer ())->SetBool (TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetEx8S (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber,
  IN UINT8       Value
  )
{
  ASSERT (Guid != NULL);
 
  return (GetPiPcdPpiPointer ())->Set8 (Guid, TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetEx16S (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber,
  IN UINT16      Value
  )
{
  ASSERT (Guid != NULL);
 
  return (GetPiPcdPpiPointer ())->Set16 (Guid, TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetEx32S (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber,
  IN UINT32      Value
  )
{
  ASSERT (Guid != NULL);
 
  return (GetPiPcdPpiPointer ())->Set32 (Guid, TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetEx64S (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber,
  IN UINT64      Value
  )
{
  ASSERT (Guid != NULL);
 
  return (GetPiPcdPpiPointer ())->Set64 (Guid, TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetExPtrS (
  IN CONST GUID   *Guid,
  IN       UINTN  TokenNumber,
  IN OUT   UINTN  *SizeOfBuffer,
  IN       VOID   *Buffer
  )
{
  ASSERT (Guid != NULL);
 
  ASSERT (SizeOfBuffer != NULL);
 
  if (*SizeOfBuffer > 0) {
    ASSERT (Buffer != NULL);
  }
 
  return (GetPiPcdPpiPointer ())->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetExBoolS (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber,
  IN BOOLEAN     Value
  )
{
  ASSERT (Guid != NULL);
 
  return (GetPiPcdPpiPointer ())->SetBool (Guid, TokenNumber, Value);
}
 
VOID
EFIAPI
LibPcdCallbackOnSet (
  IN CONST GUID    *Guid        OPTIONAL,
  IN UINTN         TokenNumber,
  IN PCD_CALLBACK  NotificationFunction
  )
{
  EFI_STATUS  Status;
 
  ASSERT (NotificationFunction != NULL);
 
  Status = (GetPiPcdPpiPointer ())->CallbackOnSet (Guid, TokenNumber, (EFI_PEI_PCD_PPI_CALLBACK)NotificationFunction);
 
  ASSERT_EFI_ERROR (Status);
 
  return;
}
 
VOID
EFIAPI
LibPcdCancelCallback (
  IN CONST GUID    *Guid        OPTIONAL,
  IN UINTN         TokenNumber,
  IN PCD_CALLBACK  NotificationFunction
  )
{
  EFI_STATUS  Status;
 
  ASSERT (NotificationFunction != NULL);
 
  Status = (GetPiPcdPpiPointer ())->CancelCallback (Guid, TokenNumber, (EFI_PEI_PCD_PPI_CALLBACK)NotificationFunction);
 
  ASSERT_EFI_ERROR (Status);
 
  return;
}
 
UINTN
EFIAPI
LibPcdGetNextToken (
  IN CONST GUID  *Guid        OPTIONAL,
  IN UINTN       TokenNumber
  )
{
  EFI_STATUS  Status;
 
  Status = (GetPiPcdPpiPointer ())->GetNextToken (Guid, &TokenNumber);
  ASSERT (!EFI_ERROR (Status) || TokenNumber == 0);
 
  return TokenNumber;
}
 
GUID *
EFIAPI
LibPcdGetNextTokenSpace (
  IN CONST GUID  *TokenSpaceGuid
  )
{
  (GetPiPcdPpiPointer ())->GetNextTokenSpace (&TokenSpaceGuid);
 
  return (GUID *)TokenSpaceGuid;
}
 
VOID *
EFIAPI
LibPatchPcdSetPtr (
  OUT       VOID   *PatchVariable,
  IN        UINTN  MaximumDatumSize,
  IN OUT    UINTN  *SizeOfBuffer,
  IN CONST  VOID   *Buffer
  )
{
  ASSERT (PatchVariable != NULL);
  ASSERT (SizeOfBuffer  != NULL);
 
  if (*SizeOfBuffer > 0) {
    ASSERT (Buffer != NULL);
  }
 
  if ((*SizeOfBuffer > MaximumDatumSize) ||
      (*SizeOfBuffer == MAX_ADDRESS))
  {
    *SizeOfBuffer = MaximumDatumSize;
    return NULL;
  }
 
  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
 
  return (VOID *)Buffer;
}
 
RETURN_STATUS
EFIAPI
LibPatchPcdSetPtrS (
  OUT      VOID   *PatchVariable,
  IN       UINTN  MaximumDatumSize,
  IN OUT   UINTN  *SizeOfBuffer,
  IN CONST VOID   *Buffer
  )
{
  ASSERT (PatchVariable != NULL);
  ASSERT (SizeOfBuffer  != NULL);
 
  if (*SizeOfBuffer > 0) {
    ASSERT (Buffer != NULL);
  }
 
  if ((*SizeOfBuffer > MaximumDatumSize) ||
      (*SizeOfBuffer == MAX_ADDRESS))
  {
    *SizeOfBuffer = MaximumDatumSize;
    return RETURN_INVALID_PARAMETER;
  }
 
  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
 
  return RETURN_SUCCESS;
}
 
VOID *
EFIAPI
LibPatchPcdSetPtrAndSize (
  OUT       VOID   *PatchVariable,
  OUT       UINTN  *SizeOfPatchVariable,
  IN        UINTN  MaximumDatumSize,
  IN OUT    UINTN  *SizeOfBuffer,
  IN CONST  VOID   *Buffer
  )
{
  ASSERT (PatchVariable != NULL);
  ASSERT (SizeOfPatchVariable != NULL);
  ASSERT (SizeOfBuffer  != NULL);
 
  if (*SizeOfBuffer > 0) {
    ASSERT (Buffer != NULL);
  }
 
  if ((*SizeOfBuffer > MaximumDatumSize) ||
      (*SizeOfBuffer == MAX_ADDRESS))
  {
    *SizeOfBuffer = MaximumDatumSize;
    return NULL;
  }
 
  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
  *SizeOfPatchVariable = *SizeOfBuffer;
 
  return (VOID *)Buffer;
}
 
RETURN_STATUS
EFIAPI
LibPatchPcdSetPtrAndSizeS (
  OUT      VOID   *PatchVariable,
  OUT      UINTN  *SizeOfPatchVariable,
  IN       UINTN  MaximumDatumSize,
  IN OUT   UINTN  *SizeOfBuffer,
  IN CONST VOID   *Buffer
  )
{
  ASSERT (PatchVariable != NULL);
  ASSERT (SizeOfPatchVariable != NULL);
  ASSERT (SizeOfBuffer  != NULL);
 
  if (*SizeOfBuffer > 0) {
    ASSERT (Buffer != NULL);
  }
 
  if ((*SizeOfBuffer > MaximumDatumSize) ||
      (*SizeOfBuffer == MAX_ADDRESS))
  {
    *SizeOfBuffer = MaximumDatumSize;
    return RETURN_INVALID_PARAMETER;
  }
 
  CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
  *SizeOfPatchVariable = *SizeOfBuffer;
 
  return RETURN_SUCCESS;
}
 
VOID
EFIAPI
LibPcdGetInfo (
  IN        UINTN     TokenNumber,
  OUT       PCD_INFO  *PcdInfo
  )
{
  EFI_STATUS  Status;
 
  Status = GetPcdInfoPpiPointer ()->GetInfo (TokenNumber, (EFI_PCD_INFO *)PcdInfo);
  ASSERT_EFI_ERROR (Status);
}
 
VOID
EFIAPI
LibPcdGetInfoEx (
  IN CONST  GUID      *Guid,
  IN        UINTN     TokenNumber,
  OUT       PCD_INFO  *PcdInfo
  )
{
  EFI_STATUS  Status;
 
  Status = GetPiPcdInfoPpiPointer ()->GetInfo (Guid, TokenNumber, (EFI_PCD_INFO *)PcdInfo);
  ASSERT_EFI_ERROR (Status);
}
 
UINTN
EFIAPI
LibPcdGetSku (
  VOID
  )
{
  return GetPiPcdInfoPpiPointer ()->GetSku ();
}