]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/PCD/Pei/Service.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Use single one PcdFrameworkCompatibilitySupport PCD to support framework HII and...
[mirror_edk2.git] / MdeModulePkg / Universal / PCD / Pei / Service.c
1 /** @file
2 The driver internal functions are implmented here.
3 They build Pei PCD database, and provide access service to PCD database.
4
5 Copyright (c) 2006 - 2008, Intel Corporation
6 All rights reserved. This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 #include "Service.h"
17
18 /**
19 The function registers the CallBackOnSet fucntion
20 according to TokenNumber and EFI_GUID space.
21
22 @param ExTokenNumber The token number.
23 @param Guid The GUID space.
24 @param CallBackFunction The Callback function to be registered.
25 @param Register To register or unregister the callback function.
26
27 @retval EFI_SUCCESS If the Callback function is registered.
28 @retval EFI_NOT_FOUND If the PCD Entry is not found according to Token Number and GUID space.
29 @retval EFI_OUT_OF_RESOURCES If the callback function can't be registered because there is not free
30 slot left in the CallbackFnTable.
31 **/
32 EFI_STATUS
33 PeiRegisterCallBackWorker (
34 IN UINTN ExTokenNumber,
35 IN CONST EFI_GUID *Guid, OPTIONAL
36 IN PCD_PPI_CALLBACK CallBackFunction,
37 IN BOOLEAN Register
38 )
39 {
40 EFI_HOB_GUID_TYPE *GuidHob;
41 PCD_PPI_CALLBACK *CallbackTable;
42 PCD_PPI_CALLBACK Compare;
43 PCD_PPI_CALLBACK Assign;
44 UINT32 LocalTokenNumber;
45 UINTN TokenNumber;
46 UINTN Idx;
47
48 if (Guid == NULL) {
49 TokenNumber = ExTokenNumber;
50
51 //
52 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
53 // We have to decrement TokenNumber by 1 to make it usable
54 // as the array index.
55 //
56 TokenNumber--;
57 ASSERT (TokenNumber + 1 < PEI_NEX_TOKEN_NUMBER + 1);
58 } else {
59 TokenNumber = GetExPcdTokenNumber (Guid, ExTokenNumber);
60
61 //
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.
65 //
66 TokenNumber--;
67 // EBC compiler is very choosy. It may report warning about comparison
68 // between UINTN and 0 . So we add 1 in each size of the
69 // comparison.
70 ASSERT (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);
71 }
72
73
74 LocalTokenNumber = GetPcdDatabase()->Init.LocalTokenNumberTable[TokenNumber];
75
76 //
77 // We don't support SET for HII and VPD type PCD entry in PEI phase.
78 // So we will assert if any register callback for such PCD entry.
79 //
80 ASSERT ((LocalTokenNumber & PCD_TYPE_HII) == 0);
81 ASSERT ((LocalTokenNumber & PCD_TYPE_VPD) == 0);
82
83 GuidHob = GetFirstGuidHob (&gEfiCallerIdGuid);
84 ASSERT (GuidHob != NULL);
85
86 CallbackTable = GET_GUID_HOB_DATA (GuidHob);
87 CallbackTable = CallbackTable + (TokenNumber * FixedPcdGet32(PcdMaxPeiPcdCallBackNumberPerPcdEntry));
88
89 Compare = Register? NULL: CallBackFunction;
90 Assign = Register? CallBackFunction: NULL;
91
92
93 for (Idx = 0; Idx < FixedPcdGet32(PcdMaxPeiPcdCallBackNumberPerPcdEntry); Idx++) {
94 if (CallbackTable[Idx] == Compare) {
95 CallbackTable[Idx] = Assign;
96 return EFI_SUCCESS;
97 }
98 }
99
100 return Register? EFI_OUT_OF_RESOURCES : EFI_NOT_FOUND;
101
102 }
103
104 /**
105 The function builds the PCD database.
106 **/
107 VOID
108 BuildPcdDatabase (
109 VOID
110 )
111 {
112 PEI_PCD_DATABASE *Database;
113 VOID *CallbackFnTable;
114 UINTN SizeOfCallbackFnTable;
115
116 Database = BuildGuidHob (&gPcdDataBaseHobGuid, sizeof (PEI_PCD_DATABASE));
117
118 ZeroMem (Database, sizeof (PEI_PCD_DATABASE));
119
120 //
121 // gPEIPcdDbInit is smaller than PEI_PCD_DATABASE
122 //
123
124 CopyMem (&Database->Init, &gPEIPcdDbInit, sizeof (gPEIPcdDbInit));
125
126 SizeOfCallbackFnTable = PEI_LOCAL_TOKEN_NUMBER * sizeof (PCD_PPI_CALLBACK) * FixedPcdGet32(PcdMaxPeiPcdCallBackNumberPerPcdEntry);
127
128 CallbackFnTable = BuildGuidHob (&gEfiCallerIdGuid, SizeOfCallbackFnTable);
129
130 ZeroMem (CallbackFnTable, SizeOfCallbackFnTable);
131 }
132
133 /**
134 The function is provided by PCD PEIM and PCD DXE driver to
135 do the work of reading a HII variable from variable service.
136
137 @param VariableGuid The Variable GUID.
138 @param VariableName The Variable Name.
139 @param VariableData The output data.
140 @param VariableSize The size of the variable.
141
142 @retval EFI_SUCCESS Operation successful.
143 @retval EFI_NOT_FOUND Variablel not found.
144 **/
145 EFI_STATUS
146 GetHiiVariable (
147 IN CONST EFI_GUID *VariableGuid,
148 IN UINT16 *VariableName,
149 OUT VOID **VariableData,
150 OUT UINTN *VariableSize
151 )
152 {
153 UINTN Size;
154 EFI_STATUS Status;
155 VOID *Buffer;
156 EFI_PEI_READ_ONLY_VARIABLE2_PPI *VariablePpi;
157
158 Status = PeiServicesLocatePpi (&gEfiPeiReadOnlyVariable2PpiGuid, 0, NULL, (VOID **) &VariablePpi);
159 ASSERT_EFI_ERROR (Status);
160
161 Size = 0;
162 Status = VariablePpi->GetVariable (
163 VariablePpi,
164 VariableName,
165 (EFI_GUID *) VariableGuid,
166 NULL,
167 &Size,
168 NULL
169 );
170
171 if (Status == EFI_BUFFER_TOO_SMALL) {
172 Status = PeiServicesAllocatePool (Size, &Buffer);
173 ASSERT_EFI_ERROR (Status);
174
175 Status = VariablePpi->GetVariable (
176 VariablePpi,
177 (UINT16 *) VariableName,
178 (EFI_GUID *) VariableGuid,
179 NULL,
180 &Size,
181 Buffer
182 );
183 ASSERT_EFI_ERROR (Status);
184
185 *VariableSize = Size;
186 *VariableData = Buffer;
187
188 return EFI_SUCCESS;
189 }
190
191 return EFI_NOT_FOUND;
192 }
193
194 /**
195 Find the local token number according to system SKU ID.
196
197 @param LocalTokenNumber PCD token number
198 @param Size The size of PCD entry.
199
200 @return Token number according to system SKU ID.
201
202 **/
203 UINT32
204 GetSkuEnabledTokenNumber (
205 UINT32 LocalTokenNumber,
206 UINTN Size
207 )
208 {
209 PEI_PCD_DATABASE *PeiPcdDb;
210 SKU_HEAD *SkuHead;
211 SKU_ID *SkuIdTable;
212 INTN Index;
213 UINT8 *Value;
214
215 PeiPcdDb = GetPcdDatabase ();
216
217 ASSERT ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0);
218
219 SkuHead = (SKU_HEAD *) ((UINT8 *)PeiPcdDb + (LocalTokenNumber & PCD_DATABASE_OFFSET_MASK));
220 Value = (UINT8 *) ((UINT8 *)PeiPcdDb + (SkuHead->SkuDataStartOffset));
221 SkuIdTable = (SKU_ID *) ((UINT8 *)PeiPcdDb + (SkuHead->SkuIdTableOffset));
222
223 for (Index = 0; Index < SkuIdTable[0]; Index++) {
224 if (PeiPcdDb->Init.SystemSkuId == SkuIdTable[Index + 1]) {
225 break;
226 }
227 }
228
229 switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
230 case PCD_TYPE_VPD:
231 Value = (UINT8 *) &(((VPD_HEAD *) Value)[Index]);
232 return (UINT32) ((Value - (UINT8 *) PeiPcdDb) | PCD_TYPE_VPD);
233
234 case PCD_TYPE_HII:
235 Value = (UINT8 *) &(((VARIABLE_HEAD *) Value)[Index]);
236 return (UINT32) ((Value - (UINT8 *) PeiPcdDb) | PCD_TYPE_HII);
237
238 case PCD_TYPE_STRING:
239 Value = (UINT8 *) &(((STRING_HEAD *) Value)[Index]);
240 return (UINT32) ((Value - (UINT8 *) PeiPcdDb) | PCD_TYPE_STRING);
241
242 case PCD_TYPE_DATA:
243 Value += Size * Index;
244 return (UINT32) (Value - (UINT8 *) PeiPcdDb);
245
246 default:
247 ASSERT (FALSE);
248 }
249
250 ASSERT (FALSE);
251
252 return 0;
253 }
254
255 /**
256 Invoke the callback function when dynamic PCD entry was set, if this PCD entry
257 has registered callback function.
258
259 @param ExTokenNumber DynamicEx PCD's token number, if this PCD entry is dyanmicEx
260 type PCD.
261 @param Guid DynamicEx PCD's guid, if this PCD entry is dynamicEx type
262 PCD.
263 @param TokenNumber PCD token number generated by build tools.
264 @param Data Value want to be set for this PCD entry
265 @param Size The size of value
266
267 **/
268 VOID
269 InvokeCallbackOnSet (
270 UINTN ExTokenNumber,
271 CONST EFI_GUID *Guid, OPTIONAL
272 UINTN TokenNumber,
273 VOID *Data,
274 UINTN Size
275 )
276 {
277 EFI_HOB_GUID_TYPE *GuidHob;
278 PCD_PPI_CALLBACK *CallbackTable;
279 UINTN Idx;
280
281 //
282 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
283 // We have to decrement TokenNumber by 1 to make it usable
284 // as the array index.
285 //
286 TokenNumber--;
287
288 if (Guid == NULL) {
289 // EBC compiler is very choosy. It may report warning about comparison
290 // between UINTN and 0 . So we add 1 in each size of the
291 // comparison.
292 ASSERT (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);
293 }
294
295 GuidHob = GetFirstGuidHob (&gEfiCallerIdGuid);
296 ASSERT (GuidHob != NULL);
297
298 CallbackTable = GET_GUID_HOB_DATA (GuidHob);
299
300 CallbackTable += (TokenNumber * FixedPcdGet32(PcdMaxPeiPcdCallBackNumberPerPcdEntry));
301
302 for (Idx = 0; Idx < FixedPcdGet32(PcdMaxPeiPcdCallBackNumberPerPcdEntry); Idx++) {
303 if (CallbackTable[Idx] != NULL) {
304 CallbackTable[Idx] (Guid,
305 (Guid == NULL)? TokenNumber: ExTokenNumber,
306 Data,
307 Size
308 );
309 }
310 }
311 }
312
313 /**
314 Wrapper function for setting non-pointer type value for a PCD entry.
315
316 @param TokenNumber Pcd token number autogenerated by build tools.
317 @param Data Value want to be set for PCD entry
318 @param Size Size of value.
319
320 @return status of SetWorker.
321
322 **/
323 EFI_STATUS
324 SetValueWorker (
325 IN UINTN TokenNumber,
326 IN VOID *Data,
327 IN UINTN Size
328 )
329 {
330 return SetWorker (TokenNumber, Data, &Size, FALSE);
331 }
332
333 /**
334 Set value for an PCD entry
335
336 @param TokenNumber Pcd token number autogenerated by build tools.
337 @param Data Value want to be set for PCD entry
338 @param Size Size of value.
339 @param PtrType If TRUE, the type of PCD entry's value is Pointer.
340 If False, the type of PCD entry's value is not Pointer.
341
342 @retval EFI_INVALID_PARAMETER If this PCD type is VPD, VPD PCD can not be set.
343 @retval EFI_INVALID_PARAMETER If Size can not be set to size table.
344 @retval EFI_NOT_FOUND If value type of PCD entry is intergrate, but not in
345 range of UINT8, UINT16, UINT32, UINT64
346 @retval EFI_NOT_FOUND Can not find the PCD type according to token number.
347 **/
348 EFI_STATUS
349 SetWorker (
350 IN UINTN TokenNumber,
351 IN VOID *Data,
352 IN OUT UINTN *Size,
353 IN BOOLEAN PtrType
354 )
355 {
356 UINT32 LocalTokenNumber;
357 PEI_PCD_DATABASE *PeiPcdDb;
358 UINT16 StringTableIdx;
359 UINTN Offset;
360 VOID *InternalData;
361 UINTN MaxSize;
362
363 if (!FeaturePcdGet(PcdPeiFullPcdDatabaseEnable)) {
364 return EFI_UNSUPPORTED;
365 }
366
367 //
368 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
369 // We have to decrement TokenNumber by 1 to make it usable
370 // as the array index.
371 //
372 TokenNumber--;
373
374 // EBC compiler is very choosy. It may report warning about comparison
375 // between UINTN and 0 . So we add 1 in each size of the
376 // comparison.
377 ASSERT (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);
378
379 PeiPcdDb = GetPcdDatabase ();
380
381 LocalTokenNumber = PeiPcdDb->Init.LocalTokenNumberTable[TokenNumber];
382
383 if (!PtrType) {
384 ASSERT (PeiPcdGetSize(TokenNumber + 1) == *Size);
385 }
386
387 //
388 // We only invoke the callback function for Dynamic Type PCD Entry.
389 // For Dynamic EX PCD entry, we have invoked the callback function for Dynamic EX
390 // type PCD entry in ExSetWorker.
391 //
392 if (TokenNumber + 1 < PEI_NEX_TOKEN_NUMBER + 1) {
393 InvokeCallbackOnSet (0, NULL, TokenNumber + 1, Data, *Size);
394 }
395
396 if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {
397 if (PtrType) {
398 MaxSize = GetPtrTypeSize (TokenNumber, &MaxSize, PeiPcdDb);
399 } else {
400 MaxSize = *Size;
401 }
402 LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, MaxSize);
403 }
404
405 Offset = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;
406 InternalData = (VOID *) ((UINT8 *) PeiPcdDb + Offset);
407
408 switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
409 case PCD_TYPE_VPD:
410 case PCD_TYPE_HII:
411 {
412 ASSERT (FALSE);
413 return EFI_INVALID_PARAMETER;
414 }
415
416 case PCD_TYPE_STRING:
417 if (SetPtrTypeSize (TokenNumber, Size, PeiPcdDb)) {
418 StringTableIdx = *((UINT16 *)InternalData);
419 CopyMem (&PeiPcdDb->Init.StringTable[StringTableIdx], Data, *Size);
420 return EFI_SUCCESS;
421 } else {
422 return EFI_INVALID_PARAMETER;
423 }
424
425 case PCD_TYPE_DATA:
426 {
427 if (PtrType) {
428 if (SetPtrTypeSize (TokenNumber, Size, PeiPcdDb)) {
429 CopyMem (InternalData, Data, *Size);
430 return EFI_SUCCESS;
431 } else {
432 return EFI_INVALID_PARAMETER;
433 }
434 }
435
436 switch (*Size) {
437 case sizeof(UINT8):
438 *((UINT8 *) InternalData) = *((UINT8 *) Data);
439 return EFI_SUCCESS;
440
441 case sizeof(UINT16):
442 *((UINT16 *) InternalData) = *((UINT16 *) Data);
443 return EFI_SUCCESS;
444
445 case sizeof(UINT32):
446 *((UINT32 *) InternalData) = *((UINT32 *) Data);
447 return EFI_SUCCESS;
448
449 case sizeof(UINT64):
450 *((UINT64 *) InternalData) = *((UINT64 *) Data);
451 return EFI_SUCCESS;
452
453 default:
454 ASSERT (FALSE);
455 return EFI_NOT_FOUND;
456 }
457 }
458
459 }
460
461 ASSERT (FALSE);
462 return EFI_NOT_FOUND;
463
464 }
465
466 /**
467 Wrapper function for set PCD value for non-Pointer type dynamic-ex PCD.
468
469 @param ExTokenNumber Token number for dynamic-ex PCD.
470 @param Guid Token space guid for dynamic-ex PCD.
471 @param Data Value want to be set.
472 @param SetSize The size of value.
473
474 @return status of ExSetWorker().
475
476 **/
477 EFI_STATUS
478 ExSetValueWorker (
479 IN UINTN ExTokenNumber,
480 IN CONST EFI_GUID *Guid,
481 IN VOID *Data,
482 IN UINTN Size
483 )
484 {
485 return ExSetWorker (ExTokenNumber, Guid, Data, &Size, FALSE);
486 }
487
488 /**
489 Set value for a dynamic PCD entry.
490
491 This routine find the local token number according to dynamic-ex PCD's token
492 space guid and token number firstly, and invoke callback function if this PCD
493 entry registered callback function. Finally, invoken general SetWorker to set
494 PCD value.
495
496 @param ExTokenNumber Dynamic-ex PCD token number.
497 @param Guid Token space guid for dynamic-ex PCD.
498 @param Data PCD value want to be set
499 @param SetSize Size of value.
500 @param PtrType If TRUE, this PCD entry is pointer type.
501 If FALSE, this PCD entry is not pointer type.
502
503 @return status of SetWorker().
504
505 **/
506 EFI_STATUS
507 ExSetWorker (
508 IN UINTN ExTokenNumber,
509 IN CONST EFI_GUID *Guid,
510 IN VOID *Data,
511 IN OUT UINTN *Size,
512 IN BOOLEAN PtrType
513 )
514 {
515 UINTN TokenNumber;
516
517 if (!FeaturePcdGet(PcdPeiFullPcdDatabaseEnable)) {
518 return EFI_UNSUPPORTED;
519 }
520
521 TokenNumber = GetExPcdTokenNumber (Guid, ExTokenNumber);
522
523 InvokeCallbackOnSet (ExTokenNumber, Guid, TokenNumber, Data, *Size);
524
525 return SetWorker (TokenNumber, Data, Size, PtrType);
526
527 }
528
529 /**
530 Wrapper function for get PCD value for dynamic-ex PCD.
531
532 @param Guid Token space guid for dynamic-ex PCD.
533 @param ExTokenNumber Token number for dyanmic-ex PCD.
534 @param GetSize The size of dynamic-ex PCD value.
535
536 @return PCD entry in PCD database.
537
538 **/
539 VOID *
540 ExGetWorker (
541 IN CONST EFI_GUID *Guid,
542 IN UINTN ExTokenNumber,
543 IN UINTN GetSize
544 )
545 {
546 return GetWorker (GetExPcdTokenNumber (Guid, ExTokenNumber), GetSize);
547 }
548
549 /**
550 Get the PCD entry pointer in PCD database.
551
552 This routine will visit PCD database to find the PCD entry according to given
553 token number. The given token number is autogened by build tools and it will be
554 translated to local token number. Local token number contains PCD's type and
555 offset of PCD entry in PCD database.
556
557 @param TokenNumber Token's number, it is autogened by build tools
558 @param GetSize The size of token's value
559
560 @return PCD entry pointer in PCD database
561
562 **/
563 VOID *
564 GetWorker (
565 IN UINTN TokenNumber,
566 IN UINTN GetSize
567 )
568 {
569 UINT32 Offset;
570 EFI_GUID *Guid;
571 UINT16 *Name;
572 VARIABLE_HEAD *VariableHead;
573 EFI_STATUS Status;
574 UINTN DataSize;
575 VOID *Data;
576 UINT16 *StringTable;
577 UINT16 StringTableIdx;
578 PEI_PCD_DATABASE *PeiPcdDb;
579 UINT32 LocalTokenNumber;
580 UINTN MaxSize;
581
582 //
583 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
584 // We have to decrement TokenNumber by 1 to make it usable
585 // as the array index.
586 //
587 TokenNumber--;
588
589 // EBC compiler is very choosy. It may report warning about comparison
590 // between UINTN and 0 . So we add 1 in each size of the
591 // comparison.
592 ASSERT (TokenNumber + 1 < PEI_LOCAL_TOKEN_NUMBER + 1);
593
594 ASSERT ((GetSize == PeiPcdGetSize(TokenNumber + 1)) || (GetSize == 0));
595
596 PeiPcdDb = GetPcdDatabase ();
597
598 LocalTokenNumber = PeiPcdDb->Init.LocalTokenNumberTable[TokenNumber];
599
600 if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {
601 if (GetSize == 0) {
602 MaxSize = GetPtrTypeSize (TokenNumber, &MaxSize, PeiPcdDb);
603 } else {
604 MaxSize = GetSize;
605 }
606 LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, MaxSize);
607 }
608
609 Offset = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;
610 StringTable = PeiPcdDb->Init.StringTable;
611
612 switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
613 case PCD_TYPE_VPD:
614 {
615 VPD_HEAD *VpdHead;
616 VpdHead = (VPD_HEAD *) ((UINT8 *)PeiPcdDb + Offset);
617 return (VOID *) (UINTN) (FixedPcdGet32(PcdVpdBaseAddress) + VpdHead->Offset);
618 }
619
620 case PCD_TYPE_HII:
621 {
622 VariableHead = (VARIABLE_HEAD *) ((UINT8 *)PeiPcdDb + Offset);
623
624 Guid = &(PeiPcdDb->Init.GuidTable[VariableHead->GuidTableIndex]);
625 Name = &StringTable[VariableHead->StringIndex];
626
627 Status = GetHiiVariable (Guid, Name, &Data, &DataSize);
628
629 if (Status == EFI_SUCCESS) {
630 return (VOID *) ((UINT8 *) Data + VariableHead->Offset);
631 } else {
632 //
633 // Return the default value specified by Platform Integrator
634 //
635 return (VOID *) ((UINT8 *) PeiPcdDb + VariableHead->DefaultValueOffset);
636 }
637 }
638
639 case PCD_TYPE_DATA:
640 return (VOID *) ((UINT8 *)PeiPcdDb + Offset);
641
642 case PCD_TYPE_STRING:
643 StringTableIdx = (UINT16) *((UINT8 *) PeiPcdDb + Offset);
644 return (VOID *) (&StringTable[StringTableIdx]);
645
646 default:
647 ASSERT (FALSE);
648 break;
649
650 }
651
652 ASSERT (FALSE);
653
654 return NULL;
655
656 }
657
658 /**
659 Get local token number according to dynamic-ex PCD's {token space guid:token number}
660
661 A dynamic-ex type PCD, developer must provide pair of token space guid: token number
662 in DEC file. PCD database maintain a mapping table that translate pair of {token
663 space guid: token number} to local token number.
664
665 @param Guid Token space guid for dynamic-ex PCD entry.
666 @param ExTokenNumber EDES_TODO: Add parameter description
667
668 @return local token number for dynamic-ex PCD.
669
670 **/
671 UINTN
672 GetExPcdTokenNumber (
673 IN CONST EFI_GUID *Guid,
674 IN UINTN ExTokenNumber
675 )
676 {
677 UINT32 Index;
678 DYNAMICEX_MAPPING *ExMap;
679 EFI_GUID *GuidTable;
680 EFI_GUID *MatchGuid;
681 UINTN MatchGuidIdx;
682 PEI_PCD_DATABASE *PeiPcdDb;
683
684 PeiPcdDb = GetPcdDatabase();
685
686 ExMap = PeiPcdDb->Init.ExMapTable;
687 GuidTable = PeiPcdDb->Init.GuidTable;
688
689 MatchGuid = ScanGuid (GuidTable, sizeof(PeiPcdDb->Init.GuidTable), Guid);
690 //
691 // We need to ASSERT here. If GUID can't be found in GuidTable, this is a
692 // error in the BUILD system.
693 //
694 ASSERT (MatchGuid != NULL);
695
696 MatchGuidIdx = MatchGuid - GuidTable;
697
698 for (Index = 0; Index < PEI_EXMAPPING_TABLE_SIZE; Index++) {
699 if ((ExTokenNumber == ExMap[Index].ExTokenNumber) &&
700 (MatchGuidIdx == ExMap[Index].ExGuidIndex)) {
701 return ExMap[Index].LocalTokenNumber;
702 }
703 }
704
705 ASSERT (FALSE);
706
707 return 0;
708 }
709
710 /**
711 Get PCD database from GUID HOB in PEI phase.
712
713 @return Pointer to PCD database.
714
715 **/
716 PEI_PCD_DATABASE *
717 GetPcdDatabase (
718 VOID
719 )
720 {
721 EFI_HOB_GUID_TYPE *GuidHob;
722
723 GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
724 ASSERT (GuidHob != NULL);
725
726 return (PEI_PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob);
727 }
728
729 /**
730 Get SKU ID tabble from PCD database.
731
732 @param LocalTokenNumberTableIdx Index of local token number in token number table.
733 @param Database PCD database.
734
735 @return Pointer to SKU ID array table
736
737 **/
738 SKU_ID *
739 GetSkuIdArray (
740 IN UINTN LocalTokenNumberTableIdx,
741 IN PEI_PCD_DATABASE *Database
742 )
743 {
744 SKU_HEAD *SkuHead;
745 UINTN LocalTokenNumber;
746
747 LocalTokenNumber = Database->Init.LocalTokenNumberTable[LocalTokenNumberTableIdx];
748
749 ASSERT ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) != 0);
750
751 SkuHead = (SKU_HEAD *) ((UINT8 *)Database + (LocalTokenNumber & PCD_DATABASE_OFFSET_MASK));
752
753 return (SKU_ID *) ((UINT8 *)Database + SkuHead->SkuIdTableOffset);
754
755 }
756
757 /**
758 Get index of PCD entry in size table.
759
760 @param LocalTokenNumberTableIdx Index of this PCD in local token number table.
761 @param Database Pointer to PCD database in PEI phase.
762
763 @return index of PCD entry in size table.
764
765 **/
766 UINTN
767 GetSizeTableIndex (
768 IN UINTN LocalTokenNumberTableIdx,
769 IN PEI_PCD_DATABASE *Database
770 )
771 {
772 UINTN Index;
773 UINTN SizeTableIdx;
774 UINTN LocalTokenNumber;
775 SKU_ID *SkuIdTable;
776
777 SizeTableIdx = 0;
778
779 for (Index=0; Index<LocalTokenNumberTableIdx; Index++) {
780 LocalTokenNumber = Database->Init.LocalTokenNumberTable[Index];
781
782 if ((LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) == PCD_DATUM_TYPE_POINTER) {
783 //
784 // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
785 // PCD entry.
786 //
787 if ((LocalTokenNumber & PCD_TYPE_VPD) != 0) {
788 //
789 // We have only one entry for VPD enabled PCD entry:
790 // 1) MAX Size.
791 // We consider current size is equal to MAX size.
792 //
793 SizeTableIdx++;
794 } else {
795 if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0) {
796 //
797 // We have only two entry for Non-Sku enabled PCD entry:
798 // 1) MAX SIZE
799 // 2) Current Size
800 //
801 SizeTableIdx += 2;
802 } else {
803 //
804 // We have these entry for SKU enabled PCD entry
805 // 1) MAX SIZE
806 // 2) Current Size for each SKU_ID (It is equal to MaxSku).
807 //
808 SkuIdTable = GetSkuIdArray (Index, Database);
809 SizeTableIdx += (UINTN)*SkuIdTable + 1;
810 }
811 }
812 }
813
814 }
815
816 return SizeTableIdx;
817 }
EFI Development Kit II mirror for PVE