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: 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     {
 416       ASSERT (FALSE);
 417       return EFI_INVALID_PARAMETER;
 418     }
 419
 420     case PCD_TYPE_STRING:
 421       if (SetPtrTypeSize (TokenNumber, Size, PeiPcdDb)) {
 422         StringTableIdx = *((UINT16 *)InternalData);
 423         CopyMem (&PeiPcdDb->Init.StringTable[StringTableIdx], Data, *Size);
 424         return EFI_SUCCESS;
 425       } else {
 426         return EFI_INVALID_PARAMETER;
 427       }
 428
 429     case PCD_TYPE_DATA:
 430     {
 431       if (PtrType) {
 432         if (SetPtrTypeSize (TokenNumber, Size, PeiPcdDb)) {
 433           CopyMem (InternalData, Data, *Size);
 434           return EFI_SUCCESS;
 435         } else {
 436           return EFI_INVALID_PARAMETER;
 437         }
 438       }
 439
 440       switch (*Size) {
 441         case sizeof(UINT8):
 442           *((UINT8 *) InternalData) = *((UINT8 *) Data);
 443           return EFI_SUCCESS;
 444
 445         case sizeof(UINT16):
 446           *((UINT16 *) InternalData) = *((UINT16 *) Data);
 447           return EFI_SUCCESS;
 448
 449         case sizeof(UINT32):
 450           *((UINT32 *) InternalData) = *((UINT32 *) Data);
 451           return EFI_SUCCESS;
 452
 453         case sizeof(UINT64):
 454           *((UINT64 *) InternalData) = *((UINT64 *) Data);
 455           return EFI_SUCCESS;
 456
 457         default:
 458           ASSERT (FALSE);
 459           return EFI_NOT_FOUND;
 460       }
 461     }
 462
 463   }
 464
 465   ASSERT (FALSE);
 466   return EFI_NOT_FOUND;
 467
 468 }
 469
 470 /**
 471   Wrapper function for set PCD value for non-Pointer type dynamic-ex PCD.
 472
 473   @param ExTokenNumber   Token number for dynamic-ex PCD.
 474   @param Guid            Token space guid for dynamic-ex PCD.
 475   @param Data            Value want to be set.
 476   @param SetSize         The size of value.
 477
 478   @return status of ExSetWorker().
 479
 480 **/
 481 EFI_STATUS
 482 ExSetValueWorker (
 483   IN          UINTN                ExTokenNumber,
 484   IN          CONST EFI_GUID       *Guid,
 485   IN          VOID                 *Data,
 486   IN          UINTN                Size
 487   )
 488 {
 489   return ExSetWorker (ExTokenNumber, Guid, Data, &Size, FALSE);
 490 }
 491
 492 /**
 493   Set value for a dynamic PCD entry.
 494
 495   This routine find the local token number according to dynamic-ex PCD's token
 496   space guid and token number firstly, and invoke callback function if this PCD
 497   entry registered callback function. Finally, invoken general SetWorker to set
 498   PCD value.
 499
 500   @param ExTokenNumber   Dynamic-ex PCD token number.
 501   @param Guid            Token space guid for dynamic-ex PCD.
 502   @param Data            PCD value want to be set
 503   @param SetSize         Size of value.
 504   @param PtrType         If TRUE, this PCD entry is pointer type.
 505                          If FALSE, this PCD entry is not pointer type.
 506
 507   @return status of SetWorker().
 508
 509 **/
 510 EFI_STATUS
 511 ExSetWorker (
 512   IN            UINTN                ExTokenNumber,
 513   IN            CONST EFI_GUID       *Guid,
 514   IN            VOID                 *Data,
 515   IN OUT        UINTN                *Size,
 516   IN            BOOLEAN              PtrType
 517   )
 518 {
 519   UINTN                     TokenNumber;
 520
 521   if (!FeaturePcdGet(PcdPeiFullPcdDatabaseEnable)) {
 522     return EFI_UNSUPPORTED;
 523   }
 524
 525   TokenNumber = GetExPcdTokenNumber (Guid, ExTokenNumber);
 526   if (TokenNumber == PCD_INVALID_TOKEN_NUMBER) {
 527     return EFI_NOT_FOUND;
 528   }
 529
 530   InvokeCallbackOnSet (ExTokenNumber, Guid, TokenNumber, Data, *Size);
 531
 532   return SetWorker (TokenNumber, Data, Size, PtrType);
 533
 534 }
 535
 536 /**
 537   Wrapper function for get PCD value for dynamic-ex PCD.
 538
 539   @param Guid            Token space guid for dynamic-ex PCD.
 540   @param ExTokenNumber   Token number for dyanmic-ex PCD.
 541   @param GetSize         The size of dynamic-ex PCD value.
 542
 543   @return PCD entry in PCD database.
 544
 545 **/
 546 VOID *
 547 ExGetWorker (
 548   IN CONST  EFI_GUID  *Guid,
 549   IN UINTN            ExTokenNumber,
 550   IN UINTN            GetSize
 551   )
 552 {
 553   return GetWorker (GetExPcdTokenNumber (Guid, ExTokenNumber), GetSize);
 554 }
 555
 556 /**
 557   Get the PCD entry pointer in PCD database.
 558
 559   This routine will visit PCD database to find the PCD entry according to given
 560   token number. The given token number is autogened by build tools and it will be
 561   translated to local token number. Local token number contains PCD's type and
 562   offset of PCD entry in PCD database.
 563
 564   @param TokenNumber     Token's number, it is autogened by build tools
 565   @param GetSize         The size of token's value
 566
 567   @return PCD entry pointer in PCD database
 568
 569 **/
 570 VOID *
 571 GetWorker (
 572   IN UINTN               TokenNumber,
 573   IN UINTN               GetSize
 574   )
 575 {
 576   UINT32              Offset;
 577   EFI_GUID            *Guid;
 578   UINT16              *Name;
 579   VARIABLE_HEAD       *VariableHead;
 580   EFI_STATUS          Status;
 581   UINTN               DataSize;
 582   VOID                *Data;
 583   UINT8               *StringTable;
 584   UINT16              StringTableIdx;
 585   PEI_PCD_DATABASE    *PeiPcdDb;
 586   UINT32              LocalTokenNumber;
 587   UINTN               MaxSize;
 588
 589   //
 590   // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
 591   // We have to decrement TokenNumber by 1 to make it usable
 592   // as the array index.
 593   //
 594   TokenNumber--;
 595
 596   // EBC compiler is very choosy. It may report warning about comparison
 597   // between UINTN and 0 . So we add 1 in each size of the
 598   // comparison.
 599   ASSERT (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);
 600
 601   ASSERT ((GetSize == PeiPcdGetSize(TokenNumber + 1)) || (GetSize == 0));
 602
 603   PeiPcdDb        = GetPcdDatabase ();
 604
 605   LocalTokenNumber = PeiPcdDb->Init.LocalTokenNumberTable[TokenNumber];
 606
 607   if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {
 608     if (GetSize == 0) {
 609       MaxSize = GetPtrTypeSize (TokenNumber, &MaxSize, PeiPcdDb);
 610     } else {
 611       MaxSize = GetSize;
 612     }
 613     LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, MaxSize);
 614   }
 615
 616   Offset      = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;
 617   StringTable = PeiPcdDb->Init.StringTable;
 618
 619   switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
 620     case PCD_TYPE_VPD:
 621     {
 622       VPD_HEAD *VpdHead;
 623       VpdHead = (VPD_HEAD *) ((UINT8 *)PeiPcdDb + Offset);
 624       return (VOID *) (UINTN) (PcdGet32 (PcdVpdBaseAddress) + VpdHead->Offset);
 625     }
 626
 627     case PCD_TYPE_HII:
 628     {
 629       VariableHead = (VARIABLE_HEAD *) ((UINT8 *)PeiPcdDb + Offset);
 630
 631       Guid = &(PeiPcdDb->Init.GuidTable[VariableHead->GuidTableIndex]);
 632       Name = (UINT16*)&StringTable[VariableHead->StringIndex];
 633
 634       Status = GetHiiVariable (Guid, Name, &Data, &DataSize);
 635
 636       if (Status == EFI_SUCCESS) {
 637         return (VOID *) ((UINT8 *) Data + VariableHead->Offset);
 638       } else {
 639         //
 640         // Return the default value specified by Platform Integrator
 641         //
 642         return (VOID *) ((UINT8 *) PeiPcdDb + VariableHead->DefaultValueOffset);
 643       }
 644     }
 645
 646     case PCD_TYPE_DATA:
 647       return (VOID *) ((UINT8 *)PeiPcdDb + Offset);
 648
 649     case PCD_TYPE_STRING:
 650       StringTableIdx = * (UINT16*) ((UINT8 *) PeiPcdDb + Offset);
 651       return (VOID *) (&StringTable[StringTableIdx]);
 652
 653     default:
 654       ASSERT (FALSE);
 655       break;
 656
 657   }
 658
 659   ASSERT (FALSE);
 660
 661   return NULL;
 662
 663 }
 664
 665 /**
 666   Get local token number according to dynamic-ex PCD's {token space guid:token number}
 667
 668   A dynamic-ex type PCD, developer must provide pair of token space guid: token number
 669   in DEC file. PCD database maintain a mapping table that translate pair of {token
 670   space guid: token number} to local token number.
 671
 672   @param Guid            Token space guid for dynamic-ex PCD entry.
 673   @param ExTokenNumber   EDES_TODO: Add parameter description
 674
 675   @return local token number for dynamic-ex PCD.
 676
 677 **/
 678 UINTN
 679 GetExPcdTokenNumber (
 680   IN CONST EFI_GUID             *Guid,
 681   IN UINTN                      ExTokenNumber
 682   )
 683 {
 684   UINT32              Index;
 685   DYNAMICEX_MAPPING   *ExMap;
 686   EFI_GUID            *GuidTable;
 687   EFI_GUID            *MatchGuid;
 688   UINTN               MatchGuidIdx;
 689   PEI_PCD_DATABASE    *PeiPcdDb;
 690
 691   PeiPcdDb    = GetPcdDatabase();
 692
 693   ExMap       = PeiPcdDb->Init.ExMapTable;
 694   GuidTable   = PeiPcdDb->Init.GuidTable;
 695
 696   MatchGuid = ScanGuid (GuidTable, sizeof(PeiPcdDb->Init.GuidTable), Guid);
 697   //
 698   // We need to ASSERT here. If GUID can't be found in GuidTable, this is a
 699   // error in the BUILD system.
 700   //
 701   ASSERT (MatchGuid != NULL);
 702
 703   MatchGuidIdx = MatchGuid - GuidTable;
 704
 705   for (Index = 0; Index < PEI_EXMAPPING_TABLE_SIZE; Index++) {
 706     if ((ExTokenNumber == ExMap[Index].ExTokenNumber) &&
 707         (MatchGuidIdx == ExMap[Index].ExGuidIndex)) {
 708       return ExMap[Index].LocalTokenNumber;
 709     }
 710   }
 711
 712   return PCD_INVALID_TOKEN_NUMBER;
 713 }
 714
 715 /**
 716   Get PCD database from GUID HOB in PEI phase.
 717
 718   @return Pointer to PCD database.
 719
 720 **/
 721 PEI_PCD_DATABASE *
 722 GetPcdDatabase (
 723   VOID
 724   )
 725 {
 726   EFI_HOB_GUID_TYPE *GuidHob;
 727
 728   GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
 729   ASSERT (GuidHob != NULL);
 730
 731   return (PEI_PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob);
 732 }
 733
 734 /**
 735   Get SKU ID tabble from PCD database.
 736
 737   @param LocalTokenNumberTableIdx Index of local token number in token number table.
 738   @param Database                 PCD database.
 739
 740   @return Pointer to SKU ID array table
 741
 742 **/
 743 SKU_ID *
 744 GetSkuIdArray (
 745   IN    UINTN             LocalTokenNumberTableIdx,
 746   IN    PEI_PCD_DATABASE  *Database
 747   )
 748 {
 749   SKU_HEAD *SkuHead;
 750   UINTN     LocalTokenNumber;
 751
 752   LocalTokenNumber = Database->Init.LocalTokenNumberTable[LocalTokenNumberTableIdx];
 753
 754   ASSERT ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) != 0);
 755
 756   SkuHead = (SKU_HEAD *) ((UINT8 *)Database + (LocalTokenNumber & PCD_DATABASE_OFFSET_MASK));
 757
 758   return (SKU_ID *) ((UINT8 *)Database + SkuHead->SkuIdTableOffset);
 759
 760 }
 761
 762 /**
 763   Get index of PCD entry in size table.
 764
 765   @param LocalTokenNumberTableIdx Index of this PCD in local token number table.
 766   @param Database                 Pointer to PCD database in PEI phase.
 767
 768   @return index of PCD entry in size table.
 769
 770 **/
 771 UINTN
 772 GetSizeTableIndex (
 773   IN    UINTN             LocalTokenNumberTableIdx,
 774   IN    PEI_PCD_DATABASE  *Database
 775   )
 776 {
 777   UINTN       Index;
 778   UINTN        SizeTableIdx;
 779   UINTN       LocalTokenNumber;
 780   SKU_ID      *SkuIdTable;
 781
 782   SizeTableIdx = 0;
 783
 784   for (Index=0; Index<LocalTokenNumberTableIdx; Index++) {
 785     LocalTokenNumber = Database->Init.LocalTokenNumberTable[Index];
 786
 787     if ((LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) == PCD_DATUM_TYPE_POINTER) {
 788       //
 789       // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
 790       // PCD entry.
 791       //
 792       if ((LocalTokenNumber & PCD_TYPE_VPD) != 0) {
 793           //
 794           // We have only one entry for VPD enabled PCD entry:
 795           // 1) MAX Size.
 796           // We consider current size is equal to MAX size.
 797           //
 798           SizeTableIdx++;
 799       } else {
 800         if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0) {
 801           //
 802           // We have only two entry for Non-Sku enabled PCD entry:
 803           // 1) MAX SIZE
 804           // 2) Current Size
 805           //
 806           SizeTableIdx += 2;
 807         } else {
 808           //
 809           // We have these entry for SKU enabled PCD entry
 810           // 1) MAX SIZE
 811           // 2) Current Size for each SKU_ID (It is equal to MaxSku).
 812           //
 813           SkuIdTable = GetSkuIdArray (Index, Database);
 814           SizeTableIdx += (UINTN)*SkuIdTable + 1;
 815         }
 816       }
 817     }
 818
 819   }
 820
 821   return SizeTableIdx;
 822 }