MdeModulePkg/Universal/PCD/Pei/Service.c

   1 /** @file
   2   The driver internal functions are implmented here.
   3   They build Pei PCD database, and provide access service to PCD database.
   4
   5 Copyright (c) 2006 - 2010, Intel Corporation
   6 All rights reserved. This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "Service.h"
  17
  18 /**
  19   The function registers the CallBackOnSet fucntion
  20   according to TokenNumber and EFI_GUID space.
  21
  22   @param  ExTokenNumber       The token number.
  23   @param  Guid              The GUID space.
  24   @param  CallBackFunction  The Callback function to be registered.
  25   @param  Register          To register or unregister the callback function.
  26
  27   @retval EFI_SUCCESS If the Callback function is registered.
  28   @retval EFI_NOT_FOUND If the PCD Entry is not found according to Token Number and GUID space.
  29   @retval EFI_OUT_OF_RESOURCES If the callback function can't be registered because there is not free
  30                                 slot left in the CallbackFnTable.
  31 **/
  32 EFI_STATUS
  33 PeiRegisterCallBackWorker (
  34   IN  UINTN                       ExTokenNumber,
  35   IN  CONST EFI_GUID              *Guid, OPTIONAL
  36   IN  PCD_PPI_CALLBACK            CallBackFunction,
  37   IN  BOOLEAN                     Register
  38 )
  39 {
  40   EFI_HOB_GUID_TYPE       *GuidHob;
  41   PCD_PPI_CALLBACK        *CallbackTable;
  42   PCD_PPI_CALLBACK        Compare;
  43   PCD_PPI_CALLBACK        Assign;
  44   UINT32                  LocalTokenNumber;
  45   UINTN                   TokenNumber;
  46   UINTN                   Idx;
  47
  48   if (Guid == NULL) {
  49     TokenNumber = ExTokenNumber;
  50
  51     //
  52     // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
  53     // We have to decrement TokenNumber by 1 to make it usable
  54     // as the array index.
  55     //
  56     TokenNumber--;
  57     ASSERT (TokenNumber + 1 < PEI_NEX_TOKEN_NUMBER + 1);
  58   } else {
  59     TokenNumber = GetExPcdTokenNumber (Guid, ExTokenNumber);
  60     if (TokenNumber == PCD_INVALID_TOKEN_NUMBER) {
  61       return EFI_NOT_FOUND;
  62     }
  63
  64     //
  65     // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
  66     // We have to decrement TokenNumber by 1 to make it usable
  67     // as the array index.
  68     //
  69     TokenNumber--;
  70     // EBC compiler is very choosy. It may report warning about comparison
  71     // between UINTN and 0 . So we add 1 in each size of the
  72     // comparison.
  73     ASSERT (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);
  74   }
  75
  76
  77   LocalTokenNumber = GetPcdDatabase()->Init.LocalTokenNumberTable[TokenNumber];
  78
  79   //
  80   // We don't support SET for HII and VPD type PCD entry in PEI phase.
  81   // So we will assert if any register callback for such PCD entry.
  82   //
  83   ASSERT ((LocalTokenNumber & PCD_TYPE_HII) == 0);
  84   ASSERT ((LocalTokenNumber & PCD_TYPE_VPD) == 0);
  85
  86   GuidHob = GetFirstGuidHob (&gEfiCallerIdGuid);
  87   ASSERT (GuidHob != NULL);
  88
  89   CallbackTable = GET_GUID_HOB_DATA (GuidHob);
  90   CallbackTable = CallbackTable + (TokenNumber * PcdGet32 (PcdMaxPeiPcdCallBackNumberPerPcdEntry));
  91
  92   Compare = Register? NULL: CallBackFunction;
  93   Assign  = Register? CallBackFunction: NULL;
  94
  95
  96   for (Idx = 0; Idx < PcdGet32 (PcdMaxPeiPcdCallBackNumberPerPcdEntry); Idx++) {
  97     if (CallbackTable[Idx] == Compare) {
  98       CallbackTable[Idx] = Assign;
  99       return EFI_SUCCESS;
 100     }
 101   }
 102
 103   return Register? EFI_OUT_OF_RESOURCES : EFI_NOT_FOUND;
 104
 105 }
 106
 107 /**
 108   The function builds the PCD database.
 109 **/
 110 VOID
 111 BuildPcdDatabase (
 112   VOID
 113   )
 114 {
 115   PEI_PCD_DATABASE  *Database;
 116   VOID              *CallbackFnTable;
 117   UINTN             SizeOfCallbackFnTable;
 118
 119   Database = BuildGuidHob (&gPcdDataBaseHobGuid, sizeof (PEI_PCD_DATABASE));
 120
 121   ZeroMem (Database, sizeof (PEI_PCD_DATABASE));
 122
 123   //
 124   // gPEIPcdDbInit is smaller than PEI_PCD_DATABASE
 125   //
 126
 127   CopyMem (&Database->Init, &gPEIPcdDbInit, sizeof (gPEIPcdDbInit));
 128
 129   SizeOfCallbackFnTable = PEI_LOCAL_TOKEN_NUMBER * sizeof (PCD_PPI_CALLBACK) * PcdGet32 (PcdMaxPeiPcdCallBackNumberPerPcdEntry);
 130
 131   CallbackFnTable = BuildGuidHob (&gEfiCallerIdGuid, SizeOfCallbackFnTable);
 132
 133   ZeroMem (CallbackFnTable, SizeOfCallbackFnTable);
 134 }
 135
 136 /**
 137   The function is provided by PCD PEIM and PCD DXE driver to
 138   do the work of reading a HII variable from variable service.
 139
 140   @param VariableGuid     The Variable GUID.
 141   @param VariableName     The Variable Name.
 142   @param VariableData    The output data.
 143   @param VariableSize    The size of the variable.
 144
 145   @retval EFI_SUCCESS         Operation successful.
 146   @retval EFI_NOT_FOUND         Variablel not found.
 147 **/
 148 EFI_STATUS
 149 GetHiiVariable (
 150   IN  CONST EFI_GUID      *VariableGuid,
 151   IN  UINT16              *VariableName,
 152   OUT VOID                **VariableData,
 153   OUT UINTN               *VariableSize
 154   )
 155 {
 156   UINTN      Size;
 157   EFI_STATUS Status;
 158   VOID       *Buffer;
 159   EFI_PEI_READ_ONLY_VARIABLE2_PPI *VariablePpi;
 160
 161   Status = PeiServicesLocatePpi (&gEfiPeiReadOnlyVariable2PpiGuid, 0, NULL, (VOID **) &VariablePpi);
 162   ASSERT_EFI_ERROR (Status);
 163
 164   Size = 0;
 165   Status = VariablePpi->GetVariable (
 166                           VariablePpi,
 167                           VariableName,
 168                           (EFI_GUID *) VariableGuid,
 169                           NULL,
 170                           &Size,
 171                           NULL
 172                           );
 173
 174   if (Status == EFI_BUFFER_TOO_SMALL) {
 175     Status = PeiServicesAllocatePool (Size, &Buffer);
 176     ASSERT_EFI_ERROR (Status);
 177
 178     Status = VariablePpi->GetVariable (
 179                               VariablePpi,
 180                               (UINT16 *) VariableName,
 181                               (EFI_GUID *) VariableGuid,
 182                               NULL,
 183                               &Size,
 184                               Buffer
 185                               );
 186     ASSERT_EFI_ERROR (Status);
 187
 188     *VariableSize = Size;
 189     *VariableData = Buffer;
 190
 191     return EFI_SUCCESS;
 192   }
 193
 194   return EFI_NOT_FOUND;
 195 }
 196
 197 /**
 198   Find the local token number according to system SKU ID.
 199
 200   @param LocalTokenNumber PCD token number
 201   @param Size             The size of PCD entry.
 202
 203   @return Token number according to system SKU ID.
 204
 205 **/
 206 UINT32
 207 GetSkuEnabledTokenNumber (
 208   UINT32 LocalTokenNumber,
 209   UINTN  Size
 210   )
 211 {
 212   PEI_PCD_DATABASE      *PeiPcdDb;
 213   SKU_HEAD              *SkuHead;
 214   SKU_ID                *SkuIdTable;
 215   INTN                  Index;
 216   UINT8                 *Value;
 217
 218   PeiPcdDb = GetPcdDatabase ();
 219
 220   ASSERT ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0);
 221
 222   SkuHead     = (SKU_HEAD *) ((UINT8 *)PeiPcdDb + (LocalTokenNumber & PCD_DATABASE_OFFSET_MASK));
 223   Value       = (UINT8 *) ((UINT8 *)PeiPcdDb + (SkuHead->SkuDataStartOffset));
 224   SkuIdTable  = (SKU_ID *) ((UINT8 *)PeiPcdDb + (SkuHead->SkuIdTableOffset));
 225
 226   for (Index = 0; Index < SkuIdTable[0]; Index++) {
 227     if (PeiPcdDb->Init.SystemSkuId == SkuIdTable[Index + 1]) {
 228       break;
 229     }
 230   }
 231
 232   switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
 233     case PCD_TYPE_VPD:
 234       Value = (UINT8 *) &(((VPD_HEAD *) Value)[Index]);
 235       return (UINT32) ((Value - (UINT8 *) PeiPcdDb) | PCD_TYPE_VPD);
 236
 237     case PCD_TYPE_HII:
 238       Value = (UINT8 *) &(((VARIABLE_HEAD *) Value)[Index]);
 239       return (UINT32) ((Value - (UINT8 *) PeiPcdDb) | PCD_TYPE_HII);
 240
 241     case PCD_TYPE_STRING:
 242       Value = (UINT8 *) &(((STRING_HEAD *) Value)[Index]);
 243       return (UINT32) ((Value - (UINT8 *) PeiPcdDb) | PCD_TYPE_STRING);
 244
 245     case PCD_TYPE_DATA:
 246       Value += Size * Index;
 247       return (UINT32) (Value - (UINT8 *) PeiPcdDb);
 248
 249     default:
 250       ASSERT (FALSE);
 251   }
 252
 253   ASSERT (FALSE);
 254
 255   return 0;
 256 }
 257
 258 /**
 259   Invoke the callback function when dynamic PCD entry was set, if this PCD entry
 260   has registered callback function.
 261
 262   @param ExTokenNumber   DynamicEx PCD's token number, if this PCD entry is dyanmicEx
 263                          type PCD.
 264   @param Guid            DynamicEx PCD's guid, if this PCD entry is dynamicEx type
 265                          PCD.
 266   @param TokenNumber     PCD token number generated by build tools.
 267   @param Data            Value want to be set for this PCD entry
 268   @param Size            The size of value
 269
 270 **/
 271 VOID
 272 InvokeCallbackOnSet (
 273   UINTN             ExTokenNumber,
 274   CONST EFI_GUID    *Guid, OPTIONAL
 275   UINTN             TokenNumber,
 276   VOID              *Data,
 277   UINTN             Size
 278   )
 279 {
 280   EFI_HOB_GUID_TYPE   *GuidHob;
 281   PCD_PPI_CALLBACK    *CallbackTable;
 282   UINTN               Idx;
 283
 284   //
 285   // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
 286   // We have to decrement TokenNumber by 1 to make it usable
 287   // as the array index.
 288   //
 289   TokenNumber--;
 290
 291   if (Guid == NULL) {
 292     // EBC compiler is very choosy. It may report warning about comparison
 293     // between UINTN and 0 . So we add 1 in each size of the
 294     // comparison.
 295     ASSERT (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);
 296   }
 297
 298   GuidHob = GetFirstGuidHob (&gEfiCallerIdGuid);
 299   ASSERT (GuidHob != NULL);
 300
 301   CallbackTable = GET_GUID_HOB_DATA (GuidHob);
 302
 303   CallbackTable += (TokenNumber * PcdGet32 (PcdMaxPeiPcdCallBackNumberPerPcdEntry));
 304
 305   for (Idx = 0; Idx < PcdGet32 (PcdMaxPeiPcdCallBackNumberPerPcdEntry); Idx++) {
 306     if (CallbackTable[Idx] != NULL) {
 307       CallbackTable[Idx] (Guid,
 308                           (Guid == NULL) ? (TokenNumber + 1) : ExTokenNumber,
 309                           Data,
 310                           Size
 311                           );
 312     }
 313   }
 314 }
 315
 316 /**
 317   Wrapper function for setting non-pointer type value for a PCD entry.
 318
 319   @param TokenNumber     Pcd token number autogenerated by build tools.
 320   @param Data            Value want to be set for PCD entry
 321   @param Size            Size of value.
 322
 323   @return status of SetWorker.
 324
 325 **/
 326 EFI_STATUS
 327 SetValueWorker (
 328   IN          UINTN              TokenNumber,
 329   IN          VOID               *Data,
 330   IN          UINTN              Size
 331   )
 332 {
 333   return SetWorker (TokenNumber, Data, &Size, FALSE);
 334 }
 335
 336 /**
 337   Set value for an PCD entry
 338
 339   @param TokenNumber     Pcd token number autogenerated by build tools.
 340   @param Data            Value want to be set for PCD entry
 341   @param Size            Size of value.
 342   @param PtrType         If TRUE, the type of PCD entry's value is Pointer.
 343                          If False, the type of PCD entry's value is not Pointer.
 344
 345   @retval EFI_INVALID_PARAMETER  If this PCD type is VPD, VPD PCD can not be set.
 346   @retval EFI_INVALID_PARAMETER  If Size can not be set to size table.
 347   @retval EFI_INVALID_PARAMETER  If Size of non-Ptr type PCD does not match the size information in PCD database.
 348   @retval EFI_NOT_FOUND          If value type of PCD entry is intergrate, but not in
 349                                  range of UINT8, UINT16, UINT32, UINT64
 350   @retval EFI_NOT_FOUND          Can not find the PCD type according to token number.
 351 **/
 352 EFI_STATUS
 353 SetWorker (
 354   IN          UINTN               TokenNumber,
 355   IN          VOID                *Data,
 356   IN OUT      UINTN               *Size,
 357   IN          BOOLEAN             PtrType
 358   )
 359 {
 360   UINT32              LocalTokenNumber;
 361   PEI_PCD_DATABASE    *PeiPcdDb;
 362   UINT16              StringTableIdx;
 363   UINTN               Offset;
 364   VOID                *InternalData;
 365   UINTN               MaxSize;
 366
 367   if (!FeaturePcdGet(PcdPeiFullPcdDatabaseEnable)) {
 368     return EFI_UNSUPPORTED;
 369   }
 370
 371   //
 372   // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
 373   // We have to decrement TokenNumber by 1 to make it usable
 374   // as the array index.
 375   //
 376   TokenNumber--;
 377
 378   // EBC compiler is very choosy. It may report warning about comparison
 379   // between UINTN and 0 . So we add 1 in each size of the
 380   // comparison.
 381   ASSERT (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);
 382
 383   PeiPcdDb = GetPcdDatabase ();
 384
 385   LocalTokenNumber = PeiPcdDb->Init.LocalTokenNumberTable[TokenNumber];
 386
 387   if ((!PtrType) && (PeiPcdGetSize(TokenNumber + 1) != *Size)) {
 388     return EFI_INVALID_PARAMETER;
 389   }
 390
 391   //
 392   // We only invoke the callback function for Dynamic Type PCD Entry.
 393   // For Dynamic EX PCD entry, we have invoked the callback function for Dynamic EX
 394   // type PCD entry in ExSetWorker.
 395   //
 396   if (TokenNumber + 1 < PEI_NEX_TOKEN_NUMBER + 1) {
 397     InvokeCallbackOnSet (0, NULL, TokenNumber + 1, Data, *Size);
 398   }
 399
 400   if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {
 401     if (PtrType) {
 402       MaxSize = GetPtrTypeSize (TokenNumber, &MaxSize, PeiPcdDb);
 403     } else {
 404       MaxSize = *Size;
 405     }
 406     LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, MaxSize);
 407   }
 408
 409   Offset          = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;
 410   InternalData    = (VOID *) ((UINT8 *) PeiPcdDb + Offset);
 411
 412   switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
 413     case PCD_TYPE_VPD:
 414     case PCD_TYPE_HII:
 415     case PCD_TYPE_HII|PCD_TYPE_STRING:
 416     {
 417       ASSERT (FALSE);
 418       return EFI_INVALID_PARAMETER;
 419     }
 420
 421     case PCD_TYPE_STRING:
 422       if (SetPtrTypeSize (TokenNumber, Size, PeiPcdDb)) {
 423         StringTableIdx = *((UINT16 *)InternalData);
 424         CopyMem (&PeiPcdDb->Init.StringTable[StringTableIdx], Data, *Size);
 425         return EFI_SUCCESS;
 426       } else {
 427         return EFI_INVALID_PARAMETER;
 428       }
 429
 430     case PCD_TYPE_DATA:
 431     {
 432       if (PtrType) {
 433         if (SetPtrTypeSize (TokenNumber, Size, PeiPcdDb)) {
 434           CopyMem (InternalData, Data, *Size);
 435           return EFI_SUCCESS;
 436         } else {
 437           return EFI_INVALID_PARAMETER;
 438         }
 439       }
 440
 441       switch (*Size) {
 442         case sizeof(UINT8):
 443           *((UINT8 *) InternalData) = *((UINT8 *) Data);
 444           return EFI_SUCCESS;
 445
 446         case sizeof(UINT16):
 447           *((UINT16 *) InternalData) = *((UINT16 *) Data);
 448           return EFI_SUCCESS;
 449
 450         case sizeof(UINT32):
 451           *((UINT32 *) InternalData) = *((UINT32 *) Data);
 452           return EFI_SUCCESS;
 453
 454         case sizeof(UINT64):
 455           *((UINT64 *) InternalData) = *((UINT64 *) Data);
 456           return EFI_SUCCESS;
 457
 458         default:
 459           ASSERT (FALSE);
 460           return EFI_NOT_FOUND;
 461       }
 462     }
 463
 464   }
 465
 466   ASSERT (FALSE);
 467   return EFI_NOT_FOUND;
 468
 469 }
 470
 471 /**
 472   Wrapper function for set PCD value for non-Pointer type dynamic-ex PCD.
 473
 474   @param ExTokenNumber   Token number for dynamic-ex PCD.
 475   @param Guid            Token space guid for dynamic-ex PCD.
 476   @param Data            Value want to be set.
 477   @param SetSize         The size of value.
 478
 479   @return status of ExSetWorker().
 480
 481 **/
 482 EFI_STATUS
 483 ExSetValueWorker (
 484   IN          UINTN                ExTokenNumber,
 485   IN          CONST EFI_GUID       *Guid,
 486   IN          VOID                 *Data,
 487   IN          UINTN                Size
 488   )
 489 {
 490   return ExSetWorker (ExTokenNumber, Guid, Data, &Size, FALSE);
 491 }
 492
 493 /**
 494   Set value for a dynamic PCD entry.
 495
 496   This routine find the local token number according to dynamic-ex PCD's token
 497   space guid and token number firstly, and invoke callback function if this PCD
 498   entry registered callback function. Finally, invoken general SetWorker to set
 499   PCD value.
 500
 501   @param ExTokenNumber   Dynamic-ex PCD token number.
 502   @param Guid            Token space guid for dynamic-ex PCD.
 503   @param Data            PCD value want to be set
 504   @param SetSize         Size of value.
 505   @param PtrType         If TRUE, this PCD entry is pointer type.
 506                          If FALSE, this PCD entry is not pointer type.
 507
 508   @return status of SetWorker().
 509
 510 **/
 511 EFI_STATUS
 512 ExSetWorker (
 513   IN            UINTN                ExTokenNumber,
 514   IN            CONST EFI_GUID       *Guid,
 515   IN            VOID                 *Data,
 516   IN OUT        UINTN                *Size,
 517   IN            BOOLEAN              PtrType
 518   )
 519 {
 520   UINTN                     TokenNumber;
 521
 522   if (!FeaturePcdGet(PcdPeiFullPcdDatabaseEnable)) {
 523     return EFI_UNSUPPORTED;
 524   }
 525
 526   TokenNumber = GetExPcdTokenNumber (Guid, ExTokenNumber);
 527   if (TokenNumber == PCD_INVALID_TOKEN_NUMBER) {
 528     return EFI_NOT_FOUND;
 529   }
 530
 531   InvokeCallbackOnSet (ExTokenNumber, Guid, TokenNumber, Data, *Size);
 532
 533   return SetWorker (TokenNumber, Data, Size, PtrType);
 534
 535 }
 536
 537 /**
 538   Wrapper function for get PCD value for dynamic-ex PCD.
 539
 540   @param Guid            Token space guid for dynamic-ex PCD.
 541   @param ExTokenNumber   Token number for dyanmic-ex PCD.
 542   @param GetSize         The size of dynamic-ex PCD value.
 543
 544   @return PCD entry in PCD database.
 545
 546 **/
 547 VOID *
 548 ExGetWorker (
 549   IN CONST  EFI_GUID  *Guid,
 550   IN UINTN            ExTokenNumber,
 551   IN UINTN            GetSize
 552   )
 553 {
 554   return GetWorker (GetExPcdTokenNumber (Guid, ExTokenNumber), GetSize);
 555 }
 556
 557 /**
 558   Get the PCD entry pointer in PCD database.
 559
 560   This routine will visit PCD database to find the PCD entry according to given
 561   token number. The given token number is autogened by build tools and it will be
 562   translated to local token number. Local token number contains PCD's type and
 563   offset of PCD entry in PCD database.
 564
 565   @param TokenNumber     Token's number, it is autogened by build tools
 566   @param GetSize         The size of token's value
 567
 568   @return PCD entry pointer in PCD database
 569
 570 **/
 571 VOID *
 572 GetWorker (
 573   IN UINTN               TokenNumber,
 574   IN UINTN               GetSize
 575   )
 576 {
 577   UINT32              Offset;
 578   EFI_GUID            *Guid;
 579   UINT16              *Name;
 580   VARIABLE_HEAD       *VariableHead;
 581   EFI_STATUS          Status;
 582   UINTN               DataSize;
 583   VOID                *Data;
 584   UINT8               *StringTable;
 585   UINT16              StringTableIdx;
 586   PEI_PCD_DATABASE    *PeiPcdDb;
 587   UINT32              LocalTokenNumber;
 588   UINTN               MaxSize;
 589
 590   //
 591   // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
 592   // We have to decrement TokenNumber by 1 to make it usable
 593   // as the array index.
 594   //
 595   TokenNumber--;
 596
 597   // EBC compiler is very choosy. It may report warning about comparison
 598   // between UINTN and 0 . So we add 1 in each size of the
 599   // comparison.
 600   ASSERT (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);
 601
 602   ASSERT ((GetSize == PeiPcdGetSize(TokenNumber + 1)) || (GetSize == 0));
 603
 604   PeiPcdDb        = GetPcdDatabase ();
 605
 606   LocalTokenNumber = PeiPcdDb->Init.LocalTokenNumberTable[TokenNumber];
 607
 608   if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {
 609     if (GetSize == 0) {
 610       MaxSize = GetPtrTypeSize (TokenNumber, &MaxSize, PeiPcdDb);
 611     } else {
 612       MaxSize = GetSize;
 613     }
 614     LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, MaxSize);
 615   }
 616
 617   Offset      = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;
 618   StringTable = PeiPcdDb->Init.StringTable;
 619
 620   switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
 621     case PCD_TYPE_VPD:
 622     {
 623       VPD_HEAD *VpdHead;
 624       VpdHead = (VPD_HEAD *) ((UINT8 *)PeiPcdDb + Offset);
 625       return (VOID *) (UINTN) (PcdGet32 (PcdVpdBaseAddress) + VpdHead->Offset);
 626     }
 627
 628     case PCD_TYPE_HII|PCD_TYPE_STRING:
 629     case PCD_TYPE_HII:
 630     {
 631       VariableHead = (VARIABLE_HEAD *) ((UINT8 *)PeiPcdDb + Offset);
 632
 633       Guid = &(PeiPcdDb->Init.GuidTable[VariableHead->GuidTableIndex]);
 634       Name = (UINT16*)&StringTable[VariableHead->StringIndex];
 635
 636       Status = GetHiiVariable (Guid, Name, &Data, &DataSize);
 637
 638       if (Status == EFI_SUCCESS) {
 639         return (VOID *) ((UINT8 *) Data + VariableHead->Offset);
 640       } else {
 641         //
 642         // Return the default value specified by Platform Integrator
 643         //
 644         if ((LocalTokenNumber & PCD_TYPE_ALL_SET) == (PCD_TYPE_HII|PCD_TYPE_STRING)) {
 645           return (VOID*)&StringTable[*(UINT16*)((UINT8*)PeiPcdDb + VariableHead->DefaultValueOffset)];
 646         } else {
 647           return (VOID *) ((UINT8 *) PeiPcdDb + VariableHead->DefaultValueOffset);
 648         }
 649       }
 650     }
 651
 652     case PCD_TYPE_DATA:
 653       return (VOID *) ((UINT8 *)PeiPcdDb + Offset);
 654
 655     case PCD_TYPE_STRING:
 656       StringTableIdx = * (UINT16*) ((UINT8 *) PeiPcdDb + Offset);
 657       return (VOID *) (&StringTable[StringTableIdx]);
 658
 659     default:
 660       ASSERT (FALSE);
 661       break;
 662
 663   }
 664
 665   ASSERT (FALSE);
 666
 667   return NULL;
 668
 669 }
 670
 671 /**
 672   Get local token number according to dynamic-ex PCD's {token space guid:token number}
 673
 674   A dynamic-ex type PCD, developer must provide pair of token space guid: token number
 675   in DEC file. PCD database maintain a mapping table that translate pair of {token
 676   space guid: token number} to local token number.
 677
 678   @param Guid            Token space guid for dynamic-ex PCD entry.
 679   @param ExTokenNumber   EDES_TODO: Add parameter description
 680
 681   @return local token number for dynamic-ex PCD.
 682
 683 **/
 684 UINTN
 685 GetExPcdTokenNumber (
 686   IN CONST EFI_GUID             *Guid,
 687   IN UINTN                      ExTokenNumber
 688   )
 689 {
 690   UINT32              Index;
 691   DYNAMICEX_MAPPING   *ExMap;
 692   EFI_GUID            *GuidTable;
 693   EFI_GUID            *MatchGuid;
 694   UINTN               MatchGuidIdx;
 695   PEI_PCD_DATABASE    *PeiPcdDb;
 696
 697   PeiPcdDb    = GetPcdDatabase();
 698
 699   ExMap       = PeiPcdDb->Init.ExMapTable;
 700   GuidTable   = PeiPcdDb->Init.GuidTable;
 701
 702   MatchGuid = ScanGuid (GuidTable, sizeof(PeiPcdDb->Init.GuidTable), Guid);
 703   //
 704   // We need to ASSERT here. If GUID can't be found in GuidTable, this is a
 705   // error in the BUILD system.
 706   //
 707   ASSERT (MatchGuid != NULL);
 708
 709   MatchGuidIdx = MatchGuid - GuidTable;
 710
 711   for (Index = 0; Index < PEI_EXMAPPING_TABLE_SIZE; Index++) {
 712     if ((ExTokenNumber == ExMap[Index].ExTokenNumber) &&
 713         (MatchGuidIdx == ExMap[Index].ExGuidIndex)) {
 714       return ExMap[Index].LocalTokenNumber;
 715     }
 716   }
 717
 718   return PCD_INVALID_TOKEN_NUMBER;
 719 }
 720
 721 /**
 722   Get PCD database from GUID HOB in PEI phase.
 723
 724   @return Pointer to PCD database.
 725
 726 **/
 727 PEI_PCD_DATABASE *
 728 GetPcdDatabase (
 729   VOID
 730   )
 731 {
 732   EFI_HOB_GUID_TYPE *GuidHob;
 733
 734   GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
 735   ASSERT (GuidHob != NULL);
 736
 737   return (PEI_PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob);
 738 }
 739
 740 /**
 741   Get SKU ID tabble from PCD database.
 742
 743   @param LocalTokenNumberTableIdx Index of local token number in token number table.
 744   @param Database                 PCD database.
 745
 746   @return Pointer to SKU ID array table
 747
 748 **/
 749 SKU_ID *
 750 GetSkuIdArray (
 751   IN    UINTN             LocalTokenNumberTableIdx,
 752   IN    PEI_PCD_DATABASE  *Database
 753   )
 754 {
 755   SKU_HEAD *SkuHead;
 756   UINTN     LocalTokenNumber;
 757
 758   LocalTokenNumber = Database->Init.LocalTokenNumberTable[LocalTokenNumberTableIdx];
 759
 760   ASSERT ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) != 0);
 761
 762   SkuHead = (SKU_HEAD *) ((UINT8 *)Database + (LocalTokenNumber & PCD_DATABASE_OFFSET_MASK));
 763
 764   return (SKU_ID *) ((UINT8 *)Database + SkuHead->SkuIdTableOffset);
 765
 766 }
 767
 768 /**
 769   Get index of PCD entry in size table.
 770
 771   @param LocalTokenNumberTableIdx Index of this PCD in local token number table.
 772   @param Database                 Pointer to PCD database in PEI phase.
 773
 774   @return index of PCD entry in size table.
 775
 776 **/
 777 UINTN
 778 GetSizeTableIndex (
 779   IN    UINTN             LocalTokenNumberTableIdx,
 780   IN    PEI_PCD_DATABASE  *Database
 781   )
 782 {
 783   UINTN       Index;
 784   UINTN        SizeTableIdx;
 785   UINTN       LocalTokenNumber;
 786   SKU_ID      *SkuIdTable;
 787
 788   SizeTableIdx = 0;
 789
 790   for (Index=0; Index<LocalTokenNumberTableIdx; Index++) {
 791     LocalTokenNumber = Database->Init.LocalTokenNumberTable[Index];
 792
 793     if ((LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) == PCD_DATUM_TYPE_POINTER) {
 794       //
 795       // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
 796       // PCD entry.
 797       //
 798       if ((LocalTokenNumber & PCD_TYPE_VPD) != 0) {
 799           //
 800           // We have only one entry for VPD enabled PCD entry:
 801           // 1) MAX Size.
 802           // We consider current size is equal to MAX size.
 803           //
 804           SizeTableIdx++;
 805       } else {
 806         if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0) {
 807           //
 808           // We have only two entry for Non-Sku enabled PCD entry:
 809           // 1) MAX SIZE
 810           // 2) Current Size
 811           //
 812           SizeTableIdx += 2;
 813         } else {
 814           //
 815           // We have these entry for SKU enabled PCD entry
 816           // 1) MAX SIZE
 817           // 2) Current Size for each SKU_ID (It is equal to MaxSku).
 818           //
 819           SkuIdTable = GetSkuIdArray (Index, Database);
 820           SizeTableIdx += (UINTN)*SkuIdTable + 1;
 821         }
 822       }
 823     }
 824
 825   }
 826
 827   return SizeTableIdx;
 828 }