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