edk2/MdePkg/Library/BasePcdLibNull/PcdLib.c

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