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 *
GetPcdPpiPointer(VOID)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 *
GetPiPcdPpiPointer(VOID)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 *
GetPcdInfoPpiPointer(VOID)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 *
GetPiPcdInfoPpiPointer(VOID)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
LibPcdSetSku(IN UINTN SkuId)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
LibPcdGet8(IN UINTN TokenNumber)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
LibPcdGet16(IN UINTN TokenNumber)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
LibPcdGet32(IN UINTN TokenNumber)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
LibPcdGet64(IN UINTN TokenNumber)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
LibPcdGetPtr(IN UINTN TokenNumber)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
LibPcdGetBool(IN UINTN TokenNumber)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
LibPcdGetSize(IN UINTN TokenNumber)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
LibPcdGetEx8(IN CONST GUID * Guid,IN UINTN TokenNumber)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
LibPcdGetEx16(IN CONST GUID * Guid,IN UINTN TokenNumber)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
LibPcdGetEx32(IN CONST GUID * Guid,IN UINTN TokenNumber)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
LibPcdGetEx64(IN CONST GUID * Guid,IN UINTN TokenNumber)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
LibPcdGetExPtr(IN CONST GUID * Guid,IN UINTN TokenNumber)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
LibPcdGetExBool(IN CONST GUID * Guid,IN UINTN TokenNumber)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
LibPcdGetExSize(IN CONST GUID * Guid,IN UINTN TokenNumber)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
LibPcdSet8(IN UINTN TokenNumber,IN UINT8 Value)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
LibPcdSet16(IN UINTN TokenNumber,IN UINT16 Value)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
LibPcdSet32(IN UINTN TokenNumber,IN UINT32 Value)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
LibPcdSet64(IN UINTN TokenNumber,IN UINT64 Value)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
LibPcdSetPtr(IN UINTN TokenNumber,IN OUT UINTN * SizeOfBuffer,IN CONST VOID * Buffer)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
LibPcdSetBool(IN UINTN TokenNumber,IN BOOLEAN Value)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
LibPcdSetEx8(IN CONST GUID * Guid,IN UINTN TokenNumber,IN UINT8 Value)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
LibPcdSetEx16(IN CONST GUID * Guid,IN UINTN TokenNumber,IN UINT16 Value)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
LibPcdSetEx32(IN CONST GUID * Guid,IN UINTN TokenNumber,IN UINT32 Value)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
LibPcdSetEx64(IN CONST GUID * Guid,IN UINTN TokenNumber,IN UINT64 Value)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
LibPcdSetExPtr(IN CONST GUID * Guid,IN UINTN TokenNumber,IN OUT UINTN * SizeOfBuffer,IN VOID * Buffer)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
LibPcdSetExBool(IN CONST GUID * Guid,IN UINTN TokenNumber,IN BOOLEAN Value)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
LibPcdSet8S(IN UINTN TokenNumber,IN UINT8 Value)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
LibPcdSet16S(IN UINTN TokenNumber,IN UINT16 Value)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
LibPcdSet32S(IN UINTN TokenNumber,IN UINT32 Value)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
LibPcdSet64S(IN UINTN TokenNumber,IN UINT64 Value)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
LibPcdSetPtrS(IN UINTN TokenNumber,IN OUT UINTN * SizeOfBuffer,IN CONST VOID * Buffer)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
LibPcdSetBoolS(IN UINTN TokenNumber,IN BOOLEAN Value)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
LibPcdSetEx8S(IN CONST GUID * Guid,IN UINTN TokenNumber,IN UINT8 Value)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
LibPcdSetEx16S(IN CONST GUID * Guid,IN UINTN TokenNumber,IN UINT16 Value)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
LibPcdSetEx32S(IN CONST GUID * Guid,IN UINTN TokenNumber,IN UINT32 Value)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
LibPcdSetEx64S(IN CONST GUID * Guid,IN UINTN TokenNumber,IN UINT64 Value)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
LibPcdSetExPtrS(IN CONST GUID * Guid,IN UINTN TokenNumber,IN OUT UINTN * SizeOfBuffer,IN VOID * Buffer)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
LibPcdSetExBoolS(IN CONST GUID * Guid,IN UINTN TokenNumber,IN BOOLEAN Value)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
LibPcdCallbackOnSet(IN CONST GUID * Guid,OPTIONAL IN UINTN TokenNumber,IN PCD_CALLBACK NotificationFunction)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
LibPcdCancelCallback(IN CONST GUID * Guid,OPTIONAL IN UINTN TokenNumber,IN PCD_CALLBACK NotificationFunction)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
LibPcdGetNextToken(IN CONST GUID * Guid,OPTIONAL IN UINTN TokenNumber)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
LibPcdGetNextTokenSpace(IN CONST GUID * TokenSpaceGuid)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
LibPatchPcdSetPtr(OUT VOID * PatchVariable,IN UINTN MaximumDatumSize,IN OUT UINTN * SizeOfBuffer,IN CONST VOID * Buffer)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
LibPatchPcdSetPtrS(OUT VOID * PatchVariable,IN UINTN MaximumDatumSize,IN OUT UINTN * SizeOfBuffer,IN CONST VOID * Buffer)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
LibPatchPcdSetPtrAndSize(OUT VOID * PatchVariable,OUT UINTN * SizeOfPatchVariable,IN UINTN MaximumDatumSize,IN OUT UINTN * SizeOfBuffer,IN CONST VOID * Buffer)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
LibPatchPcdSetPtrAndSizeS(OUT VOID * PatchVariable,OUT UINTN * SizeOfPatchVariable,IN UINTN MaximumDatumSize,IN OUT UINTN * SizeOfBuffer,IN CONST VOID * Buffer)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
LibPcdGetInfo(IN UINTN TokenNumber,OUT PCD_INFO * PcdInfo)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
LibPcdGetInfoEx(IN CONST GUID * Guid,IN UINTN TokenNumber,OUT PCD_INFO * PcdInfo)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
LibPcdGetSku(VOID)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