]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/PCD/Dxe/Service.c
projects / mirror_edk2.git / blob
? search:


4cbf6dd209ec6e72662e46311f96a019fcf8d63e
[mirror_edk2.git] / MdeModulePkg / Universal / PCD / Dxe / Service.c
1 /** @file
2 Help functions used by PCD DXE driver.
3
4 Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "Service.h"
16 #include <Library/DxeServicesLib.h>
17
18 PCD_DATABASE mPcdDatabase;
19
20 UINT32 mPcdTotalTokenCount;
21 UINT32 mPeiLocalTokenCount;
22 UINT32 mDxeLocalTokenCount;
23 UINT32 mPeiNexTokenCount;
24 UINT32 mDxeNexTokenCount;
25 UINT32 mPeiExMapppingTableSize;
26 UINT32 mDxeExMapppingTableSize;
27 UINT32 mPeiGuidTableSize;
28 UINT32 mDxeGuidTableSize;
29
30 BOOLEAN mPeiExMapTableEmpty;
31 BOOLEAN mDxeExMapTableEmpty;
32 BOOLEAN mPeiDatabaseEmpty;
33
34 LIST_ENTRY *mCallbackFnTable;
35 EFI_GUID **TmpTokenSpaceBuffer;
36 UINTN TmpTokenSpaceBufferCount;
37
38 /**
39 Get Local Token Number by Token Number.
40
41 @param[in] IsPeiDb If TRUE, the pcd entry is initialized in PEI phase,
42 If FALSE, the pcd entry is initialized in DXE phase.
43 @param[in] TokenNumber The PCD token number.
44
45 @return Local Token Number.
46 **/
47 UINT32
48 GetLocalTokenNumber (
49 IN BOOLEAN IsPeiDb,
50 IN UINTN TokenNumber
51 )
52 {
53 UINTN TmpTokenNumber;
54 UINT32 *LocalTokenNumberTable;
55 UINT32 LocalTokenNumber;
56 UINTN Size;
57 UINTN MaxSize;
58
59 //
60 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
61 // We have to decrement TokenNumber by 1 to make it usable
62 // as the array index.
63 //
64 TokenNumber--;
65
66 //
67 // Backup the TokenNumber passed in as GetPtrTypeSize need the original TokenNumber
68 //
69 TmpTokenNumber = TokenNumber;
70
71 LocalTokenNumberTable = IsPeiDb ? (UINT32 *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->LocalTokenNumberTableOffset) :
72 (UINT32 *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->LocalTokenNumberTableOffset);
73 TokenNumber = IsPeiDb ? TokenNumber : TokenNumber - mPeiLocalTokenCount;
74
75 LocalTokenNumber = LocalTokenNumberTable[TokenNumber];
76
77 Size = (LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) >> PCD_DATUM_TYPE_SHIFT;
78
79 if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {
80 if (Size == 0) {
81 GetPtrTypeSize (TmpTokenNumber, &MaxSize);
82 } else {
83 MaxSize = Size;
84 }
85 LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, MaxSize, IsPeiDb);
86 }
87
88 return LocalTokenNumber;
89 }
90
91 /**
92 Get PCD type by Local Token Number.
93
94 @param[in] LocalTokenNumber The PCD local token number.
95
96 @return PCD type.
97 **/
98 EFI_PCD_TYPE
99 GetPcdType (
100 IN UINT32 LocalTokenNumber
101 )
102 {
103 switch (LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) {
104 case PCD_DATUM_TYPE_POINTER:
105 return EFI_PCD_TYPE_PTR;
106 case PCD_DATUM_TYPE_UINT8:
107 if ((LocalTokenNumber & PCD_DATUM_TYPE_UINT8_BOOLEAN) == PCD_DATUM_TYPE_UINT8_BOOLEAN) {
108 return EFI_PCD_TYPE_BOOL;
109 } else {
110 return EFI_PCD_TYPE_8;
111 }
112 case PCD_DATUM_TYPE_UINT16:
113 return EFI_PCD_TYPE_16;
114 case PCD_DATUM_TYPE_UINT32:
115 return EFI_PCD_TYPE_32;
116 case PCD_DATUM_TYPE_UINT64:
117 return EFI_PCD_TYPE_64;
118 default:
119 ASSERT (FALSE);
120 return EFI_PCD_TYPE_8;
121 }
122 }
123
124 /**
125 Get PCD name.
126
127 @param[in] OnlyTokenSpaceName If TRUE, only need to get the TokenSpaceCName.
128 If FALSE, need to get the full PCD name.
129 @param[in] IsPeiDb If TRUE, the pcd entry is initialized in PEI phase,
130 If FALSE, the pcd entry is initialized in DXE phase.
131 @param[in] TokenNumber The PCD token number.
132
133 @return The TokenSpaceCName or full PCD name.
134 **/
135 CHAR8 *
136 GetPcdName (
137 IN BOOLEAN OnlyTokenSpaceName,
138 IN BOOLEAN IsPeiDb,
139 IN UINTN TokenNumber
140 )
141 {
142 PCD_DATABASE_INIT *Database;
143 UINT8 *StringTable;
144 PCD_NAME_INDEX *PcdNameIndex;
145 CHAR8 *TokenSpaceName;
146 CHAR8 *PcdName;
147 CHAR8 *Name;
148
149 //
150 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
151 // We have to decrement TokenNumber by 1 to make it usable
152 // as the array index.
153 //
154 TokenNumber--;
155
156 Database = IsPeiDb ? mPcdDatabase.PeiDb: mPcdDatabase.DxeDb;
157 TokenNumber = IsPeiDb ? TokenNumber : TokenNumber - mPeiLocalTokenCount;
158
159 StringTable = (UINT8 *) Database + Database->StringTableOffset;
160
161 //
162 // Get the PCD name index.
163 //
164 PcdNameIndex = (PCD_NAME_INDEX *)((UINT8 *) Database + Database->PcdNameTableOffset) + TokenNumber;
165 TokenSpaceName = (CHAR8 *)&StringTable[PcdNameIndex->TokenSpaceCNameIndex];
166 PcdName = (CHAR8 *)&StringTable[PcdNameIndex->PcdCNameIndex];
167
168 if (OnlyTokenSpaceName) {
169 //
170 // Only need to get the TokenSpaceCName.
171 //
172 Name = AllocateCopyPool (AsciiStrSize (TokenSpaceName), TokenSpaceName);
173 } else {
174 //
175 // Need to get the full PCD name.
176 //
177 Name = AllocateZeroPool (AsciiStrSize (TokenSpaceName) + AsciiStrSize (PcdName));
178 ASSERT (Name != NULL);
179 //
180 // Catenate TokenSpaceCName and PcdCName with a '.' to form the full PCD name.
181 //
182 AsciiStrCat (Name, TokenSpaceName);
183 Name[AsciiStrSize (TokenSpaceName) - sizeof (CHAR8)] = '.';
184 AsciiStrCat (Name, PcdName);
185 }
186
187 return Name;
188 }
189
190 /**
191 Retrieve additional information associated with a PCD token.
192
193 This includes information such as the type of value the TokenNumber is associated with as well as possible
194 human readable name that is associated with the token.
195
196 @param[in] IsPeiDb If TRUE, the pcd entry is initialized in PEI phase,
197 If FALSE, the pcd entry is initialized in DXE phase.
198 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
199 @param[in] TokenNumber The PCD token number.
200 @param[out] PcdInfo The returned information associated with the requested TokenNumber.
201 The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
202
203 @retval EFI_SUCCESS The PCD information was returned successfully
204 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
205 **/
206 EFI_STATUS
207 ExGetPcdInfo (
208 IN BOOLEAN IsPeiDb,
209 IN CONST EFI_GUID *Guid,
210 IN UINTN TokenNumber,
211 OUT EFI_PCD_INFO *PcdInfo
212 )
213 {
214 PCD_DATABASE_INIT *Database;
215 UINTN GuidTableIdx;
216 EFI_GUID *MatchGuid;
217 EFI_GUID *GuidTable;
218 DYNAMICEX_MAPPING *ExMapTable;
219 UINTN Index;
220 UINT32 LocalTokenNumber;
221
222 Database = IsPeiDb ? mPcdDatabase.PeiDb: mPcdDatabase.DxeDb;
223
224 GuidTable = (EFI_GUID *)((UINT8 *)Database + Database->GuidTableOffset);
225 MatchGuid = ScanGuid (GuidTable, Database->GuidTableCount * sizeof(EFI_GUID), Guid);
226
227 if (MatchGuid == NULL) {
228 return EFI_NOT_FOUND;
229 }
230
231 GuidTableIdx = MatchGuid - GuidTable;
232
233 ExMapTable = (DYNAMICEX_MAPPING *)((UINT8 *)Database + Database->ExMapTableOffset);
234
235 //
236 // Find the PCD by GuidTableIdx and ExTokenNumber in ExMapTable.
237 //
238 for (Index = 0; Index < Database->ExTokenCount; Index++) {
239 if (ExMapTable[Index].ExGuidIndex == GuidTableIdx) {
240 if (TokenNumber == PCD_INVALID_TOKEN_NUMBER) {
241 //
242 // TokenNumber is 0, follow spec to set PcdType to EFI_PCD_TYPE_8,
243 // PcdSize to 0 and PcdName to the null-terminated ASCII string
244 // associated with the token's namespace Guid.
245 //
246 PcdInfo->PcdType = EFI_PCD_TYPE_8;
247 PcdInfo->PcdSize = 0;
248 //
249 // Here use one representative in the token space to get the TokenSpaceCName.
250 //
251 PcdInfo->PcdName = GetPcdName (TRUE, IsPeiDb, ExMapTable[Index].TokenNumber);
252 return EFI_SUCCESS;
253 } else if (ExMapTable[Index].ExTokenNumber == TokenNumber) {
254 PcdInfo->PcdSize = DxePcdGetSize (ExMapTable[Index].TokenNumber);
255 LocalTokenNumber = GetLocalTokenNumber (IsPeiDb, ExMapTable[Index].TokenNumber);
256 PcdInfo->PcdType = GetPcdType (LocalTokenNumber);
257 PcdInfo->PcdName = GetPcdName (FALSE, IsPeiDb, ExMapTable[Index].TokenNumber);
258 return EFI_SUCCESS;
259 }
260 }
261 }
262
263 return EFI_NOT_FOUND;
264 }
265
266 /**
267 Retrieve additional information associated with a PCD token.
268
269 This includes information such as the type of value the TokenNumber is associated with as well as possible
270 human readable name that is associated with the token.
271
272 @param[in] Guid The 128-bit unique value that designates the namespace from which to extract the value.
273 @param[in] TokenNumber The PCD token number.
274 @param[out] PcdInfo The returned information associated with the requested TokenNumber.
275 The caller is responsible for freeing the buffer that is allocated by callee for PcdInfo->PcdName.
276
277 @retval EFI_SUCCESS The PCD information was returned successfully.
278 @retval EFI_NOT_FOUND The PCD service could not find the requested token number.
279 **/
280 EFI_STATUS
281 DxeGetPcdInfo (
282 IN CONST EFI_GUID *Guid,
283 IN UINTN TokenNumber,
284 OUT EFI_PCD_INFO *PcdInfo
285 )
286 {
287 EFI_STATUS Status;
288 BOOLEAN PeiExMapTableEmpty;
289 BOOLEAN DxeExMapTableEmpty;
290 UINT32 LocalTokenNumber;
291 BOOLEAN IsPeiDb;
292
293 ASSERT (PcdInfo != NULL);
294
295 Status = EFI_NOT_FOUND;
296 PeiExMapTableEmpty = mPeiExMapTableEmpty;
297 DxeExMapTableEmpty = mDxeExMapTableEmpty;
298
299 if (Guid == NULL) {
300 if (((TokenNumber + 1 > mPeiNexTokenCount + 1) && (TokenNumber + 1 <= mPeiLocalTokenCount + 1)) ||
301 ((TokenNumber + 1 > (mPeiLocalTokenCount + mDxeNexTokenCount + 1)))) {
302 return EFI_NOT_FOUND;
303 } else if (TokenNumber == PCD_INVALID_TOKEN_NUMBER) {
304 //
305 // TokenNumber is 0, follow spec to set PcdType to EFI_PCD_TYPE_8,
306 // PcdSize to 0 and PcdName to NULL for default Token Space.
307 //
308 PcdInfo->PcdType = EFI_PCD_TYPE_8;
309 PcdInfo->PcdSize = 0;
310 PcdInfo->PcdName = NULL;
311 } else {
312 PcdInfo->PcdSize = DxePcdGetSize (TokenNumber);
313 IsPeiDb = FALSE;
314 if ((TokenNumber + 1 <= mPeiNexTokenCount + 1)) {
315 IsPeiDb = TRUE;
316 }
317 LocalTokenNumber = GetLocalTokenNumber (IsPeiDb, TokenNumber);
318 PcdInfo->PcdType = GetPcdType (LocalTokenNumber);
319 PcdInfo->PcdName = GetPcdName (FALSE, IsPeiDb, TokenNumber);
320 }
321 return EFI_SUCCESS;
322 }
323
324 if (PeiExMapTableEmpty && DxeExMapTableEmpty) {
325 return EFI_NOT_FOUND;
326 }
327
328 if (!PeiExMapTableEmpty) {
329 Status = ExGetPcdInfo (
330 TRUE,
331 Guid,
332 TokenNumber,
333 PcdInfo
334 );
335 }
336
337 if (Status == EFI_SUCCESS) {
338 return Status;
339 }
340
341 if (!DxeExMapTableEmpty) {
342 Status = ExGetPcdInfo (
343 FALSE,
344 Guid,
345 TokenNumber,
346 PcdInfo
347 );
348 }
349
350 return Status;
351 }
352
353 /**
354 Get the PCD entry pointer in PCD database.
355
356 This routine will visit PCD database to find the PCD entry according to given
357 token number. The given token number is autogened by build tools and it will be
358 translated to local token number. Local token number contains PCD's type and
359 offset of PCD entry in PCD database.
360
361 @param TokenNumber Token's number, it is autogened by build tools
362 @param GetSize The size of token's value
363
364 @return PCD entry pointer in PCD database
365
366 **/
367 VOID *
368 GetWorker (
369 IN UINTN TokenNumber,
370 IN UINTN GetSize
371 )
372 {
373 EFI_GUID *GuidTable;
374 UINT8 *StringTable;
375 EFI_GUID *Guid;
376 UINT16 *Name;
377 VARIABLE_HEAD *VariableHead;
378 UINT8 *VaraiableDefaultBuffer;
379 UINT8 *Data;
380 VPD_HEAD *VpdHead;
381 UINT8 *PcdDb;
382 VOID *RetPtr;
383 UINTN TmpTokenNumber;
384 UINTN DataSize;
385 EFI_STATUS Status;
386 UINT32 LocalTokenNumber;
387 UINT32 Offset;
388 STRING_HEAD StringTableIdx;
389 BOOLEAN IsPeiDb;
390
391 //
392 // Aquire lock to prevent reentrance from TPL_CALLBACK level
393 //
394 EfiAcquireLock (&mPcdDatabaseLock);
395
396 RetPtr = NULL;
397
398 ASSERT (TokenNumber > 0);
399 //
400 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
401 // We have to decrement TokenNumber by 1 to make it usable
402 // as the array index.
403 //
404 TokenNumber--;
405
406 TmpTokenNumber = TokenNumber;
407
408 //
409 // EBC compiler is very choosy. It may report warning about comparison
410 // between UINTN and 0 . So we add 1 in each size of the
411 // comparison.
412 //
413 ASSERT (TokenNumber + 1 < mPcdTotalTokenCount + 1);
414
415 ASSERT ((GetSize == DxePcdGetSize (TokenNumber + 1)) || (GetSize == 0));
416
417 // EBC compiler is very choosy. It may report warning about comparison
418 // between UINTN and 0 . So we add 1 in each size of the
419 // comparison.
420 IsPeiDb = (BOOLEAN) ((TokenNumber + 1 < mPeiLocalTokenCount + 1) ? TRUE : FALSE);
421
422 LocalTokenNumber = GetLocalTokenNumber (IsPeiDb, TokenNumber + 1);
423
424 PcdDb = IsPeiDb ? ((UINT8 *) mPcdDatabase.PeiDb) : ((UINT8 *) mPcdDatabase.DxeDb);
425
426 if (IsPeiDb) {
427 StringTable = (UINT8 *) ((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->StringTableOffset);
428 } else {
429 StringTable = (UINT8 *) ((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->StringTableOffset);
430 }
431
432
433 Offset = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;
434
435 switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
436 case PCD_TYPE_VPD:
437 VpdHead = (VPD_HEAD *) ((UINT8 *) PcdDb + Offset);
438 RetPtr = (VOID *) (UINTN) (PcdGet32 (PcdVpdBaseAddress) + VpdHead->Offset);
439
440 break;
441
442 case PCD_TYPE_HII|PCD_TYPE_STRING:
443 case PCD_TYPE_HII:
444 if (IsPeiDb) {
445 GuidTable = (EFI_GUID *) ((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->GuidTableOffset);
446 } else {
447 GuidTable = (EFI_GUID *) ((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->GuidTableOffset);
448 }
449
450 VariableHead = (VARIABLE_HEAD *) (PcdDb + Offset);
451 Guid = GuidTable + VariableHead->GuidTableIndex;
452 Name = (UINT16*)(StringTable + VariableHead->StringIndex);
453
454 if ((LocalTokenNumber & PCD_TYPE_ALL_SET) == (PCD_TYPE_HII|PCD_TYPE_STRING)) {
455 //
456 // If a HII type PCD's datum type is VOID*, the DefaultValueOffset is the index of
457 // string array in string table.
458 //
459 StringTableIdx = *(STRING_HEAD*)((UINT8 *) PcdDb + VariableHead->DefaultValueOffset);
460 VaraiableDefaultBuffer = (UINT8 *) (StringTable + StringTableIdx);
461 } else {
462 VaraiableDefaultBuffer = (UINT8 *) PcdDb + VariableHead->DefaultValueOffset;
463 }
464 Status = GetHiiVariable (Guid, Name, &Data, &DataSize);
465 if (Status == EFI_SUCCESS) {
466 if (DataSize >= (VariableHead->Offset + GetSize)) {
467 if (GetSize == 0) {
468 //
469 // It is a pointer type. So get the MaxSize reserved for
470 // this PCD entry.
471 //
472 GetPtrTypeSize (TmpTokenNumber, &GetSize);
473 if (GetSize > (DataSize - VariableHead->Offset)) {
474 //
475 // Use actual valid size.
476 //
477 GetSize = DataSize - VariableHead->Offset;
478 }
479 }
480 //
481 // If the operation is successful, we copy the data
482 // to the default value buffer in the PCD Database.
483 // So that we can free the Data allocated in GetHiiVariable.
484 //
485 CopyMem (VaraiableDefaultBuffer, Data + VariableHead->Offset, GetSize);
486 }
487 FreePool (Data);
488 }
489 RetPtr = (VOID *) VaraiableDefaultBuffer;
490 break;
491
492 case PCD_TYPE_STRING:
493 StringTableIdx = *(STRING_HEAD*)((UINT8 *) PcdDb + Offset);
494 RetPtr = (VOID *) (StringTable + StringTableIdx);
495 break;
496
497 case PCD_TYPE_DATA:
498 RetPtr = (VOID *) ((UINT8 *) PcdDb + Offset);
499 break;
500
501 default:
502 ASSERT (FALSE);
503 break;
504
505 }
506
507 EfiReleaseLock (&mPcdDatabaseLock);
508
509 return RetPtr;
510
511 }
512
513 /**
514 Register the callback function for a PCD entry.
515
516 This routine will register a callback function to a PCD entry by given token number
517 and token space guid.
518
519 @param TokenNumber PCD token's number, it is autogened by build tools.
520 @param Guid PCD token space's guid,
521 if not NULL, this PCD is dynamicEx type PCD.
522 @param CallBackFunction Callback function pointer
523
524 @return EFI_SUCCESS Always success for registering callback function.
525
526 **/
527 EFI_STATUS
528 DxeRegisterCallBackWorker (
529 IN UINTN TokenNumber,
530 IN CONST EFI_GUID *Guid, OPTIONAL
531 IN PCD_PROTOCOL_CALLBACK CallBackFunction
532 )
533 {
534 CALLBACK_FN_ENTRY *FnTableEntry;
535 LIST_ENTRY *ListHead;
536 LIST_ENTRY *ListNode;
537
538 if (Guid != NULL) {
539 TokenNumber = GetExPcdTokenNumber (Guid, (UINT32) TokenNumber);
540 }
541
542 //
543 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
544 // We have to decrement TokenNumber by 1 to make it usable
545 // as the array index of mCallbackFnTable[].
546 //
547 ListHead = &mCallbackFnTable[TokenNumber - 1];
548 ListNode = GetFirstNode (ListHead);
549
550 while (ListNode != ListHead) {
551 FnTableEntry = CR_FNENTRY_FROM_LISTNODE(ListNode, CALLBACK_FN_ENTRY, Node);
552
553 if (FnTableEntry->CallbackFn == CallBackFunction) {
554 //
555 // We only allow a Callback function to be register once
556 // for a TokenNumber. So just return EFI_SUCCESS
557 //
558 return EFI_SUCCESS;
559 }
560 ListNode = GetNextNode (ListHead, ListNode);
561 }
562
563 FnTableEntry = AllocatePool (sizeof(CALLBACK_FN_ENTRY));
564 ASSERT (FnTableEntry != NULL);
565
566 FnTableEntry->CallbackFn = CallBackFunction;
567 InsertTailList (ListHead, &FnTableEntry->Node);
568
569 return EFI_SUCCESS;
570 }
571
572 /**
573 UnRegister the callback function for a PCD entry.
574
575 This routine will unregister a callback function to a PCD entry by given token number
576 and token space guid.
577
578 @param TokenNumber PCD token's number, it is autogened by build tools.
579 @param Guid PCD token space's guid.
580 if not NULL, this PCD is dynamicEx type PCD.
581 @param CallBackFunction Callback function pointer
582
583 @retval EFI_SUCCESS Callback function is success to be unregister.
584 @retval EFI_INVALID_PARAMETER Can not find the PCD entry by given token number.
585 **/
586 EFI_STATUS
587 DxeUnRegisterCallBackWorker (
588 IN UINTN TokenNumber,
589 IN CONST EFI_GUID *Guid, OPTIONAL
590 IN PCD_PROTOCOL_CALLBACK CallBackFunction
591 )
592 {
593 CALLBACK_FN_ENTRY *FnTableEntry;
594 LIST_ENTRY *ListHead;
595 LIST_ENTRY *ListNode;
596
597 if (Guid != NULL) {
598 TokenNumber = GetExPcdTokenNumber (Guid, (UINT32) TokenNumber);
599 }
600
601 //
602 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
603 // We have to decrement TokenNumber by 1 to make it usable
604 // as the array index of mCallbackFnTable[].
605 //
606 ListHead = &mCallbackFnTable[TokenNumber - 1];
607 ListNode = GetFirstNode (ListHead);
608
609 while (ListNode != ListHead) {
610 FnTableEntry = CR_FNENTRY_FROM_LISTNODE(ListNode, CALLBACK_FN_ENTRY, Node);
611
612 if (FnTableEntry->CallbackFn == CallBackFunction) {
613 //
614 // We only allow a Callback function to be register once
615 // for a TokenNumber. So we can safely remove the Node from
616 // the Link List and return EFI_SUCCESS.
617 //
618 RemoveEntryList (ListNode);
619 FreePool (FnTableEntry);
620
621 return EFI_SUCCESS;
622 }
623 ListNode = GetNextNode (ListHead, ListNode);
624 }
625
626 return EFI_INVALID_PARAMETER;
627 }
628
629 /**
630 Get next token number in given token space.
631
632 This routine is used for dynamicEx type PCD. It will firstly scan token space
633 table to get token space according to given token space guid. Then scan given
634 token number in found token space, if found, then return next token number in
635 this token space.
636
637 @param Guid Token space guid. Next token number will be scaned in
638 this token space.
639 @param TokenNumber Token number.
640 If PCD_INVALID_TOKEN_NUMBER, return first token number in
641 token space table.
642 If not PCD_INVALID_TOKEN_NUMBER, return next token number
643 in token space table.
644 @param GuidTable Token space guid table. It will be used for scan token space
645 by given token space guid.
646 @param SizeOfGuidTable The size of guid table.
647 @param ExMapTable DynamicEx token number mapping table.
648 @param SizeOfExMapTable The size of dynamicEx token number mapping table.
649
650 @retval EFI_NOT_FOUND Can not given token space or token number.
651 @retval EFI_SUCCESS Success to get next token number.
652
653 **/
654 EFI_STATUS
655 ExGetNextTokeNumber (
656 IN CONST EFI_GUID *Guid,
657 IN OUT UINTN *TokenNumber,
658 IN EFI_GUID *GuidTable,
659 IN UINTN SizeOfGuidTable,
660 IN DYNAMICEX_MAPPING *ExMapTable,
661 IN UINTN SizeOfExMapTable
662 )
663 {
664 EFI_GUID *MatchGuid;
665 UINTN Index;
666 UINTN GuidTableIdx;
667 BOOLEAN Found;
668 UINTN ExMapTableCount;
669
670 //
671 // Scan token space guid
672 //
673 MatchGuid = ScanGuid (GuidTable, SizeOfGuidTable, Guid);
674 if (MatchGuid == NULL) {
675 return EFI_NOT_FOUND;
676 }
677
678 //
679 // Find the token space table in dynamicEx mapping table.
680 //
681 Found = FALSE;
682 GuidTableIdx = MatchGuid - GuidTable;
683 ExMapTableCount = SizeOfExMapTable / sizeof(ExMapTable[0]);
684 for (Index = 0; Index < ExMapTableCount; Index++) {
685 if (ExMapTable[Index].ExGuidIndex == GuidTableIdx) {
686 Found = TRUE;
687 break;
688 }
689 }
690
691 if (Found) {
692 //
693 // If given token number is PCD_INVALID_TOKEN_NUMBER, then return the first
694 // token number in found token space.
695 //
696 if (*TokenNumber == PCD_INVALID_TOKEN_NUMBER) {
697 *TokenNumber = ExMapTable[Index].ExTokenNumber;
698 return EFI_SUCCESS;
699 }
700
701 for ( ; Index < ExMapTableCount; Index++) {
702 if (ExMapTable[Index].ExTokenNumber == *TokenNumber) {
703 break;
704 }
705 }
706
707 while (Index < ExMapTableCount) {
708 Index++;
709 if (Index == ExMapTableCount) {
710 //
711 // Exceed the length of ExMap Table
712 //
713 *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
714 return EFI_NOT_FOUND;
715 } else if (ExMapTable[Index].ExGuidIndex == GuidTableIdx) {
716 //
717 // Found the next match
718 //
719 *TokenNumber = ExMapTable[Index].ExTokenNumber;
720 return EFI_SUCCESS;
721 }
722 }
723 }
724
725 return EFI_NOT_FOUND;
726 }
727
728 /**
729 Find the PCD database.
730
731 @retval The base address of external PCD database binary.
732 @retval NULL Return NULL if not find.
733 **/
734 DXE_PCD_DATABASE *
735 LocateExPcdBinary (
736 VOID
737 )
738 {
739 DXE_PCD_DATABASE *DxePcdDbBinary;
740 UINTN DxePcdDbSize;
741 EFI_STATUS Status;
742
743 DxePcdDbBinary = NULL;
744 //
745 // Search the External Pcd database from one section of current FFS,
746 // and read it to memory
747 //
748 Status = GetSectionFromFfs (
749 EFI_SECTION_RAW,
750 0,
751 (VOID **) &DxePcdDbBinary,
752 &DxePcdDbSize
753 );
754 ASSERT_EFI_ERROR (Status);
755
756 //
757 // Check the first bytes (Header Signature Guid) and build version.
758 //
759 if (!CompareGuid ((VOID *)DxePcdDbBinary, &gPcdDataBaseSignatureGuid) ||
760 (DxePcdDbBinary->BuildVersion != PCD_SERVICE_DXE_VERSION)) {
761 ASSERT (FALSE);
762 }
763
764 return DxePcdDbBinary;
765 }
766
767 /**
768 Initialize the PCD database in DXE phase.
769
770 PCD database in DXE phase also contains PCD database in PEI phase which is copied
771 from GUID Hob.
772
773 **/
774 VOID
775 BuildPcdDxeDataBase (
776 VOID
777 )
778 {
779 PEI_PCD_DATABASE *PeiDatabase;
780 EFI_HOB_GUID_TYPE *GuidHob;
781 UINTN Index;
782 UINT32 PcdDxeDbLen;
783 VOID *PcdDxeDb;
784
785 //
786 // Assign PCD Entries with default value to PCD DATABASE
787 //
788 mPcdDatabase.DxeDb = LocateExPcdBinary ();
789 ASSERT(mPcdDatabase.DxeDb != NULL);
790 PcdDxeDbLen = mPcdDatabase.DxeDb->Length + mPcdDatabase.DxeDb->UninitDataBaseSize;
791 PcdDxeDb = AllocateZeroPool (PcdDxeDbLen);
792 ASSERT (PcdDxeDb != NULL);
793 CopyMem (PcdDxeDb, mPcdDatabase.DxeDb, mPcdDatabase.DxeDb->Length);
794 FreePool (mPcdDatabase.DxeDb);
795 mPcdDatabase.DxeDb = PcdDxeDb;
796
797 GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
798 if (GuidHob != NULL) {
799
800 //
801 // If no PEIMs use dynamic Pcd Entry, the Pcd Service PEIM
802 // should not be included at all. So the GuidHob could
803 // be NULL. If it is NULL, we just copy over the DXE Default
804 // Value to PCD Database.
805 //
806
807 PeiDatabase = (PEI_PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob);
808 //
809 // Assign PCD Entries refereneced in PEI phase to PCD DATABASE
810 //
811 mPcdDatabase.PeiDb = PeiDatabase;
812 //
813 // Inherit the SystemSkuId from PEI phase.
814 //
815 mPcdDatabase.DxeDb->SystemSkuId = mPcdDatabase.PeiDb->SystemSkuId;
816 } else {
817 mPcdDatabase.PeiDb = AllocateZeroPool (sizeof (PEI_PCD_DATABASE));
818 ASSERT(mPcdDatabase.PeiDb != NULL);
819 }
820
821 //
822 // Initialized the external PCD database local variables
823 //
824 mPeiLocalTokenCount = mPcdDatabase.PeiDb->LocalTokenCount;
825 mDxeLocalTokenCount = mPcdDatabase.DxeDb->LocalTokenCount;
826
827 mPeiExMapppingTableSize = mPcdDatabase.PeiDb->ExTokenCount * sizeof (DYNAMICEX_MAPPING);
828 mDxeExMapppingTableSize = mPcdDatabase.DxeDb->ExTokenCount * sizeof (DYNAMICEX_MAPPING);
829 mPeiGuidTableSize = mPcdDatabase.PeiDb->GuidTableCount * sizeof(GUID);
830 mDxeGuidTableSize = mPcdDatabase.DxeDb->GuidTableCount * sizeof (GUID);
831
832 mPcdTotalTokenCount = mPeiLocalTokenCount + mDxeLocalTokenCount;
833 mPeiNexTokenCount = mPeiLocalTokenCount - mPcdDatabase.PeiDb->ExTokenCount;
834 mDxeNexTokenCount = mDxeLocalTokenCount - mPcdDatabase.DxeDb->ExTokenCount;
835
836 mPeiExMapTableEmpty = (mPcdDatabase.PeiDb->ExTokenCount == 0) ? TRUE : FALSE;
837 mDxeExMapTableEmpty = (mPcdDatabase.DxeDb->ExTokenCount == 0) ? TRUE : FALSE;
838 mPeiDatabaseEmpty = (mPeiLocalTokenCount == 0) ? TRUE : FALSE;
839
840 TmpTokenSpaceBufferCount = mPcdDatabase.PeiDb->ExTokenCount + mPcdDatabase.DxeDb->ExTokenCount;
841 TmpTokenSpaceBuffer = (EFI_GUID **)AllocateZeroPool(TmpTokenSpaceBufferCount * sizeof (EFI_GUID *));
842
843 //
844 // Initialized the Callback Function Table
845 //
846 mCallbackFnTable = AllocateZeroPool (mPcdTotalTokenCount * sizeof (LIST_ENTRY));
847 ASSERT(mCallbackFnTable != NULL);
848
849 //
850 // EBC compiler is very choosy. It may report warning about comparison
851 // between UINTN and 0 . So we add 1 in each size of the
852 // comparison.
853 //
854 for (Index = 0; Index + 1 < mPcdTotalTokenCount + 1; Index++) {
855 InitializeListHead (&mCallbackFnTable[Index]);
856 }
857 }
858
859 /**
860 Get Variable which contains HII type PCD entry.
861
862 @param VariableGuid Variable's guid
863 @param VariableName Variable's unicode name string
864 @param VariableData Variable's data pointer,
865 @param VariableSize Variable's size.
866
867 @return the status of gRT->GetVariable
868 **/
869 EFI_STATUS
870 GetHiiVariable (
871 IN EFI_GUID *VariableGuid,
872 IN UINT16 *VariableName,
873 OUT UINT8 **VariableData,
874 OUT UINTN *VariableSize
875 )
876 {
877 UINTN Size;
878 EFI_STATUS Status;
879 UINT8 *Buffer;
880
881 Size = 0;
882 Buffer = NULL;
883
884 //
885 // Firstly get the real size of HII variable
886 //
887 Status = gRT->GetVariable (
888 (UINT16 *)VariableName,
889 VariableGuid,
890 NULL,
891 &Size,
892 Buffer
893 );
894
895 //
896 // Allocate buffer to hold whole variable data according to variable size.
897 //
898 if (Status == EFI_BUFFER_TOO_SMALL) {
899 Buffer = (UINT8 *) AllocatePool (Size);
900
901 ASSERT (Buffer != NULL);
902
903 Status = gRT->GetVariable (
904 VariableName,
905 VariableGuid,
906 NULL,
907 &Size,
908 Buffer
909 );
910
911 ASSERT (Status == EFI_SUCCESS);
912 *VariableData = Buffer;
913 *VariableSize = Size;
914 } else {
915 //
916 // Use Default Data only when variable is not found.
917 // For other error status, correct data can't be got, and trig ASSERT().
918 //
919 ASSERT (Status == EFI_NOT_FOUND);
920 }
921
922 return Status;
923 }
924
925 /**
926 Find the local token number according to system SKU ID.
927
928 @param LocalTokenNumber PCD token number
929 @param Size The size of PCD entry.
930 @param IsPeiDb If TRUE, the PCD entry is initialized in PEI phase.
931 If False, the PCD entry is initialized in DXE phase.
932
933 @return Token number according to system SKU ID.
934
935 **/
936 UINT32
937 GetSkuEnabledTokenNumber (
938 UINT32 LocalTokenNumber,
939 UINTN Size,
940 BOOLEAN IsPeiDb
941 )
942 {
943 SKU_HEAD *SkuHead;
944 SKU_ID *SkuIdTable;
945 INTN Index;
946 UINT8 *Value;
947 UINT8 *PcdDb;
948 BOOLEAN FoundSku;
949
950 ASSERT ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0);
951
952 PcdDb = IsPeiDb ? (UINT8 *) mPcdDatabase.PeiDb : (UINT8 *) mPcdDatabase.DxeDb;
953
954 SkuHead = (SKU_HEAD *) (PcdDb + (LocalTokenNumber & PCD_DATABASE_OFFSET_MASK));
955 Value = (UINT8 *) (PcdDb + SkuHead->SkuDataStartOffset);
956
957 SkuIdTable = (SKU_ID *)(PcdDb + SkuHead->SkuIdTableOffset);
958 //
959 // Find the current system's SKU ID entry in SKU ID table.
960 //
961 FoundSku = FALSE;
962 for (Index = 0; Index < SkuIdTable[0]; Index++) {
963 if (mPcdDatabase.DxeDb->SystemSkuId == SkuIdTable[Index + 1]) {
964 FoundSku = TRUE;
965 break;
966 }
967 }
968
969 //
970 // Find the default SKU ID entry in SKU ID table.
971 //
972
973 if(!FoundSku) {
974 for (Index = 0; Index < SkuIdTable[0]; Index++) {
975 if (0 == SkuIdTable[Index + 1]) {
976 break;
977 }
978 }
979 }
980 ASSERT (Index < SkuIdTable[0]);
981
982 switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
983 case PCD_TYPE_VPD:
984 Value = (UINT8 *) &(((VPD_HEAD *) Value)[Index]);
985 return (UINT32) ((Value - PcdDb) | PCD_TYPE_VPD);
986
987 case PCD_TYPE_HII:
988 Value = (UINT8 *) &(((VARIABLE_HEAD *) Value)[Index]);
989 return (UINT32) ((Value - PcdDb) | PCD_TYPE_HII);
990
991 case PCD_TYPE_HII|PCD_TYPE_STRING:
992 Value = (UINT8 *) &(((VARIABLE_HEAD *) Value)[Index]);
993 return (UINT32) ((Value - PcdDb) | PCD_TYPE_HII | PCD_TYPE_STRING);
994
995 case PCD_TYPE_STRING:
996 Value = (UINT8 *) &(((STRING_HEAD *) Value)[Index]);
997 return (UINT32) ((Value - PcdDb) | PCD_TYPE_STRING);
998
999 case PCD_TYPE_DATA:
1000 Value += Size * Index;
1001 return (UINT32) ((Value - PcdDb) | PCD_TYPE_DATA);
1002
1003 default:
1004 ASSERT (FALSE);
1005 }
1006
1007 ASSERT (FALSE);
1008
1009 return 0;
1010
1011 }
1012
1013 /**
1014 Invoke the callback function when dynamic PCD entry was set, if this PCD entry
1015 has registered callback function.
1016
1017 @param ExTokenNumber DynamicEx PCD's token number, if this PCD entry is dyanmicEx
1018 type PCD.
1019 @param Guid DynamicEx PCD's guid, if this PCD entry is dynamicEx type
1020 PCD.
1021 @param TokenNumber PCD token number generated by build tools.
1022 @param Data Value want to be set for this PCD entry
1023 @param Size The size of value
1024
1025 **/
1026 VOID
1027 InvokeCallbackOnSet (
1028 UINT32 ExTokenNumber,
1029 CONST EFI_GUID *Guid, OPTIONAL
1030 UINTN TokenNumber,
1031 VOID *Data,
1032 UINTN Size
1033 )
1034 {
1035 CALLBACK_FN_ENTRY *FnTableEntry;
1036 LIST_ENTRY *ListHead;
1037 LIST_ENTRY *ListNode;
1038
1039 //
1040 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
1041 // We have to decrement TokenNumber by 1 to make it usable
1042 // as the array index of mCallbackFnTable[].
1043 //
1044 ListHead = &mCallbackFnTable[TokenNumber - 1];
1045 ListNode = GetFirstNode (ListHead);
1046
1047 while (ListNode != ListHead) {
1048 FnTableEntry = CR_FNENTRY_FROM_LISTNODE (ListNode, CALLBACK_FN_ENTRY, Node);
1049
1050 FnTableEntry->CallbackFn(Guid,
1051 (Guid == NULL) ? TokenNumber : ExTokenNumber,
1052 Data,
1053 Size);
1054
1055 ListNode = GetNextNode (ListHead, ListNode);
1056 }
1057
1058 return;
1059 }
1060
1061
1062 /**
1063 Wrapper function for setting non-pointer type value for a PCD entry.
1064
1065 @param TokenNumber Pcd token number autogenerated by build tools.
1066 @param Data Value want to be set for PCD entry
1067 @param Size Size of value.
1068
1069 @return status of SetWorker.
1070
1071 **/
1072 EFI_STATUS
1073 SetValueWorker (
1074 IN UINTN TokenNumber,
1075 IN VOID *Data,
1076 IN UINTN Size
1077 )
1078 {
1079 return SetWorker (TokenNumber, Data, &Size, FALSE);
1080 }
1081
1082
1083 /**
1084 Set value for an PCD entry
1085
1086 @param TokenNumber Pcd token number autogenerated by build tools.
1087 @param Data Value want to be set for PCD entry
1088 @param Size Size of value.
1089 @param PtrType If TRUE, the type of PCD entry's value is Pointer.
1090 If False, the type of PCD entry's value is not Pointer.
1091
1092 @retval EFI_INVALID_PARAMETER If this PCD type is VPD, VPD PCD can not be set.
1093 @retval EFI_INVALID_PARAMETER If Size can not be set to size table.
1094 @retval EFI_INVALID_PARAMETER If Size of non-Ptr type PCD does not match the size information in PCD database.
1095 @retval EFI_NOT_FOUND If value type of PCD entry is intergrate, but not in
1096 range of UINT8, UINT16, UINT32, UINT64
1097 @retval EFI_NOT_FOUND Can not find the PCD type according to token number.
1098 **/
1099 EFI_STATUS
1100 SetWorker (
1101 IN UINTN TokenNumber,
1102 IN VOID *Data,
1103 IN OUT UINTN *Size,
1104 IN BOOLEAN PtrType
1105 )
1106 {
1107 BOOLEAN IsPeiDb;
1108 UINT32 LocalTokenNumber;
1109 EFI_GUID *GuidTable;
1110 UINT8 *StringTable;
1111 EFI_GUID *Guid;
1112 UINT16 *Name;
1113 UINTN VariableOffset;
1114 VOID *InternalData;
1115 VARIABLE_HEAD *VariableHead;
1116 UINTN Offset;
1117 UINT8 *PcdDb;
1118 EFI_STATUS Status;
1119 UINTN MaxSize;
1120 UINTN TmpTokenNumber;
1121
1122 //
1123 // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
1124 // We have to decrement TokenNumber by 1 to make it usable
1125 // as the array index.
1126 //
1127 TokenNumber--;
1128
1129 TmpTokenNumber = TokenNumber;
1130
1131 //
1132 // EBC compiler is very choosy. It may report warning about comparison
1133 // between UINTN and 0 . So we add 1 in each size of the
1134 // comparison.
1135 //
1136 ASSERT (TokenNumber + 1 < mPcdTotalTokenCount + 1);
1137
1138 if (PtrType) {
1139 //
1140 // Get MaxSize first, then check new size with max buffer size.
1141 //
1142 GetPtrTypeSize (TokenNumber, &MaxSize);
1143 if (*Size > MaxSize) {
1144 *Size = MaxSize;
1145 return EFI_INVALID_PARAMETER;
1146 }
1147 } else {
1148 if (*Size != DxePcdGetSize (TokenNumber + 1)) {
1149 return EFI_INVALID_PARAMETER;
1150 }
1151 }
1152
1153 //
1154 // EBC compiler is very choosy. It may report warning about comparison
1155 // between UINTN and 0 . So we add 1 in each size of the
1156 // comparison.
1157 //
1158 if ((TokenNumber + 1 < mPeiNexTokenCount + 1) ||
1159 (TokenNumber + 1 >= mPeiLocalTokenCount + 1 && TokenNumber + 1 < (mPeiLocalTokenCount + mDxeNexTokenCount + 1))) {
1160 InvokeCallbackOnSet (0, NULL, TokenNumber + 1, Data, *Size);
1161 }
1162
1163 //
1164 // Aquire lock to prevent reentrance from TPL_CALLBACK level
1165 //
1166 EfiAcquireLock (&mPcdDatabaseLock);
1167
1168 //
1169 // EBC compiler is very choosy. It may report warning about comparison
1170 // between UINTN and 0 . So we add 1 in each size of the
1171 // comparison.
1172 //
1173 IsPeiDb = (BOOLEAN) ((TokenNumber + 1 < mPeiLocalTokenCount + 1) ? TRUE : FALSE);
1174
1175 LocalTokenNumber = GetLocalTokenNumber (IsPeiDb, TokenNumber + 1);
1176
1177 Offset = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;
1178
1179 PcdDb = IsPeiDb ? ((UINT8 *) mPcdDatabase.PeiDb) : ((UINT8 *) mPcdDatabase.DxeDb);
1180
1181 if (IsPeiDb) {
1182 StringTable = (UINT8 *) ((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->StringTableOffset);
1183 } else {
1184 StringTable = (UINT8 *) ((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->StringTableOffset);
1185 }
1186
1187
1188 InternalData = PcdDb + Offset;
1189
1190 switch (LocalTokenNumber & PCD_TYPE_ALL_SET) {
1191 case PCD_TYPE_VPD:
1192 ASSERT (FALSE);
1193 Status = EFI_INVALID_PARAMETER;
1194 break;
1195
1196 case PCD_TYPE_STRING:
1197 if (SetPtrTypeSize (TmpTokenNumber, Size)) {
1198 CopyMem (StringTable + *((STRING_HEAD *)InternalData), Data, *Size);
1199 Status = EFI_SUCCESS;
1200 } else {
1201 Status = EFI_INVALID_PARAMETER;
1202 }
1203 break;
1204
1205 case PCD_TYPE_HII|PCD_TYPE_STRING:
1206 case PCD_TYPE_HII:
1207 if (PtrType) {
1208 if (!SetPtrTypeSize (TmpTokenNumber, Size)) {
1209 Status = EFI_INVALID_PARAMETER;
1210 break;
1211 }
1212 }
1213
1214 if (IsPeiDb) {
1215 GuidTable = (EFI_GUID *) ((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->GuidTableOffset);
1216 } else {
1217 GuidTable = (EFI_GUID *) ((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->GuidTableOffset);
1218 }
1219
1220 VariableHead = (VARIABLE_HEAD *) (PcdDb + Offset);
1221
1222 Guid = GuidTable + VariableHead->GuidTableIndex;
1223 Name = (UINT16*) (StringTable + VariableHead->StringIndex);
1224 VariableOffset = VariableHead->Offset;
1225 Status = SetHiiVariable (Guid, Name, Data, *Size, VariableOffset);
1226
1227 if (EFI_NOT_FOUND == Status) {
1228 if ((LocalTokenNumber & PCD_TYPE_ALL_SET) == (PCD_TYPE_HII|PCD_TYPE_STRING)) {
1229 CopyMem (
1230 StringTable + *(STRING_HEAD *)(PcdDb + VariableHead->DefaultValueOffset),
1231 Data,
1232 *Size
1233 );
1234 } else {
1235 CopyMem (PcdDb + VariableHead->DefaultValueOffset, Data, *Size);
1236 }
1237 Status = EFI_SUCCESS;
1238 }
1239 break;
1240
1241 case PCD_TYPE_DATA:
1242 if (PtrType) {
1243 if (SetPtrTypeSize (TmpTokenNumber, Size)) {
1244 CopyMem (InternalData, Data, *Size);
1245 Status = EFI_SUCCESS;
1246 } else {
1247 Status = EFI_INVALID_PARAMETER;
1248 }
1249 break;
1250 }
1251
1252 Status = EFI_SUCCESS;
1253 switch (*Size) {
1254 case sizeof(UINT8):
1255 *((UINT8 *) InternalData) = *((UINT8 *) Data);
1256 break;
1257
1258 case sizeof(UINT16):
1259 *((UINT16 *) InternalData) = *((UINT16 *) Data);
1260 break;
1261
1262 case sizeof(UINT32):
1263 *((UINT32 *) InternalData) = *((UINT32 *) Data);
1264 break;
1265
1266 case sizeof(UINT64):
1267 *((UINT64 *) InternalData) = *((UINT64 *) Data);
1268 break;
1269
1270 default:
1271 ASSERT (FALSE);
1272 Status = EFI_NOT_FOUND;
1273 break;
1274 }
1275 break;
1276
1277 default:
1278 ASSERT (FALSE);
1279 Status = EFI_NOT_FOUND;
1280 break;
1281 }
1282
1283 EfiReleaseLock (&mPcdDatabaseLock);
1284
1285 return Status;
1286 }
1287
1288 /**
1289 Wrapper function for get PCD value for dynamic-ex PCD.
1290
1291 @param Guid Token space guid for dynamic-ex PCD.
1292 @param ExTokenNumber Token number for dynamic-ex PCD.
1293 @param GetSize The size of dynamic-ex PCD value.
1294
1295 @return PCD entry in PCD database.
1296
1297 **/
1298 VOID *
1299 ExGetWorker (
1300 IN CONST EFI_GUID *Guid,
1301 IN UINTN ExTokenNumber,
1302 IN UINTN GetSize
1303 )
1304 {
1305 return GetWorker(GetExPcdTokenNumber (Guid, (UINT32) ExTokenNumber), GetSize);
1306 }
1307
1308 /**
1309 Wrapper function for set PCD value for non-Pointer type dynamic-ex PCD.
1310
1311 @param ExTokenNumber Token number for dynamic-ex PCD.
1312 @param Guid Token space guid for dynamic-ex PCD.
1313 @param Data Value want to be set.
1314 @param SetSize The size of value.
1315
1316 @return status of ExSetWorker().
1317
1318 **/
1319 EFI_STATUS
1320 ExSetValueWorker (
1321 IN UINTN ExTokenNumber,
1322 IN CONST EFI_GUID *Guid,
1323 IN VOID *Data,
1324 IN UINTN SetSize
1325 )
1326 {
1327 return ExSetWorker (ExTokenNumber, Guid, Data, &SetSize, FALSE);
1328 }
1329
1330 /**
1331 Set value for a dynamic-ex PCD entry.
1332
1333 This routine find the local token number according to dynamic-ex PCD's token
1334 space guid and token number firstly, and invoke callback function if this PCD
1335 entry registered callback function. Finally, invoken general SetWorker to set
1336 PCD value.
1337
1338 @param ExTokenNumber Dynamic-ex PCD token number.
1339 @param Guid Token space guid for dynamic-ex PCD.
1340 @param Data PCD value want to be set
1341 @param SetSize Size of value.
1342 @param PtrType If TRUE, this PCD entry is pointer type.
1343 If FALSE, this PCD entry is not pointer type.
1344
1345 @return status of SetWorker().
1346
1347 **/
1348 EFI_STATUS
1349 ExSetWorker (
1350 IN UINTN ExTokenNumber,
1351 IN CONST EFI_GUID *Guid,
1352 IN VOID *Data,
1353 IN OUT UINTN *SetSize,
1354 IN BOOLEAN PtrType
1355 )
1356 {
1357 UINTN TokenNumber;
1358
1359 TokenNumber = GetExPcdTokenNumber (Guid, (UINT32) ExTokenNumber);
1360
1361 InvokeCallbackOnSet ((UINT32) ExTokenNumber, Guid, TokenNumber, Data, *SetSize);
1362
1363 return SetWorker (TokenNumber, Data, SetSize, PtrType);
1364
1365 }
1366
1367 /**
1368 Set value for HII-type PCD.
1369
1370 A HII-type PCD's value is stored in a variable. Setting/Getting the value of
1371 HII-type PCD is to visit this variable.
1372
1373 @param VariableGuid Guid of variable which stored value of a HII-type PCD.
1374 @param VariableName Unicode name of variable which stored value of a HII-type PCD.
1375 @param Data Value want to be set.
1376 @param DataSize Size of value
1377 @param Offset Value offset of HII-type PCD in variable.
1378
1379 @return status of GetVariable()/SetVariable().
1380
1381 **/
1382 EFI_STATUS
1383 SetHiiVariable (
1384 IN EFI_GUID *VariableGuid,
1385 IN UINT16 *VariableName,
1386 IN CONST VOID *Data,
1387 IN UINTN DataSize,
1388 IN UINTN Offset
1389 )
1390 {
1391 UINTN Size;
1392 VOID *Buffer;
1393 EFI_STATUS Status;
1394 UINT32 Attribute;
1395 UINTN SetSize;
1396
1397 Size = 0;
1398 SetSize = 0;
1399
1400 //
1401 // Try to get original variable size information.
1402 //
1403 Status = gRT->GetVariable (
1404 (UINT16 *)VariableName,
1405 VariableGuid,
1406 NULL,
1407 &Size,
1408 NULL
1409 );
1410
1411 if (Status == EFI_BUFFER_TOO_SMALL) {
1412 //
1413 // Patch new PCD's value to offset in given HII variable.
1414 //
1415 if (Size >= (DataSize + Offset)) {
1416 SetSize = Size;
1417 } else {
1418 SetSize = DataSize + Offset;
1419 }
1420 Buffer = AllocatePool (SetSize);
1421 ASSERT (Buffer != NULL);
1422
1423 Status = gRT->GetVariable (
1424 VariableName,
1425 VariableGuid,
1426 &Attribute,
1427 &Size,
1428 Buffer
1429 );
1430
1431 ASSERT_EFI_ERROR (Status);
1432
1433 CopyMem ((UINT8 *)Buffer + Offset, Data, DataSize);
1434
1435 Status = gRT->SetVariable (
1436 VariableName,
1437 VariableGuid,
1438 Attribute,
1439 SetSize,
1440 Buffer
1441 );
1442
1443 FreePool (Buffer);
1444 return Status;
1445 } else if (Status == EFI_NOT_FOUND) {
1446 //
1447 // If variable does not exist, a new variable need to be created.
1448 //
1449
1450 Size = Offset + DataSize;
1451
1452 Buffer = AllocateZeroPool (Size);
1453 ASSERT (Buffer != NULL);
1454
1455 CopyMem ((UINT8 *)Buffer + Offset, Data, DataSize);
1456
1457 Status = gRT->SetVariable (
1458 VariableName,
1459 VariableGuid,
1460 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
1461 Size,
1462 Buffer
1463 );
1464
1465 FreePool (Buffer);
1466 return Status;
1467 }
1468
1469 //
1470 // If we drop to here, the value is failed to be written in to variable area
1471 // So, we will save the data in the PCD Database's volatile area.
1472 //
1473 return Status;
1474 }
1475
1476 /**
1477 Get Token Number according to dynamic-ex PCD's {token space guid:token number}
1478
1479 A dynamic-ex type PCD, developer must provide pair of token space guid: token number
1480 in DEC file. PCD database maintain a mapping table that translate pair of {token
1481 space guid: token number} to Token Number.
1482
1483 @param Guid Token space guid for dynamic-ex PCD entry.
1484 @param ExTokenNumber Dynamic-ex PCD token number.
1485
1486 @return Token Number for dynamic-ex PCD.
1487
1488 **/
1489 UINTN
1490 GetExPcdTokenNumber (
1491 IN CONST EFI_GUID *Guid,
1492 IN UINT32 ExTokenNumber
1493 )
1494 {
1495 UINT32 Index;
1496 DYNAMICEX_MAPPING *ExMap;
1497 EFI_GUID *GuidTable;
1498 EFI_GUID *MatchGuid;
1499 UINTN MatchGuidIdx;
1500
1501 if (!mPeiDatabaseEmpty) {
1502 ExMap = (DYNAMICEX_MAPPING *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->ExMapTableOffset);
1503 GuidTable = (EFI_GUID *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->GuidTableOffset);
1504
1505 MatchGuid = ScanGuid (GuidTable, mPeiGuidTableSize, Guid);
1506
1507 if (MatchGuid != NULL) {
1508
1509 MatchGuidIdx = MatchGuid - GuidTable;
1510
1511 for (Index = 0; Index < mPeiExMapppingTableSize; Index++) {
1512 if ((ExTokenNumber == ExMap[Index].ExTokenNumber) &&
1513 (MatchGuidIdx == ExMap[Index].ExGuidIndex)) {
1514 return ExMap[Index].TokenNumber;
1515 }
1516 }
1517 }
1518 }
1519
1520 ExMap = (DYNAMICEX_MAPPING *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->ExMapTableOffset);
1521 GuidTable = (EFI_GUID *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->GuidTableOffset);
1522
1523 MatchGuid = ScanGuid (GuidTable, mDxeGuidTableSize, Guid);
1524 //
1525 // We need to ASSERT here. If GUID can't be found in GuidTable, this is a
1526 // error in the BUILD system.
1527 //
1528 ASSERT (MatchGuid != NULL);
1529
1530 MatchGuidIdx = MatchGuid - GuidTable;
1531
1532 for (Index = 0; Index < mDxeExMapppingTableSize; Index++) {
1533 if ((ExTokenNumber == ExMap[Index].ExTokenNumber) &&
1534 (MatchGuidIdx == ExMap[Index].ExGuidIndex)) {
1535 return ExMap[Index].TokenNumber;
1536 }
1537 }
1538
1539 ASSERT (FALSE);
1540
1541 return 0;
1542 }
1543
1544 /**
1545 Get SKU ID table from PCD database.
1546
1547 @param LocalTokenNumberTableIdx Index of local token number in token number table.
1548 @param IsPeiDb If TRUE, the pcd entry is initialized in PEI phase,
1549 If FALSE, the pcd entry is initialized in DXE phase.
1550 @return Pointer to SKU ID array table
1551
1552 **/
1553 SKU_ID *
1554 GetSkuIdArray (
1555 IN UINTN LocalTokenNumberTableIdx,
1556 IN BOOLEAN IsPeiDb
1557 )
1558 {
1559 SKU_HEAD *SkuHead;
1560 UINTN LocalTokenNumber;
1561 UINT8 *Database;
1562
1563 if (IsPeiDb) {
1564 LocalTokenNumber = *((UINT32 *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->LocalTokenNumberTableOffset) + LocalTokenNumberTableIdx);
1565 Database = (UINT8 *) mPcdDatabase.PeiDb;
1566 } else {
1567 LocalTokenNumber = *((UINT32 *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->LocalTokenNumberTableOffset) + LocalTokenNumberTableIdx);
1568 Database = (UINT8 *) mPcdDatabase.DxeDb;
1569 }
1570
1571 ASSERT ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) != 0);
1572
1573 SkuHead = (SKU_HEAD *) ((UINT8 *)Database + (LocalTokenNumber & PCD_DATABASE_OFFSET_MASK));
1574
1575 return (SKU_ID *) (Database + SkuHead->SkuIdTableOffset);
1576
1577 }
1578
1579 /**
1580 Wrapper function of getting index of PCD entry in size table.
1581
1582 @param LocalTokenNumberTableIdx Index of this PCD in local token number table.
1583 @param IsPeiDb If TRUE, the pcd entry is initialized in PEI phase,
1584 If FALSE, the pcd entry is initialized in DXE phase.
1585
1586 @return index of PCD entry in size table.
1587 **/
1588 UINTN
1589 GetSizeTableIndex (
1590 IN UINTN LocalTokenNumberTableIdx,
1591 IN BOOLEAN IsPeiDb
1592 )
1593 {
1594 UINT32 *LocalTokenNumberTable;
1595 UINTN LocalTokenNumber;
1596 UINTN Index;
1597 UINTN SizeTableIdx;
1598 SKU_ID *SkuIdTable;
1599
1600 if (IsPeiDb) {
1601 LocalTokenNumberTable = (UINT32 *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->LocalTokenNumberTableOffset);
1602 } else {
1603 LocalTokenNumberTable = (UINT32 *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->LocalTokenNumberTableOffset);
1604 }
1605
1606 SizeTableIdx = 0;
1607
1608 for (Index = 0; Index < LocalTokenNumberTableIdx; Index ++) {
1609 LocalTokenNumber = LocalTokenNumberTable[Index];
1610
1611 if ((LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) == PCD_DATUM_TYPE_POINTER) {
1612 //
1613 // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
1614 // PCD entry.
1615 //
1616 if ((LocalTokenNumber & PCD_TYPE_VPD) != 0) {
1617 //
1618 // We have only two entry for VPD enabled PCD entry:
1619 // 1) MAX Size.
1620 // 2) Current Size
1621 // Current size is equal to MAX size.
1622 //
1623 SizeTableIdx += 2;
1624 } else {
1625 if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0) {
1626 //
1627 // We have only two entry for Non-Sku enabled PCD entry:
1628 // 1) MAX SIZE
1629 // 2) Current Size
1630 //
1631 SizeTableIdx += 2;
1632 } else {
1633 //
1634 // We have these entry for SKU enabled PCD entry
1635 // 1) MAX SIZE
1636 // 2) Current Size for each SKU_ID (It is equal to MaxSku).
1637 //
1638 SkuIdTable = GetSkuIdArray (Index, IsPeiDb);
1639 SizeTableIdx += (UINTN)*SkuIdTable + 1;
1640 }
1641 }
1642 }
1643
1644 }
1645
1646 return SizeTableIdx;
1647 }
1648
1649 /**
1650 Get size of POINTER type PCD value.
1651
1652 @param LocalTokenNumberTableIdx Index of local token number in local token number table.
1653 @param MaxSize Maxmium size of POINTER type PCD value.
1654
1655 @return size of POINTER type PCD value.
1656
1657 **/
1658 UINTN
1659 GetPtrTypeSize (
1660 IN UINTN LocalTokenNumberTableIdx,
1661 OUT UINTN *MaxSize
1662 )
1663 {
1664 INTN SizeTableIdx;
1665 UINTN LocalTokenNumber;
1666 SKU_ID *SkuIdTable;
1667 SIZE_INFO *SizeTable;
1668 UINTN Index;
1669 BOOLEAN IsPeiDb;
1670 UINT32 *LocalTokenNumberTable;
1671
1672 // EBC compiler is very choosy. It may report warning about comparison
1673 // between UINTN and 0 . So we add 1 in each size of the
1674 // comparison.
1675 IsPeiDb = (BOOLEAN) (LocalTokenNumberTableIdx + 1 < mPeiLocalTokenCount + 1);
1676
1677
1678 if (IsPeiDb) {
1679 LocalTokenNumberTable = (UINT32 *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->LocalTokenNumberTableOffset);
1680 SizeTable = (SIZE_INFO *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->SizeTableOffset);
1681 } else {
1682 LocalTokenNumberTableIdx -= mPeiLocalTokenCount;
1683 LocalTokenNumberTable = (UINT32 *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->LocalTokenNumberTableOffset);
1684 SizeTable = (SIZE_INFO *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->SizeTableOffset);
1685 }
1686
1687 LocalTokenNumber = LocalTokenNumberTable[LocalTokenNumberTableIdx];
1688
1689 ASSERT ((LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) == PCD_DATUM_TYPE_POINTER);
1690
1691 SizeTableIdx = GetSizeTableIndex (LocalTokenNumberTableIdx, IsPeiDb);
1692
1693 *MaxSize = SizeTable[SizeTableIdx];
1694 //
1695 // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
1696 // PCD entry.
1697 //
1698 if ((LocalTokenNumber & PCD_TYPE_VPD) != 0) {
1699 //
1700 // We have only two entry for VPD enabled PCD entry:
1701 // 1) MAX Size.
1702 // 2) Current Size
1703 // We consider current size is equal to MAX size.
1704 //
1705 return *MaxSize;
1706 } else {
1707 if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0) {
1708 //
1709 // We have only two entry for Non-Sku enabled PCD entry:
1710 // 1) MAX SIZE
1711 // 2) Current Size
1712 //
1713 return SizeTable[SizeTableIdx + 1];
1714 } else {
1715 //
1716 // We have these entry for SKU enabled PCD entry
1717 // 1) MAX SIZE
1718 // 2) Current Size for each SKU_ID (It is equal to MaxSku).
1719 //
1720 SkuIdTable = GetSkuIdArray (LocalTokenNumberTableIdx, IsPeiDb);
1721 for (Index = 0; Index < SkuIdTable[0]; Index++) {
1722 if (SkuIdTable[1 + Index] == mPcdDatabase.DxeDb->SystemSkuId) {
1723 return SizeTable[SizeTableIdx + 1 + Index];
1724 }
1725 }
1726 return SizeTable[SizeTableIdx + 1];
1727 }
1728 }
1729 }
1730
1731 /**
1732 Set size of POINTER type PCD value. The size should not exceed the maximum size
1733 of this PCD value.
1734
1735 @param LocalTokenNumberTableIdx Index of local token number in local token number table.
1736 @param CurrentSize Size of POINTER type PCD value.
1737
1738 @retval TRUE Success to set size of PCD value.
1739 @retval FALSE Fail to set size of PCD value.
1740 **/
1741 BOOLEAN
1742 SetPtrTypeSize (
1743 IN UINTN LocalTokenNumberTableIdx,
1744 IN OUT UINTN *CurrentSize
1745 )
1746 {
1747 INTN SizeTableIdx;
1748 UINTN LocalTokenNumber;
1749 SKU_ID *SkuIdTable;
1750 SIZE_INFO *SizeTable;
1751 UINTN Index;
1752 UINTN MaxSize;
1753 BOOLEAN IsPeiDb;
1754 UINT32 *LocalTokenNumberTable;
1755
1756 //
1757 // EBC compiler is very choosy. It may report warning about comparison
1758 // between UINTN and 0 . So we add 1 in each size of the
1759 // comparison.
1760 //
1761 IsPeiDb = (BOOLEAN) (LocalTokenNumberTableIdx + 1 < mPeiLocalTokenCount + 1);
1762
1763 if (IsPeiDb) {
1764 LocalTokenNumberTable = (UINT32 *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->LocalTokenNumberTableOffset);
1765 SizeTable = (SIZE_INFO *)((UINT8 *)mPcdDatabase.PeiDb + mPcdDatabase.PeiDb->SizeTableOffset);
1766 } else {
1767 LocalTokenNumberTableIdx -= mPeiLocalTokenCount;
1768 LocalTokenNumberTable = (UINT32 *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->LocalTokenNumberTableOffset);
1769 SizeTable = (SIZE_INFO *)((UINT8 *)mPcdDatabase.DxeDb + mPcdDatabase.DxeDb->SizeTableOffset);
1770 }
1771
1772 LocalTokenNumber = LocalTokenNumberTable[LocalTokenNumberTableIdx];
1773
1774 ASSERT ((LocalTokenNumber & PCD_DATUM_TYPE_ALL_SET) == PCD_DATUM_TYPE_POINTER);
1775
1776 SizeTableIdx = GetSizeTableIndex (LocalTokenNumberTableIdx, IsPeiDb);
1777
1778 MaxSize = SizeTable[SizeTableIdx];
1779 //
1780 // SizeTable only contain record for PCD_DATUM_TYPE_POINTER type
1781 // PCD entry.
1782 //
1783 if ((LocalTokenNumber & PCD_TYPE_VPD) != 0) {
1784 //
1785 // We shouldn't come here as we don't support SET for VPD
1786 //
1787 ASSERT (FALSE);
1788 return FALSE;
1789 } else {
1790 if ((*CurrentSize > MaxSize) ||
1791 (*CurrentSize == MAX_ADDRESS)) {
1792 *CurrentSize = MaxSize;
1793 return FALSE;
1794 }
1795
1796 if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0) {
1797 //
1798 // We have only two entry for Non-Sku enabled PCD entry:
1799 // 1) MAX SIZE
1800 // 2) Current Size
1801 //
1802 SizeTable[SizeTableIdx + 1] = (SIZE_INFO) *CurrentSize;
1803 return TRUE;
1804 } else {
1805 //
1806 // We have these entry for SKU enabled PCD entry
1807 // 1) MAX SIZE
1808 // 2) Current Size for each SKU_ID (It is equal to MaxSku).
1809 //
1810 SkuIdTable = GetSkuIdArray (LocalTokenNumberTableIdx, IsPeiDb);
1811 for (Index = 0; Index < SkuIdTable[0]; Index++) {
1812 if (SkuIdTable[1 + Index] == mPcdDatabase.DxeDb->SystemSkuId) {
1813 SizeTable[SizeTableIdx + 1 + Index] = (SIZE_INFO) *CurrentSize;
1814 return TRUE;
1815 }
1816 }
1817 SizeTable[SizeTableIdx + 1] = (SIZE_INFO) *CurrentSize;
1818 return TRUE;
1819 }
1820 }
1821 }
EFI Development Kit II mirror for PVE