MdePkg PcdLib: Follow the comment of LibPcdGetNextToken to ASSERT when an invalid...
[mirror_edk2.git] / MdePkg / Library / PeiPcdLib / PeiPcdLib.c
1 /** @file
2 Implementation of PcdLib class library for PEI phase.
3
4 Copyright (c) 2006 - 2013, 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 /**
489 This function provides a means by which to set a value for a given PCD token.
490
491 Sets the 8-bit value for the token specified by TokenNumber
492 to the value specified by Value. Value is returned.
493
494 @param[in] TokenNumber The PCD token number to set a current value for.
495 @param[in] Value The 8-bit value to set.
496
497 @return Return the value that was set.
498
499 **/
500 UINT8
501 EFIAPI
502 LibPcdSet8 (
503 IN UINTN TokenNumber,
504 IN UINT8 Value
505 )
506 {
507 EFI_STATUS Status;
508
509 Status = (GetPcdPpiPointer ())->Set8 (TokenNumber, Value);
510
511 ASSERT_EFI_ERROR (Status);
512
513 return Value;
514 }
515
516
517
518 /**
519 This function provides a means by which to set a value for a given PCD token.
520
521 Sets the 16-bit value for the token specified by TokenNumber
522 to the value specified by Value. Value is returned.
523
524 @param[in] TokenNumber The PCD token number to set a current value for.
525 @param[in] Value The 16-bit value to set.
526
527 @return Return the value that was set.
528
529 **/
530 UINT16
531 EFIAPI
532 LibPcdSet16 (
533 IN UINTN TokenNumber,
534 IN UINT16 Value
535 )
536 {
537 EFI_STATUS Status;
538
539 Status = (GetPcdPpiPointer ())->Set16 (TokenNumber, Value);
540
541 ASSERT_EFI_ERROR (Status);
542
543 return Value;
544 }
545
546
547
548 /**
549 This function provides a means by which to set a value for a given PCD token.
550
551 Sets the 32-bit value for the token specified by TokenNumber
552 to the value specified by Value. Value is returned.
553
554 @param[in] TokenNumber The PCD token number to set a current value for.
555 @param[in] Value The 32-bit value to set.
556
557 @return Return the value that was set.
558
559 **/
560 UINT32
561 EFIAPI
562 LibPcdSet32 (
563 IN UINTN TokenNumber,
564 IN UINT32 Value
565 )
566 {
567 EFI_STATUS Status;
568
569 Status = (GetPcdPpiPointer ())->Set32 (TokenNumber, Value);
570
571 ASSERT_EFI_ERROR (Status);
572
573 return Value;
574 }
575
576
577
578 /**
579 This function provides a means by which to set a value for a given PCD token.
580
581 Sets the 64-bit value for the token specified by TokenNumber
582 to the value specified by Value. Value is returned.
583
584 @param[in] TokenNumber The PCD token number to set a current value for.
585 @param[in] Value The 64-bit value to set.
586
587 @return Return the value that was set.
588
589 **/
590 UINT64
591 EFIAPI
592 LibPcdSet64 (
593 IN UINTN TokenNumber,
594 IN UINT64 Value
595 )
596 {
597 EFI_STATUS Status;
598
599 Status = (GetPcdPpiPointer ())->Set64 (TokenNumber, Value);
600
601 ASSERT_EFI_ERROR (Status);
602
603 return Value;
604 }
605
606
607
608 /**
609 This function provides a means by which to set a value for a given PCD token.
610
611 Sets a buffer for the token specified by TokenNumber to the value
612 specified by Buffer and SizeOfBuffer. Buffer is returned.
613 If SizeOfBuffer is greater than the maximum size support by TokenNumber,
614 then set SizeOfBuffer to the maximum size supported by TokenNumber and
615 return NULL to indicate that the set operation was not actually performed.
616
617 If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the
618 maximum size supported by TokenName and NULL must be returned.
619
620 If SizeOfBuffer is NULL, then ASSERT().
621 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
622
623 @param[in] TokenNumber The PCD token number to set a current value for.
624 @param[in, out] SizeOfBuffer The size, in bytes, of Buffer.
625 @param[in] Buffer A pointer to the buffer to set.
626
627 @return Return the pointer for the buffer been set.
628
629 **/
630 VOID *
631 EFIAPI
632 LibPcdSetPtr (
633 IN UINTN TokenNumber,
634 IN OUT UINTN *SizeOfBuffer,
635 IN CONST VOID *Buffer
636 )
637 {
638 EFI_STATUS Status;
639
640 ASSERT (SizeOfBuffer != NULL);
641
642 if (*SizeOfBuffer > 0) {
643 ASSERT (Buffer != NULL);
644 }
645
646 Status = (GetPcdPpiPointer ())->SetPtr (TokenNumber, SizeOfBuffer, (VOID *) Buffer);
647
648 if (EFI_ERROR (Status)) {
649 return NULL;
650 }
651
652 return (VOID *) Buffer;
653 }
654
655
656
657 /**
658 This function provides a means by which to set a value for a given PCD token.
659
660 Sets the Boolean value for the token specified by TokenNumber
661 to the value specified by Value. Value is returned.
662
663 @param[in] TokenNumber The PCD token number to set a current value for.
664 @param[in] Value The boolean value to set.
665
666 @return Return the value that was set.
667
668 **/
669 BOOLEAN
670 EFIAPI
671 LibPcdSetBool (
672 IN UINTN TokenNumber,
673 IN BOOLEAN Value
674 )
675 {
676 EFI_STATUS Status;
677
678 Status = (GetPcdPpiPointer ())->SetBool (TokenNumber, Value);
679
680 ASSERT_EFI_ERROR (Status);
681
682 return Value;
683 }
684
685
686
687 /**
688 This function provides a means by which to set a value for a given PCD token.
689
690 Sets the 8-bit value for the token specified by TokenNumber and
691 Guid to the value specified by Value. Value is returned.
692
693 If Guid is NULL, then ASSERT().
694
695 @param[in] Guid The pointer to a 128-bit unique value that
696 designates which namespace to set a value from.
697 @param[in] TokenNumber The PCD token number to set a current value for.
698 @param[in] Value The 8-bit value to set.
699
700 @return Return the value that was set.
701
702 **/
703 UINT8
704 EFIAPI
705 LibPcdSetEx8 (
706 IN CONST GUID *Guid,
707 IN UINTN TokenNumber,
708 IN UINT8 Value
709 )
710 {
711 EFI_STATUS Status;
712
713 ASSERT (Guid != NULL);
714
715 Status = (GetPiPcdPpiPointer ())->Set8 (Guid, TokenNumber, Value);
716
717 ASSERT_EFI_ERROR (Status);
718
719 return Value;
720 }
721
722
723
724 /**
725 This function provides a means by which to set a value for a given PCD token.
726
727 Sets the 16-bit value for the token specified by TokenNumber and
728 Guid to the value specified by Value. Value is returned.
729
730 If Guid is NULL, then ASSERT().
731
732 @param[in] Guid The pointer to a 128-bit unique value that
733 designates which namespace to set a value from.
734 @param[in] TokenNumber The PCD token number to set a current value for.
735 @param[in] Value The 16-bit value to set.
736
737 @return Return the value that was set.
738
739 **/
740 UINT16
741 EFIAPI
742 LibPcdSetEx16 (
743 IN CONST GUID *Guid,
744 IN UINTN TokenNumber,
745 IN UINT16 Value
746 )
747 {
748 EFI_STATUS Status;
749 ASSERT (Guid != NULL);
750 Status = (GetPiPcdPpiPointer ())->Set16 (Guid, TokenNumber, Value);
751
752 ASSERT_EFI_ERROR (Status);
753
754 return Value;
755 }
756
757
758
759 /**
760 This function provides a means by which to set a value for a given PCD token.
761
762 Sets the 32-bit value for the token specified by TokenNumber and
763 Guid to the value specified by Value. Value is returned.
764
765 If Guid is NULL, then ASSERT().
766
767 @param[in] Guid The pointer to a 128-bit unique value that
768 designates which namespace to set a value from.
769 @param[in] TokenNumber The PCD token number to set a current value for.
770 @param[in] Value The 32-bit value to set.
771
772 @return Return the value that was set.
773
774 **/
775 UINT32
776 EFIAPI
777 LibPcdSetEx32 (
778 IN CONST GUID *Guid,
779 IN UINTN TokenNumber,
780 IN UINT32 Value
781 )
782 {
783 EFI_STATUS Status;
784
785 ASSERT (Guid != NULL);
786
787 Status = (GetPiPcdPpiPointer ())->Set32 (Guid, TokenNumber, Value);
788
789 ASSERT_EFI_ERROR (Status);
790
791 return Value;
792 }
793
794
795
796 /**
797 This function provides a means by which to set a value for a given PCD token.
798
799 Sets the 64-bit value for the token specified by TokenNumber and
800 Guid to the value specified by Value. Value is returned.
801 If Guid is NULL, then ASSERT().
802
803 @param[in] Guid The pointer to a 128-bit unique value that
804 designates which namespace to set a value from.
805 @param[in] TokenNumber The PCD token number to set a current value for.
806 @param[in] Value The 64-bit value to set.
807
808 @return Return the value that was set.
809
810 **/
811 UINT64
812 EFIAPI
813 LibPcdSetEx64 (
814 IN CONST GUID *Guid,
815 IN UINTN TokenNumber,
816 IN UINT64 Value
817 )
818 {
819 EFI_STATUS Status;
820 ASSERT (Guid != NULL);
821
822 Status = (GetPiPcdPpiPointer ())->Set64 (Guid, TokenNumber, Value);
823
824 ASSERT_EFI_ERROR (Status);
825
826 return Value;
827 }
828
829
830
831 /**
832 This function provides a means by which to set a value for a given PCD token.
833
834 Sets a buffer for the token specified by TokenNumber to the value specified by
835 Buffer and SizeOfBuffer. Buffer is returned. If SizeOfBuffer is greater than
836 the maximum size support by TokenNumber, then set SizeOfBuffer to the maximum size
837 supported by TokenNumber and return NULL to indicate that the set operation
838 was not actually performed.
839
840 If Guid is NULL, then ASSERT().
841 If SizeOfBuffer is NULL, then ASSERT().
842 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
843
844 @param[in] Guid The pointer to a 128-bit unique value that
845 designates which namespace to set a value from.
846 @param[in] TokenNumber The PCD token number to set a current value for.
847 @param[in, out] SizeOfBuffer The size, in bytes, of Buffer.
848 @param[in] Buffer A pointer to the buffer to set.
849
850 @return Return the pinter to the buffer been set.
851
852 **/
853 VOID *
854 EFIAPI
855 LibPcdSetExPtr (
856 IN CONST GUID *Guid,
857 IN UINTN TokenNumber,
858 IN OUT UINTN *SizeOfBuffer,
859 IN VOID *Buffer
860 )
861 {
862 EFI_STATUS Status;
863 ASSERT (SizeOfBuffer != NULL);
864 if (*SizeOfBuffer > 0) {
865 ASSERT (Buffer != NULL);
866 }
867 ASSERT (Guid != NULL);
868
869 Status = (GetPiPcdPpiPointer ())->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer);
870
871 if (EFI_ERROR (Status)) {
872 return NULL;
873 }
874
875 return Buffer;
876 }
877
878
879
880 /**
881 This function provides a means by which to set a value for a given PCD token.
882
883 Sets the Boolean value for the token specified by TokenNumber and
884 Guid to the value specified by Value. Value is returned.
885
886 If Guid is NULL, then ASSERT().
887
888 @param[in] Guid The pointer to a 128-bit unique value that
889 designates which namespace to set a value from.
890 @param[in] TokenNumber The PCD token number to set a current value for.
891 @param[in] Value The Boolean value to set.
892
893 @return Return the value that was set.
894
895 **/
896 BOOLEAN
897 EFIAPI
898 LibPcdSetExBool (
899 IN CONST GUID *Guid,
900 IN UINTN TokenNumber,
901 IN BOOLEAN Value
902 )
903 {
904 EFI_STATUS Status;
905
906 ASSERT (Guid != NULL);
907 Status = (GetPiPcdPpiPointer ())->SetBool (Guid, TokenNumber, Value);
908
909 ASSERT_EFI_ERROR (Status);
910
911 return Value;
912 }
913
914
915
916 /**
917 Set up a notification function that is called when a specified token is set.
918
919 When the token specified by TokenNumber and Guid is set,
920 then notification function specified by NotificationFunction is called.
921 If Guid is NULL, then the default token space is used.
922 If NotificationFunction is NULL, then ASSERT().
923
924 @param[in] Guid The pointer to a 128-bit unique value that
925 designates which namespace to set a value from.
926 If NULL, then the default token space is used.
927 @param[in] TokenNumber The PCD token number to monitor.
928 @param[in] NotificationFunction The function to call when the token
929 specified by Guid and TokenNumber is set.
930
931 **/
932 VOID
933 EFIAPI
934 LibPcdCallbackOnSet (
935 IN CONST GUID *Guid, OPTIONAL
936 IN UINTN TokenNumber,
937 IN PCD_CALLBACK NotificationFunction
938 )
939 {
940 EFI_STATUS Status;
941
942 ASSERT (NotificationFunction != NULL);
943
944 Status = (GetPiPcdPpiPointer ())->CallbackOnSet (Guid, TokenNumber, (EFI_PEI_PCD_PPI_CALLBACK) NotificationFunction);
945
946 ASSERT_EFI_ERROR (Status);
947
948 return;
949 }
950
951
952
953 /**
954 Disable a notification function that was established with LibPcdCallbackonSet().
955
956 Disable a notification function that was previously established with LibPcdCallbackOnSet().
957 If NotificationFunction is NULL, then ASSERT().
958 If LibPcdCallbackOnSet() was not previously called with Guid, TokenNumber,
959 and NotificationFunction, then ASSERT().
960
961 @param[in] Guid Specify the GUID token space.
962 @param[in] TokenNumber Specify the token number.
963 @param[in] NotificationFunction The callback function to be unregistered.
964
965 **/
966 VOID
967 EFIAPI
968 LibPcdCancelCallback (
969 IN CONST GUID *Guid, OPTIONAL
970 IN UINTN TokenNumber,
971 IN PCD_CALLBACK NotificationFunction
972 )
973 {
974 EFI_STATUS Status;
975
976 ASSERT (NotificationFunction != NULL);
977
978 Status = (GetPiPcdPpiPointer ())->CancelCallback (Guid, TokenNumber, (EFI_PEI_PCD_PPI_CALLBACK) NotificationFunction);
979
980 ASSERT_EFI_ERROR (Status);
981
982 return;
983 }
984
985
986
987 /**
988 Retrieves the next token in a token space.
989
990 Retrieves the next PCD token number from the token space specified by Guid.
991 If Guid is NULL, then the default token space is used. If TokenNumber is 0,
992 then the first token number is returned. Otherwise, the token number that
993 follows TokenNumber in the token space is returned. If TokenNumber is the last
994 token number in the token space, then 0 is returned.
995
996 If TokenNumber is not 0 and is not in the token space specified by Guid, then ASSERT().
997
998 @param[in] Guid The pointer to a 128-bit unique value that designates which namespace
999 to set a value from. If NULL, then the default token space is used.
1000 @param[in] TokenNumber The previous PCD token number. If 0, then retrieves the first PCD
1001 token number.
1002
1003 @return The next valid token number.
1004
1005 **/
1006 UINTN
1007 EFIAPI
1008 LibPcdGetNextToken (
1009 IN CONST GUID *Guid, OPTIONAL
1010 IN UINTN TokenNumber
1011 )
1012 {
1013 EFI_STATUS Status;
1014
1015 Status = (GetPiPcdPpiPointer ())->GetNextToken (Guid, &TokenNumber);
1016 ASSERT (!EFI_ERROR (Status) || TokenNumber == 0);
1017
1018 return TokenNumber;
1019 }
1020
1021
1022 /**
1023 Used to retrieve the list of available PCD token space GUIDs.
1024
1025 Returns the PCD token space GUID that follows TokenSpaceGuid in the list of token spaces
1026 in the platform.
1027 If TokenSpaceGuid is NULL, then a pointer to the first PCD token spaces returned.
1028 If TokenSpaceGuid is the last PCD token space GUID in the list, then NULL is returned.
1029
1030 @param TokenSpaceGuid The pointer to the a PCD token space GUID
1031
1032 @return The next valid token namespace.
1033
1034 **/
1035 GUID *
1036 EFIAPI
1037 LibPcdGetNextTokenSpace (
1038 IN CONST GUID *TokenSpaceGuid
1039 )
1040 {
1041 (GetPiPcdPpiPointer ())->GetNextTokenSpace (&TokenSpaceGuid);
1042
1043 return (GUID *) TokenSpaceGuid;
1044 }
1045
1046
1047
1048 /**
1049 Sets a value of a patchable PCD entry that is type pointer.
1050
1051 Sets the PCD entry specified by PatchVariable to the value specified by Buffer
1052 and SizeOfBuffer. Buffer is returned. If SizeOfBuffer is greater than
1053 MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return
1054 NULL to indicate that the set operation was not actually performed.
1055 If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
1056 MaximumDatumSize and NULL must be returned.
1057
1058 If PatchVariable is NULL, then ASSERT().
1059 If SizeOfBuffer is NULL, then ASSERT().
1060 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
1061
1062 @param[in] PatchVariable A pointer to the global variable in a module that is
1063 the target of the set operation.
1064 @param[in] MaximumDatumSize The maximum size allowed for the PCD entry specified by PatchVariable.
1065 @param[in, out] SizeOfBuffer A pointer to the size, in bytes, of Buffer.
1066 @param[in] Buffer A pointer to the buffer to used to set the target variable.
1067
1068 @return Return the pointer to the buffer been set.
1069
1070 **/
1071 VOID *
1072 EFIAPI
1073 LibPatchPcdSetPtr (
1074 IN VOID *PatchVariable,
1075 IN UINTN MaximumDatumSize,
1076 IN OUT UINTN *SizeOfBuffer,
1077 IN CONST VOID *Buffer
1078 )
1079 {
1080 ASSERT (PatchVariable != NULL);
1081 ASSERT (SizeOfBuffer != NULL);
1082
1083 if (*SizeOfBuffer > 0) {
1084 ASSERT (Buffer != NULL);
1085 }
1086
1087 if ((*SizeOfBuffer > MaximumDatumSize) ||
1088 (*SizeOfBuffer == MAX_ADDRESS)) {
1089 *SizeOfBuffer = MaximumDatumSize;
1090 return NULL;
1091 }
1092
1093 CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
1094
1095 return (VOID *) Buffer;
1096 }
1097
1098 /**
1099 Retrieve additional information associated with a PCD token.
1100
1101 This includes information such as the type of value the TokenNumber is associated with as well as possible
1102 human readable name that is associated with the token.
1103
1104 If TokenNumber is not in the default token space specified, then ASSERT().
1105
1106 @param[in] TokenNumber The PCD token number.
1107 @param[out] PcdInfo The returned information associated with the requested TokenNumber.
1108 The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
1109 **/
1110 VOID
1111 EFIAPI
1112 LibPcdGetInfo (
1113 IN UINTN TokenNumber,
1114 OUT PCD_INFO *PcdInfo
1115 )
1116 {
1117 EFI_STATUS Status;
1118
1119 Status = GetPcdInfoPpiPointer()->GetInfo (TokenNumber, (EFI_PCD_INFO *) PcdInfo);
1120 ASSERT_EFI_ERROR (Status);
1121 }
1122
1123 /**
1124 Retrieve additional information associated with a PCD token.
1125
1126 This includes information such as the type of value the TokenNumber is associated with as well as possible
1127 human readable name that is associated with the token.
1128
1129 If TokenNumber is not in the token space specified by Guid, then ASSERT().
1130
1131 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
1132 @param[in] TokenNumber The PCD token number.
1133 @param[out] PcdInfo The returned information associated with the requested TokenNumber.
1134 The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
1135 **/
1136 VOID
1137 EFIAPI
1138 LibPcdGetInfoEx (
1139 IN CONST GUID *Guid,
1140 IN UINTN TokenNumber,
1141 OUT PCD_INFO *PcdInfo
1142 )
1143 {
1144 EFI_STATUS Status;
1145
1146 Status = GetPiPcdInfoPpiPointer()->GetInfo (Guid, TokenNumber, (EFI_PCD_INFO *) PcdInfo);
1147 ASSERT_EFI_ERROR (Status);
1148 }
1149
1150 /**
1151 Retrieve the currently set SKU Id.
1152
1153 If the sku id got >= PCD_MAX_SKU_ID, then ASSERT().
1154
1155 @return The currently set SKU Id. If the platform has not set at a SKU Id, then the
1156 default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
1157 Id is returned.
1158 **/
1159 UINTN
1160 EFIAPI
1161 LibPcdGetSku (
1162 VOID
1163 )
1164 {
1165 UINTN SkuId;
1166
1167 SkuId = GetPiPcdInfoPpiPointer()->GetSku ();
1168 ASSERT (SkuId < PCD_MAX_SKU_ID);
1169
1170 return SkuId;
1171 }