MdePkg/Library/BasePcdLibNull/PcdLib.c

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