2 Private functions used by PCD DXE driver.
4 Copyright (c) 2006 - 2007, 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.
14 Module Name: Service.c
18 // Include common header file for this module.
20 #include "CommonHeader.h"
25 PCD_DATABASE
* mPcdDatabase
;
27 LIST_ENTRY
*mCallbackFnTable
;
35 UINT32
*LocalTokenNumberTable
;
40 VARIABLE_HEAD
*VariableHead
;
41 UINT8
*VaraiableDefaultBuffer
;
50 UINT32 LocalTokenNumber
;
52 UINT16 StringTableIdx
;
56 // Aquire lock to prevent reentrance from TPL_CALLBACK level
58 EfiAcquireLock (&mPcdDatabaseLock
);
62 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
63 // We have to decrement TokenNumber by 1 to make it usable
64 // as the array index.
68 TmpTokenNumber
= TokenNumber
;
71 // PCD_TOTAL_TOKEN_NUMBER is a auto-generated constant.
72 // It could be zero. EBC compiler is very choosy. It may
73 // report warning. So we add 1 in each size of the
76 ASSERT (TokenNumber
+ 1 < PCD_TOTAL_TOKEN_NUMBER
+ 1);
78 ASSERT ((GetSize
== DxePcdGetSize (TokenNumber
+ 1)) || (GetSize
== 0));
80 // EBC compiler is very choosy. It may report warning about comparison
81 // between UINTN and 0 . So we add 1 in each size of the
83 IsPeiDb
= (BOOLEAN
) ((TokenNumber
+ 1 < PEI_LOCAL_TOKEN_NUMBER
+ 1) ? TRUE
: FALSE
);
85 LocalTokenNumberTable
= IsPeiDb
? mPcdDatabase
->PeiDb
.Init
.LocalTokenNumberTable
:
86 mPcdDatabase
->DxeDb
.Init
.LocalTokenNumberTable
;
88 TokenNumber
= IsPeiDb
? TokenNumber
:
89 TokenNumber
- PEI_LOCAL_TOKEN_NUMBER
;
91 LocalTokenNumber
= LocalTokenNumberTable
[TokenNumber
];
93 if ((LocalTokenNumber
& PCD_TYPE_SKU_ENABLED
) == PCD_TYPE_SKU_ENABLED
) {
95 GetPtrTypeSize (TmpTokenNumber
, &MaxSize
);
99 LocalTokenNumber
= GetSkuEnabledTokenNumber (LocalTokenNumber
& ~PCD_TYPE_SKU_ENABLED
, MaxSize
, IsPeiDb
);
102 PcdDb
= IsPeiDb
? ((UINT8
*) &mPcdDatabase
->PeiDb
) : ((UINT8
*) &mPcdDatabase
->DxeDb
);
103 StringTable
= IsPeiDb
? mPcdDatabase
->PeiDb
.Init
.StringTable
:
104 mPcdDatabase
->DxeDb
.Init
.StringTable
;
106 Offset
= LocalTokenNumber
& PCD_DATABASE_OFFSET_MASK
;
108 switch (LocalTokenNumber
& PCD_TYPE_ALL_SET
) {
110 VpdHead
= (VPD_HEAD
*) ((UINT8
*) PcdDb
+ Offset
);
111 RetPtr
= (VOID
*) (UINTN
) (FixedPcdGet32(PcdVpdBaseAddress
) + VpdHead
->Offset
);
115 GuidTable
= IsPeiDb
? mPcdDatabase
->PeiDb
.Init
.GuidTable
:
116 mPcdDatabase
->DxeDb
.Init
.GuidTable
;
118 VariableHead
= (VARIABLE_HEAD
*) (PcdDb
+ Offset
);
120 Guid
= &(GuidTable
[VariableHead
->GuidTableIndex
]);
121 Name
= &(StringTable
[VariableHead
->StringIndex
]);
122 VaraiableDefaultBuffer
= (UINT8
*) PcdDb
+ VariableHead
->DefaultValueOffset
;
124 Status
= GetHiiVariable (Guid
, Name
, &Data
, &DataSize
);
125 if (Status
== EFI_SUCCESS
) {
128 // It is a pointer type. So get the MaxSize reserved for
131 GetPtrTypeSize (TmpTokenNumber
, &GetSize
);
133 CopyMem (VaraiableDefaultBuffer
, Data
+ VariableHead
->Offset
, GetSize
);
137 // If the operation is successful, we copy the data
138 // to the default value buffer in the PCD Database.
139 // So that we can free the Data allocated in GetHiiVariable.
142 // If the operation is not successful,
143 // Return 1) either the default value specified by Platform Integrator
144 // 2) Or the value Set by a PCD set operation.
146 RetPtr
= (VOID
*) VaraiableDefaultBuffer
;
149 case PCD_TYPE_STRING
:
150 StringTableIdx
= (UINT16
) *((UINT8
*) PcdDb
+ Offset
);
151 RetPtr
= (VOID
*) &StringTable
[StringTableIdx
];
155 RetPtr
= (VOID
*) ((UINT8
*) PcdDb
+ Offset
);
164 EfiReleaseLock (&mPcdDatabaseLock
);
173 DxeRegisterCallBackWorker (
174 IN UINTN TokenNumber
,
175 IN CONST GUID
*Guid
, OPTIONAL
176 IN PCD_PROTOCOL_CALLBACK CallBackFunction
179 CALLBACK_FN_ENTRY
*FnTableEntry
;
180 LIST_ENTRY
*ListHead
;
181 LIST_ENTRY
*ListNode
;
184 TokenNumber
= GetExPcdTokenNumber (Guid
, (UINT32
) TokenNumber
);
188 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
189 // We have to decrement TokenNumber by 1 to make it usable
190 // as the array index.
194 ListHead
= &mCallbackFnTable
[TokenNumber
];
195 ListNode
= GetFirstNode (ListHead
);
197 while (ListNode
!= ListHead
) {
198 FnTableEntry
= CR_FNENTRY_FROM_LISTNODE(ListNode
, CALLBACK_FN_ENTRY
, Node
);
200 if (FnTableEntry
->CallbackFn
== CallBackFunction
) {
202 // We only allow a Callback function to be register once
203 // for a TokenNumber. So just return EFI_SUCCESS
207 ListNode
= GetNextNode (ListHead
, ListNode
);
210 FnTableEntry
= AllocatePool (sizeof(CALLBACK_FN_ENTRY
));
211 ASSERT (FnTableEntry
!= NULL
);
213 FnTableEntry
->CallbackFn
= CallBackFunction
;
214 InsertTailList (ListHead
, &FnTableEntry
->Node
);
223 DxeUnRegisterCallBackWorker (
224 IN UINTN TokenNumber
,
225 IN CONST GUID
*Guid
, OPTIONAL
226 IN PCD_PROTOCOL_CALLBACK CallBackFunction
229 CALLBACK_FN_ENTRY
*FnTableEntry
;
230 LIST_ENTRY
*ListHead
;
231 LIST_ENTRY
*ListNode
;
234 TokenNumber
= GetExPcdTokenNumber (Guid
, (UINT32
) TokenNumber
);
238 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
239 // We have to decrement TokenNumber by 1 to make it usable
240 // as the array index.
244 ListHead
= &mCallbackFnTable
[TokenNumber
];
245 ListNode
= GetFirstNode (ListHead
);
247 while (ListNode
!= ListHead
) {
248 FnTableEntry
= CR_FNENTRY_FROM_LISTNODE(ListNode
, CALLBACK_FN_ENTRY
, Node
);
250 if (FnTableEntry
->CallbackFn
== CallBackFunction
) {
252 // We only allow a Callback function to be register once
253 // for a TokenNumber. So we can safely remove the Node from
254 // the Link List and return EFI_SUCCESS.
256 RemoveEntryList (ListNode
);
257 FreePool (FnTableEntry
);
261 ListNode
= GetNextNode (ListHead
, ListNode
);
264 return EFI_INVALID_PARAMETER
;
270 ExGetNextTokeNumber (
271 IN CONST EFI_GUID
*Guid
,
272 IN OUT UINTN
*TokenNumber
,
273 IN EFI_GUID
*GuidTable
,
274 IN UINTN SizeOfGuidTable
,
275 IN DYNAMICEX_MAPPING
*ExMapTable
,
276 IN UINTN SizeOfExMapTable
284 MatchGuid
= ScanGuid (GuidTable
, SizeOfGuidTable
, Guid
);
285 if (MatchGuid
== NULL
) {
286 return EFI_NOT_FOUND
;
290 GuidTableIdx
= MatchGuid
- GuidTable
;
291 for (Idx
= 0; Idx
< SizeOfExMapTable
; Idx
++) {
292 if (ExMapTable
[Idx
].ExGuidIndex
== GuidTableIdx
) {
299 if (*TokenNumber
== PCD_INVALID_TOKEN_NUMBER
) {
300 *TokenNumber
= ExMapTable
[Idx
].ExTokenNumber
;
304 for ( ; Idx
< SizeOfExMapTable
; Idx
++) {
305 if (ExMapTable
[Idx
].ExTokenNumber
== *TokenNumber
) {
307 if (Idx
== SizeOfExMapTable
) {
309 // Exceed the length of ExMap Table
311 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
313 } else if (ExMapTable
[Idx
].ExGuidIndex
== GuidTableIdx
) {
315 // Found the next match
317 *TokenNumber
= ExMapTable
[Idx
].ExTokenNumber
;
321 // Guid has been changed. It is the next Token Space Guid.
322 // We should flag no more TokenNumber.
324 *TokenNumber
= PCD_INVALID_TOKEN_NUMBER
;
331 return EFI_NOT_FOUND
;
338 BuildPcdDxeDataBase (
342 PEI_PCD_DATABASE
*PeiDatabase
;
343 EFI_HOB_GUID_TYPE
*GuidHob
;
346 mPcdDatabase
= AllocateZeroPool (sizeof(PCD_DATABASE
));
347 ASSERT (mPcdDatabase
!= NULL
);
349 GuidHob
= GetFirstGuidHob (&gPcdDataBaseHobGuid
);
350 if (GuidHob
!= NULL
) {
353 // We will copy over the PEI phase's PCD Database.
355 // If no PEIMs use dynamic Pcd Entry, the Pcd Service PEIM
356 // should not be included at all. So the GuidHob could
357 // be NULL. If it is NULL, we just copy over the DXE Default
358 // Value to PCD Database.
361 PeiDatabase
= (PEI_PCD_DATABASE
*) GET_GUID_HOB_DATA (GuidHob
);
363 // Copy PCD Entries refereneced in PEI phase to PCD DATABASE
365 CopyMem (&mPcdDatabase
->PeiDb
, PeiDatabase
, sizeof (PEI_PCD_DATABASE
));
369 // Copy PCD Entries with default value to PCD DATABASE
371 CopyMem (&mPcdDatabase
->DxeDb
.Init
, &gDXEPcdDbInit
, sizeof(DXE_PCD_DATABASE_INIT
));
375 // Initialized the Callback Function Table
378 mCallbackFnTable
= AllocateZeroPool (PCD_TOTAL_TOKEN_NUMBER
* sizeof (LIST_ENTRY
));
380 // EBC compiler is very choosy. It may report warning about comparison
381 // between UINTN and 0 . So we add 1 in each size of the
383 for (Idx
= 0; Idx
+ 1 < PCD_TOTAL_TOKEN_NUMBER
+ 1; Idx
++) {
384 InitializeListHead (&mCallbackFnTable
[Idx
]);
394 IN EFI_GUID
*VariableGuid
,
395 IN UINT16
*VariableName
,
396 OUT UINT8
**VariableData
,
397 OUT UINTN
*VariableSize
407 Status
= gRT
->GetVariable (
408 (UINT16
*)VariableName
,
415 if (Status
== EFI_BUFFER_TOO_SMALL
) {
416 Buffer
= (UINT8
*) AllocatePool (Size
);
418 ASSERT (Buffer
!= NULL
);
420 Status
= gRT
->GetVariable (
428 ASSERT (Status
== EFI_SUCCESS
);
429 *VariableData
= Buffer
;
430 *VariableSize
= Size
;
438 GetSkuEnabledTokenNumber (
439 UINT32 LocalTokenNumber
,
448 SKU_ID
*PhaseSkuIdTable
;
451 ASSERT ((LocalTokenNumber
& PCD_TYPE_SKU_ENABLED
) == 0);
453 PcdDb
= IsPeiDb
? (UINT8
*) &mPcdDatabase
->PeiDb
: (UINT8
*) &mPcdDatabase
->DxeDb
;
455 SkuHead
= (SKU_HEAD
*) (PcdDb
+ (LocalTokenNumber
& PCD_DATABASE_OFFSET_MASK
));
456 Value
= (UINT8
*) (PcdDb
+ SkuHead
->SkuDataStartOffset
);
458 PhaseSkuIdTable
= IsPeiDb
? mPcdDatabase
->PeiDb
.Init
.SkuIdTable
:
459 mPcdDatabase
->DxeDb
.Init
.SkuIdTable
;
461 SkuIdTable
= &PhaseSkuIdTable
[SkuHead
->SkuIdTableOffset
];
463 for (i
= 0; i
< SkuIdTable
[0]; i
++) {
464 if (mPcdDatabase
->PeiDb
.Init
.SystemSkuId
== SkuIdTable
[i
+ 1]) {
468 ASSERT (i
< SkuIdTable
[0]);
470 switch (LocalTokenNumber
& PCD_TYPE_ALL_SET
) {
472 Value
= (UINT8
*) &(((VPD_HEAD
*) Value
)[i
]);
473 return (UINT32
) ((Value
- PcdDb
) | PCD_TYPE_VPD
);
476 Value
= (UINT8
*) &(((VARIABLE_HEAD
*) Value
)[i
]);
477 return (UINT32
) ((Value
- PcdDb
) | PCD_TYPE_HII
);
479 case PCD_TYPE_STRING
:
480 Value
= (UINT8
*) &(((STRING_HEAD
*) Value
)[i
]);
481 return (UINT32
) ((Value
- PcdDb
) | PCD_TYPE_STRING
);
485 return (UINT32
) (Value
- PcdDb
);
502 InvokeCallbackOnSet (
503 UINT32 ExTokenNumber
,
504 CONST EFI_GUID
*Guid
, OPTIONAL
510 CALLBACK_FN_ENTRY
*FnTableEntry
;
511 LIST_ENTRY
*ListHead
;
512 LIST_ENTRY
*ListNode
;
515 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
516 // We have to decrement TokenNumber by 1 to make it usable
517 // as the array index.
521 ListHead
= &mCallbackFnTable
[TokenNumber
];
522 ListNode
= GetFirstNode (ListHead
);
524 while (ListNode
!= ListHead
) {
525 FnTableEntry
= CR_FNENTRY_FROM_LISTNODE(ListNode
, CALLBACK_FN_ENTRY
, Node
);
527 FnTableEntry
->CallbackFn(Guid
,
528 (Guid
== NULL
) ? TokenNumber
: ExTokenNumber
,
532 ListNode
= GetNextNode (ListHead
, ListNode
);
541 IN UINTN TokenNumber
,
546 return SetWorker (TokenNumber
, Data
, &Size
, FALSE
);
552 IN UINTN TokenNumber
,
558 UINT32
*LocalTokenNumberTable
;
560 UINT32 LocalTokenNumber
;
565 UINTN VariableOffset
;
567 VARIABLE_HEAD
*VariableHead
;
572 UINTN TmpTokenNumber
;
575 // Aquire lock to prevent reentrance from TPL_CALLBACK level
577 EfiAcquireLock (&mPcdDatabaseLock
);
580 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
581 // We have to decrement TokenNumber by 1 to make it usable
582 // as the array index.
586 TmpTokenNumber
= TokenNumber
;
588 // EBC compiler is very choosy. It may report warning about comparison
589 // between UINTN and 0 . So we add 1 in each size of the
592 ASSERT (TokenNumber
+ 1 < PCD_TOTAL_TOKEN_NUMBER
+ 1);
595 ASSERT (*Size
== DxePcdGetSize (TokenNumber
+ 1));
598 // EBC compiler is very choosy. It may report warning about comparison
599 // between UINTN and 0 . So we add 1 in each size of the
601 IsPeiDb
= (BOOLEAN
) ((TokenNumber
+ 1 < PEI_LOCAL_TOKEN_NUMBER
+ 1) ? TRUE
: FALSE
);
603 LocalTokenNumberTable
= IsPeiDb
? mPcdDatabase
->PeiDb
.Init
.LocalTokenNumberTable
:
604 mPcdDatabase
->DxeDb
.Init
.LocalTokenNumberTable
;
606 // EBC compiler is very choosy. It may report warning about comparison
607 // between UINTN and 0 . So we add 1 in each size of the
609 if ((TokenNumber
+ 1 < PEI_NEX_TOKEN_NUMBER
+ 1) ||
610 (TokenNumber
+ 1 >= PEI_LOCAL_TOKEN_NUMBER
+ 1 || TokenNumber
+ 1 < (PEI_LOCAL_TOKEN_NUMBER
+ DXE_NEX_TOKEN_NUMBER
+ 1))) {
611 InvokeCallbackOnSet (0, NULL
, TokenNumber
+ 1, Data
, *Size
);
614 TokenNumber
= IsPeiDb
? TokenNumber
615 : TokenNumber
- PEI_LOCAL_TOKEN_NUMBER
;
617 LocalTokenNumber
= LocalTokenNumberTable
[TokenNumber
];
619 if ((LocalTokenNumber
& PCD_TYPE_SKU_ENABLED
) == PCD_TYPE_SKU_ENABLED
) {
621 GetPtrTypeSize (TmpTokenNumber
, &MaxSize
);
625 LocalTokenNumber
= GetSkuEnabledTokenNumber (LocalTokenNumber
& ~PCD_TYPE_SKU_ENABLED
, MaxSize
, IsPeiDb
);
628 Offset
= LocalTokenNumber
& PCD_DATABASE_OFFSET_MASK
;
630 PcdDb
= IsPeiDb
? ((UINT8
*) &mPcdDatabase
->PeiDb
) : ((UINT8
*) &mPcdDatabase
->DxeDb
);
632 StringTable
= IsPeiDb
? mPcdDatabase
->PeiDb
.Init
.StringTable
:
633 mPcdDatabase
->DxeDb
.Init
.StringTable
;
635 InternalData
= PcdDb
+ Offset
;
637 switch (LocalTokenNumber
& PCD_TYPE_ALL_SET
) {
640 Status
= EFI_INVALID_PARAMETER
;
643 case PCD_TYPE_STRING
:
644 if (SetPtrTypeSize (TmpTokenNumber
, Size
)) {
645 CopyMem (&StringTable
[*((UINT16
*)InternalData
)], Data
, *Size
);
646 Status
= EFI_SUCCESS
;
648 Status
= EFI_INVALID_PARAMETER
;
654 if (!SetPtrTypeSize (TmpTokenNumber
, Size
)) {
655 Status
= EFI_INVALID_PARAMETER
;
660 GuidTable
= IsPeiDb
? mPcdDatabase
->PeiDb
.Init
.GuidTable
:
661 mPcdDatabase
->DxeDb
.Init
.GuidTable
;
663 VariableHead
= (VARIABLE_HEAD
*) (PcdDb
+ Offset
);
665 Guid
= &(GuidTable
[VariableHead
->GuidTableIndex
]);
666 Name
= &(StringTable
[VariableHead
->StringIndex
]);
667 VariableOffset
= VariableHead
->Offset
;
669 Status
= SetHiiVariable (Guid
, Name
, Data
, *Size
, VariableOffset
);
671 if (EFI_NOT_FOUND
== Status
) {
672 CopyMem (PcdDb
+ VariableHead
->DefaultValueOffset
, Data
, *Size
);
673 Status
= EFI_SUCCESS
;
679 if (SetPtrTypeSize (TmpTokenNumber
, Size
)) {
680 CopyMem (InternalData
, Data
, *Size
);
681 Status
= EFI_SUCCESS
;
683 Status
= EFI_INVALID_PARAMETER
;
688 Status
= EFI_SUCCESS
;
691 *((UINT8
*) InternalData
) = *((UINT8
*) Data
);
695 *((UINT16
*) InternalData
) = *((UINT16
*) Data
);
699 *((UINT32
*) InternalData
) = *((UINT32
*) Data
);
703 *((UINT64
*) InternalData
) = *((UINT64
*) Data
);
708 Status
= EFI_NOT_FOUND
;
715 Status
= EFI_NOT_FOUND
;
719 EfiReleaseLock (&mPcdDatabaseLock
);
730 IN CONST EFI_GUID
*Guid
,
731 IN UINTN ExTokenNumber
,
735 return GetWorker(GetExPcdTokenNumber (Guid
, (UINT32
) ExTokenNumber
), GetSize
);
743 IN UINTN ExTokenNumber
,
744 IN CONST EFI_GUID
*Guid
,
749 return ExSetWorker (ExTokenNumber
, Guid
, Data
, &SetSize
, FALSE
);
755 IN UINTN ExTokenNumber
,
756 IN CONST EFI_GUID
*Guid
,
758 IN OUT UINTN
*SetSize
,
764 TokenNumber
= GetExPcdTokenNumber (Guid
, (UINT32
) ExTokenNumber
);
766 InvokeCallbackOnSet ((UINT32
) ExTokenNumber
, Guid
, TokenNumber
, Data
, *SetSize
);
768 return SetWorker (TokenNumber
, Data
, SetSize
, PtrType
);
777 IN EFI_GUID
*VariableGuid
,
778 IN UINT16
*VariableName
,
791 Status
= gRT
->GetVariable (
792 (UINT16
*)VariableName
,
799 if (Status
== EFI_BUFFER_TOO_SMALL
) {
801 Buffer
= AllocatePool (Size
);
803 ASSERT (Buffer
!= NULL
);
805 Status
= gRT
->GetVariable (
813 ASSERT_EFI_ERROR (Status
);
815 CopyMem ((UINT8
*)Buffer
+ Offset
, Data
, DataSize
);
817 Status
= gRT
->SetVariable (
831 // If we drop to here, we don't have a Variable entry in
832 // the variable service yet. So, we will save the data
833 // in the PCD Database's volatile area.
843 GetExPcdTokenNumber (
844 IN CONST EFI_GUID
*Guid
,
845 IN UINT32 ExTokenNumber
849 DYNAMICEX_MAPPING
*ExMap
;
854 if (!PEI_DATABASE_EMPTY
) {
855 ExMap
= mPcdDatabase
->PeiDb
.Init
.ExMapTable
;
856 GuidTable
= mPcdDatabase
->PeiDb
.Init
.GuidTable
;
858 MatchGuid
= ScanGuid (GuidTable
, sizeof(mPcdDatabase
->PeiDb
.Init
.GuidTable
), Guid
);
860 if (MatchGuid
!= NULL
) {
862 MatchGuidIdx
= MatchGuid
- GuidTable
;
864 for (i
= 0; i
< PEI_EXMAPPING_TABLE_SIZE
; i
++) {
865 if ((ExTokenNumber
== ExMap
[i
].ExTokenNumber
) &&
866 (MatchGuidIdx
== ExMap
[i
].ExGuidIndex
)) {
867 return ExMap
[i
].LocalTokenNumber
;
874 ExMap
= mPcdDatabase
->DxeDb
.Init
.ExMapTable
;
875 GuidTable
= mPcdDatabase
->DxeDb
.Init
.GuidTable
;
877 MatchGuid
= ScanGuid (GuidTable
, sizeof(mPcdDatabase
->DxeDb
.Init
.GuidTable
), Guid
);
879 // We need to ASSERT here. If GUID can't be found in GuidTable, this is a
880 // error in the BUILD system.
882 ASSERT (MatchGuid
!= NULL
);
884 MatchGuidIdx
= MatchGuid
- GuidTable
;
886 for (i
= 0; i
< DXE_EXMAPPING_TABLE_SIZE
; i
++) {
887 if ((ExTokenNumber
== ExMap
[i
].ExTokenNumber
) &&
888 (MatchGuidIdx
== ExMap
[i
].ExGuidIndex
)) {
889 return ExMap
[i
].LocalTokenNumber
;
902 IN UINTN LocalTokenNumberTableIdx
,
907 UINTN LocalTokenNumber
;
911 LocalTokenNumber
= mPcdDatabase
->PeiDb
.Init
.LocalTokenNumberTable
[LocalTokenNumberTableIdx
];
912 Database
= (UINT8
*) &mPcdDatabase
->PeiDb
;
914 LocalTokenNumber
= mPcdDatabase
->DxeDb
.Init
.LocalTokenNumberTable
[LocalTokenNumberTableIdx
- PEI_LOCAL_TOKEN_NUMBER
];
915 Database
= (UINT8
*) &mPcdDatabase
->DxeDb
;
918 ASSERT ((LocalTokenNumber
& PCD_TYPE_SKU_ENABLED
) != 0);
920 SkuHead
= (SKU_HEAD
*) ((UINT8
*)Database
+ (LocalTokenNumber
& PCD_DATABASE_OFFSET_MASK
));
922 return (SKU_ID
*) (Database
+ SkuHead
->SkuIdTableOffset
);
930 IN UINTN LocalTokenNumberTableIdx
,
931 IN UINT32
*LocalTokenNumberTable
,
937 UINTN LocalTokenNumber
;
942 for (i
=0; i
<LocalTokenNumberTableIdx
; i
++) {
943 LocalTokenNumber
= LocalTokenNumberTable
[i
];
945 if ((LocalTokenNumber
& PCD_DATUM_TYPE_ALL_SET
) == PCD_DATUM_TYPE_POINTER
) {
947 // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
950 if (LocalTokenNumber
& PCD_TYPE_VPD
) {
952 // We have only one entry for VPD enabled PCD entry:
954 // We consider current size is equal to MAX size.
958 if ((LocalTokenNumber
& PCD_TYPE_SKU_ENABLED
) == 0) {
960 // We have only two entry for Non-Sku enabled PCD entry:
967 // We have these entry for SKU enabled PCD entry
969 // 2) Current Size for each SKU_ID (It is equal to MaxSku).
971 SkuIdTable
= GetSkuIdArray (i
, IsPeiDb
);
972 SizeTableIdx
+= (UINTN
)*SkuIdTable
+ 1;
987 IN UINTN LocalTokenNumberTableIdx
,
991 UINT32
*LocalTokenNumberTable
;
994 LocalTokenNumberTable
= mPcdDatabase
->PeiDb
.Init
.LocalTokenNumberTable
;
996 LocalTokenNumberTable
= mPcdDatabase
->DxeDb
.Init
.LocalTokenNumberTable
;
998 return GetSizeTableIndexA (LocalTokenNumberTableIdx
,
999 LocalTokenNumberTable
,
1007 IN UINTN LocalTokenNumberTableIdx
,
1012 UINTN LocalTokenNumber
;
1014 SIZE_INFO
*SizeTable
;
1017 UINT32
*LocalTokenNumberTable
;
1019 // EBC compiler is very choosy. It may report warning about comparison
1020 // between UINTN and 0 . So we add 1 in each size of the
1022 IsPeiDb
= (BOOLEAN
) (LocalTokenNumberTableIdx
+ 1 < PEI_LOCAL_TOKEN_NUMBER
+ 1);
1026 LocalTokenNumberTable
= mPcdDatabase
->PeiDb
.Init
.LocalTokenNumberTable
;
1027 SizeTable
= mPcdDatabase
->PeiDb
.Init
.SizeTable
;
1029 LocalTokenNumberTableIdx
-= PEI_LOCAL_TOKEN_NUMBER
;
1030 LocalTokenNumberTable
= mPcdDatabase
->DxeDb
.Init
.LocalTokenNumberTable
;
1031 SizeTable
= mPcdDatabase
->DxeDb
.Init
.SizeTable
;
1034 LocalTokenNumber
= LocalTokenNumberTable
[LocalTokenNumberTableIdx
];
1036 ASSERT ((LocalTokenNumber
& PCD_DATUM_TYPE_ALL_SET
) == PCD_DATUM_TYPE_POINTER
);
1038 SizeTableIdx
= GetSizeTableIndex (LocalTokenNumberTableIdx
, IsPeiDb
);
1040 *MaxSize
= SizeTable
[SizeTableIdx
];
1042 // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
1045 if (LocalTokenNumber
& PCD_TYPE_VPD
) {
1047 // We have only one entry for VPD enabled PCD entry:
1049 // We consider current size is equal to MAX size.
1053 if ((LocalTokenNumber
& PCD_TYPE_SKU_ENABLED
) == 0) {
1055 // We have only two entry for Non-Sku enabled PCD entry:
1059 return SizeTable
[SizeTableIdx
+ 1];
1062 // We have these entry for SKU enabled PCD entry
1064 // 2) Current Size for each SKU_ID (It is equal to MaxSku).
1066 SkuIdTable
= GetSkuIdArray (LocalTokenNumberTableIdx
, IsPeiDb
);
1067 for (i
= 0; i
< SkuIdTable
[0]; i
++) {
1068 if (SkuIdTable
[1 + i
] == mPcdDatabase
->PeiDb
.Init
.SystemSkuId
) {
1069 return SizeTable
[SizeTableIdx
+ 1 + i
];
1072 return SizeTable
[SizeTableIdx
+ 1];
1081 IN UINTN LocalTokenNumberTableIdx
,
1082 IN OUT UINTN
*CurrentSize
1086 UINTN LocalTokenNumber
;
1088 SIZE_INFO
*SizeTable
;
1092 UINT32
*LocalTokenNumberTable
;
1094 // EBC compiler is very choosy. It may report warning about comparison
1095 // between UINTN and 0 . So we add 1 in each size of the
1097 IsPeiDb
= (BOOLEAN
) (LocalTokenNumberTableIdx
+ 1 < PEI_LOCAL_TOKEN_NUMBER
+ 1);
1100 LocalTokenNumberTable
= mPcdDatabase
->PeiDb
.Init
.LocalTokenNumberTable
;
1101 SizeTable
= mPcdDatabase
->PeiDb
.Init
.SizeTable
;
1103 LocalTokenNumberTableIdx
-= PEI_LOCAL_TOKEN_NUMBER
;
1104 LocalTokenNumberTable
= mPcdDatabase
->DxeDb
.Init
.LocalTokenNumberTable
;
1105 SizeTable
= mPcdDatabase
->DxeDb
.Init
.SizeTable
;
1108 LocalTokenNumber
= LocalTokenNumberTable
[LocalTokenNumberTableIdx
];
1110 ASSERT ((LocalTokenNumber
& PCD_DATUM_TYPE_ALL_SET
) == PCD_DATUM_TYPE_POINTER
);
1112 SizeTableIdx
= GetSizeTableIndex (LocalTokenNumberTableIdx
, IsPeiDb
);
1114 MaxSize
= SizeTable
[SizeTableIdx
];
1116 // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
1119 if (LocalTokenNumber
& PCD_TYPE_VPD
) {
1121 // We shouldn't come here as we don't support SET for VPD
1126 if ((*CurrentSize
> MaxSize
) ||
1127 (*CurrentSize
== MAX_ADDRESS
)) {
1128 *CurrentSize
= MaxSize
;
1132 if ((LocalTokenNumber
& PCD_TYPE_SKU_ENABLED
) == 0) {
1134 // We have only two entry for Non-Sku enabled PCD entry:
1138 SizeTable
[SizeTableIdx
+ 1] = (SIZE_INFO
) *CurrentSize
;
1142 // We have these entry for SKU enabled PCD entry
1144 // 2) Current Size for each SKU_ID (It is equal to MaxSku).
1146 SkuIdTable
= GetSkuIdArray (LocalTokenNumberTableIdx
, IsPeiDb
);
1147 for (i
= 0; i
< SkuIdTable
[0]; i
++) {
1148 if (SkuIdTable
[1 + i
] == mPcdDatabase
->PeiDb
.Init
.SystemSkuId
) {
1149 SizeTable
[SizeTableIdx
+ 1 + i
] = (SIZE_INFO
) *CurrentSize
;
1153 SizeTable
[SizeTableIdx
+ 1] = (SIZE_INFO
) *CurrentSize
;