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