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