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   This function provides a means by which SKU support can be established in the PCD infrastructure.
  17
  18   Sets the current SKU in the PCD database to the value specified by SkuId.  SkuId is returned.
  19
  20   @param[in]  SkuId The SKU value that will be used when the PCD service will retrieve and
  21                     set values associated with a PCD token.
  22
  23   @return Return the SKU ID that just be set.
  24
  25 **/
  26 UINTN
  27 EFIAPI
  28 LibPcdSetSku (
  29   IN UINTN  SkuId
  30   )
  31 {
  32   ASSERT (FALSE);
  33
  34   return 0;
  35 }
  36
  37 /**
  38   This function provides a means by which to retrieve a value for a given PCD token.
  39
  40   Returns the 8-bit value for the token specified by TokenNumber.
  41
  42   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
  43
  44   @return Returns the 8-bit value for the token specified by TokenNumber.
  45
  46 **/
  47 UINT8
  48 EFIAPI
  49 LibPcdGet8 (
  50   IN UINTN  TokenNumber
  51   )
  52 {
  53   ASSERT (FALSE);
  54
  55   return 0;
  56 }
  57
  58 /**
  59   This function provides a means by which to retrieve a value for a given PCD token.
  60
  61   Returns the 16-bit value for the token specified by TokenNumber.
  62
  63   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
  64
  65   @return Returns the 16-bit value for the token specified by TokenNumber.
  66
  67 **/
  68 UINT16
  69 EFIAPI
  70 LibPcdGet16 (
  71   IN UINTN  TokenNumber
  72   )
  73 {
  74   ASSERT (FALSE);
  75
  76   return 0;
  77 }
  78
  79 /**
  80   This function provides a means by which to retrieve a value for a given PCD token.
  81
  82   Returns the 32-bit value for the token specified by TokenNumber.
  83
  84   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
  85
  86   @return Returns the 32-bit value for the token specified by TokenNumber.
  87
  88 **/
  89 UINT32
  90 EFIAPI
  91 LibPcdGet32 (
  92   IN UINTN  TokenNumber
  93   )
  94 {
  95   ASSERT (FALSE);
  96
  97   return 0;
  98 }
  99
 100 /**
 101   This function provides a means by which to retrieve a value for a given PCD token.
 102
 103   Returns the 64-bit value for the token specified by TokenNumber.
 104
 105   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 106
 107   @return Returns the 64-bit value for the token specified by TokenNumber.
 108
 109 **/
 110 UINT64
 111 EFIAPI
 112 LibPcdGet64 (
 113   IN UINTN  TokenNumber
 114   )
 115 {
 116   ASSERT (FALSE);
 117
 118   return 0;
 119 }
 120
 121 /**
 122   This function provides a means by which to retrieve a value for a given PCD token.
 123
 124   Returns the pointer to the buffer of the token specified by TokenNumber.
 125
 126   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 127
 128   @return Returns the pointer to the token specified by TokenNumber.
 129
 130 **/
 131 VOID *
 132 EFIAPI
 133 LibPcdGetPtr (
 134   IN UINTN  TokenNumber
 135   )
 136 {
 137   ASSERT (FALSE);
 138
 139   return 0;
 140 }
 141
 142 /**
 143   This function provides a means by which to retrieve a value for a given PCD token.
 144
 145   Returns the Boolean value of the token specified by TokenNumber.
 146
 147   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 148
 149   @return Returns the Boolean value of the token specified by TokenNumber.
 150
 151 **/
 152 BOOLEAN
 153 EFIAPI
 154 LibPcdGetBool (
 155   IN UINTN  TokenNumber
 156   )
 157 {
 158   ASSERT (FALSE);
 159
 160   return 0;
 161 }
 162
 163 /**
 164   This function provides a means by which to retrieve the size of a given PCD token.
 165
 166   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 167
 168   @return Returns the size of the token specified by TokenNumber.
 169
 170 **/
 171 UINTN
 172 EFIAPI
 173 LibPcdGetSize (
 174   IN UINTN  TokenNumber
 175   )
 176 {
 177   ASSERT (FALSE);
 178
 179   return 0;
 180 }
 181
 182 /**
 183   This function provides a means by which to retrieve a value for a given PCD token.
 184
 185   Returns the 8-bit value for the token specified by TokenNumber and Guid.
 186
 187   If Guid is NULL, then ASSERT().
 188
 189   @param[in]  Guid The pointer to a 128-bit unique value that designates
 190               which namespace to retrieve a value from.
 191   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 192
 193   @return Return the UINT8.
 194
 195 **/
 196 UINT8
 197 EFIAPI
 198 LibPcdGetEx8 (
 199   IN CONST GUID  *Guid,
 200   IN UINTN       TokenNumber
 201   )
 202 {
 203   ASSERT (FALSE);
 204
 205   return 0;
 206 }
 207
 208 /**
 209   This function provides a means by which to retrieve a value for a given PCD token.
 210
 211   Returns the 16-bit value for the token specified by TokenNumber and Guid.
 212
 213   If Guid is NULL, then ASSERT().
 214
 215   @param[in]  Guid The pointer to a 128-bit unique value that designates
 216               which namespace to retrieve a value from.
 217   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 218
 219   @return Return the UINT16.
 220
 221 **/
 222 UINT16
 223 EFIAPI
 224 LibPcdGetEx16 (
 225   IN CONST GUID  *Guid,
 226   IN UINTN       TokenNumber
 227   )
 228 {
 229   ASSERT (FALSE);
 230
 231   return 0;
 232 }
 233
 234 /**
 235   Returns the 32-bit value for the token specified by TokenNumber and Guid.
 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 UINT32.
 243
 244 **/
 245 UINT32
 246 EFIAPI
 247 LibPcdGetEx32 (
 248   IN CONST GUID  *Guid,
 249   IN UINTN       TokenNumber
 250   )
 251 {
 252   ASSERT (FALSE);
 253
 254   return 0;
 255 }
 256
 257 /**
 258   This function provides a means by which to retrieve a value for a given PCD token.
 259
 260   Returns the 64-bit value for the token specified by TokenNumber and Guid.
 261
 262   If Guid is NULL, then ASSERT().
 263
 264   @param[in]  Guid          The pointer to a 128-bit unique value that designates
 265                             which namespace to retrieve a value from.
 266   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 267
 268   @return Return the UINT64.
 269
 270 **/
 271 UINT64
 272 EFIAPI
 273 LibPcdGetEx64 (
 274   IN CONST GUID  *Guid,
 275   IN UINTN       TokenNumber
 276   )
 277 {
 278   ASSERT (FALSE);
 279
 280   return 0;
 281 }
 282
 283 /**
 284   This function provides a means by which to retrieve a value for a given PCD token.
 285
 286   Returns the pointer to the buffer of token specified by TokenNumber and Guid.
 287
 288   If Guid is NULL, then ASSERT().
 289
 290   @param[in]  Guid          The pointer to a 128-bit unique value that designates
 291                             which namespace to retrieve a value from.
 292   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 293
 294   @return Return the VOID* pointer.
 295
 296 **/
 297 VOID *
 298 EFIAPI
 299 LibPcdGetExPtr (
 300   IN CONST GUID  *Guid,
 301   IN UINTN       TokenNumber
 302   )
 303 {
 304   ASSERT (FALSE);
 305
 306   return 0;
 307 }
 308
 309 /**
 310   This function provides a means by which to retrieve a value for a given PCD token.
 311
 312   Returns the Boolean value of the token specified by TokenNumber and Guid.
 313
 314   If Guid is NULL, then ASSERT().
 315
 316   @param[in]  Guid          The pointer to a 128-bit unique value that designates
 317                             which namespace to retrieve a value from.
 318   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 319
 320   @return Return the BOOLEAN.
 321
 322 **/
 323 BOOLEAN
 324 EFIAPI
 325 LibPcdGetExBool (
 326   IN CONST GUID  *Guid,
 327   IN UINTN       TokenNumber
 328   )
 329 {
 330   ASSERT (FALSE);
 331
 332   return 0;
 333 }
 334
 335 /**
 336   This function provides a means by which to retrieve the size of a given PCD token.
 337
 338   Returns the size of the token specified by TokenNumber and Guid.
 339
 340   If Guid is NULL, then ASSERT().
 341
 342   @param[in]  Guid          The pointer to a 128-bit unique value that designates
 343                             which namespace to retrieve a value from.
 344   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 345
 346   @return Return the size.
 347
 348 **/
 349 UINTN
 350 EFIAPI
 351 LibPcdGetExSize (
 352   IN CONST GUID  *Guid,
 353   IN UINTN       TokenNumber
 354   )
 355 {
 356   ASSERT (FALSE);
 357
 358   return 0;
 359 }
 360
 361 /**
 362   This function provides a means by which to set a value for a given PCD token.
 363
 364   Sets the 8-bit value for the token specified by TokenNumber
 365   to the value specified by Value.
 366
 367   @param[in] TokenNumber    The PCD token number to set a current value for.
 368   @param[in] Value          The 8-bit value to set.
 369
 370   @return The status of the set operation.
 371
 372 **/
 373 RETURN_STATUS
 374 EFIAPI
 375 LibPcdSet8S (
 376   IN UINTN  TokenNumber,
 377   IN UINT8  Value
 378   )
 379 {
 380   ASSERT (FALSE);
 381
 382   return RETURN_INVALID_PARAMETER;
 383 }
 384
 385 /**
 386   This function provides a means by which to set a value for a given PCD token.
 387
 388   Sets the 16-bit value for the token specified by TokenNumber
 389   to the value specified by Value.
 390
 391   @param[in] TokenNumber    The PCD token number to set a current value for.
 392   @param[in] Value          The 16-bit value to set.
 393
 394   @return The status of the set operation.
 395
 396 **/
 397 RETURN_STATUS
 398 EFIAPI
 399 LibPcdSet16S (
 400   IN UINTN   TokenNumber,
 401   IN UINT16  Value
 402   )
 403 {
 404   ASSERT (FALSE);
 405
 406   return RETURN_INVALID_PARAMETER;
 407 }
 408
 409 /**
 410   This function provides a means by which to set a value for a given PCD token.
 411
 412   Sets the 32-bit value for the token specified by TokenNumber
 413   to the value specified by Value.
 414
 415   @param[in] TokenNumber    The PCD token number to set a current value for.
 416   @param[in] Value          The 32-bit value to set.
 417
 418   @return The status of the set operation.
 419
 420 **/
 421 RETURN_STATUS
 422 EFIAPI
 423 LibPcdSet32S (
 424   IN UINTN   TokenNumber,
 425   IN UINT32  Value
 426   )
 427 {
 428   ASSERT (FALSE);
 429
 430   return RETURN_INVALID_PARAMETER;
 431 }
 432
 433 /**
 434   This function provides a means by which to set a value for a given PCD token.
 435
 436   Sets the 64-bit value for the token specified by TokenNumber
 437   to the value specified by Value.
 438
 439   @param[in] TokenNumber    The PCD token number to set a current value for.
 440   @param[in] Value          The 64-bit value to set.
 441
 442   @return The status of the set operation.
 443
 444 **/
 445 RETURN_STATUS
 446 EFIAPI
 447 LibPcdSet64S (
 448   IN UINTN   TokenNumber,
 449   IN UINT64  Value
 450   )
 451 {
 452   ASSERT (FALSE);
 453
 454   return RETURN_INVALID_PARAMETER;
 455 }
 456
 457 /**
 458   This function provides a means by which to set a value for a given PCD token.
 459
 460   Sets a buffer for the token specified by TokenNumber to the value specified
 461   by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
 462   support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
 463   TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation
 464   was not actually performed.
 465
 466   If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the
 467   maximum size supported by TokenName and EFI_INVALID_PARAMETER must be returned.
 468
 469   If SizeOfBuffer is NULL, then ASSERT().
 470   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 471
 472   @param[in]      TokenNumber   The PCD token number to set a current value for.
 473   @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
 474   @param[in]      Buffer        A pointer to the buffer to set.
 475
 476   @return The status of the set operation.
 477
 478 **/
 479 RETURN_STATUS
 480 EFIAPI
 481 LibPcdSetPtrS (
 482   IN       UINTN  TokenNumber,
 483   IN OUT   UINTN  *SizeOfBuffer,
 484   IN CONST VOID   *Buffer
 485   )
 486 {
 487   ASSERT (FALSE);
 488
 489   return RETURN_INVALID_PARAMETER;
 490 }
 491
 492 /**
 493   This function provides a means by which to set a value for a given PCD token.
 494
 495   Sets the boolean value for the token specified by TokenNumber
 496   to the value specified by Value.
 497
 498   @param[in] TokenNumber    The PCD token number to set a current value for.
 499   @param[in] Value          The boolean value to set.
 500
 501   @return The status of the set operation.
 502
 503 **/
 504 RETURN_STATUS
 505 EFIAPI
 506 LibPcdSetBoolS (
 507   IN UINTN    TokenNumber,
 508   IN BOOLEAN  Value
 509   )
 510 {
 511   ASSERT (FALSE);
 512
 513   return RETURN_INVALID_PARAMETER;
 514 }
 515
 516 /**
 517   This function provides a means by which to set a value for a given PCD token.
 518
 519   Sets the 8-bit value for the token specified by TokenNumber
 520   to the value specified by Value.
 521
 522   If Guid is NULL, then ASSERT().
 523
 524   @param[in] Guid           The pointer to a 128-bit unique value that
 525                             designates which namespace to set a value from.
 526   @param[in] TokenNumber    The PCD token number to set a current value for.
 527   @param[in] Value          The 8-bit value to set.
 528
 529   @return The status of the set operation.
 530
 531 **/
 532 RETURN_STATUS
 533 EFIAPI
 534 LibPcdSetEx8S (
 535   IN CONST GUID  *Guid,
 536   IN UINTN       TokenNumber,
 537   IN UINT8       Value
 538   )
 539 {
 540   ASSERT (FALSE);
 541
 542   return RETURN_INVALID_PARAMETER;
 543 }
 544
 545 /**
 546   This function provides a means by which to set a value for a given PCD token.
 547
 548   Sets the 16-bit value for the token specified by TokenNumber
 549   to the value specified by Value.
 550
 551   If Guid is NULL, then ASSERT().
 552
 553   @param[in] Guid           The pointer to a 128-bit unique value that
 554                             designates which namespace to set a value from.
 555   @param[in] TokenNumber    The PCD token number to set a current value for.
 556   @param[in] Value          The 16-bit value to set.
 557
 558   @return The status of the set operation.
 559
 560 **/
 561 RETURN_STATUS
 562 EFIAPI
 563 LibPcdSetEx16S (
 564   IN CONST GUID  *Guid,
 565   IN UINTN       TokenNumber,
 566   IN UINT16      Value
 567   )
 568 {
 569   ASSERT (FALSE);
 570
 571   return RETURN_INVALID_PARAMETER;
 572 }
 573
 574 /**
 575   This function provides a means by which to set a value for a given PCD token.
 576
 577   Sets the 32-bit value for the token specified by TokenNumber
 578   to the value specified by Value.
 579
 580   If Guid is NULL, then ASSERT().
 581
 582   @param[in] Guid           The pointer to a 128-bit unique value that
 583                             designates which namespace to set a value from.
 584   @param[in] TokenNumber    The PCD token number to set a current value for.
 585   @param[in] Value          The 32-bit value to set.
 586
 587   @return The status of the set operation.
 588
 589 **/
 590 RETURN_STATUS
 591 EFIAPI
 592 LibPcdSetEx32S (
 593   IN CONST GUID  *Guid,
 594   IN UINTN       TokenNumber,
 595   IN UINT32      Value
 596   )
 597 {
 598   ASSERT (FALSE);
 599
 600   return RETURN_INVALID_PARAMETER;
 601 }
 602
 603 /**
 604   This function provides a means by which to set a value for a given PCD token.
 605
 606   Sets the 64-bit value for the token specified by TokenNumber
 607   to the value specified by Value.
 608
 609   If Guid is NULL, then ASSERT().
 610
 611   @param[in] Guid           The pointer to a 128-bit unique value that
 612                             designates which namespace to set a value from.
 613   @param[in] TokenNumber    The PCD token number to set a current value for.
 614   @param[in] Value          The 64-bit value to set.
 615
 616   @return The status of the set operation.
 617
 618 **/
 619 RETURN_STATUS
 620 EFIAPI
 621 LibPcdSetEx64S (
 622   IN CONST GUID  *Guid,
 623   IN UINTN       TokenNumber,
 624   IN UINT64      Value
 625   )
 626 {
 627   ASSERT (FALSE);
 628
 629   return RETURN_INVALID_PARAMETER;
 630 }
 631
 632 /**
 633   This function provides a means by which to set a value for a given PCD token.
 634
 635   Sets a buffer for the token specified by TokenNumber to the value specified by
 636   Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size
 637   support by TokenNumber, then set SizeOfBuffer to the maximum size supported by
 638   TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation
 639   was not actually performed.
 640
 641   If Guid is NULL, then ASSERT().
 642   If SizeOfBuffer is NULL, then ASSERT().
 643   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 644
 645   @param[in]      Guid          Pointer to a 128-bit unique value that
 646                                 designates which namespace to set a value from.
 647   @param[in]      TokenNumber   The PCD token number to set a current value for.
 648   @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
 649   @param[in]      Buffer        A pointer to the buffer to set.
 650
 651   @return The status of the set operation.
 652
 653 **/
 654 RETURN_STATUS
 655 EFIAPI
 656 LibPcdSetExPtrS (
 657   IN CONST GUID   *Guid,
 658   IN       UINTN  TokenNumber,
 659   IN OUT   UINTN  *SizeOfBuffer,
 660   IN       VOID   *Buffer
 661   )
 662 {
 663   ASSERT (FALSE);
 664
 665   return RETURN_INVALID_PARAMETER;
 666 }
 667
 668 /**
 669   This function provides a means by which to set a value for a given PCD token.
 670
 671   Sets the boolean value for the token specified by TokenNumber
 672   to the value specified by Value.
 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 boolean value to set.
 680
 681   @return The status of the set operation.
 682
 683 **/
 684 RETURN_STATUS
 685 EFIAPI
 686 LibPcdSetExBoolS (
 687   IN CONST GUID  *Guid,
 688   IN UINTN       TokenNumber,
 689   IN BOOLEAN     Value
 690   )
 691 {
 692   ASSERT (FALSE);
 693
 694   return RETURN_INVALID_PARAMETER;
 695 }
 696
 697 /**
 698   Set up a notification function that is called when a specified token is set.
 699
 700   When the token specified by TokenNumber and Guid is set,
 701   then notification function specified by NotificationFunction is called.
 702   If Guid is NULL, then the default token space is used.
 703
 704   If NotificationFunction is NULL, then ASSERT().
 705
 706   @param[in]  Guid      The pointer to a 128-bit unique value that designates which
 707                         namespace to set a value from.  If NULL, then the default
 708                         token space is used.
 709   @param[in]  TokenNumber   The PCD token number to monitor.
 710   @param[in]  NotificationFunction  The function to call when the token
 711                                     specified by Guid and TokenNumber is set.
 712
 713 **/
 714 VOID
 715 EFIAPI
 716 LibPcdCallbackOnSet (
 717   IN CONST GUID    *Guid        OPTIONAL,
 718   IN UINTN         TokenNumber,
 719   IN PCD_CALLBACK  NotificationFunction
 720   )
 721 {
 722   ASSERT (FALSE);
 723 }
 724
 725 /**
 726   Disable a notification function that was established with LibPcdCallbackonSet().
 727
 728   Disable a notification function that was previously established with LibPcdCallbackOnSet().
 729
 730   If NotificationFunction is NULL, then ASSERT().
 731   If LibPcdCallbackOnSet() was not previously called with Guid, TokenNumber,
 732   and NotificationFunction, then ASSERT().
 733
 734   @param[in]  Guid          Specify the GUID token space.
 735   @param[in]  TokenNumber   Specify the token number.
 736   @param[in]  NotificationFunction The callback function to be unregistered.
 737
 738 **/
 739 VOID
 740 EFIAPI
 741 LibPcdCancelCallback (
 742   IN CONST GUID    *Guid        OPTIONAL,
 743   IN UINTN         TokenNumber,
 744   IN PCD_CALLBACK  NotificationFunction
 745   )
 746 {
 747   ASSERT (FALSE);
 748 }
 749
 750 /**
 751   Retrieves the next token in a token space.
 752
 753   Retrieves the next PCD token number from the token space specified by Guid.
 754   If Guid is NULL, then the default token space is used.  If TokenNumber is 0,
 755   then the first token number is returned.  Otherwise, the token number that
 756   follows TokenNumber in the token space is returned.  If TokenNumber is the last
 757   token number in the token space, then 0 is returned.
 758
 759   If TokenNumber is not 0 and is not in the token space specified by Guid, then ASSERT().
 760
 761   @param[in]  Guid        The pointer to a 128-bit unique value that designates which namespace
 762                           to set a value from.  If NULL, then the default token space is used.
 763   @param[in]  TokenNumber The previous PCD token number.  If 0, then retrieves the first PCD
 764                           token number.
 765
 766   @return The next valid token number.
 767
 768 **/
 769 UINTN
 770 EFIAPI
 771 LibPcdGetNextToken (
 772   IN CONST GUID  *Guid        OPTIONAL,
 773   IN UINTN       TokenNumber
 774   )
 775 {
 776   ASSERT (FALSE);
 777
 778   return 0;
 779 }
 780
 781 /**
 782   Used to retrieve the list of available PCD token space GUIDs.
 783
 784   Returns the PCD token space GUID that follows TokenSpaceGuid in the list of token spaces
 785   in the platform.
 786   If TokenSpaceGuid is NULL, then a pointer to the first PCD token spaces returned.
 787   If TokenSpaceGuid is the last PCD token space GUID in the list, then NULL is returned.
 788
 789   @param  TokenSpaceGuid  The pointer to a PCD token space GUID.
 790
 791   @return The next valid token namespace.
 792
 793 **/
 794 GUID *
 795 EFIAPI
 796 LibPcdGetNextTokenSpace (
 797   IN CONST GUID  *TokenSpaceGuid
 798   )
 799 {
 800   ASSERT (FALSE);
 801
 802   return NULL;
 803 }
 804
 805 /**
 806   Sets a value of a patchable PCD entry that is type pointer.
 807
 808   Sets the PCD entry specified by PatchVariable to the value specified by Buffer
 809   and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than
 810   MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return
 811   NULL to indicate that the set operation was not actually performed.
 812   If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
 813   MaximumDatumSize and NULL must be returned.
 814
 815   If PatchVariable is NULL, then ASSERT().
 816   If SizeOfBuffer is NULL, then ASSERT().
 817   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 818
 819   @param[out] PatchVariable     A pointer to the global variable in a module that is
 820                                 the target of the set operation.
 821   @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
 822   @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
 823   @param[in] Buffer             A pointer to the buffer to used to set the target variable.
 824
 825   @return Return the pointer to the buffer that was set.
 826
 827 **/
 828 VOID *
 829 EFIAPI
 830 LibPatchPcdSetPtr (
 831   OUT       VOID   *PatchVariable,
 832   IN        UINTN  MaximumDatumSize,
 833   IN OUT    UINTN  *SizeOfBuffer,
 834   IN CONST  VOID   *Buffer
 835   )
 836 {
 837   ASSERT (PatchVariable != NULL);
 838   ASSERT (SizeOfBuffer  != NULL);
 839
 840   if (*SizeOfBuffer > 0) {
 841     ASSERT (Buffer != NULL);
 842   }
 843
 844   if ((*SizeOfBuffer > MaximumDatumSize) ||
 845       (*SizeOfBuffer == MAX_ADDRESS))
 846   {
 847     *SizeOfBuffer = MaximumDatumSize;
 848     return NULL;
 849   }
 850
 851   CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
 852
 853   return (VOID *)Buffer;
 854 }
 855
 856 /**
 857   Sets a value of a patchable PCD entry that is type pointer.
 858
 859   Sets the PCD entry specified by PatchVariable to the value specified
 860   by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize,
 861   then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER
 862   to indicate that the set operation was not actually performed.
 863   If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
 864   MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned.
 865
 866   If PatchVariable is NULL, then ASSERT().
 867   If SizeOfBuffer is NULL, then ASSERT().
 868   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 869
 870   @param[out] PatchVariable     A pointer to the global variable in a module that is
 871                                 the target of the set operation.
 872   @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
 873   @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
 874   @param[in] Buffer             A pointer to the buffer to used to set the target variable.
 875
 876   @return The status of the set operation.
 877
 878 **/
 879 RETURN_STATUS
 880 EFIAPI
 881 LibPatchPcdSetPtrS (
 882   OUT      VOID   *PatchVariable,
 883   IN       UINTN  MaximumDatumSize,
 884   IN OUT   UINTN  *SizeOfBuffer,
 885   IN CONST VOID   *Buffer
 886   )
 887 {
 888   ASSERT (PatchVariable != NULL);
 889   ASSERT (SizeOfBuffer  != NULL);
 890
 891   if (*SizeOfBuffer > 0) {
 892     ASSERT (Buffer != NULL);
 893   }
 894
 895   if ((*SizeOfBuffer > MaximumDatumSize) ||
 896       (*SizeOfBuffer == MAX_ADDRESS))
 897   {
 898     *SizeOfBuffer = MaximumDatumSize;
 899     return RETURN_INVALID_PARAMETER;
 900   }
 901
 902   CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
 903
 904   return RETURN_SUCCESS;
 905 }
 906
 907 /**
 908   Sets a value and size of a patchable PCD entry that is type pointer.
 909
 910   Sets the PCD entry specified by PatchVariable to the value specified by Buffer
 911   and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than
 912   MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return
 913   NULL to indicate that the set operation was not actually performed.
 914   If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
 915   MaximumDatumSize and NULL must be returned.
 916
 917   If PatchVariable is NULL, then ASSERT().
 918   If SizeOfPatchVariable is NULL, then ASSERT().
 919   If SizeOfBuffer is NULL, then ASSERT().
 920   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 921
 922   @param[out] PatchVariable     A pointer to the global variable in a module that is
 923                                 the target of the set operation.
 924   @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable.
 925   @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
 926   @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
 927   @param[in] Buffer             A pointer to the buffer to used to set the target variable.
 928
 929   @return Return the pointer to the buffer been set.
 930
 931 **/
 932 VOID *
 933 EFIAPI
 934 LibPatchPcdSetPtrAndSize (
 935   OUT       VOID   *PatchVariable,
 936   OUT       UINTN  *SizeOfPatchVariable,
 937   IN        UINTN  MaximumDatumSize,
 938   IN OUT    UINTN  *SizeOfBuffer,
 939   IN CONST  VOID   *Buffer
 940   )
 941 {
 942   ASSERT (PatchVariable != NULL);
 943   ASSERT (SizeOfPatchVariable != NULL);
 944   ASSERT (SizeOfBuffer  != NULL);
 945
 946   if (*SizeOfBuffer > 0) {
 947     ASSERT (Buffer != NULL);
 948   }
 949
 950   if ((*SizeOfBuffer > MaximumDatumSize) ||
 951       (*SizeOfBuffer == MAX_ADDRESS))
 952   {
 953     *SizeOfBuffer = MaximumDatumSize;
 954     return NULL;
 955   }
 956
 957   CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
 958   *SizeOfPatchVariable = *SizeOfBuffer;
 959
 960   return (VOID *)Buffer;
 961 }
 962
 963 /**
 964   Sets a value and size of a patchable PCD entry that is type pointer.
 965
 966   Sets the PCD entry specified by PatchVariable to the value specified
 967   by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize,
 968   then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER
 969   to indicate that the set operation was not actually performed.
 970   If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
 971   MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned.
 972
 973   If PatchVariable is NULL, then ASSERT().
 974   If SizeOfPatchVariable is NULL, then ASSERT().
 975   If SizeOfBuffer is NULL, then ASSERT().
 976   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 977
 978   @param[out] PatchVariable     A pointer to the global variable in a module that is
 979                                 the target of the set operation.
 980   @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable.
 981   @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
 982   @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
 983   @param[in] Buffer             A pointer to the buffer to used to set the target variable.
 984
 985   @return The status of the set operation.
 986
 987 **/
 988 RETURN_STATUS
 989 EFIAPI
 990 LibPatchPcdSetPtrAndSizeS (
 991   OUT      VOID   *PatchVariable,
 992   OUT      UINTN  *SizeOfPatchVariable,
 993   IN       UINTN  MaximumDatumSize,
 994   IN OUT   UINTN  *SizeOfBuffer,
 995   IN CONST VOID   *Buffer
 996   )
 997 {
 998   ASSERT (PatchVariable != NULL);
 999   ASSERT (SizeOfPatchVariable != NULL);
1000   ASSERT (SizeOfBuffer  != NULL);
1001
1002   if (*SizeOfBuffer > 0) {
1003     ASSERT (Buffer != NULL);
1004   }
1005
1006   if ((*SizeOfBuffer > MaximumDatumSize) ||
1007       (*SizeOfBuffer == MAX_ADDRESS))
1008   {
1009     *SizeOfBuffer = MaximumDatumSize;
1010     return RETURN_INVALID_PARAMETER;
1011   }
1012
1013   CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
1014   *SizeOfPatchVariable = *SizeOfBuffer;
1015
1016   return RETURN_SUCCESS;
1017 }
1018
1019 /**
1020   Retrieve additional information associated with a PCD token.
1021
1022   This includes information such as the type of value the TokenNumber is associated with as well as possible
1023   human readable name that is associated with the token.
1024
1025   If TokenNumber is not in the default token space specified, then ASSERT().
1026
1027   @param[in]    TokenNumber The PCD token number.
1028   @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
1029                             The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
1030 **/
1031 VOID
1032 EFIAPI
1033 LibPcdGetInfo (
1034   IN        UINTN     TokenNumber,
1035   OUT       PCD_INFO  *PcdInfo
1036   )
1037 {
1038   ASSERT (FALSE);
1039 }
1040
1041 /**
1042   Retrieve additional information associated with a PCD token.
1043
1044   This includes information such as the type of value the TokenNumber is associated with as well as possible
1045   human readable name that is associated with the token.
1046
1047   If TokenNumber is not in the token space specified by Guid, then ASSERT().
1048
1049   @param[in]    Guid        The 128-bit unique value that designates the namespace from which to extract the value.
1050   @param[in]    TokenNumber The PCD token number.
1051   @param[out]   PcdInfo     The returned information associated with the requested TokenNumber.
1052                             The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
1053 **/
1054 VOID
1055 EFIAPI
1056 LibPcdGetInfoEx (
1057   IN CONST  GUID      *Guid,
1058   IN        UINTN     TokenNumber,
1059   OUT       PCD_INFO  *PcdInfo
1060   )
1061 {
1062   ASSERT (FALSE);
1063 }
1064
1065 /**
1066   Retrieve the currently set SKU Id.
1067
1068   @return   The currently set SKU Id. If the platform has not set at a SKU Id, then the
1069             default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
1070             Id is returned.
1071 **/
1072 UINTN
1073 EFIAPI
1074 LibPcdGetSku (
1075   VOID
1076   )
1077 {
1078   ASSERT (FALSE);
1079
1080   return 0;
1081 }