Check in the Pcd service Driver/PEIM according to the new way of generating PCD Database

LIMITATION:

1) ONLY dynamic type PCD is supported for now. DynamicEx is not supported.
2) HII enable and VPD is not tested.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@253 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 403 insertions, 309 deletions

diff --git a/EdkModulePkg/Universal/PCD/Dxe/Service.c b/EdkModulePkg/Universal/PCD/Dxe/Service.c
index 280a45ea31..52097ade7e 100644
--- a/EdkModulePkg/Universal/PCD/Dxe/Service.c
+++ b/EdkModulePkg/Universal/PCD/Dxe/Service.c
@@ -14,427 +14,463 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 Module Name: Service.c

 

 **/

-#include "../Common/PcdCommon.h"

 #include "Service.h"

 

-static PCD_DATABASE *PrivatePcdDxeDatabase;

-static LIST_ENTRY   mPcdDatabaseListHead = INITIALIZE_LIST_HEAD_VARIABLE(mPcdDatabaseListHead);

 

-LIST_ENTRY *

-GetPcdDatabaseListHead (

-  VOID

-  )

-{

-  return &mPcdDatabaseListHead;

-}

-

-PCD_DATABASE *

-GetPcdDxeDataBaseInstance (

-  VOID

-)

-{

-  return PrivatePcdDxeDatabase;

-}

+//

+// Build Tool will generate DXE_PCD_DB_INIT_VALUE in Autogen.h

+// Compression Algorithm will take care of the size optimization.

+//

 

-PCD_DATABASE *

-SetPcdDxeDataBaseInstance (

-  PCD_DATABASE *PcdDatabase

-)

-{

-  return PrivatePcdDxeDatabase = PcdDatabase;

-}

+/*

+DXE_PCD_DATABASE_INIT gDXEPcdDbInit = {

+  DXE_PCD_DB_INIT_VALUE

+};

+*/

 

+PCD_DATABASE * gPcdDatabase;

 

-VOID

-DxeGetPcdEntryWorker (

-  IN UINTN            TokenNumber,

-  IN CONST GUID       *Guid,  OPTIONAL

-  IN PCD_DATA_TYPE    Type,

-  OUT VOID            *Data

-  )

+VOID *

+GetWorkerByLocalTokenNumber (

+  UINT32      LocalTokenNumber,

+  BOOLEAN     IsPeiDb,

+  UINTN       Size

+  ) 

 {

-  PCD_DATABASE *Database;

-  Database = GetPcdDxeDataBaseInstance ();

+  UINT32              Offset;

+  EFI_GUID            *GuidTable;

+  UINT16              *StringTable;

+  EFI_GUID            *Guid;

+  UINT16              *Name;

+  VARIABLE_HEAD       *VariableHead;

+  EFI_STATUS          Status;

+  UINTN               DataSize;

+  VOID                *Data;

+  VPD_HEAD            *VpdHead;

+  UINT8               *PcdDb;

+  UINT16              StringTableIdx;      

+

+  if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {

+    LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, Size, IsPeiDb);

+  }

+

+  PcdDb = IsPeiDb ? ((UINT8 *) &gPcdDatabase->PeiDb) : ((UINT8 *) &gPcdDatabase->DxeDb);

+  StringTable = IsPeiDb ? gPcdDatabase->PeiDb.Init.StringTable :

+                          gPcdDatabase->DxeDb.Init.StringTable;

+  

+  Offset     = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;

+  

+  switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) {

+    case PCD_TYPE_VPD:

+      VpdHead = (VPD_HEAD *) ((UINT8 *) PcdDb + Offset);

+      return (VOID *) (FixedPcdGet32(PcdVpdBaseAddress) + VpdHead->Offset);

+      

+    case PCD_TYPE_HII:

+      GuidTable   = IsPeiDb ? gPcdDatabase->PeiDb.Init.GuidTable :

+                              gPcdDatabase->DxeDb.Init.GuidTable;

+                              

+      VariableHead = (VARIABLE_HEAD *) (PcdDb + Offset);

+      

+      Guid = &(GuidTable[VariableHead->GuidTableIndex]);

+      Name = &(StringTable[VariableHead->StringIndex]);

 

-  GetPcdEntryWorker ( &Database->Info,

-                      TokenNumber,

-                      Guid,

-                      Type,

-                      Data

-                      );

+      Status = GetHiiVariable (Guid, Name, &Data, &DataSize);

+      ASSERT_EFI_ERROR (Status);

+      ASSERT (DataSize >= (UINTN) (VariableHead->Offset + Size));

 

+      return (UINT8 *) Data + VariableHead->Offset;

 

-  return;

-}

+    case PCD_TYPE_STRING:

+      StringTableIdx = (UINT16) *((UINT8 *) PcdDb + Offset);

+      return (VOID *) &StringTable[StringTableIdx];

 

+    case PCD_TYPE_DATA:

+      return (VOID *) ((UINT8 *) PcdDb + Offset);

+      break;

 

+    default:

+      ASSERT (FALSE);

+      break;

+      

+  }

 

-EFI_STATUS

-DxeSetPcdEntryWorker (

-  IN UINTN              TokenNumber,

-  IN CONST GUID         *Guid,  OPTIONAL

-  IN PCD_DATA_TYPE      Type,

-  IN CONST VOID         *Data

+  ASSERT (FALSE);

+      

+  return NULL;

+}

+  

+VOID *

+GetWorker (

+  UINTN  TokenNumber

   )

 {

-  PCD_DATABASE            *Database;

-  PCD_INDEX               *PcdIndex;

-  EFI_STATUS              Status;

-

-  Database = GetPcdDxeDataBaseInstance ();

-

-

-  ASSERT (Data != NULL);

-

-  PcdIndex = FindPcdIndex (TokenNumber, Guid, &Database->Info, NULL);

+  UINT32        *LocalTokenNumberTable;

+  UINT16        *SizeTable;

+  BOOLEAN       IsPeiDb;

 

-  ASSERT (PcdIndex != NULL);

+  ASSERT (TokenNumber < PCD_TOTAL_TOKEN_NUMBER);

+  

+  IsPeiDb = (TokenNumber <= PEI_LOCAL_TOKEN_NUMBER) ? TRUE : FALSE;

 

-  ASSERT (PcdIndex->StateByte.DataType == Type);

+  LocalTokenNumberTable  = IsPeiDb ? gPcdDatabase->PeiDb.Init.LocalTokenNumberTable : 

+                                     gPcdDatabase->DxeDb.Init.LocalTokenNumberTable;

 

-  //

-  // Invoke the callback function.

-  //

+  SizeTable              = IsPeiDb ? gPcdDatabase->PeiDb.Init.SizeTable: 

+                                     gPcdDatabase->DxeDb.Init.SizeTable;

 

-  Status = SetPcdData (PcdIndex, &Database->Info, Data);

+  TokenNumber            = IsPeiDb ? TokenNumber :

+                                     TokenNumber - PEI_LOCAL_TOKEN_NUMBER;

+  return GetWorkerByLocalTokenNumber (LocalTokenNumberTable[TokenNumber], IsPeiDb, SizeTable[TokenNumber]);

+}

 

-  return Status;

 

 

+EFI_STATUS

+DxeRegisterCallBackWorker (

+  IN  UINTN                   TokenNumber,

+  IN  CONST GUID              *Guid, OPTIONAL

+  IN  PCD_PROTOCOL_CALLBACK   CallBackFunction,

+  IN  BOOLEAN                 Register

+)

+{

+  

+  return EFI_SUCCESS;

 }

 

 

-

-UINTN

-DxeGetPcdEntrySizeWorker (

-  IN UINTN            TokenNumber,

-  IN CONST GUID       *Guid  OPTIONAL

+EFI_STATUS

+DxeGetNextTokenWorker (

+  IN OUT UINTN            *TokenNumber,

+  IN CONST GUID           *Guid     OPTIONAL

   )

 {

-  PCD_DATABASE *Database;

-  Database = GetPcdDxeDataBaseInstance ();

-

-  return GetPcdEntrySizeWorker (&Database->Info,

-                                TokenNumber,

-                                Guid

-                                );

+  return EFI_SUCCESS;

 }

 

 

 

-LIST_ENTRY *

-InsertToGuidSpaceListI (

-  IN LIST_ENTRY       *GuidSpaceListHead,

-  IN CONST EFI_GUID   *Guid

-  )

+VOID

+BuildPcdDxeDataBase (

+  VOID

+)

 {

-  PCD_GUID_SPACE    *GuidSpaceEntry;

+  PEI_PCD_DATABASE    *PeiDatabase;

+  EFI_HOB_GUID_TYPE   *GuidHob;

 

-  GuidSpaceEntry = AllocatePool (sizeof (PCD_GUID_SPACE));

-  ASSERT (GuidSpaceEntry != NULL);

+  gPcdDatabase = AllocateZeroPool (sizeof(PCD_DATABASE));

+  ASSERT (gPcdDatabase != NULL);

 

-  GuidSpaceEntry->GuidSpace= Guid;

-  InitializeListHead (&GuidSpaceEntry->TokenSpaceHead);

-  

-  InsertTailList (GuidSpaceListHead, &GuidSpaceEntry->ListNode);

+  GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);

+  ASSERT (GuidHob != NULL);

 

-  return &GuidSpaceEntry->TokenSpaceHead;

+  PeiDatabase = (PEI_PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob);

+  //

+  // Copy PCD Entries refereneced in PEI phase to PCD DATABASE

+  //

+  CopyMem (&gPcdDatabase->PeiDb, PeiDatabase, sizeof (PEI_PCD_DATABASE));

+

+  //

+  // Copy PCD Entries with default value to PCD DATABASE

+  //

+  CopyMem (&gPcdDatabase->DxeDb.Init, &gDXEPcdDbInit, sizeof(DXE_PCD_DATABASE_INIT));

+    

+  return;

 }

 

 

 

-LIST_ENTRY *

-InsertToTokenSpaceListI (

-  IN LIST_ENTRY *TokenSpaceListHead,

-  IN UINTN      TokenNumber

+EFI_STATUS

+GetHiiVariable (

+  IN  EFI_GUID      *VariableGuid,

+  IN  UINT16        *VariableName,

+  OUT VOID          ** VariableData,

+  OUT UINTN         *VariableSize

   )

 {

-  PCD_TOKEN_SPACE   *TokenSpaceEntry;

+  UINTN      Size;

+  EFI_STATUS Status;

+  VOID       *Buffer;

 

-  TokenSpaceEntry = AllocatePool (sizeof (PCD_TOKEN_SPACE));

-  ASSERT (TokenSpaceEntry != NULL);

+  Status = EfiGetVariable (

+    (UINT16 *)VariableName,

+    VariableGuid,

+    NULL,

+    &Size,

+    NULL

+    );

+  ASSERT (Status == EFI_BUFFER_TOO_SMALL);

 

-  TokenSpaceEntry->TokeNumber = TokenNumber;

-  InitializeListHead (&TokenSpaceEntry->CallbackListHead);

-  

-  InsertTailList (TokenSpaceListHead, &TokenSpaceEntry->ListNode);

+  Buffer = AllocatePool (Size);

 

-  return &TokenSpaceEntry->CallbackListHead;

-}

+  ASSERT (Buffer != NULL);

 

+  Status = EfiGetVariable (

+    VariableName,

+    VariableGuid,

+    NULL,

+    &Size,

+    Buffer

+    );

 

+  return Status;

 

-VOID

-InsertToCallbackListI (

-  IN  LIST_ENTRY *CallbackListHead,

-  IN  PCD_PROTOCOL_CALLBACK   CallBackFunction

-  )

-{

-  PCD_CALLBACK_ENTRY *CallbackEntry;

-  

-  CallbackEntry = AllocatePool (sizeof (PCD_CALLBACK_ENTRY));

-  ASSERT (CallbackEntry != NULL);

-  CallbackEntry->CallbackFunction = CallBackFunction;

-  InsertTailList (CallbackListHead, &CallbackEntry->ListNode);

-  

-  return;

 }

 

 

+UINT32

+GetSkuEnabledTokenNumber (

+  UINT32    LocalTokenNumber,

+  UINTN     Size,

+  BOOLEAN   IsPeiDb

+  ) 

+{

+  SKU_HEAD              *SkuHead;

+  SKU_ID                *SkuIdTable;

+  INTN                  i;

+  UINT8                 *Value;

+  SKU_ID                *PhaseSkuIdTable;

+  UINT8                 *PcdDb;

 

+  ASSERT ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0);

 

-VOID

-InsertToCallbackList (

-  IN  UINTN                   TokenNumber,

-  IN  CONST EFI_GUID          *Guid,

-  IN  PCD_PROTOCOL_CALLBACK   CallBackFunction

-  )

-{

-  LIST_ENTRY        *GuidListNode;

-  LIST_ENTRY        *GuidListHead;

-  LIST_ENTRY        *TokenListNode;

-  LIST_ENTRY        *TokenListHead;

-  LIST_ENTRY        *CallbackListHead;

-  PCD_GUID_SPACE    *GuidSpaceEntry;

-  PCD_TOKEN_SPACE   *TokenSpaceEntry;

+  PcdDb = IsPeiDb ? (UINT8 *) &gPcdDatabase->PeiDb : (UINT8 *) &gPcdDatabase->DxeDb;

 

-  

-  GuidListHead = GetPcdDatabaseListHead ();

-

-  GuidListNode = GetFirstNode (GuidListHead);

-  while (!IsNull (GuidListNode, GuidListHead)) {

-    GuidSpaceEntry = PCD_GUID_SPACE_FROM_LISTNODE(GuidListNode);

-

-    if (CompareGuid (GuidSpaceEntry->GuidSpace, Guid)) {

-      TokenListHead = &GuidSpaceEntry->TokenSpaceHead;

-      TokenListNode = GetFirstNode (TokenListHead);

-      while (!IsNull (TokenListNode, TokenListHead)) {

-        TokenSpaceEntry = PCD_TOKEN_SPACE_FROM_LISTNODE(TokenListNode);

-        if (TokenSpaceEntry->TokeNumber == TokenNumber) {

-          InsertToCallbackListI (&TokenSpaceEntry->CallbackListHead , CallBackFunction);

-        }

-      }

+  SkuHead     = (SKU_HEAD *) (PcdDb + (LocalTokenNumber & PCD_DATABASE_OFFSET_MASK));

+  Value       = (UINT8 *) (PcdDb + SkuHead->SkuDataStartOffset); 

 

-      //

-      // No TokenNumber match input found in this GuidSpace

-      //

-      CallbackListHead = InsertToTokenSpaceListI (TokenListHead, TokenNumber);

-      InsertToCallbackListI (CallbackListHead , CallBackFunction);

+  PhaseSkuIdTable = IsPeiDb ? gPcdDatabase->PeiDb.Init.SkuIdTable :

+                              gPcdDatabase->DxeDb.Init.SkuIdTable;

+                              

+  SkuIdTable  = &PhaseSkuIdTable[SkuHead->SkuIdTableOffset];

+        

+  for (i = 0; i < SkuIdTable[0]; i++) {

+    if (gPcdDatabase->PeiDb.Init.SystemSkuId == SkuIdTable[i + 1]) {

+      break;

     }

-    

-    GuidListNode = GetNextNode (GuidListHead, GuidListNode);

   }

+  ASSERT (i < SkuIdTable[0]);

 

-  //

-  // No GuidSpace match the input Guid, so build the GuidSpace, TokenNumberSpace and Callback

-  //

-  TokenListHead = InsertToGuidSpaceListI (GuidListHead, Guid);

-  CallbackListHead = InsertToTokenSpaceListI (TokenListHead, TokenNumber);

-  InsertToCallbackListI (CallbackListHead , CallBackFunction);

+  switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) {

+    case PCD_TYPE_VPD:

+      Value = (UINT8 *) &(((VPD_HEAD *) Value)[i]);

+      return ((Value - PcdDb) | PCD_TYPE_VPD);

 

-  return;

+    case PCD_TYPE_HII:

+      Value = (UINT8 *) &(((VARIABLE_HEAD *) Value)[i]);

+      return ((Value - PcdDb) | PCD_TYPE_HII);

+      

+    case PCD_TYPE_DATA:

+      Value += Size * i;

+      return (Value - PcdDb);

+      

+    default:

+      ASSERT (FALSE);

+  }

+

+  ASSERT (FALSE);

+

+  return 0;

   

 }

 

-EFI_STATUS

-RemoveFromCallbackListI (

-  IN  LIST_ENTRY              *CallbackListHead,

-  IN  PCD_PROTOCOL_CALLBACK   CallBackFunction

-  )

-{

-  LIST_ENTRY          *ListNode;

-  PCD_CALLBACK_ENTRY  *CallbackEntry;

 

-  ListNode = GetFirstNode (CallbackListHead);

 

-  while (!IsNull(CallbackListHead, ListNode)) {

-    CallbackEntry = PCD_CALLBACK_ENTRY_FROM_LISTNODE(ListNode);

 

-    if (CallbackEntry->CallbackFunction == CallBackFunction) {

-      RemoveEntryList (ListNode);

-      FreePool (CallbackEntry);

-      return EFI_SUCCESS;

-    }

-    ListNode = GetNextNode (CallbackListHead, ListNode);

-  }

 

-  return EFI_NOT_FOUND;

+VOID

+InvokeCallbackOnSet (

+  UINT32            ExTokenNumber,

+  CONST EFI_GUID    *Guid, OPTIONAL

+  UINTN             TokenNumber,

+  VOID              *Data,

+  UINTN             Size

+  )

+{

+  return;

 }

 

 

 

+

 EFI_STATUS

-RemoveFromCallbackList (

-  IN  UINTN                   TokenNumber,

-  IN  CONST GUID              *Guid,

-  IN  PCD_PROTOCOL_CALLBACK   CallBackFunction

+SetWorker (

+  UINTN         TokenNumber,

+  VOID          *Data,

+  UINTN         Size,

+  BOOLEAN       PtrType

   )

 {

-  LIST_ENTRY        *GuidListNode;

-  LIST_ENTRY        *GuidListHead;

-  LIST_ENTRY        *TokenListNode;

-  LIST_ENTRY        *TokenListHead;

-  PCD_GUID_SPACE    *GuidSpaceEntry;

-  PCD_TOKEN_SPACE   *TokenSpaceEntry;

+  UINT32              *LocalTokenNumberTable;

+  BOOLEAN             IsPeiDb;

 

-  

-  GuidListHead = GetPcdDatabaseListHead ();

 

-  GuidListNode = GetFirstNode (GuidListHead);

-  while (!IsNull (GuidListNode, GuidListHead)) {

-    

-    GuidSpaceEntry = PCD_GUID_SPACE_FROM_LISTNODE(GuidListNode);

-    if (CompareGuid (GuidSpaceEntry->GuidSpace, Guid)) {

-      

-      TokenListHead = &GuidSpaceEntry->TokenSpaceHead;

-      TokenListNode = GetFirstNode (TokenListHead);

-      while (!IsNull (TokenListNode, TokenListHead)) {

-        

-        TokenSpaceEntry = PCD_TOKEN_SPACE_FROM_LISTNODE(TokenListNode);

-        if (TokenSpaceEntry->TokeNumber == TokenNumber) {

-          return RemoveFromCallbackListI (&TokenSpaceEntry->CallbackListHead , CallBackFunction);

-        }

-      }

+  ASSERT (TokenNumber < PCD_TOTAL_TOKEN_NUMBER);

 

-      //

-      // No TokenNumber match input found in this GuidSpace

-      //

-      return EFI_NOT_FOUND;

-    }

-    

-    GuidListNode = GetNextNode (GuidListHead, GuidListNode);

+  if (PtrType) {

+    ASSERT (Size <= DxePcdGetSize (TokenNumber));

+  } else {

+    ASSERT (Size == DxePcdGetSize (TokenNumber));

   }

-

-

-  return EFI_NOT_FOUND;

   

-}

-

+  IsPeiDb = (TokenNumber <= PEI_LOCAL_TOKEN_NUMBER) ? TRUE : FALSE;

 

+  LocalTokenNumberTable  = IsPeiDb ? gPcdDatabase->PeiDb.Init.LocalTokenNumberTable : 

+                                     gPcdDatabase->DxeDb.Init.LocalTokenNumberTable;

 

-EFI_STATUS

-DxeRegisterCallBackWorker (

-  IN  UINTN                   TokenNumber,

-  IN  CONST GUID              *Guid, OPTIONAL

-  IN  PCD_PROTOCOL_CALLBACK   CallBackFunction,

-  IN  BOOLEAN                 Register

-)

-{

-  PCD_DATABASE *Database;

-  PCD_INDEX    *PcdIndex;

+  TokenNumber = IsPeiDb ? TokenNumber

+                        : TokenNumber - PEI_LOCAL_TOKEN_NUMBER;

   

-  Database = GetPcdDxeDataBaseInstance ();

+  InvokeCallbackOnSet (0, NULL, TokenNumber, Data, Size);

 

-  PcdIndex = FindPcdIndex (TokenNumber, Guid, &Database->Info, NULL);

+  return SetWorkerByLocalTokenNumber (LocalTokenNumberTable[TokenNumber], Data, Size, PtrType, IsPeiDb);

 

-  if (PcdIndex == NULL) {

-    return EFI_NOT_FOUND;

-  }

+}

 

-  if (Register) {

-    InsertToCallbackList (TokenNumber, Guid, CallBackFunction);

-    return EFI_SUCCESS;

-  } else {

-    return RemoveFromCallbackList (TokenNumber, Guid, CallBackFunction); 

-  }

 

- }

 

 

 

-EFI_STATUS

-DxeSetSku (

-  UINTN Id

-)

+VOID *

+ExGetWorker (

+  IN CONST EFI_GUID         *Guid,

+  IN UINTN                  ExTokenNumber,

+  IN UINTN                  GetSize

+  ) 

 {

-  PCD_DATABASE * Database;

+  EX_PCD_ENTRY_ATTRIBUTE Attr;

 

-  Database = GetPcdDxeDataBaseInstance ();

+  GetExPcdTokenAttributes (Guid, ExTokenNumber, &Attr);

 

-  return Database->Info.SkuId = Id;

+  ASSERT ((GetSize == Attr.Size) || (GetSize == 0));

 

+  return GetWorkerByLocalTokenNumber (Attr.LocalTokenNumberAlias,

+                                                Attr.IsPeiDb,

+                                                Attr.Size

+                                                );

 }

 

 

 

+

+

 EFI_STATUS

-DxeGetNextTokenWorker (

-  IN OUT UINTN            *TokenNumber,

-  IN CONST GUID           *Guid     OPTIONAL

+ExSetWorker (

+  IN UINT32               ExTokenNumber,

+  IN CONST EFI_GUID       *Guid,

+  VOID                    *Data,

+  UINTN                   SetSize,

+  BOOLEAN                 PtrType

   )

 {

-  PCD_DATABASE * Database;

+  EX_PCD_ENTRY_ATTRIBUTE Attr;

 

-  Database = GetPcdDxeDataBaseInstance ();

+  GetExPcdTokenAttributes (Guid, ExTokenNumber, &Attr);

 

-  return GetNextTokenWorker (&Database->Info,

-                             TokenNumber,

-                             Guid

-                             );

-}

+  ASSERT (!PtrType && (SetSize == Attr.Size));

 

+  ASSERT (PtrType && (SetSize <= Attr.Size));

 

+  InvokeCallbackOnSet (ExTokenNumber, Guid, Attr.TokenNumber, Data, Attr.Size);

 

-VOID

-InitPcdDxeDataBase (

-  VOID

-)

-{

-  PCD_DATABASE        *PeiDatabase;

-  PCD_DATABASE        *DxeDatabase;

-  EFI_HOB_GUID_TYPE   *GuidHob;

+  SetWorkerByLocalTokenNumber (Attr.LocalTokenNumberAlias, Data, Attr.Size, PtrType, Attr.IsPeiDb);

 

-  GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);

-  ASSERT (GuidHob != NULL);

+  return EFI_SUCCESS;

+  

+}

 

-  PeiDatabase = (PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob);

 

-  DxeDatabase = AllocateCopyPool (PeiDatabase->Info.DatabaseLen, PeiDatabase);

 

-  ASSERT (DxeDatabase != NULL);

 

-  SetPcdDxeDataBaseInstance (DxeDatabase);

+EFI_STATUS

+SetWorkerByLocalTokenNumber (

+  UINT32        LocalTokenNumber,

+  VOID          *Data,

+  UINTN         Size,

+  BOOLEAN       PtrType,

+  BOOLEAN       IsPeiDb

+  )

+{

+  EFI_GUID            *GuidTable;

+  UINT16              *StringTable;

+  EFI_GUID            *Guid;

+  UINT16              *Name;

+  VOID                *InternalData;

+  VARIABLE_HEAD       *VariableHead;

+  UINTN               Offset;

+  UINT8               *PcdDb;

+

+

+  if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {

+    LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, Size, IsPeiDb);

+  }

 

-  return;

-}

+  Offset = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;

 

+  PcdDb = IsPeiDb ? ((UINT8 *) &gPcdDatabase->PeiDb) : ((UINT8 *) &gPcdDatabase->DxeDb);

 

+  StringTable = IsPeiDb ? gPcdDatabase->PeiDb.Init.StringTable :

+                          gPcdDatabase->DxeDb.Init.StringTable;

+  

+  InternalData = PcdDb + Offset;

 

-EFI_STATUS

-GetHiiVariable (

-  IN  EFI_GUID      *VariableGuid,

-  IN  UINT16        *VariableName,

-  OUT VOID          ** VariableData,

-  OUT UINTN         *VariableSize

-  )

-{

-  UINTN      Size;

-  EFI_STATUS Status;

-  VOID       *Buffer;

+  switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) {

+    case PCD_TYPE_VPD:

+      ASSERT (FALSE);

+      return EFI_INVALID_PARAMETER;

+    

+    case PCD_TYPE_STRING:

+      CopyMem (&StringTable[*((UINT16 *)InternalData)], Data, Size);

+      break;

 

-  Status = EfiGetVariable (

-    (UINT16 *)VariableName,

-    VariableGuid,

-    NULL,

-    &Size,

-    NULL

-    );

-  ASSERT (Status == EFI_BUFFER_TOO_SMALL);

+    case PCD_TYPE_HII:

+      //

+      // Bug Bug: Please implement this

+      //

+      GuidTable   = IsPeiDb ? gPcdDatabase->PeiDb.Init.GuidTable :

+                              gPcdDatabase->DxeDb.Init.GuidTable;

+                              

+      VariableHead = (VARIABLE_HEAD *) (PcdDb + Offset);

+      

+      Guid = &(GuidTable[VariableHead->GuidTableIndex]);

+      Name = &(StringTable[VariableHead->StringIndex]);

 

-  Buffer = AllocatePool (Size);

+      return EFI_SUCCESS;

 

-  ASSERT (Buffer != NULL);

+    case PCD_TYPE_DATA:

+      if (PtrType) {

+        CopyMem (InternalData, Data, Size);

+        return EFI_SUCCESS;

+      }

 

-  Status = EfiGetVariable (

-    VariableName,

-    VariableGuid,

-    NULL,

-    &Size,

-    Buffer

-    );

+      switch (Size) {

+        case sizeof(UINT8):

+          *((UINT8 *) InternalData) = *((UINT8 *) Data);

+          return EFI_SUCCESS;

 

-  return Status;

+        case sizeof(UINT16):

+          *((UINT16 *) InternalData) = *((UINT16 *) Data);

+          return EFI_SUCCESS;

+

+        case sizeof(UINT32):

+          *((UINT32 *) InternalData) = *((UINT32 *) Data);

+          return EFI_SUCCESS;

+

+        case sizeof(UINT64):

+          *((UINT64 *) InternalData) = *((UINT64 *) Data);

+          return EFI_SUCCESS;

 

+        default:

+          ASSERT (FALSE);

+          return EFI_NOT_FOUND;

+      }

+

+    default:

+      ASSERT (FALSE);

+      break;

+    }

+      

+  ASSERT (FALSE);

+  return EFI_NOT_FOUND;

 }

 

 

@@ -448,16 +484,17 @@ SetHiiVariable (
   IN  UINTN        Offset

   )

 {

-  UINTN Size;

-  VOID  *Buffer;

-  EFI_STATUS Status;

+  UINTN       Size;

+  VOID        *Buffer;

+  EFI_STATUS  Status;

+  UINT32      Attribute;

 

   Size = 0;

 

   Status = EfiGetVariable (

     (UINT16 *)VariableName,

     VariableGuid,

-    NULL,

+    &Attribute,

     &Size,

     NULL

     );

@@ -471,7 +508,7 @@ SetHiiVariable (
   Status = EfiGetVariable (

     VariableName,

     VariableGuid,

-    NULL,

+    &Attribute,

     &Size,

     Buffer

     );

@@ -482,10 +519,67 @@ SetHiiVariable (
   return EfiSetVariable (

     VariableName,

     VariableGuid,

-    0,

+    Attribute,

     Size,

     Buffer

     );

 

 }

 

+

+

+

+

+VOID

+GetExPcdTokenAttributes (

+  IN CONST EFI_GUID             *Guid,

+  IN UINT32                     ExTokenNumber,

+  OUT EX_PCD_ENTRY_ATTRIBUTE    *ExAttr

+  )

+{

+  UINT32              i;

+  DYNAMICEX_MAPPING   *ExMap;

+  EFI_GUID            *GuidTable;

+  UINT16              *SizeTable;

+

+  ExMap       = gPcdDatabase->PeiDb.Init.ExMapTable;

+  GuidTable   = gPcdDatabase->PeiDb.Init.GuidTable;

+  SizeTable   = gPcdDatabase->PeiDb.Init.SizeTable;

+  

+  for (i = 0; i < PEI_EXMAPPING_TABLE_SIZE; i++) {

+    if ((ExTokenNumber == ExMap[i].ExTokenNumber) &&

+        CompareGuid (Guid, (CONST EFI_GUID *) &GuidTable[ExMap[i].ExGuidIndex])

+      ) {

+

+        ExAttr->IsPeiDb               = TRUE;

+        ExAttr->Size                  = SizeTable[i + PEI_NEX_TOKEN_NUMBER];

+        ExAttr->TokenNumber           = i + PEI_NEX_TOKEN_NUMBER;

+        ExAttr->LocalTokenNumberAlias = ExMap[i].LocalTokenNumber;

+        return;

+

+    }

+  }

+  

+  ExMap       = gPcdDatabase->DxeDb.Init.ExMapTable;

+  GuidTable   = gPcdDatabase->DxeDb.Init.GuidTable;

+  SizeTable   = gPcdDatabase->DxeDb.Init.SizeTable;

+  

+  for (i = 0; i < DXE_EXMAPPING_TABLE_SIZE; i++) {

+    if ((ExTokenNumber == ExMap[i].ExTokenNumber) &&

+         CompareGuid (Guid, (CONST EFI_GUID *) &GuidTable[ExMap[i].ExGuidIndex])

+      ) {

+

+        ExAttr->IsPeiDb               = FALSE;

+        ExAttr->Size                  = SizeTable[i + DXE_NEX_TOKEN_NUMBER];

+        ExAttr->TokenNumber           = i + DXE_NEX_TOKEN_NUMBER;

+        ExAttr->LocalTokenNumberAlias = ExMap[i].LocalTokenNumber;

+        return;

+

+    }

+  }

+

+  ASSERT (FALSE);

+

+  return;

+}

+