MdePkg/Include/Library/PcdLib.h

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