MdePkg/Library/BasePcdLibNull/PcdLib.c

   1 /** @file
   2   A emptry template implementation of PCD Library.
   3
   4   Copyright (c) 2006, Intel Corporation
   5   All rights reserved. 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   Module Name:  PcdLib.c
  14
  15 **/
  16
  17
  18
  19 /**
  20   Sets the current SKU in the PCD database to the value specified by SkuId.  SkuId is returned.
  21
  22   @param[in]  SkuId The SKU value that will be used when the PCD service will retrieve and
  23               set values associated with a PCD token.
  24
  25   @retval SKU_ID Return the SKU ID that just be set.
  26
  27 **/
  28 UINTN
  29 EFIAPI
  30 LibPcdSetSku (
  31   IN UINTN  SkuId
  32   )
  33 {
  34   return SkuId;
  35 }
  36
  37
  38
  39 /**
  40   Returns the 8-bit value for the token specified by TokenNumber.
  41
  42   @param[in]  The PCD token number to retrieve a current value for.
  43
  44   @retval UINT8 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   return 0;
  54 }
  55
  56
  57
  58 /**
  59   Returns the 16-bit value for the token specified by TokenNumber.
  60
  61   @param[in]  The PCD token number to retrieve a current value for.
  62
  63   @retval UINT16 Returns the 16-bit value for the token specified by TokenNumber.
  64
  65 **/
  66 UINT16
  67 EFIAPI
  68 LibPcdGet16 (
  69   IN UINTN             TokenNumber
  70   )
  71 {
  72   return 0;
  73 }
  74
  75
  76
  77 /**
  78   Returns the 32-bit value for the token specified by TokenNumber.
  79
  80   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
  81
  82   @retval UINT32 Returns the 32-bit value for the token specified by TokenNumber.
  83
  84 **/
  85 UINT32
  86 EFIAPI
  87 LibPcdGet32 (
  88   IN UINTN             TokenNumber
  89   )
  90 {
  91   return 0;
  92 }
  93
  94
  95
  96 /**
  97   Returns the 64-bit value for the token specified by TokenNumber.
  98
  99   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 100
 101   @retval UINT64 Returns the 64-bit value for the token specified by TokenNumber.
 102
 103 **/
 104 UINT64
 105 EFIAPI
 106 LibPcdGet64 (
 107   IN UINTN             TokenNumber
 108   )
 109 {
 110   return 0;
 111 }
 112
 113
 114
 115 /**
 116   Returns the pointer to the buffer of the token specified by TokenNumber.
 117
 118   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 119
 120   @retval VOID* Returns the pointer to the token specified by TokenNumber.
 121
 122 **/
 123 VOID *
 124 EFIAPI
 125 LibPcdGetPtr (
 126   IN UINTN             TokenNumber
 127   )
 128 {
 129   return 0;
 130 }
 131
 132
 133
 134 /**
 135   Returns the Boolean value of the token specified by TokenNumber.
 136
 137   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 138
 139   @retval BOOLEAN Returns the Boolean value of the token specified by TokenNumber.
 140
 141 **/
 142 BOOLEAN
 143 EFIAPI
 144 LibPcdGetBool (
 145   IN UINTN             TokenNumber
 146   )
 147 {
 148   return 0;
 149 }
 150
 151
 152
 153 /**
 154   Returns the size of the token specified by TokenNumber.
 155
 156   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 157
 158   @retval UINTN Returns the size of the token specified by TokenNumber.
 159
 160 **/
 161 UINTN
 162 EFIAPI
 163 LibPcdGetSize (
 164   IN UINTN             TokenNumber
 165   )
 166 {
 167   return 0;
 168 }
 169
 170
 171
 172 /**
 173   Returns the 8-bit value for the token specified by TokenNumber and Guid.
 174   If Guid is NULL, then ASSERT().
 175
 176   @param[in]  Guid Pointer to a 128-bit unique value that designates
 177               which namespace to retrieve a value from.
 178   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 179
 180   @retval UINT8 Return the UINT8.
 181
 182 **/
 183 UINT8
 184 EFIAPI
 185 LibPcdGetEx8 (
 186   IN CONST GUID        *Guid,
 187   IN UINTN             TokenNumber
 188   )
 189 {
 190   ASSERT (Guid != NULL);
 191
 192   return 0;
 193 }
 194
 195
 196
 197 /**
 198   Returns the 16-bit value for the token specified by TokenNumber and Guid.
 199   If Guid is NULL, then ASSERT().
 200
 201   @param[in]  Guid Pointer to a 128-bit unique value that designates
 202               which namespace to retrieve a value from.
 203   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 204
 205   @retval UINT16 Return the UINT16.
 206
 207 **/
 208 UINT16
 209 EFIAPI
 210 LibPcdGetEx16 (
 211   IN CONST GUID        *Guid,
 212   IN UINTN             TokenNumber
 213   )
 214 {
 215   ASSERT (Guid != NULL);
 216
 217   return 0;
 218 }
 219
 220
 221
 222 /**
 223   Returns the 32-bit value for the token specified by TokenNumber and Guid.
 224   If Guid is NULL, then ASSERT().
 225
 226   @param[in]  Guid Pointer to a 128-bit unique value that designates
 227               which namespace to retrieve a value from.
 228   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 229
 230   @retval UINT32 Return the UINT32.
 231
 232 **/
 233 UINT32
 234 EFIAPI
 235 LibPcdGetEx32 (
 236   IN CONST GUID        *Guid,
 237   IN UINTN             TokenNumber
 238   )
 239 {
 240   ASSERT (Guid != NULL);
 241
 242   return 0;
 243 }
 244
 245
 246
 247 /**
 248   Returns the 64-bit value for the token specified by TokenNumber and Guid.
 249   If Guid is NULL, then ASSERT().
 250
 251   @param[in]  Guid Pointer to a 128-bit unique value that designates
 252               which namespace to retrieve a value from.
 253   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 254
 255   @retval UINT64 Return the UINT64.
 256
 257 **/
 258 UINT64
 259 EFIAPI
 260 LibPcdGetEx64 (
 261   IN CONST GUID        *Guid,
 262   IN UINTN             TokenNumber
 263   )
 264 {
 265   ASSERT (Guid != NULL);
 266
 267   return 0;
 268 }
 269
 270
 271
 272 /**
 273   Returns the pointer to the buffer of the token specified by TokenNumber and Guid.
 274   If Guid is NULL, then ASSERT().
 275
 276   @param[in]  Guid Pointer to a 128-bit unique value that designates
 277               which namespace to retrieve a value from.
 278   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 279
 280   @retval VOID* Return the VOID* pointer.
 281
 282 **/
 283 VOID *
 284 EFIAPI
 285 LibPcdGetExPtr (
 286   IN CONST GUID        *Guid,
 287   IN UINTN             TokenNumber
 288   )
 289 {
 290   ASSERT (Guid != NULL);
 291
 292   return 0;
 293 }
 294
 295
 296
 297 /**
 298   Returns the Boolean value of the token specified by TokenNumber and Guid.
 299   If Guid is NULL, then ASSERT().
 300
 301   @param[in]  Guid Pointer to a 128-bit unique value that designates
 302               which namespace to retrieve a value from.
 303   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 304
 305   @retval BOOLEAN Return the BOOLEAN.
 306
 307 **/
 308 BOOLEAN
 309 EFIAPI
 310 LibPcdGetExBool (
 311   IN CONST GUID        *Guid,
 312   IN UINTN             TokenNumber
 313   )
 314 {
 315   ASSERT (Guid != NULL);
 316
 317   return 0;
 318 }
 319
 320
 321
 322 /**
 323   Returns the size of the token specified by TokenNumber and Guid.
 324   If Guid is NULL, then ASSERT().
 325
 326   @param[in]  Guid Pointer to a 128-bit unique value that designates
 327               which namespace to retrieve a value from.
 328   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 329
 330   @retval UINTN Return the size.
 331
 332 **/
 333 UINTN
 334 EFIAPI
 335 LibPcdGetExSize (
 336   IN CONST GUID        *Guid,
 337   IN UINTN             TokenNumber
 338   )
 339 {
 340   ASSERT (Guid != NULL);
 341
 342   return 0;
 343 }
 344
 345
 346
 347 /**
 348   Sets the 8-bit value for the token specified by TokenNumber
 349   to the value specified by Value.  Value is returned.
 350
 351   @param[in]  TokenNumber The PCD token number to set a current value for.
 352   @param[in]  Value The 8-bit value to set.
 353
 354   @retval UINT8 Return the value been set.
 355
 356 **/
 357 UINT8
 358 EFIAPI
 359 LibPcdSet8 (
 360   IN UINTN             TokenNumber,
 361   IN UINT8             Value
 362   )
 363 {
 364   return Value;
 365 }
 366
 367
 368
 369 /**
 370   Sets the 16-bit value for the token specified by TokenNumber
 371   to the value specified by Value.  Value is returned.
 372
 373   @param[in]  TokenNumber The PCD token number to set a current value for.
 374   @param[in]  Value The 16-bit value to set.
 375
 376   @retval UINT16 Return the value been set.
 377
 378 **/
 379 UINT16
 380 EFIAPI
 381 LibPcdSet16 (
 382   IN UINTN             TokenNumber,
 383   IN UINT16            Value
 384   )
 385 {
 386   return Value;
 387 }
 388
 389
 390
 391 /**
 392   Sets the 32-bit value for the token specified by TokenNumber
 393   to the value specified by Value.  Value is returned.
 394
 395   @param[in]  TokenNumber The PCD token number to set a current value for.
 396   @param[in]  Value The 32-bit value to set.
 397
 398   @retval UINT32 Return the value been set.
 399
 400 **/
 401 UINT32
 402 EFIAPI
 403 LibPcdSet32 (
 404   IN UINTN              TokenNumber,
 405   IN UINT32             Value
 406   )
 407 {
 408   return Value;
 409 }
 410
 411
 412
 413 /**
 414   Sets the 64-bit value for the token specified by TokenNumber
 415   to the value specified by Value.  Value is returned.
 416
 417   @param[in]  TokenNumber The PCD token number to set a current value for.
 418   @param[in]  Value The 64-bit value to set.
 419
 420   @retval UINT64 Return the value been set.
 421
 422 **/
 423 UINT64
 424 EFIAPI
 425 LibPcdSet64 (
 426   IN UINTN              TokenNumber,
 427   IN UINT64             Value
 428   )
 429 {
 430   return Value;
 431 }
 432
 433
 434
 435 /**
 436   Sets a buffer for the token specified by TokenNumber to
 437   the value specified by Buffer and SizeOfValue.  Buffer to
 438   be set is returned. The content of the buffer could be
 439   overwritten if a Callback on SET is registered with this
 440   TokenNumber.
 441
 442   If SizeOfValue is greater than the maximum
 443   size support by TokenNumber, then set SizeOfValue to the
 444   maximum size supported by TokenNumber and return NULL to
 445   indicate that the set operation was not actually performed.
 446
 447   If SizeOfValue > 0 and Buffer is NULL, then ASSERT().
 448
 449   @param[in]  TokenNumber The PCD token number to set a current value for.
 450   @param[in,out] SizeOfBuffer The size, in bytes, of Buffer.
 451   @param[in]  Value A pointer to the buffer to set.
 452
 453   @retval VOID* Return the pointer for the buffer been set.
 454
 455 **/
 456 VOID *
 457 EFIAPI
 458 LibPcdSetPtr (
 459   IN      UINTN             TokenNumber,
 460   IN OUT  UINTN             *SizeOfBuffer,
 461   IN      VOID              *Buffer
 462   )
 463 {
 464   if (*SizeOfBuffer > 0) {
 465     ASSERT (Buffer != NULL);
 466   }
 467
 468   return Buffer;
 469 }
 470
 471
 472
 473 /**
 474   Sets the Boolean value for the token specified by TokenNumber
 475   to the value specified by Value.  Value is returned.
 476
 477   @param[in]  TokenNumber The PCD token number to set a current value for.
 478   @param[in]  Value The boolean value to set.
 479
 480   @retval BOOLEAN Return the value been set.
 481
 482 **/
 483 BOOLEAN
 484 EFIAPI
 485 LibPcdSetBool (
 486   IN UINTN             TokenNumber,
 487   IN BOOLEAN           Value
 488   )
 489 {
 490   return Value;
 491 }
 492
 493
 494
 495 /**
 496   Sets the 8-bit value for the token specified by TokenNumber and
 497   Guid to the value specified by Value. Value is returned.
 498   If Guid is NULL, then ASSERT().
 499
 500   @param[in]  Guid Pointer to a 128-bit unique value that
 501               designates which namespace to set a value from.
 502   @param[in]  TokenNumber The PCD token number to set a current value for.
 503   @param[in]  Value The 8-bit value to set.
 504
 505   @retval UINT8 Return the value been set.
 506
 507 **/
 508 UINT8
 509 EFIAPI
 510 LibPcdSetEx8 (
 511   IN CONST GUID        *Guid,
 512   IN UINTN             TokenNumber,
 513   IN UINT8             Value
 514   )
 515 {
 516   ASSERT (Guid != NULL);
 517
 518   return Value;
 519 }
 520
 521
 522
 523 /**
 524   Sets the 16-bit value for the token specified by TokenNumber and
 525   Guid to the value specified by Value. Value is returned.
 526   If Guid is NULL, then ASSERT().
 527
 528   @param[in]  Guid Pointer to a 128-bit unique value that
 529               designates which namespace to set a value from.
 530   @param[in]  TokenNumber The PCD token number to set a current value for.
 531   @param[in]  Value The 16-bit value to set.
 532
 533   @retval UINT8 Return the value been set.
 534
 535 **/
 536 UINT16
 537 EFIAPI
 538 LibPcdSetEx16 (
 539   IN CONST GUID        *Guid,
 540   IN UINTN             TokenNumber,
 541   IN UINT16            Value
 542   )
 543 {
 544   ASSERT (Guid != NULL);
 545
 546   return Value;
 547 }
 548
 549
 550
 551 /**
 552   Sets the 32-bit value for the token specified by TokenNumber and
 553   Guid to the value specified by Value. Value is returned.
 554   If Guid is NULL, then ASSERT().
 555
 556   @param[in]  Guid Pointer to a 128-bit unique value that
 557               designates which namespace to set a value from.
 558   @param[in]  TokenNumber The PCD token number to set a current value for.
 559   @param[in]  Value The 32-bit value to set.
 560
 561   @retval UINT32 Return the value been set.
 562
 563 **/
 564 UINT32
 565 EFIAPI
 566 LibPcdSetEx32 (
 567   IN CONST GUID        *Guid,
 568   IN UINTN             TokenNumber,
 569   IN UINT32            Value
 570   )
 571 {
 572   ASSERT (Guid != NULL);
 573
 574   return Value;
 575 }
 576
 577
 578
 579 /**
 580   Sets the 64-bit value for the token specified by TokenNumber and
 581   Guid to the value specified by Value. Value is returned.
 582   If Guid is NULL, then ASSERT().
 583
 584   @param[in]  Guid Pointer to a 128-bit unique value that
 585               designates which namespace to set a value from.
 586   @param[in]  TokenNumber The PCD token number to set a current value for.
 587   @param[in]  Value The 64-bit value to set.
 588
 589   @retval UINT64 Return the value been set.
 590
 591 **/
 592 UINT64
 593 EFIAPI
 594 LibPcdSetEx64 (
 595   IN CONST GUID        *Guid,
 596   IN UINTN             TokenNumber,
 597   IN UINT64            Value
 598   )
 599 {
 600   ASSERT (Guid != NULL);
 601
 602   return Value;
 603 }
 604
 605
 606
 607 /**
 608   Sets a buffer for the token specified by TokenNumber to the value specified by
 609   Buffer and SizeOfValue.  Buffer is returned.  If SizeOfValue is greater than
 610   the maximum size support by TokenNumber, then set SizeOfValue to the maximum size
 611   supported by TokenNumber and return NULL to indicate that the set operation
 612   was not actually performed.
 613
 614   If SizeOfValue > 0 and Buffer is NULL, then ASSERT().
 615
 616   @param[in]  Guid Pointer to a 128-bit unique value that
 617               designates which namespace to set a value from.
 618   @param[in]  TokenNumber The PCD token number to set a current value for.
 619   @param[in, out] SizeOfBuffer The size, in bytes, of Buffer.
 620   @param[in]  Buffer A pointer to the buffer to set.
 621
 622   @retval VOID * Return the pinter to the buffer been set.
 623
 624 **/
 625 VOID *
 626 EFIAPI
 627 LibPcdSetExPtr (
 628   IN      CONST GUID        *Guid,
 629   IN      UINTN             TokenNumber,
 630   IN OUT  UINTN             *SizeOfBuffer,
 631   IN      VOID              *Buffer
 632   )
 633 {
 634   ASSERT (Guid != NULL);
 635
 636   if (*SizeOfBuffer > 0) {
 637     ASSERT (Buffer != NULL);
 638   }
 639
 640   return Buffer;
 641 }
 642
 643
 644
 645 /**
 646   Sets the Boolean value for the token specified by TokenNumber and
 647   Guid to the value specified by Value. Value is returned.
 648   If Guid is NULL, then ASSERT().
 649
 650   @param[in]  Guid Pointer to a 128-bit unique value that
 651               designates which namespace to set a value from.
 652   @param[in]  TokenNumber The PCD token number to set a current value for.
 653   @param[in]  Value The Boolean value to set.
 654
 655   @retval Boolean Return the value been set.
 656
 657 **/
 658 BOOLEAN
 659 EFIAPI
 660 LibPcdSetExBool (
 661   IN CONST GUID        *Guid,
 662   IN UINTN             TokenNumber,
 663   IN BOOLEAN           Value
 664   )
 665 {
 666   ASSERT (Guid != NULL);
 667
 668   return Value;
 669 }
 670
 671
 672
 673 /**
 674   When the token specified by TokenNumber and Guid is set,
 675   then notification function specified by NotificationFunction is called.
 676   If Guid is NULL, then the default token space is used.
 677   If NotificationFunction is NULL, then ASSERT().
 678
 679   @param[in]  Guid Pointer to a 128-bit unique value that designates which
 680               namespace to set a value from.  If NULL, then the default
 681               token space is used.
 682   @param[in]  TokenNumber The PCD token number to monitor.
 683   @param[in]  NotificationFunction The function to call when the token
 684               specified by Guid and TokenNumber is set.
 685
 686   @retval VOID
 687
 688 **/
 689 VOID
 690 EFIAPI
 691 LibPcdCallbackOnSet (
 692   IN CONST GUID               *Guid,       OPTIONAL
 693   IN UINTN                    TokenNumber,
 694   IN PCD_CALLBACK             NotificationFunction
 695   )
 696 {
 697   ASSERT (NotificationFunction != NULL);
 698 }
 699
 700
 701
 702 /**
 703   Disable a notification function that was established with LibPcdCallbackonSet().
 704   If NotificationFunction is NULL, then ASSERT().
 705
 706   @param[in]  Guid Specify the GUID token space.
 707   @param[in]  TokenNumber Specify the token number.
 708   @param[in]  NotificationFunction The callback function to be unregistered.
 709
 710   @retval VOID
 711
 712 **/
 713 VOID
 714 EFIAPI
 715 LibPcdCancelCallback (
 716   IN CONST GUID               *Guid,       OPTIONAL
 717   IN UINTN                    TokenNumber,
 718   IN PCD_CALLBACK             NotificationFunction
 719   )
 720 {
 721   ASSERT (NotificationFunction != NULL);
 722 }
 723
 724
 725
 726 /**
 727   Retrieves the next PCD token number from the token space specified by Guid.
 728   If Guid is NULL, then the default token space is used.  If TokenNumber is 0,
 729   then the first token number is returned.  Otherwise, the token number that
 730   follows TokenNumber in the token space is returned.  If TokenNumber is the last
 731   token number in the token space, then 0 is returned.  If TokenNumber is not 0 and
 732   is not in the token space specified by Guid, then ASSERT().
 733
 734   @param[in]  Pointer to a 128-bit unique value that designates which namespace
 735               to set a value from.  If NULL, then the default token space is used.
 736   @param[in]  The previous PCD token number.  If 0, then retrieves the first PCD
 737               token number.
 738
 739   @retval UINTN            The next valid token number.
 740
 741 **/
 742 UINTN
 743 EFIAPI
 744 LibPcdGetNextToken (
 745   IN CONST GUID               *Guid, OPTIONAL
 746   IN       UINTN              TokenNumber
 747   )
 748 {
 749   return 0;
 750 }
 751
 752
 753
 754 /**
 755   Retrieves the next PCD token space from a token space specified by Guid.
 756   Guid of NULL is reserved to mark the default local token namespace on the current
 757   platform. If Guid is NULL, then the GUID of the first non-local token space of the
 758   current platform is returned. If Guid is the last non-local token space,
 759   then NULL is returned.
 760
 761   If Guid is not NULL and is not a valid token space in the current platform, then ASSERT().
 762
 763
 764
 765   @param[in]  Pointer to a 128-bit unique value that designates from which namespace
 766               to start the search.
 767
 768   @retval CONST GUID *  The next valid token namespace.
 769
 770 **/
 771 CONST GUID*
 772 EFIAPI
 773 LibPcdGetNextTokenSpace (
 774   IN CONST GUID  *Guid
 775   )
 776 {
 777   return NULL;
 778 }