2 All Pcd Ppi services are implemented here.
4 Copyright (c) 2006 - 2008, Intel Corporation
5 All rights reserved. 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
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.
17 PCD_PPI mPcdPpiInstance
= {
50 PeiRegisterCallBackOnSet
,
51 PcdUnRegisterCallBackOnSet
,
53 PeiPcdGetNextTokenSpace
56 EFI_PEI_PPI_DESCRIPTOR mPpiPCD
= {
57 (EFI_PEI_PPI_DESCRIPTOR_PPI
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
),
63 Main entry for PCD PEIM driver.
65 This routine initialize the PCD database for PEI phase and install PCD_PPI.
67 @param FileHandle Handle of the file being invoked.
68 @param PeiServices Describes the list of possible PEI Services.
70 @return Status of install PCD_PPI
76 IN EFI_PEI_FILE_HANDLE FileHandle
,
77 IN CONST EFI_PEI_SERVICES
**PeiServices
82 return PeiServicesInstallPpi (&mPpiPCD
);
86 Sets the SKU value for subsequent calls to set or get PCD token values.
88 SetSku() sets the SKU Id to be used for subsequent calls to set or get PCD values.
89 SetSku() is normally called only once by the system.
91 For each item (token), the database can hold a single value that applies to all SKUs,
92 or multiple values, where each value is associated with a specific SKU Id. Items with multiple,
93 SKU-specific values are called SKU enabled.
95 The SKU Id of zero is reserved as a default. The valid SkuId range is 1 to 255.
96 For tokens that are not SKU enabled, the system ignores any set SKU Id and works with the
97 single value for that token. For SKU-enabled tokens, the system will use the SKU Id set by the
98 last call to SetSku(). If no SKU Id is set or the currently set SKU Id isn't valid for the specified token,
99 the system uses the default SKU Id. If the system attempts to use the default SKU Id and no value has been
100 set for that Id, the results are unpredictable.
102 @param[in] SkuId The SKU value that will be used when the PCD service will retrieve and
103 set values associated with a PCD token.
113 GetPcdDatabase()->Init
.SystemSkuId
= (SKU_ID
) SkuId
;
119 Retrieves an 8-bit value for a given PCD token.
121 Retrieves the current byte-sized value for a PCD token number.
122 If the TokenNumber is invalid, the results are unpredictable.
124 @param[in] TokenNumber The PCD token number.
126 @return The UINT8 value.
135 return *((UINT8
*) GetWorker (TokenNumber
, sizeof (UINT8
)));
139 Retrieves an 16-bit value for a given PCD token.
141 Retrieves the current 16-bits value for a PCD token number.
142 If the TokenNumber is invalid, the results are unpredictable.
144 @param[in] TokenNumber The PCD token number.
146 @return The UINT16 value.
155 return ReadUnaligned16 (GetWorker (TokenNumber
, sizeof (UINT16
)));
159 Retrieves an 32-bit value for a given PCD token.
161 Retrieves the current 32-bits value for a PCD token number.
162 If the TokenNumber is invalid, the results are unpredictable.
164 @param[in] TokenNumber The PCD token number.
166 @return The UINT32 value.
175 return ReadUnaligned32 (GetWorker (TokenNumber
, sizeof (UINT32
)));
179 Retrieves an 64-bit value for a given PCD token.
181 Retrieves the current 64-bits value for a PCD token number.
182 If the TokenNumber is invalid, the results are unpredictable.
184 @param[in] TokenNumber The PCD token number.
186 @return The UINT64 value.
195 return ReadUnaligned64 (GetWorker (TokenNumber
, sizeof (UINT64
)));
199 Retrieves a pointer to a value for a given PCD token.
201 Retrieves the current pointer to the buffer for a PCD token number.
202 Do not make any assumptions about the alignment of the pointer that
203 is returned by this function call. If the TokenNumber is invalid,
204 the results are unpredictable.
206 @param[in] TokenNumber The PCD token number.
208 @return The pointer to the buffer to be retrieved.
217 return GetWorker (TokenNumber
, 0);
221 Retrieves a Boolean value for a given PCD token.
223 Retrieves the current boolean value for a PCD token number.
224 Do not make any assumptions about the alignment of the pointer that
225 is returned by this function call. If the TokenNumber is invalid,
226 the results are unpredictable.
228 @param[in] TokenNumber The PCD token number.
230 @return The Boolean value.
239 return *((BOOLEAN
*) GetWorker (TokenNumber
, sizeof (BOOLEAN
)));
243 Retrieves the size of the value for a given PCD token.
245 Retrieves the current size of a particular PCD token.
246 If the TokenNumber is invalid, the results are unpredictable.
248 @param[in] TokenNumber The PCD token number.
250 @return The size of the value for the PCD token.
259 PEI_PCD_DATABASE
*PeiPcdDb
;
263 PeiPcdDb
= GetPcdDatabase ();
265 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
266 // We have to decrement TokenNumber by 1 to make it usable
267 // as the array index.
271 // EBC compiler is very choosy. It may report warning about comparison
272 // between UINTN and 0 . So we add 1 in each size of the
274 ASSERT (TokenNumber
+ 1 < PEI_LOCAL_TOKEN_NUMBER
+ 1);
276 Size
= (PeiPcdDb
->Init
.LocalTokenNumberTable
[TokenNumber
] & PCD_DATUM_TYPE_ALL_SET
) >> PCD_DATUM_TYPE_SHIFT
;
280 // For pointer type, we need to scan the SIZE_TABLE to get the current size.
282 return GetPtrTypeSize (TokenNumber
, &MaxSize
, PeiPcdDb
);
290 Retrieves an 8-bit value for a given PCD token.
292 Retrieves the 8-bit value of a particular PCD token.
293 If the TokenNumber is invalid or the token space
294 specified by Guid does not exist, the results are
297 @param[in] Guid The token space for the token number.
298 @param[in] ExTokenNumber The PCD token number.
300 @return The size 8-bit value for the PCD token.
306 IN CONST EFI_GUID
*Guid
,
307 IN UINTN ExTokenNumber
310 return *((UINT8
*) ExGetWorker (Guid
, ExTokenNumber
, sizeof (UINT8
)));
314 Retrieves an 16-bit value for a given PCD token.
316 Retrieves the 16-bit value of a particular PCD token.
317 If the TokenNumber is invalid or the token space
318 specified by Guid does not exist, the results are
321 @param[in] Guid The token space for the token number.
322 @param[in] ExTokenNumber The PCD token number.
324 @return The size 16-bit value for the PCD token.
330 IN CONST EFI_GUID
*Guid
,
331 IN UINTN ExTokenNumber
334 return ReadUnaligned16 (ExGetWorker (Guid
, ExTokenNumber
, sizeof (UINT16
)));
338 Retrieves an 32-bit value for a given PCD token.
340 Retrieves the 32-bit value of a particular PCD token.
341 If the TokenNumber is invalid or the token space
342 specified by Guid does not exist, the results are
345 @param[in] Guid The token space for the token number.
346 @param[in] ExTokenNumber The PCD token number.
348 @return The size 32-bit value for the PCD token.
354 IN CONST EFI_GUID
*Guid
,
355 IN UINTN ExTokenNumber
358 return ReadUnaligned32 (ExGetWorker (Guid
, ExTokenNumber
, sizeof (UINT32
)));
362 Retrieves an 64-bit value for a given PCD token.
364 Retrieves the 64-bit value of a particular PCD token.
365 If the TokenNumber is invalid or the token space
366 specified by Guid does not exist, the results are
369 @param[in] Guid The token space for the token number.
370 @param[in] ExTokenNumber The PCD token number.
372 @return The size 64-bit value for the PCD token.
378 IN CONST EFI_GUID
*Guid
,
379 IN UINTN ExTokenNumber
382 return ReadUnaligned64 (ExGetWorker (Guid
, ExTokenNumber
, sizeof (UINT64
)));
386 Retrieves a pointer to a value for a given PCD token.
388 Retrieves the current pointer to the buffer for a PCD token number.
389 Do not make any assumptions about the alignment of the pointer that
390 is returned by this function call. If the TokenNumber is invalid,
391 the results are unpredictable.
393 @param[in] Guid The token space for the token number.
394 @param[in] ExTokenNumber The PCD token number.
396 @return The pointer to the buffer to be retrieved.
402 IN CONST EFI_GUID
*Guid
,
403 IN UINTN ExTokenNumber
406 return ExGetWorker (Guid
, ExTokenNumber
, 0);
410 Retrieves an Boolean value for a given PCD token.
412 Retrieves the Boolean value of a particular PCD token.
413 If the TokenNumber is invalid or the token space
414 specified by Guid does not exist, the results are
417 @param[in] Guid The token space for the token number.
418 @param[in] ExTokenNumber The PCD token number.
420 @return The size Boolean value for the PCD token.
426 IN CONST EFI_GUID
*Guid
,
427 IN UINTN ExTokenNumber
430 return *((BOOLEAN
*) ExGetWorker (Guid
, ExTokenNumber
, sizeof (BOOLEAN
)));
434 Retrieves the size of the value for a given PCD token.
436 Retrieves the current size of a particular PCD token.
437 If the TokenNumber is invalid, the results are unpredictable.
439 @param[in] Guid The token space for the token number.
440 @param[in] ExTokenNumber The PCD token number.
442 @return The size of the value for the PCD token.
448 IN CONST EFI_GUID
*Guid
,
449 IN UINTN ExTokenNumber
452 return PeiPcdGetSize (GetExPcdTokenNumber (Guid
, ExTokenNumber
));
456 Sets an 8-bit value for a given PCD token.
458 When the PCD service sets a value, it will check to ensure that the
459 size of the value being set is compatible with the Token's existing definition.
460 If it is not, an error will be returned.
462 @param[in] TokenNumber The PCD token number.
463 @param[in] Value The value to set for the PCD token.
465 @retval EFI_SUCCESS Procedure returned successfully.
466 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
467 being set was incompatible with a call to this function.
468 Use GetSize() to retrieve the size of the target data.
469 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
475 IN UINTN TokenNumber
,
479 return SetValueWorker (TokenNumber
, &Value
, sizeof (Value
));
483 Sets an 16-bit value for a given PCD token.
485 When the PCD service sets a value, it will check to ensure that the
486 size of the value being set is compatible with the Token's existing definition.
487 If it is not, an error will be returned.
489 @param[in] TokenNumber The PCD token number.
490 @param[in] Value The value to set for the PCD token.
492 @retval EFI_SUCCESS Procedure returned successfully.
493 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
494 being set was incompatible with a call to this function.
495 Use GetSize() to retrieve the size of the target data.
496 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
502 IN UINTN TokenNumber
,
506 return SetValueWorker (TokenNumber
, &Value
, sizeof (Value
));
510 Sets an 32-bit value for a given PCD token.
512 When the PCD service sets a value, it will check to ensure that the
513 size of the value being set is compatible with the Token's existing definition.
514 If it is not, an error will be returned.
516 @param[in] TokenNumber The PCD token number.
517 @param[in] Value The value to set for the PCD token.
519 @retval EFI_SUCCESS Procedure returned successfully.
520 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
521 being set was incompatible with a call to this function.
522 Use GetSize() to retrieve the size of the target data.
523 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
529 IN UINTN TokenNumber
,
533 return SetValueWorker (TokenNumber
, &Value
, sizeof (Value
));
537 Sets an 64-bit value for a given PCD token.
539 When the PCD service sets a value, it will check to ensure that the
540 size of the value being set is compatible with the Token's existing definition.
541 If it is not, an error will be returned.
543 @param[in] TokenNumber The PCD token number.
544 @param[in] Value The value to set for the PCD token.
546 @retval EFI_SUCCESS Procedure returned successfully.
547 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
548 being set was incompatible with a call to this function.
549 Use GetSize() to retrieve the size of the target data.
550 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
556 IN UINTN TokenNumber
,
560 return SetValueWorker (TokenNumber
, &Value
, sizeof (Value
));
564 Sets a value of a specified size for a given PCD token.
566 When the PCD service sets a value, it will check to ensure that the
567 size of the value being set is compatible with the Token's existing definition.
568 If it is not, an error will be returned.
570 @param[in] TokenNumber The PCD token number.
571 @param[in, out] SizeOfBuffer A pointer to the length of the value being set for the PCD token.
572 On input, if the SizeOfValue is greater than the maximum size supported
573 for this TokenNumber then the output value of SizeOfValue will reflect
574 the maximum size supported for this TokenNumber.
575 @param[in] Buffer The buffer to set for the PCD token.
577 @retval EFI_SUCCESS Procedure returned successfully.
578 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
579 being set was incompatible with a call to this function.
580 Use GetSize() to retrieve the size of the target data.
581 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
587 IN UINTN TokenNumber
,
588 IN OUT UINTN
*SizeOfBuffer
,
592 return SetWorker (TokenNumber
, Buffer
, SizeOfBuffer
, TRUE
);
596 Sets an Boolean value for a given PCD token.
598 When the PCD service sets a value, it will check to ensure that the
599 size of the value being set is compatible with the Token's existing definition.
600 If it is not, an error will be returned.
602 @param[in] TokenNumber The PCD token number.
603 @param[in] Value The value to set for the PCD token.
605 @retval EFI_SUCCESS Procedure returned successfully.
606 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
607 being set was incompatible with a call to this function.
608 Use GetSize() to retrieve the size of the target data.
609 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
615 IN UINTN TokenNumber
,
619 return SetValueWorker (TokenNumber
, &Value
, sizeof (Value
));
623 Sets an 8-bit value for a given PCD token.
625 When the PCD service sets a value, it will check to ensure that the
626 size of the value being set is compatible with the Token's existing definition.
627 If it is not, an error will be returned.
629 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
630 @param[in] ExTokenNumber The PCD token number.
631 @param[in] Value The value to set for the PCD token.
633 @retval EFI_SUCCESS Procedure returned successfully.
634 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
635 being set was incompatible with a call to this function.
636 Use GetSize() to retrieve the size of the target data.
637 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
643 IN CONST EFI_GUID
*Guid
,
644 IN UINTN ExTokenNumber
,
648 return ExSetValueWorker (ExTokenNumber
, Guid
, &Value
, sizeof (Value
));
652 Sets an 16-bit value for a given PCD token.
654 When the PCD service sets a value, it will check to ensure that the
655 size of the value being set is compatible with the Token's existing definition.
656 If it is not, an error will be returned.
658 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
659 @param[in] ExTokenNumber The PCD token number.
660 @param[in] Value The value to set for the PCD token.
662 @retval EFI_SUCCESS Procedure returned successfully.
663 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
664 being set was incompatible with a call to this function.
665 Use GetSize() to retrieve the size of the target data.
666 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
672 IN CONST EFI_GUID
*Guid
,
673 IN UINTN ExTokenNumber
,
677 return ExSetValueWorker (ExTokenNumber
, Guid
, &Value
, sizeof (Value
));
681 Sets an 32-bit value for a given PCD token.
683 When the PCD service sets a value, it will check to ensure that the
684 size of the value being set is compatible with the Token's existing definition.
685 If it is not, an error will be returned.
687 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
688 @param[in] ExTokenNumber The PCD token number.
689 @param[in] Value The value to set for the PCD token.
691 @retval EFI_SUCCESS Procedure returned successfully.
692 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
693 being set was incompatible with a call to this function.
694 Use GetSize() to retrieve the size of the target data.
695 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
701 IN CONST EFI_GUID
*Guid
,
702 IN UINTN ExTokenNumber
,
706 return ExSetValueWorker (ExTokenNumber
, Guid
, &Value
, sizeof (Value
));
710 Sets an 64-bit value for a given PCD token.
712 When the PCD service sets a value, it will check to ensure that the
713 size of the value being set is compatible with the Token's existing definition.
714 If it is not, an error will be returned.
716 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
717 @param[in] ExTokenNumber The PCD token number.
718 @param[in] Value The value to set for the PCD token.
720 @retval EFI_SUCCESS Procedure returned successfully.
721 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
722 being set was incompatible with a call to this function.
723 Use GetSize() to retrieve the size of the target data.
724 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
730 IN CONST EFI_GUID
*Guid
,
731 IN UINTN ExTokenNumber
,
735 return ExSetValueWorker (ExTokenNumber
, Guid
, &Value
, sizeof (Value
));
739 Sets a value of a specified size for a given PCD token.
741 When the PCD service sets a value, it will check to ensure that the
742 size of the value being set is compatible with the Token's existing definition.
743 If it is not, an error will be returned.
745 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
746 @param[in] ExTokenNumber The PCD token number.
747 @param[in, out] SizeOfBuffer A pointer to the length of the value being set for the PCD token.
748 On input, if the SizeOfValue is greater than the maximum size supported
749 for this TokenNumber then the output value of SizeOfValue will reflect
750 the maximum size supported for this TokenNumber.
751 @param[in] Value The buffer to set for the PCD token.
753 @retval EFI_SUCCESS Procedure returned successfully.
754 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
755 being set was incompatible with a call to this function.
756 Use GetSize() to retrieve the size of the target data.
757 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
763 IN CONST EFI_GUID
*Guid
,
764 IN UINTN ExTokenNumber
,
765 IN OUT UINTN
*SizeOfBuffer
,
769 return ExSetWorker (ExTokenNumber
, Guid
, Value
, SizeOfBuffer
, TRUE
);
773 Sets an Boolean value for a given PCD token.
775 When the PCD service sets a value, it will check to ensure that the
776 size of the value being set is compatible with the Token's existing definition.
777 If it is not, an error will be returned.
779 @param [in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
780 @param [in] ExTokenNumber The PCD token number.
781 @param [in] Value The value to set for the PCD token.
783 @retval EFI_SUCCESS Procedure returned successfully.
784 @retval EFI_INVALID_PARAMETER The PCD service determined that the size of the data
785 being set was incompatible with a call to this function.
786 Use GetSize() to retrieve the size of the target data.
787 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
793 IN CONST EFI_GUID
*Guid
,
794 IN UINTN ExTokenNumber
,
798 return ExSetValueWorker (ExTokenNumber
, Guid
, &Value
, sizeof (Value
));
802 Specifies a function to be called anytime the value of a designated token is changed.
804 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
805 @param[in] ExTokenNumber The PCD token number.
806 @param[in] CallBackFunction The function prototype called when the value associated with the CallBackToken is set.
808 @retval EFI_SUCCESS The PCD service has successfully established a call event
809 for the CallBackToken requested.
810 @retval EFI_NOT_FOUND The PCD service could not find the referenced token number.
815 PeiRegisterCallBackOnSet (
816 IN CONST EFI_GUID
*Guid
, OPTIONAL
817 IN UINTN ExTokenNumber
,
818 IN PCD_PPI_CALLBACK CallBackFunction
821 if (!FeaturePcdGet(PcdPeiFullPcdDatabaseEnable
)) {
822 return EFI_UNSUPPORTED
;
825 if (CallBackFunction
== NULL
) {
826 return EFI_INVALID_PARAMETER
;
829 return PeiRegisterCallBackWorker (ExTokenNumber
, Guid
, CallBackFunction
, TRUE
);
833 Cancels a previously set callback function for a particular PCD token number.
835 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
836 @param[in] ExTokenNumber The PCD token number.
837 @param[in] CallBackFunction The function prototype called when the value associated with the CallBackToken is set.
839 @retval EFI_SUCCESS The PCD service has successfully established a call event
840 for the CallBackToken requested.
841 @retval EFI_NOT_FOUND The PCD service could not find the referenced token number.
846 PcdUnRegisterCallBackOnSet (
847 IN CONST EFI_GUID
*Guid
, OPTIONAL
848 IN UINTN ExTokenNumber
,
849 IN PCD_PPI_CALLBACK CallBackFunction
852 if (!FeaturePcdGet(PcdPeiFullPcdDatabaseEnable
)) {
853 return EFI_UNSUPPORTED
;
856 if (CallBackFunction
== NULL
) {
857 return EFI_INVALID_PARAMETER
;
860 return PeiRegisterCallBackWorker (ExTokenNumber
, Guid
, CallBackFunction
, FALSE
);
864 Retrieves the next valid token number in a given namespace.
866 This is useful since the PCD infrastructure contains a sparse list of token numbers,
867 and one cannot a priori know what token numbers are valid in the database.
869 If TokenNumber is 0 and Guid is not NULL, then the first token from the token space specified by Guid is returned.
870 If TokenNumber is not 0 and Guid is not NULL, then the next token in the token space specified by Guid is returned.
871 If TokenNumber is 0 and Guid is NULL, then the first token in the default token space is returned.
872 If TokenNumber is not 0 and Guid is NULL, then the next token in the default token space is returned.
873 The token numbers in the default token space may not be related to token numbers in token spaces that are named by Guid.
874 If the next token number can be retrieved, then it is returned in TokenNumber, and EFI_SUCCESS is returned.
875 If TokenNumber represents the last token number in the token space specified by Guid, then EFI_NOT_FOUND is returned.
876 If TokenNumber is not present in the token space specified by Guid, then EFI_NOT_FOUND is returned.
879 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
880 This is an optional parameter that may be NULL. If this parameter is NULL, then a request
881 is being made to retrieve tokens from the default token space.
882 @param[in, out] TokenNumber A pointer to the PCD token number to use to find the subsequent token number.
884 @retval EFI_SUCCESS The PCD service has retrieved the next valid token number.
885 Or the input token number is already the last valid token number in the PCD database.
886 In the later case, *TokenNumber is updated with the value of 0.
887 @retval EFI_NOT_FOUND If this input token number and token namespace does not exist on the platform.
893 IN CONST EFI_GUID
*Guid
, OPTIONAL
894 IN OUT UINTN
*TokenNumber
898 PEI_PCD_DATABASE
*PeiPcdDb
;
900 DYNAMICEX_MAPPING
*ExMapTable
;
903 BOOLEAN PeiExMapTableEmpty
;
905 if (!FeaturePcdGet (PcdPeiFullPcdDatabaseEnable
)) {
906 return EFI_UNSUPPORTED
;
909 PeiExMapTableEmpty
= PEI_EXMAP_TABLE_EMPTY
;
912 if (*TokenNumber
> PEI_NEX_TOKEN_NUMBER
) {
913 return EFI_NOT_FOUND
;
916 if (*TokenNumber
> PEI_NEX_TOKEN_NUMBER
) {
917 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
921 if (PeiExMapTableEmpty
) {
922 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
927 // Assume PCD Database AutoGen tool is sorting the ExMap based on the following order
931 PeiPcdDb
= GetPcdDatabase ();
933 MatchGuid
= ScanGuid (PeiPcdDb
->Init
.GuidTable
, sizeof(PeiPcdDb
->Init
.GuidTable
), Guid
);
935 if (MatchGuid
== NULL
) {
936 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
937 return EFI_NOT_FOUND
;
940 GuidTableIdx
= MatchGuid
- PeiPcdDb
->Init
.GuidTable
;
942 ExMapTable
= PeiPcdDb
->Init
.ExMapTable
;
946 // Locate the GUID in ExMapTable first.
948 for (Index
= 0; Index
< PEI_EXMAPPING_TABLE_SIZE
; Index
++) {
949 if (ExMapTable
[Index
].ExGuidIndex
== GuidTableIdx
) {
956 if (*TokenNumber
== PCD_INVALID_TOKEN_NUMBER
) {
957 *TokenNumber
= ExMapTable
[Index
].ExTokenNumber
;
961 for ( ; Index
< PEI_EXMAPPING_TABLE_SIZE
; Index
++) {
962 if (ExMapTable
[Index
].ExTokenNumber
== *TokenNumber
) {
964 if (Index
== PEI_EXMAPPING_TABLE_SIZE
) {
966 // Exceed the length of ExMap Table
968 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
971 if (ExMapTable
[Index
].ExGuidIndex
== GuidTableIdx
) {
972 *TokenNumber
= ExMapTable
[Index
].ExTokenNumber
;
975 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
980 return EFI_NOT_FOUND
;
984 return EFI_NOT_FOUND
;
988 Retrieves the next valid PCD token namespace for a given namespace.
990 @param[in, out] Guid An indirect pointer to EFI_GUID. On input it designates
991 a known token namespace from which the search will start. On output,
992 it designates the next valid token namespace on the platform. If the input
993 token namespace does not exist on the platform, an error is returned and
994 the value of *Guid is undefined. If *Guid is NULL, then the GUID of the
995 first token space of the current platform is assigned to *Guid the function
996 return EFI_SUCCESS. If *Guid is NULL and there is no namespace exist in
997 the platform other than the default (NULL) tokennamespace, *Guid is unchanged
998 and the function return EFI_SUCCESS. If this input token namespace is the last
999 namespace on the platform, *Guid will be assigned to NULL and the function return
1002 @retval EFI_SUCCESS The PCD service retrieved the next valid token space Guid.
1003 Or the input token space Guid is already the last valid token space Guid
1004 in the PCD database. In the later case, *Guid is updated with the value of NULL.
1005 @retval EFI_NOT_FOUND If the input token namespace does not exist on the platform.
1010 PeiPcdGetNextTokenSpace (
1011 IN OUT CONST EFI_GUID
**Guid
1015 EFI_GUID
*MatchGuid
;
1016 PEI_PCD_DATABASE
*PeiPcdDb
;
1017 DYNAMICEX_MAPPING
*ExMapTable
;
1020 BOOLEAN PeiExMapTableEmpty
;
1022 if (!FeaturePcdGet (PcdPeiFullPcdDatabaseEnable
)) {
1023 return EFI_UNSUPPORTED
;
1026 ASSERT (Guid
!= NULL
);
1028 PeiExMapTableEmpty
= PEI_EXMAP_TABLE_EMPTY
;
1030 if (PeiExMapTableEmpty
) {
1031 if (*Guid
!= NULL
) {
1032 return EFI_NOT_FOUND
;
1039 // Assume PCD Database AutoGen tool is sorting the ExMap based on the following order
1043 PeiPcdDb
= GetPcdDatabase ();
1045 ExMapTable
= PeiPcdDb
->Init
.ExMapTable
;
1047 if (*Guid
== NULL
) {
1049 // return the first Token Space Guid.
1051 *Guid
= &PeiPcdDb
->Init
.GuidTable
[ExMapTable
[0].ExGuidIndex
];
1055 MatchGuid
= ScanGuid (PeiPcdDb
->Init
.GuidTable
, sizeof(PeiPcdDb
->Init
.GuidTable
), *Guid
);
1057 if (MatchGuid
== NULL
) {
1058 return EFI_NOT_FOUND
;
1061 GuidTableIdx
= MatchGuid
- PeiPcdDb
->Init
.GuidTable
;
1064 for (Index
= 0; Index
< PEI_EXMAPPING_TABLE_SIZE
; Index
++) {
1065 if (ExMapTable
[Index
].ExGuidIndex
== GuidTableIdx
) {
1073 for ( ; Index
< PEI_EXMAPPING_TABLE_SIZE
; Index
++ ) {
1074 if (ExMapTable
[Index
].ExGuidIndex
!= GuidTableIdx
) {
1075 *Guid
= &PeiPcdDb
->Init
.GuidTable
[ExMapTable
[Index
].ExGuidIndex
];
1083 return EFI_NOT_FOUND
;
1088 Get PCD value's size for POINTER type PCD.
1090 The POINTER type PCD's value will be stored into a buffer in specificed size.
1091 The max size of this PCD's value is described in PCD's definition in DEC file.
1093 @param LocalTokenNumberTableIdx Index of PCD token number in PCD token table
1094 @param MaxSize Maximum size of PCD's value
1095 @param Database Pcd database in PEI phase.
1097 @return PCD value's size for POINTER type PCD.
1102 IN UINTN LocalTokenNumberTableIdx
,
1104 IN PEI_PCD_DATABASE
*Database
1108 UINTN LocalTokenNumber
;
1110 SIZE_INFO
*SizeTable
;
1113 SizeTableIdx
= GetSizeTableIndex (LocalTokenNumberTableIdx
, Database
);
1115 LocalTokenNumber
= Database
->Init
.LocalTokenNumberTable
[LocalTokenNumberTableIdx
];
1117 ASSERT ((LocalTokenNumber
& PCD_DATUM_TYPE_ALL_SET
) == PCD_DATUM_TYPE_POINTER
);
1119 SizeTable
= Database
->Init
.SizeTable
;
1121 *MaxSize
= SizeTable
[SizeTableIdx
];
1123 // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
1126 if ((LocalTokenNumber
& PCD_TYPE_VPD
) != 0) {
1128 // We have only one entry for VPD enabled PCD entry:
1130 // We consider current size is equal to MAX size.
1134 if ((LocalTokenNumber
& PCD_TYPE_SKU_ENABLED
) == 0) {
1136 // We have only two entry for Non-Sku enabled PCD entry:
1140 return SizeTable
[SizeTableIdx
+ 1];
1143 // We have these entry for SKU enabled PCD entry
1145 // 2) Current Size for each SKU_ID (It is equal to MaxSku).
1147 SkuIdTable
= GetSkuIdArray (LocalTokenNumberTableIdx
, Database
);
1148 for (Index
= 0; Index
< SkuIdTable
[0]; Index
++) {
1149 if (SkuIdTable
[1 + Index
] == Database
->Init
.SystemSkuId
) {
1150 return SizeTable
[SizeTableIdx
+ 1 + Index
];
1153 return SizeTable
[SizeTableIdx
+ 1];
1159 Set PCD value's size for POINTER type PCD.
1161 The POINTER type PCD's value will be stored into a buffer in specificed size.
1162 The max size of this PCD's value is described in PCD's definition in DEC file.
1164 @param LocalTokenNumberTableIdx Index of PCD token number in PCD token table
1165 @param CurrentSize Maximum size of PCD's value
1166 @param Database Pcd database in PEI phase.
1168 @retval TRUE Success to set PCD's value size, which is not exceed maximum size
1169 @retval FALSE Fail to set PCD's value size, which maybe exceed maximum size
1174 IN UINTN LocalTokenNumberTableIdx
,
1175 IN OUT UINTN
*CurrentSize
,
1176 IN PEI_PCD_DATABASE
*Database
1180 UINTN LocalTokenNumber
;
1182 SIZE_INFO
*SizeTable
;
1186 SizeTableIdx
= GetSizeTableIndex (LocalTokenNumberTableIdx
, Database
);
1188 LocalTokenNumber
= Database
->Init
.LocalTokenNumberTable
[LocalTokenNumberTableIdx
];
1190 ASSERT ((LocalTokenNumber
& PCD_DATUM_TYPE_ALL_SET
) == PCD_DATUM_TYPE_POINTER
);
1192 SizeTable
= Database
->Init
.SizeTable
;
1194 MaxSize
= SizeTable
[SizeTableIdx
];
1196 // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
1199 if ((LocalTokenNumber
& PCD_TYPE_VPD
) != 0) {
1201 // We shouldn't come here as we don't support SET for VPD
1206 if ((*CurrentSize
> MaxSize
) ||
1207 (*CurrentSize
== MAX_ADDRESS
)) {
1208 *CurrentSize
= MaxSize
;
1212 if ((LocalTokenNumber
& PCD_TYPE_SKU_ENABLED
) == 0) {
1214 // We have only two entry for Non-Sku enabled PCD entry:
1218 SizeTable
[SizeTableIdx
+ 1] = (SIZE_INFO
) *CurrentSize
;
1222 // We have these entry for SKU enabled PCD entry
1224 // 2) Current Size for each SKU_ID (It is equal to MaxSku).
1226 SkuIdTable
= GetSkuIdArray (LocalTokenNumberTableIdx
, Database
);
1227 for (Index
= 0; Index
< SkuIdTable
[0]; Index
++) {
1228 if (SkuIdTable
[1 + Index
] == Database
->Init
.SystemSkuId
) {
1229 SizeTable
[SizeTableIdx
+ 1 + Index
] = (SIZE_INFO
) *CurrentSize
;
1233 SizeTable
[SizeTableIdx
+ 1] = (SIZE_INFO
) *CurrentSize
;