]> git.proxmox.com Git - mirror_edk2.git/blob - EdkCompatibilityPkg/Compatibility/FrameworkHiiOnUefiHiiThunk/UefiIfrParser.c
projects / mirror_edk2.git / blob
? search:


bfeb564ba210bb0b9e5f9585321db8581fe76578
[mirror_edk2.git] / EdkCompatibilityPkg / Compatibility / FrameworkHiiOnUefiHiiThunk / UefiIfrParser.c
1 /** @file
2 Parser for IFR binary encoding.
3
4 Copyright (c) 2008, Intel Corporation
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include <PiDxe.h>
16
17 #include <Protocol/HiiConfigAccess.h>
18 #include <Protocol/HiiConfigRouting.h>
19 #include <Protocol/HiiDatabase.h>
20 #include <Protocol/HiiString.h>
21
22 #include <Library/BaseLib.h>
23 #include <Library/BaseMemoryLib.h>
24 #include <Library/DebugLib.h>
25 #include <Library/HiiLib.h>
26 #include <Library/MemoryAllocationLib.h>
27 #include <Library/PrintLib.h>
28 #include <Library/UefiBootServicesTableLib.h>
29
30 #include <Guid/MdeModuleHii.h>
31
32 #include "UefiIfrParser.h"
33
34 #include "UefiIfrParserExpression.h"
35
36 UINT16 mStatementIndex;
37
38 BOOLEAN mInScopeSubtitle;
39 BOOLEAN mInScopeSuppress;
40 BOOLEAN mInScopeGrayOut;
41
42 EFI_GUID mFrameworkHiiCompatibilityGuid = EFI_IFR_FRAMEWORK_GUID;
43 extern EFI_GUID mTianoHiiIfrGuid;
44
45 LIST_ENTRY *
46 GetOneOfOptionMapEntryListHead (
47 IN CONST FORM_BROWSER_FORMSET *FormSet,
48 IN UINT16 QuestionId
49 )
50 {
51 LIST_ENTRY *Link;
52 ONE_OF_OPTION_MAP *Map;
53
54 Link = GetFirstNode (&FormSet->OneOfOptionMapListHead);
55
56 while (!IsNull (&FormSet->OneOfOptionMapListHead, Link)) {
57 Map = ONE_OF_OPTION_MAP_FROM_LINK (Link);
58 if (QuestionId == Map->QuestionId) {
59 return &Map->OneOfOptionMapEntryListHead;
60 }
61 Link = GetNextNode (&FormSet->OneOfOptionMapListHead, Link);
62 }
63
64 return NULL;
65 }
66
67 VOID
68 DestoryOneOfOptionMap (
69 IN LIST_ENTRY *OneOfOptionMapListHead
70 )
71 {
72 ONE_OF_OPTION_MAP *Map;
73 ONE_OF_OPTION_MAP_ENTRY *MapEntry;
74 LIST_ENTRY *Link;
75 LIST_ENTRY *Link2;
76
77 while (!IsListEmpty (OneOfOptionMapListHead)) {
78 Link = GetFirstNode (OneOfOptionMapListHead);
79
80 Map = ONE_OF_OPTION_MAP_FROM_LINK (Link);
81
82 while (!IsListEmpty (&Map->OneOfOptionMapEntryListHead)) {
83 Link2 = GetFirstNode (&Map->OneOfOptionMapEntryListHead);
84
85 MapEntry = ONE_OF_OPTION_MAP_ENTRY_FROM_LINK (Link2);
86
87 RemoveEntryList (Link2);
88
89 FreePool (MapEntry);
90 }
91
92 RemoveEntryList (Link);
93 FreePool (Map);
94 }
95 }
96
97
98 /**
99 Initialize Statement header members.
100
101 @param OpCodeData Pointer of the raw OpCode data.
102 @param FormSet Pointer of the current FormSe.
103 @param Form Pointer of the current Form.
104
105 @return The Statement.
106
107 **/
108 FORM_BROWSER_STATEMENT *
109 CreateStatement (
110 IN UINT8 *OpCodeData,
111 IN OUT FORM_BROWSER_FORMSET *FormSet,
112 IN OUT FORM_BROWSER_FORM *Form
113 )
114 {
115 FORM_BROWSER_STATEMENT *Statement;
116 EFI_IFR_STATEMENT_HEADER *StatementHdr;
117
118 if (Form == NULL) {
119 //
120 // We are currently not in a Form Scope, so just skip this Statement
121 //
122 return NULL;
123 }
124
125 Statement = &FormSet->StatementBuffer[mStatementIndex];
126 mStatementIndex++;
127
128 InitializeListHead (&Statement->DefaultListHead);
129 InitializeListHead (&Statement->OptionListHead);
130
131 Statement->Signature = FORM_BROWSER_STATEMENT_SIGNATURE;
132
133 Statement->Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;
134
135 StatementHdr = (EFI_IFR_STATEMENT_HEADER *) (OpCodeData + sizeof (EFI_IFR_OP_HEADER));
136 CopyMem (&Statement->Prompt, &StatementHdr->Prompt, sizeof (EFI_STRING_ID));
137 CopyMem (&Statement->Help, &StatementHdr->Help, sizeof (EFI_STRING_ID));
138
139 Statement->InSubtitle = mInScopeSubtitle;
140
141 //
142 // Insert this Statement into current Form
143 //
144 InsertTailList (&Form->StatementListHead, &Statement->Link);
145
146 return Statement;
147 }
148
149 /**
150 Initialize Question's members.
151
152 @param OpCodeData Pointer of the raw OpCode data.
153 @param FormSet Pointer of the current FormSet.
154 @param Form Pointer of the current Form.
155
156 @return The Question.
157
158 **/
159 FORM_BROWSER_STATEMENT *
160 CreateQuestion (
161 IN UINT8 *OpCodeData,
162 IN OUT FORM_BROWSER_FORMSET *FormSet,
163 IN OUT FORM_BROWSER_FORM *Form
164 )
165 {
166 FORM_BROWSER_STATEMENT *Statement;
167 EFI_IFR_QUESTION_HEADER *QuestionHdr;
168 LIST_ENTRY *Link;
169 FORMSET_STORAGE *Storage;
170
171 Statement = CreateStatement (OpCodeData, FormSet, Form);
172 if (Statement == NULL) {
173 return NULL;
174 }
175
176 QuestionHdr = (EFI_IFR_QUESTION_HEADER *) (OpCodeData + sizeof (EFI_IFR_OP_HEADER));
177 CopyMem (&Statement->QuestionId, &QuestionHdr->QuestionId, sizeof (EFI_QUESTION_ID));
178 CopyMem (&Statement->VarStoreId, &QuestionHdr->VarStoreId, sizeof (EFI_VARSTORE_ID));
179 CopyMem (&Statement->VarStoreInfo.VarOffset, &QuestionHdr->VarStoreInfo.VarOffset, sizeof (UINT16));
180
181 if (FormSet->MaxQuestionId < QuestionHdr->QuestionId) {
182 FormSet->MaxQuestionId = QuestionHdr->QuestionId;
183 }
184
185 Statement->QuestionFlags = QuestionHdr->Flags;
186
187 if (Statement->VarStoreId == 0) {
188 //
189 // VarStoreId of zero indicates no variable storage
190 //
191 return Statement;
192 }
193
194 //
195 // Find Storage for this Question
196 //
197 Link = GetFirstNode (&FormSet->StorageListHead);
198 while (!IsNull (&FormSet->StorageListHead, Link)) {
199 Storage = FORMSET_STORAGE_FROM_LINK (Link);
200
201 if (Storage->VarStoreId == Statement->VarStoreId) {
202 Statement->Storage = Storage;
203 break;
204 }
205
206 Link = GetNextNode (&FormSet->StorageListHead, Link);
207 }
208 ASSERT (Statement->Storage != NULL);
209
210 return Statement;
211 }
212
213 /**
214 Allocate a FORMSET_STORAGE data structure and insert to FormSet Storage List.
215
216 @param FormSet Pointer of the current FormSet
217
218 @return Pointer to a FORMSET_STORAGE data structure.
219
220 **/
221 FORMSET_STORAGE *
222 CreateStorage (
223 IN FORM_BROWSER_FORMSET *FormSet
224 )
225 {
226 FORMSET_STORAGE *Storage;
227
228 Storage = AllocateZeroPool (sizeof (FORMSET_STORAGE));
229 Storage->Signature = FORMSET_STORAGE_SIGNATURE;
230 InsertTailList (&FormSet->StorageListHead, &Storage->Link);
231
232 return Storage;
233 }
234
235 /**
236 Free resources of a storage
237
238 @param Storage Pointer of the storage
239
240 @return None.
241
242 **/
243 VOID
244 DestroyStorage (
245 IN FORMSET_STORAGE *Storage
246 )
247 {
248 if (Storage == NULL) {
249 return;
250 }
251
252 if (Storage->Name!= NULL) {
253 FreePool (Storage->Name);
254 }
255
256 FreePool (Storage);
257 }
258
259
260 /**
261 Free resources of a Statement
262
263 @param Statement Pointer of the Statement
264
265 @return None.
266
267 **/
268 VOID
269 DestroyStatement (
270 IN OUT FORM_BROWSER_STATEMENT *Statement
271 )
272 {
273 LIST_ENTRY *Link;
274 QUESTION_DEFAULT *Default;
275 QUESTION_OPTION *Option;
276
277 //
278 // Free Default value List
279 //
280 while (!IsListEmpty (&Statement->DefaultListHead)) {
281 Link = GetFirstNode (&Statement->DefaultListHead);
282 Default = QUESTION_DEFAULT_FROM_LINK (Link);
283 RemoveEntryList (&Default->Link);
284
285 gBS->FreePool (Default);
286 }
287
288 //
289 // Free Options List
290 //
291 while (!IsListEmpty (&Statement->OptionListHead)) {
292 Link = GetFirstNode (&Statement->OptionListHead);
293 Option = QUESTION_OPTION_FROM_LINK (Link);
294 RemoveEntryList (&Option->Link);
295
296 gBS->FreePool (Option);
297 }
298
299 }
300
301
302
303 /**
304 Free resources of a Form
305
306 @param Form Pointer of the Form
307
308 @return None.
309
310 **/
311 VOID
312 DestroyForm (
313 IN OUT FORM_BROWSER_FORM *Form
314 )
315 {
316 LIST_ENTRY *Link;
317 FORM_BROWSER_STATEMENT *Statement;
318
319 //
320 // Free Statements/Questions
321 //
322 while (!IsListEmpty (&Form->StatementListHead)) {
323 Link = GetFirstNode (&Form->StatementListHead);
324 Statement = FORM_BROWSER_STATEMENT_FROM_LINK (Link);
325 RemoveEntryList (&Statement->Link);
326
327 DestroyStatement (Statement);
328 }
329
330 //
331 // Free this Form
332 //
333 gBS->FreePool (Form);
334 }
335
336
337 /**
338 Free resources allocated for a FormSet
339
340 @param FormSet Pointer of the FormSet
341
342 @return None.
343
344 **/
345 VOID
346 DestroyFormSet (
347 IN OUT FORM_BROWSER_FORMSET *FormSet
348 )
349 {
350 LIST_ENTRY *Link;
351 FORMSET_STORAGE *Storage;
352 FORMSET_DEFAULTSTORE *DefaultStore;
353 FORM_BROWSER_FORM *Form;
354
355 //
356 // Free IFR binary buffer
357 //
358 FreePool (FormSet->IfrBinaryData);
359
360 //
361 // Free FormSet Storage
362 //
363 if (FormSet->StorageListHead.ForwardLink != NULL) {
364 while (!IsListEmpty (&FormSet->StorageListHead)) {
365 Link = GetFirstNode (&FormSet->StorageListHead);
366 Storage = FORMSET_STORAGE_FROM_LINK (Link);
367 RemoveEntryList (&Storage->Link);
368
369 DestroyStorage (Storage);
370 }
371 }
372
373 //
374 // Free FormSet Default Store
375 //
376 if (FormSet->DefaultStoreListHead.ForwardLink != NULL) {
377 while (!IsListEmpty (&FormSet->DefaultStoreListHead)) {
378 Link = GetFirstNode (&FormSet->DefaultStoreListHead);
379 DefaultStore = FORMSET_DEFAULTSTORE_FROM_LINK (Link);
380 RemoveEntryList (&DefaultStore->Link);
381
382 gBS->FreePool (DefaultStore);
383 }
384 }
385
386 //
387 // Free Forms
388 //
389 if (FormSet->FormListHead.ForwardLink != NULL) {
390 while (!IsListEmpty (&FormSet->FormListHead)) {
391 Link = GetFirstNode (&FormSet->FormListHead);
392 Form = FORM_BROWSER_FORM_FROM_LINK (Link);
393 RemoveEntryList (&Form->Link);
394
395 DestroyForm (Form);
396 }
397 }
398
399 if (FormSet->StatementBuffer != NULL) {
400 FreePool (FormSet->StatementBuffer);
401 }
402
403 DestoryOneOfOptionMap (&FormSet->OneOfOptionMapListHead);
404
405 if (FormSet->OriginalDefaultVarStoreName != NULL) {
406 FreePool (FormSet->OriginalDefaultVarStoreName);
407 }
408
409 FreePool (FormSet);
410 }
411
412
413 /**
414 Tell whether this Operand is an Expression OpCode or not
415
416 @param Operand Operand of an IFR OpCode.
417
418 @retval TRUE This is an Expression OpCode.
419 @retval FALSE Not an Expression OpCode.
420
421 **/
422 BOOLEAN
423 IsExpressionOpCode (
424 IN UINT8 Operand
425 )
426 {
427 if (((Operand >= EFI_IFR_EQ_ID_VAL_OP) && (Operand <= EFI_IFR_NOT_OP)) ||
428 ((Operand >= EFI_IFR_MATCH_OP) && (Operand <= EFI_IFR_SPAN_OP)) ||
429 (Operand == EFI_IFR_CATENATE_OP)
430 ) {
431 return TRUE;
432 } else {
433 return FALSE;
434 }
435 }
436
437
438 /**
439 Calculate number of Statemens(Questions) and Expression OpCodes.
440
441 @param FormSet The FormSet to be counted.
442 @param NumberOfStatement Number of Statemens(Questions)
443 @param NumberOfExpression Number of Expression OpCodes
444
445 @return None.
446
447 **/
448 VOID
449 CountOpCodes (
450 IN FORM_BROWSER_FORMSET *FormSet,
451 IN OUT UINT16 *NumberOfStatement,
452 IN OUT UINT16 *NumberOfExpression
453 )
454 {
455 UINT16 StatementCount;
456 UINT16 ExpressionCount;
457 UINT8 *OpCodeData;
458 UINTN Offset;
459 UINTN OpCodeLen;
460
461 Offset = 0;
462 StatementCount = 0;
463 ExpressionCount = 0;
464
465 while (Offset < FormSet->IfrBinaryLength) {
466 OpCodeData = FormSet->IfrBinaryData + Offset;
467 OpCodeLen = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
468 Offset += OpCodeLen;
469
470 if (IsExpressionOpCode (((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode)) {
471 ExpressionCount++;
472 } else {
473 StatementCount++;
474 }
475 }
476
477 *NumberOfStatement = StatementCount;
478 *NumberOfExpression = ExpressionCount;
479 }
480
481
482 /**
483 Parse opcodes in the formset IFR binary.
484
485 @param FormSet Pointer of the FormSet data structure.
486
487 @retval EFI_SUCCESS Opcode parse success.
488 @retval Other Opcode parse fail.
489
490 **/
491 EFI_STATUS
492 ParseOpCodes (
493 IN FORM_BROWSER_FORMSET *FormSet
494 )
495 {
496 EFI_STATUS Status;
497 UINT16 Index;
498 FORM_BROWSER_FORM *CurrentForm;
499 FORM_BROWSER_STATEMENT *CurrentStatement;
500 UINT8 Operand;
501 UINT8 Scope;
502 UINTN OpCodeOffset;
503 UINTN OpCodeLength;
504 UINT8 *OpCodeData;
505 UINT8 ScopeOpCode;
506 FORMSET_STORAGE *Storage;
507 FORMSET_DEFAULTSTORE *DefaultStore;
508 QUESTION_DEFAULT *CurrentDefault;
509 QUESTION_OPTION *CurrentOption;
510 CHAR8 *AsciiString;
511 UINT16 NumberOfStatement;
512 UINT16 NumberOfExpression;
513 EFI_IMAGE_ID *ImageId;
514 EFI_HII_VALUE *Value;
515 LIST_ENTRY *OneOfOptinMapEntryListHead;
516 EFI_IFR_GUID_OPTIONKEY *OptionMap;
517 ONE_OF_OPTION_MAP *OneOfOptionMap;
518 ONE_OF_OPTION_MAP_ENTRY *OneOfOptionMapEntry;
519 UINT8 OneOfType;
520 EFI_IFR_ONE_OF *OneOfOpcode;
521
522 mInScopeSubtitle = FALSE;
523 mInScopeSuppress = FALSE;
524 mInScopeGrayOut = FALSE;
525 CurrentDefault = NULL;
526 CurrentOption = NULL;
527
528 //
529 // Set to a invalid value.
530 //
531 OneOfType = (UINT8) -1;
532
533 //
534 // Get the number of Statements and Expressions
535 //
536 CountOpCodes (FormSet, &NumberOfStatement, &NumberOfExpression);
537 FormSet->NumberOfStatement = NumberOfStatement;
538
539 mStatementIndex = 0;
540 FormSet->StatementBuffer = AllocateZeroPool (NumberOfStatement * sizeof (FORM_BROWSER_STATEMENT));
541 if (FormSet->StatementBuffer == NULL) {
542 return EFI_OUT_OF_RESOURCES;
543 }
544
545 InitializeListHead (&FormSet->StorageListHead);
546 InitializeListHead (&FormSet->DefaultStoreListHead);
547 InitializeListHead (&FormSet->FormListHead);
548 InitializeListHead (&FormSet->OneOfOptionMapListHead);
549
550 CurrentForm = NULL;
551 CurrentStatement = NULL;
552
553 ResetScopeStack ();
554
555 OpCodeOffset = 0;
556 while (OpCodeOffset < FormSet->IfrBinaryLength) {
557 OpCodeData = FormSet->IfrBinaryData + OpCodeOffset;
558
559 OpCodeLength = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
560 OpCodeOffset += OpCodeLength;
561 Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;
562 Scope = ((EFI_IFR_OP_HEADER *) OpCodeData)->Scope;
563
564 //
565 // If scope bit set, push onto scope stack
566 //
567 if (Scope) {
568 PushScope (Operand);
569 }
570
571 if (IsExpressionOpCode (Operand)) {
572 continue;
573 }
574
575 //
576 // Parse the Opcode
577 //
578 switch (Operand) {
579
580 case EFI_IFR_FORM_SET_OP:
581 //
582 // check the formset GUID
583 //
584 if (!CompareGuid ((EFI_GUID *)(VOID *)&FormSet->Guid, (EFI_GUID *)(VOID *)&((EFI_IFR_FORM_SET *) OpCodeData)->Guid)) {
585 return EFI_INVALID_PARAMETER;
586 }
587
588 CopyMem (&FormSet->FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID));
589 CopyMem (&FormSet->Help, &((EFI_IFR_FORM_SET *) OpCodeData)->Help, sizeof (EFI_STRING_ID));
590 break;
591
592 case EFI_IFR_FORM_OP:
593 //
594 // Create a new Form for this FormSet
595 //
596 CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM));
597 CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE;
598
599 InitializeListHead (&CurrentForm->StatementListHead);
600
601 CopyMem (&CurrentForm->FormId, &((EFI_IFR_FORM *) OpCodeData)->FormId, sizeof (UINT16));
602 CopyMem (&CurrentForm->FormTitle, &((EFI_IFR_FORM *) OpCodeData)->FormTitle, sizeof (EFI_STRING_ID));
603
604 //
605 // Insert into Form list of this FormSet
606 //
607 InsertTailList (&FormSet->FormListHead, &CurrentForm->Link);
608 break;
609
610 //
611 // Storage
612 //
613 case EFI_IFR_VARSTORE_OP:
614 //
615 // Create a buffer Storage for this FormSet
616 //
617 Storage = CreateStorage (FormSet);
618 Storage->Type = EFI_HII_VARSTORE_BUFFER;
619
620 CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
621 CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE *) OpCodeData)->Guid, sizeof (EFI_GUID));
622 CopyMem (&Storage->Size, &((EFI_IFR_VARSTORE *) OpCodeData)->Size, sizeof (UINT16));
623
624 AsciiString = (CHAR8 *) ((EFI_IFR_VARSTORE *) OpCodeData)->Name;
625 Storage->Name = AllocateZeroPool (AsciiStrSize (AsciiString) * 2);
626 ASSERT (Storage->Name != NULL);
627 for (Index = 0; AsciiString[Index] != 0; Index++) {
628 Storage->Name[Index] = (CHAR16) AsciiString[Index];
629 }
630
631 break;
632
633 case EFI_IFR_VARSTORE_NAME_VALUE_OP:
634 ASSERT (FALSE);
635
636 break;
637
638 case EFI_IFR_VARSTORE_EFI_OP:
639 //
640 // Create a EFI variable Storage for this FormSet
641 //
642 Storage = CreateStorage (FormSet);
643 Storage->Type = EFI_HII_VARSTORE_EFI_VARIABLE;
644
645 CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
646 CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Guid, sizeof (EFI_GUID));
647 CopyMem (&Storage->Attributes, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Attributes, sizeof (UINT32));
648 break;
649
650 //
651 // DefaultStore
652 //
653 case EFI_IFR_DEFAULTSTORE_OP:
654 DefaultStore = AllocateZeroPool (sizeof (FORMSET_DEFAULTSTORE));
655 DefaultStore->Signature = FORMSET_DEFAULTSTORE_SIGNATURE;
656
657 CopyMem (&DefaultStore->DefaultId, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultId, sizeof (UINT16));
658 CopyMem (&DefaultStore->DefaultName, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultName, sizeof (EFI_STRING_ID));
659
660 //
661 // Insert to DefaultStore list of this Formset
662 //
663 InsertTailList (&FormSet->DefaultStoreListHead, &DefaultStore->Link);
664 break;
665
666 //
667 // Statements
668 //
669 case EFI_IFR_SUBTITLE_OP:
670 CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
671 CurrentStatement->Flags = ((EFI_IFR_SUBTITLE *) OpCodeData)->Flags;
672
673 if (Scope) {
674 mInScopeSubtitle = TRUE;
675 }
676 break;
677
678 case EFI_IFR_TEXT_OP:
679 CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
680
681 CopyMem (&CurrentStatement->TextTwo, &((EFI_IFR_TEXT *) OpCodeData)->TextTwo, sizeof (EFI_STRING_ID));
682 break;
683
684 //
685 // Questions
686 //
687 case EFI_IFR_ACTION_OP:
688 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
689
690 if (OpCodeLength == sizeof (EFI_IFR_ACTION_1)) {
691 //
692 // No QuestionConfig present, so no configuration string will be processed
693 //
694 CurrentStatement->QuestionConfig = 0;
695 } else {
696 CopyMem (&CurrentStatement->QuestionConfig, &((EFI_IFR_ACTION *) OpCodeData)->QuestionConfig, sizeof (EFI_STRING_ID));
697 }
698 break;
699
700 case EFI_IFR_RESET_BUTTON_OP:
701 CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
702 CopyMem (&CurrentStatement->DefaultId, &((EFI_IFR_RESET_BUTTON *) OpCodeData)->DefaultId, sizeof (EFI_DEFAULT_ID));
703 break;
704
705 case EFI_IFR_REF_OP:
706 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
707
708 CopyMem (&CurrentStatement->RefFormId, &((EFI_IFR_REF *) OpCodeData)->FormId, sizeof (EFI_FORM_ID));
709 if (OpCodeLength >= sizeof (EFI_IFR_REF2)) {
710 CopyMem (&CurrentStatement->RefQuestionId, &((EFI_IFR_REF2 *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
711
712 if (OpCodeLength >= sizeof (EFI_IFR_REF3)) {
713 CopyMem (&CurrentStatement->RefFormSetId, &((EFI_IFR_REF3 *) OpCodeData)->FormSetId, sizeof (EFI_GUID));
714
715 if (OpCodeLength >= sizeof (EFI_IFR_REF4)) {
716 CopyMem (&CurrentStatement->RefDevicePath, &((EFI_IFR_REF4 *) OpCodeData)->DevicePath, sizeof (EFI_STRING_ID));
717 }
718 }
719 }
720 break;
721
722 case EFI_IFR_ONE_OF_OP:
723 case EFI_IFR_NUMERIC_OP:
724 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
725
726 CurrentStatement->Flags = ((EFI_IFR_ONE_OF *) OpCodeData)->Flags;
727 Value = &CurrentStatement->HiiValue;
728
729 switch (CurrentStatement->Flags & EFI_IFR_NUMERIC_SIZE) {
730 case EFI_IFR_NUMERIC_SIZE_1:
731 CurrentStatement->Minimum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MinValue;
732 CurrentStatement->Maximum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MaxValue;
733 CurrentStatement->Step = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.Step;
734 CurrentStatement->StorageWidth = sizeof (UINT8);
735 Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
736 break;
737
738 case EFI_IFR_NUMERIC_SIZE_2:
739 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MinValue, sizeof (UINT16));
740 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MaxValue, sizeof (UINT16));
741 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.Step, sizeof (UINT16));
742 CurrentStatement->StorageWidth = sizeof (UINT16);
743 Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
744 break;
745
746 case EFI_IFR_NUMERIC_SIZE_4:
747 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MinValue, sizeof (UINT32));
748 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MaxValue, sizeof (UINT32));
749 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.Step, sizeof (UINT32));
750 CurrentStatement->StorageWidth = sizeof (UINT32);
751 Value->Type = EFI_IFR_TYPE_NUM_SIZE_32;
752 break;
753
754 case EFI_IFR_NUMERIC_SIZE_8:
755 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MinValue, sizeof (UINT64));
756 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MaxValue, sizeof (UINT64));
757 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.Step, sizeof (UINT64));
758 CurrentStatement->StorageWidth = sizeof (UINT64);
759 Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
760 break;
761
762 default:
763 break;
764 }
765
766 if (Operand == EFI_IFR_ONE_OF_OP) {
767 OneOfOpcode = (EFI_IFR_ONE_OF *) OpCodeData;
768 OneOfType = (UINT8) (OneOfOpcode->Flags & EFI_IFR_NUMERIC_SIZE);
769 }
770 break;
771
772 case EFI_IFR_ORDERED_LIST_OP:
773 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
774
775 CurrentStatement->Flags = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->Flags;
776 CurrentStatement->MaxContainers = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->MaxContainers;
777 CurrentStatement->StorageWidth = (UINT16)(CurrentStatement->MaxContainers * sizeof (UINT8));
778
779 //
780 // No buffer type is defined in EFI_IFR_TYPE_VALUE, so a Configuration Driver
781 // has to use FormBrowser2.Callback() to retrieve the uncommited data for
782 // an interactive orderedlist (i.e. with EFI_IFR_FLAG_CALLBACK flag set).
783 //
784 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_OTHER;
785 CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
786
787 break;
788
789 case EFI_IFR_CHECKBOX_OP:
790 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
791
792 CurrentStatement->Flags = ((EFI_IFR_CHECKBOX *) OpCodeData)->Flags;
793 CurrentStatement->StorageWidth = sizeof (BOOLEAN);
794 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_BOOLEAN;
795
796 break;
797
798 case EFI_IFR_STRING_OP:
799 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
800
801 //
802 // MinSize is the minimum number of characters that can be accepted for this opcode,
803 // MaxSize is the maximum number of characters that can be accepted for this opcode.
804 // The characters are stored as Unicode, so the storage width should multiply 2.
805 //
806 CurrentStatement->Minimum = ((EFI_IFR_STRING *) OpCodeData)->MinSize;
807 CurrentStatement->Maximum = ((EFI_IFR_STRING *) OpCodeData)->MaxSize;
808 CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16));
809 CurrentStatement->Flags = ((EFI_IFR_STRING *) OpCodeData)->Flags;
810
811 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
812 CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
813
814 break;
815
816 case EFI_IFR_PASSWORD_OP:
817 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
818
819 //
820 // MinSize is the minimum number of characters that can be accepted for this opcode,
821 // MaxSize is the maximum number of characters that can be accepted for this opcode.
822 // The characters are stored as Unicode, so the storage width should multiply 2.
823 //
824 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_PASSWORD *) OpCodeData)->MinSize, sizeof (UINT16));
825 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_PASSWORD *) OpCodeData)->MaxSize, sizeof (UINT16));
826 CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16));
827
828 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
829 CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
830
831 break;
832
833 case EFI_IFR_DATE_OP:
834 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
835
836 CurrentStatement->Flags = ((EFI_IFR_DATE *) OpCodeData)->Flags;
837 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_DATE;
838
839 break;
840
841 case EFI_IFR_TIME_OP:
842 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
843
844 CurrentStatement->Flags = ((EFI_IFR_TIME *) OpCodeData)->Flags;
845 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_TIME;
846
847 break;
848
849 //
850 // Default
851 //
852 case EFI_IFR_DEFAULT_OP:
853 //
854 // EFI_IFR_DEFAULT appear in scope of a Question,
855 // It creates a default value for the current question.
856 // A Question may have more than one Default value which have different default types.
857 //
858 CurrentDefault = AllocateZeroPool (sizeof (QUESTION_DEFAULT));
859 CurrentDefault->Signature = QUESTION_DEFAULT_SIGNATURE;
860
861 CurrentDefault->Value.Type = ((EFI_IFR_DEFAULT *) OpCodeData)->Type;
862 CopyMem (&CurrentDefault->DefaultId, &((EFI_IFR_DEFAULT *) OpCodeData)->DefaultId, sizeof (UINT16));
863 CopyMem (&CurrentDefault->Value.Value, &((EFI_IFR_DEFAULT *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
864 ExtendValueToU64 (&CurrentDefault->Value);
865
866 //
867 // Insert to Default Value list of current Question
868 //
869 InsertTailList (&CurrentStatement->DefaultListHead, &CurrentDefault->Link);
870
871 break;
872
873 //
874 // Option
875 //
876 case EFI_IFR_ONE_OF_OPTION_OP:
877 //
878 // EFI_IFR_ONE_OF_OPTION appear in scope of a Question.
879 // It create a selection for use in current Question.
880 //
881 CurrentOption = AllocateZeroPool (sizeof (QUESTION_OPTION));
882 CurrentOption->Signature = QUESTION_OPTION_SIGNATURE;
883
884 CurrentOption->Flags = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Flags;
885 CurrentOption->Value.Type = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Type;
886 CopyMem (&CurrentOption->Text, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Option, sizeof (EFI_STRING_ID));
887 CopyMem (&CurrentOption->Value.Value, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
888 ExtendValueToU64 (&CurrentOption->Value);
889
890 //
891 // Insert to Option list of current Question
892 //
893 InsertTailList (&CurrentStatement->OptionListHead, &CurrentOption->Link);
894 break;
895
896 //
897 // Conditional
898 //
899 case EFI_IFR_NO_SUBMIT_IF_OP:
900 case EFI_IFR_INCONSISTENT_IF_OP:
901 break;
902
903 case EFI_IFR_SUPPRESS_IF_OP:
904 break;
905
906 case EFI_IFR_GRAY_OUT_IF_OP:
907 break;
908
909 case EFI_IFR_DISABLE_IF_OP:
910 ASSERT (FALSE);
911
912
913 //
914 // Expression
915 //
916 case EFI_IFR_VALUE_OP:
917 break;
918
919 case EFI_IFR_RULE_OP:
920 break;
921
922 //
923 // Image
924 //
925 case EFI_IFR_IMAGE_OP:
926 //
927 // Get ScopeOpcode from top of stack
928 //
929 PopScope (&ScopeOpCode);
930 PushScope (ScopeOpCode);
931
932 switch (ScopeOpCode) {
933 case EFI_IFR_FORM_SET_OP:
934 ImageId = &FormSet->ImageId;
935 break;
936
937 case EFI_IFR_FORM_OP:
938 ImageId = &CurrentForm->ImageId;
939 break;
940
941 case EFI_IFR_ONE_OF_OPTION_OP:
942 ImageId = &CurrentOption->ImageId;
943 break;
944
945 default:
946 ImageId = &CurrentStatement->ImageId;
947 break;
948 }
949
950 CopyMem (ImageId, &((EFI_IFR_IMAGE *) OpCodeData)->Id, sizeof (EFI_IMAGE_ID));
951 break;
952
953 //
954 // Refresh
955 //
956 case EFI_IFR_REFRESH_OP:
957 CurrentStatement->RefreshInterval = ((EFI_IFR_REFRESH *) OpCodeData)->RefreshInterval;
958 break;
959
960 //
961 // Vendor specific
962 //
963 case EFI_IFR_GUID_OP:
964 OptionMap = (EFI_IFR_GUID_OPTIONKEY *) OpCodeData;
965
966 if (CompareGuid (&mTianoHiiIfrGuid, (EFI_GUID *)(OpCodeData + sizeof (EFI_IFR_OP_HEADER)))) {
967 //
968 // Tiano specific GUIDed opcodes
969 //
970 switch (((EFI_IFR_GUID_LABEL *) OpCodeData)->ExtendOpCode) {
971 case EFI_IFR_EXTEND_OP_LABEL:
972 //
973 // just ignore label
974 //
975 break;
976
977
978 case EFI_IFR_EXTEND_OP_CLASS:
979 CopyMem (&FormSet->Class, &((EFI_IFR_GUID_CLASS *) OpCodeData)->Class, sizeof (UINT16));
980 break;
981
982 case EFI_IFR_EXTEND_OP_SUBCLASS:
983 CopyMem (&FormSet->SubClass, &((EFI_IFR_GUID_SUBCLASS *) OpCodeData)->SubClass, sizeof (UINT16));
984 break;
985
986 default:
987 break;
988 }
989 } else if (CompareGuid ((EFI_GUID *)(VOID *)&OptionMap->Guid, &mFrameworkHiiCompatibilityGuid)) {
990 if (OptionMap->ExtendOpCode == EFI_IFR_EXTEND_OP_OPTIONKEY) {
991 OneOfOptinMapEntryListHead = GetOneOfOptionMapEntryListHead (FormSet, OptionMap->QuestionId);
992 if (OneOfOptinMapEntryListHead == NULL) {
993 OneOfOptionMap = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP));
994 ASSERT (OneOfOptionMap != NULL);
995
996 OneOfOptionMap->Signature = ONE_OF_OPTION_MAP_SIGNATURE;
997 OneOfOptionMap->QuestionId = OptionMap->QuestionId;
998
999 //
1000 // Make sure OneOfType is initialized.
1001 //
1002 ASSERT (OneOfType != (UINT8) -1);
1003 OneOfOptionMap->ValueType = OneOfType;
1004 InitializeListHead (&OneOfOptionMap->OneOfOptionMapEntryListHead);
1005 OneOfOptinMapEntryListHead = &OneOfOptionMap->OneOfOptionMapEntryListHead;
1006 InsertTailList (&FormSet->OneOfOptionMapListHead, &OneOfOptionMap->Link);
1007 }
1008 OneOfOptionMapEntry = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP_ENTRY));
1009 ASSERT (OneOfOptionMapEntry != NULL);
1010
1011 OneOfOptionMapEntry->Signature = ONE_OF_OPTION_MAP_ENTRY_SIGNATURE;
1012 OneOfOptionMapEntry->FwKey = OptionMap->KeyValue;
1013 CopyMem (&OneOfOptionMapEntry->Value, &OptionMap->OptionValue, sizeof (EFI_IFR_TYPE_VALUE));
1014
1015 InsertTailList (OneOfOptinMapEntryListHead, &OneOfOptionMapEntry->Link);
1016 }
1017 }
1018 break;
1019
1020 //
1021 // Scope End
1022 //
1023 case EFI_IFR_END_OP:
1024 Status = PopScope (&ScopeOpCode);
1025 if (EFI_ERROR (Status)) {
1026 ResetScopeStack ();
1027 return Status;
1028 }
1029
1030 switch (ScopeOpCode) {
1031 case EFI_IFR_FORM_SET_OP:
1032 //
1033 // End of FormSet, update FormSet IFR binary length
1034 // to stop parsing substantial OpCodes
1035 //
1036 FormSet->IfrBinaryLength = OpCodeOffset;
1037 break;
1038
1039 case EFI_IFR_FORM_OP:
1040 //
1041 // End of Form
1042 //
1043 CurrentForm = NULL;
1044 break;
1045
1046 case EFI_IFR_ONE_OF_OPTION_OP:
1047 //
1048 // End of Option
1049 //
1050 CurrentOption = NULL;
1051 break;
1052
1053 case EFI_IFR_SUBTITLE_OP:
1054 mInScopeSubtitle = FALSE;
1055 break;
1056
1057 case EFI_IFR_NO_SUBMIT_IF_OP:
1058 case EFI_IFR_INCONSISTENT_IF_OP:
1059 //
1060 // Ignore end of EFI_IFR_NO_SUBMIT_IF and EFI_IFR_INCONSISTENT_IF
1061 //
1062 break;
1063
1064 case EFI_IFR_GRAY_OUT_IF_OP:
1065 mInScopeGrayOut = FALSE;
1066 break;
1067
1068 default:
1069 if (IsExpressionOpCode (ScopeOpCode)) {
1070 }
1071 break;
1072 }
1073 break;
1074
1075 default:
1076 break;
1077 }
1078 }
1079
1080 return EFI_SUCCESS;
1081 }
1082
1083
1084
1085
EFI Development Kit II mirror for PVE