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   ASSERT (SkuId < 0x100);
  61
  62   mPcd->SetSku (SkuId);
  63
  64   return SkuId;
  65 }
  66
  67
  68
  69 /**
  70   Returns the 8-bit value for the token specified by TokenNumber.
  71
  72   @param[in]  The PCD token number to retrieve a current value for.
  73
  74   @retval UINT8 Returns the 8-bit value for the token specified by TokenNumber.
  75
  76 **/
  77 UINT8
  78 EFIAPI
  79 LibPcdGet8 (
  80   IN UINTN             TokenNumber
  81   )
  82 {
  83   return mPcd->Get8 (TokenNumber);
  84 }
  85
  86
  87
  88 /**
  89   Returns the 16-bit value for the token specified by TokenNumber.
  90
  91   @param[in]  The PCD token number to retrieve a current value for.
  92
  93   @retval UINT16 Returns the 16-bit value for the token specified by TokenNumber.
  94
  95 **/
  96 UINT16
  97 EFIAPI
  98 LibPcdGet16 (
  99   IN UINTN             TokenNumber
 100   )
 101 {
 102   return mPcd->Get16 (TokenNumber);
 103 }
 104
 105
 106
 107 /**
 108   Returns the 32-bit value for the token specified by TokenNumber.
 109
 110   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 111
 112   @retval UINT32 Returns the 32-bit value for the token specified by TokenNumber.
 113
 114 **/
 115 UINT32
 116 EFIAPI
 117 LibPcdGet32 (
 118   IN UINTN             TokenNumber
 119   )
 120 {
 121   return mPcd->Get32 (TokenNumber);
 122 }
 123
 124
 125
 126 /**
 127   Returns the 64-bit value for the token specified by TokenNumber.
 128
 129   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 130
 131   @retval UINT64 Returns the 64-bit value for the token specified by TokenNumber.
 132
 133 **/
 134 UINT64
 135 EFIAPI
 136 LibPcdGet64 (
 137   IN UINTN             TokenNumber
 138   )
 139 {
 140   return mPcd->Get64 (TokenNumber);
 141 }
 142
 143
 144
 145 /**
 146   Returns the pointer to the buffer of the token specified by TokenNumber.
 147
 148   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 149
 150   @retval VOID* Returns the pointer to the token specified by TokenNumber.
 151
 152 **/
 153 VOID *
 154 EFIAPI
 155 LibPcdGetPtr (
 156   IN UINTN             TokenNumber
 157   )
 158 {
 159   return mPcd->GetPtr (TokenNumber);
 160 }
 161
 162
 163
 164 /**
 165   Returns the Boolean value of the token specified by TokenNumber.
 166
 167   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 168
 169   @retval BOOLEAN Returns the Boolean value of the token specified by TokenNumber.
 170
 171 **/
 172 BOOLEAN
 173 EFIAPI
 174 LibPcdGetBool (
 175   IN UINTN             TokenNumber
 176   )
 177 {
 178   return mPcd->GetBool (TokenNumber);
 179 }
 180
 181
 182
 183 /**
 184   Returns the size of the token specified by TokenNumber.
 185
 186   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 187
 188   @retval UINTN Returns the size of the token specified by TokenNumber.
 189
 190 **/
 191 UINTN
 192 EFIAPI
 193 LibPcdGetSize (
 194   IN UINTN             TokenNumber
 195   )
 196 {
 197   return mPcd->GetSize (TokenNumber);
 198 }
 199
 200
 201
 202 /**
 203   Returns the 8-bit value for the token specified by TokenNumber and Guid.
 204   If Guid is NULL, then ASSERT().
 205
 206   @param[in]  Guid Pointer to a 128-bit unique value that designates
 207               which namespace to retrieve a value from.
 208   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 209
 210   @retval UINT8 Return the UINT8.
 211
 212 **/
 213 UINT8
 214 EFIAPI
 215 LibPcdGetEx8 (
 216   IN CONST GUID        *Guid,
 217   IN UINTN             TokenNumber
 218   )
 219 {
 220   ASSERT (Guid != NULL);
 221
 222   return mPcd->Get8Ex (Guid, TokenNumber);
 223 }
 224
 225
 226 /**
 227   Returns the 16-bit value for the token specified by TokenNumber and Guid.
 228   If Guid is NULL, then ASSERT().
 229
 230   @param[in]  Guid Pointer to a 128-bit unique value that designates
 231               which namespace to retrieve a value from.
 232   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 233
 234   @retval UINT16 Return the UINT16.
 235
 236 **/
 237 UINT16
 238 EFIAPI
 239 LibPcdGetEx16 (
 240   IN CONST GUID        *Guid,
 241   IN UINTN             TokenNumber
 242   )
 243 {
 244   ASSERT (Guid != NULL);
 245
 246   return mPcd->Get16Ex (Guid, TokenNumber);
 247 }
 248
 249
 250 /**
 251   Returns the 32-bit value for the token specified by TokenNumber and Guid.
 252   If Guid is NULL, then ASSERT().
 253
 254   @param[in]  Guid Pointer to a 128-bit unique value that designates
 255               which namespace to retrieve a value from.
 256   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 257
 258   @retval UINT32 Return the UINT32.
 259
 260 **/
 261 UINT32
 262 EFIAPI
 263 LibPcdGetEx32 (
 264   IN CONST GUID        *Guid,
 265   IN UINTN             TokenNumber
 266   )
 267 {
 268   ASSERT (Guid != NULL);
 269
 270   return mPcd->Get32Ex (Guid, TokenNumber);
 271 }
 272
 273
 274
 275 /**
 276   Returns the 64-bit value for the token specified by TokenNumber and Guid.
 277   If Guid is NULL, then ASSERT().
 278
 279   @param[in]  Guid Pointer to a 128-bit unique value that designates
 280               which namespace to retrieve a value from.
 281   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 282
 283   @retval UINT64 Return the UINT64.
 284
 285 **/
 286 UINT64
 287 EFIAPI
 288 LibPcdGetEx64 (
 289   IN CONST GUID        *Guid,
 290   IN UINTN             TokenNumber
 291   )
 292 {
 293   ASSERT (Guid != NULL);
 294
 295   return mPcd->Get64Ex (Guid, TokenNumber);
 296 }
 297
 298
 299
 300 /**
 301   Returns the pointer to the token specified by TokenNumber and Guid.
 302   If Guid is NULL, then ASSERT().
 303
 304   @param[in]  Guid Pointer to a 128-bit unique value that designates
 305               which namespace to retrieve a value from.
 306   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 307
 308   @retval VOID* Return the VOID* pointer.
 309
 310 **/
 311 VOID *
 312 EFIAPI
 313 LibPcdGetExPtr (
 314   IN CONST GUID        *Guid,
 315   IN UINTN             TokenNumber
 316   )
 317 {
 318   ASSERT (Guid != NULL);
 319
 320   return mPcd->GetPtrEx (Guid, TokenNumber);
 321 }
 322
 323
 324
 325 /**
 326   Returns the Boolean value of the token specified by TokenNumber and Guid.
 327   If Guid is NULL, then ASSERT().
 328
 329   @param[in]  Guid Pointer to a 128-bit unique value that designates
 330               which namespace to retrieve a value from.
 331   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 332
 333   @retval BOOLEAN Return the BOOLEAN.
 334
 335 **/
 336 BOOLEAN
 337 EFIAPI
 338 LibPcdGetExBool (
 339   IN CONST GUID        *Guid,
 340   IN UINTN             TokenNumber
 341   )
 342 {
 343   ASSERT (Guid != NULL);
 344
 345   return mPcd->GetBoolEx (Guid, TokenNumber);
 346 }
 347
 348
 349
 350 /**
 351   Returns the size of the token specified by TokenNumber and Guid.
 352   If Guid is NULL, then ASSERT().
 353
 354   @param[in]  Guid Pointer to a 128-bit unique value that designates
 355               which namespace to retrieve a value from.
 356   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 357
 358   @retval UINTN Return the size.
 359
 360 **/
 361 UINTN
 362 EFIAPI
 363 LibPcdGetExSize (
 364   IN CONST GUID        *Guid,
 365   IN UINTN             TokenNumber
 366   )
 367 {
 368   ASSERT (Guid != NULL);
 369
 370   return mPcd->GetSizeEx (Guid, TokenNumber);
 371 }
 372
 373
 374
 375 /**
 376   Sets the 8-bit value for the token specified by TokenNumber
 377   to the value specified by Value.  Value is returned.
 378
 379   @param[in]  TokenNumber The PCD token number to set a current value for.
 380   @param[in]  Value The 8-bit value to set.
 381
 382   @retval UINT8 Return the value been set.
 383
 384 **/
 385 UINT8
 386 EFIAPI
 387 LibPcdSet8 (
 388   IN UINTN             TokenNumber,
 389   IN UINT8             Value
 390   )
 391 {
 392   EFI_STATUS Status;
 393
 394   Status = mPcd->Set8 (TokenNumber, Value);
 395
 396   ASSERT_EFI_ERROR (Status);
 397
 398   return Value;
 399 }
 400
 401
 402
 403 /**
 404   Sets the 16-bit value for the token specified by TokenNumber
 405   to the value specified by Value.  Value is returned.
 406
 407   @param[in]  TokenNumber The PCD token number to set a current value for.
 408   @param[in]  Value The 16-bit value to set.
 409
 410   @retval UINT16 Return the value been set.
 411
 412 **/
 413 UINT16
 414 EFIAPI
 415 LibPcdSet16 (
 416   IN UINTN             TokenNumber,
 417   IN UINT16            Value
 418   )
 419 {
 420   EFI_STATUS Status;
 421
 422   Status = mPcd->Set16 (TokenNumber, Value);
 423
 424   ASSERT_EFI_ERROR (Status);
 425
 426   return Value;
 427 }
 428
 429
 430
 431 /**
 432   Sets the 32-bit value for the token specified by TokenNumber
 433   to the value specified by Value.  Value is returned.
 434
 435   @param[in]  TokenNumber The PCD token number to set a current value for.
 436   @param[in]  Value The 32-bit value to set.
 437
 438   @retval UINT32 Return the value been set.
 439
 440 **/
 441 UINT32
 442 EFIAPI
 443 LibPcdSet32 (
 444   IN UINTN             TokenNumber,
 445   IN UINT32             Value
 446   )
 447 {
 448   EFI_STATUS Status;
 449   Status = mPcd->Set32 (TokenNumber, Value);
 450
 451   ASSERT_EFI_ERROR (Status);
 452
 453   return Value;
 454 }
 455
 456
 457
 458 /**
 459   Sets the 64-bit value for the token specified by TokenNumber
 460   to the value specified by Value.  Value is returned.
 461
 462   @param[in]  TokenNumber The PCD token number to set a current value for.
 463   @param[in]  Value The 64-bit value to set.
 464
 465   @retval UINT64 Return the value been set.
 466
 467 **/
 468 UINT64
 469 EFIAPI
 470 LibPcdSet64 (
 471   IN UINTN             TokenNumber,
 472   IN UINT64             Value
 473   )
 474 {
 475   EFI_STATUS Status;
 476
 477   Status = mPcd->Set64 (TokenNumber, Value);
 478
 479   ASSERT_EFI_ERROR (Status);
 480
 481   return Value;
 482 }
 483
 484
 485
 486 /**
 487   Sets a buffer for the token specified by TokenNumber to
 488   the value specified by Buffer and SizeOfValue.  Buffer to
 489   be set is returned. The content of the buffer could be
 490   overwritten if a Callback on SET is registered with this
 491   TokenNumber.
 492
 493   If SizeOfValue is greater than the maximum
 494   size support by TokenNumber, then set SizeOfValue to the
 495   maximum size supported by TokenNumber and return NULL to
 496   indicate that the set operation was not actually performed.
 497
 498   If SizeOfValue > 0 and Buffer is NULL, then ASSERT().
 499
 500   @param[in]  TokenNumber The PCD token number to set a current value for.
 501   @param[in,out] SizeOfBuffer The size, in bytes, of Buffer.
 502   @param[in]  Value A pointer to the buffer to set.
 503
 504   @retval VOID* Return the pointer for the buffer been set.
 505
 506 **/
 507
 508 VOID *
 509 EFIAPI
 510 LibPcdSetPtr (
 511   IN      UINTN             TokenNumber,
 512   IN OUT  UINTN             *SizeOfBuffer,
 513   IN      VOID              *Buffer
 514   )
 515 {
 516   EFI_STATUS Status;
 517
 518   ASSERT (SizeOfBuffer != NULL);
 519
 520   if (*SizeOfBuffer > 0) {
 521     ASSERT (Buffer != NULL);
 522   }
 523
 524   Status = mPcd->SetPtr (TokenNumber, SizeOfBuffer, Buffer);
 525
 526   if (EFI_ERROR (Status)) {
 527     return NULL;
 528   }
 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
 728   ASSERT (Guid != NULL);
 729
 730   ASSERT (SizeOfBuffer != NULL);
 731
 732   if (*SizeOfBuffer > 0) {
 733     ASSERT (Buffer != NULL);
 734   }
 735
 736   Status = mPcd->SetPtrEx (Guid, TokenNumber, SizeOfBuffer, Buffer);
 737
 738   if (EFI_ERROR (Status)) {
 739     return NULL;
 740   }
 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 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 *) Guid;
 914 }
 915
 916
 917 /**
 918   Sets the PCD entry specified by PatchVariable to the value specified by Buffer
 919   and SizeOfValue.  Buffer is returned.  If SizeOfValue is greater than
 920   MaximumDatumSize, then set SizeOfValue to MaximumDatumSize and return
 921   NULL to indicate that the set operation was not actually performed.
 922   If SizeOfValue is set to MAX_ADDRESS, then SizeOfValue must be set to
 923   MaximumDatumSize and NULL must be returned.
 924
 925   If PatchVariable is NULL, then ASSERT().
 926   If SizeOfValue is NULL, then ASSERT().
 927   If SizeOfValue > 0 and Buffer is NULL, then ASSERT().
 928
 929   @param[in] PatchVariable      A pointer to the global variable in a module that is
 930                                 the target of the set operation.
 931   @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
 932   @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
 933   @param[in] Buffer             A pointer to the buffer to used to set the target variable.
 934
 935 **/
 936 VOID *
 937 EFIAPI
 938 LibPatchPcdSetPtr (
 939   IN        VOID        *PatchVariable,
 940   IN        UINTN       MaximumDatumSize,
 941   IN OUT    UINTN       *SizeOfBuffer,
 942   IN CONST  VOID        *Buffer
 943   )
 944 {
 945   ASSERT (PatchVariable != NULL);
 946   ASSERT (SizeOfBuffer  != NULL);
 947
 948   if (*SizeOfBuffer > 0) {
 949     ASSERT (Buffer != NULL);
 950   }
 951
 952   if ((*SizeOfBuffer > MaximumDatumSize) ||
 953       (*SizeOfBuffer == MAX_ADDRESS)) {
 954     *SizeOfBuffer = MaximumDatumSize;
 955     return NULL;
 956   }
 957
 958   CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
 959
 960   return (VOID *) Buffer;
 961 }
 962
 963
 964