DxePcdLib.c

Go to the documentation of this file.

 
#include <PiDxe.h>
 
#include <Protocol/Pcd.h>
#include <Protocol/PiPcd.h>
#include <Protocol/PcdInfo.h>
#include <Protocol/PiPcdInfo.h>
 
#include <Library/PcdLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/BaseMemoryLib.h>
 
PCD_PROTOCOL               *mPcd       = NULL;
EFI_PCD_PROTOCOL           *mPiPcd     = NULL;
GET_PCD_INFO_PROTOCOL      *mPcdInfo   = NULL;
EFI_GET_PCD_INFO_PROTOCOL  *mPiPcdInfo = NULL;
 
EFI_PCD_PROTOCOL *
EFIAPI
GetPiPcdProtocol (
  VOID
  )
{
  EFI_STATUS  Status;
 
  if (mPiPcd == NULL) {
    //
    // PI Pcd protocol defined in PI 1.2 vol3 should be installed before the module
    // access DynamicEx type PCD.
    //
    Status = gBS->LocateProtocol (&gEfiPcdProtocolGuid, NULL, (VOID **)&mPiPcd);
    ASSERT_EFI_ERROR (Status);
    ASSERT (mPiPcd != NULL);
  }
 
  return mPiPcd;
}
 
PCD_PROTOCOL *
EFIAPI
GetPcdProtocol (
  VOID
  )
{
  EFI_STATUS  Status;
 
  if (mPcd == NULL) {
    //
    // PCD protocol need to be installed before the module access Dynamic type PCD.
    // But dynamic type PCD is not required in PI 1.2 specification.
    //
    Status = gBS->LocateProtocol (&gPcdProtocolGuid, NULL, (VOID **)&mPcd);
    ASSERT_EFI_ERROR (Status);
    ASSERT (mPcd != NULL);
  }
 
  return mPcd;
}
 
EFI_GET_PCD_INFO_PROTOCOL *
GetPiPcdInfoProtocolPointer (
  VOID
  )
{
  EFI_STATUS  Status;
 
  if (mPiPcdInfo == NULL) {
    Status = gBS->LocateProtocol (&gEfiGetPcdInfoProtocolGuid, NULL, (VOID **)&mPiPcdInfo);
    ASSERT_EFI_ERROR (Status);
    ASSERT (mPiPcdInfo != NULL);
  }
 
  return mPiPcdInfo;
}
 
GET_PCD_INFO_PROTOCOL *
GetPcdInfoProtocolPointer (
  VOID
  )
{
  EFI_STATUS  Status;
 
  if (mPcdInfo == NULL) {
    Status = gBS->LocateProtocol (&gGetPcdInfoProtocolGuid, NULL, (VOID **)&mPcdInfo);
    ASSERT_EFI_ERROR (Status);
    ASSERT (mPcdInfo != NULL);
  }
 
  return mPcdInfo;
}
 
UINTN
EFIAPI
LibPcdSetSku (
  IN UINTN  SkuId
  )
{
  GetPcdProtocol ()->SetSku (SkuId);
 
  return SkuId;
}
 
UINT8
EFIAPI
LibPcdGet8 (
  IN UINTN  TokenNumber
  )
{
  return GetPcdProtocol ()->Get8 (TokenNumber);
}
 
UINT16
EFIAPI
LibPcdGet16 (
  IN UINTN  TokenNumber
  )
{
  return GetPcdProtocol ()->Get16 (TokenNumber);
}
 
UINT32
EFIAPI
LibPcdGet32 (
  IN UINTN  TokenNumber
  )
{
  return GetPcdProtocol ()->Get32 (TokenNumber);
}
 
UINT64
EFIAPI
LibPcdGet64 (
  IN UINTN  TokenNumber
  )
{
  return GetPcdProtocol ()->Get64 (TokenNumber);
}
 
VOID *
EFIAPI
LibPcdGetPtr (
  IN UINTN  TokenNumber
  )
{
  return GetPcdProtocol ()->GetPtr (TokenNumber);
}
 
BOOLEAN
EFIAPI
LibPcdGetBool (
  IN UINTN  TokenNumber
  )
{
  return GetPcdProtocol ()->GetBool (TokenNumber);
}
 
UINTN
EFIAPI
LibPcdGetSize (
  IN UINTN  TokenNumber
  )
{
  return GetPcdProtocol ()->GetSize (TokenNumber);
}
 
UINT8
EFIAPI
LibPcdGetEx8 (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->Get8 (Guid, TokenNumber);
}
 
UINT16
EFIAPI
LibPcdGetEx16 (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->Get16 (Guid, TokenNumber);
}
 
UINT32
EFIAPI
LibPcdGetEx32 (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->Get32 (Guid, TokenNumber);
}
 
UINT64
EFIAPI
LibPcdGetEx64 (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->Get64 (Guid, TokenNumber);
}
 
VOID *
EFIAPI
LibPcdGetExPtr (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->GetPtr (Guid, TokenNumber);
}
 
BOOLEAN
EFIAPI
LibPcdGetExBool (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->GetBool (Guid, TokenNumber);
}
 
UINTN
EFIAPI
LibPcdGetExSize (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->GetSize (Guid, TokenNumber);
}
 
RETURN_STATUS
EFIAPI
LibPcdSet8S (
  IN UINTN  TokenNumber,
  IN UINT8  Value
  )
{
  return GetPcdProtocol ()->Set8 (TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSet16S (
  IN UINTN   TokenNumber,
  IN UINT16  Value
  )
{
  return GetPcdProtocol ()->Set16 (TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSet32S (
  IN UINTN   TokenNumber,
  IN UINT32  Value
  )
{
  return GetPcdProtocol ()->Set32 (TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSet64S (
  IN UINTN   TokenNumber,
  IN UINT64  Value
  )
{
  return GetPcdProtocol ()->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 GetPcdProtocol ()->SetPtr (TokenNumber, SizeOfBuffer, (VOID *)Buffer);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetBoolS (
  IN UINTN    TokenNumber,
  IN BOOLEAN  Value
  )
{
  return GetPcdProtocol ()->SetBool (TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetEx8S (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber,
  IN UINT8       Value
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->Set8 (Guid, TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetEx16S (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber,
  IN UINT16      Value
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->Set16 (Guid, TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetEx32S (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber,
  IN UINT32      Value
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->Set32 (Guid, TokenNumber, Value);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetEx64S (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber,
  IN UINT64      Value
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->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 GetPiPcdProtocol ()->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer);
}
 
RETURN_STATUS
EFIAPI
LibPcdSetExBoolS (
  IN CONST GUID  *Guid,
  IN UINTN       TokenNumber,
  IN BOOLEAN     Value
  )
{
  ASSERT (Guid != NULL);
 
  return GetPiPcdProtocol ()->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 = GetPiPcdProtocol ()->CallbackOnSet (Guid, TokenNumber, (EFI_PCD_PROTOCOL_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 = GetPiPcdProtocol ()->CancelCallback (Guid, TokenNumber, (EFI_PCD_PROTOCOL_CALLBACK)NotificationFunction);
  ASSERT_EFI_ERROR (Status);
 
  return;
}
 
UINTN
EFIAPI
LibPcdGetNextToken (
  IN CONST GUID  *Guid        OPTIONAL,
  IN UINTN       TokenNumber
  )
{
  EFI_STATUS  Status;
 
  Status = GetPiPcdProtocol ()->GetNextToken (Guid, &TokenNumber);
  ASSERT (!EFI_ERROR (Status) || TokenNumber == 0);
 
  return TokenNumber;
}
 
GUID *
EFIAPI
LibPcdGetNextTokenSpace (
  IN CONST GUID  *TokenSpaceGuid
  )
{
  GetPiPcdProtocol ()->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 = GetPcdInfoProtocolPointer ()->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 = GetPiPcdInfoProtocolPointer ()->GetInfo (Guid, TokenNumber, (EFI_PCD_INFO *)PcdInfo);
  ASSERT_EFI_ERROR (Status);
}
 
UINTN
EFIAPI
LibPcdGetSku (
  VOID
  )
{
  return GetPiPcdInfoProtocolPointer ()->GetSku ();
}