MdePkg/Library/DxePcdLib/DxePcdLib.c

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