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