[mirror_edk2.git] / EdkModulePkg / Universal / PCD / Dxe / Pcd.c

/** @file\r
PCD DXE driver\r
\r
Copyright (c) 2006 - 2007, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
\r
Module Name: Pcd.c\r
\r
**/\r
\r
#include "Service.h"\r
\r
EFI_LOCK mPcdDatabaseLock = EFI_INITIALIZE_LOCK_VARIABLE(EFI_TPL_CALLBACK);\r
\r
PCD_PROTOCOL mPcdInstance = {\r
  DxePcdSetSku,\r
\r
  DxePcdGet8,\r
  DxePcdGet16,\r
  DxePcdGet32,\r
  DxePcdGet64,\r
  DxePcdGetPtr,\r
  DxePcdGetBool,\r
  DxePcdGetSize,\r
\r
  DxePcdGet8Ex,\r
  DxePcdGet16Ex,\r
  DxePcdGet32Ex,\r
  DxePcdGet64Ex,\r
  DxePcdGetPtrEx,\r
  DxePcdGetBoolEx,\r
  DxePcdGetSizeEx,\r
\r
  DxePcdSet8,\r
  DxePcdSet16,\r
  DxePcdSet32,\r
  DxePcdSet64,\r
  DxePcdSetPtr,\r
  DxePcdSetBool,\r
\r
  DxePcdSet8Ex,\r
  DxePcdSet16Ex,\r
  DxePcdSet32Ex,\r
  DxePcdSet64Ex,\r
  DxePcdSetPtrEx,\r
  DxePcdSetBoolEx,\r
\r
  DxeRegisterCallBackOnSet,\r
  DxeUnRegisterCallBackOnSet,\r
  DxePcdGetNextToken,\r
  DxePcdGetNextTokenSpace\r
};\r
\r
\r
//\r
// Static global to reduce the code size\r
//\r
static EFI_HANDLE mNewHandle = NULL;\r
\r
EFI_STATUS\r
EFIAPI\r
PcdDxeInit (\r
  IN EFI_HANDLE           ImageHandle,\r
  IN EFI_SYSTEM_TABLE     *SystemTable\r
  )\r
{\r
  EFI_STATUS          Status;\r
\r
  //\r
  // Make sure the Pcd Protocol is not already installed in the system\r
  //\r
\r
  ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gPcdProtocolGuid);\r
\r
  BuildPcdDxeDataBase ();\r
\r
  Status = gBS->InstallProtocolInterface (\r
                  &mNewHandle,\r
                  &gPcdProtocolGuid,\r
                  EFI_NATIVE_INTERFACE,\r
                  &mPcdInstance\r
                  );\r
\r
  ASSERT_EFI_ERROR (Status);\r
\r
  return EFI_SUCCESS;\r
\r
}\r
\r
\r
VOID\r
EFIAPI\r
DxePcdSetSku (\r
  IN  UINTN         SkuId\r
  )\r
{\r
  mPcdDatabase->PeiDb.Init.SystemSkuId = (SKU_ID) SkuId;\r
  \r
  return;\r
}\r
\r
\r
\r
UINT8\r
EFIAPI\r
DxePcdGet8 (\r
  IN UINTN                    TokenNumber\r
  )\r
{\r
  return *((UINT8 *) GetWorker (TokenNumber, sizeof (UINT8)));\r
}\r
\r
\r
\r
UINT16\r
EFIAPI\r
DxePcdGet16 (\r
  IN UINTN                    TokenNumber\r
  )\r
{\r
  return ReadUnaligned16 (GetWorker (TokenNumber, sizeof (UINT16)));\r
}\r
\r
\r
\r
UINT32\r
EFIAPI\r
DxePcdGet32 (\r
  IN UINTN                    TokenNumber\r
  )\r
{\r
  return ReadUnaligned32 (GetWorker (TokenNumber, sizeof (UINT32)));\r
}\r
\r
\r
\r
UINT64\r
EFIAPI\r
DxePcdGet64 (\r
  IN UINTN                     TokenNumber\r
  )\r
{\r
  return ReadUnaligned64(GetWorker (TokenNumber, sizeof (UINT64)));\r
}\r
\r
\r
\r
VOID *\r
EFIAPI\r
DxePcdGetPtr (\r
  IN UINTN                     TokenNumber\r
  )\r
{\r
  return GetWorker (TokenNumber, 0);\r
}\r
\r
\r
\r
BOOLEAN\r
EFIAPI\r
DxePcdGetBool (\r
  IN UINTN                     TokenNumber\r
  )\r
{\r
  return *((BOOLEAN *) GetWorker (TokenNumber, sizeof (BOOLEAN)));\r
}\r
\r
\r
\r
UINTN\r
EFIAPI\r
DxePcdGetSize (\r
  IN UINTN                     TokenNumber\r
  )\r
{\r
  UINTN   Size;\r
  UINT32  *LocalTokenNumberTable;\r
  BOOLEAN IsPeiDb;\r
  UINTN   MaxSize;\r
  UINTN   TmpTokenNumber;\r
  //\r
  // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.\r
  // We have to decrement TokenNumber by 1 to make it usable\r
  // as the array index.\r
  //\r
  TokenNumber--;\r
\r
  //\r
  // Backup the TokenNumber passed in as GetPtrTypeSize need the original TokenNumber\r
  // \r
  TmpTokenNumber = TokenNumber;\r
\r
  // EBC compiler is very choosy. It may report warning about comparison\r
  // between UINTN and 0 . So we add 1 in each size of the \r
  // comparison.\r
  ASSERT (TokenNumber + 1 < PCD_TOTAL_TOKEN_NUMBER + 1);\r
\r
  // EBC compiler is very choosy. It may report warning about comparison\r
  // between UINTN and 0 . So we add 1 in each size of the \r
  // comparison.\r
  IsPeiDb = (BOOLEAN) (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);\r
  \r
  TokenNumber = IsPeiDb ? TokenNumber : \r
                          (TokenNumber - PEI_LOCAL_TOKEN_NUMBER);\r
\r
  LocalTokenNumberTable = IsPeiDb ? mPcdDatabase->PeiDb.Init.LocalTokenNumberTable \r
                                  : mPcdDatabase->DxeDb.Init.LocalTokenNumberTable;\r
\r
  Size = (LocalTokenNumberTable[TokenNumber] & PCD_DATUM_TYPE_ALL_SET) >> PCD_DATUM_TYPE_SHIFT;\r
\r
  if (Size == 0) {\r
    //\r
    // For pointer type, we need to scan the SIZE_TABLE to get the current size.\r
    //\r
    return GetPtrTypeSize (TmpTokenNumber, &MaxSize);\r
  } else {\r
    return Size;\r
  }\r
\r
}\r
\r
\r
\r
UINT8\r
EFIAPI\r
DxePcdGet8Ex (\r
  IN CONST EFI_GUID         *Guid,\r
  IN UINTN                 ExTokenNumber\r
  )\r
{\r
  return *((UINT8 *) ExGetWorker (Guid, ExTokenNumber, sizeof(UINT8)));\r
}\r
\r
\r
\r
UINT16\r
EFIAPI\r
DxePcdGet16Ex (\r
  IN CONST EFI_GUID        *Guid,\r
  IN UINTN                ExTokenNumber\r
  )\r
{\r
  return ReadUnaligned16 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT16)));\r
}\r
\r
\r
\r
UINT32\r
EFIAPI\r
DxePcdGet32Ex (\r
  IN CONST EFI_GUID        *Guid,\r
  IN UINTN                 ExTokenNumber\r
  )\r
{\r
  return ReadUnaligned32 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT32)));\r
}\r
\r
\r
\r
UINT64\r
EFIAPI\r
DxePcdGet64Ex (\r
  IN CONST EFI_GUID        *Guid,\r
  IN UINTN                 ExTokenNumber\r
  )\r
{\r
  return ReadUnaligned64 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT64)));\r
}\r
\r
\r
\r
VOID *\r
EFIAPI\r
DxePcdGetPtrEx (\r
  IN CONST EFI_GUID        *Guid,\r
  IN UINTN                 ExTokenNumber\r
  )\r
{\r
  return  ExGetWorker (Guid, ExTokenNumber, 0);\r
}\r
\r
\r
\r
BOOLEAN\r
EFIAPI\r
DxePcdGetBoolEx (\r
  IN CONST EFI_GUID        *Guid,\r
  IN UINTN                 ExTokenNumber\r
  )\r
{\r
  return *((BOOLEAN *) ExGetWorker (Guid, ExTokenNumber, sizeof(BOOLEAN)));\r
}\r
\r
\r
\r
UINTN\r
EFIAPI\r
DxePcdGetSizeEx (\r
  IN CONST EFI_GUID        *Guid,\r
  IN UINTN                 ExTokenNumber\r
  )\r
{\r
  return DxePcdGetSize(GetExPcdTokenNumber (Guid, (UINT32) ExTokenNumber));\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSet8 (\r
  IN UINTN              TokenNumber,\r
  IN UINT8              Value\r
  )\r
{\r
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSet16 (\r
  IN UINTN              TokenNumber,\r
  IN UINT16             Value\r
  )\r
{\r
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSet32 (\r
  IN UINTN              TokenNumber,\r
  IN UINT32             Value\r
  )\r
{\r
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSet64 (\r
  IN UINTN              TokenNumber,\r
  IN UINT64             Value\r
  )\r
{\r
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSetPtr (\r
  IN          UINTN              TokenNumber,\r
  IN OUT      UINTN              *SizeOfBuffer,\r
  IN          VOID               *Buffer\r
  )\r
{\r
  return SetWorker (TokenNumber, Buffer, SizeOfBuffer, TRUE);\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSetBool (\r
  IN UINTN              TokenNumber,\r
  IN BOOLEAN            Value\r
  )\r
{\r
  return SetValueWorker (TokenNumber, &Value, sizeof (Value));\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSet8Ex (\r
  IN CONST EFI_GUID         *Guid,\r
  IN UINTN                  ExTokenNumber,\r
  IN UINT8                  Value\r
  )\r
{\r
  return  ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSet16Ex (\r
  IN CONST EFI_GUID    *Guid,\r
  IN UINTN             ExTokenNumber,\r
  IN UINT16            Value\r
  )\r
{\r
  return  ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSet32Ex (\r
  IN CONST EFI_GUID     *Guid,\r
  IN UINTN              ExTokenNumber,\r
  IN UINT32             Value\r
  )\r
{\r
  return  ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSet64Ex (\r
  IN CONST EFI_GUID    *Guid,\r
  IN UINTN             ExTokenNumber,\r
  IN UINT64            Value\r
  )\r
{\r
  return  ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSetPtrEx (\r
  IN            CONST EFI_GUID         *Guid,\r
  IN            UINTN                  ExTokenNumber,\r
  IN OUT        UINTN                  *SizeOfBuffer,\r
  IN            VOID                   *Buffer\r
  )\r
{\r
  return  ExSetWorker(ExTokenNumber, Guid, Buffer, SizeOfBuffer, TRUE);\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdSetBoolEx (\r
  IN CONST EFI_GUID    *Guid,\r
  IN UINTN             ExTokenNumber,\r
  IN BOOLEAN           Value\r
  )\r
{\r
  return  ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));\r
}\r
\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxeRegisterCallBackOnSet (\r
  IN  CONST EFI_GUID          *Guid, OPTIONAL\r
  IN  UINTN                   TokenNumber,\r
  IN  PCD_PROTOCOL_CALLBACK   CallBackFunction\r
  )\r
{\r
  EFI_STATUS Status;\r
  \r
  ASSERT (CallBackFunction != NULL);\r
  \r
  //\r
  // Aquire lock to prevent reentrance from TPL_CALLBACK level\r
  //\r
  EfiAcquireLock (&mPcdDatabaseLock);\r
\r
  Status = DxeRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction);\r
\r
  EfiReleaseLock (&mPcdDatabaseLock);\r
  \r
  return Status;\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxeUnRegisterCallBackOnSet (\r
  IN  CONST EFI_GUID          *Guid, OPTIONAL\r
  IN  UINTN                   TokenNumber,\r
  IN  PCD_PROTOCOL_CALLBACK   CallBackFunction\r
  )\r
{\r
  EFI_STATUS Status;\r
  \r
  ASSERT (CallBackFunction != NULL);\r
\r
  //\r
  // Aquire lock to prevent reentrance from TPL_CALLBACK level\r
  //\r
  EfiAcquireLock (&mPcdDatabaseLock);\r
  \r
  Status = DxeUnRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction);\r
\r
  EfiReleaseLock (&mPcdDatabaseLock);\r
  \r
  return Status;\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdGetNextToken (\r
  IN CONST EFI_GUID         *Guid, OPTIONAL\r
  IN OUT   UINTN            *TokenNumber\r
  )\r
{\r
  EFI_STATUS          Status;\r
\r
  if (!FeaturePcdGet (PcdDxePcdDatabaseTraverseEnabled)) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  Status = EFI_NOT_FOUND;\r
  //\r
  // Scan the local token space\r
  //\r
  if (Guid == NULL) {\r
    // EBC compiler is very choosy. It may report warning about comparison\r
    // between UINTN and 0 . So we add 1 in each size of the \r
    // comparison.\r
    if (((*TokenNumber + 1 > PEI_NEX_TOKEN_NUMBER + 1) && (*TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1)) ||\r
        ((*TokenNumber + 1 > (PEI_LOCAL_TOKEN_NUMBER + DXE_NEX_TOKEN_NUMBER + 1)))) {\r
        return EFI_NOT_FOUND;\r
    }\r
    \r
    (*TokenNumber)++;\r
    if ((*TokenNumber + 1 > PEI_NEX_TOKEN_NUMBER + 1) &&\r
        (*TokenNumber <= PEI_LOCAL_TOKEN_NUMBER)) {\r
      //\r
      // The first Non-Ex type Token Number for DXE PCD \r
      // database is PEI_LOCAL_TOKEN_NUMBER\r
      //\r
      *TokenNumber = PEI_LOCAL_TOKEN_NUMBER;\r
    } else if (*TokenNumber + 1 > DXE_NEX_TOKEN_NUMBER + PEI_LOCAL_TOKEN_NUMBER + 1) {\r
      *TokenNumber = PCD_INVALID_TOKEN_NUMBER;\r
    }\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (PEI_EXMAP_TABLE_EMPTY && DXE_EXMAP_TABLE_EMPTY) {\r
    *TokenNumber = PCD_INVALID_TOKEN_NUMBER;\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  if (!PEI_EXMAP_TABLE_EMPTY) {\r
    Status = ExGetNextTokeNumber (\r
                        Guid,\r
                        TokenNumber,\r
                        mPcdDatabase->PeiDb.Init.GuidTable,\r
                        sizeof(mPcdDatabase->PeiDb.Init.GuidTable),\r
                        mPcdDatabase->PeiDb.Init.ExMapTable,\r
                        sizeof(mPcdDatabase->PeiDb.Init.ExMapTable)\r
                        );\r
  }\r
\r
  if (Status == EFI_SUCCESS) {\r
    return Status;\r
  }\r
\r
  if (!DXE_EXMAP_TABLE_EMPTY) {\r
    Status = ExGetNextTokeNumber (\r
                        Guid,\r
                        TokenNumber,\r
                        mPcdDatabase->DxeDb.Init.GuidTable,\r
                        sizeof(mPcdDatabase->DxeDb.Init.GuidTable),\r
                        mPcdDatabase->DxeDb.Init.ExMapTable,\r
                        sizeof(mPcdDatabase->DxeDb.Init.ExMapTable)\r
                        );\r
  }\r
\r
  return Status;\r
}\r
\r
\r
EFI_GUID **\r
GetDistinctTokenSpace (\r
  IN OUT    UINTN             *ExMapTableSize,\r
  IN        DYNAMICEX_MAPPING *ExMapTable,\r
  IN        EFI_GUID          *GuidTable\r
  )\r
{\r
  EFI_GUID  **DistinctTokenSpace;\r
  UINTN     OldGuidIndex;\r
  UINTN     TsIdx;\r
  UINTN     Idx;\r
\r
\r
  DistinctTokenSpace = AllocateZeroPool (*ExMapTableSize * sizeof (EFI_GUID *));\r
  ASSERT (DistinctTokenSpace != NULL);\r
\r
  TsIdx = 0;\r
  OldGuidIndex = ExMapTable[0].ExGuidIndex;\r
  DistinctTokenSpace[TsIdx] = &GuidTable[OldGuidIndex];\r
  for (Idx = 1; Idx < *ExMapTableSize; Idx++) {\r
    if (ExMapTable[Idx].ExGuidIndex != OldGuidIndex) {\r
      OldGuidIndex = ExMapTable[Idx].ExGuidIndex;\r
      DistinctTokenSpace[++TsIdx] = &GuidTable[OldGuidIndex];\r
    }\r
  }\r
\r
  //\r
  // The total number of Distinct Token Space\r
  // is TsIdx + 1 because we use TsIdx as a index\r
  // to the DistinctTokenSpace[]\r
  //\r
  *ExMapTableSize = TsIdx + 1;\r
  return DistinctTokenSpace;\r
    \r
}\r
  \r
//\r
// Just pre-allocate a memory buffer that is big enough to\r
// host all distinct TokenSpace guid in both\r
// PEI ExMap and DXE ExMap.\r
//\r
STATIC EFI_GUID *TmpTokenSpaceBuffer[PEI_EXMAPPING_TABLE_SIZE + DXE_EXMAPPING_TABLE_SIZE] = { 0 };\r
\r
EFI_STATUS\r
EFIAPI\r
DxePcdGetNextTokenSpace (\r
  IN OUT CONST EFI_GUID               **Guid\r
  )\r
{\r
  UINTN               Idx;\r
  UINTN               Idx2;\r
  UINTN               Idx3;\r
  UINTN               PeiTokenSpaceTableSize;\r
  UINTN               DxeTokenSpaceTableSize;\r
  EFI_GUID            **PeiTokenSpaceTable;\r
  EFI_GUID            **DxeTokenSpaceTable;\r
  BOOLEAN             Match;\r
\r
  if (!FeaturePcdGet (PcdDxePcdDatabaseTraverseEnabled)) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  ASSERT (Guid != NULL);\r
  \r
  if (PEI_EXMAP_TABLE_EMPTY && DXE_EXMAP_TABLE_EMPTY) {\r
    if (*Guid != NULL) {\r
      return EFI_NOT_FOUND;\r
    } else {\r
      return EFI_SUCCESS;\r
    }\r
  }\r
  \r
  \r
  if (TmpTokenSpaceBuffer[0] == NULL) {\r
    PeiTokenSpaceTableSize = 0;\r
\r
    if (!PEI_EXMAP_TABLE_EMPTY) {\r
      PeiTokenSpaceTableSize = PEI_EXMAPPING_TABLE_SIZE;\r
      PeiTokenSpaceTable = GetDistinctTokenSpace (&PeiTokenSpaceTableSize,\r
                            mPcdDatabase->PeiDb.Init.ExMapTable,\r
                            mPcdDatabase->PeiDb.Init.GuidTable\r
                            );\r
      CopyMem (TmpTokenSpaceBuffer, PeiTokenSpaceTable, sizeof (EFI_GUID*) * PeiTokenSpaceTableSize);\r
    }\r
\r
    if (!DXE_EXMAP_TABLE_EMPTY) {\r
      DxeTokenSpaceTableSize = DXE_EXMAPPING_TABLE_SIZE;\r
      DxeTokenSpaceTable = GetDistinctTokenSpace (&DxeTokenSpaceTableSize,\r
                            mPcdDatabase->DxeDb.Init.ExMapTable,\r
                            mPcdDatabase->DxeDb.Init.GuidTable\r
                            );\r
\r
      //\r
      // Make sure EFI_GUID in DxeTokenSpaceTable does not exist in PeiTokenSpaceTable\r
      //\r
      for (Idx2 = 0, Idx3 = PeiTokenSpaceTableSize; Idx2 < DxeTokenSpaceTableSize; Idx2++) {\r
        Match = FALSE;\r
        for (Idx = 0; Idx < PeiTokenSpaceTableSize; Idx++) {\r
          if (CompareGuid (TmpTokenSpaceBuffer[Idx], DxeTokenSpaceTable[Idx2])) {\r
            Match = TRUE;\r
            break;\r
          }\r
        }\r
        if (!Match) {\r
          TmpTokenSpaceBuffer[Idx3++] = DxeTokenSpaceTable[Idx2];\r
        }\r
      }\r
    }\r
  }\r
\r
  if (*Guid == NULL) {\r
    *Guid = TmpTokenSpaceBuffer[0];\r
    return EFI_SUCCESS;\r
  }\r
  \r
  for (Idx = 0; Idx < (PEI_EXMAPPING_TABLE_SIZE + DXE_EXMAPPING_TABLE_SIZE); Idx++) {\r
    if(CompareGuid (*Guid, TmpTokenSpaceBuffer[Idx])) {\r
      Idx++;\r
      *Guid = TmpTokenSpaceBuffer[Idx];\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  return EFI_NOT_FOUND;\r
\r
}\r
\r
\r
Commit	Line	Data
	1	/** @file\r
	2	PCD DXE driver\r
	3	\r
	4	Copyright (c) 2006 - 2007, Intel Corporation\r
	5	All rights reserved. This program and the accompanying materials\r
	6	are licensed and made available under the terms and conditions of the BSD License\r
	7	which accompanies this distribution. The full text of the license may be found at\r
	8	http://opensource.org/licenses/bsd-license.php\r
	9	\r
	10	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	11	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	12	\r
	13	\r
	14	Module Name: Pcd.c\r
	15	\r
	16	**/\r
	17	\r
	18	#include "Service.h"\r
	19	\r
	20	EFI_LOCK mPcdDatabaseLock = EFI_INITIALIZE_LOCK_VARIABLE(EFI_TPL_CALLBACK);\r
	21	\r
	22	PCD_PROTOCOL mPcdInstance = {\r
	23	DxePcdSetSku,\r
	24	\r
	25	DxePcdGet8,\r
	26	DxePcdGet16,\r
	27	DxePcdGet32,\r
	28	DxePcdGet64,\r
	29	DxePcdGetPtr,\r
	30	DxePcdGetBool,\r
	31	DxePcdGetSize,\r
	32	\r
	33	DxePcdGet8Ex,\r
	34	DxePcdGet16Ex,\r
	35	DxePcdGet32Ex,\r
	36	DxePcdGet64Ex,\r
	37	DxePcdGetPtrEx,\r
	38	DxePcdGetBoolEx,\r
	39	DxePcdGetSizeEx,\r
	40	\r
	41	DxePcdSet8,\r
	42	DxePcdSet16,\r
	43	DxePcdSet32,\r
	44	DxePcdSet64,\r
	45	DxePcdSetPtr,\r
	46	DxePcdSetBool,\r
	47	\r
	48	DxePcdSet8Ex,\r
	49	DxePcdSet16Ex,\r
	50	DxePcdSet32Ex,\r
	51	DxePcdSet64Ex,\r
	52	DxePcdSetPtrEx,\r
	53	DxePcdSetBoolEx,\r
	54	\r
	55	DxeRegisterCallBackOnSet,\r
	56	DxeUnRegisterCallBackOnSet,\r
	57	DxePcdGetNextToken,\r
	58	DxePcdGetNextTokenSpace\r
	59	};\r
	60	\r
	61	\r
	62	//\r
	63	// Static global to reduce the code size\r
	64	//\r
	65	static EFI_HANDLE mNewHandle = NULL;\r
	66	\r
	67	EFI_STATUS\r
	68	EFIAPI\r
	69	PcdDxeInit (\r
	70	IN EFI_HANDLE ImageHandle,\r
	71	IN EFI_SYSTEM_TABLE *SystemTable\r
	72	)\r
	73	{\r
	74	EFI_STATUS Status;\r
	75	\r
	76	//\r
	77	// Make sure the Pcd Protocol is not already installed in the system\r
	78	//\r
	79	\r
	80	ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gPcdProtocolGuid);\r
	81	\r
	82	BuildPcdDxeDataBase ();\r
	83	\r
	84	Status = gBS->InstallProtocolInterface (\r
	85	&mNewHandle,\r
	86	&gPcdProtocolGuid,\r
	87	EFI_NATIVE_INTERFACE,\r
	88	&mPcdInstance\r
	89	);\r
	90	\r
	91	ASSERT_EFI_ERROR (Status);\r
	92	\r
	93	return EFI_SUCCESS;\r
	94	\r
	95	}\r
	96	\r
	97	\r
	98	VOID\r
	99	EFIAPI\r
	100	DxePcdSetSku (\r
	101	IN UINTN SkuId\r
	102	)\r
	103	{\r
	104	mPcdDatabase->PeiDb.Init.SystemSkuId = (SKU_ID) SkuId;\r
	105	\r
	106	return;\r
	107	}\r
	108	\r
	109	\r
	110	\r
	111	UINT8\r
	112	EFIAPI\r
	113	DxePcdGet8 (\r
	114	IN UINTN TokenNumber\r
	115	)\r
	116	{\r
	117	return ((UINT8 ) GetWorker (TokenNumber, sizeof (UINT8)));\r
	118	}\r
	119	\r
	120	\r
	121	\r
	122	UINT16\r
	123	EFIAPI\r
	124	DxePcdGet16 (\r
	125	IN UINTN TokenNumber\r
	126	)\r
	127	{\r
	128	return ReadUnaligned16 (GetWorker (TokenNumber, sizeof (UINT16)));\r
	129	}\r
	130	\r
	131	\r
	132	\r
	133	UINT32\r
	134	EFIAPI\r
	135	DxePcdGet32 (\r
	136	IN UINTN TokenNumber\r
	137	)\r
	138	{\r
	139	return ReadUnaligned32 (GetWorker (TokenNumber, sizeof (UINT32)));\r
	140	}\r
	141	\r
	142	\r
	143	\r
	144	UINT64\r
	145	EFIAPI\r
	146	DxePcdGet64 (\r
	147	IN UINTN TokenNumber\r
	148	)\r
	149	{\r
	150	return ReadUnaligned64(GetWorker (TokenNumber, sizeof (UINT64)));\r
	151	}\r
	152	\r
	153	\r
	154	\r
	155	VOID *\r
	156	EFIAPI\r
	157	DxePcdGetPtr (\r
	158	IN UINTN TokenNumber\r
	159	)\r
	160	{\r
	161	return GetWorker (TokenNumber, 0);\r
	162	}\r
	163	\r
	164	\r
	165	\r
	166	BOOLEAN\r
	167	EFIAPI\r
	168	DxePcdGetBool (\r
	169	IN UINTN TokenNumber\r
	170	)\r
	171	{\r
	172	return ((BOOLEAN ) GetWorker (TokenNumber, sizeof (BOOLEAN)));\r
	173	}\r
	174	\r
	175	\r
	176	\r
	177	UINTN\r
	178	EFIAPI\r
	179	DxePcdGetSize (\r
	180	IN UINTN TokenNumber\r
	181	)\r
	182	{\r
	183	UINTN Size;\r
	184	UINT32 *LocalTokenNumberTable;\r
	185	BOOLEAN IsPeiDb;\r
	186	UINTN MaxSize;\r
	187	UINTN TmpTokenNumber;\r
	188	//\r
	189	// TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.\r
	190	// We have to decrement TokenNumber by 1 to make it usable\r
	191	// as the array index.\r
	192	//\r
	193	TokenNumber--;\r
	194	\r
	195	//\r
	196	// Backup the TokenNumber passed in as GetPtrTypeSize need the original TokenNumber\r
	197	// \r
	198	TmpTokenNumber = TokenNumber;\r
	199	\r
	200	// EBC compiler is very choosy. It may report warning about comparison\r
	201	// between UINTN and 0 . So we add 1 in each size of the \r
	202	// comparison.\r
	203	ASSERT (TokenNumber + 1 < PCD_TOTAL_TOKEN_NUMBER + 1);\r
	204	\r
	205	// EBC compiler is very choosy. It may report warning about comparison\r
	206	// between UINTN and 0 . So we add 1 in each size of the \r
	207	// comparison.\r
	208	IsPeiDb = (BOOLEAN) (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);\r
	209	\r
	210	TokenNumber = IsPeiDb ? TokenNumber : \r
	211	(TokenNumber - PEI_LOCAL_TOKEN_NUMBER);\r
	212	\r
	213	LocalTokenNumberTable = IsPeiDb ? mPcdDatabase->PeiDb.Init.LocalTokenNumberTable \r
	214	: mPcdDatabase->DxeDb.Init.LocalTokenNumberTable;\r
	215	\r
	216	Size = (LocalTokenNumberTable[TokenNumber] & PCD_DATUM_TYPE_ALL_SET) >> PCD_DATUM_TYPE_SHIFT;\r
	217	\r
	218	if (Size == 0) {\r
	219	//\r
	220	// For pointer type, we need to scan the SIZE_TABLE to get the current size.\r
	221	//\r
	222	return GetPtrTypeSize (TmpTokenNumber, &MaxSize);\r
	223	} else {\r
	224	return Size;\r
	225	}\r
	226	\r
	227	}\r
	228	\r
	229	\r
	230	\r
	231	UINT8\r
	232	EFIAPI\r
	233	DxePcdGet8Ex (\r
	234	IN CONST EFI_GUID *Guid,\r
	235	IN UINTN ExTokenNumber\r
	236	)\r
	237	{\r
	238	return ((UINT8 ) ExGetWorker (Guid, ExTokenNumber, sizeof(UINT8)));\r
	239	}\r
	240	\r
	241	\r
	242	\r
	243	UINT16\r
	244	EFIAPI\r
	245	DxePcdGet16Ex (\r
	246	IN CONST EFI_GUID *Guid,\r
	247	IN UINTN ExTokenNumber\r
	248	)\r
	249	{\r
	250	return ReadUnaligned16 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT16)));\r
	251	}\r
	252	\r
	253	\r
	254	\r
	255	UINT32\r
	256	EFIAPI\r
	257	DxePcdGet32Ex (\r
	258	IN CONST EFI_GUID *Guid,\r
	259	IN UINTN ExTokenNumber\r
	260	)\r
	261	{\r
	262	return ReadUnaligned32 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT32)));\r
	263	}\r
	264	\r
	265	\r
	266	\r
	267	UINT64\r
	268	EFIAPI\r
	269	DxePcdGet64Ex (\r
	270	IN CONST EFI_GUID *Guid,\r
	271	IN UINTN ExTokenNumber\r
	272	)\r
	273	{\r
	274	return ReadUnaligned64 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT64)));\r
	275	}\r
	276	\r
	277	\r
	278	\r
	279	VOID *\r
	280	EFIAPI\r
	281	DxePcdGetPtrEx (\r
	282	IN CONST EFI_GUID *Guid,\r
	283	IN UINTN ExTokenNumber\r
	284	)\r
	285	{\r
	286	return ExGetWorker (Guid, ExTokenNumber, 0);\r
	287	}\r
	288	\r
	289	\r
	290	\r
	291	BOOLEAN\r
	292	EFIAPI\r
	293	DxePcdGetBoolEx (\r
	294	IN CONST EFI_GUID *Guid,\r
	295	IN UINTN ExTokenNumber\r
	296	)\r
	297	{\r
	298	return ((BOOLEAN ) ExGetWorker (Guid, ExTokenNumber, sizeof(BOOLEAN)));\r
	299	}\r
	300	\r
	301	\r
	302	\r
	303	UINTN\r
	304	EFIAPI\r
	305	DxePcdGetSizeEx (\r
	306	IN CONST EFI_GUID *Guid,\r
	307	IN UINTN ExTokenNumber\r
	308	)\r
	309	{\r
	310	return DxePcdGetSize(GetExPcdTokenNumber (Guid, (UINT32) ExTokenNumber));\r
	311	}\r
	312	\r
	313	\r
	314	\r
	315	EFI_STATUS\r
	316	EFIAPI\r
	317	DxePcdSet8 (\r
	318	IN UINTN TokenNumber,\r
	319	IN UINT8 Value\r
	320	)\r
	321	{\r
	322	return SetValueWorker (TokenNumber, &Value, sizeof (Value));\r
	323	}\r
	324	\r
	325	\r
	326	\r
	327	EFI_STATUS\r
	328	EFIAPI\r
	329	DxePcdSet16 (\r
	330	IN UINTN TokenNumber,\r
	331	IN UINT16 Value\r
	332	)\r
	333	{\r
	334	return SetValueWorker (TokenNumber, &Value, sizeof (Value));\r
	335	}\r
	336	\r
	337	\r
	338	\r
	339	EFI_STATUS\r
	340	EFIAPI\r
	341	DxePcdSet32 (\r
	342	IN UINTN TokenNumber,\r
	343	IN UINT32 Value\r
	344	)\r
	345	{\r
	346	return SetValueWorker (TokenNumber, &Value, sizeof (Value));\r
	347	}\r
	348	\r
	349	\r
	350	\r
	351	EFI_STATUS\r
	352	EFIAPI\r
	353	DxePcdSet64 (\r
	354	IN UINTN TokenNumber,\r
	355	IN UINT64 Value\r
	356	)\r
	357	{\r
	358	return SetValueWorker (TokenNumber, &Value, sizeof (Value));\r
	359	}\r
	360	\r
	361	\r
	362	\r
	363	EFI_STATUS\r
	364	EFIAPI\r
	365	DxePcdSetPtr (\r
	366	IN UINTN TokenNumber,\r
	367	IN OUT UINTN *SizeOfBuffer,\r
	368	IN VOID *Buffer\r
	369	)\r
	370	{\r
	371	return SetWorker (TokenNumber, Buffer, SizeOfBuffer, TRUE);\r
	372	}\r
	373	\r
	374	\r
	375	\r
	376	EFI_STATUS\r
	377	EFIAPI\r
	378	DxePcdSetBool (\r
	379	IN UINTN TokenNumber,\r
	380	IN BOOLEAN Value\r
	381	)\r
	382	{\r
	383	return SetValueWorker (TokenNumber, &Value, sizeof (Value));\r
	384	}\r
	385	\r
	386	\r
	387	\r
	388	EFI_STATUS\r
	389	EFIAPI\r
	390	DxePcdSet8Ex (\r
	391	IN CONST EFI_GUID *Guid,\r
	392	IN UINTN ExTokenNumber,\r
	393	IN UINT8 Value\r
	394	)\r
	395	{\r
	396	return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));\r
	397	}\r
	398	\r
	399	\r
	400	\r
	401	EFI_STATUS\r
	402	EFIAPI\r
	403	DxePcdSet16Ex (\r
	404	IN CONST EFI_GUID *Guid,\r
	405	IN UINTN ExTokenNumber,\r
	406	IN UINT16 Value\r
	407	)\r
	408	{\r
	409	return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));\r
	410	}\r
	411	\r
	412	\r
	413	\r
	414	EFI_STATUS\r
	415	EFIAPI\r
	416	DxePcdSet32Ex (\r
	417	IN CONST EFI_GUID *Guid,\r
	418	IN UINTN ExTokenNumber,\r
	419	IN UINT32 Value\r
	420	)\r
	421	{\r
	422	return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));\r
	423	}\r
	424	\r
	425	\r
	426	\r
	427	EFI_STATUS\r
	428	EFIAPI\r
	429	DxePcdSet64Ex (\r
	430	IN CONST EFI_GUID *Guid,\r
	431	IN UINTN ExTokenNumber,\r
	432	IN UINT64 Value\r
	433	)\r
	434	{\r
	435	return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));\r
	436	}\r
	437	\r
	438	\r
	439	\r
	440	EFI_STATUS\r
	441	EFIAPI\r
	442	DxePcdSetPtrEx (\r
	443	IN CONST EFI_GUID *Guid,\r
	444	IN UINTN ExTokenNumber,\r
	445	IN OUT UINTN *SizeOfBuffer,\r
	446	IN VOID *Buffer\r
	447	)\r
	448	{\r
	449	return ExSetWorker(ExTokenNumber, Guid, Buffer, SizeOfBuffer, TRUE);\r
	450	}\r
	451	\r
	452	\r
	453	\r
	454	EFI_STATUS\r
	455	EFIAPI\r
	456	DxePcdSetBoolEx (\r
	457	IN CONST EFI_GUID *Guid,\r
	458	IN UINTN ExTokenNumber,\r
	459	IN BOOLEAN Value\r
	460	)\r
	461	{\r
	462	return ExSetValueWorker (ExTokenNumber, Guid, &Value, sizeof (Value));\r
	463	}\r
	464	\r
	465	\r
	466	\r
	467	\r
	468	EFI_STATUS\r
	469	EFIAPI\r
	470	DxeRegisterCallBackOnSet (\r
	471	IN CONST EFI_GUID *Guid, OPTIONAL\r
	472	IN UINTN TokenNumber,\r
	473	IN PCD_PROTOCOL_CALLBACK CallBackFunction\r
	474	)\r
	475	{\r
	476	EFI_STATUS Status;\r
	477	\r
	478	ASSERT (CallBackFunction != NULL);\r
	479	\r
	480	//\r
	481	// Aquire lock to prevent reentrance from TPL_CALLBACK level\r
	482	//\r
	483	EfiAcquireLock (&mPcdDatabaseLock);\r
	484	\r
	485	Status = DxeRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction);\r
	486	\r
	487	EfiReleaseLock (&mPcdDatabaseLock);\r
	488	\r
	489	return Status;\r
	490	}\r
	491	\r
	492	\r
	493	\r
	494	EFI_STATUS\r
	495	EFIAPI\r
	496	DxeUnRegisterCallBackOnSet (\r
	497	IN CONST EFI_GUID *Guid, OPTIONAL\r
	498	IN UINTN TokenNumber,\r
	499	IN PCD_PROTOCOL_CALLBACK CallBackFunction\r
	500	)\r
	501	{\r
	502	EFI_STATUS Status;\r
	503	\r
	504	ASSERT (CallBackFunction != NULL);\r
	505	\r
	506	//\r
	507	// Aquire lock to prevent reentrance from TPL_CALLBACK level\r
	508	//\r
	509	EfiAcquireLock (&mPcdDatabaseLock);\r
	510	\r
	511	Status = DxeUnRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction);\r
	512	\r
	513	EfiReleaseLock (&mPcdDatabaseLock);\r
	514	\r
	515	return Status;\r
	516	}\r
	517	\r
	518	\r
	519	\r
	520	EFI_STATUS\r
	521	EFIAPI\r
	522	DxePcdGetNextToken (\r
	523	IN CONST EFI_GUID *Guid, OPTIONAL\r
	524	IN OUT UINTN *TokenNumber\r
	525	)\r
	526	{\r
	527	EFI_STATUS Status;\r
	528	\r
	529	if (!FeaturePcdGet (PcdDxePcdDatabaseTraverseEnabled)) {\r
	530	return EFI_UNSUPPORTED;\r
	531	}\r
	532	\r
	533	Status = EFI_NOT_FOUND;\r
	534	//\r
	535	// Scan the local token space\r
	536	//\r
	537	if (Guid == NULL) {\r
	538	// EBC compiler is very choosy. It may report warning about comparison\r
	539	// between UINTN and 0 . So we add 1 in each size of the \r
	540	// comparison.\r
	541	if (((TokenNumber + 1 > PEI_NEX_TOKEN_NUMBER + 1) && (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1)) \|\|\r
	542	((*TokenNumber + 1 > (PEI_LOCAL_TOKEN_NUMBER + DXE_NEX_TOKEN_NUMBER + 1)))) {\r
	543	return EFI_NOT_FOUND;\r
	544	}\r
	545	\r
	546	(*TokenNumber)++;\r
	547	if ((*TokenNumber + 1 > PEI_NEX_TOKEN_NUMBER + 1) &&\r
	548	(*TokenNumber <= PEI_LOCAL_TOKEN_NUMBER)) {\r
	549	//\r
	550	// The first Non-Ex type Token Number for DXE PCD \r
	551	// database is PEI_LOCAL_TOKEN_NUMBER\r
	552	//\r
	553	*TokenNumber = PEI_LOCAL_TOKEN_NUMBER;\r
	554	} else if (*TokenNumber + 1 > DXE_NEX_TOKEN_NUMBER + PEI_LOCAL_TOKEN_NUMBER + 1) {\r
	555	*TokenNumber = PCD_INVALID_TOKEN_NUMBER;\r
	556	}\r
	557	return EFI_SUCCESS;\r
	558	}\r
	559	\r
	560	if (PEI_EXMAP_TABLE_EMPTY && DXE_EXMAP_TABLE_EMPTY) {\r
	561	*TokenNumber = PCD_INVALID_TOKEN_NUMBER;\r
	562	return EFI_NOT_FOUND;\r
	563	}\r
	564	\r
	565	if (!PEI_EXMAP_TABLE_EMPTY) {\r
	566	Status = ExGetNextTokeNumber (\r
	567	Guid,\r
	568	TokenNumber,\r
	569	mPcdDatabase->PeiDb.Init.GuidTable,\r
	570	sizeof(mPcdDatabase->PeiDb.Init.GuidTable),\r
	571	mPcdDatabase->PeiDb.Init.ExMapTable,\r
	572	sizeof(mPcdDatabase->PeiDb.Init.ExMapTable)\r
	573	);\r
	574	}\r
	575	\r
	576	if (Status == EFI_SUCCESS) {\r
	577	return Status;\r
	578	}\r
	579	\r
	580	if (!DXE_EXMAP_TABLE_EMPTY) {\r
	581	Status = ExGetNextTokeNumber (\r
	582	Guid,\r
	583	TokenNumber,\r
	584	mPcdDatabase->DxeDb.Init.GuidTable,\r
	585	sizeof(mPcdDatabase->DxeDb.Init.GuidTable),\r
	586	mPcdDatabase->DxeDb.Init.ExMapTable,\r
	587	sizeof(mPcdDatabase->DxeDb.Init.ExMapTable)\r
	588	);\r
	589	}\r
	590	\r
	591	return Status;\r
	592	}\r
	593	\r
	594	\r
	595	EFI_GUID **\r
	596	GetDistinctTokenSpace (\r
	597	IN OUT UINTN *ExMapTableSize,\r
	598	IN DYNAMICEX_MAPPING *ExMapTable,\r
	599	IN EFI_GUID *GuidTable\r
	600	)\r
	601	{\r
	602	EFI_GUID **DistinctTokenSpace;\r
	603	UINTN OldGuidIndex;\r
	604	UINTN TsIdx;\r
	605	UINTN Idx;\r
	606	\r
	607	\r
	608	DistinctTokenSpace = AllocateZeroPool (ExMapTableSize sizeof (EFI_GUID *));\r
	609	ASSERT (DistinctTokenSpace != NULL);\r
	610	\r
	611	TsIdx = 0;\r
	612	OldGuidIndex = ExMapTable[0].ExGuidIndex;\r
	613	DistinctTokenSpace[TsIdx] = &GuidTable[OldGuidIndex];\r
	614	for (Idx = 1; Idx < *ExMapTableSize; Idx++) {\r
	615	if (ExMapTable[Idx].ExGuidIndex != OldGuidIndex) {\r
	616	OldGuidIndex = ExMapTable[Idx].ExGuidIndex;\r
	617	DistinctTokenSpace[++TsIdx] = &GuidTable[OldGuidIndex];\r
	618	}\r
	619	}\r
	620	\r
	621	//\r
	622	// The total number of Distinct Token Space\r
	623	// is TsIdx + 1 because we use TsIdx as a index\r
	624	// to the DistinctTokenSpace[]\r
	625	//\r
	626	*ExMapTableSize = TsIdx + 1;\r
	627	return DistinctTokenSpace;\r
	628	\r
	629	}\r
	630	\r
	631	//\r
	632	// Just pre-allocate a memory buffer that is big enough to\r
	633	// host all distinct TokenSpace guid in both\r
	634	// PEI ExMap and DXE ExMap.\r
	635	//\r
	636	STATIC EFI_GUID *TmpTokenSpaceBuffer[PEI_EXMAPPING_TABLE_SIZE + DXE_EXMAPPING_TABLE_SIZE] = { 0 };\r
	637	\r
	638	EFI_STATUS\r
	639	EFIAPI\r
	640	DxePcdGetNextTokenSpace (\r
	641	IN OUT CONST EFI_GUID **Guid\r
	642	)\r
	643	{\r
	644	UINTN Idx;\r
	645	UINTN Idx2;\r
	646	UINTN Idx3;\r
	647	UINTN PeiTokenSpaceTableSize;\r
	648	UINTN DxeTokenSpaceTableSize;\r
	649	EFI_GUID **PeiTokenSpaceTable;\r
	650	EFI_GUID **DxeTokenSpaceTable;\r
	651	BOOLEAN Match;\r
	652	\r
	653	if (!FeaturePcdGet (PcdDxePcdDatabaseTraverseEnabled)) {\r
	654	return EFI_UNSUPPORTED;\r
	655	}\r
	656	\r
	657	ASSERT (Guid != NULL);\r
	658	\r
	659	if (PEI_EXMAP_TABLE_EMPTY && DXE_EXMAP_TABLE_EMPTY) {\r
	660	if (*Guid != NULL) {\r
	661	return EFI_NOT_FOUND;\r
	662	} else {\r
	663	return EFI_SUCCESS;\r
	664	}\r
	665	}\r
	666	\r
	667	\r
	668	if (TmpTokenSpaceBuffer[0] == NULL) {\r
	669	PeiTokenSpaceTableSize = 0;\r
	670	\r
	671	if (!PEI_EXMAP_TABLE_EMPTY) {\r
	672	PeiTokenSpaceTableSize = PEI_EXMAPPING_TABLE_SIZE;\r
	673	PeiTokenSpaceTable = GetDistinctTokenSpace (&PeiTokenSpaceTableSize,\r
	674	mPcdDatabase->PeiDb.Init.ExMapTable,\r
	675	mPcdDatabase->PeiDb.Init.GuidTable\r
	676	);\r
	677	CopyMem (TmpTokenSpaceBuffer, PeiTokenSpaceTable, sizeof (EFI_GUID) PeiTokenSpaceTableSize);\r
	678	}\r
	679	\r
	680	if (!DXE_EXMAP_TABLE_EMPTY) {\r
	681	DxeTokenSpaceTableSize = DXE_EXMAPPING_TABLE_SIZE;\r
	682	DxeTokenSpaceTable = GetDistinctTokenSpace (&DxeTokenSpaceTableSize,\r
	683	mPcdDatabase->DxeDb.Init.ExMapTable,\r
	684	mPcdDatabase->DxeDb.Init.GuidTable\r
	685	);\r
	686	\r
	687	//\r
	688	// Make sure EFI_GUID in DxeTokenSpaceTable does not exist in PeiTokenSpaceTable\r
	689	//\r
	690	for (Idx2 = 0, Idx3 = PeiTokenSpaceTableSize; Idx2 < DxeTokenSpaceTableSize; Idx2++) {\r
	691	Match = FALSE;\r
	692	for (Idx = 0; Idx < PeiTokenSpaceTableSize; Idx++) {\r
	693	if (CompareGuid (TmpTokenSpaceBuffer[Idx], DxeTokenSpaceTable[Idx2])) {\r
	694	Match = TRUE;\r
	695	break;\r
	696	}\r
	697	}\r
	698	if (!Match) {\r
	699	TmpTokenSpaceBuffer[Idx3++] = DxeTokenSpaceTable[Idx2];\r
	700	}\r
	701	}\r
	702	}\r
	703	}\r
	704	\r
	705	if (*Guid == NULL) {\r
	706	*Guid = TmpTokenSpaceBuffer[0];\r
	707	return EFI_SUCCESS;\r
	708	}\r
	709	\r
	710	for (Idx = 0; Idx < (PEI_EXMAPPING_TABLE_SIZE + DXE_EXMAPPING_TABLE_SIZE); Idx++) {\r
	711	if(CompareGuid (*Guid, TmpTokenSpaceBuffer[Idx])) {\r
	712	Idx++;\r
	713	*Guid = TmpTokenSpaceBuffer[Idx];\r
	714	return EFI_SUCCESS;\r
	715	}\r
	716	}\r
	717	\r
	718	return EFI_NOT_FOUND;\r
	719	\r
	720	}\r
	721	\r
	722	\r