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   if (*SizeOfBuffer > 0) {
 518     ASSERT (Buffer != NULL);
 519   }
 520
 521   Size = LibPcdGetSize (TokenNumber);
 522
 523   if (*SizeOfBuffer > Size) {
 524     *SizeOfBuffer = Size;
 525     return NULL;
 526   }
 527
 528   Status = mPcd->SetPtr (TokenNumber, *SizeOfBuffer, Buffer);
 529
 530   ASSERT_EFI_ERROR (Status);
 531
 532   return Buffer;
 533 }
 534
 535
 536
 537 /**
 538   Sets the Boolean value for the token specified by TokenNumber
 539   to the value specified by Value.  Value is returned.
 540
 541   @param[in]  TokenNumber The PCD token number to set a current value for.
 542   @param[in]  Value The boolean value to set.
 543
 544   @retval BOOLEAN Return the value been set.
 545
 546 **/
 547 BOOLEAN
 548 EFIAPI
 549 LibPcdSetBool (
 550   IN UINTN             TokenNumber,
 551   IN BOOLEAN           Value
 552   )
 553 {
 554   EFI_STATUS Status;
 555
 556   Status = mPcd->SetBool (TokenNumber, Value);
 557
 558   ASSERT_EFI_ERROR (Status);
 559
 560   return Value;
 561 }
 562
 563
 564
 565 /**
 566   Sets the 8-bit value for the token specified by TokenNumber and
 567   Guid to the value specified by Value. Value is returned.
 568   If Guid is NULL, then ASSERT().
 569
 570   @param[in]  Guid Pointer to a 128-bit unique value that
 571               designates which namespace to set a value from.
 572   @param[in]  TokenNumber The PCD token number to set a current value for.
 573   @param[in]  Value The 8-bit value to set.
 574
 575   @retval UINT8 Return the value been set.
 576
 577 **/
 578 UINT8
 579 EFIAPI
 580 LibPcdSetEx8 (
 581   IN CONST GUID        *Guid,
 582   IN UINTN             TokenNumber,
 583   IN UINT8             Value
 584   )
 585 {
 586   EFI_STATUS Status;
 587
 588   ASSERT (Guid != NULL);
 589
 590   Status = mPcd->Set8Ex (Guid, TokenNumber, Value);
 591
 592   ASSERT_EFI_ERROR (Status);
 593
 594   return Value;
 595 }
 596
 597
 598
 599 /**
 600   Sets the 16-bit value for the token specified by TokenNumber and
 601   Guid to the value specified by Value. Value is returned.
 602   If Guid is NULL, then ASSERT().
 603
 604   @param[in]  Guid Pointer to a 128-bit unique value that
 605               designates which namespace to set a value from.
 606   @param[in]  TokenNumber The PCD token number to set a current value for.
 607   @param[in]  Value The 16-bit value to set.
 608
 609   @retval UINT8 Return the value been set.
 610
 611 **/
 612 UINT16
 613 EFIAPI
 614 LibPcdSetEx16 (
 615   IN CONST GUID        *Guid,
 616   IN UINTN             TokenNumber,
 617   IN UINT16            Value
 618   )
 619 {
 620   EFI_STATUS Status;
 621
 622   ASSERT (Guid != NULL);
 623
 624   Status = mPcd->Set16Ex (Guid, TokenNumber, Value);
 625
 626   ASSERT_EFI_ERROR (Status);
 627
 628   return Value;
 629 }
 630
 631
 632
 633 /**
 634   Sets the 32-bit value for the token specified by TokenNumber and
 635   Guid to the value specified by Value. Value is returned.
 636   If Guid is NULL, then ASSERT().
 637
 638   @param[in]  Guid Pointer to a 128-bit unique value that
 639               designates which namespace to set a value from.
 640   @param[in]  TokenNumber The PCD token number to set a current value for.
 641   @param[in]  Value The 32-bit value to set.
 642
 643   @retval UINT32 Return the value been set.
 644
 645 **/
 646 UINT32
 647 EFIAPI
 648 LibPcdSetEx32 (
 649   IN CONST GUID        *Guid,
 650   IN UINTN             TokenNumber,
 651   IN UINT32             Value
 652   )
 653 {
 654   EFI_STATUS Status;
 655
 656   ASSERT (Guid != NULL);
 657
 658   Status = mPcd->Set32Ex (Guid, TokenNumber, Value);
 659
 660   ASSERT_EFI_ERROR (Status);
 661
 662   return Value;
 663 }
 664
 665
 666
 667 /**
 668   Sets the 64-bit value for the token specified by TokenNumber and
 669   Guid to the value specified by Value. Value is returned.
 670   If Guid is NULL, then ASSERT().
 671
 672   @param[in]  Guid Pointer to a 128-bit unique value that
 673               designates which namespace to set a value from.
 674   @param[in]  TokenNumber The PCD token number to set a current value for.
 675   @param[in]  Value The 64-bit value to set.
 676
 677   @retval UINT64 Return the value been set.
 678
 679 **/
 680 UINT64
 681 EFIAPI
 682 LibPcdSetEx64 (
 683   IN CONST GUID        *Guid,
 684   IN UINTN             TokenNumber,
 685   IN UINT64             Value
 686   )
 687 {
 688   EFI_STATUS Status;
 689
 690   ASSERT (Guid != NULL);
 691
 692   Status = mPcd->Set64Ex (Guid, TokenNumber, Value);
 693
 694   ASSERT_EFI_ERROR (Status);
 695
 696   return Value;
 697 }
 698
 699
 700
 701 /**
 702   Sets a buffer for the token specified by TokenNumber to the value specified by
 703   Buffer and SizeOfValue.  Buffer is returned.  If SizeOfValue is greater than
 704   the maximum size support by TokenNumber, then set SizeOfValue to the maximum size
 705   supported by TokenNumber and return NULL to indicate that the set operation
 706   was not actually performed.
 707
 708   If SizeOfValue > 0 and Buffer is NULL, then ASSERT().
 709
 710   @param[in]  Guid Pointer to a 128-bit unique value that
 711               designates which namespace to set a value from.
 712   @param[in]  TokenNumber The PCD token number to set a current value for.
 713   @param[in, out] SizeOfBuffer The size, in bytes, of Buffer.
 714   @param[in]  Buffer A pointer to the buffer to set.
 715
 716   @retval VOID * Return the pinter to the buffer been set.
 717
 718 **/
 719 VOID *
 720 EFIAPI
 721 LibPcdSetExPtr (
 722   IN      CONST GUID        *Guid,
 723   IN      UINTN             TokenNumber,
 724   IN OUT  UINTN             *SizeOfBuffer,
 725   IN      VOID              *Buffer
 726   )
 727 {
 728   EFI_STATUS  Status;
 729   UINTN       Size;
 730
 731   if (*SizeOfBuffer > 0) {
 732     ASSERT (Buffer != NULL);
 733   }
 734
 735   Size = LibPcdGetExSize (Guid, TokenNumber);
 736   if (*SizeOfBuffer > Size) {
 737     *SizeOfBuffer = Size;
 738     return NULL;
 739   }
 740
 741   Status = mPcd->SetPtrEx (Guid, TokenNumber, *SizeOfBuffer, Buffer);
 742
 743   ASSERT_EFI_ERROR (Status);
 744
 745   return Buffer;
 746 }
 747
 748
 749
 750 /**
 751   Sets the Boolean value for the token specified by TokenNumber and
 752   Guid to the value specified by Value. Value is returned.
 753   If Guid is NULL, then ASSERT().
 754
 755   @param[in]  Guid Pointer to a 128-bit unique value that
 756               designates which namespace to set a value from.
 757   @param[in]  TokenNumber The PCD token number to set a current value for.
 758   @param[in]  Value The Boolean value to set.
 759
 760   @retval Boolean Return the value been set.
 761
 762 **/
 763 BOOLEAN
 764 EFIAPI
 765 LibPcdSetExBool (
 766   IN CONST GUID        *Guid,
 767   IN UINTN             TokenNumber,
 768   IN BOOLEAN           Value
 769   )
 770 {
 771   EFI_STATUS Status;
 772
 773   ASSERT (Guid != NULL);
 774
 775   Status = mPcd->SetBoolEx (Guid, TokenNumber, Value);
 776
 777   ASSERT_EFI_ERROR (Status);
 778
 779   return Value;
 780 }
 781
 782
 783
 784 /**
 785   When the token specified by TokenNumber and Guid is set,
 786   then notification function specified by NotificationFunction is called.
 787   If Guid is NULL, then the default token space is used.
 788   If NotificationFunction is NULL, then ASSERT().
 789
 790   @param[in]  Guid Pointer to a 128-bit unique value that designates which
 791               namespace to set a value from.  If NULL, then the default
 792               token space is used.
 793   @param[in]  TokenNumber The PCD token number to monitor.
 794   @param[in]  NotificationFunction The function to call when the token
 795               specified by Guid and TokenNumber is set.
 796
 797   @retval VOID
 798
 799 **/
 800 VOID
 801 EFIAPI
 802 LibPcdCallbackOnSet (
 803   IN CONST GUID               *Guid,       OPTIONAL
 804   IN UINTN                    TokenNumber,
 805   IN PCD_CALLBACK             NotificationFunction
 806   )
 807 {
 808   EFI_STATUS Status;
 809
 810   ASSERT (NotificationFunction != NULL);
 811
 812   Status = mPcd->CallbackOnSet (TokenNumber, Guid, NotificationFunction);
 813
 814   ASSERT_EFI_ERROR (Status);
 815
 816   return;
 817 }
 818
 819
 820
 821 /**
 822   Disable a notification function that was established with LibPcdCallbackonSet().
 823   If NotificationFunction is NULL, then ASSERT().
 824
 825   @param[in]  Guid Specify the GUID token space.
 826   @param[in]  TokenNumber Specify the token number.
 827   @param[in]  NotificationFunction The callback function to be unregistered.
 828
 829   @retval VOID
 830
 831 **/
 832 VOID
 833 EFIAPI
 834 LibPcdCancelCallback (
 835   IN CONST GUID               *Guid,       OPTIONAL
 836   IN UINTN                    TokenNumber,
 837   IN PCD_CALLBACK             NotificationFunction
 838   )
 839 {
 840   EFI_STATUS Status;
 841
 842   ASSERT (NotificationFunction != NULL);
 843
 844   Status = mPcd->CancelCallback (TokenNumber, Guid, NotificationFunction);
 845
 846   ASSERT_EFI_ERROR (Status);
 847
 848   return;
 849 }
 850
 851
 852
 853 /**
 854   Retrieves the next PCD token number from the token space specified by Guid.
 855   If Guid is NULL, then the default token space is used.  If TokenNumber is 0,
 856   then the first token number is returned.  Otherwise, the token number that
 857   follows TokenNumber in the token space is returned.  If TokenNumber is the last
 858   token number in the token space, then 0 is returned.  If TokenNumber is not 0 and
 859   is not in the token space specified by Guid, then ASSERT().
 860
 861   @param[in]  Pointer to a 128-bit unique value that designates which namespace
 862               to set a value from.  If NULL, then the default token space is used.
 863   @param[in]  The previous PCD token number.  If 0, then retrieves the first PCD
 864               token number.
 865
 866   @retval UINTN            The next valid token number.
 867
 868 **/
 869 UINTN
 870 EFIAPI
 871 LibPcdGetNextToken (
 872   IN CONST GUID             *Guid, OPTIONAL
 873   IN       UINTN            TokenNumber
 874   )
 875 {
 876   EFI_STATUS Status;
 877
 878   Status = mPcd->GetNextToken (Guid, &TokenNumber);
 879
 880   ASSERT_EFI_ERROR (Status);
 881
 882   return TokenNumber;
 883 }
 884
 885
 886
 887 /**
 888   Retrieves the next PCD token space from a token space specified by Guid.
 889   Guid of NULL is reserved to mark the default local token namespace on the current
 890   platform. If Guid is NULL, then the GUID of the first non-local token space of the
 891   current platform is returned. If Guid is the last non-local token space,
 892   then NULL is returned.
 893
 894   If Guid is not NULL and is not a valid token space in the current platform, then ASSERT().
 895
 896
 897
 898   @param[in]  Pointer to a 128-bit unique value that designates from which namespace
 899               to start the search.
 900
 901   @retval CONST GUID *  The next valid token namespace.
 902
 903 **/
 904 CONST GUID*
 905 EFIAPI
 906 LibPcdGetNextTokenSpace (
 907   IN CONST GUID  *Guid
 908   )
 909 {
 910   EFI_STATUS Status;
 911
 912   Status = mPcd->GetNextTokenSpace (&Guid);
 913
 914   ASSERT_EFI_ERROR (Status);
 915
 916   return Guid;
 917 }
 918