1 /** @file 2 Implementation of PcdLib class library for PEI phase. 3 4 Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR> 5 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 **/ 15 16 17 18 19 #include <PiPei.h> 20 21 #include <Ppi/Pcd.h> 22 #include <Ppi/PiPcd.h> 23 #include <Ppi/PcdInfo.h> 24 #include <Ppi/PiPcdInfo.h> 25 26 #include <Library/PeiServicesLib.h> 27 #include <Library/PcdLib.h> 28 #include <Library/DebugLib.h> 29 #include <Library/BaseMemoryLib.h> 30 31 /** 32 Retrieve the PCD_PPI pointer. 33 34 This function is to locate PCD_PPI PPI via PeiService. 35 If fail to locate PCD_PPI, then ASSERT_EFI_ERROR(). 36 37 @retval PCD_PPI * The pointer to the PCD_PPI. 38 39 **/ 40 PCD_PPI * 41 GetPcdPpiPointer ( 42 VOID 43 ) 44 { 45 EFI_STATUS Status; 46 PCD_PPI *PcdPpi; 47 48 Status = PeiServicesLocatePpi (&gPcdPpiGuid, 0, NULL, (VOID **)&PcdPpi); 49 ASSERT_EFI_ERROR (Status); 50 51 return PcdPpi; 52 } 53 54 /** 55 Retrieve the pointer of EFI_PEI_PCD_PPI defined in PI 1.2 Vol 3. 56 57 This function is to locate EFI_PEI_PCD_PPI PPI via PeiService. 58 If fail to locate EFI_PEI_PCD_PPI, then ASSERT_EFI_ERROR(). 59 60 @retval EFI_PEI_PCD_PPI * The pointer to the EFI_PEI_PCD_PPI. 61 62 **/ 63 EFI_PEI_PCD_PPI * 64 GetPiPcdPpiPointer ( 65 VOID 66 ) 67 { 68 EFI_STATUS Status; 69 EFI_PEI_PCD_PPI *PiPcdPpi; 70 71 Status = PeiServicesLocatePpi (&gEfiPeiPcdPpiGuid, 0, NULL, (VOID **)&PiPcdPpi); 72 ASSERT_EFI_ERROR (Status); 73 74 return PiPcdPpi; 75 } 76 77 /** 78 Retrieve the GET_PCD_INFO_PPI pointer. 79 80 This function is to locate GET_PCD_INFO_PPI PPI via PeiService. 81 If fail to locate GET_PCD_INFO_PPI, then ASSERT_EFI_ERROR(). 82 83 @retval GET_PCD_INFO_PPI * The pointer to the GET_PCD_INFO_PPI. 84 85 **/ 86 GET_PCD_INFO_PPI * 87 GetPcdInfoPpiPointer ( 88 VOID 89 ) 90 { 91 EFI_STATUS Status; 92 GET_PCD_INFO_PPI *PcdInfoPpi; 93 94 Status = PeiServicesLocatePpi (&gGetPcdInfoPpiGuid, 0, NULL, (VOID **)&PcdInfoPpi); 95 ASSERT_EFI_ERROR (Status); 96 97 return PcdInfoPpi; 98 } 99 100 /** 101 Retrieve the pointer of EFI_GET_PCD_INFO_PPI defined in PI 1.2.1 Vol 3. 102 103 This function is to locate EFI_GET_PCD_INFO_PPI PPI via PeiService. 104 If fail to locate EFI_GET_PCD_INFO_PPI, then ASSERT_EFI_ERROR(). 105 106 @retval EFI_GET_PCD_INFO_PPI * The pointer to the EFI_GET_PCD_INFO_PPI. 107 108 **/ 109 EFI_GET_PCD_INFO_PPI * 110 GetPiPcdInfoPpiPointer ( 111 VOID 112 ) 113 { 114 EFI_STATUS Status; 115 EFI_GET_PCD_INFO_PPI *PiPcdInfoPpi; 116 117 Status = PeiServicesLocatePpi (&gEfiGetPcdInfoPpiGuid, 0, NULL, (VOID **)&PiPcdInfoPpi); 118 ASSERT_EFI_ERROR (Status); 119 120 return PiPcdInfoPpi; 121 } 122 123 /** 124 This function provides a means by which SKU support can be established in the PCD infrastructure. 125 126 Sets the current SKU in the PCD database to the value specified by SkuId. SkuId is returned. 127 If SkuId >= PCD_MAX_SKU_ID, then ASSERT(). 128 129 @param SkuId The SKU value that will be used when the PCD service retrieves 130 and sets values associated with a PCD token. 131 132 @return Return the SKU ID that just be set. 133 134 **/ 135 UINTN 136 EFIAPI 137 LibPcdSetSku ( 138 IN UINTN SkuId 139 ) 140 { 141 142 ASSERT (SkuId < PCD_MAX_SKU_ID); 143 144 GetPiPcdPpiPointer()->SetSku (SkuId); 145 146 return SkuId; 147 } 148 149 150 151 /** 152 This function provides a means by which to retrieve a value for a given PCD token. 153 154 Returns the 8-bit value for the token specified by TokenNumber. 155 156 @param[in] TokenNumber The PCD token number to retrieve a current value for. 157 158 @return Returns the 8-bit value for the token specified by TokenNumber. 159 160 **/ 161 UINT8 162 EFIAPI 163 LibPcdGet8 ( 164 IN UINTN TokenNumber 165 ) 166 { 167 return (GetPcdPpiPointer ())->Get8 (TokenNumber); 168 } 169 170 171 172 /** 173 This function provides a means by which to retrieve a value for a given PCD token. 174 175 Returns the 16-bit value for the token specified by TokenNumber. 176 177 @param[in] TokenNumber The PCD token number to retrieve a current value for. 178 179 @return Returns the 16-bit value for the token specified by TokenNumber. 180 181 **/ 182 UINT16 183 EFIAPI 184 LibPcdGet16 ( 185 IN UINTN TokenNumber 186 ) 187 { 188 return (GetPcdPpiPointer ())->Get16 (TokenNumber); 189 } 190 191 192 193 /** 194 This function provides a means by which to retrieve a value for a given PCD token. 195 196 Returns the 32-bit value for the token specified by TokenNumber. 197 198 @param[in] TokenNumber The PCD token number to retrieve a current value for. 199 200 @return Returns the 32-bit value for the token specified by TokenNumber. 201 202 **/ 203 UINT32 204 EFIAPI 205 LibPcdGet32 ( 206 IN UINTN TokenNumber 207 ) 208 { 209 return (GetPcdPpiPointer ())->Get32 (TokenNumber); 210 } 211 212 213 214 /** 215 This function provides a means by which to retrieve a value for a given PCD token. 216 217 Returns the 64-bit value for the token specified by TokenNumber. 218 219 @param[in] TokenNumber The PCD token number to retrieve a current value for. 220 221 @return Returns the 64-bit value for the token specified by TokenNumber. 222 223 **/ 224 UINT64 225 EFIAPI 226 LibPcdGet64 ( 227 IN UINTN TokenNumber 228 ) 229 { 230 return (GetPcdPpiPointer ())->Get64 (TokenNumber); 231 } 232 233 234 235 /** 236 This function provides a means by which to retrieve a value for a given PCD token. 237 238 Returns the pointer to the buffer of the token specified by TokenNumber. 239 240 @param[in] TokenNumber The PCD token number to retrieve a current value for. 241 242 @return Returns the pointer to the token specified by TokenNumber. 243 244 **/ 245 VOID * 246 EFIAPI 247 LibPcdGetPtr ( 248 IN UINTN TokenNumber 249 ) 250 { 251 return (GetPcdPpiPointer ())->GetPtr (TokenNumber); 252 } 253 254 255 256 /** 257 This function provides a means by which to retrieve a value for a given PCD token. 258 259 Returns the Boolean value of the token specified by TokenNumber. 260 261 @param[in] TokenNumber The PCD token number to retrieve a current value for. 262 263 @return Returns the Boolean value of the token specified by TokenNumber. 264 265 **/ 266 BOOLEAN 267 EFIAPI 268 LibPcdGetBool ( 269 IN UINTN TokenNumber 270 ) 271 { 272 return (GetPcdPpiPointer ())->GetBool (TokenNumber); 273 } 274 275 276 277 /** 278 This function provides a means by which to retrieve the size of a given PCD token. 279 280 @param[in] TokenNumber The PCD token number to retrieve a current value for. 281 282 @return Returns the size of the token specified by TokenNumber. 283 284 **/ 285 UINTN 286 EFIAPI 287 LibPcdGetSize ( 288 IN UINTN TokenNumber 289 ) 290 { 291 return (GetPcdPpiPointer ())->GetSize (TokenNumber); 292 } 293 294 295 296 /** 297 This function provides a means by which to retrieve a value for a given PCD token. 298 299 Returns the 8-bit value for the token specified by TokenNumber and Guid. 300 301 If Guid is NULL, then ASSERT(). 302 303 @param[in] Guid The pointer to a 128-bit unique value that designates 304 which namespace to retrieve a value from. 305 @param[in] TokenNumber The PCD token number to retrieve a current value for. 306 307 @return Return the UINT8. 308 309 **/ 310 UINT8 311 EFIAPI 312 LibPcdGetEx8 ( 313 IN CONST GUID *Guid, 314 IN UINTN TokenNumber 315 ) 316 { 317 ASSERT (Guid != NULL); 318 319 return (GetPiPcdPpiPointer ())->Get8 (Guid, TokenNumber); 320 } 321 322 323 324 /** 325 This function provides a means by which to retrieve a value for a given PCD token. 326 327 Returns the 16-bit value for the token specified by TokenNumber and Guid. 328 329 If Guid is NULL, then ASSERT(). 330 331 @param[in] Guid The 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 @return Return the UINT16. 336 337 **/ 338 UINT16 339 EFIAPI 340 LibPcdGetEx16 ( 341 IN CONST GUID *Guid, 342 IN UINTN TokenNumber 343 ) 344 { 345 346 ASSERT (Guid != NULL); 347 348 return (GetPiPcdPpiPointer ())->Get16 (Guid, TokenNumber); 349 } 350 351 352 353 /** 354 Returns the 32-bit value for the token specified by TokenNumber and Guid. 355 If Guid is NULL, then ASSERT(). 356 357 @param[in] Guid The pointer to a 128-bit unique value that designates 358 which namespace to retrieve a value from. 359 @param[in] TokenNumber The PCD token number to retrieve a current value for. 360 361 @return Return the UINT32. 362 363 **/ 364 UINT32 365 EFIAPI 366 LibPcdGetEx32 ( 367 IN CONST GUID *Guid, 368 IN UINTN TokenNumber 369 ) 370 { 371 ASSERT (Guid != NULL); 372 373 return (GetPiPcdPpiPointer ())->Get32 (Guid, TokenNumber); 374 } 375 376 377 378 379 /** 380 This function provides a means by which to retrieve a value for a given PCD token. 381 382 Returns the 64-bit value for the token specified by TokenNumber and Guid. 383 384 If Guid is NULL, then ASSERT(). 385 386 @param[in] Guid The pointer to a 128-bit unique value that designates 387 which namespace to retrieve a value from. 388 @param[in] TokenNumber The PCD token number to retrieve a current value for. 389 390 @return Return the UINT64. 391 392 **/ 393 UINT64 394 EFIAPI 395 LibPcdGetEx64 ( 396 IN CONST GUID *Guid, 397 IN UINTN TokenNumber 398 ) 399 { 400 ASSERT (Guid != NULL); 401 return (GetPiPcdPpiPointer ())->Get64 (Guid, TokenNumber); 402 } 403 404 405 406 /** 407 This function provides a means by which to retrieve a value for a given PCD token. 408 409 Returns the pointer to the buffer of token specified by TokenNumber and Guid. 410 411 If Guid is NULL, then ASSERT(). 412 413 @param[in] Guid The pointer to a 128-bit unique value that designates 414 which namespace to retrieve a value from. 415 @param[in] TokenNumber The PCD token number to retrieve a current value for. 416 417 @return Return the VOID* pointer. 418 419 **/ 420 VOID * 421 EFIAPI 422 LibPcdGetExPtr ( 423 IN CONST GUID *Guid, 424 IN UINTN TokenNumber 425 ) 426 { 427 ASSERT (Guid != NULL); 428 429 return (GetPiPcdPpiPointer ())->GetPtr (Guid, TokenNumber); 430 } 431 432 433 434 /** 435 This function provides a means by which to retrieve a value for a given PCD token. 436 437 Returns the Boolean value of the token specified by TokenNumber and Guid. 438 439 If Guid is NULL, then ASSERT(). 440 441 @param[in] Guid The pointer to a 128-bit unique value that designates 442 which namespace to retrieve a value from. 443 @param[in] TokenNumber The PCD token number to retrieve a current value for. 444 445 @return Return the BOOLEAN. 446 447 **/ 448 BOOLEAN 449 EFIAPI 450 LibPcdGetExBool ( 451 IN CONST GUID *Guid, 452 IN UINTN TokenNumber 453 ) 454 { 455 ASSERT (Guid != NULL); 456 return (GetPiPcdPpiPointer ())->GetBool (Guid, TokenNumber); 457 } 458 459 460 461 /** 462 This function provides a means by which to retrieve the size of a given PCD token. 463 464 Returns the size of the token specified by TokenNumber and Guid. 465 466 If Guid is NULL, then ASSERT(). 467 468 @param[in] Guid The pointer to a 128-bit unique value that designates 469 which namespace to retrieve a value from. 470 @param[in] TokenNumber The PCD token number to retrieve a current value for. 471 472 @return Return the size. 473 474 **/ 475 UINTN 476 EFIAPI 477 LibPcdGetExSize ( 478 IN CONST GUID *Guid, 479 IN UINTN TokenNumber 480 ) 481 { 482 ASSERT (Guid != NULL); 483 return (GetPiPcdPpiPointer ())->GetSize (Guid, TokenNumber); 484 } 485 486 487 488 #ifndef DISABLE_NEW_DEPRECATED_INTERFACES 489 /** 490 This function provides a means by which to set a value for a given PCD token. 491 492 Sets the 8-bit value for the token specified by TokenNumber 493 to the value specified by Value. Value is returned. 494 495 @param[in] TokenNumber The PCD token number to set a current value for. 496 @param[in] Value The 8-bit value to set. 497 498 @return Return the value that was set. 499 500 **/ 501 UINT8 502 EFIAPI 503 LibPcdSet8 ( 504 IN UINTN TokenNumber, 505 IN UINT8 Value 506 ) 507 { 508 (GetPcdPpiPointer ())->Set8 (TokenNumber, Value); 509 510 return Value; 511 } 512 513 514 515 /** 516 This function provides a means by which to set a value for a given PCD token. 517 518 Sets the 16-bit value for the token specified by TokenNumber 519 to the value specified by Value. Value is returned. 520 521 @param[in] TokenNumber The PCD token number to set a current value for. 522 @param[in] Value The 16-bit value to set. 523 524 @return Return the value that was set. 525 526 **/ 527 UINT16 528 EFIAPI 529 LibPcdSet16 ( 530 IN UINTN TokenNumber, 531 IN UINT16 Value 532 ) 533 { 534 (GetPcdPpiPointer ())->Set16 (TokenNumber, Value); 535 536 return Value; 537 } 538 539 540 541 /** 542 This function provides a means by which to set a value for a given PCD token. 543 544 Sets the 32-bit value for the token specified by TokenNumber 545 to the value specified by Value. Value is returned. 546 547 @param[in] TokenNumber The PCD token number to set a current value for. 548 @param[in] Value The 32-bit value to set. 549 550 @return Return the value that was set. 551 552 **/ 553 UINT32 554 EFIAPI 555 LibPcdSet32 ( 556 IN UINTN TokenNumber, 557 IN UINT32 Value 558 ) 559 { 560 (GetPcdPpiPointer ())->Set32 (TokenNumber, Value); 561 562 return Value; 563 } 564 565 566 567 /** 568 This function provides a means by which to set a value for a given PCD token. 569 570 Sets the 64-bit value for the token specified by TokenNumber 571 to the value specified by Value. Value is returned. 572 573 @param[in] TokenNumber The PCD token number to set a current value for. 574 @param[in] Value The 64-bit value to set. 575 576 @return Return the value that was set. 577 578 **/ 579 UINT64 580 EFIAPI 581 LibPcdSet64 ( 582 IN UINTN TokenNumber, 583 IN UINT64 Value 584 ) 585 { 586 (GetPcdPpiPointer ())->Set64 (TokenNumber, Value); 587 588 return Value; 589 } 590 591 592 593 /** 594 This function provides a means by which to set a value for a given PCD token. 595 596 Sets a buffer for the token specified by TokenNumber to the value 597 specified by Buffer and SizeOfBuffer. Buffer is returned. 598 If SizeOfBuffer is greater than the maximum size support by TokenNumber, 599 then set SizeOfBuffer to the maximum size supported by TokenNumber and 600 return NULL to indicate that the set operation was not actually performed. 601 602 If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the 603 maximum size supported by TokenName and NULL must be returned. 604 605 If SizeOfBuffer is NULL, then ASSERT(). 606 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT(). 607 608 @param[in] TokenNumber The PCD token number to set a current value for. 609 @param[in, out] SizeOfBuffer The size, in bytes, of Buffer. 610 @param[in] Buffer A pointer to the buffer to set. 611 612 @return Return the pointer for the buffer been set. 613 614 **/ 615 VOID * 616 EFIAPI 617 LibPcdSetPtr ( 618 IN UINTN TokenNumber, 619 IN OUT UINTN *SizeOfBuffer, 620 IN CONST VOID *Buffer 621 ) 622 { 623 EFI_STATUS Status; 624 UINTN InputSizeOfBuffer; 625 626 ASSERT (SizeOfBuffer != NULL); 627 628 if (*SizeOfBuffer > 0) { 629 ASSERT (Buffer != NULL); 630 } 631 632 InputSizeOfBuffer = *SizeOfBuffer; 633 Status = (GetPcdPpiPointer ())->SetPtr (TokenNumber, SizeOfBuffer, (VOID *) Buffer); 634 if (EFI_ERROR (Status) && (*SizeOfBuffer < InputSizeOfBuffer)) { 635 return NULL; 636 } 637 638 return (VOID *) Buffer; 639 } 640 641 642 643 /** 644 This function provides a means by which to set a value for a given PCD token. 645 646 Sets the Boolean value for the token specified by TokenNumber 647 to the value specified by Value. Value is returned. 648 649 @param[in] TokenNumber The PCD token number to set a current value for. 650 @param[in] Value The boolean value to set. 651 652 @return Return the value that was set. 653 654 **/ 655 BOOLEAN 656 EFIAPI 657 LibPcdSetBool ( 658 IN UINTN TokenNumber, 659 IN BOOLEAN Value 660 ) 661 { 662 (GetPcdPpiPointer ())->SetBool (TokenNumber, Value); 663 664 return Value; 665 } 666 667 668 669 /** 670 This function provides a means by which to set a value for a given PCD token. 671 672 Sets the 8-bit value for the token specified by TokenNumber and 673 Guid to the value specified by Value. Value is returned. 674 675 If Guid is NULL, then ASSERT(). 676 677 @param[in] Guid The pointer to a 128-bit unique value that 678 designates which namespace to set a value from. 679 @param[in] TokenNumber The PCD token number to set a current value for. 680 @param[in] Value The 8-bit value to set. 681 682 @return Return the value that was set. 683 684 **/ 685 UINT8 686 EFIAPI 687 LibPcdSetEx8 ( 688 IN CONST GUID *Guid, 689 IN UINTN TokenNumber, 690 IN UINT8 Value 691 ) 692 { 693 ASSERT (Guid != NULL); 694 695 (GetPiPcdPpiPointer ())->Set8 (Guid, TokenNumber, Value); 696 697 return Value; 698 } 699 700 701 702 /** 703 This function provides a means by which to set a value for a given PCD token. 704 705 Sets the 16-bit value for the token specified by TokenNumber and 706 Guid to the value specified by Value. Value is returned. 707 708 If Guid is NULL, then ASSERT(). 709 710 @param[in] Guid The 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] Value The 16-bit value to set. 714 715 @return Return the value that was set. 716 717 **/ 718 UINT16 719 EFIAPI 720 LibPcdSetEx16 ( 721 IN CONST GUID *Guid, 722 IN UINTN TokenNumber, 723 IN UINT16 Value 724 ) 725 { 726 ASSERT (Guid != NULL); 727 728 (GetPiPcdPpiPointer ())->Set16 (Guid, TokenNumber, Value); 729 730 return Value; 731 } 732 733 734 735 /** 736 This function provides a means by which to set a value for a given PCD token. 737 738 Sets the 32-bit value for the token specified by TokenNumber and 739 Guid to the value specified by Value. Value is returned. 740 741 If Guid is NULL, then ASSERT(). 742 743 @param[in] Guid The pointer to a 128-bit unique value that 744 designates which namespace to set a value from. 745 @param[in] TokenNumber The PCD token number to set a current value for. 746 @param[in] Value The 32-bit value to set. 747 748 @return Return the value that was set. 749 750 **/ 751 UINT32 752 EFIAPI 753 LibPcdSetEx32 ( 754 IN CONST GUID *Guid, 755 IN UINTN TokenNumber, 756 IN UINT32 Value 757 ) 758 { 759 ASSERT (Guid != NULL); 760 761 (GetPiPcdPpiPointer ())->Set32 (Guid, TokenNumber, Value); 762 763 return Value; 764 } 765 766 767 768 /** 769 This function provides a means by which to set a value for a given PCD token. 770 771 Sets the 64-bit value for the token specified by TokenNumber and 772 Guid to the value specified by Value. Value is returned. 773 774 If Guid is NULL, then ASSERT(). 775 776 @param[in] Guid The pointer to a 128-bit unique value that 777 designates which namespace to set a value from. 778 @param[in] TokenNumber The PCD token number to set a current value for. 779 @param[in] Value The 64-bit value to set. 780 781 @return Return the value that was set. 782 783 **/ 784 UINT64 785 EFIAPI 786 LibPcdSetEx64 ( 787 IN CONST GUID *Guid, 788 IN UINTN TokenNumber, 789 IN UINT64 Value 790 ) 791 { 792 ASSERT (Guid != NULL); 793 794 (GetPiPcdPpiPointer ())->Set64 (Guid, TokenNumber, Value); 795 796 return Value; 797 } 798 799 800 801 /** 802 This function provides a means by which to set a value for a given PCD token. 803 804 Sets a buffer for the token specified by TokenNumber to the value specified by 805 Buffer and SizeOfBuffer. Buffer is returned. If SizeOfBuffer is greater than 806 the maximum size support by TokenNumber, then set SizeOfBuffer to the maximum size 807 supported by TokenNumber and return NULL to indicate that the set operation 808 was not actually performed. 809 810 If Guid is NULL, then ASSERT(). 811 If SizeOfBuffer is NULL, then ASSERT(). 812 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT(). 813 814 @param[in] Guid The pointer to a 128-bit unique value that 815 designates which namespace to set a value from. 816 @param[in] TokenNumber The PCD token number to set a current value for. 817 @param[in, out] SizeOfBuffer The size, in bytes, of Buffer. 818 @param[in] Buffer A pointer to the buffer to set. 819 820 @return Return the pinter to the buffer been set. 821 822 **/ 823 VOID * 824 EFIAPI 825 LibPcdSetExPtr ( 826 IN CONST GUID *Guid, 827 IN UINTN TokenNumber, 828 IN OUT UINTN *SizeOfBuffer, 829 IN VOID *Buffer 830 ) 831 { 832 EFI_STATUS Status; 833 UINTN InputSizeOfBuffer; 834 835 ASSERT (SizeOfBuffer != NULL); 836 if (*SizeOfBuffer > 0) { 837 ASSERT (Buffer != NULL); 838 } 839 ASSERT (Guid != NULL); 840 841 InputSizeOfBuffer = *SizeOfBuffer; 842 Status = (GetPiPcdPpiPointer ())->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer); 843 if (EFI_ERROR (Status) && (*SizeOfBuffer < InputSizeOfBuffer)) { 844 return NULL; 845 } 846 847 return Buffer; 848 } 849 850 851 852 /** 853 This function provides a means by which to set a value for a given PCD token. 854 855 Sets the Boolean value for the token specified by TokenNumber and 856 Guid to the value specified by Value. Value is returned. 857 858 If Guid is NULL, then ASSERT(). 859 860 @param[in] Guid The pointer to a 128-bit unique value that 861 designates which namespace to set a value from. 862 @param[in] TokenNumber The PCD token number to set a current value for. 863 @param[in] Value The Boolean value to set. 864 865 @return Return the value that was set. 866 867 **/ 868 BOOLEAN 869 EFIAPI 870 LibPcdSetExBool ( 871 IN CONST GUID *Guid, 872 IN UINTN TokenNumber, 873 IN BOOLEAN Value 874 ) 875 { 876 ASSERT (Guid != NULL); 877 878 (GetPiPcdPpiPointer ())->SetBool (Guid, TokenNumber, Value); 879 880 return Value; 881 } 882 #endif 883 884 /** 885 This function provides a means by which to set a value for a given PCD token. 886 887 Sets the 8-bit value for the token specified by TokenNumber 888 to the value specified by Value. 889 890 @param[in] TokenNumber The PCD token number to set a current value for. 891 @param[in] Value The 8-bit value to set. 892 893 @return The status of the set operation. 894 895 **/ 896 RETURN_STATUS 897 EFIAPI 898 LibPcdSet8S ( 899 IN UINTN TokenNumber, 900 IN UINT8 Value 901 ) 902 { 903 return (GetPcdPpiPointer ())->Set8 (TokenNumber, Value); 904 } 905 906 /** 907 This function provides a means by which to set a value for a given PCD token. 908 909 Sets the 16-bit value for the token specified by TokenNumber 910 to the value specified by Value. 911 912 @param[in] TokenNumber The PCD token number to set a current value for. 913 @param[in] Value The 16-bit value to set. 914 915 @return The status of the set operation. 916 917 **/ 918 RETURN_STATUS 919 EFIAPI 920 LibPcdSet16S ( 921 IN UINTN TokenNumber, 922 IN UINT16 Value 923 ) 924 { 925 return (GetPcdPpiPointer ())->Set16 (TokenNumber, Value); 926 } 927 928 /** 929 This function provides a means by which to set a value for a given PCD token. 930 931 Sets the 32-bit value for the token specified by TokenNumber 932 to the value specified by Value. 933 934 @param[in] TokenNumber The PCD token number to set a current value for. 935 @param[in] Value The 32-bit value to set. 936 937 @return The status of the set operation. 938 939 **/ 940 RETURN_STATUS 941 EFIAPI 942 LibPcdSet32S ( 943 IN UINTN TokenNumber, 944 IN UINT32 Value 945 ) 946 { 947 return (GetPcdPpiPointer ())->Set32 (TokenNumber, Value); 948 } 949 950 /** 951 This function provides a means by which to set a value for a given PCD token. 952 953 Sets the 64-bit value for the token specified by TokenNumber 954 to the value specified by Value. 955 956 @param[in] TokenNumber The PCD token number to set a current value for. 957 @param[in] Value The 64-bit value to set. 958 959 @return The status of the set operation. 960 961 **/ 962 RETURN_STATUS 963 EFIAPI 964 LibPcdSet64S ( 965 IN UINTN TokenNumber, 966 IN UINT64 Value 967 ) 968 { 969 return (GetPcdPpiPointer ())->Set64 (TokenNumber, Value); 970 } 971 972 /** 973 This function provides a means by which to set a value for a given PCD token. 974 975 Sets a buffer for the token specified by TokenNumber to the value specified 976 by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size 977 support by TokenNumber, then set SizeOfBuffer to the maximum size supported by 978 TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation 979 was not actually performed. 980 981 If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the 982 maximum size supported by TokenName and EFI_INVALID_PARAMETER must be returned. 983 984 If SizeOfBuffer is NULL, then ASSERT(). 985 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT(). 986 987 @param[in] TokenNumber The PCD token number to set a current value for. 988 @param[in, out] SizeOfBuffer The size, in bytes, of Buffer. 989 @param[in] Buffer A pointer to the buffer to set. 990 991 @return The status of the set operation. 992 993 **/ 994 RETURN_STATUS 995 EFIAPI 996 LibPcdSetPtrS ( 997 IN UINTN TokenNumber, 998 IN OUT UINTN *SizeOfBuffer, 999 IN CONST VOID *Buffer 1000 ) 1001 { 1002 ASSERT (SizeOfBuffer != NULL); 1003 1004 if (*SizeOfBuffer > 0) { 1005 ASSERT (Buffer != NULL); 1006 } 1007 1008 return (GetPcdPpiPointer ())->SetPtr (TokenNumber, SizeOfBuffer, (VOID *) Buffer); 1009 } 1010 1011 /** 1012 This function provides a means by which to set a value for a given PCD token. 1013 1014 Sets the boolean value for the token specified by TokenNumber 1015 to the value specified by Value. 1016 1017 @param[in] TokenNumber The PCD token number to set a current value for. 1018 @param[in] Value The boolean value to set. 1019 1020 @return The status of the set operation. 1021 1022 **/ 1023 RETURN_STATUS 1024 EFIAPI 1025 LibPcdSetBoolS ( 1026 IN UINTN TokenNumber, 1027 IN BOOLEAN Value 1028 ) 1029 { 1030 return (GetPcdPpiPointer ())->SetBool (TokenNumber, Value); 1031 } 1032 1033 /** 1034 This function provides a means by which to set a value for a given PCD token. 1035 1036 Sets the 8-bit value for the token specified by TokenNumber 1037 to the value specified by Value. 1038 1039 If Guid is NULL, then ASSERT(). 1040 1041 @param[in] Guid The pointer to a 128-bit unique value that 1042 designates which namespace to set a value from. 1043 @param[in] TokenNumber The PCD token number to set a current value for. 1044 @param[in] Value The 8-bit value to set. 1045 1046 @return The status of the set operation. 1047 1048 **/ 1049 RETURN_STATUS 1050 EFIAPI 1051 LibPcdSetEx8S ( 1052 IN CONST GUID *Guid, 1053 IN UINTN TokenNumber, 1054 IN UINT8 Value 1055 ) 1056 { 1057 ASSERT (Guid != NULL); 1058 1059 return (GetPiPcdPpiPointer ())->Set8 (Guid, TokenNumber, Value); 1060 } 1061 1062 /** 1063 This function provides a means by which to set a value for a given PCD token. 1064 1065 Sets the 16-bit value for the token specified by TokenNumber 1066 to the value specified by Value. 1067 1068 If Guid is NULL, then ASSERT(). 1069 1070 @param[in] Guid The pointer to a 128-bit unique value that 1071 designates which namespace to set a value from. 1072 @param[in] TokenNumber The PCD token number to set a current value for. 1073 @param[in] Value The 16-bit value to set. 1074 1075 @return The status of the set operation. 1076 1077 **/ 1078 RETURN_STATUS 1079 EFIAPI 1080 LibPcdSetEx16S ( 1081 IN CONST GUID *Guid, 1082 IN UINTN TokenNumber, 1083 IN UINT16 Value 1084 ) 1085 { 1086 ASSERT (Guid != NULL); 1087 1088 return (GetPiPcdPpiPointer ())->Set16 (Guid, TokenNumber, Value); 1089 } 1090 1091 /** 1092 This function provides a means by which to set a value for a given PCD token. 1093 1094 Sets the 32-bit value for the token specified by TokenNumber 1095 to the value specified by Value. 1096 1097 If Guid is NULL, then ASSERT(). 1098 1099 @param[in] Guid The pointer to a 128-bit unique value that 1100 designates which namespace to set a value from. 1101 @param[in] TokenNumber The PCD token number to set a current value for. 1102 @param[in] Value The 32-bit value to set. 1103 1104 @return The status of the set operation. 1105 1106 **/ 1107 RETURN_STATUS 1108 EFIAPI 1109 LibPcdSetEx32S ( 1110 IN CONST GUID *Guid, 1111 IN UINTN TokenNumber, 1112 IN UINT32 Value 1113 ) 1114 { 1115 ASSERT (Guid != NULL); 1116 1117 return (GetPiPcdPpiPointer ())->Set32 (Guid, TokenNumber, Value); 1118 } 1119 1120 /** 1121 This function provides a means by which to set a value for a given PCD token. 1122 1123 Sets the 64-bit value for the token specified by TokenNumber 1124 to the value specified by Value. 1125 1126 If Guid is NULL, then ASSERT(). 1127 1128 @param[in] Guid The pointer to a 128-bit unique value that 1129 designates which namespace to set a value from. 1130 @param[in] TokenNumber The PCD token number to set a current value for. 1131 @param[in] Value The 64-bit value to set. 1132 1133 @return The status of the set operation. 1134 1135 **/ 1136 RETURN_STATUS 1137 EFIAPI 1138 LibPcdSetEx64S ( 1139 IN CONST GUID *Guid, 1140 IN UINTN TokenNumber, 1141 IN UINT64 Value 1142 ) 1143 { 1144 ASSERT (Guid != NULL); 1145 1146 return (GetPiPcdPpiPointer ())->Set64 (Guid, TokenNumber, Value); 1147 } 1148 1149 /** 1150 This function provides a means by which to set a value for a given PCD token. 1151 1152 Sets a buffer for the token specified by TokenNumber to the value specified by 1153 Buffer and SizeOfBuffer. If SizeOfBuffer is greater than the maximum size 1154 support by TokenNumber, then set SizeOfBuffer to the maximum size supported by 1155 TokenNumber and return EFI_INVALID_PARAMETER to indicate that the set operation 1156 was not actually performed. 1157 1158 If Guid is NULL, then ASSERT(). 1159 If SizeOfBuffer is NULL, then ASSERT(). 1160 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT(). 1161 1162 @param[in] Guid Pointer to a 128-bit unique value that 1163 designates which namespace to set a value from. 1164 @param[in] TokenNumber The PCD token number to set a current value for. 1165 @param[in, out] SizeOfBuffer The size, in bytes, of Buffer. 1166 @param[in] Buffer A pointer to the buffer to set. 1167 1168 @return The status of the set operation. 1169 1170 **/ 1171 RETURN_STATUS 1172 EFIAPI 1173 LibPcdSetExPtrS ( 1174 IN CONST GUID *Guid, 1175 IN UINTN TokenNumber, 1176 IN OUT UINTN *SizeOfBuffer, 1177 IN VOID *Buffer 1178 ) 1179 { 1180 ASSERT (Guid != NULL); 1181 1182 ASSERT (SizeOfBuffer != NULL); 1183 1184 if (*SizeOfBuffer > 0) { 1185 ASSERT (Buffer != NULL); 1186 } 1187 1188 return (GetPiPcdPpiPointer ())->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer); 1189 } 1190 1191 /** 1192 This function provides a means by which to set a value for a given PCD token. 1193 1194 Sets the boolean value for the token specified by TokenNumber 1195 to the value specified by Value. 1196 1197 If Guid is NULL, then ASSERT(). 1198 1199 @param[in] Guid The pointer to a 128-bit unique value that 1200 designates which namespace to set a value from. 1201 @param[in] TokenNumber The PCD token number to set a current value for. 1202 @param[in] Value The boolean value to set. 1203 1204 @return The status of the set operation. 1205 1206 **/ 1207 RETURN_STATUS 1208 EFIAPI 1209 LibPcdSetExBoolS ( 1210 IN CONST GUID *Guid, 1211 IN UINTN TokenNumber, 1212 IN BOOLEAN Value 1213 ) 1214 { 1215 ASSERT (Guid != NULL); 1216 1217 return (GetPiPcdPpiPointer ())->SetBool (Guid, TokenNumber, Value); 1218 } 1219 1220 /** 1221 Set up a notification function that is called when a specified token is set. 1222 1223 When the token specified by TokenNumber and Guid is set, 1224 then notification function specified by NotificationFunction is called. 1225 If Guid is NULL, then the default token space is used. 1226 If NotificationFunction is NULL, then ASSERT(). 1227 1228 @param[in] Guid The pointer to a 128-bit unique value that 1229 designates which namespace to set a value from. 1230 If NULL, then the default token space is used. 1231 @param[in] TokenNumber The PCD token number to monitor. 1232 @param[in] NotificationFunction The function to call when the token 1233 specified by Guid and TokenNumber is set. 1234 1235 **/ 1236 VOID 1237 EFIAPI 1238 LibPcdCallbackOnSet ( 1239 IN CONST GUID *Guid, OPTIONAL 1240 IN UINTN TokenNumber, 1241 IN PCD_CALLBACK NotificationFunction 1242 ) 1243 { 1244 EFI_STATUS Status; 1245 1246 ASSERT (NotificationFunction != NULL); 1247 1248 Status = (GetPiPcdPpiPointer ())->CallbackOnSet (Guid, TokenNumber, (EFI_PEI_PCD_PPI_CALLBACK) NotificationFunction); 1249 1250 ASSERT_EFI_ERROR (Status); 1251 1252 return; 1253 } 1254 1255 1256 1257 /** 1258 Disable a notification function that was established with LibPcdCallbackonSet(). 1259 1260 Disable a notification function that was previously established with LibPcdCallbackOnSet(). 1261 If NotificationFunction is NULL, then ASSERT(). 1262 If LibPcdCallbackOnSet() was not previously called with Guid, TokenNumber, 1263 and NotificationFunction, then ASSERT(). 1264 1265 @param[in] Guid Specify the GUID token space. 1266 @param[in] TokenNumber Specify the token number. 1267 @param[in] NotificationFunction The callback function to be unregistered. 1268 1269 **/ 1270 VOID 1271 EFIAPI 1272 LibPcdCancelCallback ( 1273 IN CONST GUID *Guid, OPTIONAL 1274 IN UINTN TokenNumber, 1275 IN PCD_CALLBACK NotificationFunction 1276 ) 1277 { 1278 EFI_STATUS Status; 1279 1280 ASSERT (NotificationFunction != NULL); 1281 1282 Status = (GetPiPcdPpiPointer ())->CancelCallback (Guid, TokenNumber, (EFI_PEI_PCD_PPI_CALLBACK) NotificationFunction); 1283 1284 ASSERT_EFI_ERROR (Status); 1285 1286 return; 1287 } 1288 1289 1290 1291 /** 1292 Retrieves the next token in a token space. 1293 1294 Retrieves the next PCD token number from the token space specified by Guid. 1295 If Guid is NULL, then the default token space is used. If TokenNumber is 0, 1296 then the first token number is returned. Otherwise, the token number that 1297 follows TokenNumber in the token space is returned. If TokenNumber is the last 1298 token number in the token space, then 0 is returned. 1299 1300 If TokenNumber is not 0 and is not in the token space specified by Guid, then ASSERT(). 1301 1302 @param[in] Guid The pointer to a 128-bit unique value that designates which namespace 1303 to set a value from. If NULL, then the default token space is used. 1304 @param[in] TokenNumber The previous PCD token number. If 0, then retrieves the first PCD 1305 token number. 1306 1307 @return The next valid token number. 1308 1309 **/ 1310 UINTN 1311 EFIAPI 1312 LibPcdGetNextToken ( 1313 IN CONST GUID *Guid, OPTIONAL 1314 IN UINTN TokenNumber 1315 ) 1316 { 1317 EFI_STATUS Status; 1318 1319 Status = (GetPiPcdPpiPointer ())->GetNextToken (Guid, &TokenNumber); 1320 ASSERT (!EFI_ERROR (Status) || TokenNumber == 0); 1321 1322 return TokenNumber; 1323 } 1324 1325 1326 /** 1327 Used to retrieve the list of available PCD token space GUIDs. 1328 1329 Returns the PCD token space GUID that follows TokenSpaceGuid in the list of token spaces 1330 in the platform. 1331 If TokenSpaceGuid is NULL, then a pointer to the first PCD token spaces returned. 1332 If TokenSpaceGuid is the last PCD token space GUID in the list, then NULL is returned. 1333 1334 @param TokenSpaceGuid The pointer to the a PCD token space GUID 1335 1336 @return The next valid token namespace. 1337 1338 **/ 1339 GUID * 1340 EFIAPI 1341 LibPcdGetNextTokenSpace ( 1342 IN CONST GUID *TokenSpaceGuid 1343 ) 1344 { 1345 (GetPiPcdPpiPointer ())->GetNextTokenSpace (&TokenSpaceGuid); 1346 1347 return (GUID *) TokenSpaceGuid; 1348 } 1349 1350 1351 1352 /** 1353 Sets a value of a patchable PCD entry that is type pointer. 1354 1355 Sets the PCD entry specified by PatchVariable to the value specified by Buffer 1356 and SizeOfBuffer. Buffer is returned. If SizeOfBuffer is greater than 1357 MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return 1358 NULL to indicate that the set operation was not actually performed. 1359 If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 1360 MaximumDatumSize and NULL must be returned. 1361 1362 If PatchVariable is NULL, then ASSERT(). 1363 If SizeOfBuffer is NULL, then ASSERT(). 1364 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT(). 1365 1366 @param[out] PatchVariable A pointer to the global variable in a module that is 1367 the target of the set operation. 1368 @param[in] MaximumDatumSize The maximum size allowed for the PCD entry specified by PatchVariable. 1369 @param[in, out] SizeOfBuffer A pointer to the size, in bytes, of Buffer. 1370 @param[in] Buffer A pointer to the buffer to used to set the target variable. 1371 1372 @return Return the pointer to the buffer been set. 1373 1374 **/ 1375 VOID * 1376 EFIAPI 1377 LibPatchPcdSetPtr ( 1378 OUT VOID *PatchVariable, 1379 IN UINTN MaximumDatumSize, 1380 IN OUT UINTN *SizeOfBuffer, 1381 IN CONST VOID *Buffer 1382 ) 1383 { 1384 ASSERT (PatchVariable != NULL); 1385 ASSERT (SizeOfBuffer != NULL); 1386 1387 if (*SizeOfBuffer > 0) { 1388 ASSERT (Buffer != NULL); 1389 } 1390 1391 if ((*SizeOfBuffer > MaximumDatumSize) || 1392 (*SizeOfBuffer == MAX_ADDRESS)) { 1393 *SizeOfBuffer = MaximumDatumSize; 1394 return NULL; 1395 } 1396 1397 CopyMem (PatchVariable, Buffer, *SizeOfBuffer); 1398 1399 return (VOID *) Buffer; 1400 } 1401 1402 /** 1403 Sets a value of a patchable PCD entry that is type pointer. 1404 1405 Sets the PCD entry specified by PatchVariable to the value specified 1406 by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize, 1407 then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER 1408 to indicate that the set operation was not actually performed. 1409 If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 1410 MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned. 1411 1412 If PatchVariable is NULL, then ASSERT(). 1413 If SizeOfBuffer is NULL, then ASSERT(). 1414 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT(). 1415 1416 @param[out] PatchVariable A pointer to the global variable in a module that is 1417 the target of the set operation. 1418 @param[in] MaximumDatumSize The maximum size allowed for the PCD entry specified by PatchVariable. 1419 @param[in, out] SizeOfBuffer A pointer to the size, in bytes, of Buffer. 1420 @param[in] Buffer A pointer to the buffer to used to set the target variable. 1421 1422 @return The status of the set operation. 1423 1424 **/ 1425 RETURN_STATUS 1426 EFIAPI 1427 LibPatchPcdSetPtrS ( 1428 OUT VOID *PatchVariable, 1429 IN UINTN MaximumDatumSize, 1430 IN OUT UINTN *SizeOfBuffer, 1431 IN CONST VOID *Buffer 1432 ) 1433 { 1434 ASSERT (PatchVariable != NULL); 1435 ASSERT (SizeOfBuffer != NULL); 1436 1437 if (*SizeOfBuffer > 0) { 1438 ASSERT (Buffer != NULL); 1439 } 1440 1441 if ((*SizeOfBuffer > MaximumDatumSize) || 1442 (*SizeOfBuffer == MAX_ADDRESS)) { 1443 *SizeOfBuffer = MaximumDatumSize; 1444 return RETURN_INVALID_PARAMETER; 1445 } 1446 1447 CopyMem (PatchVariable, Buffer, *SizeOfBuffer); 1448 1449 return RETURN_SUCCESS; 1450 } 1451 1452 1453 /** 1454 Sets a value and size of a patchable PCD entry that is type pointer. 1455 1456 Sets the PCD entry specified by PatchVariable to the value specified by Buffer 1457 and SizeOfBuffer. Buffer is returned. If SizeOfBuffer is greater than 1458 MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return 1459 NULL to indicate that the set operation was not actually performed. 1460 If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 1461 MaximumDatumSize and NULL must be returned. 1462 1463 If PatchVariable is NULL, then ASSERT(). 1464 If SizeOfPatchVariable is NULL, then ASSERT(). 1465 If SizeOfBuffer is NULL, then ASSERT(). 1466 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT(). 1467 1468 @param[out] PatchVariable A pointer to the global variable in a module that is 1469 the target of the set operation. 1470 @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable. 1471 @param[in] MaximumDatumSize The maximum size allowed for the PCD entry specified by PatchVariable. 1472 @param[in, out] SizeOfBuffer A pointer to the size, in bytes, of Buffer. 1473 @param[in] Buffer A pointer to the buffer to used to set the target variable. 1474 1475 @return Return the pointer to the buffer been set. 1476 1477 **/ 1478 VOID * 1479 EFIAPI 1480 LibPatchPcdSetPtrAndSize ( 1481 OUT VOID *PatchVariable, 1482 OUT UINTN *SizeOfPatchVariable, 1483 IN UINTN MaximumDatumSize, 1484 IN OUT UINTN *SizeOfBuffer, 1485 IN CONST VOID *Buffer 1486 ) 1487 { 1488 ASSERT (PatchVariable != NULL); 1489 ASSERT (SizeOfPatchVariable != NULL); 1490 ASSERT (SizeOfBuffer != NULL); 1491 1492 if (*SizeOfBuffer > 0) { 1493 ASSERT (Buffer != NULL); 1494 } 1495 1496 if ((*SizeOfBuffer > MaximumDatumSize) || 1497 (*SizeOfBuffer == MAX_ADDRESS)) { 1498 *SizeOfBuffer = MaximumDatumSize; 1499 return NULL; 1500 } 1501 1502 CopyMem (PatchVariable, Buffer, *SizeOfBuffer); 1503 *SizeOfPatchVariable = *SizeOfBuffer; 1504 1505 return (VOID *) Buffer; 1506 } 1507 1508 /** 1509 Sets a value and size of a patchable PCD entry that is type pointer. 1510 1511 Sets the PCD entry specified by PatchVariable to the value specified 1512 by Buffer and SizeOfBuffer. If SizeOfBuffer is greater than MaximumDatumSize, 1513 then set SizeOfBuffer to MaximumDatumSize and return RETURN_INVALID_PARAMETER 1514 to indicate that the set operation was not actually performed. 1515 If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to 1516 MaximumDatumSize and RETURN_INVALID_PARAMETER must be returned. 1517 1518 If PatchVariable is NULL, then ASSERT(). 1519 If SizeOfPatchVariable is NULL, then ASSERT(). 1520 If SizeOfBuffer is NULL, then ASSERT(). 1521 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT(). 1522 1523 @param[out] PatchVariable A pointer to the global variable in a module that is 1524 the target of the set operation. 1525 @param[out] SizeOfPatchVariable A pointer to the size, in bytes, of PatchVariable. 1526 @param[in] MaximumDatumSize The maximum size allowed for the PCD entry specified by PatchVariable. 1527 @param[in, out] SizeOfBuffer A pointer to the size, in bytes, of Buffer. 1528 @param[in] Buffer A pointer to the buffer to used to set the target variable. 1529 1530 @return The status of the set operation. 1531 1532 **/ 1533 RETURN_STATUS 1534 EFIAPI 1535 LibPatchPcdSetPtrAndSizeS ( 1536 OUT VOID *PatchVariable, 1537 OUT UINTN *SizeOfPatchVariable, 1538 IN UINTN MaximumDatumSize, 1539 IN OUT UINTN *SizeOfBuffer, 1540 IN CONST VOID *Buffer 1541 ) 1542 { 1543 ASSERT (PatchVariable != NULL); 1544 ASSERT (SizeOfPatchVariable != NULL); 1545 ASSERT (SizeOfBuffer != NULL); 1546 1547 if (*SizeOfBuffer > 0) { 1548 ASSERT (Buffer != NULL); 1549 } 1550 1551 if ((*SizeOfBuffer > MaximumDatumSize) || 1552 (*SizeOfBuffer == MAX_ADDRESS)) { 1553 *SizeOfBuffer = MaximumDatumSize; 1554 return RETURN_INVALID_PARAMETER; 1555 } 1556 1557 CopyMem (PatchVariable, Buffer, *SizeOfBuffer); 1558 *SizeOfPatchVariable = *SizeOfBuffer; 1559 1560 return RETURN_SUCCESS; 1561 } 1562 1563 /** 1564 Retrieve additional information associated with a PCD token. 1565 1566 This includes information such as the type of value the TokenNumber is associated with as well as possible 1567 human readable name that is associated with the token. 1568 1569 If TokenNumber is not in the default token space specified, then ASSERT(). 1570 1571 @param[in] TokenNumber The PCD token number. 1572 @param[out] PcdInfo The returned information associated with the requested TokenNumber. 1573 The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName. 1574 **/ 1575 VOID 1576 EFIAPI 1577 LibPcdGetInfo ( 1578 IN UINTN TokenNumber, 1579 OUT PCD_INFO *PcdInfo 1580 ) 1581 { 1582 EFI_STATUS Status; 1583 1584 Status = GetPcdInfoPpiPointer()->GetInfo (TokenNumber, (EFI_PCD_INFO *) PcdInfo); 1585 ASSERT_EFI_ERROR (Status); 1586 } 1587 1588 /** 1589 Retrieve additional information associated with a PCD token. 1590 1591 This includes information such as the type of value the TokenNumber is associated with as well as possible 1592 human readable name that is associated with the token. 1593 1594 If TokenNumber is not in the token space specified by Guid, then ASSERT(). 1595 1596 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value. 1597 @param[in] TokenNumber The PCD token number. 1598 @param[out] PcdInfo The returned information associated with the requested TokenNumber. 1599 The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName. 1600 **/ 1601 VOID 1602 EFIAPI 1603 LibPcdGetInfoEx ( 1604 IN CONST GUID *Guid, 1605 IN UINTN TokenNumber, 1606 OUT PCD_INFO *PcdInfo 1607 ) 1608 { 1609 EFI_STATUS Status; 1610 1611 Status = GetPiPcdInfoPpiPointer()->GetInfo (Guid, TokenNumber, (EFI_PCD_INFO *) PcdInfo); 1612 ASSERT_EFI_ERROR (Status); 1613 } 1614 1615 /** 1616 Retrieve the currently set SKU Id. 1617 1618 If the sku id got >= PCD_MAX_SKU_ID, then ASSERT(). 1619 1620 @return The currently set SKU Id. If the platform has not set at a SKU Id, then the 1621 default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU 1622 Id is returned. 1623 **/ 1624 UINTN 1625 EFIAPI 1626 LibPcdGetSku ( 1627 VOID 1628 ) 1629 { 1630 UINTN SkuId; 1631 1632 SkuId = GetPiPcdInfoPpiPointer()->GetSku (); 1633 ASSERT (SkuId < PCD_MAX_SKU_ID); 1634 1635 return SkuId; 1636 } 1637