BaseTool/VfrCompile: make delete[] match with new[]
[mirror_edk2.git] / BaseTools / Source / C / VfrCompile / VfrUtilityLib.cpp
1 /** @file
2
3 Vfr common library functions.
4
5 Copyright (c) 2004 - 2018, Intel Corporation. All rights reserved.<BR>
6 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 "stdio.h"
17 #include "stdlib.h"
18 #include "assert.h"
19 #include "CommonLib.h"
20 #include "VfrUtilityLib.h"
21 #include "VfrFormPkg.h"
22
23 VOID
24 CVfrBinaryOutput::WriteLine (
25 IN FILE *pFile,
26 IN UINT32 LineBytes,
27 IN CONST CHAR8 *LineHeader,
28 IN CHAR8 *BlkBuf,
29 IN UINT32 BlkSize
30 )
31 {
32 UINT32 Index;
33
34 if ((pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) {
35 return;
36 }
37
38 for (Index = 0; Index < BlkSize; Index++) {
39 if ((Index % LineBytes) == 0) {
40 fprintf (pFile, "\n%s", LineHeader);
41 }
42 fprintf (pFile, "0x%02X, ", (UINT8)BlkBuf[Index]);
43 }
44 }
45
46 VOID
47 CVfrBinaryOutput::WriteEnd (
48 IN FILE *pFile,
49 IN UINT32 LineBytes,
50 IN CONST CHAR8 *LineHeader,
51 IN CHAR8 *BlkBuf,
52 IN UINT32 BlkSize
53 )
54 {
55 UINT32 Index;
56
57 if ((BlkSize == 0) || (pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) {
58 return;
59 }
60
61 for (Index = 0; Index < BlkSize - 1; Index++) {
62 if ((Index % LineBytes) == 0) {
63 fprintf (pFile, "\n%s", LineHeader);
64 }
65 fprintf (pFile, "0x%02X, ", (UINT8)BlkBuf[Index]);
66 }
67
68 if ((Index % LineBytes) == 0) {
69 fprintf (pFile, "\n%s", LineHeader);
70 }
71 fprintf (pFile, "0x%02X\n", (UINT8)BlkBuf[Index]);
72 }
73
74 SConfigInfo::SConfigInfo (
75 IN UINT8 Type,
76 IN UINT16 Offset,
77 IN UINT32 Width,
78 IN EFI_IFR_TYPE_VALUE Value
79 )
80 {
81 mNext = NULL;
82 mOffset = Offset;
83 mWidth = (UINT16)Width;
84 mValue = new UINT8[mWidth];
85 if (mValue == NULL) {
86 return;
87 }
88
89 switch (Type) {
90 case EFI_IFR_TYPE_NUM_SIZE_8 :
91 memcpy (mValue, &Value.u8, mWidth);
92 break;
93 case EFI_IFR_TYPE_NUM_SIZE_16 :
94 memcpy (mValue, &Value.u16, mWidth);
95 break;
96 case EFI_IFR_TYPE_NUM_SIZE_32 :
97 memcpy (mValue, &Value.u32, mWidth);
98 break;
99 case EFI_IFR_TYPE_NUM_SIZE_64 :
100 memcpy (mValue, &Value.u64, mWidth);
101 break;
102 case EFI_IFR_TYPE_BOOLEAN :
103 memcpy (mValue, &Value.b, mWidth);
104 break;
105 case EFI_IFR_TYPE_TIME :
106 memcpy (mValue, &Value.time, mWidth);
107 break;
108 case EFI_IFR_TYPE_DATE :
109 memcpy (mValue, &Value.date, mWidth);
110 break;
111 case EFI_IFR_TYPE_STRING :
112 memcpy (mValue, &Value.string, mWidth);
113 break;
114 case EFI_IFR_TYPE_BUFFER :
115 memcpy (mValue, &Value.u8, mWidth);
116 break;
117
118 case EFI_IFR_TYPE_OTHER :
119 return;
120 }
121 }
122
123 SConfigInfo::~SConfigInfo (
124 VOID
125 )
126 {
127 ARRAY_SAFE_FREE (mValue);
128 }
129
130 SConfigItem::SConfigItem (
131 IN CHAR8 *Name,
132 IN EFI_GUID *Guid,
133 IN CHAR8 *Id
134 )
135 {
136 mName = NULL;
137 mGuid = NULL;
138 mId = NULL;
139 mInfoStrList = NULL;
140 mNext = NULL;
141
142 if (Name != NULL) {
143 if ((mName = new CHAR8[strlen (Name) + 1]) != NULL) {
144 strcpy (mName, Name);
145 }
146 }
147
148 if (Guid != NULL) {
149 if ((mGuid = (EFI_GUID *) new CHAR8[sizeof (EFI_GUID)]) != NULL) {
150 memcpy (mGuid, Guid, sizeof (EFI_GUID));
151 }
152 }
153
154 if (Id != NULL) {
155 if ((mId = new CHAR8[strlen (Id) + 1]) != NULL) {
156 strcpy (mId, Id);
157 }
158 }
159 }
160
161 SConfigItem::SConfigItem (
162 IN CHAR8 *Name,
163 IN EFI_GUID *Guid,
164 IN CHAR8 *Id,
165 IN UINT8 Type,
166 IN UINT16 Offset,
167 IN UINT16 Width,
168 IN EFI_IFR_TYPE_VALUE Value
169 )
170 {
171 mName = NULL;
172 mGuid = NULL;
173 mId = NULL;
174 mInfoStrList = NULL;
175 mNext = NULL;
176
177 if (Name != NULL) {
178 if ((mName = new CHAR8[strlen (Name) + 1]) != NULL) {
179 strcpy (mName, Name);
180 }
181 }
182
183 if (Guid != NULL) {
184 if ((mGuid = (EFI_GUID *) new CHAR8[sizeof (EFI_GUID)]) != NULL) {
185 memcpy (mGuid, Guid, sizeof (EFI_GUID));
186 }
187 }
188
189 if (Id != NULL) {
190 if ((mId = new CHAR8[strlen (Id) + 1]) != NULL) {
191 strcpy (mId, Id);
192 }
193 }
194
195 mInfoStrList = new SConfigInfo(Type, Offset, Width, Value);
196 }
197
198 SConfigItem::~SConfigItem (
199 VOID
200 )
201 {
202 SConfigInfo *Info;
203
204 ARRAY_SAFE_FREE (mName);
205 ARRAY_SAFE_FREE (mGuid);
206 ARRAY_SAFE_FREE (mId);
207 while (mInfoStrList != NULL) {
208 Info = mInfoStrList;
209 mInfoStrList = mInfoStrList->mNext;
210
211 BUFFER_SAFE_FREE (Info);
212 }
213 }
214
215 UINT8
216 CVfrBufferConfig::Register (
217 IN CHAR8 *Name,
218 IN EFI_GUID *Guid,
219 IN CHAR8 *Id
220 )
221 {
222 SConfigItem *pNew;
223
224 if (Select (Name, Guid) == 0) {
225 return 1;
226 }
227
228 if ((pNew = new SConfigItem (Name, Guid, Id)) == NULL) {
229 return 2;
230 }
231
232 if (mItemListHead == NULL) {
233 mItemListHead = pNew;
234 mItemListTail = pNew;
235 } else {
236 mItemListTail->mNext = pNew;
237 mItemListTail = pNew;
238 }
239 mItemListPos = pNew;
240
241 return 0;
242 }
243
244 VOID
245 CVfrBufferConfig::Open (
246 VOID
247 )
248 {
249 mItemListPos = mItemListHead;
250 }
251
252 BOOLEAN
253 CVfrBufferConfig::Eof(
254 VOID
255 )
256 {
257 return (mItemListPos == NULL) ? TRUE : FALSE;
258 }
259
260 UINT8
261 CVfrBufferConfig::Select (
262 IN CHAR8 *Name,
263 IN EFI_GUID *Guid,
264 IN CHAR8 *Id
265 )
266 {
267 SConfigItem *p;
268
269 if (Name == NULL || Guid == NULL) {
270 mItemListPos = mItemListHead;
271 return 0;
272 } else {
273 for (p = mItemListHead; p != NULL; p = p->mNext) {
274 if ((strcmp (p->mName, Name) != 0) || (memcmp (p->mGuid, Guid, sizeof (EFI_GUID)) != 0)) {
275 continue;
276 }
277
278 if (Id != NULL) {
279 if (p->mId == NULL || strcmp (p->mId, Id) != 0) {
280 continue;
281 }
282 } else if (p->mId != NULL) {
283 continue;
284 }
285
286 mItemListPos = p;
287 return 0;
288 }
289 }
290
291 return 1;
292 }
293
294 UINT8
295 CVfrBufferConfig::Write (
296 IN CONST CHAR8 Mode,
297 IN CHAR8 *Name,
298 IN EFI_GUID *Guid,
299 IN CHAR8 *Id,
300 IN UINT8 Type,
301 IN UINT16 Offset,
302 IN UINT32 Width,
303 IN EFI_IFR_TYPE_VALUE Value
304 )
305 {
306 UINT8 Ret;
307 SConfigItem *pItem;
308 SConfigInfo *pInfo;
309
310 if ((Ret = Select (Name, Guid)) != 0) {
311 return Ret;
312 }
313
314 switch (Mode) {
315 case 'a' : // add
316 if (Select (Name, Guid, Id) != 0) {
317 if ((pItem = new SConfigItem (Name, Guid, Id, Type, Offset, (UINT16) Width, Value)) == NULL) {
318 return 2;
319 }
320 if (mItemListHead == NULL) {
321 mItemListHead = pItem;
322 mItemListTail = pItem;
323 } else {
324 mItemListTail->mNext = pItem;
325 mItemListTail = pItem;
326 }
327 mItemListPos = pItem;
328 } else {
329 // tranverse the list to find out if there's already the value for the same offset
330 for (pInfo = mItemListPos->mInfoStrList; pInfo != NULL; pInfo = pInfo->mNext) {
331 if (pInfo->mOffset == Offset) {
332 return 0;
333 }
334 }
335 if((pInfo = new SConfigInfo (Type, Offset, Width, Value)) == NULL) {
336 return 2;
337 }
338 pInfo->mNext = mItemListPos->mInfoStrList;
339 mItemListPos->mInfoStrList = pInfo;
340 }
341 break;
342
343 case 'd' : // delete
344 if (mItemListHead == mItemListPos) {
345 mItemListHead = mItemListPos->mNext;
346 delete mItemListPos;
347 break;
348 }
349
350 for (pItem = mItemListHead; pItem->mNext != mItemListPos; pItem = pItem->mNext)
351 ;
352
353 pItem->mNext = mItemListPos->mNext;
354 if (mItemListTail == mItemListPos) {
355 mItemListTail = pItem;
356 }
357 delete mItemListPos;
358 mItemListPos = pItem->mNext;
359 break;
360
361 case 'i' : // set info
362 if (mItemListPos->mId != NULL) {
363 delete[] mItemListPos->mId;
364 }
365 mItemListPos->mId = NULL;
366 if (Id != NULL) {
367 if ((mItemListPos->mId = new CHAR8[strlen (Id) + 1]) == NULL) {
368 return 2;
369 }
370 strcpy (mItemListPos->mId, Id);
371 }
372 break;
373
374 default :
375 return 1;
376 }
377
378 return 0;
379 }
380
381
382 VOID
383 CVfrBufferConfig::Close (
384 VOID
385 )
386 {
387 mItemListPos = NULL;
388 }
389
390 #define BYTES_PRE_LINE 0x10
391
392 VOID
393 CVfrBufferConfig::OutputCFile (
394 IN FILE *pFile,
395 IN CHAR8 *BaseName
396 )
397 {
398 CVfrBinaryOutput Output;
399 SConfigItem *Item;
400 SConfigInfo *Info;
401 UINT32 TotalLen;
402
403 if (pFile == NULL) {
404 return;
405 }
406
407 for (Item = mItemListHead; Item != NULL; Item = Item->mNext) {
408 if (Item->mId != NULL || Item->mInfoStrList == NULL) {
409 continue;
410 }
411 fprintf (pFile, "\nunsigned char %s%sBlockName[] = {", BaseName, Item->mName);
412
413 TotalLen = sizeof (UINT32);
414 for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) {
415 TotalLen += sizeof (UINT16) * 2;
416 }
417 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&TotalLen, sizeof (UINT32));
418
419 for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) {
420 fprintf (pFile, "\n");
421 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&Info->mOffset, sizeof (UINT16));
422 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&Info->mWidth, sizeof (UINT16));
423 }
424 fprintf (pFile, "\n};\n");
425 }
426
427 for (Item = mItemListHead; Item != NULL; Item = Item->mNext) {
428 if (Item->mId != NULL && Item->mInfoStrList != NULL) {
429 fprintf (pFile, "\nunsigned char %s%sDefault%s[] = {", BaseName, Item->mName, Item->mId);
430
431 TotalLen = sizeof (UINT32);
432 for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) {
433 TotalLen += Info->mWidth + sizeof (UINT16) * 2;
434 }
435 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&TotalLen, sizeof (UINT32));
436
437 for (Info = Item->mInfoStrList; Info != NULL; Info = Info->mNext) {
438 fprintf (pFile, "\n");
439 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&Info->mOffset, sizeof (UINT16));
440 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&Info->mWidth, sizeof (UINT16));
441 if (Info->mNext == NULL) {
442 Output.WriteEnd (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)Info->mValue, Info->mWidth);
443 } else {
444 Output.WriteLine (pFile, BYTES_PRE_LINE, " ", (CHAR8 *)Info->mValue, Info->mWidth);
445 }
446 }
447 fprintf (pFile, "\n};\n");
448 }
449 }
450 }
451
452 CVfrBufferConfig::CVfrBufferConfig (
453 VOID
454 )
455 {
456 mItemListHead = NULL;
457 mItemListTail = NULL;
458 mItemListPos = NULL;
459 }
460
461 CVfrBufferConfig::~CVfrBufferConfig (
462 VOID
463 )
464 {
465 SConfigItem *p;
466
467 while (mItemListHead != NULL) {
468 p = mItemListHead;
469 mItemListHead = mItemListHead->mNext;
470 delete p;
471 }
472
473 mItemListHead = NULL;
474 mItemListTail = NULL;
475 mItemListPos = NULL;
476 }
477
478 CVfrBufferConfig gCVfrBufferConfig;
479
480 static struct {
481 CONST CHAR8 *mTypeName;
482 UINT8 mType;
483 UINT32 mSize;
484 UINT32 mAlign;
485 } gInternalTypesTable [] = {
486 {"UINT64", EFI_IFR_TYPE_NUM_SIZE_64, sizeof (UINT64), sizeof (UINT64)},
487 {"UINT32", EFI_IFR_TYPE_NUM_SIZE_32, sizeof (UINT32), sizeof (UINT32)},
488 {"UINT16", EFI_IFR_TYPE_NUM_SIZE_16, sizeof (UINT16), sizeof (UINT16)},
489 {"UINT8", EFI_IFR_TYPE_NUM_SIZE_8, sizeof (UINT8), sizeof (UINT8)},
490 {"BOOLEAN", EFI_IFR_TYPE_BOOLEAN, sizeof (BOOLEAN), sizeof (BOOLEAN)},
491 {"EFI_HII_DATE", EFI_IFR_TYPE_DATE, sizeof (EFI_HII_DATE), sizeof (UINT16)},
492 {"EFI_STRING_ID", EFI_IFR_TYPE_STRING, sizeof (EFI_STRING_ID),sizeof (EFI_STRING_ID)},
493 {"EFI_HII_TIME", EFI_IFR_TYPE_TIME, sizeof (EFI_HII_TIME), sizeof (UINT8)},
494 {"EFI_HII_REF", EFI_IFR_TYPE_REF, sizeof (EFI_HII_REF), sizeof (EFI_GUID)},
495 {NULL, EFI_IFR_TYPE_OTHER, 0, 0}
496 };
497
498 STATIC
499 BOOLEAN
500 _IS_INTERNAL_TYPE (
501 IN CHAR8 *TypeName
502 )
503 {
504 UINT32 Index;
505
506 if (TypeName == NULL) {
507 return FALSE;
508 }
509
510 for (Index = 0; gInternalTypesTable[Index].mTypeName != NULL; Index++) {
511 if (strcmp (TypeName, gInternalTypesTable[Index].mTypeName) == 0) {
512 return TRUE;
513 }
514 }
515
516 return FALSE;
517 }
518
519 STATIC
520 CHAR8 *
521 TrimHex (
522 IN CHAR8 *Str,
523 OUT bool *IsHex
524 )
525 {
526 *IsHex = FALSE;
527
528 while (*Str && *Str == ' ') {
529 Str++;
530 }
531 while (*Str && *Str == '0') {
532 Str++;
533 }
534 if (*Str && (*Str == 'x' || *Str == 'X')) {
535 Str++;
536 *IsHex = TRUE;
537 }
538
539 return Str;
540 }
541
542 UINT32
543 _STR2U32 (
544 IN CHAR8 *Str
545 )
546 {
547 bool IsHex;
548 UINT32 Value;
549 CHAR8 c;
550
551 Str = TrimHex (Str, &IsHex);
552 for (Value = 0; (c = *Str) != '\0'; Str++) {
553 //
554 // BUG: does not handle overflow here
555 //
556 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);
557
558 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {
559 Value += (c - 'a' + 10);
560 }
561 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) {
562 Value += (c - 'A' + 10);
563 }
564 if (c >= '0' && c <= '9') {
565 Value += (c - '0');
566 }
567 }
568
569 return Value;
570 }
571
572 VOID
573 CVfrVarDataTypeDB::RegisterNewType (
574 IN SVfrDataType *New
575 )
576 {
577 New->mNext = mDataTypeList;
578 mDataTypeList = New;
579 }
580
581 EFI_VFR_RETURN_CODE
582 CVfrVarDataTypeDB::ExtractStructTypeName (
583 IN CHAR8 *&VarStr,
584 OUT CHAR8 *TName
585 )
586 {
587 if (TName == NULL) {
588 return VFR_RETURN_FATAL_ERROR;
589 }
590
591 while((*VarStr != '\0') && (*VarStr != '.')) {
592 *TName = *VarStr;
593 VarStr++;
594 TName++;
595 }
596 *TName = '\0';
597 if (*VarStr == '.') {
598 VarStr++;
599 }
600
601 return VFR_RETURN_SUCCESS;
602 }
603
604 /**
605 Check whether the DataType contain bit field.
606
607 @param TypeName The name of the type.
608
609 **/
610 BOOLEAN
611 CVfrVarDataTypeDB::DataTypeHasBitField (
612 IN CHAR8 *TypeName
613 )
614 {
615 SVfrDataType *pType = NULL;
616 SVfrDataField *pTmp;
617
618 GetDataType (TypeName, &pType);
619
620 if (pType == NULL){
621 return FALSE;
622 }
623 for (pTmp = pType->mMembers; pTmp!= NULL; pTmp = pTmp->mNext) {
624 if (pTmp->mIsBitField) {
625 return TRUE;
626 }
627 }
628 return FALSE;
629 }
630
631 /**
632 Check whether the field is bit field or not.
633
634 @param VarStr Point to the field name which may contain the structure name.
635
636 **/
637 BOOLEAN
638 CVfrVarDataTypeDB::IsThisBitField (
639 IN CHAR8 *VarStr
640 )
641 {
642 CHAR8 FName[MAX_NAME_LEN];
643 CHAR8 TName[MAX_NAME_LEN];
644 UINT32 ArrayIdx;
645 SVfrDataType *pType = NULL;
646 SVfrDataField *pField = NULL;
647
648 CHECK_ERROR_RETURN (ExtractStructTypeName (VarStr, TName), VFR_RETURN_SUCCESS);
649 CHECK_ERROR_RETURN (GetDataType (TName, &pType), VFR_RETURN_SUCCESS);
650
651 while (*VarStr != '\0') {
652 CHECK_ERROR_RETURN(ExtractFieldNameAndArrary(VarStr, FName, ArrayIdx), VFR_RETURN_SUCCESS);
653 CHECK_ERROR_RETURN(GetTypeField (FName, pType, pField), VFR_RETURN_SUCCESS);
654 pType = pField->mFieldType;
655 }
656 if (pField != NULL && pField->mIsBitField) {
657 return TRUE;
658 } else {
659 return FALSE;
660 }
661 }
662
663 EFI_VFR_RETURN_CODE
664 CVfrVarDataTypeDB::ExtractFieldNameAndArrary (
665 IN CHAR8 *&VarStr,
666 IN CHAR8 *FName,
667 OUT UINT32 &ArrayIdx
668 )
669 {
670 UINT32 Idx;
671 CHAR8 ArrayStr[MAX_NAME_LEN + 1];
672
673 ArrayIdx = INVALID_ARRAY_INDEX;
674
675 if (FName == NULL) {
676 return VFR_RETURN_FATAL_ERROR;
677 }
678
679 while((*VarStr != '\0') &&
680 (*VarStr != '.') &&
681 (*VarStr != '[') &&
682 (*VarStr != ']')) {
683 *FName = *VarStr;
684 VarStr++;
685 FName++;
686 }
687 *FName = '\0';
688
689 switch (*VarStr) {
690 case '.' :
691 VarStr++;
692 case '\0':
693 return VFR_RETURN_SUCCESS;
694 case '[' :
695 VarStr++;
696 for (Idx = 0; (Idx < MAX_NAME_LEN) && (*VarStr != '\0') && (*VarStr != ']'); VarStr++, Idx++) {
697 ArrayStr[Idx] = *VarStr;
698 }
699 ArrayStr[Idx] = '\0';
700
701 if ((*VarStr != ']') && (ArrayStr[0] == '\0')) {
702 return VFR_RETURN_DATA_STRING_ERROR;
703 }
704 ArrayIdx = _STR2U32 (ArrayStr);
705 if (*VarStr == ']') {
706 VarStr++;
707 }
708 if (*VarStr == '.') {
709 VarStr++;
710 }
711 return VFR_RETURN_SUCCESS;
712 case ']':
713 return VFR_RETURN_DATA_STRING_ERROR;
714 }
715
716 return VFR_RETURN_SUCCESS;
717 }
718
719 EFI_VFR_RETURN_CODE
720 CVfrVarDataTypeDB::GetTypeField (
721 IN CONST CHAR8 *FName,
722 IN SVfrDataType *Type,
723 OUT SVfrDataField *&Field
724 )
725 {
726 SVfrDataField *pField = NULL;
727
728 if ((FName == NULL) || (Type == NULL)) {
729 return VFR_RETURN_FATAL_ERROR;
730 }
731
732 for (pField = Type->mMembers; pField != NULL; pField = pField->mNext) {
733 //
734 // For type EFI_IFR_TYPE_TIME, because field name is not correctly wrote,
735 // add code to adjust it.
736 //
737 if (Type->mType == EFI_IFR_TYPE_TIME) {
738 if (strcmp (FName, "Hour") == 0) {
739 FName = "Hours";
740 } else if (strcmp (FName, "Minute") == 0) {
741 FName = "Minuts";
742 } else if (strcmp (FName, "Second") == 0) {
743 FName = "Seconds";
744 }
745 }
746
747 if (strcmp (pField->mFieldName, FName) == 0) {
748 Field = pField;
749 return VFR_RETURN_SUCCESS;
750 }
751 }
752
753 return VFR_RETURN_UNDEFINED;
754 }
755
756 EFI_VFR_RETURN_CODE
757 CVfrVarDataTypeDB::GetFieldOffset (
758 IN SVfrDataField *Field,
759 IN UINT32 ArrayIdx,
760 OUT UINT32 &Offset,
761 IN BOOLEAN IsBitField
762 )
763 {
764 if (Field == NULL) {
765 return VFR_RETURN_FATAL_ERROR;
766 }
767
768 //
769 // Framework Vfr file Array Index is from 1.
770 // But Uefi Vfr file Array Index is from 0.
771 //
772 if (VfrCompatibleMode && ArrayIdx != INVALID_ARRAY_INDEX) {
773 if (ArrayIdx == 0) {
774 return VFR_RETURN_ERROR_ARRARY_NUM;
775 }
776 ArrayIdx = ArrayIdx - 1;
777 }
778
779 if ((ArrayIdx != INVALID_ARRAY_INDEX) && ((Field->mArrayNum == 0) || (Field->mArrayNum <= ArrayIdx))) {
780 return VFR_RETURN_ERROR_ARRARY_NUM;
781 }
782
783 //
784 // Be compatible with the current usage
785 // If ArraryIdx is not specified, the first one is used.
786 //
787 // if ArrayNum is larger than zero, ArraryIdx must be specified.
788 //
789 // if ((ArrayIdx == INVALID_ARRAY_INDEX) && (Field->mArrayNum > 0)) {
790 // return VFR_RETURN_ERROR_ARRARY_NUM;
791 // }
792 //
793 if (IsBitField) {
794 Offset = Field->mBitOffset + Field->mFieldType->mTotalSize * ((ArrayIdx == INVALID_ARRAY_INDEX) ? 0 : ArrayIdx) * 8;
795 } else {
796 Offset = Field->mOffset + Field->mFieldType->mTotalSize * ((ArrayIdx == INVALID_ARRAY_INDEX) ? 0 : ArrayIdx);
797 }
798 return VFR_RETURN_SUCCESS;
799 }
800
801 UINT8
802 CVfrVarDataTypeDB::GetFieldWidth (
803 IN SVfrDataField *Field
804 )
805 {
806 if (Field == NULL) {
807 return 0;
808 }
809
810 return Field->mFieldType->mType;
811 }
812
813 UINT32
814 CVfrVarDataTypeDB::GetFieldSize (
815 IN SVfrDataField *Field,
816 IN UINT32 ArrayIdx,
817 IN BOOLEAN BitField
818 )
819 {
820 if (Field == NULL) {
821 return VFR_RETURN_FATAL_ERROR;
822 }
823
824 if ((ArrayIdx == INVALID_ARRAY_INDEX) && (Field->mArrayNum != 0)) {
825 return Field->mFieldType->mTotalSize * Field->mArrayNum;
826 } else {
827 if (BitField) {
828 return Field->mBitWidth;
829 } else {
830 return Field->mFieldType->mTotalSize;
831 }
832 }
833 }
834
835 VOID
836 CVfrVarDataTypeDB::InternalTypesListInit (
837 VOID
838 )
839 {
840 SVfrDataType *New = NULL;
841 UINT32 Index;
842
843 for (Index = 0; gInternalTypesTable[Index].mTypeName != NULL; Index++) {
844 New = new SVfrDataType;
845 if (New != NULL) {
846 assert (strlen (gInternalTypesTable[Index].mTypeName) < MAX_NAME_LEN);
847 strncpy (New->mTypeName, gInternalTypesTable[Index].mTypeName, MAX_NAME_LEN - 1);
848 New->mTypeName[MAX_NAME_LEN - 1] = 0;
849 New->mType = gInternalTypesTable[Index].mType;
850 New->mAlign = gInternalTypesTable[Index].mAlign;
851 New->mTotalSize = gInternalTypesTable[Index].mSize;
852 if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_DATE") == 0) {
853 SVfrDataField *pYearField = new SVfrDataField;
854 SVfrDataField *pMonthField = new SVfrDataField;
855 SVfrDataField *pDayField = new SVfrDataField;
856
857 strcpy (pYearField->mFieldName, "Year");
858 GetDataType ((CHAR8 *)"UINT16", &pYearField->mFieldType);
859 pYearField->mOffset = 0;
860 pYearField->mNext = pMonthField;
861 pYearField->mArrayNum = 0;
862 pYearField->mIsBitField = FALSE;
863
864 strcpy (pMonthField->mFieldName, "Month");
865 GetDataType ((CHAR8 *)"UINT8", &pMonthField->mFieldType);
866 pMonthField->mOffset = 2;
867 pMonthField->mNext = pDayField;
868 pMonthField->mArrayNum = 0;
869 pMonthField->mIsBitField = FALSE;
870
871 strcpy (pDayField->mFieldName, "Day");
872 GetDataType ((CHAR8 *)"UINT8", &pDayField->mFieldType);
873 pDayField->mOffset = 3;
874 pDayField->mNext = NULL;
875 pDayField->mArrayNum = 0;
876 pDayField->mIsBitField = FALSE;
877
878 New->mMembers = pYearField;
879 } else if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_TIME") == 0) {
880 SVfrDataField *pHoursField = new SVfrDataField;
881 SVfrDataField *pMinutesField = new SVfrDataField;
882 SVfrDataField *pSecondsField = new SVfrDataField;
883
884 strcpy (pHoursField->mFieldName, "Hours");
885 GetDataType ((CHAR8 *)"UINT8", &pHoursField->mFieldType);
886 pHoursField->mOffset = 0;
887 pHoursField->mNext = pMinutesField;
888 pHoursField->mArrayNum = 0;
889 pHoursField->mIsBitField = FALSE;
890
891 strcpy (pMinutesField->mFieldName, "Minutes");
892 GetDataType ((CHAR8 *)"UINT8", &pMinutesField->mFieldType);
893 pMinutesField->mOffset = 1;
894 pMinutesField->mNext = pSecondsField;
895 pMinutesField->mArrayNum = 0;
896 pMinutesField->mIsBitField = FALSE;
897
898 strcpy (pSecondsField->mFieldName, "Seconds");
899 GetDataType ((CHAR8 *)"UINT8", &pSecondsField->mFieldType);
900 pSecondsField->mOffset = 2;
901 pSecondsField->mNext = NULL;
902 pSecondsField->mArrayNum = 0;
903 pSecondsField->mIsBitField = FALSE;
904
905 New->mMembers = pHoursField;
906 } else if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_REF") == 0) {
907 SVfrDataField *pQuestionIdField = new SVfrDataField;
908 SVfrDataField *pFormIdField = new SVfrDataField;
909 SVfrDataField *pFormSetGuidField = new SVfrDataField;
910 SVfrDataField *pDevicePathField = new SVfrDataField;
911
912 strcpy (pQuestionIdField->mFieldName, "QuestionId");
913 GetDataType ((CHAR8 *)"UINT16", &pQuestionIdField->mFieldType);
914 pQuestionIdField->mOffset = 0;
915 pQuestionIdField->mNext = pFormIdField;
916 pQuestionIdField->mArrayNum = 0;
917 pQuestionIdField->mIsBitField = FALSE;
918
919 strcpy (pFormIdField->mFieldName, "FormId");
920 GetDataType ((CHAR8 *)"UINT16", &pFormIdField->mFieldType);
921 pFormIdField->mOffset = 2;
922 pFormIdField->mNext = pFormSetGuidField;
923 pFormIdField->mArrayNum = 0;
924 pFormIdField->mIsBitField = FALSE;
925
926 strcpy (pFormSetGuidField->mFieldName, "FormSetGuid");
927 GetDataType ((CHAR8 *)"EFI_GUID", &pFormSetGuidField->mFieldType);
928 pFormSetGuidField->mOffset = 4;
929 pFormSetGuidField->mNext = pDevicePathField;
930 pFormSetGuidField->mArrayNum = 0;
931 pFormSetGuidField->mIsBitField = FALSE;
932
933 strcpy (pDevicePathField->mFieldName, "DevicePath");
934 GetDataType ((CHAR8 *)"EFI_STRING_ID", &pDevicePathField->mFieldType);
935 pDevicePathField->mOffset = 20;
936 pDevicePathField->mNext = NULL;
937 pDevicePathField->mArrayNum = 0;
938 pDevicePathField->mIsBitField = FALSE;
939
940 New->mMembers = pQuestionIdField;
941 } else {
942 New->mMembers = NULL;
943 }
944 New->mNext = NULL;
945 RegisterNewType (New);
946 New = NULL;
947 }
948 }
949 }
950
951 CVfrVarDataTypeDB::CVfrVarDataTypeDB (
952 VOID
953 )
954 {
955 mDataTypeList = NULL;
956 mNewDataType = NULL;
957 mCurrDataField = NULL;
958 mPackAlign = DEFAULT_PACK_ALIGN;
959 mPackStack = NULL;
960 mFirstNewDataTypeName = NULL;
961 mCurrDataType = NULL;
962
963 InternalTypesListInit ();
964 }
965
966 CVfrVarDataTypeDB::~CVfrVarDataTypeDB (
967 VOID
968 )
969 {
970 SVfrDataType *pType;
971 SVfrDataField *pField;
972 SVfrPackStackNode *pPack;
973
974 if (mNewDataType != NULL) {
975 delete mNewDataType;
976 }
977
978 while (mDataTypeList != NULL) {
979 pType = mDataTypeList;
980 mDataTypeList = mDataTypeList->mNext;
981 while(pType->mMembers != NULL) {
982 pField = pType->mMembers;
983 pType->mMembers = pType->mMembers->mNext;
984 delete pField;
985 }
986 delete pType;
987 }
988
989 while (mPackStack != NULL) {
990 pPack = mPackStack;
991 mPackStack = mPackStack->mNext;
992 delete pPack;
993 }
994 }
995
996 EFI_VFR_RETURN_CODE
997 CVfrVarDataTypeDB::Pack (
998 IN UINT32 LineNum,
999 IN UINT8 Action,
1000 IN CHAR8 *Identifier,
1001 IN UINT32 Number
1002 )
1003 {
1004 UINT32 PackAlign;
1005 CHAR8 Msg[MAX_STRING_LEN] = {0, };
1006
1007 if (Action & VFR_PACK_SHOW) {
1008 sprintf (Msg, "value of pragma pack(show) == %d", mPackAlign);
1009 gCVfrErrorHandle.PrintMsg (LineNum, NULL, "Warning", Msg);
1010 }
1011
1012 if (Action & VFR_PACK_PUSH) {
1013 SVfrPackStackNode *pNew = NULL;
1014
1015 if ((pNew = new SVfrPackStackNode (Identifier, mPackAlign)) == NULL) {
1016 return VFR_RETURN_FATAL_ERROR;
1017 }
1018 pNew->mNext = mPackStack;
1019 mPackStack = pNew;
1020 }
1021
1022 if (Action & VFR_PACK_POP) {
1023 SVfrPackStackNode *pNode = NULL;
1024
1025 if (mPackStack == NULL) {
1026 gCVfrErrorHandle.PrintMsg (LineNum, NULL, "Error", "#pragma pack(pop...) : more pops than pushes");
1027 }
1028
1029 for (pNode = mPackStack; pNode != NULL; pNode = pNode->mNext) {
1030 if (pNode->Match (Identifier) == TRUE) {
1031 mPackAlign = pNode->mNumber;
1032 mPackStack = pNode->mNext;
1033 }
1034 }
1035 }
1036
1037 if (Action & VFR_PACK_ASSIGN) {
1038 PackAlign = (Number > 1) ? Number + Number % 2 : Number;
1039 if ((PackAlign == 0) || (PackAlign > 16)) {
1040 gCVfrErrorHandle.PrintMsg (LineNum, NULL, "Error", "expected pragma parameter to be '1', '2', '4', '8', or '16'");
1041 } else {
1042 mPackAlign = PackAlign;
1043 }
1044 }
1045
1046 return VFR_RETURN_SUCCESS;
1047 }
1048
1049 VOID
1050 CVfrVarDataTypeDB::DeclareDataTypeBegin (
1051 VOID
1052 )
1053 {
1054 SVfrDataType *pNewType = NULL;
1055
1056 pNewType = new SVfrDataType;
1057 pNewType->mTypeName[0] = '\0';
1058 pNewType->mType = EFI_IFR_TYPE_OTHER;
1059 pNewType->mAlign = DEFAULT_ALIGN;
1060 pNewType->mTotalSize = 0;
1061 pNewType->mMembers = NULL;
1062 pNewType->mNext = NULL;
1063 pNewType->mHasBitField = FALSE;
1064
1065 mNewDataType = pNewType;
1066 }
1067
1068 EFI_VFR_RETURN_CODE
1069 CVfrVarDataTypeDB::SetNewTypeName (
1070 IN CHAR8 *TypeName
1071 )
1072 {
1073 SVfrDataType *pType;
1074
1075 if (mNewDataType == NULL) {
1076 return VFR_RETURN_ERROR_SKIPED;
1077 }
1078 if (TypeName == NULL) {
1079 return VFR_RETURN_FATAL_ERROR;
1080 }
1081 if (strlen(TypeName) >= MAX_NAME_LEN) {
1082 return VFR_RETURN_INVALID_PARAMETER;
1083 }
1084
1085 for (pType = mDataTypeList; pType != NULL; pType = pType->mNext) {
1086 if (strcmp(pType->mTypeName, TypeName) == 0) {
1087 return VFR_RETURN_REDEFINED;
1088 }
1089 }
1090
1091 strncpy(mNewDataType->mTypeName, TypeName, MAX_NAME_LEN - 1);
1092 mNewDataType->mTypeName[MAX_NAME_LEN - 1] = 0;
1093 return VFR_RETURN_SUCCESS;
1094 }
1095
1096 /**
1097 Record the bit field info in the data type.
1098
1099 @param FieldName Point to the field name.
1100 @param TypeName Point to the type name.
1101 @param Width The bit width.
1102 @param FieldInUnion The filed is in Union type or Structure type.
1103
1104 **/
1105 EFI_VFR_RETURN_CODE
1106 CVfrVarDataTypeDB::DataTypeAddBitField (
1107 IN CHAR8 *FieldName,
1108 IN CHAR8 *TypeName,
1109 IN UINT32 Width,
1110 IN BOOLEAN FieldInUnion
1111 )
1112 {
1113 SVfrDataField *pNewField = NULL;
1114 SVfrDataType *pFieldType = NULL;
1115 SVfrDataField *pTmp;
1116 UINT32 Align;
1117 UINT32 MaxDataTypeSize;
1118 BOOLEAN UpdateTotalSize;
1119
1120 CHECK_ERROR_RETURN (GetDataType (TypeName, &pFieldType), VFR_RETURN_SUCCESS);
1121
1122 if (Width > MAX_BIT_WIDTH) {
1123 return VFR_RETURN_BIT_WIDTH_ERROR;
1124 }
1125
1126 if (Width > pFieldType->mTotalSize * 8) {
1127 return VFR_RETURN_BIT_WIDTH_ERROR;
1128 }
1129
1130 if (FieldName != NULL && strlen (FieldName) >= MAX_NAME_LEN) {
1131 return VFR_RETURN_INVALID_PARAMETER;
1132 }
1133
1134 if (Width == 0 && FieldName != NULL) {
1135 return VFR_RETURN_INVALID_PARAMETER;
1136 }
1137
1138 for (pTmp = mNewDataType->mMembers; pTmp != NULL; pTmp = pTmp->mNext) {
1139 if (FieldName != NULL && strcmp (pTmp->mFieldName, FieldName) == 0) {
1140 return VFR_RETURN_REDEFINED;
1141 }
1142 }
1143
1144 Align = MIN (mPackAlign, pFieldType->mAlign);
1145 UpdateTotalSize = FALSE;
1146
1147 if ((pNewField = new SVfrDataField) == NULL) {
1148 return VFR_RETURN_OUT_FOR_RESOURCES;
1149 }
1150
1151 MaxDataTypeSize = mNewDataType->mTotalSize;
1152 if (FieldName != NULL) {
1153 strncpy (pNewField->mFieldName, FieldName, MAX_NAME_LEN - 1);
1154 pNewField->mFieldName[MAX_NAME_LEN - 1] = 0;
1155 }
1156 pNewField->mFieldType = pFieldType;
1157 pNewField->mIsBitField = TRUE;
1158 pNewField->mBitWidth = Width;
1159 pNewField->mArrayNum = 0;
1160 pNewField->mBitOffset = 0;
1161 pNewField->mOffset = 0;
1162
1163 if (mNewDataType->mMembers == NULL) {
1164 mNewDataType->mMembers = pNewField;
1165 pNewField->mNext = NULL;
1166 } else {
1167 for (pTmp = mNewDataType->mMembers; pTmp->mNext != NULL; pTmp = pTmp->mNext)
1168 ;
1169 pTmp->mNext = pNewField;
1170 pNewField->mNext = NULL;
1171 }
1172
1173 if (FieldInUnion) {
1174 pNewField->mOffset = 0;
1175 if (MaxDataTypeSize < pNewField->mFieldType->mTotalSize) {
1176 mNewDataType->mTotalSize = pNewField->mFieldType->mTotalSize;
1177 }
1178 } else {
1179 //
1180 // Check whether the bit fileds can be contained within one FieldType.
1181 //
1182 if (pTmp != NULL && pTmp->mIsBitField && strcmp (pTmp->mFieldType->mTypeName, pNewField->mFieldType->mTypeName) == 0 &&
1183 (pTmp->mBitOffset - pTmp->mOffset * 8) + pTmp->mBitWidth + pNewField->mBitWidth <= pNewField->mFieldType->mTotalSize * 8) {
1184 pNewField->mBitOffset = pTmp->mBitOffset + pTmp->mBitWidth;
1185 pNewField->mOffset = pTmp->mOffset;
1186 //
1187 // If BitWidth=0,used to force alignment at the next word boundary.
1188 // So make this bit field occupy the remaing bit width of current field type.
1189 //
1190 if (pNewField->mBitWidth == 0) {
1191 pNewField->mBitWidth = pNewField->mFieldType->mTotalSize * 8 - (pNewField->mBitOffset - pTmp->mOffset * 8);
1192 }
1193 } else {
1194 //
1195 // The bit filed start a new memory
1196 //
1197 pNewField->mBitOffset = mNewDataType->mTotalSize * 8;
1198 UpdateTotalSize = TRUE;
1199 }
1200 }
1201
1202 if (UpdateTotalSize){
1203 if ((mNewDataType->mTotalSize % Align) == 0) {
1204 pNewField->mOffset = mNewDataType->mTotalSize;
1205 } else {
1206 pNewField->mOffset = mNewDataType->mTotalSize + ALIGN_STUFF(mNewDataType->mTotalSize, Align);
1207 }
1208 mNewDataType->mTotalSize = pNewField->mOffset + (pNewField->mFieldType->mTotalSize);
1209 }
1210
1211 mNewDataType->mAlign = MIN (mPackAlign, MAX (pFieldType->mAlign, mNewDataType->mAlign));
1212 mNewDataType->mHasBitField = TRUE;
1213 return VFR_RETURN_SUCCESS;
1214 }
1215
1216 EFI_VFR_RETURN_CODE
1217 CVfrVarDataTypeDB::DataTypeAddField (
1218 IN CHAR8 *FieldName,
1219 IN CHAR8 *TypeName,
1220 IN UINT32 ArrayNum,
1221 IN BOOLEAN FieldInUnion
1222 )
1223 {
1224 SVfrDataField *pNewField = NULL;
1225 SVfrDataType *pFieldType = NULL;
1226 SVfrDataField *pTmp;
1227 UINT32 Align;
1228 UINT32 MaxDataTypeSize;
1229
1230 CHECK_ERROR_RETURN (GetDataType (TypeName, &pFieldType), VFR_RETURN_SUCCESS);
1231 MaxDataTypeSize = mNewDataType->mTotalSize;
1232
1233 if (strlen (FieldName) >= MAX_NAME_LEN) {
1234 return VFR_RETURN_INVALID_PARAMETER;
1235 }
1236
1237 for (pTmp = mNewDataType->mMembers; pTmp != NULL; pTmp = pTmp->mNext) {
1238 if (strcmp (pTmp->mFieldName, FieldName) == 0) {
1239 return VFR_RETURN_REDEFINED;
1240 }
1241 }
1242
1243 Align = MIN (mPackAlign, pFieldType->mAlign);
1244
1245 if ((pNewField = new SVfrDataField) == NULL) {
1246 return VFR_RETURN_OUT_FOR_RESOURCES;
1247 }
1248 strncpy (pNewField->mFieldName, FieldName, MAX_NAME_LEN - 1);
1249 pNewField->mFieldName[MAX_NAME_LEN - 1] = 0;
1250 pNewField->mFieldType = pFieldType;
1251 pNewField->mArrayNum = ArrayNum;
1252 pNewField->mIsBitField = FALSE;
1253 if ((mNewDataType->mTotalSize % Align) == 0) {
1254 pNewField->mOffset = mNewDataType->mTotalSize;
1255 } else {
1256 pNewField->mOffset = mNewDataType->mTotalSize + ALIGN_STUFF(mNewDataType->mTotalSize, Align);
1257 }
1258 if (mNewDataType->mMembers == NULL) {
1259 mNewDataType->mMembers = pNewField;
1260 pNewField->mNext = NULL;
1261 } else {
1262 for (pTmp = mNewDataType->mMembers; pTmp->mNext != NULL; pTmp = pTmp->mNext)
1263 ;
1264 pTmp->mNext = pNewField;
1265 pNewField->mNext = NULL;
1266 }
1267
1268 mNewDataType->mAlign = MIN (mPackAlign, MAX (pFieldType->mAlign, mNewDataType->mAlign));
1269
1270 if (FieldInUnion) {
1271 if (MaxDataTypeSize < pNewField->mFieldType->mTotalSize) {
1272 mNewDataType->mTotalSize = pNewField->mFieldType->mTotalSize;
1273 }
1274 pNewField->mOffset = 0;
1275 } else {
1276 mNewDataType->mTotalSize = pNewField->mOffset + (pNewField->mFieldType->mTotalSize) * ((ArrayNum == 0) ? 1 : ArrayNum);
1277 }
1278
1279 return VFR_RETURN_SUCCESS;
1280 }
1281
1282 VOID
1283 CVfrVarDataTypeDB::DeclareDataTypeEnd (
1284 VOID
1285 )
1286 {
1287 if (mNewDataType->mTypeName[0] == '\0') {
1288 return;
1289 }
1290
1291 if ((mNewDataType->mTotalSize % mNewDataType->mAlign) !=0) {
1292 mNewDataType->mTotalSize += ALIGN_STUFF (mNewDataType->mTotalSize, mNewDataType->mAlign);
1293 }
1294
1295 RegisterNewType (mNewDataType);
1296 if (mFirstNewDataTypeName == NULL) {
1297 mFirstNewDataTypeName = mNewDataType->mTypeName;
1298 }
1299
1300 mNewDataType = NULL;
1301 }
1302
1303 EFI_VFR_RETURN_CODE
1304 CVfrVarDataTypeDB::GetDataType (
1305 IN CHAR8 *TypeName,
1306 OUT SVfrDataType **DataType
1307 )
1308 {
1309 SVfrDataType *pDataType = NULL;
1310
1311 if (TypeName == NULL) {
1312 return VFR_RETURN_ERROR_SKIPED;
1313 }
1314
1315 if (DataType == NULL) {
1316 return VFR_RETURN_FATAL_ERROR;
1317 }
1318
1319 *DataType = NULL;
1320
1321 for (pDataType = mDataTypeList; pDataType != NULL; pDataType = pDataType->mNext) {
1322 if (strcmp (TypeName, pDataType->mTypeName) == 0) {
1323 *DataType = pDataType;
1324 return VFR_RETURN_SUCCESS;
1325 }
1326 }
1327
1328 return VFR_RETURN_UNDEFINED;
1329 }
1330
1331 EFI_VFR_RETURN_CODE
1332 CVfrVarDataTypeDB::GetDataTypeSize (
1333 IN UINT8 DataType,
1334 OUT UINT32 *Size
1335 )
1336 {
1337 SVfrDataType *pDataType = NULL;
1338
1339 if (Size == NULL) {
1340 return VFR_RETURN_FATAL_ERROR;
1341 }
1342
1343 *Size = 0;
1344 DataType = DataType & 0x0F;
1345
1346 //
1347 // For user defined data type, the size can't be got by this function.
1348 //
1349 if (DataType == EFI_IFR_TYPE_OTHER) {
1350 return VFR_RETURN_SUCCESS;
1351 }
1352
1353 for (pDataType = mDataTypeList; pDataType != NULL; pDataType = pDataType->mNext) {
1354 if (DataType == pDataType->mType) {
1355 *Size = pDataType->mTotalSize;
1356 return VFR_RETURN_SUCCESS;
1357 }
1358 }
1359
1360 return VFR_RETURN_UNDEFINED;
1361 }
1362
1363 EFI_VFR_RETURN_CODE
1364 CVfrVarDataTypeDB::GetDataTypeSize (
1365 IN CHAR8 *TypeName,
1366 OUT UINT32 *Size
1367 )
1368 {
1369 SVfrDataType *pDataType = NULL;
1370
1371 if (Size == NULL) {
1372 return VFR_RETURN_FATAL_ERROR;
1373 }
1374
1375 *Size = 0;
1376
1377 for (pDataType = mDataTypeList; pDataType != NULL; pDataType = pDataType->mNext) {
1378 if (strcmp (TypeName, pDataType->mTypeName) == 0) {
1379 *Size = pDataType->mTotalSize;
1380 return VFR_RETURN_SUCCESS;
1381 }
1382 }
1383
1384 return VFR_RETURN_UNDEFINED;
1385 }
1386
1387 EFI_VFR_RETURN_CODE
1388 CVfrVarDataTypeDB::GetDataFieldInfo (
1389 IN CHAR8 *VarStr,
1390 OUT UINT16 &Offset,
1391 OUT UINT8 &Type,
1392 OUT UINT32 &Size,
1393 OUT BOOLEAN &BitField
1394 )
1395 {
1396 CHAR8 TName[MAX_NAME_LEN], FName[MAX_NAME_LEN];
1397 UINT32 ArrayIdx, Tmp;
1398 SVfrDataType *pType = NULL;
1399 SVfrDataField *pField = NULL;
1400 CHAR8 *VarStrName;
1401
1402 Offset = 0;
1403 Type = EFI_IFR_TYPE_OTHER;
1404 Size = 0;
1405 VarStrName = VarStr;
1406
1407 CHECK_ERROR_RETURN (ExtractStructTypeName (VarStr, TName), VFR_RETURN_SUCCESS);
1408 CHECK_ERROR_RETURN (GetDataType (TName, &pType), VFR_RETURN_SUCCESS);
1409
1410 BitField = IsThisBitField (VarStrName);
1411
1412 //
1413 // if it is not struct data type
1414 //
1415 Type = pType->mType;
1416 Size = pType->mTotalSize;
1417
1418 while (*VarStr != '\0') {
1419 CHECK_ERROR_RETURN(ExtractFieldNameAndArrary(VarStr, FName, ArrayIdx), VFR_RETURN_SUCCESS);
1420 CHECK_ERROR_RETURN(GetTypeField (FName, pType, pField), VFR_RETURN_SUCCESS);
1421 pType = pField->mFieldType;
1422 CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp, pField->mIsBitField), VFR_RETURN_SUCCESS);
1423 if (BitField && !pField->mIsBitField) {
1424 Offset = (UINT16) (Offset + Tmp * 8);
1425 } else {
1426 Offset = (UINT16) (Offset + Tmp);
1427 }
1428 Type = GetFieldWidth (pField);
1429 Size = GetFieldSize (pField, ArrayIdx, BitField);
1430 }
1431 return VFR_RETURN_SUCCESS;
1432 }
1433
1434 EFI_VFR_RETURN_CODE
1435 CVfrVarDataTypeDB::GetUserDefinedTypeNameList (
1436 OUT CHAR8 ***NameList,
1437 OUT UINT32 *ListSize
1438 )
1439 {
1440 UINT32 Index;
1441 SVfrDataType *pType;
1442
1443 if ((NameList == NULL) || (ListSize == NULL)) {
1444 return VFR_RETURN_FATAL_ERROR;
1445 }
1446
1447 *NameList = NULL;
1448 *ListSize = 0;
1449
1450 for (pType = mDataTypeList; pType != NULL; pType = pType->mNext) {
1451 if (_IS_INTERNAL_TYPE(pType->mTypeName) == FALSE) {
1452 (*ListSize)++;
1453 }
1454 }
1455
1456 if (*ListSize == 0) {
1457 return VFR_RETURN_SUCCESS;
1458 }
1459
1460 if ((*NameList = new CHAR8*[*ListSize]) == NULL) {
1461 *ListSize = 0;
1462 return VFR_RETURN_OUT_FOR_RESOURCES;
1463 }
1464
1465 for (Index = 0, pType = mDataTypeList; pType != NULL; pType = pType->mNext, Index++) {
1466 if (_IS_INTERNAL_TYPE(pType->mTypeName) == FALSE) {
1467 (*NameList)[Index] = pType->mTypeName;
1468 }
1469 }
1470 return VFR_RETURN_SUCCESS;
1471 }
1472
1473 BOOLEAN
1474 CVfrVarDataTypeDB::IsTypeNameDefined (
1475 IN CHAR8 *TypeName
1476 )
1477 {
1478 SVfrDataType *pType;
1479
1480 if (TypeName == NULL) {
1481 return FALSE;
1482 }
1483
1484 for (pType = mDataTypeList; pType != NULL; pType = pType->mNext) {
1485 if (strcmp (pType->mTypeName, TypeName) == 0) {
1486 return TRUE;
1487 }
1488 }
1489
1490 return FALSE;
1491 }
1492
1493 VOID
1494 CVfrVarDataTypeDB::Dump (
1495 IN FILE *File
1496 )
1497 {
1498 SVfrDataType *pTNode;
1499 SVfrDataField *pFNode;
1500
1501 fprintf (File, "\n\n***************************************************************\n");
1502 fprintf (File, "\t\tmPackAlign = %x\n", mPackAlign);
1503 for (pTNode = mDataTypeList; pTNode != NULL; pTNode = pTNode->mNext) {
1504 fprintf (File, "\t\tstruct %s : mAlign [%d] mTotalSize [0x%x]\n\n", pTNode->mTypeName, pTNode->mAlign, pTNode->mTotalSize);
1505 fprintf (File, "\t\tstruct %s {\n", pTNode->mTypeName);
1506 for (pFNode = pTNode->mMembers; pFNode != NULL; pFNode = pFNode->mNext) {
1507 if (pFNode->mArrayNum > 0) {
1508 fprintf (File, "\t\t\t+%08d[%08x] %s[%d] <%s>\n", pFNode->mOffset, pFNode->mOffset,
1509 pFNode->mFieldName, pFNode->mArrayNum, pFNode->mFieldType->mTypeName);
1510 } else {
1511 fprintf (File, "\t\t\t+%08d[%08x] %s <%s>\n", pFNode->mOffset, pFNode->mOffset,
1512 pFNode->mFieldName, pFNode->mFieldType->mTypeName);
1513 }
1514 }
1515 fprintf (File, "\t\t};\n");
1516 fprintf (File, "---------------------------------------------------------------\n");
1517 }
1518 fprintf (File, "***************************************************************\n");
1519 }
1520
1521 #ifdef CVFR_VARDATATYPEDB_DEBUG
1522 VOID
1523 CVfrVarDataTypeDB::ParserDB (
1524 VOID
1525 )
1526 {
1527 SVfrDataType *pTNode;
1528 SVfrDataField *pFNode;
1529
1530 printf ("***************************************************************\n");
1531 printf ("\t\tmPackAlign = %x\n", mPackAlign);
1532 for (pTNode = mDataTypeList; pTNode != NULL; pTNode = pTNode->mNext) {
1533 printf ("\t\tstruct %s : mAlign [%x] mTotalSize [%x]\n\n", pTNode->mTypeName, pTNode->mAlign, pTNode->mTotalSize);
1534 printf ("\t\tstruct %s {\n", pTNode->mTypeName);
1535 for (pFNode = pTNode->mMembers; pFNode != NULL; pFNode = pFNode->mNext) {
1536 printf ("\t\t\t%s\t%s\n", pFNode->mFieldType->mTypeName, pFNode->mFieldName);
1537 }
1538 printf ("\t\t};\n");
1539 printf ("---------------------------------------------------------------\n");
1540 }
1541 printf ("***************************************************************\n");
1542 }
1543 #endif
1544
1545 SVfrVarStorageNode::SVfrVarStorageNode (
1546 IN EFI_GUID *Guid,
1547 IN CHAR8 *StoreName,
1548 IN EFI_VARSTORE_ID VarStoreId,
1549 IN EFI_STRING_ID VarName,
1550 IN UINT32 VarSize,
1551 IN BOOLEAN Flag
1552 )
1553 {
1554 if (Guid != NULL) {
1555 mGuid = *Guid;
1556 } else {
1557 memset (&mGuid, 0, sizeof (EFI_GUID));
1558 }
1559 if (StoreName != NULL) {
1560 mVarStoreName = new CHAR8[strlen(StoreName) + 1];
1561 strcpy (mVarStoreName, StoreName);
1562 } else {
1563 mVarStoreName = NULL;
1564 }
1565 mNext = NULL;
1566 mVarStoreId = VarStoreId;
1567 mVarStoreType = EFI_VFR_VARSTORE_EFI;
1568 mStorageInfo.mEfiVar.mEfiVarName = VarName;
1569 mStorageInfo.mEfiVar.mEfiVarSize = VarSize;
1570 mAssignedFlag = Flag;
1571 }
1572
1573 SVfrVarStorageNode::SVfrVarStorageNode (
1574 IN EFI_GUID *Guid,
1575 IN CHAR8 *StoreName,
1576 IN EFI_VARSTORE_ID VarStoreId,
1577 IN SVfrDataType *DataType,
1578 IN BOOLEAN BitsVarstore,
1579 IN BOOLEAN Flag
1580 )
1581 {
1582 if (Guid != NULL) {
1583 mGuid = *Guid;
1584 } else {
1585 memset (&mGuid, 0, sizeof (EFI_GUID));
1586 }
1587 if (StoreName != NULL) {
1588 mVarStoreName = new CHAR8[strlen(StoreName) + 1];
1589 strcpy (mVarStoreName, StoreName);
1590 } else {
1591 mVarStoreName = NULL;
1592 }
1593 mNext = NULL;
1594 mVarStoreId = VarStoreId;
1595 if (BitsVarstore) {
1596 mVarStoreType = EFI_VFR_VARSTORE_BUFFER_BITS;
1597 } else {
1598 mVarStoreType = EFI_VFR_VARSTORE_BUFFER;
1599 }
1600 mStorageInfo.mDataType = DataType;
1601 mAssignedFlag = Flag;
1602 }
1603
1604 SVfrVarStorageNode::SVfrVarStorageNode (
1605 IN CHAR8 *StoreName,
1606 IN EFI_VARSTORE_ID VarStoreId
1607 )
1608 {
1609 memset (&mGuid, 0, sizeof (EFI_GUID));
1610 if (StoreName != NULL) {
1611 mVarStoreName = new CHAR8[strlen(StoreName) + 1];
1612 strcpy (mVarStoreName, StoreName);
1613 } else {
1614 mVarStoreName = NULL;
1615 }
1616 mNext = NULL;
1617 mVarStoreId = VarStoreId;
1618 mVarStoreType = EFI_VFR_VARSTORE_NAME;
1619 mStorageInfo.mNameSpace.mNameTable = new EFI_VARSTORE_ID[DEFAULT_NAME_TABLE_ITEMS];
1620 mStorageInfo.mNameSpace.mTableSize = 0;
1621 mAssignedFlag = FALSE;
1622 }
1623
1624 SVfrVarStorageNode::~SVfrVarStorageNode (
1625 VOID
1626 )
1627 {
1628 if (mVarStoreName != NULL) {
1629 delete[] mVarStoreName;
1630 }
1631
1632 if (mVarStoreType == EFI_VFR_VARSTORE_NAME) {
1633 delete[] mStorageInfo.mNameSpace.mNameTable;
1634 }
1635 }
1636
1637 CVfrDataStorage::CVfrDataStorage (
1638 VOID
1639 )
1640 {
1641 UINT32 Index;
1642
1643 for (Index = 0; Index < EFI_FREE_VARSTORE_ID_BITMAP_SIZE; Index++) {
1644 mFreeVarStoreIdBitMap[Index] = 0;
1645 }
1646
1647 // Question ID 0 is reserved.
1648 mFreeVarStoreIdBitMap[0] = 0x80000000;
1649
1650 mBufferVarStoreList = NULL;
1651 mEfiVarStoreList = NULL;
1652 mNameVarStoreList = NULL;
1653 mCurrVarStorageNode = NULL;
1654 mNewVarStorageNode = NULL;
1655 mBufferFieldInfoListHead = NULL;
1656 mBufferFieldInfoListTail = NULL;
1657 }
1658
1659 CVfrDataStorage::~CVfrDataStorage (
1660 VOID
1661 )
1662 {
1663 SVfrVarStorageNode *pNode;
1664
1665 while (mBufferVarStoreList != NULL) {
1666 pNode = mBufferVarStoreList;
1667 mBufferVarStoreList = mBufferVarStoreList->mNext;
1668 delete pNode;
1669 }
1670 while (mEfiVarStoreList != NULL) {
1671 pNode = mEfiVarStoreList;
1672 mEfiVarStoreList = mEfiVarStoreList->mNext;
1673 delete pNode;
1674 }
1675 while (mNameVarStoreList != NULL) {
1676 pNode = mNameVarStoreList;
1677 mNameVarStoreList = mNameVarStoreList->mNext;
1678 delete pNode;
1679 }
1680 if (mNewVarStorageNode != NULL) {
1681 delete mNewVarStorageNode;
1682 }
1683 }
1684
1685 EFI_VARSTORE_ID
1686 CVfrDataStorage::GetFreeVarStoreId (
1687 EFI_VFR_VARSTORE_TYPE VarType
1688 )
1689 {
1690 UINT32 Index, Mask, Offset;
1691
1692 //
1693 // Assign the different ID range for the different type VarStore to support Framework Vfr
1694 //
1695 Index = 0;
1696 if ((!VfrCompatibleMode) || (VarType == EFI_VFR_VARSTORE_BUFFER)) {
1697 Index = 0;
1698 } else if (VarType == EFI_VFR_VARSTORE_EFI) {
1699 Index = 1;
1700 } else if (VarType == EFI_VFR_VARSTORE_NAME) {
1701 Index = 2;
1702 }
1703
1704 for (; Index < EFI_FREE_VARSTORE_ID_BITMAP_SIZE; Index++) {
1705 if (mFreeVarStoreIdBitMap[Index] != 0xFFFFFFFF) {
1706 break;
1707 }
1708 }
1709
1710 if (Index == EFI_FREE_VARSTORE_ID_BITMAP_SIZE) {
1711 return EFI_VARSTORE_ID_INVALID;
1712 }
1713
1714 for (Offset = 0, Mask = 0x80000000; Mask != 0; Mask >>= 1, Offset++) {
1715 if ((mFreeVarStoreIdBitMap[Index] & Mask) == 0) {
1716 mFreeVarStoreIdBitMap[Index] |= Mask;
1717 return (EFI_VARSTORE_ID)((Index << EFI_BITS_SHIFT_PER_UINT32) + Offset);
1718 }
1719 }
1720
1721 return EFI_VARSTORE_ID_INVALID;
1722 }
1723
1724 BOOLEAN
1725 CVfrDataStorage::ChekVarStoreIdFree (
1726 IN EFI_VARSTORE_ID VarStoreId
1727 )
1728 {
1729 UINT32 Index = (VarStoreId / EFI_BITS_PER_UINT32);
1730 UINT32 Offset = (VarStoreId % EFI_BITS_PER_UINT32);
1731
1732 return (mFreeVarStoreIdBitMap[Index] & (0x80000000 >> Offset)) == 0;
1733 }
1734
1735 VOID
1736 CVfrDataStorage::MarkVarStoreIdUsed (
1737 IN EFI_VARSTORE_ID VarStoreId
1738 )
1739 {
1740 UINT32 Index = (VarStoreId / EFI_BITS_PER_UINT32);
1741 UINT32 Offset = (VarStoreId % EFI_BITS_PER_UINT32);
1742
1743 mFreeVarStoreIdBitMap[Index] |= (0x80000000 >> Offset);
1744 }
1745
1746 VOID
1747 CVfrDataStorage::MarkVarStoreIdUnused (
1748 IN EFI_VARSTORE_ID VarStoreId
1749 )
1750 {
1751 UINT32 Index = (VarStoreId / EFI_BITS_PER_UINT32);
1752 UINT32 Offset = (VarStoreId % EFI_BITS_PER_UINT32);
1753
1754 mFreeVarStoreIdBitMap[Index] &= ~(0x80000000 >> Offset);
1755 }
1756
1757 EFI_VFR_RETURN_CODE
1758 CVfrDataStorage::DeclareNameVarStoreBegin (
1759 IN CHAR8 *StoreName,
1760 IN EFI_VARSTORE_ID VarStoreId
1761 )
1762 {
1763 SVfrVarStorageNode *pNode = NULL;
1764 EFI_VARSTORE_ID TmpVarStoreId;
1765
1766 if (StoreName == NULL) {
1767 return VFR_RETURN_FATAL_ERROR;
1768 }
1769
1770 if (GetVarStoreId (StoreName, &TmpVarStoreId) == VFR_RETURN_SUCCESS) {
1771 return VFR_RETURN_REDEFINED;
1772 }
1773
1774 if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
1775 VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_NAME);
1776 } else {
1777 if (ChekVarStoreIdFree (VarStoreId) == FALSE) {
1778 return VFR_RETURN_VARSTOREID_REDEFINED;
1779 }
1780 MarkVarStoreIdUsed (VarStoreId);
1781 }
1782
1783 if ((pNode = new SVfrVarStorageNode (StoreName, VarStoreId)) == NULL) {
1784 return VFR_RETURN_UNDEFINED;
1785 }
1786
1787 mNewVarStorageNode = pNode;
1788
1789 return VFR_RETURN_SUCCESS;
1790 }
1791
1792 EFI_VFR_RETURN_CODE
1793 CVfrDataStorage::NameTableAddItem (
1794 IN EFI_STRING_ID Item
1795 )
1796 {
1797 EFI_VARSTORE_ID *NewTable, *OldTable;
1798 UINT32 TableSize;
1799
1800 OldTable = mNewVarStorageNode->mStorageInfo.mNameSpace.mNameTable;
1801 TableSize = mNewVarStorageNode->mStorageInfo.mNameSpace.mTableSize;
1802
1803 if ((TableSize != 0) && ((TableSize % DEFAULT_NAME_TABLE_ITEMS) == 0)) {
1804 if ((NewTable = new EFI_VARSTORE_ID[TableSize + DEFAULT_NAME_TABLE_ITEMS]) == NULL) {
1805 return VFR_RETURN_OUT_FOR_RESOURCES;
1806 }
1807 memcpy (NewTable, OldTable, TableSize);
1808 mNewVarStorageNode->mStorageInfo.mNameSpace.mNameTable = NewTable;
1809 }
1810
1811 mNewVarStorageNode->mStorageInfo.mNameSpace.mNameTable[TableSize++] = Item;
1812 mNewVarStorageNode->mStorageInfo.mNameSpace.mTableSize = TableSize;
1813
1814 return VFR_RETURN_SUCCESS;
1815 }
1816
1817 EFI_VFR_RETURN_CODE
1818 CVfrDataStorage::DeclareNameVarStoreEnd (
1819 IN EFI_GUID *Guid
1820 )
1821 {
1822 mNewVarStorageNode->mGuid = *Guid;
1823 mNewVarStorageNode->mNext = mNameVarStoreList;
1824 mNameVarStoreList = mNewVarStorageNode;
1825
1826 mNewVarStorageNode = NULL;
1827
1828 return VFR_RETURN_SUCCESS;
1829 }
1830
1831 EFI_VFR_RETURN_CODE
1832 CVfrDataStorage::DeclareEfiVarStore (
1833 IN CHAR8 *StoreName,
1834 IN EFI_GUID *Guid,
1835 IN EFI_STRING_ID NameStrId,
1836 IN UINT32 VarSize,
1837 IN BOOLEAN Flag
1838 )
1839 {
1840 SVfrVarStorageNode *pNode;
1841 EFI_VARSTORE_ID VarStoreId;
1842
1843 if ((StoreName == NULL) || (Guid == NULL)) {
1844 return VFR_RETURN_FATAL_ERROR;
1845 }
1846
1847 if (VarSize > sizeof (UINT64)) {
1848 return VFR_RETURN_EFIVARSTORE_SIZE_ERROR;
1849 }
1850
1851 if (GetVarStoreId (StoreName, &VarStoreId, Guid) == VFR_RETURN_SUCCESS) {
1852 return VFR_RETURN_REDEFINED;
1853 }
1854
1855 VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_EFI);
1856 if ((pNode = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, NameStrId, VarSize, Flag)) == NULL) {
1857 return VFR_RETURN_OUT_FOR_RESOURCES;
1858 }
1859
1860 pNode->mNext = mEfiVarStoreList;
1861 mEfiVarStoreList = pNode;
1862
1863 return VFR_RETURN_SUCCESS;
1864 }
1865
1866 EFI_VFR_RETURN_CODE
1867 CVfrDataStorage::DeclareBufferVarStore (
1868 IN CHAR8 *StoreName,
1869 IN EFI_GUID *Guid,
1870 IN CVfrVarDataTypeDB *DataTypeDB,
1871 IN CHAR8 *TypeName,
1872 IN EFI_VARSTORE_ID VarStoreId,
1873 IN BOOLEAN IsBitVarStore,
1874 IN BOOLEAN Flag
1875 )
1876 {
1877 SVfrVarStorageNode *pNew = NULL;
1878 SVfrDataType *pDataType = NULL;
1879 EFI_VARSTORE_ID TempVarStoreId;
1880
1881 if ((StoreName == NULL) || (Guid == NULL) || (DataTypeDB == NULL)) {
1882 return VFR_RETURN_FATAL_ERROR;
1883 }
1884
1885 if (GetVarStoreId (StoreName, &TempVarStoreId, Guid) == VFR_RETURN_SUCCESS) {
1886 return VFR_RETURN_REDEFINED;
1887 }
1888
1889 CHECK_ERROR_RETURN(DataTypeDB->GetDataType (TypeName, &pDataType), VFR_RETURN_SUCCESS);
1890
1891 if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
1892 VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_BUFFER);
1893 } else {
1894 if (ChekVarStoreIdFree (VarStoreId) == FALSE) {
1895 return VFR_RETURN_VARSTOREID_REDEFINED;
1896 }
1897 MarkVarStoreIdUsed (VarStoreId);
1898 }
1899
1900 if ((pNew = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, pDataType, IsBitVarStore, Flag)) == NULL) {
1901 return VFR_RETURN_OUT_FOR_RESOURCES;
1902 }
1903
1904 pNew->mNext = mBufferVarStoreList;
1905 mBufferVarStoreList = pNew;
1906
1907 if (gCVfrBufferConfig.Register(StoreName, Guid) != 0) {
1908 return VFR_RETURN_FATAL_ERROR;
1909 }
1910
1911 return VFR_RETURN_SUCCESS;
1912 }
1913
1914 EFI_VFR_RETURN_CODE
1915 CVfrDataStorage::GetVarStoreByDataType (
1916 IN CHAR8 *DataTypeName,
1917 OUT SVfrVarStorageNode **VarNode,
1918 IN EFI_GUID *VarGuid
1919 )
1920 {
1921 SVfrVarStorageNode *pNode;
1922 SVfrVarStorageNode *MatchNode;
1923
1924 //
1925 // Framework VFR uses Data type name as varstore name, so don't need check again.
1926 //
1927 if (VfrCompatibleMode) {
1928 return VFR_RETURN_UNDEFINED;
1929 }
1930
1931 MatchNode = NULL;
1932 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
1933 if (strcmp (pNode->mStorageInfo.mDataType->mTypeName, DataTypeName) != 0) {
1934 continue;
1935 }
1936
1937 if ((VarGuid != NULL)) {
1938 if (memcmp (VarGuid, &pNode->mGuid, sizeof (EFI_GUID)) == 0) {
1939 *VarNode = pNode;
1940 return VFR_RETURN_SUCCESS;
1941 }
1942 } else {
1943 if (MatchNode == NULL) {
1944 MatchNode = pNode;
1945 } else {
1946 //
1947 // More than one varstores referred the same data structures.
1948 //
1949 return VFR_RETURN_VARSTORE_DATATYPE_REDEFINED_ERROR;
1950 }
1951 }
1952 }
1953
1954 if (MatchNode == NULL) {
1955 return VFR_RETURN_UNDEFINED;
1956 }
1957
1958 *VarNode = MatchNode;
1959 return VFR_RETURN_SUCCESS;
1960 }
1961
1962 EFI_VARSTORE_ID
1963 CVfrDataStorage::CheckGuidField (
1964 IN SVfrVarStorageNode *pNode,
1965 IN EFI_GUID *StoreGuid,
1966 IN BOOLEAN *HasFoundOne,
1967 OUT EFI_VFR_RETURN_CODE *ReturnCode
1968 )
1969 {
1970 if (StoreGuid != NULL) {
1971 //
1972 // If has guid info, compare the guid filed.
1973 //
1974 if (memcmp (StoreGuid, &pNode->mGuid, sizeof (EFI_GUID)) == 0) {
1975 //
1976 // Both name and guid are same, this this varstore.
1977 //
1978 mCurrVarStorageNode = pNode;
1979 *ReturnCode = VFR_RETURN_SUCCESS;
1980 return TRUE;
1981 }
1982 } else {
1983 //
1984 // Not has Guid field, check whether this name is the only one.
1985 //
1986 if (*HasFoundOne) {
1987 //
1988 // The name has conflict, return name redefined.
1989 //
1990 *ReturnCode = VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR;
1991 return TRUE;
1992 }
1993
1994 *HasFoundOne = TRUE;
1995 mCurrVarStorageNode = pNode;
1996 }
1997
1998 return FALSE;
1999 }
2000
2001 /**
2002 Base on the input store name and guid to find the varstore id.
2003
2004 If both name and guid are inputed, base on the name and guid to
2005 found the varstore. If only name inputed, base on the name to
2006 found the varstore and go on to check whether more than one varstore
2007 has the same name. If only has found one varstore, return this
2008 varstore; if more than one varstore has same name, return varstore
2009 name redefined error. If no varstore found by varstore name, call
2010 function GetVarStoreByDataType and use inputed varstore name as
2011 data type name to search.
2012 **/
2013 EFI_VFR_RETURN_CODE
2014 CVfrDataStorage::GetVarStoreId (
2015 IN CHAR8 *StoreName,
2016 OUT EFI_VARSTORE_ID *VarStoreId,
2017 IN EFI_GUID *StoreGuid
2018 )
2019 {
2020 EFI_VFR_RETURN_CODE ReturnCode;
2021 SVfrVarStorageNode *pNode;
2022 BOOLEAN HasFoundOne = FALSE;
2023
2024 mCurrVarStorageNode = NULL;
2025
2026 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2027 if (strcmp (pNode->mVarStoreName, StoreName) == 0) {
2028 if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) {
2029 *VarStoreId = mCurrVarStorageNode->mVarStoreId;
2030 return ReturnCode;
2031 }
2032 }
2033 }
2034
2035 for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2036 if (strcmp (pNode->mVarStoreName, StoreName) == 0) {
2037 if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) {
2038 *VarStoreId = mCurrVarStorageNode->mVarStoreId;
2039 return ReturnCode;
2040 }
2041 }
2042 }
2043
2044 for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2045 if (strcmp (pNode->mVarStoreName, StoreName) == 0) {
2046 if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) {
2047 *VarStoreId = mCurrVarStorageNode->mVarStoreId;
2048 return ReturnCode;
2049 }
2050 }
2051 }
2052
2053 if (HasFoundOne) {
2054 *VarStoreId = mCurrVarStorageNode->mVarStoreId;
2055 return VFR_RETURN_SUCCESS;
2056 }
2057
2058 *VarStoreId = EFI_VARSTORE_ID_INVALID;
2059
2060 //
2061 // Assume that Data strucutre name is used as StoreName, and check again.
2062 //
2063 ReturnCode = GetVarStoreByDataType (StoreName, &pNode, StoreGuid);
2064 if (pNode != NULL) {
2065 mCurrVarStorageNode = pNode;
2066 *VarStoreId = pNode->mVarStoreId;
2067 }
2068
2069 return ReturnCode;
2070 }
2071
2072 EFI_VFR_RETURN_CODE
2073 CVfrDataStorage::GetBufferVarStoreDataTypeName (
2074 IN EFI_VARSTORE_ID VarStoreId,
2075 OUT CHAR8 **DataTypeName
2076 )
2077 {
2078 SVfrVarStorageNode *pNode;
2079
2080 if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
2081 return VFR_RETURN_FATAL_ERROR;
2082 }
2083
2084 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2085 if (pNode->mVarStoreId == VarStoreId) {
2086 *DataTypeName = pNode->mStorageInfo.mDataType->mTypeName;
2087 return VFR_RETURN_SUCCESS;
2088 }
2089 }
2090
2091 return VFR_RETURN_UNDEFINED;
2092 }
2093
2094 EFI_VFR_VARSTORE_TYPE
2095 CVfrDataStorage::GetVarStoreType (
2096 IN EFI_VARSTORE_ID VarStoreId
2097 )
2098 {
2099 SVfrVarStorageNode *pNode;
2100 EFI_VFR_VARSTORE_TYPE VarStoreType;
2101
2102 VarStoreType = EFI_VFR_VARSTORE_INVALID;
2103
2104 if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
2105 return VarStoreType;
2106 }
2107
2108 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2109 if (pNode->mVarStoreId == VarStoreId) {
2110 VarStoreType = pNode->mVarStoreType;
2111 return VarStoreType;
2112 }
2113 }
2114
2115 for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2116 if (pNode->mVarStoreId == VarStoreId) {
2117 VarStoreType = pNode->mVarStoreType;
2118 return VarStoreType;
2119 }
2120 }
2121
2122 for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2123 if (pNode->mVarStoreId == VarStoreId) {
2124 VarStoreType = pNode->mVarStoreType;
2125 return VarStoreType;
2126 }
2127 }
2128
2129 return VarStoreType;
2130 }
2131
2132 EFI_GUID *
2133 CVfrDataStorage::GetVarStoreGuid (
2134 IN EFI_VARSTORE_ID VarStoreId
2135 )
2136 {
2137 SVfrVarStorageNode *pNode;
2138 EFI_GUID *VarGuid;
2139
2140 VarGuid = NULL;
2141
2142 if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
2143 return VarGuid;
2144 }
2145
2146 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2147 if (pNode->mVarStoreId == VarStoreId) {
2148 VarGuid = &pNode->mGuid;
2149 return VarGuid;
2150 }
2151 }
2152
2153 for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2154 if (pNode->mVarStoreId == VarStoreId) {
2155 VarGuid = &pNode->mGuid;
2156 return VarGuid;
2157 }
2158 }
2159
2160 for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2161 if (pNode->mVarStoreId == VarStoreId) {
2162 VarGuid = &pNode->mGuid;
2163 return VarGuid;
2164 }
2165 }
2166
2167 return VarGuid;
2168 }
2169
2170 EFI_VFR_RETURN_CODE
2171 CVfrDataStorage::GetVarStoreName (
2172 IN EFI_VARSTORE_ID VarStoreId,
2173 OUT CHAR8 **VarStoreName
2174 )
2175 {
2176 SVfrVarStorageNode *pNode;
2177
2178 if (VarStoreName == NULL) {
2179 return VFR_RETURN_FATAL_ERROR;
2180 }
2181
2182 for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2183 if (pNode->mVarStoreId == VarStoreId) {
2184 *VarStoreName = pNode->mVarStoreName;
2185 return VFR_RETURN_SUCCESS;
2186 }
2187 }
2188
2189 for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2190 if (pNode->mVarStoreId == VarStoreId) {
2191 *VarStoreName = pNode->mVarStoreName;
2192 return VFR_RETURN_SUCCESS;
2193 }
2194 }
2195
2196 for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) {
2197 if (pNode->mVarStoreId == VarStoreId) {
2198 *VarStoreName = pNode->mVarStoreName;
2199 return VFR_RETURN_SUCCESS;
2200 }
2201 }
2202
2203 *VarStoreName = NULL;
2204 return VFR_RETURN_UNDEFINED;
2205 }
2206
2207 EFI_VFR_RETURN_CODE
2208 CVfrDataStorage::GetEfiVarStoreInfo (
2209 IN OUT EFI_VARSTORE_INFO *Info
2210 )
2211 {
2212 if (Info == NULL) {
2213 return VFR_RETURN_FATAL_ERROR;
2214 }
2215
2216 if (mCurrVarStorageNode == NULL) {
2217 return VFR_RETURN_GET_EFIVARSTORE_ERROR;
2218 }
2219
2220 Info->mInfo.mVarName = mCurrVarStorageNode->mStorageInfo.mEfiVar.mEfiVarName;
2221 Info->mVarTotalSize = mCurrVarStorageNode->mStorageInfo.mEfiVar.mEfiVarSize;
2222 switch (Info->mVarTotalSize) {
2223 case 1:
2224 Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_8;
2225 break;
2226 case 2:
2227 Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_16;
2228 break;
2229 case 4:
2230 Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_32;
2231 break;
2232 case 8:
2233 Info->mVarType = EFI_IFR_TYPE_NUM_SIZE_64;
2234 break;
2235 default :
2236 return VFR_RETURN_FATAL_ERROR;
2237 }
2238
2239 return VFR_RETURN_SUCCESS;
2240 }
2241
2242 EFI_VFR_RETURN_CODE
2243 CVfrDataStorage::AddBufferVarStoreFieldInfo (
2244 IN EFI_VARSTORE_INFO *Info
2245 )
2246 {
2247 BufferVarStoreFieldInfoNode *pNew;
2248
2249 if ((pNew = new BufferVarStoreFieldInfoNode(Info)) == NULL) {
2250 return VFR_RETURN_FATAL_ERROR;
2251 }
2252
2253 if (mBufferFieldInfoListHead == NULL) {
2254 mBufferFieldInfoListHead = pNew;
2255 mBufferFieldInfoListTail= pNew;
2256 } else {
2257 mBufferFieldInfoListTail->mNext = pNew;
2258 mBufferFieldInfoListTail = pNew;
2259 }
2260
2261 return VFR_RETURN_SUCCESS;
2262 }
2263
2264 EFI_VFR_RETURN_CODE
2265 CVfrDataStorage::GetBufferVarStoreFieldInfo (
2266 IN OUT EFI_VARSTORE_INFO *Info
2267 )
2268 {
2269 BufferVarStoreFieldInfoNode *pNode;
2270
2271 pNode = mBufferFieldInfoListHead;
2272 while (pNode != NULL) {
2273 if (Info->mVarStoreId == pNode->mVarStoreInfo.mVarStoreId &&
2274 Info->mInfo.mVarOffset == pNode->mVarStoreInfo.mInfo.mVarOffset) {
2275 Info->mVarTotalSize = pNode->mVarStoreInfo.mVarTotalSize;
2276 Info->mVarType = pNode->mVarStoreInfo.mVarType;
2277 return VFR_RETURN_SUCCESS;
2278 }
2279 pNode = pNode->mNext;
2280 }
2281 return VFR_RETURN_FATAL_ERROR;
2282 }
2283
2284 EFI_VFR_RETURN_CODE
2285 CVfrDataStorage::GetNameVarStoreInfo (
2286 OUT EFI_VARSTORE_INFO *Info,
2287 IN UINT32 Index
2288 )
2289 {
2290 if (Info == NULL) {
2291 return VFR_RETURN_FATAL_ERROR;
2292 }
2293
2294 if (mCurrVarStorageNode == NULL) {
2295 return VFR_RETURN_GET_NVVARSTORE_ERROR;
2296 }
2297
2298 //
2299 // Framework Vfr file Index is from 1, but Uefi Vfr file Index is from 0.
2300 //
2301 if (VfrCompatibleMode) {
2302 if (Index == 0) {
2303 return VFR_RETURN_ERROR_ARRARY_NUM;
2304 }
2305 Index --;
2306 }
2307
2308 Info->mInfo.mVarName = mCurrVarStorageNode->mStorageInfo.mNameSpace.mNameTable[Index];
2309
2310 return VFR_RETURN_SUCCESS;
2311 }
2312
2313 SVfrDefaultStoreNode::SVfrDefaultStoreNode (
2314 IN EFI_IFR_DEFAULTSTORE *ObjBinAddr,
2315 IN CHAR8 *RefName,
2316 IN EFI_STRING_ID DefaultStoreNameId,
2317 IN UINT16 DefaultId
2318 )
2319 {
2320 mObjBinAddr = ObjBinAddr;
2321
2322 if (RefName != NULL) {
2323 mRefName = new CHAR8[strlen (RefName) + 1];
2324 strcpy (mRefName, RefName);
2325 } else {
2326 mRefName = NULL;
2327 }
2328
2329 mNext = NULL;
2330 mDefaultId = DefaultId;
2331 mDefaultStoreNameId = DefaultStoreNameId;
2332 }
2333
2334 SVfrDefaultStoreNode::~SVfrDefaultStoreNode (
2335 VOID
2336 )
2337 {
2338 if (mRefName != NULL) {
2339 delete[] mRefName;
2340 }
2341 }
2342
2343 CVfrDefaultStore::CVfrDefaultStore (
2344 VOID
2345 )
2346 {
2347 mDefaultStoreList = NULL;
2348 }
2349
2350 CVfrDefaultStore::~CVfrDefaultStore (
2351 VOID
2352 )
2353 {
2354 SVfrDefaultStoreNode *pTmp = NULL;
2355
2356 while (mDefaultStoreList != NULL) {
2357 pTmp = mDefaultStoreList;
2358 mDefaultStoreList = mDefaultStoreList->mNext;
2359 delete pTmp;
2360 }
2361 }
2362
2363 EFI_VFR_RETURN_CODE
2364 CVfrDefaultStore::RegisterDefaultStore (
2365 IN CHAR8 *ObjBinAddr,
2366 IN CHAR8 *RefName,
2367 IN EFI_STRING_ID DefaultStoreNameId,
2368 IN UINT16 DefaultId
2369 )
2370 {
2371 SVfrDefaultStoreNode *pNode = NULL;
2372
2373 if (RefName == NULL) {
2374 return VFR_RETURN_FATAL_ERROR;
2375 }
2376
2377 for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) {
2378 if (strcmp (pNode->mRefName, RefName) == 0) {
2379 return VFR_RETURN_REDEFINED;
2380 }
2381 }
2382
2383 if ((pNode = new SVfrDefaultStoreNode ((EFI_IFR_DEFAULTSTORE *)ObjBinAddr, RefName, DefaultStoreNameId, DefaultId)) == NULL) {
2384 return VFR_RETURN_OUT_FOR_RESOURCES;
2385 }
2386
2387 pNode->mNext = mDefaultStoreList;
2388 mDefaultStoreList = pNode;
2389
2390 return VFR_RETURN_SUCCESS;
2391 }
2392
2393 /*
2394 * assign new reference name or new default store name id only if
2395 * the original is invalid
2396 */
2397 EFI_VFR_RETURN_CODE
2398 CVfrDefaultStore::ReRegisterDefaultStoreById (
2399 IN UINT16 DefaultId,
2400 IN CHAR8 *RefName,
2401 IN EFI_STRING_ID DefaultStoreNameId
2402 )
2403 {
2404 SVfrDefaultStoreNode *pNode = NULL;
2405
2406 for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) {
2407 if (pNode->mDefaultId == DefaultId) {
2408 break;
2409 }
2410 }
2411
2412 if (pNode == NULL) {
2413 return VFR_RETURN_UNDEFINED;
2414 } else {
2415 if (pNode->mDefaultStoreNameId == EFI_STRING_ID_INVALID) {
2416 pNode->mDefaultStoreNameId = DefaultStoreNameId;
2417 if (pNode->mObjBinAddr != NULL) {
2418 pNode->mObjBinAddr->DefaultName = DefaultStoreNameId;
2419 }
2420 } else {
2421 return VFR_RETURN_REDEFINED;
2422 }
2423
2424 if (RefName != NULL) {
2425 delete pNode->mRefName;
2426 pNode->mRefName = new CHAR8[strlen (RefName) + 1];
2427 if (pNode->mRefName != NULL) {
2428 strcpy (pNode->mRefName, RefName);
2429 }
2430 }
2431 }
2432
2433 return VFR_RETURN_SUCCESS;
2434 }
2435
2436 BOOLEAN
2437 CVfrDefaultStore::DefaultIdRegistered (
2438 IN UINT16 DefaultId
2439 )
2440 {
2441 SVfrDefaultStoreNode *pNode = NULL;
2442
2443 for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) {
2444 if (pNode->mDefaultId == DefaultId) {
2445 return TRUE;
2446 }
2447 }
2448
2449 return FALSE;
2450 }
2451
2452 EFI_VFR_RETURN_CODE
2453 CVfrDefaultStore::GetDefaultId (
2454 IN CHAR8 *RefName,
2455 OUT UINT16 *DefaultId
2456 )
2457 {
2458 SVfrDefaultStoreNode *pTmp = NULL;
2459
2460 if (DefaultId == NULL) {
2461 return VFR_RETURN_FATAL_ERROR;
2462 }
2463
2464 for (pTmp = mDefaultStoreList; pTmp != NULL; pTmp = pTmp->mNext) {
2465 if (strcmp (pTmp->mRefName, RefName) == 0) {
2466 *DefaultId = pTmp->mDefaultId;
2467 return VFR_RETURN_SUCCESS;
2468 }
2469 }
2470
2471 return VFR_RETURN_UNDEFINED;
2472 }
2473
2474 EFI_VFR_RETURN_CODE
2475 CVfrDefaultStore::BufferVarStoreAltConfigAdd (
2476 IN EFI_VARSTORE_ID DefaultId,
2477 IN EFI_VARSTORE_INFO &Info,
2478 IN CHAR8 *VarStoreName,
2479 IN EFI_GUID *VarStoreGuid,
2480 IN UINT8 Type,
2481 IN EFI_IFR_TYPE_VALUE Value
2482 )
2483 {
2484 SVfrDefaultStoreNode *pNode = NULL;
2485 CHAR8 NewAltCfg[2 * 2 * sizeof (UINT16) + 1] = {0,};
2486 INTN Returnvalue = 0;
2487
2488 if (VarStoreName == NULL) {
2489 return VFR_RETURN_FATAL_ERROR;
2490 }
2491
2492 for (pNode = mDefaultStoreList; pNode != NULL; pNode = pNode->mNext) {
2493 if (pNode->mDefaultId == DefaultId) {
2494 break;
2495 }
2496 }
2497
2498 if (pNode == NULL) {
2499 return VFR_RETURN_UNDEFINED;
2500 }
2501
2502 gCVfrBufferConfig.Open ();
2503
2504 sprintf (NewAltCfg, "%04x", pNode->mDefaultId);
2505 if ((Returnvalue = gCVfrBufferConfig.Select(VarStoreName, VarStoreGuid)) == 0) {
2506 if ((Returnvalue = gCVfrBufferConfig.Write ('a', VarStoreName, VarStoreGuid, NewAltCfg, Type, Info.mInfo.mVarOffset, Info.mVarTotalSize, Value)) != 0) {
2507 goto WriteError;
2508 }
2509 }
2510
2511 gCVfrBufferConfig.Close ();
2512
2513 return VFR_RETURN_SUCCESS;
2514
2515 WriteError:
2516 gCVfrBufferConfig.Close ();
2517 return (EFI_VFR_RETURN_CODE)Returnvalue;
2518 }
2519
2520 SVfrRuleNode::SVfrRuleNode (
2521 IN CHAR8 *RuleName,
2522 IN UINT8 RuleId
2523 )
2524 {
2525 if (RuleName != NULL) {
2526 mRuleName = new CHAR8[strlen (RuleName) + 1];
2527 strcpy (mRuleName, RuleName);
2528 } else {
2529 mRuleName = NULL;
2530 }
2531
2532 mNext = NULL;
2533 mRuleId = RuleId;
2534 }
2535
2536 SVfrRuleNode::~SVfrRuleNode (
2537 VOID
2538 )
2539 {
2540 if (mRuleName != NULL) {
2541 delete[] mRuleName;
2542 }
2543 }
2544
2545 CVfrRulesDB::CVfrRulesDB ()
2546 {
2547 mRuleList = NULL;
2548 mFreeRuleId = EFI_VARSTORE_ID_START;
2549 }
2550
2551 CVfrRulesDB::~CVfrRulesDB ()
2552 {
2553 SVfrRuleNode *pNode;
2554
2555 while(mRuleList != NULL) {
2556 pNode = mRuleList;
2557 mRuleList = mRuleList->mNext;
2558 delete pNode;
2559 }
2560 }
2561
2562 VOID
2563 CVfrRulesDB::RegisterRule (
2564 IN CHAR8 *RuleName
2565 )
2566 {
2567 SVfrRuleNode *pNew;
2568
2569 if (RuleName == NULL) {
2570 return ;
2571 }
2572
2573 if ((pNew = new SVfrRuleNode (RuleName, mFreeRuleId)) == NULL) {
2574 return ;
2575 }
2576
2577 mFreeRuleId++;
2578
2579 pNew->mNext = mRuleList;
2580 mRuleList = pNew;
2581 }
2582
2583 UINT8
2584 CVfrRulesDB::GetRuleId (
2585 IN CHAR8 *RuleName
2586 )
2587 {
2588 SVfrRuleNode *pNode;
2589
2590 if (RuleName == NULL) {
2591 return EFI_RULE_ID_INVALID;
2592 }
2593
2594 for (pNode = mRuleList; pNode != NULL; pNode = pNode->mNext) {
2595 if (strcmp (pNode->mRuleName, RuleName) == 0) {
2596 return pNode->mRuleId;
2597 }
2598 }
2599
2600 return EFI_RULE_ID_INVALID;
2601 }
2602
2603 CVfrRulesDB gCVfrRulesDB;
2604
2605 EFI_VARSTORE_INFO::EFI_VARSTORE_INFO (
2606 VOID
2607 )
2608 {
2609 mVarStoreId = EFI_VARSTORE_ID_INVALID;
2610 mInfo.mVarName = EFI_STRING_ID_INVALID;
2611 mInfo.mVarOffset = EFI_VAROFFSET_INVALID;
2612 mVarType = EFI_IFR_TYPE_OTHER;
2613 mVarTotalSize = 0;
2614 mIsBitVar = FALSE;
2615 }
2616
2617 EFI_VARSTORE_INFO::EFI_VARSTORE_INFO (
2618 IN EFI_VARSTORE_INFO &Info
2619 )
2620 {
2621 mVarStoreId = Info.mVarStoreId;
2622 mInfo.mVarName = Info.mInfo.mVarName;
2623 mInfo.mVarOffset = Info.mInfo.mVarOffset;
2624 mVarType = Info.mVarType;
2625 mVarTotalSize = Info.mVarTotalSize;
2626 mIsBitVar = Info.mIsBitVar;
2627 }
2628
2629 EFI_VARSTORE_INFO&
2630 EFI_VARSTORE_INFO::operator= (
2631 IN CONST EFI_VARSTORE_INFO &Info
2632 )
2633 {
2634 if (this != &Info) {
2635 mVarStoreId = Info.mVarStoreId;
2636 mInfo.mVarName = Info.mInfo.mVarName;
2637 mInfo.mVarOffset = Info.mInfo.mVarOffset;
2638 mVarType = Info.mVarType;
2639 mVarTotalSize = Info.mVarTotalSize;
2640 mIsBitVar = Info.mIsBitVar;
2641 }
2642
2643 return *this;
2644 }
2645
2646 BOOLEAN
2647 EFI_VARSTORE_INFO::operator == (
2648 IN EFI_VARSTORE_INFO *Info
2649 )
2650 {
2651 if ((mVarStoreId == Info->mVarStoreId) &&
2652 (mInfo.mVarName == Info->mInfo.mVarName) &&
2653 (mInfo.mVarOffset == Info->mInfo.mVarOffset) &&
2654 (mVarType == Info->mVarType) &&
2655 (mVarTotalSize == Info->mVarTotalSize) &&
2656 (mIsBitVar == Info->mIsBitVar)) {
2657 return TRUE;
2658 }
2659
2660 return FALSE;
2661 }
2662
2663 BufferVarStoreFieldInfoNode::BufferVarStoreFieldInfoNode(
2664 IN EFI_VARSTORE_INFO *Info
2665 )
2666 {
2667 mVarStoreInfo.mVarType = Info->mVarType;
2668 mVarStoreInfo.mVarTotalSize = Info->mVarTotalSize;
2669 mVarStoreInfo.mInfo.mVarOffset = Info->mInfo.mVarOffset;
2670 mVarStoreInfo.mVarStoreId = Info->mVarStoreId;
2671 mNext = NULL;
2672 }
2673
2674 BufferVarStoreFieldInfoNode::~BufferVarStoreFieldInfoNode ()
2675 {
2676 mVarStoreInfo.mVarType = EFI_IFR_TYPE_OTHER;
2677 mVarStoreInfo.mVarTotalSize = 0;
2678 mVarStoreInfo.mInfo.mVarOffset = EFI_VAROFFSET_INVALID;
2679 mVarStoreInfo.mVarStoreId = EFI_VARSTORE_ID_INVALID;
2680 mNext = NULL;
2681 }
2682
2683 static EFI_VARSTORE_INFO gEfiInvalidVarStoreInfo;
2684
2685 EFI_QUESTION_ID
2686 CVfrQuestionDB::GetFreeQuestionId (
2687 VOID
2688 )
2689 {
2690 UINT32 Index, Mask, Offset;
2691
2692 for (Index = 0; Index < EFI_FREE_QUESTION_ID_BITMAP_SIZE; Index++) {
2693 if (mFreeQIdBitMap[Index] != 0xFFFFFFFF) {
2694 break;
2695 }
2696 }
2697
2698 if (Index == EFI_FREE_QUESTION_ID_BITMAP_SIZE) {
2699 return EFI_QUESTION_ID_INVALID;
2700 }
2701
2702 for (Offset = 0, Mask = 0x80000000; Mask != 0; Mask >>= 1, Offset++) {
2703 if ((mFreeQIdBitMap[Index] & Mask) == 0) {
2704 mFreeQIdBitMap[Index] |= Mask;
2705 return (EFI_QUESTION_ID)((Index << EFI_BITS_SHIFT_PER_UINT32) + Offset);
2706 }
2707 }
2708
2709 return EFI_QUESTION_ID_INVALID;
2710 }
2711
2712 BOOLEAN
2713 CVfrQuestionDB::ChekQuestionIdFree (
2714 IN EFI_QUESTION_ID QId
2715 )
2716 {
2717 UINT32 Index = (QId / EFI_BITS_PER_UINT32);
2718 UINT32 Offset = (QId % EFI_BITS_PER_UINT32);
2719
2720 return (mFreeQIdBitMap[Index] & (0x80000000 >> Offset)) == 0;
2721 }
2722
2723 VOID
2724 CVfrQuestionDB::MarkQuestionIdUsed (
2725 IN EFI_QUESTION_ID QId
2726 )
2727 {
2728 UINT32 Index = (QId / EFI_BITS_PER_UINT32);
2729 UINT32 Offset = (QId % EFI_BITS_PER_UINT32);
2730
2731 mFreeQIdBitMap[Index] |= (0x80000000 >> Offset);
2732 }
2733
2734 VOID
2735 CVfrQuestionDB::MarkQuestionIdUnused (
2736 IN EFI_QUESTION_ID QId
2737 )
2738 {
2739 UINT32 Index = (QId / EFI_BITS_PER_UINT32);
2740 UINT32 Offset = (QId % EFI_BITS_PER_UINT32);
2741
2742 mFreeQIdBitMap[Index] &= ~(0x80000000 >> Offset);
2743 }
2744
2745 SVfrQuestionNode::SVfrQuestionNode (
2746 IN CHAR8 *Name,
2747 IN CHAR8 *VarIdStr,
2748 IN UINT32 BitMask
2749 )
2750 {
2751 mName = NULL;
2752 mVarIdStr = NULL;
2753 mQuestionId = EFI_QUESTION_ID_INVALID;
2754 mBitMask = BitMask;
2755 mNext = NULL;
2756 mQtype = QUESTION_NORMAL;
2757
2758 if (Name == NULL) {
2759 mName = new CHAR8[strlen ("$DEFAULT") + 1];
2760 strcpy (mName, "$DEFAULT");
2761 } else {
2762 mName = new CHAR8[strlen (Name) + 1];
2763 strcpy (mName, Name);
2764 }
2765
2766 if (VarIdStr != NULL) {
2767 mVarIdStr = new CHAR8[strlen (VarIdStr) + 1];
2768 strcpy (mVarIdStr, VarIdStr);
2769 } else {
2770 mVarIdStr = new CHAR8[strlen ("$") + 1];
2771 strcpy (mVarIdStr, "$");
2772 }
2773 }
2774
2775 SVfrQuestionNode::~SVfrQuestionNode (
2776 VOID
2777 )
2778 {
2779 if (mName != NULL) {
2780 delete[] mName;
2781 }
2782
2783 if (mVarIdStr != NULL) {
2784 delete[] mVarIdStr;
2785 }
2786 }
2787
2788 CVfrQuestionDB::CVfrQuestionDB ()
2789 {
2790 UINT32 Index;
2791
2792 for (Index = 0; Index < EFI_FREE_QUESTION_ID_BITMAP_SIZE; Index++) {
2793 mFreeQIdBitMap[Index] = 0;
2794 }
2795
2796 // Question ID 0 is reserved.
2797 mFreeQIdBitMap[0] = 0x80000000;
2798 mQuestionList = NULL;
2799 }
2800
2801 CVfrQuestionDB::~CVfrQuestionDB ()
2802 {
2803 SVfrQuestionNode *pNode;
2804
2805 while (mQuestionList != NULL) {
2806 pNode = mQuestionList;
2807 mQuestionList = mQuestionList->mNext;
2808 delete pNode;
2809 }
2810 }
2811
2812 //
2813 // Reset to init state
2814 //
2815 VOID
2816 CVfrQuestionDB::ResetInit(
2817 IN VOID
2818 )
2819 {
2820 UINT32 Index;
2821 SVfrQuestionNode *pNode;
2822
2823 while (mQuestionList != NULL) {
2824 pNode = mQuestionList;
2825 mQuestionList = mQuestionList->mNext;
2826 delete pNode;
2827 }
2828
2829 for (Index = 0; Index < EFI_FREE_QUESTION_ID_BITMAP_SIZE; Index++) {
2830 mFreeQIdBitMap[Index] = 0;
2831 }
2832
2833 // Question ID 0 is reserved.
2834 mFreeQIdBitMap[0] = 0x80000000;
2835 mQuestionList = NULL;
2836 }
2837
2838 VOID
2839 CVfrQuestionDB::PrintAllQuestion (
2840 VOID
2841 )
2842 {
2843 SVfrQuestionNode *pNode = NULL;
2844
2845 for (pNode = mQuestionList; pNode != NULL; pNode = pNode->mNext) {
2846 printf ("Question VarId is %s and QuesitonId is 0x%x\n", pNode->mVarIdStr, pNode->mQuestionId);
2847 }
2848 }
2849
2850 EFI_VFR_RETURN_CODE
2851 CVfrQuestionDB::RegisterQuestion (
2852 IN CHAR8 *Name,
2853 IN CHAR8 *VarIdStr,
2854 IN OUT EFI_QUESTION_ID &QuestionId
2855 )
2856 {
2857 SVfrQuestionNode *pNode = NULL;
2858
2859 if ((Name != NULL) && (FindQuestion(Name) == VFR_RETURN_SUCCESS)) {
2860 return VFR_RETURN_REDEFINED;
2861 }
2862
2863 if ((pNode = new SVfrQuestionNode (Name, VarIdStr)) == NULL) {
2864 return VFR_RETURN_OUT_FOR_RESOURCES;
2865 }
2866
2867 if (QuestionId == EFI_QUESTION_ID_INVALID) {
2868 QuestionId = GetFreeQuestionId ();
2869 } else {
2870 //
2871 // For Framework Vfr, don't check question ID conflict.
2872 //
2873 if (!VfrCompatibleMode && ChekQuestionIdFree (QuestionId) == FALSE) {
2874 delete pNode;
2875 return VFR_RETURN_QUESTIONID_REDEFINED;
2876 }
2877 MarkQuestionIdUsed (QuestionId);
2878 }
2879 pNode->mQuestionId = QuestionId;
2880
2881 pNode->mNext = mQuestionList;
2882 mQuestionList = pNode;
2883
2884 gCFormPkg.DoPendingAssign (VarIdStr, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2885
2886 return VFR_RETURN_SUCCESS;
2887 }
2888
2889 VOID
2890 CVfrQuestionDB::RegisterOldDateQuestion (
2891 IN CHAR8 *YearVarId,
2892 IN CHAR8 *MonthVarId,
2893 IN CHAR8 *DayVarId,
2894 IN OUT EFI_QUESTION_ID &QuestionId
2895 )
2896 {
2897 SVfrQuestionNode *pNode[3] = {NULL, };
2898 UINT32 Index;
2899
2900 if ((YearVarId == NULL) || (MonthVarId == NULL) || (DayVarId == NULL)) {
2901 return;
2902 }
2903
2904 if ((pNode[0] = new SVfrQuestionNode (NULL, YearVarId, DATE_YEAR_BITMASK)) == NULL) {
2905 goto Err;
2906 }
2907 if ((pNode[1] = new SVfrQuestionNode (NULL, MonthVarId, DATE_MONTH_BITMASK)) == NULL) {
2908 goto Err;
2909 }
2910 if ((pNode[2] = new SVfrQuestionNode (NULL, DayVarId, DATE_DAY_BITMASK)) == NULL) {
2911 goto Err;
2912 }
2913
2914 if (QuestionId == EFI_QUESTION_ID_INVALID) {
2915 QuestionId = GetFreeQuestionId ();
2916 } else {
2917 if (ChekQuestionIdFree (QuestionId) == FALSE) {
2918 goto Err;
2919 }
2920 MarkQuestionIdUsed (QuestionId);
2921 }
2922
2923 pNode[0]->mQuestionId = QuestionId;
2924 pNode[1]->mQuestionId = QuestionId;
2925 pNode[2]->mQuestionId = QuestionId;
2926 pNode[0]->mQtype = QUESTION_DATE;
2927 pNode[1]->mQtype = QUESTION_DATE;
2928 pNode[2]->mQtype = QUESTION_DATE;
2929 pNode[0]->mNext = pNode[1];
2930 pNode[1]->mNext = pNode[2];
2931 pNode[2]->mNext = mQuestionList;
2932 mQuestionList = pNode[0];
2933
2934 gCFormPkg.DoPendingAssign (YearVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2935 gCFormPkg.DoPendingAssign (MonthVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2936 gCFormPkg.DoPendingAssign (DayVarId, (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
2937
2938 return;
2939
2940 Err:
2941 for (Index = 0; Index < 3; Index++) {
2942 if (pNode[Index] != NULL) {
2943 delete pNode[Index];
2944 }
2945 }
2946 QuestionId = EFI_QUESTION_ID_INVALID;
2947 }
2948
2949 VOID
2950 CVfrQuestionDB::RegisterNewDateQuestion (
2951 IN CHAR8 *Name,
2952 IN CHAR8 *BaseVarId,
2953 IN OUT EFI_QUESTION_ID &QuestionId
2954 )
2955 {
2956 SVfrQuestionNode *pNode[3] = {NULL, };
2957 UINT32 Len;
2958 CHAR8 *VarIdStr[3] = {NULL, };
2959 CHAR8 Index;
2960
2961 if (BaseVarId == NULL && Name == NULL) {
2962 if (QuestionId == EFI_QUESTION_ID_INVALID) {
2963 QuestionId = GetFreeQuestionId ();
2964 } else {
2965 if (ChekQuestionIdFree (QuestionId) == FALSE) {
2966 goto Err;
2967 }
2968 MarkQuestionIdUsed (QuestionId);
2969 }
2970 return;
2971 }
2972
2973 if (BaseVarId != NULL) {
2974 Len = strlen (BaseVarId);
2975
2976 VarIdStr[0] = new CHAR8[Len + strlen (".Year") + 1];
2977 if (VarIdStr[0] != NULL) {
2978 strcpy (VarIdStr[0], BaseVarId);
2979 strcat (VarIdStr[0], ".Year");
2980 }
2981 VarIdStr[1] = new CHAR8[Len + strlen (".Month") + 1];
2982 if (VarIdStr[1] != NULL) {
2983 strcpy (VarIdStr[1], BaseVarId);
2984 strcat (VarIdStr[1], ".Month");
2985 }
2986 VarIdStr[2] = new CHAR8[Len + strlen (".Day") + 1];
2987 if (VarIdStr[2] != NULL) {
2988 strcpy (VarIdStr[2], BaseVarId);
2989 strcat (VarIdStr[2], ".Day");
2990 }
2991 } else {
2992 Len = strlen (Name);
2993
2994 VarIdStr[0] = new CHAR8[Len + strlen (".Year") + 1];
2995 if (VarIdStr[0] != NULL) {
2996 strcpy (VarIdStr[0], Name);
2997 strcat (VarIdStr[0], ".Year");
2998 }
2999 VarIdStr[1] = new CHAR8[Len + strlen (".Month") + 1];
3000 if (VarIdStr[1] != NULL) {
3001 strcpy (VarIdStr[1], Name);
3002 strcat (VarIdStr[1], ".Month");
3003 }
3004 VarIdStr[2] = new CHAR8[Len + strlen (".Day") + 1];
3005 if (VarIdStr[2] != NULL) {
3006 strcpy (VarIdStr[2], Name);
3007 strcat (VarIdStr[2], ".Day");
3008 }
3009 }
3010
3011 if ((pNode[0] = new SVfrQuestionNode (Name, VarIdStr[0], DATE_YEAR_BITMASK)) == NULL) {
3012 goto Err;
3013 }
3014 if ((pNode[1] = new SVfrQuestionNode (Name, VarIdStr[1], DATE_MONTH_BITMASK)) == NULL) {
3015 goto Err;
3016 }
3017 if ((pNode[2] = new SVfrQuestionNode (Name, VarIdStr[2], DATE_DAY_BITMASK)) == NULL) {
3018 goto Err;
3019 }
3020
3021 if (QuestionId == EFI_QUESTION_ID_INVALID) {
3022 QuestionId = GetFreeQuestionId ();
3023 } else {
3024 if (ChekQuestionIdFree (QuestionId) == FALSE) {
3025 goto Err;
3026 }
3027 MarkQuestionIdUsed (QuestionId);
3028 }
3029
3030 pNode[0]->mQuestionId = QuestionId;
3031 pNode[1]->mQuestionId = QuestionId;
3032 pNode[2]->mQuestionId = QuestionId;
3033 pNode[0]->mQtype = QUESTION_DATE;
3034 pNode[1]->mQtype = QUESTION_DATE;
3035 pNode[2]->mQtype = QUESTION_DATE;
3036 pNode[0]->mNext = pNode[1];
3037 pNode[1]->mNext = pNode[2];
3038 pNode[2]->mNext = mQuestionList;
3039 mQuestionList = pNode[0];
3040
3041 for (Index = 0; Index < 3; Index++) {
3042 if (VarIdStr[Index] != NULL) {
3043 delete VarIdStr[Index];
3044 }
3045 }
3046
3047 gCFormPkg.DoPendingAssign (VarIdStr[0], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
3048 gCFormPkg.DoPendingAssign (VarIdStr[1], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
3049 gCFormPkg.DoPendingAssign (VarIdStr[2], (VOID *)&QuestionId, sizeof(EFI_QUESTION_ID));
3050
3051 return;
3052
3053 Err:
3054 for (Index = 0; Index < 3; Index++) {
3055 if (pNode[Index] != NULL) {
3056 delete pNode[Index];
3057 }
3058
3059 if (VarIdStr[Index] != NULL) {
3060 delete VarIdStr[Index];
3061 }
3062 }
3063 }
3064
3065 VOID
3066 CVfrQuestionDB::RegisterOldTimeQuestion (
3067 IN CHAR8 *HourVarId,
3068 IN CHAR8 *MinuteVarId,
3069 IN CHAR8 *SecondVarId,
3070 IN OUT EFI_QUESTION_ID &QuestionId
3071 )
3072 {
3073 SVfrQuestionNode *pNode[3] = {NULL, };
3074 UINT32 Index;
3075
3076 if ((HourVarId == NULL) || (MinuteVarId == NULL) || (SecondVarId == NULL)) {
3077 return;
3078 }
3079
3080 if ((pNode[0] = new SVfrQuestionNode (NULL, HourVarId, TIME_HOUR_BITMASK)) == NULL) {
3081 goto Err;
3082 }
3083 if ((pNode[1] = new SVfrQuestionNode (NULL, MinuteVarId, TIME_MINUTE_BITMASK)) == NULL) {
3084 goto Err;
3085 }
3086 if ((pNode[2] = new SVfrQuestionNode (NULL, SecondVarId, TIME_SECOND_BITMASK)) == NULL) {
3087 goto Err;
3088 }
3089
3090 if (QuestionId == EFI_QUESTION_ID_INVALID) {
3091 QuestionId = GetFreeQuestionId ();
3092 } else {
3093 if (ChekQuestionIdFree (QuestionId) == FALSE) {
3094 goto Err;
3095 }
3096 MarkQuestionIdUsed (QuestionId);
3097 }
3098
3099 pNode[0]->mQuestionId = QuestionId;
3100 pNode[1]->mQuestionId = QuestionId;
3101 pNode[2]->mQuestionId = QuestionId;
3102 pNode[0]->mQtype = QUESTION_TIME;
3103 pNode[1]->mQtype = QUESTION_TIME;
3104 pNode[2]->mQtype = QUESTION_TIME;
3105 pNode[0]->mNext = pNode[1];
3106 pNode[1]->mNext = pNode[2];
3107 pNode[2]->mNext = mQuestionList;