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


36e859c779d15e114ca1303ae507971615230b47
[mirror_edk2.git] / EdkModulePkg / Universal / PCD / Dxe / Service.c
1 /** @file
2 Private functions used by PCD DXE driver.s
3
4 Copyright (c) 2006, 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
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 Module Name: Service.c
15
16 **/
17 #include "Service.h"
18
19
20 //
21 // Build Tool will generate DXE_PCD_DB_INIT_VALUE in Autogen.h
22 // Compression Algorithm will take care of the size optimization.
23 //
24
25 PCD_DATABASE * mPcdDatabase;
26
27 LIST_ENTRY *mCallbackFnTable;
28
29 VOID *
30 GetWorker (
31 UINTN TokenNumber,
32 UINTN GetSize
33 )
34 {
35 UINT32 *LocalTokenNumberTable;
36 UINT16 *SizeTable;
37 BOOLEAN IsPeiDb;
38 UINTN Size;
39 UINT32 Offset;
40 EFI_GUID *GuidTable;
41 UINT16 *StringTable;
42 EFI_GUID *Guid;
43 UINT16 *Name;
44 VARIABLE_HEAD *VariableHead;
45 EFI_STATUS Status;
46 UINTN DataSize;
47 VOID *Data;
48 VPD_HEAD *VpdHead;
49 UINT8 *PcdDb;
50 UINT16 StringTableIdx;
51 UINT32 LocalTokenNumber;
52
53
54 ASSERT (TokenNumber < PCD_TOTAL_TOKEN_NUMBER);
55
56 Size = DxePcdGetSize (TokenNumber);
57 ASSERT (GetSize == Size || GetSize == 0);
58
59
60 IsPeiDb = (TokenNumber < PEI_LOCAL_TOKEN_NUMBER) ? TRUE : FALSE;
61
62 LocalTokenNumberTable = IsPeiDb ? mPcdDatabase->PeiDb.Init.LocalTokenNumberTable :
63 mPcdDatabase->DxeDb.Init.LocalTokenNumberTable;
64
65 SizeTable = IsPeiDb ? mPcdDatabase->PeiDb.Init.SizeTable:
66 mPcdDatabase->DxeDb.Init.SizeTable;
67
68 TokenNumber = IsPeiDb ? TokenNumber :
69 TokenNumber - PEI_LOCAL_TOKEN_NUMBER;
70
71 LocalTokenNumber = LocalTokenNumberTable[TokenNumber];
72
73 if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {
74 LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, Size, IsPeiDb);
75 }
76
77 PcdDb = IsPeiDb ? ((UINT8 *) &mPcdDatabase->PeiDb) : ((UINT8 *) &mPcdDatabase->DxeDb);
78 StringTable = IsPeiDb ? mPcdDatabase->PeiDb.Init.StringTable :
79 mPcdDatabase->DxeDb.Init.StringTable;
80
81 Offset = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;
82
83 switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) {
84 case PCD_TYPE_VPD:
85 VpdHead = (VPD_HEAD *) ((UINT8 *) PcdDb + Offset);
86 return (VOID *) (UINTN) (FixedPcdGet32(PcdVpdBaseAddress) + VpdHead->Offset);
87
88 case PCD_TYPE_HII:
89 GuidTable = IsPeiDb ? mPcdDatabase->PeiDb.Init.GuidTable :
90 mPcdDatabase->DxeDb.Init.GuidTable;
91
92 VariableHead = (VARIABLE_HEAD *) (PcdDb + Offset);
93
94 Guid = &(GuidTable[VariableHead->GuidTableIndex]);
95 Name = &(StringTable[VariableHead->StringIndex]);
96
97 Status = GetHiiVariable (Guid, Name, &Data, &DataSize);
98 if (Status == EFI_SUCCESS) {
99 ASSERT (DataSize >= (UINTN) (VariableHead->Offset + Size));
100 return (UINT8 *) Data + VariableHead->Offset;
101 } else {
102 //
103 // BugBug: Need to support default value. The current implementation
104 // will return a memory buffer with ALL ZERO.
105 //
106 return AllocateZeroPool (Size);
107 }
108
109 case PCD_TYPE_STRING:
110 StringTableIdx = (UINT16) *((UINT8 *) PcdDb + Offset);
111 return (VOID *) &StringTable[StringTableIdx];
112
113 case PCD_TYPE_DATA:
114 return (VOID *) ((UINT8 *) PcdDb + Offset);
115 break;
116
117 default:
118 ASSERT (FALSE);
119 break;
120
121 }
122
123 ASSERT (FALSE);
124
125 return NULL;
126
127 }
128
129
130
131 EFI_STATUS
132 DxeRegisterCallBackWorker (
133 IN UINTN TokenNumber,
134 IN CONST GUID *Guid, OPTIONAL
135 IN PCD_PROTOCOL_CALLBACK CallBackFunction
136 )
137 {
138 CALLBACK_FN_ENTRY *FnTableEntry;
139 LIST_ENTRY *ListHead;
140 LIST_ENTRY *ListNode;
141
142 if (Guid != NULL) {
143 TokenNumber = GetExPcdTokenNumber (Guid, (UINT32) TokenNumber);
144 }
145
146 ListHead = &mCallbackFnTable[TokenNumber];
147 ListNode = GetFirstNode (ListHead);
148
149 while (ListNode != ListHead) {
150 FnTableEntry = CR_FNENTRY_FROM_LISTNODE(ListNode, CALLBACK_FN_ENTRY, Node);
151
152 if (FnTableEntry->CallbackFn == CallBackFunction) {
153 //
154 // We only allow a Callback function to be register once
155 // for a TokenNumber. So just return EFI_SUCCESS
156 //
157 return EFI_SUCCESS;
158 }
159 ListNode = GetNextNode (ListHead, ListNode);
160 }
161
162 FnTableEntry = AllocatePool (sizeof(CALLBACK_FN_ENTRY));
163 ASSERT (FnTableEntry != NULL);
164
165 FnTableEntry->CallbackFn = CallBackFunction;
166 InsertTailList (ListHead, &FnTableEntry->Node);
167
168 return EFI_SUCCESS;
169 }
170
171
172
173
174 EFI_STATUS
175 DxeUnRegisterCallBackWorker (
176 IN UINTN TokenNumber,
177 IN CONST GUID *Guid, OPTIONAL
178 IN PCD_PROTOCOL_CALLBACK CallBackFunction
179 )
180 {
181 CALLBACK_FN_ENTRY *FnTableEntry;
182 LIST_ENTRY *ListHead;
183 LIST_ENTRY *ListNode;
184
185 if (Guid != NULL) {
186 TokenNumber = GetExPcdTokenNumber (Guid, (UINT32) TokenNumber);
187 }
188
189 ListHead = &mCallbackFnTable[TokenNumber];
190 ListNode = GetFirstNode (ListHead);
191
192 while (ListNode != ListHead) {
193 FnTableEntry = CR_FNENTRY_FROM_LISTNODE(ListNode, CALLBACK_FN_ENTRY, Node);
194
195 if (FnTableEntry->CallbackFn == CallBackFunction) {
196 //
197 // We only allow a Callback function to be register once
198 // for a TokenNumber. So we can safely remove the Node from
199 // the Link List and return EFI_SUCCESS.
200 //
201 RemoveEntryList (ListNode);
202 FreePool (FnTableEntry);
203
204 return EFI_SUCCESS;
205 }
206 ListNode = GetNextNode (ListHead, ListNode);
207 }
208
209 return EFI_INVALID_PARAMETER;
210 }
211
212
213
214 UINTN
215 ExGetNextTokeNumber (
216 IN CONST EFI_GUID *Guid,
217 IN UINTN TokenNumber,
218 IN EFI_GUID *GuidTable,
219 IN UINTN SizeOfGuidTable,
220 IN DYNAMICEX_MAPPING *ExMapTable,
221 IN UINTN SizeOfExMapTable
222 )
223 {
224 EFI_GUID *MatchGuid;
225 UINTN Idx;
226 UINTN GuidTableIdx;
227 BOOLEAN Found;
228
229 MatchGuid = ScanGuid (GuidTable, SizeOfGuidTable, Guid);
230 if (MatchGuid == NULL) {
231 return PCD_INVALID_TOKEN_NUMBER;
232 }
233
234 Found = FALSE;
235 GuidTableIdx = MatchGuid - GuidTable;
236 for (Idx = 0; Idx < SizeOfExMapTable; Idx++) {
237 if (ExMapTable[Idx].ExGuidIndex == GuidTableIdx) {
238 Found = TRUE;
239 break;
240 }
241 }
242
243 if (Found) {
244 if (TokenNumber == PCD_INVALID_TOKEN_NUMBER) {
245 return ExMapTable[Idx].ExTokenNumber;
246 }
247
248 for ( ; Idx < SizeOfExMapTable; Idx++) {
249 if (ExMapTable[Idx].ExTokenNumber == TokenNumber) {
250 Idx++;
251 if (Idx == SizeOfExMapTable) {
252 //
253 // Exceed the length of ExMap Table
254 //
255 return PCD_INVALID_TOKEN_NUMBER;
256 } else if (ExMapTable[Idx].ExGuidIndex == GuidTableIdx) {
257 //
258 // Found the next match
259 //
260 return ExMapTable[Idx].ExTokenNumber;
261 } else {
262 //
263 // Guid has been changed. It is the next Token Space Guid.
264 // We should flag no more TokenNumber.
265 //
266 return PCD_INVALID_TOKEN_NUMBER;
267 }
268 }
269 }
270 }
271
272 return PCD_INVALID_TOKEN_NUMBER;
273 }
274
275
276
277
278 VOID
279 BuildPcdDxeDataBase (
280 VOID
281 )
282 {
283 PEI_PCD_DATABASE *PeiDatabase;
284 EFI_HOB_GUID_TYPE *GuidHob;
285 UINTN Idx;
286
287 mPcdDatabase = AllocateZeroPool (sizeof(PCD_DATABASE));
288 ASSERT (mPcdDatabase != NULL);
289
290 GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
291
292 if (GuidHob != NULL) {
293
294 //
295 // We will copy over the PEI phase's PCD Database.
296 //
297 // If no PEIMs use dynamic Pcd Entry, the Pcd Service PEIM
298 // should not be included at all. So the GuidHob could
299 // be NULL. If it is NULL, we just copy over the DXE Default
300 // Value to PCD Database.
301 //
302
303 PeiDatabase = (PEI_PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob);
304 //
305 // Copy PCD Entries refereneced in PEI phase to PCD DATABASE
306 //
307 CopyMem (&mPcdDatabase->PeiDb, PeiDatabase, sizeof (PEI_PCD_DATABASE));
308 }
309
310 //
311 // Copy PCD Entries with default value to PCD DATABASE
312 //
313 CopyMem (&mPcdDatabase->DxeDb.Init, &gDXEPcdDbInit, sizeof(DXE_PCD_DATABASE_INIT));
314
315
316 //
317 // Initialized the Callback Function Table
318 //
319
320 if (PCD_TOTAL_TOKEN_NUMBER != 0) {
321 mCallbackFnTable = AllocateZeroPool (PCD_TOTAL_TOKEN_NUMBER * sizeof (LIST_ENTRY));
322 }
323
324 for (Idx = 0; Idx < PCD_TOTAL_TOKEN_NUMBER; Idx++) {
325 InitializeListHead (&mCallbackFnTable[Idx]);
326 }
327
328 return;
329 }
330
331
332
333 EFI_STATUS
334 GetHiiVariable (
335 IN EFI_GUID *VariableGuid,
336 IN UINT16 *VariableName,
337 OUT VOID ** VariableData,
338 OUT UINTN *VariableSize
339 )
340 {
341 UINTN Size;
342 EFI_STATUS Status;
343 VOID *Buffer;
344
345 Status = EfiGetVariable (
346 (UINT16 *)VariableName,
347 VariableGuid,
348 NULL,
349 &Size,
350 NULL
351 );
352 if (Status == EFI_BUFFER_TOO_SMALL) {
353
354 Buffer = AllocatePool (Size);
355
356 ASSERT (Buffer != NULL);
357
358 Status = EfiGetVariable (
359 VariableName,
360 VariableGuid,
361 NULL,
362 &Size,
363 Buffer
364 );
365
366 ASSERT (Status == EFI_SUCCESS);
367 }
368
369 return Status;
370
371 }
372
373
374 UINT32
375 GetSkuEnabledTokenNumber (
376 UINT32 LocalTokenNumber,
377 UINTN Size,
378 BOOLEAN IsPeiDb
379 )
380 {
381 SKU_HEAD *SkuHead;
382 SKU_ID *SkuIdTable;
383 INTN i;
384 UINT8 *Value;
385 SKU_ID *PhaseSkuIdTable;
386 UINT8 *PcdDb;
387
388 ASSERT ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0);
389
390 PcdDb = IsPeiDb ? (UINT8 *) &mPcdDatabase->PeiDb : (UINT8 *) &mPcdDatabase->DxeDb;
391
392 SkuHead = (SKU_HEAD *) (PcdDb + (LocalTokenNumber & PCD_DATABASE_OFFSET_MASK));
393 Value = (UINT8 *) (PcdDb + SkuHead->SkuDataStartOffset);
394
395 PhaseSkuIdTable = IsPeiDb ? mPcdDatabase->PeiDb.Init.SkuIdTable :
396 mPcdDatabase->DxeDb.Init.SkuIdTable;
397
398 SkuIdTable = &PhaseSkuIdTable[SkuHead->SkuIdTableOffset];
399
400 for (i = 0; i < SkuIdTable[0]; i++) {
401 if (mPcdDatabase->PeiDb.Init.SystemSkuId == SkuIdTable[i + 1]) {
402 break;
403 }
404 }
405 ASSERT (i < SkuIdTable[0]);
406
407 switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) {
408 case PCD_TYPE_VPD:
409 Value = (UINT8 *) &(((VPD_HEAD *) Value)[i]);
410 return (UINT32) ((Value - PcdDb) | PCD_TYPE_VPD);
411
412 case PCD_TYPE_HII:
413 Value = (UINT8 *) &(((VARIABLE_HEAD *) Value)[i]);
414 return (UINT32) ((Value - PcdDb) | PCD_TYPE_HII);
415
416 case PCD_TYPE_DATA:
417 Value += Size * i;
418 return (UINT32) (Value - PcdDb);
419
420 default:
421 ASSERT (FALSE);
422 }
423
424 ASSERT (FALSE);
425
426 return 0;
427
428 }
429
430
431
432
433
434 VOID
435 InvokeCallbackOnSet (
436 UINT32 ExTokenNumber,
437 CONST EFI_GUID *Guid, OPTIONAL
438 UINTN TokenNumber,
439 VOID *Data,
440 UINTN Size
441 )
442 {
443 CALLBACK_FN_ENTRY *FnTableEntry;
444 LIST_ENTRY *ListHead;
445 LIST_ENTRY *ListNode;
446
447 ListHead = &mCallbackFnTable[TokenNumber];
448 ListNode = GetFirstNode (ListHead);
449
450 while (ListNode != ListHead) {
451 FnTableEntry = CR_FNENTRY_FROM_LISTNODE(ListNode, CALLBACK_FN_ENTRY, Node);
452
453 FnTableEntry->CallbackFn(Guid,
454 (Guid == NULL) ? TokenNumber : ExTokenNumber,
455 Data,
456 Size);
457
458 ListNode = GetNextNode (ListHead, ListNode);
459 }
460
461 return;
462 }
463
464
465
466
467 EFI_STATUS
468 SetWorker (
469 UINTN TokenNumber,
470 VOID *Data,
471 UINTN Size,
472 BOOLEAN PtrType
473 )
474 {
475 UINT32 *LocalTokenNumberTable;
476 BOOLEAN IsPeiDb;
477 UINT32 LocalTokenNumber;
478 EFI_GUID *GuidTable;
479 UINT16 *StringTable;
480 EFI_GUID *Guid;
481 UINT16 *Name;
482 UINTN VariableOffset;
483 VOID *InternalData;
484 VARIABLE_HEAD *VariableHead;
485 UINTN Offset;
486 UINT8 *PcdDb;
487
488
489 ASSERT (TokenNumber < PCD_TOTAL_TOKEN_NUMBER);
490
491 if (PtrType) {
492 ASSERT (Size <= DxePcdGetSize (TokenNumber));
493 } else {
494 ASSERT (Size == DxePcdGetSize (TokenNumber));
495 }
496
497 IsPeiDb = (TokenNumber < PEI_LOCAL_TOKEN_NUMBER) ? TRUE : FALSE;
498
499 LocalTokenNumberTable = IsPeiDb ? mPcdDatabase->PeiDb.Init.LocalTokenNumberTable :
500 mPcdDatabase->DxeDb.Init.LocalTokenNumberTable;
501
502 if ((TokenNumber < PEI_NEX_TOKEN_NUMBER) ||
503 (TokenNumber >= PEI_LOCAL_TOKEN_NUMBER || TokenNumber < (PEI_LOCAL_TOKEN_NUMBER + DXE_NEX_TOKEN_NUMBER))) {
504 InvokeCallbackOnSet (0, NULL, TokenNumber, Data, Size);
505 }
506
507 TokenNumber = IsPeiDb ? TokenNumber
508 : TokenNumber - PEI_LOCAL_TOKEN_NUMBER;
509
510 LocalTokenNumber = LocalTokenNumberTable[TokenNumber];
511
512 if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) {
513 LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, Size, IsPeiDb);
514 }
515
516 Offset = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK;
517
518 PcdDb = IsPeiDb ? ((UINT8 *) &mPcdDatabase->PeiDb) : ((UINT8 *) &mPcdDatabase->DxeDb);
519
520 StringTable = IsPeiDb ? mPcdDatabase->PeiDb.Init.StringTable :
521 mPcdDatabase->DxeDb.Init.StringTable;
522
523 InternalData = PcdDb + Offset;
524
525 switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) {
526 case PCD_TYPE_VPD:
527 ASSERT (FALSE);
528 return EFI_INVALID_PARAMETER;
529
530 case PCD_TYPE_STRING:
531 CopyMem (&StringTable[*((UINT16 *)InternalData)], Data, Size);
532 return EFI_SUCCESS;
533
534 case PCD_TYPE_HII:
535 //
536 // Bug Bug: Please implement this
537 //
538 GuidTable = IsPeiDb ? mPcdDatabase->PeiDb.Init.GuidTable :
539 mPcdDatabase->DxeDb.Init.GuidTable;
540
541 VariableHead = (VARIABLE_HEAD *) (PcdDb + Offset);
542
543 Guid = &(GuidTable[VariableHead->GuidTableIndex]);
544 Name = &(StringTable[VariableHead->StringIndex]);
545 VariableOffset = VariableHead->Offset;
546
547 return SetHiiVariable (Guid, Name, Data, Size, VariableOffset);
548
549 case PCD_TYPE_DATA:
550 if (PtrType) {
551 CopyMem (InternalData, Data, Size);
552 return EFI_SUCCESS;
553 }
554
555 switch (Size) {
556 case sizeof(UINT8):
557 *((UINT8 *) InternalData) = *((UINT8 *) Data);
558 return EFI_SUCCESS;
559
560 case sizeof(UINT16):
561 *((UINT16 *) InternalData) = *((UINT16 *) Data);
562 return EFI_SUCCESS;
563
564 case sizeof(UINT32):
565 *((UINT32 *) InternalData) = *((UINT32 *) Data);
566 return EFI_SUCCESS;
567
568 case sizeof(UINT64):
569 *((UINT64 *) InternalData) = *((UINT64 *) Data);
570 return EFI_SUCCESS;
571
572 default:
573 ASSERT (FALSE);
574 return EFI_NOT_FOUND;
575 }
576
577 default:
578 ASSERT (FALSE);
579 break;
580 }
581
582 ASSERT (FALSE);
583 return EFI_NOT_FOUND;
584 }
585
586
587
588
589
590 VOID *
591 ExGetWorker (
592 IN CONST EFI_GUID *Guid,
593 IN UINTN ExTokenNumber,
594 IN UINTN GetSize
595 )
596 {
597 return GetWorker(GetExPcdTokenNumber (Guid, (UINT32) ExTokenNumber), GetSize);
598 }
599
600
601
602
603
604 EFI_STATUS
605 ExSetWorker (
606 IN UINTN ExTokenNumber,
607 IN CONST EFI_GUID *Guid,
608 VOID *Data,
609 UINTN SetSize,
610 BOOLEAN PtrType
611 )
612 {
613 UINTN TokenNumber;
614
615 TokenNumber = GetExPcdTokenNumber (Guid, (UINT32) ExTokenNumber);
616
617 InvokeCallbackOnSet ((UINT32) ExTokenNumber, Guid, TokenNumber, Data, SetSize);
618
619 SetWorker (TokenNumber, Data, SetSize, PtrType);
620
621 return EFI_SUCCESS;
622
623 }
624
625
626
627
628 EFI_STATUS
629 SetHiiVariable (
630 IN EFI_GUID *VariableGuid,
631 IN UINT16 *VariableName,
632 IN CONST VOID *Data,
633 IN UINTN DataSize,
634 IN UINTN Offset
635 )
636 {
637 UINTN Size;
638 VOID *Buffer;
639 EFI_STATUS Status;
640 UINT32 Attribute;
641
642 Size = 0;
643
644 Status = EfiGetVariable (
645 (UINT16 *)VariableName,
646 VariableGuid,
647 &Attribute,
648 &Size,
649 NULL
650 );
651
652 if (Status == EFI_BUFFER_TOO_SMALL) {
653
654 Buffer = AllocatePool (Size);
655
656 ASSERT (Buffer != NULL);
657
658 Status = EfiGetVariable (
659 VariableName,
660 VariableGuid,
661 &Attribute,
662 &Size,
663 Buffer
664 );
665
666 ASSERT_EFI_ERROR (Status);
667
668 CopyMem ((UINT8 *)Buffer + Offset, Data, DataSize);
669
670 } else {
671
672 Attribute = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
673 Size = DataSize + Offset;
674 Buffer = AllocateZeroPool (Size);
675 ASSERT (Buffer != NULL);
676 CopyMem ((UINT8 *)Buffer + Offset, Data, DataSize);
677
678 }
679
680 return EfiSetVariable (
681 VariableName,
682 VariableGuid,
683 Attribute,
684 Size,
685 Buffer
686 );
687
688 }
689
690
691
692
693
694 UINTN
695 GetExPcdTokenNumber (
696 IN CONST EFI_GUID *Guid,
697 IN UINT32 ExTokenNumber
698 )
699 {
700 UINT32 i;
701 DYNAMICEX_MAPPING *ExMap;
702 EFI_GUID *GuidTable;
703 EFI_GUID *MatchGuid;
704 UINTN MatchGuidIdx;
705
706 ExMap = mPcdDatabase->PeiDb.Init.ExMapTable;
707 GuidTable = mPcdDatabase->PeiDb.Init.GuidTable;
708
709 MatchGuid = ScanGuid (GuidTable, sizeof(mPcdDatabase->PeiDb.Init.GuidTable), Guid);
710 ASSERT (MatchGuid != NULL);
711
712 MatchGuidIdx = MatchGuid - GuidTable;
713
714 for (i = 0; i < PEI_EXMAPPING_TABLE_SIZE; i++) {
715 if ((ExTokenNumber == ExMap[i].ExTokenNumber) &&
716 (MatchGuidIdx == ExMap[i].ExGuidIndex)) {
717 return ExMap[i].LocalTokenNumber;
718
719 }
720 }
721
722 ExMap = mPcdDatabase->DxeDb.Init.ExMapTable;
723 GuidTable = mPcdDatabase->DxeDb.Init.GuidTable;
724
725 MatchGuid = ScanGuid (GuidTable, sizeof(mPcdDatabase->DxeDb.Init.GuidTable), Guid);
726 ASSERT (MatchGuid != NULL);
727
728 MatchGuidIdx = MatchGuid - GuidTable;
729
730 for (i = 0; i < DXE_EXMAPPING_TABLE_SIZE; i++) {
731 if ((ExTokenNumber == ExMap[i].ExTokenNumber) &&
732 (MatchGuidIdx == ExMap[i].ExGuidIndex)) {
733 return ExMap[i].LocalTokenNumber + PEI_LOCAL_TOKEN_NUMBER;
734 }
735 }
736
737 ASSERT (FALSE);
738
739 return 0;
740 }
741
EFI Development Kit II mirror for PVE