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   ASSERT (Buffer != NULL);
 465
 466   return Buffer;
 467 }
 468
 469
 470
 471 /**
 472   Sets the Boolean 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 boolean value to set.
 477
 478   @retval BOOLEAN Return the value been set.
 479
 480 **/
 481 BOOLEAN
 482 EFIAPI
 483 LibPcdSetBool (
 484   IN UINTN             TokenNumber,
 485   IN BOOLEAN           Value
 486   )
 487 {
 488   return Value;
 489 }
 490
 491
 492
 493 /**
 494   Sets the 8-bit value for the token specified by TokenNumber and
 495   Guid to the value specified by Value. Value is returned.
 496   If Guid is NULL, then ASSERT().
 497
 498   @param[in]  Guid Pointer to a 128-bit unique value that
 499               designates which namespace to set a value from.
 500   @param[in]  TokenNumber The PCD token number to set a current value for.
 501   @param[in]  Value The 8-bit value to set.
 502
 503   @retval UINT8 Return the value been set.
 504
 505 **/
 506 UINT8
 507 EFIAPI
 508 LibPcdSetEx8 (
 509   IN CONST GUID        *Guid,
 510   IN UINTN             TokenNumber,
 511   IN UINT8             Value
 512   )
 513 {
 514   ASSERT (Guid != NULL);
 515
 516   return Value;
 517 }
 518
 519
 520
 521 /**
 522   Sets the 16-bit value for the token specified by TokenNumber and
 523   Guid to the value specified by Value. Value is returned.
 524   If Guid is NULL, then ASSERT().
 525
 526   @param[in]  Guid Pointer to a 128-bit unique value that
 527               designates which namespace to set a value from.
 528   @param[in]  TokenNumber The PCD token number to set a current value for.
 529   @param[in]  Value The 16-bit value to set.
 530
 531   @retval UINT8 Return the value been set.
 532
 533 **/
 534 UINT16
 535 EFIAPI
 536 LibPcdSetEx16 (
 537   IN CONST GUID        *Guid,
 538   IN UINTN             TokenNumber,
 539   IN UINT16            Value
 540   )
 541 {
 542   ASSERT (Guid != NULL);
 543
 544   return Value;
 545 }
 546
 547
 548
 549 /**
 550   Sets the 32-bit value for the token specified by TokenNumber and
 551   Guid to the value specified by Value. Value is returned.
 552   If Guid is NULL, then ASSERT().
 553
 554   @param[in]  Guid Pointer to a 128-bit unique value that
 555               designates which namespace to set a value from.
 556   @param[in]  TokenNumber The PCD token number to set a current value for.
 557   @param[in]  Value The 32-bit value to set.
 558
 559   @retval UINT32 Return the value been set.
 560
 561 **/
 562 UINT32
 563 EFIAPI
 564 LibPcdSetEx32 (
 565   IN CONST GUID        *Guid,
 566   IN UINTN             TokenNumber,
 567   IN UINT32            Value
 568   )
 569 {
 570   ASSERT (Guid != NULL);
 571
 572   return Value;
 573 }
 574
 575
 576
 577 /**
 578   Sets the 64-bit value for the token specified by TokenNumber and
 579   Guid to the value specified by Value. Value is returned.
 580   If Guid is NULL, then ASSERT().
 581
 582   @param[in]  Guid 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 64-bit value to set.
 586
 587   @retval UINT64 Return the value been set.
 588
 589 **/
 590 UINT64
 591 EFIAPI
 592 LibPcdSetEx64 (
 593   IN CONST GUID        *Guid,
 594   IN UINTN             TokenNumber,
 595   IN UINT64            Value
 596   )
 597 {
 598   ASSERT (Guid != NULL);
 599
 600   return Value;
 601 }
 602
 603
 604
 605 /**
 606   Sets a buffer for the token specified by TokenNumber to the value specified by
 607   Buffer and SizeOfValue.  Buffer is returned.  If SizeOfValue is greater than
 608   the maximum size support by TokenNumber, then set SizeOfValue to the maximum size
 609   supported by TokenNumber and return NULL to indicate that the set operation
 610   was not actually performed.
 611
 612   If SizeOfValue > 0 and Buffer is NULL, then ASSERT().
 613
 614   @param[in]  Guid Pointer to a 128-bit unique value that
 615               designates which namespace to set a value from.
 616   @param[in]  TokenNumber The PCD token number to set a current value for.
 617   @param[in, out] SizeOfBuffer The size, in bytes, of Buffer.
 618   @param[in]  Buffer A pointer to the buffer to set.
 619
 620   @retval VOID * Return the pinter to the buffer been set.
 621
 622 **/
 623 VOID *
 624 EFIAPI
 625 LibPcdSetExPtr (
 626   IN      CONST GUID        *Guid,
 627   IN      UINTN             TokenNumber,
 628   IN OUT  UINTN             *SizeOfBuffer,
 629   IN      VOID              *Buffer
 630   )
 631 {
 632   ASSERT (Guid != NULL);
 633   ASSERT (Buffer != NULL);
 634
 635   return Buffer;
 636 }
 637
 638
 639
 640 /**
 641   Sets the Boolean value for the token specified by TokenNumber and
 642   Guid to the value specified by Value. Value is returned.
 643   If Guid 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]  Value The Boolean value to set.
 649
 650   @retval Boolean Return the value been set.
 651
 652 **/
 653 BOOLEAN
 654 EFIAPI
 655 LibPcdSetExBool (
 656   IN CONST GUID        *Guid,
 657   IN UINTN             TokenNumber,
 658   IN BOOLEAN           Value
 659   )
 660 {
 661   ASSERT (Guid != NULL);
 662
 663   return Value;
 664 }
 665
 666
 667
 668 /**
 669   When the token specified by TokenNumber and Guid is set,
 670   then notification function specified by NotificationFunction is called.
 671   If Guid is NULL, then the default token space is used.
 672   If NotificationFunction is NULL, then ASSERT().
 673
 674   @param[in]  Guid Pointer to a 128-bit unique value that designates which
 675               namespace to set a value from.  If NULL, then the default
 676               token space is used.
 677   @param[in]  TokenNumber The PCD token number to monitor.
 678   @param[in]  NotificationFunction The function to call when the token
 679               specified by Guid and TokenNumber is set.
 680
 681   @retval VOID
 682
 683 **/
 684 VOID
 685 EFIAPI
 686 LibPcdCallbackOnSet (
 687   IN CONST GUID               *Guid,       OPTIONAL
 688   IN UINTN                    TokenNumber,
 689   IN PCD_CALLBACK             NotificationFunction
 690   )
 691 {
 692   ASSERT (NotificationFunction != NULL);
 693 }
 694
 695
 696
 697 /**
 698   Disable a notification function that was established with LibPcdCallbackonSet().
 699   If NotificationFunction is NULL, then ASSERT().
 700
 701   @param[in]  Guid Specify the GUID token space.
 702   @param[in]  TokenNumber Specify the token number.
 703   @param[in]  NotificationFunction The callback function to be unregistered.
 704
 705   @retval VOID
 706
 707 **/
 708 VOID
 709 EFIAPI
 710 LibPcdCancelCallback (
 711   IN CONST GUID               *Guid,       OPTIONAL
 712   IN UINTN                    TokenNumber,
 713   IN PCD_CALLBACK             NotificationFunction
 714   )
 715 {
 716   ASSERT (NotificationFunction != NULL);
 717 }
 718
 719
 720
 721 /**
 722   Retrieves the next PCD token number from the token space specified by Guid.
 723   If Guid is NULL, then the default token space is used.  If TokenNumber is 0,
 724   then the first token number is returned.  Otherwise, the token number that
 725   follows TokenNumber in the token space is returned.  If TokenNumber is the last
 726   token number in the token space, then 0 is returned.  If TokenNumber is not 0 and
 727   is not in the token space specified by Guid, then ASSERT().
 728
 729   @param[in]  Pointer to a 128-bit unique value that designates which namespace
 730               to set a value from.  If NULL, then the default token space is used.
 731   @param[in]  The previous PCD token number.  If 0, then retrieves the first PCD
 732               token number.
 733
 734   @retval UINTN            The next valid token number.
 735
 736 **/
 737 UINTN
 738 EFIAPI
 739 LibPcdGetNextToken (
 740   IN CONST GUID               *Guid, OPTIONAL
 741   IN       UINTN              TokenNumber
 742   )
 743 {
 744   return 0;
 745 }
 746
 747
 748
 749 /**
 750   Retrieves the next PCD token space from a token space specified by Guid.
 751   Guid of NULL is reserved to mark the default local token namespace on the current
 752   platform. If Guid is NULL, then the GUID of the first non-local token space of the
 753   current platform is returned. If Guid is the last non-local token space,
 754   then NULL is returned.
 755
 756   If Guid is not NULL and is not a valid token space in the current platform, then ASSERT().
 757
 758
 759
 760   @param[in]  Pointer to a 128-bit unique value that designates from which namespace
 761               to start the search.
 762
 763   @retval CONST GUID *  The next valid token namespace.
 764
 765 **/
 766 CONST GUID*
 767 EFIAPI
 768 LibPcdGetNextTokenSpace (
 769   IN CONST GUID  *Guid
 770   )
 771 {
 772   return NULL;
 773 }