]> git.proxmox.com Git - mirror_edk2.git/blob - EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/VfrUtilityLib.cpp
projects / mirror_edk2.git / blob
? search:


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