MdePkg PcdLib: Follow the comment of LibPcdGetNextToken to ASSERT when an invalid...
[mirror_edk2.git] / MdePkg / Library / DxePcdLib / DxePcdLib.c
1 /** @file
2 Implementation of PcdLib class library for DXE 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 #include <PiDxe.h>
18
19 #include <Protocol/Pcd.h>
20 #include <Protocol/PiPcd.h>
21 #include <Protocol/PcdInfo.h>
22 #include <Protocol/PiPcdInfo.h>
23
24 #include <Library/PcdLib.h>
25 #include <Library/DebugLib.h>
26 #include <Library/UefiBootServicesTableLib.h>
27 #include <Library/BaseMemoryLib.h>
28
29 PCD_PROTOCOL *mPcd = NULL;
30 EFI_PCD_PROTOCOL *mPiPcd = NULL;
31 GET_PCD_INFO_PROTOCOL *mPcdInfo = NULL;
32 EFI_GET_PCD_INFO_PROTOCOL *mPiPcdInfo = NULL;
33
34 /**
35 Retrieves the PI PCD protocol from the handle database.
36
37 @retval EFI_PCD_PROTOCOL * The pointer to the EFI_PCD_PROTOCOL.
38 **/
39 EFI_PCD_PROTOCOL *
40 EFIAPI
41 GetPiPcdProtocol (
42 VOID
43 )
44 {
45 EFI_STATUS Status;
46
47 if (mPiPcd == NULL) {
48 //
49 // PI Pcd protocol defined in PI 1.2 vol3 should be installed before the module
50 // access DynamicEx type PCD.
51 //
52 Status = gBS->LocateProtocol (&gEfiPcdProtocolGuid, NULL, (VOID **) &mPiPcd);
53 ASSERT_EFI_ERROR (Status);
54 ASSERT (mPiPcd != NULL);
55 }
56 return mPiPcd;
57 }
58
59 /**
60 Retrieves the PCD protocol from the handle database.
61
62 @retval PCD_PROTOCOL * The pointer to the PCD_PROTOCOL.
63 **/
64 PCD_PROTOCOL *
65 EFIAPI
66 GetPcdProtocol (
67 VOID
68 )
69 {
70 EFI_STATUS Status;
71
72 if (mPcd == NULL) {
73 //
74 // PCD protocol need to be installed before the module access Dynamic type PCD.
75 // But dynamic type PCD is not required in PI 1.2 specification.
76 //
77 Status = gBS->LocateProtocol (&gPcdProtocolGuid, NULL, (VOID **)&mPcd);
78 ASSERT_EFI_ERROR (Status);
79 ASSERT (mPcd != NULL);
80 }
81 return mPcd;
82 }
83
84 /**
85 Retrieves the PI PCD info protocol from the handle database.
86
87 @retval EFI_GET_PCD_INFO_PROTOCOL * The pointer to the EFI_GET_PCD_INFO_PROTOCOL defined in PI 1.2.1 Vol 3.
88 **/
89 EFI_GET_PCD_INFO_PROTOCOL *
90 GetPiPcdInfoProtocolPointer (
91 VOID
92 )
93 {
94 EFI_STATUS Status;
95
96 if (mPiPcdInfo == NULL) {
97 Status = gBS->LocateProtocol (&gEfiGetPcdInfoProtocolGuid, NULL, (VOID **)&mPiPcdInfo);
98 ASSERT_EFI_ERROR (Status);
99 ASSERT (mPiPcdInfo != NULL);
100 }
101 return mPiPcdInfo;
102 }
103
104 /**
105 Retrieves the PCD info protocol from the handle database.
106
107 @retval GET_PCD_INFO_PROTOCOL * The pointer to the GET_PCD_INFO_PROTOCOL.
108 **/
109 GET_PCD_INFO_PROTOCOL *
110 GetPcdInfoProtocolPointer (
111 VOID
112 )
113 {
114 EFI_STATUS Status;
115
116 if (mPcdInfo == NULL) {
117 Status = gBS->LocateProtocol (&gGetPcdInfoProtocolGuid, NULL, (VOID **)&mPcdInfo);
118 ASSERT_EFI_ERROR (Status);
119 ASSERT (mPcdInfo != NULL);
120 }
121 return mPcdInfo;
122 }
123
124 /**
125 This function provides a means by which SKU support can be established in the PCD infrastructure.
126
127 Sets the current SKU in the PCD database to the value specified by SkuId. SkuId is returned.
128 If SkuId >= PCD_MAX_SKU_ID, then ASSERT().
129
130 @param SkuId The SKU value that will be used when the PCD service retrieves and sets values
131 associated with a PCD token.
132
133 @return Return the SKU ID that just be set.
134
135 **/
136 UINTN
137 EFIAPI
138 LibPcdSetSku (
139 IN UINTN SkuId
140 )
141 {
142 ASSERT (SkuId < PCD_MAX_SKU_ID);
143
144 GetPcdProtocol()->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 GetPcdProtocol()->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 GetPcdProtocol()->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 GetPcdProtocol()->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 GetPcdProtocol()->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 GetPcdProtocol()->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 GetPcdProtocol()->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 GetPcdProtocol()->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 GetPiPcdProtocol()->Get8 (Guid, TokenNumber);
320 }
321
322
323 /**
324 This function provides a means by which to retrieve a value for a given PCD token.
325
326 Returns the 16-bit value for the token specified by TokenNumber and Guid.
327
328 If Guid is NULL, then ASSERT().
329
330 @param[in] Guid The pointer to a 128-bit unique value that designates
331 which namespace to retrieve a value from.
332 @param[in] TokenNumber The PCD token number to retrieve a current value for.
333
334 @return Return the UINT16.
335
336 **/
337 UINT16
338 EFIAPI
339 LibPcdGetEx16 (
340 IN CONST GUID *Guid,
341 IN UINTN TokenNumber
342 )
343 {
344 ASSERT (Guid != NULL);
345
346 return GetPiPcdProtocol()->Get16 (Guid, TokenNumber);
347 }
348
349
350 /**
351 Returns the 32-bit value for the token specified by TokenNumber and Guid.
352 If Guid is NULL, then ASSERT().
353
354 @param[in] Guid The pointer to a 128-bit unique value that designates
355 which namespace to retrieve a value from.
356 @param[in] TokenNumber The PCD token number to retrieve a current value for.
357
358 @return Return the UINT32.
359
360 **/
361 UINT32
362 EFIAPI
363 LibPcdGetEx32 (
364 IN CONST GUID *Guid,
365 IN UINTN TokenNumber
366 )
367 {
368 ASSERT (Guid != NULL);
369
370 return GetPiPcdProtocol()->Get32 (Guid, TokenNumber);
371 }
372
373
374
375 /**
376 This function provides a means by which to retrieve a value for a given PCD token.
377
378 Returns the 64-bit value for the token specified by TokenNumber and Guid.
379
380 If Guid is NULL, then ASSERT().
381
382 @param[in] Guid The pointer to a 128-bit unique value that designates
383 which namespace to retrieve a value from.
384 @param[in] TokenNumber The PCD token number to retrieve a current value for.
385
386 @return Return the UINT64.
387
388 **/
389 UINT64
390 EFIAPI
391 LibPcdGetEx64 (
392 IN CONST GUID *Guid,
393 IN UINTN TokenNumber
394 )
395 {
396 ASSERT (Guid != NULL);
397
398 return GetPiPcdProtocol()->Get64 (Guid, TokenNumber);
399 }
400
401
402
403 /**
404 This function provides a means by which to retrieve a value for a given PCD token.
405
406 Returns the pointer to the buffer of token specified by TokenNumber and Guid.
407
408 If Guid is NULL, then ASSERT().
409
410 @param[in] Guid The pointer to a 128-bit unique value that designates
411 which namespace to retrieve a value from.
412 @param[in] TokenNumber The PCD token number to retrieve a current value for.
413
414 @return Return the VOID* pointer.
415
416 **/
417 VOID *
418 EFIAPI
419 LibPcdGetExPtr (
420 IN CONST GUID *Guid,
421 IN UINTN TokenNumber
422 )
423 {
424 ASSERT (Guid != NULL);
425
426 return GetPiPcdProtocol()->GetPtr (Guid, TokenNumber);
427 }
428
429
430
431 /**
432 This function provides a means by which to retrieve a value for a given PCD token.
433
434 Returns the Boolean value of the token specified by TokenNumber and Guid.
435
436 If Guid is NULL, then ASSERT().
437
438 @param[in] Guid The pointer to a 128-bit unique value that designates
439 which namespace to retrieve a value from.
440 @param[in] TokenNumber The PCD token number to retrieve a current value for.
441
442 @return Return the BOOLEAN.
443
444 **/
445 BOOLEAN
446 EFIAPI
447 LibPcdGetExBool (
448 IN CONST GUID *Guid,
449 IN UINTN TokenNumber
450 )
451 {
452 ASSERT (Guid != NULL);
453
454 return GetPiPcdProtocol()->GetBool (Guid, TokenNumber);
455 }
456
457
458
459 /**
460 This function provides a means by which to retrieve the size of a given PCD token.
461
462 Returns the size of the token specified by TokenNumber and Guid.
463
464 If Guid is NULL, then ASSERT().
465
466 @param[in] Guid The pointer to a 128-bit unique value that designates
467 which namespace to retrieve a value from.
468 @param[in] TokenNumber The PCD token number to retrieve a current value for.
469
470 @return Return the size.
471
472 **/
473 UINTN
474 EFIAPI
475 LibPcdGetExSize (
476 IN CONST GUID *Guid,
477 IN UINTN TokenNumber
478 )
479 {
480 ASSERT (Guid != NULL);
481
482 return GetPiPcdProtocol()->GetSize (Guid, TokenNumber);
483 }
484
485
486
487 /**
488 This function provides a means by which to set a value for a given PCD token.
489
490 Sets the 8-bit value for the token specified by TokenNumber
491 to the value specified by Value. Value is returned.
492
493 @param[in] TokenNumber The PCD token number to set a current value for.
494 @param[in] Value The 8-bit value to set.
495
496 @return Return the value that was set.
497
498 **/
499 UINT8
500 EFIAPI
501 LibPcdSet8 (
502 IN UINTN TokenNumber,
503 IN UINT8 Value
504 )
505 {
506 EFI_STATUS Status;
507
508 Status = GetPcdProtocol()->Set8 (TokenNumber, Value);
509 ASSERT_EFI_ERROR (Status);
510
511 return Value;
512 }
513
514
515
516 /**
517 This function provides a means by which to set a value for a given PCD token.
518
519 Sets the 16-bit value for the token specified by TokenNumber
520 to the value specified by Value. Value is returned.
521
522 @param[in] TokenNumber The PCD token number to set a current value for.
523 @param[in] Value The 16-bit value to set.
524
525 @return Return the value that was set.
526
527 **/
528 UINT16
529 EFIAPI
530 LibPcdSet16 (
531 IN UINTN TokenNumber,
532 IN UINT16 Value
533 )
534 {
535 EFI_STATUS Status;
536
537 Status = GetPcdProtocol()->Set16 (TokenNumber, Value);
538 ASSERT_EFI_ERROR (Status);
539
540 return Value;
541 }
542
543
544
545 /**
546 This function provides a means by which to set a value for a given PCD token.
547
548 Sets the 32-bit value for the token specified by TokenNumber
549 to the value specified by Value. Value is returned.
550
551 @param[in] TokenNumber The PCD token number to set a current value for.
552 @param[in] Value The 32-bit value to set.
553
554 @return Return the value that was set.
555
556 **/
557 UINT32
558 EFIAPI
559 LibPcdSet32 (
560 IN UINTN TokenNumber,
561 IN UINT32 Value
562 )
563 {
564 EFI_STATUS Status;
565
566 Status = GetPcdProtocol()->Set32 (TokenNumber, Value);
567 ASSERT_EFI_ERROR (Status);
568
569 return Value;
570 }
571
572
573
574 /**
575 This function provides a means by which to set a value for a given PCD token.
576
577 Sets the 64-bit value for the token specified by TokenNumber
578 to the value specified by Value. Value is returned.
579
580 @param[in] TokenNumber The PCD token number to set a current value for.
581 @param[in] Value The 64-bit value to set.
582
583 @return Return the value that was set.
584
585 **/
586 UINT64
587 EFIAPI
588 LibPcdSet64 (
589 IN UINTN TokenNumber,
590 IN UINT64 Value
591 )
592 {
593 EFI_STATUS Status;
594
595 Status = GetPcdProtocol()->Set64 (TokenNumber, Value);
596 ASSERT_EFI_ERROR (Status);
597
598 return Value;
599 }
600
601
602
603 /**
604 This function provides a means by which to set a value for a given PCD token.
605
606 Sets a buffer for the token specified by TokenNumber to the value
607 specified by Buffer and SizeOfBuffer. Buffer is returned.
608 If SizeOfBuffer is greater than the maximum size support by TokenNumber,
609 then set SizeOfBuffer to the maximum size supported by TokenNumber and
610 return NULL to indicate that the set operation was not actually performed.
611
612 If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the
613 maximum size supported by TokenName and NULL must be returned.
614
615 If SizeOfBuffer is NULL, then ASSERT().
616 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
617
618 @param[in] TokenNumber The PCD token number to set a current value for.
619 @param[in, out] SizeOfBuffer The size, in bytes, of Buffer.
620 @param[in] Buffer A pointer to the buffer to set.
621
622 @return Return the pointer for the buffer been set.
623
624 **/
625 VOID *
626 EFIAPI
627 LibPcdSetPtr (
628 IN UINTN TokenNumber,
629 IN OUT UINTN *SizeOfBuffer,
630 IN CONST VOID *Buffer
631 )
632 {
633 EFI_STATUS Status;
634
635 ASSERT (SizeOfBuffer != NULL);
636
637 if (*SizeOfBuffer > 0) {
638 ASSERT (Buffer != NULL);
639 }
640
641 Status = GetPcdProtocol()->SetPtr (TokenNumber, SizeOfBuffer, (VOID *) Buffer);
642 if (EFI_ERROR (Status)) {
643 return NULL;
644 }
645
646 return (VOID *)Buffer;
647 }
648
649
650
651 /**
652 This function provides a means by which to set a value for a given PCD token.
653
654 Sets the Boolean value for the token specified by TokenNumber
655 to the value specified by Value. Value is returned.
656
657 @param[in] TokenNumber The PCD token number to set a current value for.
658 @param[in] Value The boolean value to set.
659
660 @return Return the value that was set.
661
662 **/
663 BOOLEAN
664 EFIAPI
665 LibPcdSetBool (
666 IN UINTN TokenNumber,
667 IN BOOLEAN Value
668 )
669 {
670 EFI_STATUS Status;
671
672 Status = GetPcdProtocol()->SetBool (TokenNumber, Value);
673 ASSERT_EFI_ERROR (Status);
674
675 return Value;
676 }
677
678
679
680 /**
681 This function provides a means by which to set a value for a given PCD token.
682
683 Sets the 8-bit value for the token specified by TokenNumber and
684 Guid to the value specified by Value. Value is returned.
685
686 If Guid is NULL, then ASSERT().
687
688 @param[in] Guid The pointer to a 128-bit unique value that
689 designates which namespace to set a value from.
690 @param[in] TokenNumber The PCD token number to set a current value for.
691 @param[in] Value The 8-bit value to set.
692
693 @return Return the value that was set.
694
695 **/
696 UINT8
697 EFIAPI
698 LibPcdSetEx8 (
699 IN CONST GUID *Guid,
700 IN UINTN TokenNumber,
701 IN UINT8 Value
702 )
703 {
704 EFI_STATUS Status;
705
706 ASSERT (Guid != NULL);
707
708 Status = GetPiPcdProtocol()->Set8 (Guid, TokenNumber, Value);
709 ASSERT_EFI_ERROR (Status);
710
711 return Value;
712 }
713
714
715
716 /**
717 This function provides a means by which to set a value for a given PCD token.
718
719 Sets the 16-bit value for the token specified by TokenNumber and
720 Guid to the value specified by Value. Value is returned.
721
722 If Guid is NULL, then ASSERT().
723
724 @param[in] Guid The pointer to a 128-bit unique value that
725 designates which namespace to set a value from.
726 @param[in] TokenNumber The PCD token number to set a current value for.
727 @param[in] Value The 16-bit value to set.
728
729 @return Return the value that was set.
730
731 **/
732 UINT16
733 EFIAPI
734 LibPcdSetEx16 (
735 IN CONST GUID *Guid,
736 IN UINTN TokenNumber,
737 IN UINT16 Value
738 )
739 {
740 EFI_STATUS Status;
741
742 ASSERT (Guid != NULL);
743
744 Status = GetPiPcdProtocol()->Set16 (Guid, TokenNumber, Value);
745 ASSERT_EFI_ERROR (Status);
746
747 return Value;
748 }
749
750
751
752 /**
753 This function provides a means by which to set a value for a given PCD token.
754
755 Sets the 32-bit value for the token specified by TokenNumber and
756 Guid to the value specified by Value. Value is returned.
757
758 If Guid is NULL, then ASSERT().
759
760 @param[in] Guid The pointer to a 128-bit unique value that
761 designates which namespace to set a value from.
762 @param[in] TokenNumber The PCD token number to set a current value for.
763 @param[in] Value The 32-bit value to set.
764
765 @return Return the value that was set.
766
767 **/
768 UINT32
769 EFIAPI
770 LibPcdSetEx32 (
771 IN CONST GUID *Guid,
772 IN UINTN TokenNumber,
773 IN UINT32 Value
774 )
775 {
776 EFI_STATUS Status;
777
778 ASSERT (Guid != NULL);
779
780 Status = GetPiPcdProtocol()->Set32 (Guid, TokenNumber, Value);
781 ASSERT_EFI_ERROR (Status);
782
783 return Value;
784 }
785
786
787
788 /**
789 This function provides a means by which to set a value for a given PCD token.
790
791 Sets the 64-bit value for the token specified by TokenNumber and
792 Guid to the value specified by Value. Value is returned.
793 If Guid is NULL, then ASSERT().
794
795 @param[in] Guid The pointer to a 128-bit unique value that
796 designates which namespace to set a value from.
797 @param[in] TokenNumber The PCD token number to set a current value for.
798 @param[in] Value The 64-bit value to set.
799
800 @return Return the value that was set.
801
802 **/
803 UINT64
804 EFIAPI
805 LibPcdSetEx64 (
806 IN CONST GUID *Guid,
807 IN UINTN TokenNumber,
808 IN UINT64 Value
809 )
810 {
811 EFI_STATUS Status;
812
813 ASSERT (Guid != NULL);
814
815 Status = GetPiPcdProtocol()->Set64 (Guid, TokenNumber, Value);
816 ASSERT_EFI_ERROR (Status);
817
818 return Value;
819 }
820
821
822
823 /**
824 This function provides a means by which to set a value for a given PCD token.
825
826 Sets a buffer for the token specified by TokenNumber to the value specified by
827 Buffer and SizeOfBuffer. Buffer is returned. If SizeOfBuffer is greater than
828 the maximum size support by TokenNumber, then set SizeOfBuffer to the maximum size
829 supported by TokenNumber and return NULL to indicate that the set operation
830 was not actually performed.
831
832 If Guid is NULL, then ASSERT().
833 If SizeOfBuffer is NULL, then ASSERT().
834 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
835
836 @param[in] Guid The pointer to a 128-bit unique value that
837 designates which namespace to set a value from.
838 @param[in] TokenNumber The PCD token number to set a current value for.
839 @param[in, out] SizeOfBuffer The size, in bytes, of Buffer.
840 @param[in] Buffer A pointer to the buffer to set.
841
842 @return Return the pointer to the buffer been set.
843
844 **/
845 VOID *
846 EFIAPI
847 LibPcdSetExPtr (
848 IN CONST GUID *Guid,
849 IN UINTN TokenNumber,
850 IN OUT UINTN *SizeOfBuffer,
851 IN VOID *Buffer
852 )
853 {
854 EFI_STATUS Status;
855
856 ASSERT (Guid != NULL);
857
858 ASSERT (SizeOfBuffer != NULL);
859
860 if (*SizeOfBuffer > 0) {
861 ASSERT (Buffer != NULL);
862 }
863
864 Status = GetPiPcdProtocol()->SetPtr (Guid, TokenNumber, SizeOfBuffer, Buffer);
865 if (EFI_ERROR (Status)) {
866 return NULL;
867 }
868
869 return Buffer;
870 }
871
872
873
874 /**
875 This function provides a means by which to set a value for a given PCD token.
876
877 Sets the Boolean value for the token specified by TokenNumber and
878 Guid to the value specified by Value. Value is returned.
879
880 If Guid is NULL, then ASSERT().
881
882 @param[in] Guid The pointer to a 128-bit unique value that
883 designates which namespace to set a value from.
884 @param[in] TokenNumber The PCD token number to set a current value for.
885 @param[in] Value The Boolean value to set.
886
887 @return Return the value that was set.
888
889 **/
890 BOOLEAN
891 EFIAPI
892 LibPcdSetExBool (
893 IN CONST GUID *Guid,
894 IN UINTN TokenNumber,
895 IN BOOLEAN Value
896 )
897 {
898 EFI_STATUS Status;
899
900 ASSERT (Guid != NULL);
901
902 Status = GetPiPcdProtocol()->SetBool (Guid, TokenNumber, Value);
903 ASSERT_EFI_ERROR (Status);
904
905 return Value;
906 }
907
908
909
910 /**
911 Set up a notification function that is called when a specified token is set.
912
913 When the token specified by TokenNumber and Guid is set,
914 then notification function specified by NotificationFunction is called.
915 If Guid is NULL, then the default token space is used.
916 If NotificationFunction is NULL, then ASSERT().
917
918 @param[in] Guid The pointer to a 128-bit unique value that designates which
919 namespace to set a value from. If NULL, then the default
920 token space is used.
921 @param[in] TokenNumber The PCD token number to monitor.
922 @param[in] NotificationFunction The function to call when the token
923 specified by Guid and TokenNumber is set.
924
925 **/
926 VOID
927 EFIAPI
928 LibPcdCallbackOnSet (
929 IN CONST GUID *Guid, OPTIONAL
930 IN UINTN TokenNumber,
931 IN PCD_CALLBACK NotificationFunction
932 )
933 {
934 EFI_STATUS Status;
935
936 ASSERT (NotificationFunction != NULL);
937
938 Status = GetPiPcdProtocol()->CallbackOnSet (Guid, TokenNumber, (EFI_PCD_PROTOCOL_CALLBACK) NotificationFunction);
939 ASSERT_EFI_ERROR (Status);
940
941 return;
942 }
943
944
945
946 /**
947 Disable a notification function that was established with LibPcdCallbackonSet().
948
949 Disable a notification function that was previously established with LibPcdCallbackOnSet().
950 If NotificationFunction is NULL, then ASSERT().
951 If LibPcdCallbackOnSet() was not previously called with Guid, TokenNumber,
952 and NotificationFunction, then ASSERT().
953
954 @param[in] Guid Specify the GUID token space.
955 @param[in] TokenNumber Specify the token number.
956 @param[in] NotificationFunction The callback function to be unregistered.
957
958 **/
959 VOID
960 EFIAPI
961 LibPcdCancelCallback (
962 IN CONST GUID *Guid, OPTIONAL
963 IN UINTN TokenNumber,
964 IN PCD_CALLBACK NotificationFunction
965 )
966 {
967 EFI_STATUS Status;
968
969 ASSERT (NotificationFunction != NULL);
970
971 Status = GetPiPcdProtocol()->CancelCallback (Guid, TokenNumber, (EFI_PCD_PROTOCOL_CALLBACK) NotificationFunction);
972 ASSERT_EFI_ERROR (Status);
973
974 return;
975 }
976
977
978
979 /**
980 Retrieves the next token in a token space.
981
982 Retrieves the next PCD token number from the token space specified by Guid.
983 If Guid is NULL, then the default token space is used. If TokenNumber is 0,
984 then the first token number is returned. Otherwise, the token number that
985 follows TokenNumber in the token space is returned. If TokenNumber is the last
986 token number in the token space, then 0 is returned.
987
988 If TokenNumber is not 0 and is not in the token space specified by Guid, then ASSERT().
989
990 @param[in] Guid The pointer to a 128-bit unique value that designates which namespace
991 to set a value from. If NULL, then the default token space is used.
992 @param[in] TokenNumber The previous PCD token number. If 0, then retrieves the first PCD
993 token number.
994
995 @return The next valid token number.
996
997 **/
998 UINTN
999 EFIAPI
1000 LibPcdGetNextToken (
1001 IN CONST GUID *Guid, OPTIONAL
1002 IN UINTN TokenNumber
1003 )
1004 {
1005 EFI_STATUS Status;
1006
1007 Status = GetPiPcdProtocol()->GetNextToken (Guid, &TokenNumber);
1008 ASSERT (!EFI_ERROR (Status) || TokenNumber == 0);
1009
1010 return TokenNumber;
1011 }
1012
1013
1014
1015 /**
1016 Used to retrieve the list of available PCD token space GUIDs.
1017
1018 Returns the PCD token space GUID that follows TokenSpaceGuid in the list of token spaces
1019 in the platform.
1020 If TokenSpaceGuid is NULL, then a pointer to the first PCD token spaces returned.
1021 If TokenSpaceGuid is the last PCD token space GUID in the list, then NULL is returned.
1022
1023 @param TokenSpaceGuid The pointer to the a PCD token space GUID.
1024
1025 @return The next valid token namespace.
1026
1027 **/
1028 GUID *
1029 EFIAPI
1030 LibPcdGetNextTokenSpace (
1031 IN CONST GUID *TokenSpaceGuid
1032 )
1033 {
1034 GetPiPcdProtocol()->GetNextTokenSpace (&TokenSpaceGuid);
1035
1036 return (GUID *)TokenSpaceGuid;
1037 }
1038
1039
1040 /**
1041 Sets a value of a patchable PCD entry that is type pointer.
1042
1043 Sets the PCD entry specified by PatchVariable to the value specified by Buffer
1044 and SizeOfBuffer. Buffer is returned. If SizeOfBuffer is greater than
1045 MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return
1046 NULL to indicate that the set operation was not actually performed.
1047 If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
1048 MaximumDatumSize and NULL must be returned.
1049
1050 If PatchVariable is NULL, then ASSERT().
1051 If SizeOfBuffer is NULL, then ASSERT().
1052 If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
1053
1054 @param[in] PatchVariable A pointer to the global variable in a module that is
1055 the target of the set operation.
1056 @param[in] MaximumDatumSize The maximum size allowed for the PCD entry specified by PatchVariable.
1057 @param[in, out] SizeOfBuffer A pointer to the size, in bytes, of Buffer.
1058 @param[in] Buffer A pointer to the buffer to used to set the target variable.
1059
1060 @return Return the pointer to the buffer been set.
1061
1062 **/
1063 VOID *
1064 EFIAPI
1065 LibPatchPcdSetPtr (
1066 IN VOID *PatchVariable,
1067 IN UINTN MaximumDatumSize,
1068 IN OUT UINTN *SizeOfBuffer,
1069 IN CONST VOID *Buffer
1070 )
1071 {
1072 ASSERT (PatchVariable != NULL);
1073 ASSERT (SizeOfBuffer != NULL);
1074
1075 if (*SizeOfBuffer > 0) {
1076 ASSERT (Buffer != NULL);
1077 }
1078
1079 if ((*SizeOfBuffer > MaximumDatumSize) ||
1080 (*SizeOfBuffer == MAX_ADDRESS)) {
1081 *SizeOfBuffer = MaximumDatumSize;
1082 return NULL;
1083 }
1084
1085 CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
1086
1087 return (VOID *) Buffer;
1088 }
1089
1090 /**
1091 Retrieve additional information associated with a PCD token.
1092
1093 This includes information such as the type of value the TokenNumber is associated with as well as possible
1094 human readable name that is associated with the token.
1095
1096 If TokenNumber is not in the default token space specified, then ASSERT().
1097
1098 @param[in] TokenNumber The PCD token number.
1099 @param[out] PcdInfo The returned information associated with the requested TokenNumber.
1100 The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
1101 **/
1102 VOID
1103 EFIAPI
1104 LibPcdGetInfo (
1105 IN UINTN TokenNumber,
1106 OUT PCD_INFO *PcdInfo
1107 )
1108 {
1109 EFI_STATUS Status;
1110
1111 Status = GetPcdInfoProtocolPointer()->GetInfo (TokenNumber, (EFI_PCD_INFO *) PcdInfo);
1112 ASSERT_EFI_ERROR (Status);
1113 }
1114
1115 /**
1116 Retrieve additional information associated with a PCD token.
1117
1118 This includes information such as the type of value the TokenNumber is associated with as well as possible
1119 human readable name that is associated with the token.
1120
1121 If TokenNumber is not in the token space specified by Guid, then ASSERT().
1122
1123 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
1124 @param[in] TokenNumber The PCD token number.
1125 @param[out] PcdInfo The returned information associated with the requested TokenNumber.
1126 The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
1127 **/
1128 VOID
1129 EFIAPI
1130 LibPcdGetInfoEx (
1131 IN CONST GUID *Guid,
1132 IN UINTN TokenNumber,
1133 OUT PCD_INFO *PcdInfo
1134 )
1135 {
1136 EFI_STATUS Status;
1137
1138 Status = GetPiPcdInfoProtocolPointer()->GetInfo (Guid, TokenNumber, (EFI_PCD_INFO *) PcdInfo);
1139 ASSERT_EFI_ERROR (Status);
1140 }
1141
1142 /**
1143 Retrieve the currently set SKU Id.
1144
1145 If the sku id got >= PCD_MAX_SKU_ID, then ASSERT().
1146
1147 @return The currently set SKU Id. If the platform has not set at a SKU Id, then the
1148 default SKU Id value of 0 is returned. If the platform has set a SKU Id, then the currently set SKU
1149 Id is returned.
1150 **/
1151 UINTN
1152 EFIAPI
1153 LibPcdGetSku (
1154 VOID
1155 )
1156 {
1157 UINTN SkuId;
1158
1159 SkuId = GetPiPcdInfoProtocolPointer()->GetSku ();
1160 ASSERT (SkuId < PCD_MAX_SKU_ID);
1161
1162 return SkuId;
1163 }
1164