Pcd.c

Go to the documentation of this file.

 
#include "Service.h"
 
EFI_LOCK  mPcdDatabaseLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY);
 
PCD_PROTOCOL  mPcdInstance = {
  DxePcdSetSku,
 
  DxePcdGet8,
  DxePcdGet16,
  DxePcdGet32,
  DxePcdGet64,
  DxePcdGetPtr,
  DxePcdGetBool,
  DxePcdGetSize,
 
  DxePcdGet8Ex,
  DxePcdGet16Ex,
  DxePcdGet32Ex,
  DxePcdGet64Ex,
  DxePcdGetPtrEx,
  DxePcdGetBoolEx,
  DxePcdGetSizeEx,
 
  DxePcdSet8,
  DxePcdSet16,
  DxePcdSet32,
  DxePcdSet64,
  DxePcdSetPtr,
  DxePcdSetBool,
 
  DxePcdSet8Ex,
  DxePcdSet16Ex,
  DxePcdSet32Ex,
  DxePcdSet64Ex,
  DxePcdSetPtrEx,
  DxePcdSetBoolEx,
 
  DxeRegisterCallBackOnSet,
  DxeUnRegisterCallBackOnSet,
  DxePcdGetNextToken,
  DxePcdGetNextTokenSpace
};
 
EFI_PCD_PROTOCOL  mEfiPcdInstance = {
  DxePcdSetSku,
  DxePcdGet8Ex,
  DxePcdGet16Ex,
  DxePcdGet32Ex,
  DxePcdGet64Ex,
  DxePcdGetPtrEx,
  DxePcdGetBoolEx,
  DxePcdGetSizeEx,
  DxePcdSet8Ex,
  DxePcdSet16Ex,
  DxePcdSet32Ex,
  DxePcdSet64Ex,
  DxePcdSetPtrEx,
  DxePcdSetBoolEx,
  (EFI_PCD_PROTOCOL_CALLBACK_ON_SET)DxeRegisterCallBackOnSet,
  (EFI_PCD_PROTOCOL_CANCEL_CALLBACK)DxeUnRegisterCallBackOnSet,
  DxePcdGetNextToken,
  DxePcdGetNextTokenSpace
};
 
GET_PCD_INFO_PROTOCOL  mGetPcdInfoInstance = {
  DxeGetPcdInfoGetInfo,
  DxeGetPcdInfoGetInfoEx,
  DxeGetPcdInfoGetSku
};
 
EFI_GET_PCD_INFO_PROTOCOL  mEfiGetPcdInfoInstance = {
  DxeGetPcdInfoGetInfoEx,
  DxeGetPcdInfoGetSku
};
 
EFI_HANDLE  mPcdHandle      = NULL;
UINTN       mVpdBaseAddress = 0;
 
EFI_STATUS
EFIAPI
PcdDxeInit (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
  VOID        *Registration;
 
  //
  // Make sure the Pcd Protocol is not already installed in the system
  //
 
  ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gPcdProtocolGuid);
 
  BuildPcdDxeDataBase ();
 
  //
  // Install PCD_PROTOCOL to handle dynamic type PCD
  // Install EFI_PCD_PROTOCOL to handle dynamicEx type PCD
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &mPcdHandle,
                  &gPcdProtocolGuid,
                  &mPcdInstance,
                  &gEfiPcdProtocolGuid,
                  &mEfiPcdInstance,
                  NULL
                  );
  ASSERT_EFI_ERROR (Status);
 
  //
  // Install GET_PCD_INFO_PROTOCOL to handle dynamic type PCD
  // Install EFI_GET_PCD_INFO_PROTOCOL to handle dynamicEx type PCD
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &mPcdHandle,
                  &gGetPcdInfoProtocolGuid,
                  &mGetPcdInfoInstance,
                  &gEfiGetPcdInfoProtocolGuid,
                  &mEfiGetPcdInfoInstance,
                  NULL
                  );
  ASSERT_EFI_ERROR (Status);
 
  //
  // Register callback function upon VariableLockProtocol
  // to lock the variables referenced by DynamicHii PCDs with RO property set in *.dsc.
  //
  EfiCreateProtocolNotifyEvent (
    &gEdkiiVariableLockProtocolGuid,
    TPL_CALLBACK,
    VariableLockCallBack,
    NULL,
    &Registration
    );
 
  //
  // Cache VpdBaseAddress in entry point for the following usage.
  //
 
  //
  // PcdVpdBaseAddress64 is DynamicEx PCD only. So, DxePcdGet64Ex() is used to get its value.
  //
  mVpdBaseAddress = (UINTN)DxePcdGet64Ex (&gEfiMdeModulePkgTokenSpaceGuid, PcdToken (PcdVpdBaseAddress64));
  if (mVpdBaseAddress == 0) {
    //
    // PcdVpdBaseAddress64 is not set, get value from PcdVpdBaseAddress.
    //
    mVpdBaseAddress = (UINTN)PcdGet32 (PcdVpdBaseAddress);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
DxeGetPcdInfoGetInfo (
  IN        UINTN         TokenNumber,
  OUT       EFI_PCD_INFO  *PcdInfo
  )
{
  return DxeGetPcdInfo (NULL, TokenNumber, PcdInfo);
}
 
EFI_STATUS
EFIAPI
DxeGetPcdInfoGetInfoEx (
  IN CONST  EFI_GUID      *Guid,
  IN        UINTN         TokenNumber,
  OUT       EFI_PCD_INFO  *PcdInfo
  )
{
  return DxeGetPcdInfo (Guid, TokenNumber, PcdInfo);
}
 
UINTN
EFIAPI
DxeGetPcdInfoGetSku (
  VOID
  )
{
  return (UINTN)mPcdDatabase.DxeDb->SystemSkuId;
}
 
VOID
EFIAPI
DxePcdSetSku (
  IN  UINTN  SkuId
  )
{
  SKU_ID      *SkuIdTable;
  UINTN       Index;
  EFI_STATUS  Status;
 
  DEBUG ((DEBUG_INFO, "PcdDxe - SkuId 0x%lx is to be set.\n", (SKU_ID)SkuId));
 
  if (SkuId == mPcdDatabase.DxeDb->SystemSkuId) {
    //
    // The input SKU Id is equal to current SKU Id, return directly.
    //
    DEBUG ((DEBUG_INFO, "PcdDxe - SkuId is same to current system Sku.\n"));
    return;
  }
 
  if (mPcdDatabase.DxeDb->SystemSkuId != (SKU_ID)0) {
    DEBUG ((DEBUG_ERROR, "PcdDxe - The SKU Id could be changed only once."));
    DEBUG ((
      DEBUG_ERROR,
      "PcdDxe - The SKU Id was set to 0x%lx already, it could not be set to 0x%lx any more.",
      mPcdDatabase.DxeDb->SystemSkuId,
      (SKU_ID)SkuId
      ));
    ASSERT (FALSE);
    return;
  }
 
  SkuIdTable = (SKU_ID *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->SkuIdTableOffset);
  for (Index = 0; Index < SkuIdTable[0]; Index++) {
    if (SkuId == SkuIdTable[Index + 1]) {
      DEBUG ((DEBUG_INFO, "PcdDxe - SkuId is found in SkuId table.\n"));
      Status = UpdatePcdDatabase (SkuId, TRUE);
      if (!EFI_ERROR (Status)) {
        mPcdDatabase.DxeDb->SystemSkuId = (SKU_ID)SkuId;
        DEBUG ((DEBUG_INFO, "PcdDxe - 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, "PcdDxe - Invalid input SkuId, the default SKU Id will be still used.\n"));
  return;
}
 
UINT8
EFIAPI
DxePcdGet8 (
  IN UINTN  TokenNumber
  )
{
  return *((UINT8 *)GetWorker (TokenNumber, sizeof (UINT8)));
}
 
UINT16
EFIAPI
DxePcdGet16 (
  IN UINTN  TokenNumber
  )
{
  return ReadUnaligned16 (GetWorker (TokenNumber, sizeof (UINT16)));
}
 
UINT32
EFIAPI
DxePcdGet32 (
  IN UINTN  TokenNumber
  )
{
  return ReadUnaligned32 (GetWorker (TokenNumber, sizeof (UINT32)));
}
 
UINT64
EFIAPI
DxePcdGet64 (
  IN UINTN  TokenNumber
  )
{
  return ReadUnaligned64 (GetWorker (TokenNumber, sizeof (UINT64)));
}
 
VOID *
EFIAPI
DxePcdGetPtr (
  IN UINTN  TokenNumber
  )
{
  return GetWorker (TokenNumber, 0);
}
 
BOOLEAN
EFIAPI
DxePcdGetBool (
  IN UINTN  TokenNumber
  )
{
  return *((BOOLEAN *)GetWorker (TokenNumber, sizeof (BOOLEAN)));
}
 
UINTN
EFIAPI
DxePcdGetSize (
  IN UINTN  TokenNumber
  )
{
  UINTN    Size;
  UINT32   *LocalTokenNumberTable;
  BOOLEAN  IsPeiDb;
  UINTN    MaxSize;
  UINTN    TmpTokenNumber;
 
  //
  // 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--;
 
  //
  // Backup the TokenNumber passed in as GetPtrTypeSize need the original TokenNumber
  //
  TmpTokenNumber = 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 < mPcdTotalTokenCount + 1);
 
  // 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.
  IsPeiDb = (BOOLEAN)(TokenNumber + 1 < mPeiLocalTokenCount + 1);
 
  TokenNumber = IsPeiDb ? TokenNumber :
                (TokenNumber - mPeiLocalTokenCount);
 
  LocalTokenNumberTable = IsPeiDb ? (UINT32 *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->LocalTokenNumberTableOffset)
                                  : (UINT32 *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->LocalTokenNumberTableOffset);
 
  Size = (LocalTokenNumberTable[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 (TmpTokenNumber, &MaxSize);
  } else {
    return Size;
  }
}
 
UINT8
EFIAPI
DxePcdGet8Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return *((UINT8 *)ExGetWorker (Guid, ExTokenNumber, sizeof (UINT8)));
}
 
UINT16
EFIAPI
DxePcdGet16Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return ReadUnaligned16 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT16)));
}
 
UINT32
EFIAPI
DxePcdGet32Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return ReadUnaligned32 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT32)));
}
 
UINT64
EFIAPI
DxePcdGet64Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return ReadUnaligned64 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT64)));
}
 
VOID *
EFIAPI
DxePcdGetPtrEx (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return ExGetWorker (Guid, ExTokenNumber, 0);
}
 
BOOLEAN
EFIAPI
DxePcdGetBoolEx (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return *((BOOLEAN *)ExGetWorker (Guid, ExTokenNumber, sizeof (BOOLEAN)));
}
 
UINTN
EFIAPI
DxePcdGetSizeEx (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber
  )
{
  return DxePcdGetSize (GetExPcdTokenNumber (Guid, (UINT32)ExTokenNumber));
}
 
EFI_STATUS
EFIAPI
DxePcdSet8 (
  IN UINTN  TokenNumber,
  IN UINT8  Value
  )
{
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
DxePcdSet16 (
  IN UINTN   TokenNumber,
  IN UINT16  Value
  )
{
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
DxePcdSet32 (
  IN UINTN   TokenNumber,
  IN UINT32  Value
  )
{
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
DxePcdSet64 (
  IN UINTN   TokenNumber,
  IN UINT64  Value
  )
{
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
DxePcdSetPtr (
  IN          UINTN  TokenNumber,
  IN OUT      UINTN  *SizeOfBuffer,
  IN          VOID   *Buffer
  )
{
  return SetWorker (TokenNumber, Buffer, SizeOfBuffer, TRUE);
}
 
EFI_STATUS
EFIAPI
DxePcdSetBool (
  IN UINTN    TokenNumber,
  IN BOOLEAN  Value
  )
{
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
DxePcdSet8Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber,
  IN UINT8           Value
  )
{
  return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
DxePcdSet16Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber,
  IN UINT16          Value
  )
{
  //
  // PcdSetNvStoreDefaultId should be set in PEI phase to take effect.
  //
  ASSERT (
    !(CompareGuid (Guid, &gEfiMdeModulePkgTokenSpaceGuid) &&
      (ExTokenNumber == PcdToken (PcdSetNvStoreDefaultId)))
    );
  return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
DxePcdSet32Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber,
  IN UINT32          Value
  )
{
  return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
DxePcdSet64Ex (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber,
  IN UINT64          Value
  )
{
  return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
DxePcdSetPtrEx (
  IN            CONST EFI_GUID  *Guid,
  IN            UINTN           ExTokenNumber,
  IN OUT        UINTN           *SizeOfBuffer,
  IN            VOID            *Buffer
  )
{
  return ExSetWorker (ExTokenNumber, Guid, Buffer, SizeOfBuffer, TRUE);
}
 
EFI_STATUS
EFIAPI
DxePcdSetBoolEx (
  IN CONST EFI_GUID  *Guid,
  IN UINTN           ExTokenNumber,
  IN BOOLEAN         Value
  )
{
  return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));
}
 
EFI_STATUS
EFIAPI
DxeRegisterCallBackOnSet (
  IN  CONST EFI_GUID         *Guid  OPTIONAL,
  IN  UINTN                  TokenNumber,
  IN  PCD_PROTOCOL_CALLBACK  CallBackFunction
  )
{
  EFI_STATUS  Status;
 
  if (CallBackFunction == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Aquire lock to prevent reentrance from TPL_CALLBACK level
  //
  EfiAcquireLock (&mPcdDatabaseLock);
 
  Status = DxeRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction);
 
  EfiReleaseLock (&mPcdDatabaseLock);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
DxeUnRegisterCallBackOnSet (
  IN  CONST EFI_GUID         *Guid  OPTIONAL,
  IN  UINTN                  TokenNumber,
  IN  PCD_PROTOCOL_CALLBACK  CallBackFunction
  )
{
  EFI_STATUS  Status;
 
  if (CallBackFunction == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Aquire lock to prevent reentrance from TPL_CALLBACK level
  //
  EfiAcquireLock (&mPcdDatabaseLock);
 
  Status = DxeUnRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction);
 
  EfiReleaseLock (&mPcdDatabaseLock);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
DxePcdGetNextToken (
  IN CONST EFI_GUID  *Guid  OPTIONAL,
  IN OUT   UINTN     *TokenNumber
  )
{
  EFI_STATUS  Status;
  BOOLEAN     PeiExMapTableEmpty;
  BOOLEAN     DxeExMapTableEmpty;
 
  Status             = EFI_NOT_FOUND;
  PeiExMapTableEmpty = mPeiExMapTableEmpty;
  DxeExMapTableEmpty = mDxeExMapTableEmpty;
 
  //
  // Scan the local token space
  //
  if (Guid == NULL) {
    // 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.
    if (((*TokenNumber + 1 > mPeiNexTokenCount + 1) && (*TokenNumber + 1 <= mPeiLocalTokenCount + 1)) ||
        ((*TokenNumber + 1 > (mPeiLocalTokenCount + mDxeNexTokenCount + 1))))
    {
      return EFI_NOT_FOUND;
    }
 
    (*TokenNumber)++;
    if ((*TokenNumber + 1 > mPeiNexTokenCount + 1) &&
        (*TokenNumber + 1 <= mPeiLocalTokenCount + 1))
    {
      //
      // The first Non-Ex type Token Number for DXE PCD
      // database is mPeiLocalTokenCount + 1
      //
      if (mDxeNexTokenCount > 0) {
        *TokenNumber = mPeiLocalTokenCount + 1;
      } else {
        *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
        return EFI_NOT_FOUND;
      }
    } else if (*TokenNumber + 1 > mDxeNexTokenCount + mPeiLocalTokenCount + 1) {
      *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
      return EFI_NOT_FOUND;
    }
 
    return EFI_SUCCESS;
  }
 
  if (PeiExMapTableEmpty && DxeExMapTableEmpty) {
    return EFI_NOT_FOUND;
  }
 
  if (!PeiExMapTableEmpty) {
    Status = ExGetNextTokeNumber (
               Guid,
               TokenNumber,
               (EFI_GUID *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->GuidTableOffset),
               mPeiGuidTableSize,
               (DYNAMICEX_MAPPING *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->ExMapTableOffset),
               mPeiExMapppingTableSize
               );
  }
 
  if (Status == EFI_SUCCESS) {
    return Status;
  }
 
  if (!DxeExMapTableEmpty) {
    Status = ExGetNextTokeNumber (
               Guid,
               TokenNumber,
               (EFI_GUID *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->GuidTableOffset),
               mDxeGuidTableSize,
               (DYNAMICEX_MAPPING *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->ExMapTableOffset),
               mDxeExMapppingTableSize
               );
  }
 
  return Status;
}
 
EFI_GUID **
GetDistinctTokenSpace (
  IN OUT    UINTN              *ExMapTableSize,
  IN        DYNAMICEX_MAPPING  *ExMapTable,
  IN        EFI_GUID           *GuidTable
  )
{
  EFI_GUID  **DistinctTokenSpace;
  UINTN     OldGuidIndex;
  UINTN     TsIdx;
  UINTN     TempTsIdx;
  UINTN     Idx;
  BOOLEAN   Match;
 
  DistinctTokenSpace = AllocateZeroPool (*ExMapTableSize * sizeof (EFI_GUID *));
  ASSERT (DistinctTokenSpace != NULL);
 
  TsIdx                     = 0;
  OldGuidIndex              = ExMapTable[0].ExGuidIndex;
  DistinctTokenSpace[TsIdx] = &GuidTable[OldGuidIndex];
  for (Idx = 1; Idx < *ExMapTableSize; Idx++) {
    Match        = FALSE;
    OldGuidIndex = ExMapTable[Idx].ExGuidIndex;
    for (TempTsIdx = 0; TempTsIdx <= TsIdx; TempTsIdx++) {
      if (&GuidTable[OldGuidIndex] == DistinctTokenSpace[TempTsIdx]) {
        //
        // Have recorded this GUID.
        //
        Match = TRUE;
        break;
      }
    }
 
    if (!Match) {
      DistinctTokenSpace[++TsIdx] = &GuidTable[OldGuidIndex];
    }
  }
 
  //
  // The total number of Distinct Token Space
  // is TsIdx + 1 because we use TsIdx as a index
  // to the DistinctTokenSpace[]
  //
  *ExMapTableSize = TsIdx + 1;
  return DistinctTokenSpace;
}
 
EFI_STATUS
EFIAPI
DxePcdGetNextTokenSpace (
  IN OUT CONST EFI_GUID  **Guid
  )
{
  UINTN     Idx;
  UINTN     Idx2;
  UINTN     Idx3;
  UINTN     PeiTokenSpaceTableSize;
  UINTN     DxeTokenSpaceTableSize;
  EFI_GUID  **PeiTokenSpaceTable;
  EFI_GUID  **DxeTokenSpaceTable;
  BOOLEAN   Match;
  BOOLEAN   PeiExMapTableEmpty;
  BOOLEAN   DxeExMapTableEmpty;
 
  ASSERT (Guid != NULL);
 
  PeiExMapTableEmpty = mPeiExMapTableEmpty;
  DxeExMapTableEmpty = mDxeExMapTableEmpty;
 
  if (PeiExMapTableEmpty && DxeExMapTableEmpty) {
    return EFI_NOT_FOUND;
  }
 
  if (TmpTokenSpaceBuffer[0] == NULL) {
    PeiTokenSpaceTableSize = 0;
 
    if (!PeiExMapTableEmpty) {
      PeiTokenSpaceTableSize = mPeiExMapppingTableSize / sizeof (DYNAMICEX_MAPPING);
      PeiTokenSpaceTable     = GetDistinctTokenSpace (
                                 &PeiTokenSpaceTableSize,
                                 (DYNAMICEX_MAPPING *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->ExMapTableOffset),
                                 (EFI_GUID *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->GuidTableOffset)
                                 );
      CopyMem (TmpTokenSpaceBuffer, PeiTokenSpaceTable, sizeof (EFI_GUID *) * PeiTokenSpaceTableSize);
      TmpTokenSpaceBufferCount = PeiTokenSpaceTableSize;
      FreePool (PeiTokenSpaceTable);
    }
 
    if (!DxeExMapTableEmpty) {
      DxeTokenSpaceTableSize = mDxeExMapppingTableSize / sizeof (DYNAMICEX_MAPPING);
      DxeTokenSpaceTable     = GetDistinctTokenSpace (
                                 &DxeTokenSpaceTableSize,
                                 (DYNAMICEX_MAPPING *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->ExMapTableOffset),
                                 (EFI_GUID *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->GuidTableOffset)
                                 );
 
      //
      // Make sure EFI_GUID in DxeTokenSpaceTable does not exist in PeiTokenSpaceTable
      //
      for (Idx2 = 0, Idx3 = PeiTokenSpaceTableSize; Idx2 < DxeTokenSpaceTableSize; Idx2++) {
        Match = FALSE;
        for (Idx = 0; Idx < PeiTokenSpaceTableSize; Idx++) {
          if (CompareGuid (TmpTokenSpaceBuffer[Idx], DxeTokenSpaceTable[Idx2])) {
            Match = TRUE;
            break;
          }
        }
 
        if (!Match) {
          TmpTokenSpaceBuffer[Idx3++] = DxeTokenSpaceTable[Idx2];
        }
      }
 
      TmpTokenSpaceBufferCount = Idx3;
      FreePool (DxeTokenSpaceTable);
    }
  }
 
  if (*Guid == NULL) {
    *Guid = TmpTokenSpaceBuffer[0];
    return EFI_SUCCESS;
  }
 
  for (Idx = 0; Idx < TmpTokenSpaceBufferCount; Idx++) {
    if (CompareGuid (*Guid, TmpTokenSpaceBuffer[Idx])) {
      if (Idx == TmpTokenSpaceBufferCount - 1) {
        //
        // It has been the last token namespace.
        //
        *Guid = NULL;
        return EFI_NOT_FOUND;
      } else {
        Idx++;
        *Guid = TmpTokenSpaceBuffer[Idx];
        return EFI_SUCCESS;
      }
    }
  }
 
  return EFI_NOT_FOUND;
}