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