X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=EdkModulePkg%2FUniversal%2FPCD%2FPei%2FService.c;h=0004bc6c76a1ffca81e8c52fe45b6d7af48f369e;hb=1de04b4f83050f9a8f6c3eedce27f841591972f3;hp=e280dd6715558a39b82c33175db5892bcd0145f2;hpb=0653eb895dfb8d059c114120a0779b561c5578ef;p=mirror_edk2.git

diff --git a/EdkModulePkg/Universal/PCD/Pei/Service.c b/EdkModulePkg/Universal/PCD/Pei/Service.c
index e280dd6715..0004bc6c76 100644
--- a/EdkModulePkg/Universal/PCD/Pei/Service.c
+++ b/EdkModulePkg/Universal/PCD/Pei/Service.c
@@ -16,7 +16,6 @@ Module Name: Service.c
 **/
 #include "Service.h"
 
-
 /**
   The function registers the CallBackOnSet fucntion
   according to TokenNumber and EFI_GUID space.
@@ -43,18 +42,36 @@ PeiRegisterCallBackWorker (
   UINT32                  LocalTokenNumber;
   UINTN                   TokenNumber;
   UINTN                   Idx;
-  EX_PCD_ENTRY_ATTRIBUTE  Attr;
 
   if (Guid == NULL) {
     TokenNumber = ExTokenNumber;
+
+    //
+    // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
+    // We have to decrement TokenNumber by 1 to make it usable
+    // as the array index.
+    //
+    TokenNumber--;
     ASSERT (TokenNumber < PEI_NEX_TOKEN_NUMBER);
-    LocalTokenNumber = GetPcdDatabase()->Init.LocalTokenNumberTable[TokenNumber];
   } else {
-    GetExPcdTokenAttributes (Guid, ExTokenNumber, &Attr);
-    TokenNumber = Attr.TokenNumber;
-    LocalTokenNumber = Attr.LocalTokenNumberAlias;
+    TokenNumber = GetExPcdTokenNumber (Guid, ExTokenNumber);
+
+    //
+    // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
+    // We have to decrement TokenNumber by 1 to make it usable
+    // as the array index.
+    //
+    TokenNumber--;
+    ASSERT (TokenNumber < PEI_LOCAL_TOKEN_NUMBER);
   }
 
+
+  LocalTokenNumber = GetPcdDatabase()->Init.LocalTokenNumberTable[TokenNumber];
+
+  //
+  // We don't support SET for HII and VPD type PCD entry in PEI phase.
+  // So we will assert if any register callback for such PCD entry.
+  //
   ASSERT ((LocalTokenNumber & PCD_TYPE_HII) == 0);
   ASSERT ((LocalTokenNumber & PCD_TYPE_VPD) == 0);
 
@@ -145,11 +162,10 @@ GetHiiVariable (
   VOID       *Buffer;
   EFI_PEI_READ_ONLY_VARIABLE_PPI *VariablePpi;
 
-  Status = PeiCoreLocatePpi (&gEfiPeiReadOnlyVariablePpiGuid, 0, NULL, (VOID **) &VariablePpi);
+  Status = PeiServicesLocatePpi (&gEfiPeiReadOnlyVariablePpiGuid, 0, NULL, (VOID **) &VariablePpi);
   ASSERT_EFI_ERROR (Status);
 
   Size = 0;
-
   Status = VariablePpi->PeiGetVariable (
                           GetPeiServicesTablePointer (),
                           VariableName,
@@ -158,25 +174,30 @@ GetHiiVariable (
                           &Size,
                           NULL
                             );
-  ASSERT (Status == EFI_BUFFER_TOO_SMALL);
+  if (Status == EFI_BUFFER_TOO_SMALL) {
 
-  Status = PeiCoreAllocatePool (Size, &Buffer);
-  ASSERT_EFI_ERROR (Status);
 
-  Status = VariablePpi->PeiGetVariable (
-                            GetPeiServicesTablePointer (),
-                            (UINT16 *) VariableName,
-                            (EFI_GUID *) VariableGuid,
-                            NULL,
-                            &Size,
-                            Buffer
-                            );
-  ASSERT_EFI_ERROR (Status);
+    Status = PeiServicesAllocatePool (Size, &Buffer);
+    ASSERT_EFI_ERROR (Status);
+
+    Status = VariablePpi->PeiGetVariable (
+                              GetPeiServicesTablePointer (),
+                              (UINT16 *) VariableName,
+                              (EFI_GUID *) VariableGuid,
+                              NULL,
+                              &Size,
+                              Buffer
+                              );
+    ASSERT_EFI_ERROR (Status);
 
-  *VariableSize = Size;
-  *VariableData = Buffer;
+    *VariableSize = Size;
+    *VariableData = Buffer;
+
+    return EFI_SUCCESS;
+  } else {
+    return EFI_NOT_FOUND;
+  }
 
-  return EFI_SUCCESS;
 }
 
 
@@ -206,19 +227,23 @@ GetSkuEnabledTokenNumber (
     }
   }
 
-  switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) {
+  switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
     case PCD_TYPE_VPD:
-      Value += sizeof(VPD_HEAD) * i;
+      Value = (UINT8 *) &(((VPD_HEAD *) Value)[i]);
       return ((Value - (UINT8 *) PeiPcdDb) | PCD_TYPE_VPD);
 
     case PCD_TYPE_HII:
-      Value += sizeof(VARIABLE_HEAD) * i;
+      Value = (UINT8 *) &(((VARIABLE_HEAD *) Value)[i]);
       return ((Value - (UINT8 *) PeiPcdDb) | PCD_TYPE_HII);
       
+    case PCD_TYPE_STRING:
+      Value = (UINT8 *) &(((STRING_HEAD *) Value)[i]);
+      return ((Value - (UINT8 *) PeiPcdDb) | PCD_TYPE_STRING);
+
     case PCD_TYPE_DATA:
       Value += Size * i;
       return (Value - (UINT8 *) PeiPcdDb);
-      
+
     default:
       ASSERT (FALSE);
   }
@@ -245,6 +270,13 @@ InvokeCallbackOnSet (
   PCD_PPI_CALLBACK    *CallbackTable;
   UINTN               Idx;
 
+  //
+  // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
+  // We have to decrement TokenNumber by 1 to make it usable
+  // as the array index.
+  //
+  TokenNumber--;
+  
   if (Guid == NULL)
     ASSERT (TokenNumber < PEI_LOCAL_TOKEN_NUMBER);
 
@@ -267,96 +299,74 @@ InvokeCallbackOnSet (
   
 }
 
+
+
 EFI_STATUS
-SetWorker (
-  UINTN         TokenNumber,
-  VOID          *Data,
-  UINTN         Size,
-  BOOLEAN       PtrType
+SetValueWorker (
+  IN          UINTN              TokenNumber,
+  IN          VOID               *Data,
+  IN          UINTN              Size
   )
 {
-  UINT32              LocalTokenNumber;
-  PEI_PCD_DATABASE    *PeiPcdDb;
-
-  ASSERT (TokenNumber < PEI_LOCAL_TOKEN_NUMBER);
-    
-  PeiPcdDb = GetPcdDatabase ();
-
-  LocalTokenNumber = PeiPcdDb->Init.LocalTokenNumberTable[TokenNumber];
-
-  if (PtrType) {
-    ASSERT (PeiPcdDb->Init.SizeTable[TokenNumber] >= Size);
-  } else {
-    ASSERT (PeiPcdDb->Init.SizeTable[TokenNumber] == Size);
-  }
-
-  InvokeCallbackOnSet (0, NULL, TokenNumber, Data, Size);
-
-  return SetWorkerByLocalTokenNumber (LocalTokenNumber, Data, Size, PtrType);
-
+  return SetWorker (TokenNumber, Data, &Size, FALSE);
 }
 
 
 
-
 EFI_STATUS
-ExSetWorker (
-  IN UINT32               ExTokenNumber,
-  IN CONST EFI_GUID       *Guid,
-  VOID                    *Data,
-  UINTN                   Size,
-  BOOLEAN                 PtrType
+SetWorker (
+  IN          UINTN               TokenNumber,
+  IN OUT      VOID                *Data,
+  IN OUT      UINTN               *Size,
+  IN          BOOLEAN             PtrType
   )
 {
-  PEI_PCD_DATABASE          *PeiPcdDb;
-  EX_PCD_ENTRY_ATTRIBUTE    Attr;
+  UINT32              LocalTokenNumber;
+  PEI_PCD_DATABASE    *PeiPcdDb;
+  UINT16              StringTableIdx;
+  UINTN               Offset;
+  VOID                *InternalData;
+  UINTN               MaxSize;
 
+  //
+  // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
+  // We have to decrement TokenNumber by 1 to make it usable
+  // as the array index.
+  //
+  TokenNumber--;
 
+  ASSERT (TokenNumber < PEI_LOCAL_TOKEN_NUMBER);
+    
   PeiPcdDb = GetPcdDatabase ();
 
-  GetExPcdTokenAttributes (Guid, ExTokenNumber, &Attr);
-
-  ASSERT (!PtrType && Attr.Size);
-
-  ASSERT (PtrType && Attr.Size >= Size);
-
-  InvokeCallbackOnSet (ExTokenNumber, Guid, Attr.TokenNumber, Data, Size);
-
-  SetWorkerByLocalTokenNumber (Attr.LocalTokenNumberAlias, Data, Size, PtrType);
-
-  return EFI_SUCCESS;
-  
-}
-
+  LocalTokenNumber = PeiPcdDb->Init.LocalTokenNumberTable[TokenNumber];
 
+  if (!PtrType) {
+    ASSERT (PeiPcdGetSize(TokenNumber + 1) == *Size);
+  }
 
+  //
+  // We only invoke the callback function for Dynamic Type PCD Entry.
+  // For Dynamic EX PCD entry, we have invoked the callback function for Dynamic EX
+  // type PCD entry in ExSetWorker.
+  //
+  if (TokenNumber < PEI_NEX_TOKEN_NUMBER) {
+    InvokeCallbackOnSet (0, NULL, TokenNumber + 1, Data, *Size);
+  }
 
-EFI_STATUS
-SetWorkerByLocalTokenNumber (
-  UINT32        LocalTokenNumber,
-  VOID          *Data,
-  UINTN         Size,
-  BOOLEAN       PtrType
-  )
-{
-  PEI_PCD_DATABASE      *PeiPcdDb;
-  UINT8                 *PeiPcdDbRaw;
-  UINT16                StringTableIdx;
-  UINTN                 Offset;
-  VOID                  *InternalData;
- 
-
-  PeiPcdDb    =    GetPcdDatabase ();
-  PeiPcdDbRaw =    (UINT8 *) PeiPcdDb;
-  
   if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {
-    LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, Size);
+    if (PtrType) {
+      MaxSize = GetPtrTypeSize (TokenNumber, &MaxSize, PeiPcdDb);
+    } else {
+      MaxSize = *Size;
+    }
+    LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, MaxSize);
   }
 
   Offset          = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;
-  InternalData    = (VOID *) (PeiPcdDbRaw + Offset);
+  InternalData    = (VOID *) ((UINT8 *) PeiPcdDb + Offset);
   
-  switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) {
+  switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
     case PCD_TYPE_VPD:
     case PCD_TYPE_HII:
     {
@@ -365,19 +375,26 @@ SetWorkerByLocalTokenNumber (
     }
 
     case PCD_TYPE_STRING:
-      StringTableIdx = *((UINT16 *)InternalData);
-      CopyMem (&PeiPcdDb->Init.StringTable[StringTableIdx], Data, Size);
-      break;
+      if (SetPtrTypeSize (TokenNumber, Size, PeiPcdDb)) {
+        StringTableIdx = *((UINT16 *)InternalData);
+        CopyMem (&PeiPcdDb->Init.StringTable[StringTableIdx], Data, *Size);
+        return EFI_SUCCESS;
+      } else {
+        return EFI_INVALID_PARAMETER;
+      }
 
     case PCD_TYPE_DATA:
     {
-      
       if (PtrType) {
-        CopyMem (InternalData, Data, Size);
-        return EFI_SUCCESS;
+        if (SetPtrTypeSize (TokenNumber, Size, PeiPcdDb)) {
+          CopyMem (InternalData, Data, *Size);
+          return EFI_SUCCESS;
+        } else {
+          return EFI_INVALID_PARAMETER;
+        }
       }
 
-      switch (Size) {
+      switch (*Size) {
         case sizeof(UINT8):
           *((UINT8 *) InternalData) = *((UINT8 *) Data);
           return EFI_SUCCESS;
@@ -404,14 +421,63 @@ SetWorkerByLocalTokenNumber (
 
   ASSERT (FALSE);
   return EFI_NOT_FOUND;
+
+}
+
+
+
+EFI_STATUS
+ExSetValueWorker (
+  IN          UINTN                ExTokenNumber,
+  IN          CONST EFI_GUID       *Guid,
+  IN          VOID                 *Data,
+  IN          UINTN                Size
+  )
+{
+  return ExSetWorker (ExTokenNumber, Guid, Data, &Size, FALSE);
+}
+
+
+
+EFI_STATUS
+ExSetWorker (
+  IN            UINTN                ExTokenNumber,
+  IN            CONST EFI_GUID       *Guid,
+  IN            VOID                 *Data,
+  IN OUT        UINTN                *Size,
+  IN            BOOLEAN              PtrType
+  )
+{
+  UINTN                     TokenNumber;
+
+  TokenNumber = GetExPcdTokenNumber (Guid, ExTokenNumber);
+
+  InvokeCallbackOnSet (ExTokenNumber, Guid, TokenNumber, Data, *Size);
+
+  return SetWorker (TokenNumber, Data, Size, PtrType);
+
 }
 
 
+
+
 VOID *
-GetWorkerByLocalTokenNumber (
-  PEI_PCD_DATABASE    *PeiPcdDb,
-  UINT32              LocalTokenNumber,
-  UINTN               Size
+ExGetWorker (
+  IN CONST  EFI_GUID  *Guid,
+  IN UINTN            ExTokenNumber,
+  IN UINTN            GetSize
+  )
+{
+  return GetWorker (GetExPcdTokenNumber (Guid, ExTokenNumber), GetSize);
+}
+
+
+
+
+VOID *
+GetWorker (
+  UINTN               TokenNumber,
+  UINTN               GetSize
   )
 {
   UINT32              Offset;
@@ -423,17 +489,38 @@ GetWorkerByLocalTokenNumber (
   VOID                *Data;
   UINT16              *StringTable;
   UINT16              StringTableIdx;
-      
+  PEI_PCD_DATABASE    *PeiPcdDb;
+  UINT32              LocalTokenNumber;
+  UINTN               MaxSize;
+
+  //
+  // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
+  // We have to decrement TokenNumber by 1 to make it usable
+  // as the array index.
+  //
+  TokenNumber--;
+
+  ASSERT (TokenNumber < PEI_LOCAL_TOKEN_NUMBER);
+
+  ASSERT ((GetSize == PeiPcdGetSize(TokenNumber + 1)) || (GetSize == 0));
+
   PeiPcdDb        = GetPcdDatabase ();
 
+  LocalTokenNumber = PeiPcdDb->Init.LocalTokenNumberTable[TokenNumber];
+
   if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {
-    LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, Size);
+    if (GetSize == 0) {
+      MaxSize = GetPtrTypeSize (TokenNumber, &MaxSize, PeiPcdDb);
+    } else {
+      MaxSize = GetSize;
+    }
+    LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, MaxSize);
   }
 
   Offset      = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;
   StringTable = PeiPcdDb->Init.StringTable;
   
-  switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) {
+  switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
     case PCD_TYPE_VPD:
     {
       VPD_HEAD *VpdHead;
@@ -449,15 +536,19 @@ GetWorkerByLocalTokenNumber (
       Name = &StringTable[VariableHead->StringIndex];
 
       Status = GetHiiVariable (Guid, Name, &Data, &DataSize);
-      ASSERT_EFI_ERROR (Status);
-      ASSERT (DataSize >= (UINTN) (VariableHead->Offset + Size));
 
-      return (VOID *) ((UINT8 *) Data + VariableHead->Offset);
+      if (Status == EFI_SUCCESS) {
+        return (VOID *) ((UINT8 *) Data + VariableHead->Offset);
+      } else {
+        //
+        // Return the default value specified by Platform Integrator 
+        //
+        return (VOID *) ((UINT8 *) PeiPcdDb + VariableHead->DefaultValueOffset);
+      }
     }
 
     case PCD_TYPE_DATA:
       return (VOID *) ((UINT8 *)PeiPcdDb + Offset);
-      break;
 
     case PCD_TYPE_STRING:
       StringTableIdx = (UINT16) *((UINT8 *) PeiPcdDb + Offset);
@@ -476,72 +567,43 @@ GetWorkerByLocalTokenNumber (
 }
 
 
-VOID *
-ExGetWorker (
-  IN CONST  EFI_GUID  *Guid,
-  IN UINT32           ExTokenNumber,
-  IN UINTN            GetSize
-  )
-{
-  EX_PCD_ENTRY_ATTRIBUTE      Attr;
-
-  GetExPcdTokenAttributes (Guid, ExTokenNumber, &Attr);
-  
-  ASSERT ((GetSize == Attr.Size) || (GetSize == 0));
-
-  return GetWorkerByLocalTokenNumber (GetPcdDatabase(),
-                                      Attr.LocalTokenNumberAlias,
-                                      Attr.Size
-                                      );
-}
-
-VOID *
-GetWorker (
-  UINTN  TokenNumber,
-  UINTN   GetSize
-  )
-{
-  PEI_PCD_DATABASE      *PeiPcdDb;
-
-  ASSERT (TokenNumber < PEI_LOCAL_TOKEN_NUMBER);
-
-  ASSERT (GetSize == PeiPcdGetSize (TokenNumber) || GetSize == 0);
-
-  PeiPcdDb = GetPcdDatabase ();
-  
-  return  GetWorkerByLocalTokenNumber (PeiPcdDb, PeiPcdDb->Init.LocalTokenNumberTable[TokenNumber], GetSize);
-}
-
-
-VOID
-GetExPcdTokenAttributes (
+UINTN           
+GetExPcdTokenNumber (
   IN CONST EFI_GUID             *Guid,
-  IN UINT32                     ExTokenNumber,
-  OUT EX_PCD_ENTRY_ATTRIBUTE    *ExAttr
+  IN UINT32                     ExTokenNumber
   )
 {
   UINT32              i;
   DYNAMICEX_MAPPING   *ExMap;
   EFI_GUID            *GuidTable;
+  EFI_GUID            *MatchGuid;
+  UINTN               MatchGuidIdx;
   PEI_PCD_DATABASE    *PeiPcdDb;
 
   PeiPcdDb    = GetPcdDatabase();
   
   ExMap       = PeiPcdDb->Init.ExMapTable;
   GuidTable   = PeiPcdDb->Init.GuidTable;
+
+  MatchGuid = ScanGuid (GuidTable, sizeof(PeiPcdDb->Init.GuidTable), Guid);
+  //
+  // We need to ASSERT here. If GUID can't be found in GuidTable, this is a
+  // error in the BUILD system.
+  //
+  ASSERT (MatchGuid != NULL);
+  
+  MatchGuidIdx = MatchGuid - GuidTable;
   
   for (i = 0; i < PEI_EXMAPPING_TABLE_SIZE; i++) {
     if ((ExTokenNumber == ExMap[i].ExTokenNumber) && 
-        CompareGuid (Guid, (CONST EFI_GUID *) &GuidTable[ExMap[i].ExGuidIndex])) {
-      ExAttr->TokenNumber               = i + PEI_NEX_TOKEN_NUMBER;
-      ExAttr->Size                      = PeiPcdDb->Init.SizeTable[i + PEI_NEX_TOKEN_NUMBER];
-      ExAttr->LocalTokenNumberAlias     = ExMap[i].LocalTokenNumber;
+        (MatchGuidIdx == ExMap[i].ExGuidIndex)) {
+      return ExMap[i].LocalTokenNumber;
     }
   }
   
   ASSERT (FALSE);
   
-  return;
+  return 0;
 }
 
 
@@ -559,3 +621,208 @@ GetPcdDatabase (
   return (PEI_PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob);
 }
 
+
+SKU_ID *
+GetSkuIdArray (
+  IN    UINTN             LocalTokenNumberTableIdx,
+  IN    PEI_PCD_DATABASE  *Database
+  )
+{
+  SKU_HEAD *SkuHead;
+  UINTN     LocalTokenNumber;
+
+  LocalTokenNumber = Database->Init.LocalTokenNumberTable[LocalTokenNumberTableIdx];
+
+  ASSERT ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) != 0);
+
+  SkuHead = (SKU_HEAD *) ((UINT8 *)Database + (LocalTokenNumber & PCD_DATABASE_OFFSET_MASK));
+
+  return (SKU_ID *) ((UINT8 *)Database + SkuHead->SkuIdTableOffset);
+  
+}
+
+
+
+UINTN
+GetSizeTableIndex (
+  IN    UINTN             LocalTokenNumberTableIdx,
+  IN    PEI_PCD_DATABASE  *Database
+  )
+{
+  UINTN       i;
+  UINTN        SizeTableIdx;
+  UINTN       LocalTokenNumber;
+  SKU_ID      *SkuIdTable;
+  
+  SizeTableIdx = 0;
+
+  for (i=0; i<LocalTokenNumberTableIdx; i++) {
+    LocalTokenNumber = Database->Init.LocalTokenNumberTable[i];
+
+    if ((LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) == PCD_DATUM_TYPE_POINTER) {
+      //
+      // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type 
+      // PCD entry.
+      //
+      if (LocalTokenNumber & PCD_TYPE_VPD) {
+          //
+          // We have only one entry for VPD enabled PCD entry:
+          // 1) MAX Size.
+          // We consider current size is equal to MAX size.
+          //
+          SizeTableIdx++;
+      } else {
+        if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0) {
+          //
+          // We have only two entry for Non-Sku enabled PCD entry:
+          // 1) MAX SIZE
+          // 2) Current Size
+          //
+          SizeTableIdx += 2;
+        } else {
+          //
+          // We have these entry for SKU enabled PCD entry
+          // 1) MAX SIZE
+          // 2) Current Size for each SKU_ID (It is equal to MaxSku).
+          //
+          SkuIdTable = GetSkuIdArray (i, Database);
+          SizeTableIdx += (UINTN)*SkuIdTable + 1;
+        }
+      }
+    }
+
+  }
+
+  return SizeTableIdx;
+}
+
+
+
+
+UINTN
+GetPtrTypeSize (
+  IN    UINTN             LocalTokenNumberTableIdx,
+  OUT   UINTN             *MaxSize,
+  IN    PEI_PCD_DATABASE  *Database
+  )
+{
+  INTN        SizeTableIdx;
+  UINTN       LocalTokenNumber;
+  SKU_ID      *SkuIdTable;
+  SIZE_INFO   *SizeTable;
+  UINTN       i;
+
+  SizeTableIdx = GetSizeTableIndex (LocalTokenNumberTableIdx, Database);
+
+  LocalTokenNumber = Database->Init.LocalTokenNumberTable[LocalTokenNumberTableIdx];
+
+  ASSERT ((LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) == PCD_DATUM_TYPE_POINTER);
+  
+  SizeTable = Database->Init.SizeTable;
+
+  *MaxSize = SizeTable[SizeTableIdx];
+  //
+  // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type 
+  // PCD entry.
+  //
+  if (LocalTokenNumber & PCD_TYPE_VPD) {
+      //
+      // We have only one entry for VPD enabled PCD entry:
+      // 1) MAX Size.
+      // We consider current size is equal to MAX size.
+      //
+      return *MaxSize;
+  } else {
+    if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0) {
+      //
+      // We have only two entry for Non-Sku enabled PCD entry:
+      // 1) MAX SIZE
+      // 2) Current Size
+      //
+      return SizeTable[SizeTableIdx + 1];
+    } else {
+      //
+      // We have these entry for SKU enabled PCD entry
+      // 1) MAX SIZE
+      // 2) Current Size for each SKU_ID (It is equal to MaxSku).
+      //
+      SkuIdTable = GetSkuIdArray (LocalTokenNumberTableIdx, Database);
+      for (i = 0; i < SkuIdTable[0]; i++) {
+        if (SkuIdTable[1 + i] == Database->Init.SystemSkuId) {
+          return SizeTable[SizeTableIdx + 1 + i];
+        }
+      }
+      return SizeTable[SizeTableIdx + 1];
+    }
+  }
+}
+
+
+
+BOOLEAN
+SetPtrTypeSize (
+  IN          UINTN             LocalTokenNumberTableIdx,
+  IN    OUT   UINTN             *CurrentSize,
+  IN          PEI_PCD_DATABASE  *Database
+  )
+{
+  INTN        SizeTableIdx;
+  UINTN       LocalTokenNumber;
+  SKU_ID      *SkuIdTable;
+  SIZE_INFO   *SizeTable;
+  UINTN       i;
+  UINTN       MaxSize;
+  
+  SizeTableIdx = GetSizeTableIndex (LocalTokenNumberTableIdx, Database);
+
+  LocalTokenNumber = Database->Init.LocalTokenNumberTable[LocalTokenNumberTableIdx];
+
+  ASSERT ((LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) == PCD_DATUM_TYPE_POINTER);
+  
+  SizeTable = Database->Init.SizeTable;
+
+  MaxSize = SizeTable[SizeTableIdx];
+  //
+  // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type 
+  // PCD entry.
+  //
+  if (LocalTokenNumber & PCD_TYPE_VPD) {
+      //
+      // We shouldn't come here as we don't support SET for VPD
+      //
+      ASSERT (FALSE);
+      return FALSE;
+  } else {
+    if ((*CurrentSize > MaxSize) ||
+      (*CurrentSize == MAX_ADDRESS)) {
+       *CurrentSize = MaxSize;
+       return FALSE;
+    } 
+    
+    if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0) {
+      //
+      // We have only two entry for Non-Sku enabled PCD entry:
+      // 1) MAX SIZE
+      // 2) Current Size
+      //
+      SizeTable[SizeTableIdx + 1] = (SIZE_INFO) *CurrentSize;
+      return TRUE;
+    } else {
+      //
+      // We have these entry for SKU enabled PCD entry
+      // 1) MAX SIZE
+      // 2) Current Size for each SKU_ID (It is equal to MaxSku).
+      //
+      SkuIdTable = GetSkuIdArray (LocalTokenNumberTableIdx, Database);
+      for (i = 0; i < SkuIdTable[0]; i++) {
+        if (SkuIdTable[1 + i] == Database->Init.SystemSkuId) {
+          SizeTable[SizeTableIdx + 1 + i] = (SIZE_INFO) *CurrentSize;
+          return TRUE;
+        }
+      }
+      SizeTable[SizeTableIdx + 1] = (SIZE_INFO) *CurrentSize;
+      return TRUE;
+    }
+  }
+
+}