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 PCD token for a given namespace.
866 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
867 @param[in, out] TokenNumber A pointer to the PCD token number to use to find the subsequent token number.
868 If the input token namespace or token number does not exist on the platform,
869 an error is returned and the value of *TokenNumber is undefined. To retrieve the "first" token,
870 have the pointer reference a TokenNumber value of 0. If the input token number is 0 and
871 there is no valid token number for this token namespace, *TokenNumber will be assigned to
872 0 and the function return EFI_SUCCESS. If the token number is the last valid token number,
873 *TokenNumber will be assigned to 0 and the function return EFI_SUCCESS.
875 @retval EFI_SUCCESS The PCD service retrieved the next valid token number. Or the input token number
876 is already the last valid token number in the PCD database.
877 In the later case, *TokenNumber is updated with the value of 0.
878 @retval EFI_NOT_FOUND If this input token number and token namespace does not exist on the platform.
884 IN CONST EFI_GUID
*Guid
, OPTIONAL
885 IN OUT UINTN
*TokenNumber
889 PEI_PCD_DATABASE
*PeiPcdDb
;
891 DYNAMICEX_MAPPING
*ExMapTable
;
894 BOOLEAN PeiExMapTableEmpty
;
896 if (!FeaturePcdGet (PcdPeiFullPcdDatabaseEnable
)) {
897 return EFI_UNSUPPORTED
;
900 PeiExMapTableEmpty
= PEI_EXMAP_TABLE_EMPTY
;
903 if (*TokenNumber
> PEI_NEX_TOKEN_NUMBER
) {
904 return EFI_NOT_FOUND
;
907 if (*TokenNumber
> PEI_NEX_TOKEN_NUMBER
) {
908 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
912 if (PeiExMapTableEmpty
) {
913 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
918 // Assume PCD Database AutoGen tool is sorting the ExMap based on the following order
922 PeiPcdDb
= GetPcdDatabase ();
924 MatchGuid
= ScanGuid (PeiPcdDb
->Init
.GuidTable
, sizeof(PeiPcdDb
->Init
.GuidTable
), Guid
);
926 if (MatchGuid
== NULL
) {
927 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
928 return EFI_NOT_FOUND
;
931 GuidTableIdx
= MatchGuid
- PeiPcdDb
->Init
.GuidTable
;
933 ExMapTable
= PeiPcdDb
->Init
.ExMapTable
;
937 // Locate the GUID in ExMapTable first.
939 for (Index
= 0; Index
< PEI_EXMAPPING_TABLE_SIZE
; Index
++) {
940 if (ExMapTable
[Index
].ExGuidIndex
== GuidTableIdx
) {
947 if (*TokenNumber
== PCD_INVALID_TOKEN_NUMBER
) {
948 *TokenNumber
= ExMapTable
[Index
].ExTokenNumber
;
952 for ( ; Index
< PEI_EXMAPPING_TABLE_SIZE
; Index
++) {
953 if (ExMapTable
[Index
].ExTokenNumber
== *TokenNumber
) {
955 if (Index
== PEI_EXMAPPING_TABLE_SIZE
) {
957 // Exceed the length of ExMap Table
959 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
962 if (ExMapTable
[Index
].ExGuidIndex
== GuidTableIdx
) {
963 *TokenNumber
= ExMapTable
[Index
].ExTokenNumber
;
966 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
971 return EFI_NOT_FOUND
;
975 return EFI_NOT_FOUND
;
979 Retrieves the next valid PCD token namespace for a given namespace.
981 @param[in, out] Guid An indirect pointer to EFI_GUID. On input it designates
982 a known token namespace from which the search will start. On output,
983 it designates the next valid token namespace on the platform. If the input
984 token namespace does not exist on the platform, an error is returned and
985 the value of *Guid is undefined. If *Guid is NULL, then the GUID of the
986 first token space of the current platform is assigned to *Guid the function
987 return EFI_SUCCESS. If *Guid is NULL and there is no namespace exist in
988 the platform other than the default (NULL) tokennamespace, *Guid is unchanged
989 and the function return EFI_SUCCESS. If this input token namespace is the last
990 namespace on the platform, *Guid will be assigned to NULL and the function return
993 @retval EFI_SUCCESS The PCD service retrieved the next valid token space Guid.
994 Or the input token space Guid is already the last valid token space Guid
995 in the PCD database. In the later case, *Guid is updated with the value of NULL.
996 @retval EFI_NOT_FOUND If the input token namespace does not exist on the platform.
1001 PeiPcdGetNextTokenSpace (
1002 IN OUT CONST EFI_GUID
**Guid
1006 EFI_GUID
*MatchGuid
;
1007 PEI_PCD_DATABASE
*PeiPcdDb
;
1008 DYNAMICEX_MAPPING
*ExMapTable
;
1011 BOOLEAN PeiExMapTableEmpty
;
1013 if (!FeaturePcdGet (PcdPeiFullPcdDatabaseEnable
)) {
1014 return EFI_UNSUPPORTED
;
1017 ASSERT (Guid
!= NULL
);
1019 PeiExMapTableEmpty
= PEI_EXMAP_TABLE_EMPTY
;
1021 if (PeiExMapTableEmpty
) {
1022 if (*Guid
!= NULL
) {
1023 return EFI_NOT_FOUND
;
1030 // Assume PCD Database AutoGen tool is sorting the ExMap based on the following order
1034 PeiPcdDb
= GetPcdDatabase ();
1036 ExMapTable
= PeiPcdDb
->Init
.ExMapTable
;
1038 if (*Guid
== NULL
) {
1040 // return the first Token Space Guid.
1042 *Guid
= &PeiPcdDb
->Init
.GuidTable
[ExMapTable
[0].ExGuidIndex
];
1046 MatchGuid
= ScanGuid (PeiPcdDb
->Init
.GuidTable
, sizeof(PeiPcdDb
->Init
.GuidTable
), *Guid
);
1048 if (MatchGuid
== NULL
) {
1049 return EFI_NOT_FOUND
;
1052 GuidTableIdx
= MatchGuid
- PeiPcdDb
->Init
.GuidTable
;
1055 for (Index
= 0; Index
< PEI_EXMAPPING_TABLE_SIZE
; Index
++) {
1056 if (ExMapTable
[Index
].ExGuidIndex
== GuidTableIdx
) {
1064 for ( ; Index
< PEI_EXMAPPING_TABLE_SIZE
; Index
++ ) {
1065 if (ExMapTable
[Index
].ExGuidIndex
!= GuidTableIdx
) {
1066 *Guid
= &PeiPcdDb
->Init
.GuidTable
[ExMapTable
[Index
].ExGuidIndex
];
1074 return EFI_NOT_FOUND
;
1079 Get PCD value's size for POINTER type PCD.
1081 The POINTER type PCD's value will be stored into a buffer in specificed size.
1082 The max size of this PCD's value is described in PCD's definition in DEC file.
1084 @param LocalTokenNumberTableIdx Index of PCD token number in PCD token table
1085 @param MaxSize Maximum size of PCD's value
1086 @param Database Pcd database in PEI phase.
1088 @return PCD value's size for POINTER type PCD.
1093 IN UINTN LocalTokenNumberTableIdx
,
1095 IN PEI_PCD_DATABASE
*Database
1099 UINTN LocalTokenNumber
;
1101 SIZE_INFO
*SizeTable
;
1104 SizeTableIdx
= GetSizeTableIndex (LocalTokenNumberTableIdx
, Database
);
1106 LocalTokenNumber
= Database
->Init
.LocalTokenNumberTable
[LocalTokenNumberTableIdx
];
1108 ASSERT ((LocalTokenNumber
& PCD_DATUM_TYPE_ALL_SET
) == PCD_DATUM_TYPE_POINTER
);
1110 SizeTable
= Database
->Init
.SizeTable
;
1112 *MaxSize
= SizeTable
[SizeTableIdx
];
1114 // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
1117 if ((LocalTokenNumber
& PCD_TYPE_VPD
) != 0) {
1119 // We have only one entry for VPD enabled PCD entry:
1121 // We consider current size is equal to MAX size.
1125 if ((LocalTokenNumber
& PCD_TYPE_SKU_ENABLED
) == 0) {
1127 // We have only two entry for Non-Sku enabled PCD entry:
1131 return SizeTable
[SizeTableIdx
+ 1];
1134 // We have these entry for SKU enabled PCD entry
1136 // 2) Current Size for each SKU_ID (It is equal to MaxSku).
1138 SkuIdTable
= GetSkuIdArray (LocalTokenNumberTableIdx
, Database
);
1139 for (Index
= 0; Index
< SkuIdTable
[0]; Index
++) {
1140 if (SkuIdTable
[1 + Index
] == Database
->Init
.SystemSkuId
) {
1141 return SizeTable
[SizeTableIdx
+ 1 + Index
];
1144 return SizeTable
[SizeTableIdx
+ 1];
1150 Set PCD value's size for POINTER type PCD.
1152 The POINTER type PCD's value will be stored into a buffer in specificed size.
1153 The max size of this PCD's value is described in PCD's definition in DEC file.
1155 @param LocalTokenNumberTableIdx Index of PCD token number in PCD token table
1156 @param CurrentSize Maximum size of PCD's value
1157 @param Database Pcd database in PEI phase.
1159 @retval TRUE Success to set PCD's value size, which is not exceed maximum size
1160 @retval FALSE Fail to set PCD's value size, which maybe exceed maximum size
1165 IN UINTN LocalTokenNumberTableIdx
,
1166 IN OUT UINTN
*CurrentSize
,
1167 IN PEI_PCD_DATABASE
*Database
1171 UINTN LocalTokenNumber
;
1173 SIZE_INFO
*SizeTable
;
1177 SizeTableIdx
= GetSizeTableIndex (LocalTokenNumberTableIdx
, Database
);
1179 LocalTokenNumber
= Database
->Init
.LocalTokenNumberTable
[LocalTokenNumberTableIdx
];
1181 ASSERT ((LocalTokenNumber
& PCD_DATUM_TYPE_ALL_SET
) == PCD_DATUM_TYPE_POINTER
);
1183 SizeTable
= Database
->Init
.SizeTable
;
1185 MaxSize
= SizeTable
[SizeTableIdx
];
1187 // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
1190 if ((LocalTokenNumber
& PCD_TYPE_VPD
) != 0) {
1192 // We shouldn't come here as we don't support SET for VPD
1197 if ((*CurrentSize
> MaxSize
) ||
1198 (*CurrentSize
== MAX_ADDRESS
)) {
1199 *CurrentSize
= MaxSize
;
1203 if ((LocalTokenNumber
& PCD_TYPE_SKU_ENABLED
) == 0) {
1205 // We have only two entry for Non-Sku enabled PCD entry:
1209 SizeTable
[SizeTableIdx
+ 1] = (SIZE_INFO
) *CurrentSize
;
1213 // We have these entry for SKU enabled PCD entry
1215 // 2) Current Size for each SKU_ID (It is equal to MaxSku).
1217 SkuIdTable
= GetSkuIdArray (LocalTokenNumberTableIdx
, Database
);
1218 for (Index
= 0; Index
< SkuIdTable
[0]; Index
++) {
1219 if (SkuIdTable
[1 + Index
] == Database
->Init
.SystemSkuId
) {
1220 SizeTable
[SizeTableIdx
+ 1 + Index
] = (SIZE_INFO
) *CurrentSize
;
1224 SizeTable
[SizeTableIdx
+ 1] = (SIZE_INFO
) *CurrentSize
;