Pcd.c

Go to the documentation of this file.

 
#include "Service.h"
 
PCD_PPI  mPcdPpiInstance = {
  PeiPcdSetSku,
 
  PeiPcdGet8,
  PeiPcdGet16,
  PeiPcdGet32,
  PeiPcdGet64,
  PeiPcdGetPtr,
  PeiPcdGetBool,
  PeiPcdGetSize,
 
  PeiPcdGet8Ex,
  PeiPcdGet16Ex,
  PeiPcdGet32Ex,
  PeiPcdGet64Ex,
  PeiPcdGetPtrEx,
  PeiPcdGetBoolEx,
  PeiPcdGetSizeEx,
 
  PeiPcdSet8,
  PeiPcdSet16,
  PeiPcdSet32,
  PeiPcdSet64,
  PeiPcdSetPtr,
  PeiPcdSetBool,
 
  PeiPcdSet8Ex,
  PeiPcdSet16Ex,
  PeiPcdSet32Ex,
  PeiPcdSet64Ex,
  PeiPcdSetPtrEx,
  PeiPcdSetBoolEx,
 
  PeiRegisterCallBackOnSet,
  PcdUnRegisterCallBackOnSet,
  PeiPcdGetNextToken,
  PeiPcdGetNextTokenSpace
};
 
EFI_PEI_PCD_PPI  mEfiPcdPpiInstance = {
  PeiPcdSetSku,
 
  PeiPcdGet8Ex,
  PeiPcdGet16Ex,
  PeiPcdGet32Ex,
  PeiPcdGet64Ex,
  PeiPcdGetPtrEx,
  PeiPcdGetBoolEx,
  PeiPcdGetSizeEx,
  PeiPcdSet8Ex,
  PeiPcdSet16Ex,
  PeiPcdSet32Ex,
  PeiPcdSet64Ex,
  PeiPcdSetPtrEx,
  PeiPcdSetBoolEx,
  (EFI_PEI_PCD_PPI_CALLBACK_ON_SET)PeiRegisterCallBackOnSet,
  (EFI_PEI_PCD_PPI_CANCEL_CALLBACK)PcdUnRegisterCallBackOnSet,
  PeiPcdGetNextToken,
  PeiPcdGetNextTokenSpace
};
 
GET_PCD_INFO_PPI  mGetPcdInfoInstance = {
  PeiGetPcdInfoGetInfo,
  PeiGetPcdInfoGetInfoEx,
  PeiGetPcdInfoGetSku
};
 
EFI_GET_PCD_INFO_PPI  mEfiGetPcdInfoInstance = {
  PeiGetPcdInfoGetInfoEx,
  PeiGetPcdInfoGetSku
};
 
EFI_PEI_PPI_DESCRIPTOR  mPpiList[] = {
  {
    EFI_PEI_PPI_DESCRIPTOR_PPI,
    &gPcdPpiGuid,
    &mPcdPpiInstance
  },
  {
    (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
    &gEfiPeiPcdPpiGuid,
    &mEfiPcdPpiInstance
  }
};
 
EFI_PEI_PPI_DESCRIPTOR  mPpiList2[] = {
  {
    EFI_PEI_PPI_DESCRIPTOR_PPI,
    &gGetPcdInfoPpiGuid,
    &mGetPcdInfoInstance
  },
  {
    (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
    &gEfiGetPcdInfoPpiGuid,
    &mEfiGetPcdInfoInstance
  }
};
 
VOID
EFIAPI
PcdSetNvStoreDefaultIdCallBack (
  IN CONST EFI_GUID  *CallBackGuid  OPTIONAL,
  IN       UINTN     CallBackToken,
  IN OUT   VOID      *TokenData,
  IN       UINTN     TokenDataSize
  )
{
  EFI_STATUS             Status;
  UINT16                 DefaultId;
  SKU_ID                 SkuId;
  UINTN                  FullSize;
  UINTN                  Index;
  UINT8                  *DataBuffer;
  UINT8                  *VarStoreHobData;
  UINT8                  *BufferEnd;
  BOOLEAN                IsFound;
  VARIABLE_STORE_HEADER  *NvStoreBuffer;
  PCD_DEFAULT_DATA       *DataHeader;
  PCD_DEFAULT_INFO       *DefaultInfo;
  PCD_DATA_DELTA         *DeltaData;
 
  DefaultId = *(UINT16 *)TokenData;
  SkuId     = GetPcdDatabase ()->SystemSkuId;
  IsFound   = FALSE;
 
  if (PeiPcdGetSizeEx (&gEfiMdeModulePkgTokenSpaceGuid, PcdToken (PcdNvStoreDefaultValueBuffer)) > sizeof (PCD_NV_STORE_DEFAULT_BUFFER_HEADER)) {
    DataBuffer = (UINT8 *)PeiPcdGetPtrEx (&gEfiMdeModulePkgTokenSpaceGuid, PcdToken (PcdNvStoreDefaultValueBuffer));
    FullSize   = ((PCD_NV_STORE_DEFAULT_BUFFER_HEADER *)DataBuffer)->Length;
    DataHeader = (PCD_DEFAULT_DATA *)(DataBuffer + sizeof (PCD_NV_STORE_DEFAULT_BUFFER_HEADER));
    //
    // The first section data includes NV storage default setting.
    //
    NvStoreBuffer   = (VARIABLE_STORE_HEADER *)((UINT8 *)DataHeader + sizeof (DataHeader->DataSize) + DataHeader->HeaderSize);
    VarStoreHobData = (UINT8 *)BuildGuidHob (&NvStoreBuffer->Signature, NvStoreBuffer->Size);
    ASSERT (VarStoreHobData != NULL);
    CopyMem (VarStoreHobData, NvStoreBuffer, NvStoreBuffer->Size);
    //
    // Find the matched SkuId and DefaultId in the first section
    //
    DefaultInfo = &(DataHeader->DefaultInfo[0]);
    BufferEnd   = (UINT8 *)DataHeader + sizeof (DataHeader->DataSize) + DataHeader->HeaderSize;
    while ((UINT8 *)DefaultInfo < BufferEnd) {
      if ((DefaultInfo->DefaultId == DefaultId) && (DefaultInfo->SkuId == SkuId)) {
        IsFound = TRUE;
        break;
      }
 
      DefaultInfo++;
    }
 
    //
    // Find the matched SkuId and DefaultId in the remaining section
    //
    Index      = sizeof (PCD_NV_STORE_DEFAULT_BUFFER_HEADER) + ((DataHeader->DataSize + 7) & (~7));
    DataHeader = (PCD_DEFAULT_DATA *)(DataBuffer + Index);
    while (!IsFound && Index < FullSize && DataHeader->DataSize != 0xFFFFFFFF) {
      DefaultInfo = &(DataHeader->DefaultInfo[0]);
      BufferEnd   = (UINT8 *)DataHeader + sizeof (DataHeader->DataSize) + DataHeader->HeaderSize;
      while ((UINT8 *)DefaultInfo < BufferEnd) {
        if ((DefaultInfo->DefaultId == DefaultId) && (DefaultInfo->SkuId == SkuId)) {
          IsFound = TRUE;
          break;
        }
 
        DefaultInfo++;
      }
 
      if (IsFound) {
        DeltaData = (PCD_DATA_DELTA *)BufferEnd;
        BufferEnd = (UINT8 *)DataHeader + DataHeader->DataSize;
        while ((UINT8 *)DeltaData < BufferEnd) {
          *(VarStoreHobData + DeltaData->Offset) = (UINT8)DeltaData->Value;
          DeltaData++;
        }
 
        break;
      }
 
      Index      = (Index + DataHeader->DataSize + 7) & (~7);
      DataHeader = (PCD_DEFAULT_DATA *)(DataBuffer + Index);
    }
  }
 
  Status = PcdUnRegisterCallBackOnSet (
             &gEfiMdeModulePkgTokenSpaceGuid,
             PcdToken (PcdSetNvStoreDefaultId),
             PcdSetNvStoreDefaultIdCallBack
             );
  ASSERT_EFI_ERROR (Status);
}
 
EFI_STATUS
EFIAPI
EndOfPeiSignalPpiNotifyCallback (
  IN EFI_PEI_SERVICES           **PeiServices,
  IN EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyDescriptor,
  IN VOID                       *Ppi
  )
{
  PEI_PCD_DATABASE     *Database;
  EFI_BOOT_MODE        BootMode;
  EFI_STATUS           Status;
  UINTN                Instance;
  EFI_PEI_FV_HANDLE    VolumeHandle;
  EFI_PEI_FILE_HANDLE  FileHandle;
  VOID                 *PcdDb;
  UINT32               Length;
  PEI_PCD_DATABASE     *PeiPcdDb;
 
  Status = PeiServicesGetBootMode (&BootMode);
  ASSERT_EFI_ERROR (Status);
 
  //
  // Don't need to report it on S3 boot.
  //
  if (BootMode == BOOT_ON_S3_RESUME) {
    return EFI_SUCCESS;
  }
 
  PeiPcdDb = GetPcdDatabase ();
  if (PeiPcdDb->SystemSkuId != (SKU_ID)0) {
    //
    // SkuId has been set. Don't need to report it to DXE phase.
    //
    return EFI_SUCCESS;
  }
 
  //
  // Get full PCD database from PcdPeim FileHandle
  //
  Instance   = 0;
  FileHandle = NULL;
  while (TRUE) {
    //
    // Traverse all firmware volume instances
    //
    Status = PeiServicesFfsFindNextVolume (Instance, &VolumeHandle);
    //
    // Error should not happen
    //
    ASSERT_EFI_ERROR (Status);
 
    //
    // Find PcdDb file from the beginning in this firmware volume.
    //
    FileHandle = NULL;
    Status     = PeiServicesFfsFindFileByName (&gEfiCallerIdGuid, VolumeHandle, &FileHandle);
    if (!EFI_ERROR (Status)) {
      //
      // Find PcdPeim FileHandle in this volume
      //
      break;
    }
 
    //
    // We cannot find PcdPeim in this firmware volume, then search the next volume.
    //
    Instance++;
  }
 
  //
  // Find PEI PcdDb and Build second PcdDB GuidHob
  //
  Status = PeiServicesFfsFindSectionData (EFI_SECTION_RAW, FileHandle, &PcdDb);
  ASSERT_EFI_ERROR (Status);
  Length   = PeiPcdDb->LengthForAllSkus;
  Database = BuildGuidHob (&gPcdDataBaseHobGuid, Length);
  CopyMem (Database, PcdDb, Length);
 
  return EFI_SUCCESS;
}
 
EFI_PEI_NOTIFY_DESCRIPTOR  mEndOfPeiSignalPpiNotifyList[] = {
  {
    (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
    &gEfiEndOfPeiSignalPpiGuid,
    EndOfPeiSignalPpiNotifyCallback
  }
};
 
EFI_STATUS
EFIAPI
PcdPeimInit (
  IN       EFI_PEI_FILE_HANDLE  FileHandle,
  IN CONST EFI_PEI_SERVICES     **PeiServices
  )
{
  EFI_STATUS  Status;
 
  Status = PeiServicesRegisterForShadow (FileHandle);
  if (Status == EFI_ALREADY_STARTED) {
    //
    // This is now starting in memory, the second time starting.
    //
    EFI_PEI_PPI_DESCRIPTOR  *OldPpiList;
    EFI_PEI_PPI_DESCRIPTOR  *OldPpiList2;
    VOID                    *Ppi;
    VOID                    *Ppi2;
 
    OldPpiList = NULL;
    Status     = PeiServicesLocatePpi (
                   &gPcdPpiGuid,
                   0,
                   &OldPpiList,
                   &Ppi
                   );
    ASSERT_EFI_ERROR (Status);
 
    if (OldPpiList != NULL) {
      Status = PeiServicesReInstallPpi (OldPpiList, &mPpiList[0]);
      ASSERT_EFI_ERROR (Status);
    }
 
    OldPpiList2 = NULL;
    Status      = PeiServicesLocatePpi (
                    &gGetPcdInfoPpiGuid,
                    0,
                    &OldPpiList2,
                    &Ppi2
                    );
    ASSERT_EFI_ERROR (Status);
 
    if (OldPpiList2 != NULL) {
      Status = PeiServicesReInstallPpi (OldPpiList2, &mPpiList2[0]);
      ASSERT_EFI_ERROR (Status);
    }
 
    OldPpiList = NULL;
    Status     = PeiServicesLocatePpi (
                   &gEfiPeiPcdPpiGuid,
                   0,
                   &OldPpiList,
                   &Ppi
                   );
    ASSERT_EFI_ERROR (Status);
 
    if (OldPpiList != NULL) {
      Status = PeiServicesReInstallPpi (OldPpiList, &mPpiList[1]);
      ASSERT_EFI_ERROR (Status);
    }
 
    OldPpiList2 = NULL;
    Status      = PeiServicesLocatePpi (
                    &gEfiGetPcdInfoPpiGuid,
                    0,
                    &OldPpiList2,
                    &Ppi2
                    );
    ASSERT_EFI_ERROR (Status);
 
    if (OldPpiList2 != NULL) {
      Status = PeiServicesReInstallPpi (OldPpiList2, &mPpiList2[1]);
      ASSERT_EFI_ERROR (Status);
    }
 
    return Status;
  }
 
  BuildPcdDatabase (FileHandle);
 
  //
  // Install PCD_PPI and EFI_PEI_PCD_PPI.
  //
  Status = PeiServicesInstallPpi (&mPpiList[0]);
  ASSERT_EFI_ERROR (Status);
 
  //
  // Install GET_PCD_INFO_PPI and EFI_GET_PCD_INFO_PPI.
  //
  Status = PeiServicesInstallPpi (&mPpiList2[0]);
  ASSERT_EFI_ERROR (Status);
 
  Status = PeiServicesNotifyPpi (&mEndOfPeiSignalPpiNotifyList[0]);
  ASSERT_EFI_ERROR (Status);
 
  Status = PeiRegisterCallBackOnSet (
             &gEfiMdeModulePkgTokenSpaceGuid,
             PcdToken (PcdSetNvStoreDefaultId),
             PcdSetNvStoreDefaultIdCallBack
             );
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
PeiGetPcdInfoGetInfo (
  IN        UINTN         TokenNumber,
  OUT       EFI_PCD_INFO  *PcdInfo
  )
{
  return PeiGetPcdInfo (NULL, TokenNumber, PcdInfo);
}
 
EFI_STATUS
EFIAPI
PeiGetPcdInfoGetInfoEx (
  IN CONST  EFI_GUID      *Guid,
  IN        UINTN         TokenNumber,
  OUT       EFI_PCD_INFO  *PcdInfo
  )
{
  return PeiGetPcdInfo (Guid, TokenNumber, PcdInfo);
}
 
UINTN
EFIAPI
PeiGetPcdInfoGetSku (
  VOID
  )
{
  return (UINTN)GetPcdDatabase ()->SystemSkuId;
}
 
VOID
EFIAPI
PeiPcdSetSku (
  IN  UINTN  SkuId
  )
{
  PEI_PCD_DATABASE        *PeiPcdDb;
  SKU_ID                  *SkuIdTable;
  UINTN                   Index;
  EFI_STATUS              Status;
  UINTN                   Instance;
  EFI_PEI_FV_HANDLE       VolumeHandle;
  EFI_PEI_FILE_HANDLE     FileHandle;
  VOID                    *PcdDb;
  UINT32                  Length;
  PCD_DATABASE_SKU_DELTA  *SkuDelta;
  PCD_DATA_DELTA          *SkuDeltaData;
 
  DEBUG ((DEBUG_INFO, "PcdPei - SkuId 0x%lx is to be set.\n", (SKU_ID)SkuId));
 
  PeiPcdDb = GetPcdDatabase ();
 
  if (SkuId == PeiPcdDb->SystemSkuId) {
    //
    // The input SKU Id is equal to current SKU Id, return directly.
    //
    DEBUG ((DEBUG_INFO, "PcdPei - SkuId is same to current system Sku.\n"));
    return;
  }
 
  if (PeiPcdDb->SystemSkuId != (SKU_ID)0) {
    DEBUG ((DEBUG_ERROR, "PcdPei - The SKU Id could be changed only once."));
    DEBUG ((
      DEBUG_ERROR,
      "PcdPei - The SKU Id was set to 0x%lx already, it could not be set to 0x%lx any more.",
      PeiPcdDb->SystemSkuId,
      (SKU_ID)SkuId
      ));
    ASSERT (FALSE);
    return;
  }
 
  SkuIdTable = (SKU_ID *)((UINT8 *)PeiPcdDb + PeiPcdDb->SkuIdTableOffset);
  for (Index = 0; Index < SkuIdTable[0]; Index++) {
    if (SkuId == SkuIdTable[Index + 1]) {
      DEBUG ((DEBUG_INFO, "PcdPei - SkuId is found in SkuId table.\n"));
      break;
    }
  }
 
  if (Index < SkuIdTable[0]) {
    //
    // Get full PCD database from PcdPeim FileHandle
    //
    Instance   = 0;
    FileHandle = NULL;
    while (TRUE) {
      //
      // Traverse all firmware volume instances
      //
      Status = PeiServicesFfsFindNextVolume (Instance, &VolumeHandle);
      //
      // Error should not happen
      //
      ASSERT_EFI_ERROR (Status);
 
      //
      // Find PcdDb file from the beginning in this firmware volume.
      //
      FileHandle = NULL;
      Status     = PeiServicesFfsFindFileByName (&gEfiCallerIdGuid, VolumeHandle, &FileHandle);
      if (!EFI_ERROR (Status)) {
        //
        // Find PcdPeim FileHandle in this volume
        //
        break;
      }
 
      //
      // We cannot find PcdPeim in this firmware volume, then search the next volume.
      //
      Instance++;
    }
 
    //
    // Find the delta data between the different Skus
    //
    Status = PeiServicesFfsFindSectionData (EFI_SECTION_RAW, FileHandle, &PcdDb);
    ASSERT_EFI_ERROR (Status);
    Length   = PeiPcdDb->LengthForAllSkus;
    Index    = (PeiPcdDb->Length + 7) & (~7);
    SkuDelta = NULL;
    while (Index < Length) {
      SkuDelta = (PCD_DATABASE_SKU_DELTA *)((UINT8 *)PcdDb + Index);
      if ((SkuDelta->SkuId == SkuId) && (SkuDelta->SkuIdCompared == 0)) {
        break;
      }
 
      Index = (Index + SkuDelta->Length + 7) & (~7);
    }
 
    //
    // Patch the delta data into current PCD database
    //
    if ((Index < Length) && (SkuDelta != NULL)) {
      SkuDeltaData = (PCD_DATA_DELTA *)(SkuDelta + 1);
      while ((UINT8 *)SkuDeltaData < (UINT8 *)SkuDelta + SkuDelta->Length) {
        *((UINT8 *)PeiPcdDb + SkuDeltaData->Offset) = (UINT8)SkuDeltaData->Value;
        SkuDeltaData++;
      }
 
      PeiPcdDb->SystemSkuId = (SKU_ID)SkuId;
      DEBUG ((DEBUG_INFO, "PcdPei - Set current SKU Id to 0x%lx.\n", (SKU_ID)SkuId));
      return;
    }
  }
 
  //
  // Invalid input SkuId, the default SKU Id will be still used for the system.
  //
  DEBUG ((DEBUG_ERROR, "PcdPei - Invalid input SkuId, the default SKU Id will be still used.\n"));
 
  return;
}
 
UINT8
EFIAPI
PeiPcdGet8 (
  IN UINTN  TokenNumber
  )
{
  return *((UINT8 *)GetWorker (TokenNumber, sizeof (UINT8)));
}
 
UINT16
EFIAPI
PeiPcdGet16 (
  IN UINTN  TokenNumber
  )
{
  return ReadUnaligned16 (GetWorker (TokenNumber, sizeof (UINT16)));
}
 
UINT32
EFIAPI
PeiPcdGet32 (
  IN UINTN  TokenNumber
  )
{
  return ReadUnaligned32 (GetWorker (TokenNumber, sizeof (UINT32)));
}
 
UINT64
EFIAPI
PeiPcdGet64 (
  IN UINTN  TokenNumber
  )
{
  return ReadUnaligned64 (GetWorker (TokenNumber, sizeof (UINT64)));
}
 
VOID *
EFIAPI
PeiPcdGetPtr (
  IN UINTN  TokenNumber
  )
{
  return GetWorker (TokenNumber, 0);
}
 
BOOLEAN
EFIAPI
PeiPcdGetBool (
  IN UINTN  TokenNumber
  )
{
  return *((BOOLEAN *)GetWorker (TokenNumber, sizeof (BOOLEAN)));
}
 
UINTN
EFIAPI
PeiPcdGetSize (
  IN UINTN  TokenNumber
  )
{
  PEI_PCD_DATABASE  *PeiPcdDb;
  UINTN             Size;
  UINTN             MaxSize;
  UINT32            LocalTokenCount;
 
  PeiPcdDb        = GetPcdDatabase ();
  LocalTokenCount = PeiPcdDb->LocalTokenCount;
  //
  // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
  // We have to decrement TokenNumber by 1 to make it usable
  // as the array index.
  //
  TokenNumber--;
 
  // EBC compiler is very choosy. It may report warning about comparison
  // between UINTN and 0 . So we add 1 in each size of the
  // comparison.
  ASSERT (TokenNumber + 1 < (LocalTokenCount + 1));
 
  Size = (*((UINT32 *)((UINT8 *)PeiPcdDb + PeiPcdDb->LocalTokenNumberTableOffset) + TokenNumber) & PCD_DATUM_TYPE_ALL_SET) >> PCD_DATUM_TYPE_SHIFT;
 
  if (Size == 0) {
    //
    // For pointer type, we need to scan the SIZE_TABLE to get the current size.
    //
    return GetPtrTypeSize (TokenNumber, &MaxSize, PeiPcdDb);
  } else {
    return Size;
  }
}
 
UINT8
EFIAPI
PeiPcdGet8Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return *((UINT8 *)ExGetWorker (Guid, ExTokenNumber, sizeof (UINT8)));
}
 
UINT16
EFIAPI
PeiPcdGet16Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return ReadUnaligned16 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT16)));
}
 
UINT32
EFIAPI
PeiPcdGet32Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return ReadUnaligned32 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT32)));
}
 
UINT64
EFIAPI
PeiPcdGet64Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return ReadUnaligned64 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT64)));
}
 
VOID *
EFIAPI
PeiPcdGetPtrEx (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return ExGetWorker (Guid, ExTokenNumber, 0);
}
 
BOOLEAN
EFIAPI
PeiPcdGetBoolEx (
  IN CONST  EFI_GUID  *Guid,
  IN UINTN            ExTokenNumber
  )
{
  return *((BOOLEAN *)ExGetWorker (Guid, ExTokenNumber, sizeof (BOOLEAN)));
}
 
UINTN
EFIAPI
PeiPcdGetSizeEx (
  IN CONST  EFI_GUID  *Guid,
  IN UINTN            ExTokenNumber
  )
{
  return PeiPcdGetSize (GetExPcdTokenNumber (Guid, ExTokenNumber));
}
 
EFI_STATUS
EFIAPI
PeiPcdSet8 (
  IN UINTN  TokenNumber,
  IN UINT8  Value
  )
{
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
PeiPcdSet16 (
  IN UINTN   TokenNumber,
  IN UINT16  Value
  )
{
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
PeiPcdSet32 (
  IN UINTN   TokenNumber,
  IN UINT32  Value
  )
{
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
PeiPcdSet64 (
  IN UINTN   TokenNumber,
  IN UINT64  Value
  )
{
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
PeiPcdSetPtr (
  IN      UINTN  TokenNumber,
  IN OUT  UINTN  *SizeOfBuffer,
  IN      VOID   *Buffer
  )
{
  return SetWorker (TokenNumber, Buffer, SizeOfBuffer, TRUE);
}
 
EFI_STATUS
EFIAPI
PeiPcdSetBool (
  IN UINTN    TokenNumber,
  IN BOOLEAN  Value
  )
{
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
PeiPcdSet8Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber,
  IN UINT8           Value
  )
{
  return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
PeiPcdSet16Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber,
  IN UINT16          Value
  )
{
  return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
PeiPcdSet32Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber,
  IN UINT32          Value
  )
{
  return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
PeiPcdSet64Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber,
  IN UINT64          Value
  )
{
  return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
PeiPcdSetPtrEx (
  IN     CONST EFI_GUID  *Guid,
  IN     UINTN           ExTokenNumber,
  IN OUT UINTN           *SizeOfBuffer,
  IN     VOID            *Value
  )
{
  return ExSetWorker (ExTokenNumber, Guid, Value, SizeOfBuffer, TRUE);
}
 
EFI_STATUS
EFIAPI
PeiPcdSetBoolEx (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber,
  IN BOOLEAN         Value
  )
{
  return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
PeiRegisterCallBackOnSet (
  IN  CONST EFI_GUID    *Guid  OPTIONAL,
  IN  UINTN             ExTokenNumber,
  IN  PCD_PPI_CALLBACK  CallBackFunction
  )
{
  if (!FeaturePcdGet (PcdPeiFullPcdDatabaseEnable)) {
    return EFI_UNSUPPORTED;
  }
 
  if (CallBackFunction == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  return PeiRegisterCallBackWorker (ExTokenNumber, Guid, CallBackFunction, TRUE);
}
 
EFI_STATUS
EFIAPI
PcdUnRegisterCallBackOnSet (
  IN  CONST EFI_GUID    *Guid  OPTIONAL,
  IN  UINTN             ExTokenNumber,
  IN  PCD_PPI_CALLBACK  CallBackFunction
  )
{
  if (!FeaturePcdGet (PcdPeiFullPcdDatabaseEnable)) {
    return EFI_UNSUPPORTED;
  }
 
  if (CallBackFunction == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  return PeiRegisterCallBackWorker (ExTokenNumber, Guid, CallBackFunction, FALSE);
}
 
EFI_STATUS
EFIAPI
PeiPcdGetNextToken (
  IN CONST EFI_GUID  *Guid  OPTIONAL,
  IN OUT  UINTN      *TokenNumber
  )
{
  UINTN              GuidTableIdx;
  PEI_PCD_DATABASE   *PeiPcdDb;
  EFI_GUID           *MatchGuid;
  EFI_GUID           *GuidTable;
  DYNAMICEX_MAPPING  *ExMapTable;
  UINTN              Index;
  BOOLEAN            Found;
  BOOLEAN            PeiExMapTableEmpty;
  UINTN              PeiNexTokenNumber;
 
  if (!FeaturePcdGet (PcdPeiFullPcdDatabaseEnable)) {
    return EFI_UNSUPPORTED;
  }
 
  PeiPcdDb          = GetPcdDatabase ();
  PeiNexTokenNumber = PeiPcdDb->LocalTokenCount - PeiPcdDb->ExTokenCount;
  GuidTable         = (EFI_GUID *)((UINT8 *)PeiPcdDb + PeiPcdDb->GuidTableOffset);
 
  if (PeiPcdDb->ExTokenCount == 0) {
    PeiExMapTableEmpty = TRUE;
  } else {
    PeiExMapTableEmpty = FALSE;
  }
 
  if (Guid == NULL) {
    if (*TokenNumber > PeiNexTokenNumber) {
      return EFI_NOT_FOUND;
    }
 
    (*TokenNumber)++;
    if (*TokenNumber > PeiNexTokenNumber) {
      *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
      return EFI_NOT_FOUND;
    }
 
    return EFI_SUCCESS;
  } else {
    if (PeiExMapTableEmpty) {
      return EFI_NOT_FOUND;
    }
 
    MatchGuid = ScanGuid (GuidTable, PeiPcdDb->GuidTableCount * sizeof (EFI_GUID), Guid);
 
    if (MatchGuid == NULL) {
      return EFI_NOT_FOUND;
    }
 
    GuidTableIdx = MatchGuid - GuidTable;
 
    ExMapTable = (DYNAMICEX_MAPPING *)((UINT8 *)PeiPcdDb + PeiPcdDb->ExMapTableOffset);
 
    Found = FALSE;
    //
    // Locate the GUID in ExMapTable first.
    //
    for (Index = 0; Index < PeiPcdDb->ExTokenCount; Index++) {
      if (ExMapTable[Index].ExGuidIndex == GuidTableIdx) {
        Found = TRUE;
        break;
      }
    }
 
    if (Found) {
      //
      // If given token number is PCD_INVALID_TOKEN_NUMBER, then return the first
      // token number in found token space.
      //
      if (*TokenNumber == PCD_INVALID_TOKEN_NUMBER) {
        *TokenNumber = ExMapTable[Index].ExTokenNumber;
        return EFI_SUCCESS;
      }
 
      for ( ; Index < PeiPcdDb->ExTokenCount; Index++) {
        if ((ExMapTable[Index].ExTokenNumber == *TokenNumber) && (ExMapTable[Index].ExGuidIndex == GuidTableIdx)) {
          break;
        }
      }
 
      while (Index < PeiPcdDb->ExTokenCount) {
        Index++;
        if (Index == PeiPcdDb->ExTokenCount) {
          //
          // Exceed the length of ExMap Table
          //
          *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
          return EFI_NOT_FOUND;
        } else if (ExMapTable[Index].ExGuidIndex == GuidTableIdx) {
          //
          // Found the next match
          //
          *TokenNumber = ExMapTable[Index].ExTokenNumber;
          return EFI_SUCCESS;
        }
      }
    }
  }
 
  return EFI_NOT_FOUND;
}
 
EFI_STATUS
EFIAPI
PeiPcdGetNextTokenSpace (
  IN OUT CONST EFI_GUID  **Guid
  )
{
  UINTN              GuidTableIdx;
  EFI_GUID           *MatchGuid;
  PEI_PCD_DATABASE   *PeiPcdDb;
  DYNAMICEX_MAPPING  *ExMapTable;
  UINTN              Index;
  UINTN              Index2;
  BOOLEAN            Found;
  BOOLEAN            PeiExMapTableEmpty;
  EFI_GUID           *GuidTable;
 
  if (!FeaturePcdGet (PcdPeiFullPcdDatabaseEnable)) {
    return EFI_UNSUPPORTED;
  }
 
  ASSERT (Guid != NULL);
 
  PeiPcdDb = GetPcdDatabase ();
 
  if (PeiPcdDb->ExTokenCount == 0) {
    PeiExMapTableEmpty = TRUE;
  } else {
    PeiExMapTableEmpty = FALSE;
  }
 
  if (PeiExMapTableEmpty) {
    return EFI_NOT_FOUND;
  }
 
  ExMapTable = (DYNAMICEX_MAPPING *)((UINT8 *)PeiPcdDb + PeiPcdDb->ExMapTableOffset);
  GuidTable  = (EFI_GUID *)((UINT8 *)PeiPcdDb + PeiPcdDb->GuidTableOffset);
 
  if (*Guid == NULL) {
    //
    // return the first Token Space Guid.
    //
    *Guid = GuidTable + ExMapTable[0].ExGuidIndex;
    return EFI_SUCCESS;
  }
 
  MatchGuid = ScanGuid (GuidTable, PeiPcdDb->GuidTableCount * sizeof (GuidTable[0]), *Guid);
 
  if (MatchGuid == NULL) {
    return EFI_NOT_FOUND;
  }
 
  GuidTableIdx = MatchGuid - GuidTable;
 
  Found = FALSE;
  for (Index = 0; Index < PeiPcdDb->ExTokenCount; Index++) {
    if (ExMapTable[Index].ExGuidIndex == GuidTableIdx) {
      Found = TRUE;
      break;
    }
  }
 
  if (Found) {
    Index++;
    for ( ; Index < PeiPcdDb->ExTokenCount; Index++ ) {
      if (ExMapTable[Index].ExGuidIndex != GuidTableIdx) {
        Found = FALSE;
        for (Index2 = 0; Index2 < Index; Index2++) {
          if (ExMapTable[Index2].ExGuidIndex == ExMapTable[Index].ExGuidIndex) {
            //
            // This token namespace should have been found and output at preceding getting.
            //
            Found = TRUE;
            break;
          }
        }
 
        if (!Found) {
          *Guid = (EFI_GUID *)((UINT8 *)PeiPcdDb + PeiPcdDb->GuidTableOffset) + ExMapTable[Index].ExGuidIndex;
          return EFI_SUCCESS;
        }
      }
    }
 
    *Guid = NULL;
  }
 
  return EFI_NOT_FOUND;
}
 
UINTN
GetPtrTypeSize (
  IN    UINTN             LocalTokenNumberTableIdx,
  OUT   UINTN             *MaxSize,
  IN    PEI_PCD_DATABASE  *Database
  )
{
  INTN       SizeTableIdx;
  UINTN      LocalTokenNumber;
  SIZE_INFO  *SizeTable;
 
  SizeTableIdx = GetSizeTableIndex (LocalTokenNumberTableIdx, Database);
 
  LocalTokenNumber = *((UINT32 *)((UINT8 *)Database + Database->LocalTokenNumberTableOffset) + LocalTokenNumberTableIdx);
 
  ASSERT ((LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) == PCD_DATUM_TYPE_POINTER);
 
  SizeTable = (SIZE_INFO *)((UINT8 *)Database + Database->SizeTableOffset);
 
  *MaxSize = SizeTable[SizeTableIdx];
  //
  // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
  // PCD entry.
  //
  if ((LocalTokenNumber & PCD_TYPE_VPD) != 0) {
    //
    // We have only two entry for VPD enabled PCD entry:
    // 1) MAX Size.
    // 2) Current Size
    // We consider current size is equal to MAX size.
    //
    return *MaxSize;
  } else {
    //
    // We have only two entry for Non-Sku enabled PCD entry:
    // 1) MAX SIZE
    // 2) Current Size
    //
    return SizeTable[SizeTableIdx + 1];
  }
}
 
BOOLEAN
SetPtrTypeSize (
  IN          UINTN             LocalTokenNumberTableIdx,
  IN    OUT   UINTN             *CurrentSize,
  IN          PEI_PCD_DATABASE  *Database
  )
{
  INTN       SizeTableIdx;
  UINTN      LocalTokenNumber;
  SIZE_INFO  *SizeTable;
  UINTN      MaxSize;
 
  SizeTableIdx = GetSizeTableIndex (LocalTokenNumberTableIdx, Database);
 
  LocalTokenNumber = *((UINT32 *)((UINT8 *)Database + Database->LocalTokenNumberTableOffset) + LocalTokenNumberTableIdx);
 
  ASSERT ((LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) == PCD_DATUM_TYPE_POINTER);
 
  SizeTable = (SIZE_INFO *)((UINT8 *)Database + Database->SizeTableOffset);
 
  MaxSize = SizeTable[SizeTableIdx];
  //
  // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
  // PCD entry.
  //
  if ((LocalTokenNumber & PCD_TYPE_VPD) != 0) {
    //
    // We shouldn't come here as we don't support SET for VPD
    //
    ASSERT (FALSE);
    return FALSE;
  } else {
    if ((*CurrentSize > MaxSize) ||
        (*CurrentSize == MAX_ADDRESS))
    {
      *CurrentSize = MaxSize;
      return FALSE;
    }
 
    //
    // We have only two entry for Non-Sku enabled PCD entry:
    // 1) MAX SIZE
    // 2) Current Size
    //
    SizeTable[SizeTableIdx + 1] = (SIZE_INFO)*CurrentSize;
    return TRUE;
  }
}