MdePkg/Library/DxePcdLib/DxePcdLib.c

   1 /** @file
   2 Implementation of PcdLib class library for DXE phase.
   3
   4 Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13
  14 **/
  15
  16
  17 #include <PiDxe.h>
  18
  19 #include <Protocol/Pcd.h>
  20 #include <Protocol/PiPcd.h>
  21 #include <Protocol/PcdInfo.h>
  22 #include <Protocol/PiPcdInfo.h>
  23
  24 #include <Library/PcdLib.h>
  25 #include <Library/DebugLib.h>
  26 #include <Library/UefiBootServicesTableLib.h>
  27 #include <Library/BaseMemoryLib.h>
  28
  29 PCD_PROTOCOL                *mPcd       = NULL;
  30 EFI_PCD_PROTOCOL            *mPiPcd     = NULL;
  31 GET_PCD_INFO_PROTOCOL       *mPcdInfo   = NULL;
  32 EFI_GET_PCD_INFO_PROTOCOL   *mPiPcdInfo = NULL;
  33
  34 /**
  35   Retrieves the PI PCD protocol from the handle database.
  36
  37   @retval EFI_PCD_PROTOCOL * The pointer to the EFI_PCD_PROTOCOL.
  38 **/
  39 EFI_PCD_PROTOCOL *
  40 EFIAPI
  41 GetPiPcdProtocol (
  42   VOID
  43   )
  44 {
  45   EFI_STATUS  Status;
  46
  47   if (mPiPcd == NULL) {
  48     //
  49     // PI Pcd protocol defined in PI 1.2 vol3 should be installed before the module
  50     // access DynamicEx type PCD.
  51     //
  52     Status = gBS->LocateProtocol (&gEfiPcdProtocolGuid, NULL, (VOID **) &mPiPcd);
  53     ASSERT_EFI_ERROR (Status);
  54     ASSERT (mPiPcd != NULL);
  55   }
  56   return mPiPcd;
  57 }
  58
  59 /**
  60   Retrieves the PCD protocol from the handle database.
  61
  62   @retval PCD_PROTOCOL * The pointer to the PCD_PROTOCOL.
  63 **/
  64 PCD_PROTOCOL *
  65 EFIAPI
  66 GetPcdProtocol (
  67   VOID
  68   )
  69 {
  70   EFI_STATUS  Status;
  71
  72   if (mPcd == NULL) {
  73     //
  74     // PCD protocol need to be installed before the module access Dynamic type PCD.
  75     // But dynamic type PCD is not required in PI 1.2 specification.
  76     //
  77     Status = gBS->LocateProtocol (&gPcdProtocolGuid, NULL, (VOID **)&mPcd);
  78     ASSERT_EFI_ERROR (Status);
  79     ASSERT (mPcd != NULL);
  80   }
  81   return mPcd;
  82 }
  83
  84 /**
  85   Retrieves the PI PCD info protocol from the handle database.
  86
  87   @retval EFI_GET_PCD_INFO_PROTOCOL * The pointer to the EFI_GET_PCD_INFO_PROTOCOL defined in PI 1.2.1 Vol 3.
  88 **/
  89 EFI_GET_PCD_INFO_PROTOCOL *
  90 GetPiPcdInfoProtocolPointer (
  91   VOID
  92   )
  93 {
  94   EFI_STATUS  Status;
  95
  96   if (mPiPcdInfo == NULL) {
  97     Status = gBS->LocateProtocol (&gEfiGetPcdInfoProtocolGuid, NULL, (VOID **)&mPiPcdInfo);
  98     ASSERT_EFI_ERROR (Status);
  99     ASSERT (mPiPcdInfo != NULL);
 100   }
 101   return mPiPcdInfo;
 102 }
 103
 104 /**
 105   Retrieves the PCD info protocol from the handle database.
 106
 107   @retval GET_PCD_INFO_PROTOCOL * The pointer to the GET_PCD_INFO_PROTOCOL.
 108 **/
 109 GET_PCD_INFO_PROTOCOL *
 110 GetPcdInfoProtocolPointer (
 111   VOID
 112   )
 113 {
 114   EFI_STATUS  Status;
 115
 116   if (mPcdInfo == NULL) {
 117     Status = gBS->LocateProtocol (&gGetPcdInfoProtocolGuid, NULL, (VOID **)&mPcdInfo);
 118     ASSERT_EFI_ERROR (Status);
 119     ASSERT (mPcdInfo != NULL);
 120   }
 121   return mPcdInfo;
 122 }
 123
 124 /**
 125   This function provides a means by which SKU support can be established in the PCD infrastructure.
 126
 127   Sets the current SKU in the PCD database to the value specified by SkuId.  SkuId is returned.
 128   If SkuId >= PCD_MAX_SKU_ID, then ASSERT().
 129
 130   @param  SkuId   The SKU value that will be used when the PCD service retrieves and sets values
 131                   associated with a PCD token.
 132
 133   @return  Return the SKU ID that just be set.
 134
 135 **/
 136 UINTN
 137 EFIAPI
 138 LibPcdSetSku (
 139   IN UINTN   SkuId
 140   )
 141 {
 142   ASSERT (SkuId < PCD_MAX_SKU_ID);
 143
 144   GetPcdProtocol()->SetSku (SkuId);
 145
 146   return SkuId;
 147 }
 148
 149
 150
 151 /**
 152   This function provides a means by which to retrieve a value for a given PCD token.
 153
 154   Returns the 8-bit value for the token specified by TokenNumber.
 155
 156   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 157
 158   @return Returns the 8-bit value for the token specified by TokenNumber.
 159
 160 **/
 161 UINT8
 162 EFIAPI
 163 LibPcdGet8 (
 164   IN UINTN             TokenNumber
 165   )
 166 {
 167   return GetPcdProtocol()->Get8 (TokenNumber);
 168 }
 169
 170
 171
 172 /**
 173   This function provides a means by which to retrieve a value for a given PCD token.
 174
 175   Returns the 16-bit value for the token specified by TokenNumber.
 176
 177   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 178
 179   @return Returns the 16-bit value for the token specified by TokenNumber.
 180
 181 **/
 182 UINT16
 183 EFIAPI
 184 LibPcdGet16 (
 185   IN UINTN             TokenNumber
 186   )
 187 {
 188   return GetPcdProtocol()->Get16 (TokenNumber);
 189 }
 190
 191
 192
 193 /**
 194   This function provides a means by which to retrieve a value for a given PCD token.
 195
 196   Returns the 32-bit value for the token specified by TokenNumber.
 197
 198   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 199
 200   @return Returns the 32-bit value for the token specified by TokenNumber.
 201
 202 **/
 203 UINT32
 204 EFIAPI
 205 LibPcdGet32 (
 206   IN UINTN             TokenNumber
 207   )
 208 {
 209   return GetPcdProtocol()->Get32 (TokenNumber);
 210 }
 211
 212
 213
 214 /**
 215   This function provides a means by which to retrieve a value for a given PCD token.
 216
 217   Returns the 64-bit value for the token specified by TokenNumber.
 218
 219   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 220
 221   @return Returns the 64-bit value for the token specified by TokenNumber.
 222
 223 **/
 224 UINT64
 225 EFIAPI
 226 LibPcdGet64 (
 227   IN UINTN             TokenNumber
 228   )
 229 {
 230   return GetPcdProtocol()->Get64 (TokenNumber);
 231 }
 232
 233
 234
 235 /**
 236   This function provides a means by which to retrieve a value for a given PCD token.
 237
 238   Returns the pointer to the buffer of the token specified by TokenNumber.
 239
 240   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 241
 242   @return Returns the pointer to the token specified by TokenNumber.
 243
 244 **/
 245 VOID *
 246 EFIAPI
 247 LibPcdGetPtr (
 248   IN UINTN             TokenNumber
 249   )
 250 {
 251   return GetPcdProtocol()->GetPtr (TokenNumber);
 252 }
 253
 254
 255
 256 /**
 257   This function provides a means by which to retrieve a value for a given PCD token.
 258
 259   Returns the Boolean value of the token specified by TokenNumber.
 260
 261   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 262
 263   @return Returns the Boolean value of the token specified by TokenNumber.
 264
 265 **/
 266 BOOLEAN
 267 EFIAPI
 268 LibPcdGetBool (
 269   IN UINTN             TokenNumber
 270   )
 271 {
 272   return GetPcdProtocol()->GetBool (TokenNumber);
 273 }
 274
 275
 276
 277 /**
 278   This function provides a means by which to retrieve the size of a given PCD token.
 279
 280   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 281
 282   @return Returns the size of the token specified by TokenNumber.
 283
 284 **/
 285 UINTN
 286 EFIAPI
 287 LibPcdGetSize (
 288   IN UINTN             TokenNumber
 289   )
 290 {
 291   return GetPcdProtocol()->GetSize (TokenNumber);
 292 }
 293
 294
 295
 296 /**
 297   This function provides a means by which to retrieve a value for a given PCD token.
 298
 299   Returns the 8-bit value for the token specified by TokenNumber and Guid.
 300
 301   If Guid is NULL, then ASSERT().
 302
 303   @param[in]  Guid         The pointer to a 128-bit unique value that designates
 304                            which namespace to retrieve a value from.
 305   @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
 306
 307   @return Return the UINT8.
 308
 309 **/
 310 UINT8
 311 EFIAPI
 312 LibPcdGetEx8 (
 313   IN CONST GUID        *Guid,
 314   IN UINTN             TokenNumber
 315   )
 316 {
 317   ASSERT (Guid != NULL);
 318
 319   return GetPiPcdProtocol()->Get8 (Guid, TokenNumber);
 320 }
 321
 322
 323 /**
 324   This function provides a means by which to retrieve a value for a given PCD token.
 325
 326   Returns the 16-bit value for the token specified by TokenNumber and Guid.
 327
 328   If Guid is NULL, then ASSERT().
 329
 330   @param[in]  Guid         The pointer to a 128-bit unique value that designates
 331                            which namespace to retrieve a value from.
 332   @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
 333
 334   @return Return the UINT16.
 335
 336 **/
 337 UINT16
 338 EFIAPI
 339 LibPcdGetEx16 (
 340   IN CONST GUID        *Guid,
 341   IN UINTN             TokenNumber
 342   )
 343 {
 344   ASSERT (Guid != NULL);
 345
 346   return GetPiPcdProtocol()->Get16 (Guid, TokenNumber);
 347 }
 348
 349
 350 /**
 351   Returns the 32-bit value for the token specified by TokenNumber and Guid.
 352   If Guid is NULL, then ASSERT().
 353
 354   @param[in]  Guid         The pointer to a 128-bit unique value that designates
 355                            which namespace to retrieve a value from.
 356   @param[in]  TokenNumber  The PCD token number to retrieve a current value for.
 357
 358   @return Return the UINT32.
 359
 360 **/
 361 UINT32
 362 EFIAPI
 363 LibPcdGetEx32 (
 364   IN CONST GUID        *Guid,
 365   IN UINTN             TokenNumber
 366   )
 367 {
 368   ASSERT (Guid != NULL);
 369
 370   return GetPiPcdProtocol()->Get32 (Guid, TokenNumber);
 371 }
 372
 373
 374
 375 /**
 376   This function provides a means by which to retrieve a value for a given PCD token.
 377
 378   Returns the 64-bit value for the token specified by TokenNumber and Guid.
 379
 380   If Guid is NULL, then ASSERT().
 381
 382   @param[in]  Guid          The pointer to a 128-bit unique value that designates
 383                             which namespace to retrieve a value from.
 384   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 385
 386   @return Return the UINT64.
 387
 388 **/
 389 UINT64
 390 EFIAPI
 391 LibPcdGetEx64 (
 392   IN CONST GUID        *Guid,
 393   IN UINTN             TokenNumber
 394   )
 395 {
 396   ASSERT (Guid != NULL);
 397
 398   return GetPiPcdProtocol()->Get64 (Guid, TokenNumber);
 399 }
 400
 401
 402
 403 /**
 404   This function provides a means by which to retrieve a value for a given PCD token.
 405
 406   Returns the pointer to the buffer of token specified by TokenNumber and Guid.
 407
 408   If Guid is NULL, then ASSERT().
 409
 410   @param[in]  Guid          The pointer to a 128-bit unique value that designates
 411                             which namespace to retrieve a value from.
 412   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 413
 414   @return Return the VOID* pointer.
 415
 416 **/
 417 VOID *
 418 EFIAPI
 419 LibPcdGetExPtr (
 420   IN CONST GUID        *Guid,
 421   IN UINTN             TokenNumber
 422   )
 423 {
 424   ASSERT (Guid != NULL);
 425
 426   return GetPiPcdProtocol()->GetPtr (Guid, TokenNumber);
 427 }
 428
 429
 430
 431 /**
 432   This function provides a means by which to retrieve a value for a given PCD token.
 433
 434   Returns the Boolean value of the token specified by TokenNumber and Guid.
 435
 436   If Guid is NULL, then ASSERT().
 437
 438   @param[in]  Guid          The pointer to a 128-bit unique value that designates
 439                             which namespace to retrieve a value from.
 440   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 441
 442   @return Return the BOOLEAN.
 443
 444 **/
 445 BOOLEAN
 446 EFIAPI
 447 LibPcdGetExBool (
 448   IN CONST GUID        *Guid,
 449   IN UINTN             TokenNumber
 450   )
 451 {
 452   ASSERT (Guid != NULL);
 453
 454   return GetPiPcdProtocol()->GetBool (Guid, TokenNumber);
 455 }
 456
 457
 458
 459 /**
 460   This function provides a means by which to retrieve the size of a given PCD token.
 461
 462   Returns the size of the token specified by TokenNumber and Guid.
 463
 464   If Guid is NULL, then ASSERT().
 465
 466   @param[in]  Guid          The pointer to a 128-bit unique value that designates
 467                             which namespace to retrieve a value from.
 468   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 469
 470   @return Return the size.
 471
 472 **/
 473 UINTN
 474 EFIAPI
 475 LibPcdGetExSize (
 476   IN CONST GUID        *Guid,
 477   IN UINTN             TokenNumber
 478   )
 479 {
 480   ASSERT (Guid != NULL);
 481
 482   return GetPiPcdProtocol()->GetSize (Guid, TokenNumber);
 483 }
 484
 485
 486
 487 #ifndef DISABLE_NEW_DEPRECATED_INTERFACES
 488 /**
 489   This function provides a means by which to set a value for a given PCD token.
 490
 491   Sets the 8-bit value for the token specified by TokenNumber
 492   to the value specified by Value.  Value is returned.
 493
 494   @param[in]  TokenNumber   The PCD token number to set a current value for.
 495   @param[in]  Value         The 8-bit value to set.
 496
 497   @return Return the value that was set.
 498
 499 **/
 500 UINT8
 501 EFIAPI
 502 LibPcdSet8 (
 503   IN UINTN             TokenNumber,
 504   IN UINT8             Value
 505   )
 506 {
 507   GetPcdProtocol()->Set8 (TokenNumber, Value);
 508
 509   return Value;
 510 }
 511
 512
 513
 514 /**
 515   This function provides a means by which to set a value for a given PCD token.
 516
 517   Sets the 16-bit value for the token specified by TokenNumber
 518   to the value specified by Value.  Value is returned.
 519
 520   @param[in]  TokenNumber   The PCD token number to set a current value for.
 521   @param[in]  Value         The 16-bit value to set.
 522
 523   @return Return the value that was set.
 524
 525 **/
 526 UINT16
 527 EFIAPI
 528 LibPcdSet16 (
 529   IN UINTN             TokenNumber,
 530   IN UINT16            Value
 531   )
 532 {
 533   GetPcdProtocol()->Set16 (TokenNumber, Value);
 534
 535   return Value;
 536 }
 537
 538
 539
 540 /**
 541   This function provides a means by which to set a value for a given PCD token.
 542
 543   Sets the 32-bit value for the token specified by TokenNumber
 544   to the value specified by Value.  Value is returned.
 545
 546   @param[in]  TokenNumber   The PCD token number to set a current value for.
 547   @param[in]  Value         The 32-bit value to set.
 548
 549   @return Return the value that was set.
 550
 551 **/
 552 UINT32
 553 EFIAPI
 554 LibPcdSet32 (
 555   IN UINTN             TokenNumber,
 556   IN UINT32            Value
 557   )
 558 {
 559   GetPcdProtocol()->Set32 (TokenNumber, Value);
 560
 561   return Value;
 562 }
 563
 564
 565
 566 /**
 567   This function provides a means by which to set a value for a given PCD token.
 568
 569   Sets the 64-bit value for the token specified by TokenNumber
 570   to the value specified by Value.  Value is returned.
 571
 572   @param[in]  TokenNumber   The PCD token number to set a current value for.
 573   @param[in]  Value         The 64-bit value to set.
 574
 575   @return Return the value that was set.
 576
 577 **/
 578 UINT64
 579 EFIAPI
 580 LibPcdSet64 (
 581   IN UINTN             TokenNumber,
 582   IN UINT64            Value
 583   )
 584 {
 585   GetPcdProtocol()->Set64 (TokenNumber, Value);
 586
 587   return Value;
 588 }
 589
 590
 591
 592 /**
 593   This function provides a means by which to set a value for a given PCD token.
 594
 595   Sets a buffer for the token specified by TokenNumber to the value
 596   specified by Buffer and SizeOfBuffer.  Buffer is returned.
 597   If SizeOfBuffer is greater than the maximum size support by TokenNumber,
 598   then set SizeOfBuffer to the maximum size supported by TokenNumber and
 599   return NULL to indicate that the set operation was not actually performed.
 600
 601   If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the
 602   maximum size supported by TokenName and NULL must be returned.
 603
 604   If SizeOfBuffer is NULL, then ASSERT().
 605   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 606
 607   @param[in]      TokenNumber   The PCD token number to set a current value for.
 608   @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
 609   @param[in]      Buffer        A pointer to the buffer to set.
 610
 611   @return Return the pointer for the buffer been set.
 612
 613 **/
 614 VOID *
 615 EFIAPI
 616 LibPcdSetPtr (
 617   IN        UINTN             TokenNumber,
 618   IN OUT    UINTN             *SizeOfBuffer,
 619   IN CONST  VOID              *Buffer
 620   )
 621 {
 622   EFI_STATUS Status;
 623   UINTN      InputSizeOfBuffer;
 624
 625   ASSERT (SizeOfBuffer != NULL);
 626
 627   if (*SizeOfBuffer > 0) {
 628     ASSERT (Buffer != NULL);
 629   }
 630
 631   InputSizeOfBuffer = *SizeOfBuffer;
 632   Status = GetPcdProtocol()->SetPtr (TokenNumber, SizeOfBuffer, (VOID *) Buffer);
 633   if (EFI_ERROR (Status) && (*SizeOfBuffer < InputSizeOfBuffer)) {
 634     return NULL;
 635   }
 636
 637   return (VOID *)Buffer;
 638 }
 639
 640
 641
 642 /**
 643   This function provides a means by which to set a value for a given PCD token.
 644
 645   Sets the Boolean value for the token specified by TokenNumber
 646   to the value specified by Value.  Value is returned.
 647
 648   @param[in]  TokenNumber   The PCD token number to set a current value for.
 649   @param[in]  Value         The boolean value to set.
 650
 651   @return Return the value that was set.
 652
 653 **/
 654 BOOLEAN
 655 EFIAPI
 656 LibPcdSetBool (
 657   IN UINTN             TokenNumber,
 658   IN BOOLEAN           Value
 659   )
 660 {
 661   GetPcdProtocol()->SetBool (TokenNumber, Value);
 662
 663   return Value;
 664 }
 665
 666
 667
 668 /**
 669   This function provides a means by which to set a value for a given PCD token.
 670
 671   Sets the 8-bit value for the token specified by TokenNumber and
 672   Guid to the value specified by Value. Value is returned.
 673
 674   If Guid is NULL, then ASSERT().
 675
 676   @param[in]  Guid          The pointer to a 128-bit unique value that
 677                             designates which namespace to set a value from.
 678   @param[in]  TokenNumber   The PCD token number to set a current value for.
 679   @param[in]  Value         The 8-bit value to set.
 680
 681   @return Return the value that was set.
 682
 683 **/
 684 UINT8
 685 EFIAPI
 686 LibPcdSetEx8 (
 687   IN CONST GUID        *Guid,
 688   IN UINTN             TokenNumber,
 689   IN UINT8             Value
 690   )
 691 {
 692   ASSERT (Guid != NULL);
 693
 694   GetPiPcdProtocol()->Set8 (Guid, TokenNumber, Value);
 695
 696   return Value;
 697 }
 698
 699
 700
 701 /**
 702   This function provides a means by which to set a value for a given PCD token.
 703
 704   Sets the 16-bit value for the token specified by TokenNumber and
 705   Guid to the value specified by Value. Value is returned.
 706
 707   If Guid is NULL, then ASSERT().
 708
 709   @param[in]  Guid          The pointer to a 128-bit unique value that
 710                             designates which namespace to set a value from.
 711   @param[in]  TokenNumber   The PCD token number to set a current value for.
 712   @param[in]  Value         The 16-bit value to set.
 713
 714   @return Return the value that was set.
 715
 716 **/
 717 UINT16
 718 EFIAPI
 719 LibPcdSetEx16 (
 720   IN CONST GUID        *Guid,
 721   IN UINTN             TokenNumber,
 722   IN UINT16            Value
 723   )
 724 {
 725   ASSERT (Guid != NULL);
 726
 727   GetPiPcdProtocol()->Set16 (Guid, TokenNumber, Value);
 728
 729   return Value;
 730 }
 731
 732
 733
 734 /**
 735   This function provides a means by which to set a value for a given PCD token.
 736
 737   Sets the 32-bit value for the token specified by TokenNumber and
 738   Guid to the value specified by Value. Value is returned.
 739
 740   If Guid is NULL, then ASSERT().
 741
 742   @param[in]  Guid          The pointer to a 128-bit unique value that
 743                             designates which namespace to set a value from.
 744   @param[in]  TokenNumber   The PCD token number to set a current value for.
 745   @param[in]  Value         The 32-bit value to set.
 746
 747   @return Return the value that was set.
 748
 749 **/
 750 UINT32
 751 EFIAPI
 752 LibPcdSetEx32 (
 753   IN CONST GUID        *Guid,
 754   IN UINTN             TokenNumber,
 755   IN UINT32            Value
 756   )
 757 {
 758   ASSERT (Guid != NULL);
 759
 760   GetPiPcdProtocol()->Set32 (Guid, TokenNumber, Value);
 761
 762   return Value;
 763 }
 764
 765
 766
 767 /**
 768   This function provides a means by which to set a value for a given PCD token.
 769
 770   Sets the 64-bit value for the token specified by TokenNumber and
 771   Guid to the value specified by Value. Value is returned.
 772
 773   If Guid is NULL, then ASSERT().
 774
 775   @param[in]  Guid          The pointer to a 128-bit unique value that
 776                             designates which namespace to set a value from.
 777   @param[in]  TokenNumber   The PCD token number to set a current value for.
 778   @param[in]  Value         The 64-bit value to set.
 779
 780   @return Return the value that was set.
 781
 782 **/
 783 UINT64
 784 EFIAPI
 785 LibPcdSetEx64 (
 786   IN CONST GUID        *Guid,
 787   IN UINTN             TokenNumber,
 788   IN UINT64            Value
 789   )
 790 {
 791   ASSERT (Guid != NULL);
 792
 793   GetPiPcdProtocol()->Set64 (Guid, TokenNumber, Value);
 794
 795   return Value;
 796 }
 797
 798
 799
 800 /**
 801   This function provides a means by which to set a value for a given PCD token.
 802
 803   Sets a buffer for the token specified by TokenNumber to the value specified by
 804   Buffer and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than
 805   the maximum size support by TokenNumber, then set SizeOfBuffer to the maximum size
 806   supported by TokenNumber and return NULL to indicate that the set operation
 807   was not actually performed.
 808
 809   If Guid is NULL, then ASSERT().
 810   If SizeOfBuffer is NULL, then ASSERT().
 811   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 812
 813   @param[in]  Guid              The pointer to a 128-bit unique value that
 814                                 designates which namespace to set a value from.
 815   @param[in]  TokenNumber       The PCD token number to set a current value for.
 816   @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
 817   @param[in]  Buffer            A pointer to the buffer to set.
 818
 819   @return Return the pointer to the buffer been set.
 820
 821 **/
 822 VOID *
 823 EFIAPI
 824 LibPcdSetExPtr (
 825   IN      CONST GUID        *Guid,
 826   IN      UINTN             TokenNumber,
 827   IN OUT  UINTN             *SizeOfBuffer,
 828   IN      VOID              *Buffer
 829   )
 830 {
 831   EFI_STATUS  Status;
 832   UINTN       InputSizeOfBuffer;
 833
 834   ASSERT (Guid != NULL);
 835
 836   ASSERT (SizeOfBuffer != NULL);
 837
 838   if (*SizeOfBuffer > 0) {
 839     ASSERT (Buffer != NULL);
 840   }
 841
 842   InputSizeOfBuffer = *SizeOfBuffer;
 843   Status = GetPiPcdProtocol()->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer);
 844   if (EFI_ERROR (Status) && (*SizeOfBuffer < InputSizeOfBuffer)) {
 845     return NULL;
 846   }
 847
 848   return Buffer;
 849 }
 850
 851
 852
 853 /**
 854   This function provides a means by which to set a value for a given PCD token.
 855
 856   Sets the Boolean value for the token specified by TokenNumber and
 857   Guid to the value specified by Value. Value is returned.
 858
 859   If Guid is NULL, then ASSERT().
 860
 861   @param[in]  Guid          The pointer to a 128-bit unique value that
 862                             designates which namespace to set a value from.
 863   @param[in]  TokenNumber   The PCD token number to set a current value for.
 864   @param[in]  Value         The Boolean value to set.
 865
 866   @return Return the value that was set.
 867
 868 **/
 869 BOOLEAN
 870 EFIAPI
 871 LibPcdSetExBool (
 872   IN CONST GUID        *Guid,
 873   IN UINTN             TokenNumber,
 874   IN BOOLEAN           Value
 875   )
 876 {
 877   ASSERT (Guid != NULL);
 878
 879   GetPiPcdProtocol()->SetBool (Guid, TokenNumber, Value);
 880
 881   return Value;
 882 }
 883 #endif
 884
 885 /**
 886   This function provides a means by which to set a value for a given PCD token.
 887
 888   Sets the 8-bit value for the token specified by TokenNumber
 889   to the value specified by Value.
 890
 891   @param[in] TokenNumber    The PCD token number to set a current value for.
 892   @param[in] Value          The 8-bit value to set.
 893
 894   @return The status of the set operation.
 895
 896 **/
 897 RETURN_STATUS
 898 EFIAPI
 899 LibPcdSet8S (
 900   IN UINTN          TokenNumber,
 901   IN UINT8          Value
 902   )
 903 {
 904   return GetPcdProtocol()->Set8 (TokenNumber, Value);
 905 }
 906
 907 /**
 908   This function provides a means by which to set a value for a given PCD token.
 909
 910   Sets the 16-bit value for the token specified by TokenNumber
 911   to the value specified by Value.
 912
 913   @param[in] TokenNumber    The PCD token number to set a current value for.
 914   @param[in] Value          The 16-bit value to set.
 915
 916   @return The status of the set operation.
 917
 918 **/
 919 RETURN_STATUS
 920 EFIAPI
 921 LibPcdSet16S (
 922   IN UINTN          TokenNumber,
 923   IN UINT16         Value
 924   )
 925 {
 926   return GetPcdProtocol()->Set16 (TokenNumber, Value);
 927 }
 928
 929 /**
 930   This function provides a means by which to set a value for a given PCD token.
 931
 932   Sets the 32-bit value for the token specified by TokenNumber
 933   to the value specified by Value.
 934
 935   @param[in] TokenNumber    The PCD token number to set a current value for.
 936   @param[in] Value          The 32-bit value to set.
 937
 938   @return The status of the set operation.
 939
 940 **/
 941 RETURN_STATUS
 942 EFIAPI
 943 LibPcdSet32S (
 944   IN UINTN          TokenNumber,
 945   IN UINT32         Value
 946   )
 947 {
 948   return GetPcdProtocol()->Set32 (TokenNumber, Value);
 949 }
 950
 951 /**
 952   This function provides a means by which to set a value for a given PCD token.
 953
 954   Sets the 64-bit value for the token specified by TokenNumber
 955   to the value specified by Value.
 956
 957   @param[in] TokenNumber    The PCD token number to set a current value for.
 958   @param[in] Value          The 64-bit value to set.
 959
 960   @return The status of the set operation.
 961
 962 **/
 963 RETURN_STATUS
 964 EFIAPI
 965 LibPcdSet64S (
 966   IN UINTN          TokenNumber,
 967   IN UINT64         Value
 968   )
 969 {
 970   return GetPcdProtocol()->Set64 (TokenNumber, Value);
 971 }
 972
 973 /**
 974   This function provides a means by which to set a value for a given PCD token.
 975
 976   Sets a buffer for the token specified by TokenNumber to the value specified
 977   by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
 978   support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
 979   TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation
 980   was not actually performed.
 981
 982   If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the
 983   maximum size supported by TokenName and EFI_INVALID_PARAMETER must be returned.
 984
 985   If SizeOfBuffer is NULL, then ASSERT().
 986   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 987
 988   @param[in]      TokenNumber   The PCD token number to set a current value for.
 989   @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
 990   @param[in]      Buffer        A pointer to the buffer to set.
 991
 992   @return The status of the set operation.
 993
 994 **/
 995 RETURN_STATUS
 996 EFIAPI
 997 LibPcdSetPtrS (
 998   IN       UINTN    TokenNumber,
 999   IN OUT   UINTN    *SizeOfBuffer,
1000   IN CONST VOID     *Buffer
1001   )
1002 {
1003   ASSERT (SizeOfBuffer != NULL);
1004
1005   if (*SizeOfBuffer > 0) {
1006     ASSERT (Buffer != NULL);
1007   }
1008
1009   return GetPcdProtocol()->SetPtr (TokenNumber, SizeOfBuffer, (VOID *) Buffer);
1010 }
1011
1012 /**
1013   This function provides a means by which to set a value for a given PCD token.
1014
1015   Sets the boolean value for the token specified by TokenNumber
1016   to the value specified by Value.
1017
1018   @param[in] TokenNumber    The PCD token number to set a current value for.
1019   @param[in] Value          The boolean value to set.
1020
1021   @return The status of the set operation.
1022
1023 **/
1024 RETURN_STATUS
1025 EFIAPI
1026 LibPcdSetBoolS (
1027   IN UINTN          TokenNumber,
1028   IN BOOLEAN        Value
1029   )
1030 {
1031   return GetPcdProtocol()->SetBool (TokenNumber, Value);
1032 }
1033
1034 /**
1035   This function provides a means by which to set a value for a given PCD token.
1036
1037   Sets the 8-bit value for the token specified by TokenNumber
1038   to the value specified by Value.
1039
1040   If Guid is NULL, then ASSERT().
1041
1042   @param[in] Guid           The pointer to a 128-bit unique value that
1043                             designates which namespace to set a value from.
1044   @param[in] TokenNumber    The PCD token number to set a current value for.
1045   @param[in] Value          The 8-bit value to set.
1046
1047   @return The status of the set operation.
1048
1049 **/
1050 RETURN_STATUS
1051 EFIAPI
1052 LibPcdSetEx8S (
1053   IN CONST GUID     *Guid,
1054   IN UINTN          TokenNumber,
1055   IN UINT8          Value
1056   )
1057 {
1058   ASSERT (Guid != NULL);
1059
1060   return GetPiPcdProtocol()->Set8 (Guid, TokenNumber, Value);
1061 }
1062
1063 /**
1064   This function provides a means by which to set a value for a given PCD token.
1065
1066   Sets the 16-bit value for the token specified by TokenNumber
1067   to the value specified by Value.
1068
1069   If Guid is NULL, then ASSERT().
1070
1071   @param[in] Guid           The pointer to a 128-bit unique value that
1072                             designates which namespace to set a value from.
1073   @param[in] TokenNumber    The PCD token number to set a current value for.
1074   @param[in] Value          The 16-bit value to set.
1075
1076   @return The status of the set operation.
1077
1078 **/
1079 RETURN_STATUS
1080 EFIAPI
1081 LibPcdSetEx16S (
1082   IN CONST GUID     *Guid,
1083   IN UINTN          TokenNumber,
1084   IN UINT16         Value
1085   )
1086 {
1087   ASSERT (Guid != NULL);
1088
1089   return GetPiPcdProtocol()->Set16 (Guid, TokenNumber, Value);
1090 }
1091
1092 /**
1093   This function provides a means by which to set a value for a given PCD token.
1094
1095   Sets the 32-bit value for the token specified by TokenNumber
1096   to the value specified by Value.
1097
1098   If Guid is NULL, then ASSERT().
1099
1100   @param[in] Guid           The pointer to a 128-bit unique value that
1101                             designates which namespace to set a value from.
1102   @param[in] TokenNumber    The PCD token number to set a current value for.
1103   @param[in] Value          The 32-bit value to set.
1104
1105   @return The status of the set operation.
1106
1107 **/
1108 RETURN_STATUS
1109 EFIAPI
1110 LibPcdSetEx32S (
1111   IN CONST GUID     *Guid,
1112   IN UINTN          TokenNumber,
1113   IN UINT32         Value
1114   )
1115 {
1116   ASSERT (Guid != NULL);
1117
1118   return GetPiPcdProtocol()->Set32 (Guid, TokenNumber, Value);
1119 }
1120
1121 /**
1122   This function provides a means by which to set a value for a given PCD token.
1123
1124   Sets the 64-bit value for the token specified by TokenNumber
1125   to the value specified by Value.
1126
1127   If Guid is NULL, then ASSERT().
1128
1129   @param[in] Guid           The pointer to a 128-bit unique value that
1130                             designates which namespace to set a value from.
1131   @param[in] TokenNumber    The PCD token number to set a current value for.
1132   @param[in] Value          The 64-bit value to set.
1133
1134   @return The status of the set operation.
1135
1136 **/
1137 RETURN_STATUS
1138 EFIAPI
1139 LibPcdSetEx64S (
1140   IN CONST GUID     *Guid,
1141   IN UINTN          TokenNumber,
1142   IN UINT64         Value
1143   )
1144 {
1145   ASSERT (Guid != NULL);
1146
1147   return GetPiPcdProtocol()->Set64 (Guid, TokenNumber, Value);
1148 }
1149
1150 /**
1151   This function provides a means by which to set a value for a given PCD token.
1152
1153   Sets a buffer for the token specified by TokenNumber to the value specified by
1154   Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
1155   support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
1156   TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation
1157   was not actually performed.
1158
1159   If Guid is NULL, then ASSERT().
1160   If SizeOfBuffer is NULL, then ASSERT().
1161   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
1162
1163   @param[in]      Guid          Pointer to a 128-bit unique value that
1164                                 designates which namespace to set a value from.
1165   @param[in]      TokenNumber   The PCD token number to set a current value for.
1166   @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
1167   @param[in]      Buffer        A pointer to the buffer to set.
1168
1169   @return The status of the set operation.
1170
1171 **/
1172 RETURN_STATUS
1173 EFIAPI
1174 LibPcdSetExPtrS (
1175   IN CONST GUID     *Guid,
1176   IN       UINTN    TokenNumber,
1177   IN OUT   UINTN    *SizeOfBuffer,
1178   IN       VOID     *Buffer
1179   )
1180 {
1181   ASSERT (Guid != NULL);
1182
1183   ASSERT (SizeOfBuffer != NULL);
1184
1185   if (*SizeOfBuffer > 0) {
1186     ASSERT (Buffer != NULL);
1187   }
1188
1189   return GetPiPcdProtocol()->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer);
1190 }
1191
1192 /**
1193   This function provides a means by which to set a value for a given PCD token.
1194
1195   Sets the boolean value for the token specified by TokenNumber
1196   to the value specified by Value.
1197
1198   If Guid is NULL, then ASSERT().
1199
1200   @param[in] Guid           The pointer to a 128-bit unique value that
1201                             designates which namespace to set a value from.
1202   @param[in] TokenNumber    The PCD token number to set a current value for.
1203   @param[in] Value          The boolean value to set.
1204
1205   @return The status of the set operation.
1206
1207 **/
1208 RETURN_STATUS
1209 EFIAPI
1210 LibPcdSetExBoolS (
1211   IN CONST GUID     *Guid,
1212   IN UINTN          TokenNumber,
1213   IN BOOLEAN        Value
1214   )
1215 {
1216   ASSERT (Guid != NULL);
1217
1218   return GetPiPcdProtocol()->SetBool (Guid, TokenNumber, Value);
1219 }
1220
1221 /**
1222   Set up a notification function that is called when a specified token is set.
1223
1224   When the token specified by TokenNumber and Guid is set,
1225   then notification function specified by NotificationFunction is called.
1226   If Guid is NULL, then the default token space is used.
1227   If NotificationFunction is NULL, then ASSERT().
1228
1229   @param[in]  Guid                  The pointer to a 128-bit unique value that designates which
1230                                     namespace to set a value from.  If NULL, then the default
1231                                     token space is used.
1232   @param[in]  TokenNumber           The PCD token number to monitor.
1233   @param[in]  NotificationFunction  The function to call when the token
1234                                     specified by Guid and TokenNumber is set.
1235
1236 **/
1237 VOID
1238 EFIAPI
1239 LibPcdCallbackOnSet (
1240   IN CONST GUID               *Guid,       OPTIONAL
1241   IN UINTN                    TokenNumber,
1242   IN PCD_CALLBACK             NotificationFunction
1243   )
1244 {
1245   EFI_STATUS Status;
1246
1247   ASSERT (NotificationFunction != NULL);
1248
1249   Status = GetPiPcdProtocol()->CallbackOnSet (Guid, TokenNumber, (EFI_PCD_PROTOCOL_CALLBACK) NotificationFunction);
1250   ASSERT_EFI_ERROR (Status);
1251
1252   return;
1253 }
1254
1255
1256
1257 /**
1258   Disable a notification function that was established with LibPcdCallbackonSet().
1259
1260   Disable a notification function that was previously established with LibPcdCallbackOnSet().
1261   If NotificationFunction is NULL, then ASSERT().
1262   If LibPcdCallbackOnSet() was not previously called with Guid, TokenNumber,
1263   and NotificationFunction, then ASSERT().
1264
1265   @param[in]  Guid                 Specify the GUID token space.
1266   @param[in]  TokenNumber          Specify the token number.
1267   @param[in]  NotificationFunction The callback function to be unregistered.
1268
1269 **/
1270 VOID
1271 EFIAPI
1272 LibPcdCancelCallback (
1273   IN CONST GUID               *Guid,       OPTIONAL
1274   IN UINTN                    TokenNumber,
1275   IN PCD_CALLBACK             NotificationFunction
1276   )
1277 {
1278   EFI_STATUS Status;
1279
1280   ASSERT (NotificationFunction != NULL);
1281
1282   Status = GetPiPcdProtocol()->CancelCallback (Guid, TokenNumber, (EFI_PCD_PROTOCOL_CALLBACK) NotificationFunction);
1283   ASSERT_EFI_ERROR (Status);
1284
1285   return;
1286 }
1287
1288
1289
1290 /**
1291   Retrieves the next token in a token space.
1292
1293   Retrieves the next PCD token number from the token space specified by Guid.
1294   If Guid is NULL, then the default token space is used.  If TokenNumber is 0,
1295   then the first token number is returned.  Otherwise, the token number that
1296   follows TokenNumber in the token space is returned.  If TokenNumber is the last
1297   token number in the token space, then 0 is returned.
1298
1299   If TokenNumber is not 0 and is not in the token space specified by Guid, then ASSERT().
1300
1301   @param[in]  Guid        The pointer to a 128-bit unique value that designates which namespace
1302                           to set a value from.  If NULL, then the default token space is used.
1303   @param[in]  TokenNumber The previous PCD token number.  If 0, then retrieves the first PCD
1304                           token number.
1305
1306   @return The next valid token number.
1307
1308 **/
1309 UINTN
1310 EFIAPI
1311 LibPcdGetNextToken (
1312   IN CONST GUID               *Guid,       OPTIONAL
1313   IN UINTN                    TokenNumber
1314   )
1315 {
1316   EFI_STATUS    Status;
1317
1318   Status = GetPiPcdProtocol()->GetNextToken (Guid, &TokenNumber);
1319   ASSERT (!EFI_ERROR (Status) || TokenNumber == 0);
1320
1321   return TokenNumber;
1322 }
1323
1324
1325
1326 /**
1327   Used to retrieve the list of available PCD token space GUIDs.
1328
1329   Returns the PCD token space GUID that follows TokenSpaceGuid in the list of token spaces
1330   in the platform.
1331   If TokenSpaceGuid is NULL, then a pointer to the first PCD token spaces returned.
1332   If TokenSpaceGuid is the last PCD token space GUID in the list, then NULL is returned.
1333
1334   @param  TokenSpaceGuid  The pointer to the a PCD token space GUID.
1335
1336   @return The next valid token namespace.
1337
1338 **/
1339 GUID *
1340 EFIAPI
1341 LibPcdGetNextTokenSpace (
1342   IN CONST GUID  *TokenSpaceGuid
1343   )
1344 {
1345   GetPiPcdProtocol()->GetNextTokenSpace (&TokenSpaceGuid);
1346
1347   return (GUID *)TokenSpaceGuid;
1348 }
1349
1350
1351 /**
1352   Sets a value of a patchable PCD entry that is type pointer.
1353
1354   Sets the PCD entry specified by PatchVariable to the value specified by Buffer
1355   and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than
1356   MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return
1357   NULL to indicate that the set operation was not actually performed.
1358   If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
1359   MaximumDatumSize and NULL must be returned.
1360
1361   If PatchVariable is NULL, then ASSERT().
1362   If SizeOfBuffer is NULL, then ASSERT().
1363   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
1364
1365   @param[in] PatchVariable      A pointer to the global variable in a module that is
1366                                 the target of the set operation.
1367   @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
1368   @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
1369   @param[in] Buffer             A pointer to the buffer to used to set the target variable.
1370
1371   @return Return the pointer to the buffer been set.
1372
1373 **/
1374 VOID *
1375 EFIAPI
1376 LibPatchPcdSetPtr (
1377   IN        VOID        *PatchVariable,
1378   IN        UINTN       MaximumDatumSize,
1379   IN OUT    UINTN       *SizeOfBuffer,
1380   IN CONST  VOID        *Buffer
1381   )
1382 {
1383   ASSERT (PatchVariable != NULL);
1384   ASSERT (SizeOfBuffer  != NULL);
1385
1386   if (*SizeOfBuffer > 0) {
1387     ASSERT (Buffer != NULL);
1388   }
1389
1390   if ((*SizeOfBuffer > MaximumDatumSize) ||
1391       (*SizeOfBuffer == MAX_ADDRESS)) {
1392     *SizeOfBuffer = MaximumDatumSize;
1393     return NULL;
1394   }
1395
1396   CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
1397
1398   return (VOID *) Buffer;
1399 }
1400
1401 /**
1402   Sets a value of a patchable PCD entry that is type pointer.
1403
1404   Sets the PCD entry specified by PatchVariable to the value specified
1405   by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize,
1406   then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER
1407   to indicate that the set operation was not actually performed.
1408   If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
1409   MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned.
1410
1411   If PatchVariable is NULL, then ASSERT().
1412   If SizeOfBuffer is NULL, then ASSERT().
1413   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
1414
1415   @param[in] PatchVariable      A pointer to the global variable in a module that is
1416                                 the target of the set operation.
1417   @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
1418   @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
1419   @param[in] Buffer             A pointer to the buffer to used to set the target variable.
1420
1421   @return The status of the set operation.
1422
1423 **/
1424 RETURN_STATUS
1425 EFIAPI
1426 LibPatchPcdSetPtrS (
1427   IN       VOID     *PatchVariable,
1428   IN       UINTN    MaximumDatumSize,
1429   IN OUT   UINTN    *SizeOfBuffer,
1430   IN CONST VOID     *Buffer
1431   )
1432 {
1433   ASSERT (PatchVariable != NULL);
1434   ASSERT (SizeOfBuffer  != NULL);
1435
1436   if (*SizeOfBuffer > 0) {
1437     ASSERT (Buffer != NULL);
1438   }
1439
1440   if ((*SizeOfBuffer > MaximumDatumSize) ||
1441       (*SizeOfBuffer == MAX_ADDRESS)) {
1442     *SizeOfBuffer = MaximumDatumSize;
1443     return RETURN_INVALID_PARAMETER;
1444   }
1445
1446   CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
1447
1448   return RETURN_SUCCESS;
1449 }
1450
1451 /**
1452   Retrieve additional information associated with a PCD token.
1453
1454   This includes information such as the type of value the TokenNumber is associated with as well as possible
1455   human readable name that is associated with the token.
1456
1457   If TokenNumber is not in the default token space specified, then ASSERT().
1458
1459   @param[in]    TokenNumber The PCD token number.
1460   @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
1461                             The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
1462 **/
1463 VOID
1464 EFIAPI
1465 LibPcdGetInfo (
1466   IN        UINTN           TokenNumber,
1467   OUT       PCD_INFO        *PcdInfo
1468   )
1469 {
1470   EFI_STATUS Status;
1471
1472   Status = GetPcdInfoProtocolPointer()->GetInfo (TokenNumber, (EFI_PCD_INFO *) PcdInfo);
1473   ASSERT_EFI_ERROR (Status);
1474 }
1475
1476 /**
1477   Retrieve additional information associated with a PCD token.
1478
1479   This includes information such as the type of value the TokenNumber is associated with as well as possible
1480   human readable name that is associated with the token.
1481
1482   If TokenNumber is not in the token space specified by Guid, then ASSERT().
1483
1484   @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
1485   @param[in]    TokenNumber The PCD token number.
1486   @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
1487                             The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
1488 **/
1489 VOID
1490 EFIAPI
1491 LibPcdGetInfoEx (
1492   IN CONST  GUID            *Guid,
1493   IN        UINTN           TokenNumber,
1494   OUT       PCD_INFO        *PcdInfo
1495   )
1496 {
1497   EFI_STATUS Status;
1498
1499   Status = GetPiPcdInfoProtocolPointer()->GetInfo (Guid, TokenNumber, (EFI_PCD_INFO *) PcdInfo);
1500   ASSERT_EFI_ERROR (Status);
1501 }
1502
1503 /**
1504   Retrieve the currently set SKU Id.
1505
1506   If the sku id got >= PCD_MAX_SKU_ID, then ASSERT().
1507
1508   @return   The currently set SKU Id. If the platform has not set at a SKU Id, then the
1509             default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
1510             Id is returned.
1511 **/
1512 UINTN
1513 EFIAPI
1514 LibPcdGetSku (
1515   VOID
1516   )
1517 {
1518   UINTN SkuId;
1519
1520   SkuId = GetPiPcdInfoProtocolPointer()->GetSku ();
1521   ASSERT (SkuId < PCD_MAX_SKU_ID);
1522
1523   return SkuId;
1524 }
1525