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


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