Port DriverSample.inf, HiiDatabase.inf and SetupBrowser.inf
[mirror_edk2.git] / IntelFrameworkModulePkg / Universal / SetupBrowserDxe / Setup.c
1 /**@file
2 Entry and initialization module for the browser.
3
4 Copyright (c) 2006 - 2007 Intel Corporation. <BR>
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 //
16 // Include common header file for this module.
17 //
18 #include "CommonHeader.h"
19
20 #include "Setup.h"
21 #include "Ui.h"
22
23 FUNCTIION_KEY_SETTING gFunctionKeySettingTable[] = {
24 //
25 // Boot Manager
26 //
27 {
28 {
29 0x847bc3fe,
30 0xb974,
31 0x446d,
32 {
33 0x94,
34 0x49,
35 0x5a,
36 0xd5,
37 0x41,
38 0x2e,
39 0x99,
40 0x3b
41 }
42 },
43 NONE_FUNCTION_KEY_SETTING
44 },
45 //
46 // Device Manager
47 //
48 {
49 {
50 0x3ebfa8e6,
51 0x511d,
52 0x4b5b,
53 {
54 0xa9,
55 0x5f,
56 0xfb,
57 0x38,
58 0x26,
59 0xf,
60 0x1c,
61 0x27
62 }
63 },
64 NONE_FUNCTION_KEY_SETTING
65 },
66 //
67 // BMM Formset.
68 //
69 {
70 {
71 0x642237c7,
72 0x35d4,
73 0x472d,
74 {
75 0x83,
76 0x65,
77 0x12,
78 0xe0,
79 0xcc,
80 0xf2,
81 0x7a,
82 0x22
83 }
84 },
85 NONE_FUNCTION_KEY_SETTING
86 },
87 //
88 // BMM File Explorer Formset.
89 //
90 {
91 {
92 0x1f2d63e1,
93 0xfebd,
94 0x4dc7,
95 {
96 0x9c,
97 0xc5,
98 0xba,
99 0x2b,
100 0x1c,
101 0xef,
102 0x9c,
103 0x5b
104 }
105 },
106 NONE_FUNCTION_KEY_SETTING
107 },
108 };
109
110 STATIC
111 EFI_STATUS
112 InitializeBinaryStructures (
113 IN EFI_HII_HANDLE *Handle,
114 IN BOOLEAN UseDatabase,
115 IN EFI_IFR_PACKET *Packet,
116 IN UINT8 *NvMapOverride,
117 IN UINTN NumberOfIfrImages,
118 EFI_FILE_FORM_TAGS **FileFormTagsHead
119 );
120
121 STATIC
122 EFI_STATUS
123 InitializeTagStructures (
124 IN EFI_IFR_BINARY *BinaryData,
125 OUT EFI_FILE_FORM_TAGS *FileFormTags
126 );
127
128 STATIC
129 UI_MENU_OPTION *
130 DisplayHomePage (
131 IN UINTN NumberOfIfrImages,
132 IN EFI_FILE_FORM_TAGS *FileFormTagsHead,
133 IN UINT8 *CallbackData
134 );
135
136 STATIC
137 EFI_STATUS
138 GetIfrBinaryData (
139 IN EFI_HII_PROTOCOL *Hii,
140 IN EFI_HII_HANDLE HiiHandle,
141 IN EFI_IFR_PACKET *Packet,
142 IN EFI_IFR_BINARY *BinaryData
143 );
144
145 STATIC
146 EFI_STATUS
147 InstallPrint (
148 VOID
149 );
150
151 STATIC
152 EFI_STATUS
153 EFIAPI
154 SendForm (
155 IN EFI_FORM_BROWSER_PROTOCOL * This,
156 IN BOOLEAN UseDatabase,
157 IN EFI_HII_HANDLE * Handle,
158 IN UINTN HandleCount,
159 IN EFI_IFR_PACKET * Packet,
160 IN EFI_HANDLE CallbackHandle,
161 IN UINT8 *NvMapOverride,
162 IN EFI_SCREEN_DESCRIPTOR *ScreenDimensions, OPTIONAL
163 OUT BOOLEAN *ResetRequired OPTIONAL
164 )
165 /*++
166
167 Routine Description:
168
169 This is the routine which an external caller uses to direct the browser
170 where to obtain it's information.
171
172 Arguments:
173
174 UseDatabase - If set to TRUE, then all information is retrieved from the HII database handle specified
175 If set to FALSE, then the passed in Packet and CallbackHandle is used and Handle is ignored
176
177 Handle - A pointer to an array of Handles. If HandleCount > 1 we display a list of the formsets for the handles specified
178
179 HandleCount - The number of Handles specified in Handle.
180
181 Packet - Valid only if UseDatabase is FALSE. Packet defines the pages being passed into
182 the browser. This is composed of IFR data as well as String information.
183
184 CallbackHandle - The handle which contains the calling driver's EFI_FORM_CALLBACK_PROTOCOL interface.
185
186 ScreenDimenions - This allows the browser to be called so that it occupies a portion of the physical screen instead of
187 dynamically determining the screen dimensions.
188
189 NvMapOverride - This buffer is used only when there is no NV variable to define the current settings and the caller
190 needs to provide to the browser the current settings for the "fake" NV variable. If used, no saving
191 of an NV variable will be possible. This parameter is also ignored if HandleCount > 1.
192
193 Returns:
194
195 --*/
196 {
197 EFI_FORM_CALLBACK_PROTOCOL *FormCallback;
198 EFI_FILE_FORM_TAGS *FileFormTagsHead;
199 UI_MENU_OPTION *Selection;
200 UI_MENU_OPTION *AltSelection;
201 EFI_STATUS Status;
202 BOOLEAN Callback;
203 VOID *CallbackData;
204 EFI_HII_HANDLE BackupHandle;
205
206 ZeroMem (&gScreenDimensions, sizeof (EFI_SCREEN_DESCRIPTOR));
207
208 gPreviousValue = AllocatePool (0x1000);
209 CallbackData = AllocatePool (0x10000);
210 ASSERT (gPreviousValue != NULL);
211 ASSERT (CallbackData != NULL);
212
213 do {
214 //
215 // Seed the dimensions in the global
216 //
217 gST->ConOut->QueryMode (
218 gST->ConOut,
219 gST->ConOut->Mode->Mode,
220 &gScreenDimensions.RightColumn,
221 &gScreenDimensions.BottomRow
222 );
223
224 if (ScreenDimensions != NULL) {
225 //
226 // Check local dimension vs. global dimension.
227 //
228 if ((gScreenDimensions.RightColumn < ScreenDimensions->RightColumn) ||
229 (gScreenDimensions.BottomRow < ScreenDimensions->BottomRow)
230 ) {
231 return EFI_INVALID_PARAMETER;
232 } else {
233 //
234 // Local dimension validation.
235 //
236 if ((ScreenDimensions->RightColumn > ScreenDimensions->LeftColumn) &&
237 (ScreenDimensions->BottomRow > ScreenDimensions->TopRow) &&
238 ((ScreenDimensions->RightColumn - ScreenDimensions->LeftColumn) > 2) &&
239 (
240 (ScreenDimensions->BottomRow - ScreenDimensions->TopRow) > STATUS_BAR_HEIGHT +
241 SCROLL_ARROW_HEIGHT *
242 2 +
243 FRONT_PAGE_HEADER_HEIGHT +
244 FOOTER_HEIGHT +
245 1
246 )
247 ) {
248 CopyMem (&gScreenDimensions, ScreenDimensions, sizeof (EFI_SCREEN_DESCRIPTOR));
249 } else {
250 return EFI_INVALID_PARAMETER;
251 }
252 }
253 }
254
255 gOptionBlockWidth = (CHAR16) ((gScreenDimensions.RightColumn - gScreenDimensions.LeftColumn) / 3);
256 gHelpBlockWidth = gOptionBlockWidth;
257 gPromptBlockWidth = gOptionBlockWidth;
258
259 //
260 // Initialize the strings for the browser, upon exit of the browser, the strings will be freed
261 //
262 InitializeBrowserStrings ();
263
264 gFunctionKeySetting = DEFAULT_FUNCTION_KEY_SETTING;
265 gClassOfVfr = EFI_SETUP_APPLICATION_SUBCLASS;
266 gResetRequired = FALSE;
267 gExitRequired = FALSE;
268 gSaveRequired = FALSE;
269 gNvUpdateRequired = FALSE;
270 gActiveIfr = 0;
271 gConsistencyId = 0;
272 gPriorMenuEntry = 0;
273 BackupHandle = *Handle;
274 gMenuRefreshHead = NULL;
275 ASSERT (CallbackData);
276 ZeroMem (CallbackData, 0x10000);
277
278 //
279 // We can recurse through this and might need to re-allocate this particular buffer
280 //
281 if (gPreviousValue == NULL) {
282 gPreviousValue = AllocatePool (0x1000);
283 ASSERT (gPreviousValue != NULL);
284 }
285
286 Callback = FALSE;
287 FormCallback = NULL;
288
289 if (CallbackHandle != NULL) {
290 //
291 // Retrieve the Callback protocol interface
292 //
293 Status = gBS->HandleProtocol (
294 CallbackHandle,
295 &gEfiFormCallbackProtocolGuid,
296 (VOID **) &FormCallback
297 );
298
299 if (EFI_ERROR (Status)) {
300 FreePool (CallbackData);
301 return Status;;
302 }
303
304 Callback = TRUE;
305 }
306 //
307 // Initializes all the internal state structures for all IFR images in system
308 //
309 Status = InitializeBinaryStructures (Handle, UseDatabase, Packet, NvMapOverride, HandleCount, &FileFormTagsHead);
310
311 if (EFI_ERROR (Status)) {
312 FreePool (CallbackData);
313 return Status;
314 }
315 //
316 // Beginning of the Presentation of the Data
317 //
318 if (UseDatabase && (HandleCount > 1)) {
319 Selection = DisplayHomePage (HandleCount, FileFormTagsHead, CallbackData);
320 } else {
321 //
322 // If passing something specific, we know there is only one Ifr
323 //
324 Selection = AllocateZeroPool (sizeof (UI_MENU_OPTION));
325 ASSERT (Selection != NULL);
326 Selection->IfrNumber = 0;
327 Selection->Handle = Handle[0];
328 UiInitMenu ();
329 }
330
331 UiInitMenuList ();
332
333 if (UseDatabase && (HandleCount > 1)) {
334 if (Selection == NULL) {
335 FreePool (CallbackData);
336 return EFI_SUCCESS;
337 }
338 }
339 //
340 // Launch the setup browser with the user's selection information
341 //
342 AltSelection = SetupBrowser (Selection, Callback, FileFormTagsHead, CallbackData);
343
344 //
345 // If the caller cares about Reset status, we can return to the caller if something happened that required a reset
346 //
347 if (ResetRequired != NULL) {
348 *ResetRequired = gResetRequired;
349 }
350
351 if (Callback && (AltSelection != NULL)) {
352 if ((FormCallback != NULL) && (FormCallback->Callback != NULL)) {
353 Status = FormCallback->Callback (
354 FormCallback,
355 AltSelection->ThisTag->Key,
356 CallbackData,
357 (EFI_HII_CALLBACK_PACKET **) &Packet
358 );
359 }
360 }
361
362 *Handle = BackupHandle;
363
364 if (EFI_ERROR (Status)) {
365 FreePool (CallbackData);
366 return Status;
367 }
368
369 if (Callback && (AltSelection == NULL)) {
370 FreePool (CallbackData);
371 return Status;
372 }
373
374 if (UseDatabase && (HandleCount > 1)) {
375 } else {
376
377 if (gBinaryDataHead->UnRegisterOnExit) {
378 Hii->RemovePack (Hii, Handle[0]);
379 }
380
381 if (Callback &&
382 ((AltSelection->ThisTag->SubClass == EFI_FRONT_PAGE_SUBCLASS) ||
383 (AltSelection->ThisTag->SubClass == EFI_SINGLE_USE_SUBCLASS))) {
384 //
385 // If this is the FrontPage, return after every selection
386 //
387 FreePool (Selection);
388 UiFreeMenu ();
389
390 //
391 // Clean up the allocated data buffers
392 //
393 FreeData (FileFormTagsHead, NULL, NULL);
394
395 gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
396 gST->ConOut->ClearScreen (gST->ConOut);
397
398 FreePool (CallbackData);
399 return EFI_SUCCESS;
400 }
401
402 FreePool (Selection);
403 UiFreeMenu ();
404
405 //
406 // Clean up the allocated data buffers
407 //
408 FreeData (FileFormTagsHead, NULL, NULL);
409
410 gST->ConOut->ClearScreen (gST->ConOut);
411
412 if (!Callback) {
413 FreePool (CallbackData);
414 return EFI_SUCCESS;
415 }
416 }
417
418 } while (!EFI_ERROR (Status));
419
420 FreePool (CallbackData);
421 return Status;
422 }
423
424 EFI_STATUS
425 EFIAPI
426 InitializeSetup (
427 IN EFI_HANDLE ImageHandle,
428 IN EFI_SYSTEM_TABLE *SystemTable
429 )
430 /*++
431
432 Routine Description:
433 Initialize Setup
434
435 Arguments:
436 (Standard EFI Image entry - EFI_IMAGE_ENTRY_POINT)
437
438 Returns:
439 EFI_SUCCESS - Setup loaded.
440 other - Setup Error
441
442 --*/
443 {
444 EFI_STATUS Status;
445 EFI_FORM_CONFIGURATION_DATA *FormData;
446 EFI_FORM_BROWSER_PROTOCOL *FormBrowser;
447 EFI_HANDLE Handle;
448 EFI_HII_PACKAGES *PackageList;
449
450 //
451 // There will be only one FormConfig in the system
452 // If there is another out there, someone is trying to install us
453 // again. Fail that scenario.
454 //
455 Status = gBS->LocateProtocol (
456 &gEfiFormBrowserProtocolGuid,
457 NULL,
458 (VOID **) &FormBrowser
459 );
460
461 gFirstIn = TRUE;
462
463 //
464 // If there was no error, assume there is an installation and fail to load
465 //
466 if (!EFI_ERROR (Status)) {
467 return EFI_DEVICE_ERROR;
468 }
469
470 FormData = AllocatePool (sizeof (EFI_FORM_CONFIGURATION_DATA));
471
472 if (FormData == NULL) {
473 return EFI_OUT_OF_RESOURCES;
474 }
475 //
476 // Fill in HII data
477 //
478 FormData->Signature = EFI_FORM_DATA_SIGNATURE;
479 FormData->FormConfig.SendForm = SendForm;
480 FormData->FormConfig.CreatePopUp = CreateDialog;
481
482 //
483 // There should only be one HII image
484 //
485 Status = gBS->LocateProtocol (
486 &gEfiHiiProtocolGuid,
487 NULL,
488 (VOID **) &FormData->Hii
489 );
490
491 ASSERT_EFI_ERROR (Status);
492
493 Hii = FormData->Hii;
494
495 PackageList = PreparePackages (1, &gEfiFormBrowserProtocolGuid, SetupBrowserStrings);
496
497 Status = Hii->NewPack (Hii, PackageList, &gHiiHandle);
498
499 FreePool (PackageList);
500
501 //
502 // Install protocol interface
503 //
504 Handle = NULL;
505 Status = gBS->InstallProtocolInterface (
506 &Handle,
507 &gEfiFormBrowserProtocolGuid,
508 EFI_NATIVE_INTERFACE,
509 &FormData->FormConfig
510 );
511
512 ASSERT_EFI_ERROR (Status);
513
514 BannerData = AllocateZeroPool (sizeof (BANNER_DATA));
515 ASSERT (BannerData != NULL);
516
517 Status = InstallPrint ();
518 return Status;
519 }
520
521 VOID
522 GetQuestionHeader (
523 IN EFI_TAG *Tag,
524 IN UINT8 *RawFormSet,
525 IN UINT16 Index,
526 IN EFI_FILE_FORM_TAGS *FileFormTags,
527 IN UINT16 CurrentVariable
528 )
529 /*++
530
531 Routine Description:
532 Initialize question tag's members.
533
534 Arguments:
535 Tag - Pointer of the current EFI_TAG structure.
536 RawFormSet - Pointer of the formset raw data.
537 Index - Offset of the current opcode in the Ifr raw data.
538 FileFormTags - Pointer of current EFI_FILE_FORM_TAGS structure.
539 CurrentVariable - Current variable number.
540
541 Returns:
542 None.
543 --*/
544 {
545 EFI_VARIABLE_DEFINITION *VariableDefinition;
546
547 Tag->NumberOfLines = 1;
548 Tag->VariableNumber = CurrentVariable;
549 CopyMem (&Tag->Id, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->QuestionId, sizeof (UINT16));
550 CopyMem (&Tag->StorageStart, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->QuestionId, sizeof (UINT16));
551 CopyMem (&Tag->StorageWidth, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Width, sizeof (UINT8));
552 CopyMem (&Tag->Text, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Prompt, sizeof (UINT16));
553 CopyMem (&Tag->Help, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Help, sizeof (UINT16));
554
555 VariableDefinition = FileFormTags->VariableDefinitions;
556
557 for (; VariableDefinition != NULL; VariableDefinition = VariableDefinition->Next) {
558 //
559 // Have we found the correct variable for the request?
560 //
561 if (CurrentVariable == VariableDefinition->VariableId) {
562 if (VariableDefinition->VariableSize < (UINTN) (Tag->StorageStart + Tag->StorageWidth)) {
563 VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableFakeSize + Tag->StorageWidth);
564 }
565
566 if (VariableDefinition->NvRamMap != NULL) {
567 //
568 // If it is an 8bit or 16bit width, then move it to Tag->Value, otherwise
569 // we will never be looking for the data in Tag->Value (e.g. strings, password, etc)
570 //
571 if (Tag->StorageWidth == (UINT16) 1) {
572 CopyMem (&Tag->Value, &VariableDefinition->NvRamMap[Tag->StorageStart], sizeof (UINT16));
573 }
574
575 if (Tag->StorageWidth == (UINT16) 2) {
576 Index = (UINT16)
577 (
578 VariableDefinition->NvRamMap[Tag->StorageStart] +
579 (VariableDefinition->NvRamMap[Tag->StorageStart + 1] * 0x100)
580 );
581 CopyMem (&Tag->Value, &Index, sizeof (UINT16));
582 }
583 } else {
584 Index = 0;
585 CopyMem (&Tag->Value, &Index, sizeof (UINT16));
586 }
587 break;
588 }
589 }
590 }
591
592 VOID
593 GetNumericHeader (
594 IN EFI_TAG *Tag,
595 IN UINT8 *RawFormSet,
596 IN UINT16 Index,
597 IN UINT16 NumberOfLines,
598 IN EFI_FILE_FORM_TAGS *FileFormTags,
599 IN UINT16 CurrentVariable
600 )
601 /*++
602
603 Routine Description:
604 Initialize numeric tag's members.
605
606 Arguments:
607 Tag - Pointer of the current EFI_TAG structure.
608 RawFormSet - Pointer of the formset raw data.
609 Index - Offset of the current opcode in the Ifr raw data.
610 NumberOfLines - Number of lines this opcode occupied.
611 FileFormTags - Pointer of current EFI_FILE_FORM_TAGS structure.
612 CurrentVariable - Current variable number.
613
614 Returns:
615 None.
616 --*/
617 {
618 EFI_VARIABLE_DEFINITION *VariableDefinition;
619
620 Tag->NumberOfLines = NumberOfLines;
621 Tag->VariableNumber = CurrentVariable;
622 CopyMem (&Tag->Id, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->QuestionId, sizeof (UINT16));
623 CopyMem (&Tag->StorageStart, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->QuestionId, sizeof (UINT16));
624 CopyMem (&Tag->StorageWidth, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Width, sizeof (UINT8));
625 CopyMem (&Tag->Text, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Prompt, sizeof (UINT16));
626 CopyMem (&Tag->Help, &((EFI_IFR_ONE_OF *) &RawFormSet[Index])->Help, sizeof (UINT16));
627 CopyMem (&Tag->Minimum, &((EFI_IFR_NUMERIC *) &RawFormSet[Index])->Minimum, sizeof (UINT16));
628 CopyMem (&Tag->Maximum, &((EFI_IFR_NUMERIC *) &RawFormSet[Index])->Maximum, sizeof (UINT16));
629 CopyMem (&Tag->Step, &((EFI_IFR_NUMERIC *) &RawFormSet[Index])->Step, sizeof (UINT16));
630 CopyMem (&Tag->Default, &((EFI_IFR_NUMERIC *) &RawFormSet[Index])->Default, sizeof (UINT16));
631 Tag->ResetRequired = (BOOLEAN) (((EFI_IFR_NUMERIC *) &RawFormSet[Index])->Flags & EFI_IFR_FLAG_RESET_REQUIRED);
632
633 VariableDefinition = FileFormTags->VariableDefinitions;
634
635 for (; VariableDefinition != NULL; VariableDefinition = VariableDefinition->Next) {
636 //
637 // Have we found the correct variable for the request?
638 //
639 if (CurrentVariable == VariableDefinition->VariableId) {
640 if (VariableDefinition->VariableSize <= (UINTN) (Tag->StorageStart + Tag->StorageWidth)) {
641 if (Tag->StorageWidth == 0) {
642 VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableFakeSize + 2);
643 } else {
644 VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableFakeSize + Tag->StorageWidth);
645 }
646 }
647
648 if (VariableDefinition->NvRamMap != NULL) {
649 //
650 // If it is an 8bit or 16bit width, then move it to Tag->Value, otherwise
651 // we will never be looking for the data in Tag->Value (e.g. strings, password, etc)
652 //
653 if (Tag->StorageWidth == (UINT16) 1) {
654 CopyMem (&Tag->Value, &VariableDefinition->NvRamMap[Tag->StorageStart], sizeof (UINT16));
655 }
656
657 if (Tag->StorageWidth == (UINT16) 2) {
658 Index = (UINT16)
659 (
660 VariableDefinition->NvRamMap[Tag->StorageStart] +
661 (VariableDefinition->NvRamMap[Tag->StorageStart + 1] * 0x100)
662 );
663 CopyMem (&Tag->Value, &Index, sizeof (UINT16));
664 }
665 } else {
666 CopyMem (&Tag->Value, &Tag->Default, sizeof (UINT16));
667 }
668 break;
669 }
670 }
671 }
672
673 VOID
674 GetTagCount (
675 IN UINT8 *RawFormSet,
676 IN OUT UINT16 *NumberOfTags
677 )
678 {
679 UINT16 Index;
680
681 //
682 // Assume on entry we are pointing to an OpCode - reasonably this should
683 // be a FormOp since the purpose is to count the tags in a particular Form.
684 //
685 for (Index = 0; RawFormSet[Index] != EFI_IFR_END_FORM_OP;) {
686 //
687 // If we encounter the end of a form set, bail out
688 //
689 if (RawFormSet[Index] == EFI_IFR_END_FORM_SET_OP) {
690 break;
691 }
692 //
693 // We treat date/time internally as three op-codes
694 //
695 if (RawFormSet[Index] == EFI_IFR_DATE_OP || RawFormSet[Index] == EFI_IFR_TIME_OP) {
696 *NumberOfTags = (UINT16) (*NumberOfTags + 3);
697 } else {
698 //
699 // Assume that we could have no more tags than op-codes
700 //
701 (*NumberOfTags)++;
702 }
703
704 Index = (UINT16) (Index + RawFormSet[Index + 1]);
705 }
706 //
707 // Increase the tag count by one so it is inclusive of the end_form_op
708 //
709 (*NumberOfTags)++;
710 }
711
712 STATIC
713 VOID
714 AddNextInconsistentTag (
715 IN OUT EFI_INCONSISTENCY_DATA **InconsistentTagsPtr
716 )
717 /*++
718
719 Routine Description:
720 Initialize the next inconsistent tag data and add it to the inconsistent tag list.
721
722 Arguments:
723 InconsistentTagsPtr - Pointer of the inconsistent tag's pointer.
724
725 Returns:
726 None.
727
728 --*/
729 {
730 EFI_INCONSISTENCY_DATA *PreviousInconsistentTags;
731 EFI_INCONSISTENCY_DATA *InconsistentTags;
732
733 InconsistentTags = *InconsistentTagsPtr;
734 //
735 // We just hit the end of an inconsistent expression. Let's allocate the ->Next structure
736 //
737 InconsistentTags->Next = AllocatePool (sizeof (EFI_INCONSISTENCY_DATA));
738 ASSERT (InconsistentTags->Next != NULL);
739
740 //
741 // Preserve current Tag entry
742 //
743 PreviousInconsistentTags = InconsistentTags;
744
745 InconsistentTags = InconsistentTags->Next;
746
747 //
748 // This will zero on the entry including the ->Next so I don't have to do it
749 //
750 ZeroMem (InconsistentTags, sizeof (EFI_INCONSISTENCY_DATA));
751
752 //
753 // Point our Previous field to the previous entry
754 //
755 InconsistentTags->Previous = PreviousInconsistentTags;
756
757 *InconsistentTagsPtr = InconsistentTags;
758
759 return ;
760 }
761
762 STATIC
763 EFI_STATUS
764 InitializeTagStructures (
765 IN EFI_IFR_BINARY *BinaryData,
766 OUT EFI_FILE_FORM_TAGS *FileFormTags
767 )
768 {
769 EFI_STATUS Status;
770 UINT8 *RawFormSet;
771 UINT16 Index;
772 UINT16 QuestionIndex;
773 UINT16 NumberOfTags;
774 INT16 CurrTag;
775 UINT8 TagLength;
776 EFI_FORM_TAGS *FormTags;
777 EFI_FORM_TAGS *SavedFormTags;
778 EFI_INCONSISTENCY_DATA *InconsistentTags;
779 EFI_VARIABLE_DEFINITION *VariableDefinitions;
780 UINTN Count;
781 UINT16 Class;
782 UINT16 SubClass;
783 UINT16 TempValue;
784 UINT16 CurrentVariable;
785 UINT16 CurrentVariable2;
786
787 //
788 // Initialize some Index variable and Status
789 //
790 Count = 0;
791 Class = 0;
792 SubClass = 0;
793 CurrentVariable = 0;
794 CurrentVariable2 = 0;
795 QuestionIndex = 0;
796 NumberOfTags = 1;
797 Status = EFI_SUCCESS;
798 FormTags = &FileFormTags->FormTags;
799 FormTags->Next = NULL;
800 if (FileFormTags->InconsistentTags == NULL) {
801 InconsistentTags = NULL;
802 } else {
803 InconsistentTags = FileFormTags->InconsistentTags;
804 }
805
806 if (FileFormTags->VariableDefinitions == NULL) {
807 VariableDefinitions = NULL;
808 } else {
809 VariableDefinitions = FileFormTags->VariableDefinitions;
810 }
811 //
812 // RawFormSet now points to the beginning of the forms portion of
813 // the specific IFR Binary.
814 //
815 RawFormSet = (UINT8 *) BinaryData->FormBinary;
816
817 //
818 // Determine the number of tags for the first form
819 //
820 GetTagCount (&RawFormSet[0], &NumberOfTags);
821
822 SavedFormTags = FormTags;
823
824 if (FormTags->Tags != NULL) {
825 do {
826 //
827 // Advance FormTags to the last entry
828 //
829 for (; FormTags->Next != NULL; FormTags = FormTags->Next)
830 ;
831
832 //
833 // Walk through each of the tags and free the IntList allocation
834 //
835 for (Index = 0; Index < NumberOfTags; Index++) {
836 if (FormTags->Tags[Index].IntList != NULL) {
837 FreePool (FormTags->Tags[Index].IntList);
838 }
839 }
840
841 FreePool (FormTags->Tags);
842
843 ASSERT (FormTags->Next == NULL);
844
845 FormTags->Tags = NULL;
846
847 FormTags = SavedFormTags;
848
849 } while (FormTags->Next != NULL);
850 }
851
852 Index = 0;
853
854 //
855 // Test for an allocated buffer. If already allocated this is due to having called this routine
856 // once for sizing of the NV storage. We then loaded the NV variable and can correctly initialize
857 // the tag structure with current values from the NV
858 //
859 if (FormTags->Tags == NULL) {
860 //
861 // Allocate memory for our tags on the first form
862 //
863 FormTags->Tags = AllocateZeroPool (NumberOfTags * sizeof (EFI_TAG));
864 ASSERT (FormTags->Tags);
865 }
866 //
867 // Test for an allocated buffer. If already allocated this is due to having called this routine
868 // once for sizing of the NV storage. We then loaded the NV variable and can correctly initialize
869 // the tag structure with current values from the NV
870 //
871 if (InconsistentTags == NULL) {
872 //
873 // We just hit the end of an inconsistent expression. Let's allocate the ->Next structure
874 //
875 InconsistentTags = AllocateZeroPool (sizeof (EFI_INCONSISTENCY_DATA));
876 ASSERT (InconsistentTags != NULL);
877
878 FileFormTags->InconsistentTags = InconsistentTags;
879 }
880
881 ZeroMem (FormTags->Tags, NumberOfTags * sizeof (EFI_TAG));
882
883 for (CurrTag = 0; RawFormSet[Index] != EFI_IFR_END_FORM_SET_OP; CurrTag++) {
884 //
885 // Operand = IFR OpCode
886 //
887 FormTags->Tags[CurrTag].Operand = RawFormSet[Index];
888
889 //
890 // Assume for now 0 lines occupied by this OpCode
891 //
892 FormTags->Tags[CurrTag].NumberOfLines = 0;
893
894 FormTags->Tags[CurrTag].Class = Class;
895 FormTags->Tags[CurrTag].SubClass = SubClass;
896
897 //
898 // Determine the length of the Tag so we can later skip to the next tag in the form
899 //
900 TagLength = RawFormSet[Index + 1];
901 //
902 // get the length
903 //
904 // Operate on the Found OpCode
905 //
906 switch (RawFormSet[Index]) {
907
908 case EFI_IFR_FORM_OP:
909 //
910 // If there was no variable op-code defined, create a dummy entry for one
911 //
912 if (FileFormTags->VariableDefinitions == NULL) {
913 FileFormTags->VariableDefinitions = AllocateZeroPool (sizeof (EFI_VARIABLE_DEFINITION));
914 ASSERT (FileFormTags->VariableDefinitions != NULL);
915 IfrToFormTag (
916 RawFormSet[Index],
917 &FormTags->Tags[CurrTag],
918 (VOID *) &RawFormSet[Index],
919 FileFormTags->VariableDefinitions
920 );
921 } else {
922 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
923 }
924 break;
925
926 case EFI_IFR_SUBTITLE_OP:
927 case EFI_IFR_TEXT_OP:
928 case EFI_IFR_REF_OP:
929 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
930 break;
931
932 case EFI_IFR_VARSTORE_OP:
933 if (FileFormTags->VariableDefinitions == NULL) {
934 VariableDefinitions = AllocateZeroPool (sizeof (EFI_VARIABLE_DEFINITION));
935 ASSERT (VariableDefinitions != NULL);
936 FileFormTags->VariableDefinitions = VariableDefinitions;
937 }
938
939 IfrToFormTag (
940 RawFormSet[Index],
941 &FormTags->Tags[CurrTag],
942 (VOID *) &RawFormSet[Index],
943 FileFormTags->VariableDefinitions
944 );
945 break;
946
947 case EFI_IFR_VARSTORE_SELECT_OP:
948 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
949 CopyMem (&CurrentVariable, &((EFI_IFR_VARSTORE_SELECT *) &RawFormSet[Index])->VarId, sizeof (UINT16));
950 CurrentVariable2 = CurrentVariable;
951 break;
952
953 case EFI_IFR_VARSTORE_SELECT_PAIR_OP:
954 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
955 CopyMem(&CurrentVariable, &((EFI_IFR_VARSTORE_SELECT_PAIR *)&RawFormSet[Index])->VarId, sizeof (UINT16));
956 CopyMem (
957 &CurrentVariable2,
958 &((EFI_IFR_VARSTORE_SELECT_PAIR *) &RawFormSet[Index])->SecondaryVarId,
959 sizeof (UINT16)
960 );
961 break;
962
963 case EFI_IFR_END_FORM_OP:
964 //
965 // Test for an allocated buffer. If already allocated this is due to having called this routine
966 // once for sizing of the NV storage. We then loaded the NV variable and can correctly initialize
967 // the tag structure with current values from the NV
968 //
969 if (FormTags->Next == NULL) {
970 //
971 // We just hit the end of a form. Let's allocate the ->Next structure
972 //
973 FormTags->Next = AllocatePool (sizeof (EFI_FORM_TAGS));
974 ASSERT (FormTags->Next);
975 }
976
977 FormTags = FormTags->Next;
978 ZeroMem (FormTags, sizeof (EFI_FORM_TAGS));
979
980 //
981 // Reset the tag count to one
982 //
983 NumberOfTags = 1;
984
985 //
986 // Reset the CurrTag value (it will be incremented, after this case statement
987 // so set to a negative one so that we get the desired effect.) Fish can beat me later.
988 //
989 CurrTag = -1;
990
991 //
992 // Determine the number of tags after this form. If this is the last
993 // form, then we will count the endformset and preserve that information
994 // in the tag structure.
995 //
996 GetTagCount (&RawFormSet[Index + TagLength], &NumberOfTags);
997
998 //
999 // Allocate memory for our tags
1000 //
1001 FormTags->Tags = AllocateZeroPool (NumberOfTags * sizeof (EFI_TAG));
1002 ASSERT (FormTags->Tags);
1003 break;
1004
1005 //
1006 // Two types of tags constitute the One Of question: a one-of header and
1007 // several one-of options.
1008 //
1009 case EFI_IFR_ONE_OF_OP:
1010 case EFI_IFR_ORDERED_LIST_OP:
1011 GetQuestionHeader (&FormTags->Tags[CurrTag], RawFormSet, Index, FileFormTags, CurrentVariable);
1012
1013 //
1014 // Store away the CurrTag since what follows will be the answer that we
1015 // need to place into the appropriate location in the tag array
1016 //
1017 //
1018 // record for setting default later
1019 //
1020 QuestionIndex = (UINT16) CurrTag;
1021 break;
1022
1023 case EFI_IFR_ONE_OF_OPTION_OP:
1024 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1025 FormTags->Tags[QuestionIndex].Flags = ((EFI_IFR_ONE_OF_OPTION *) &RawFormSet[Index])->Flags;
1026 CopyMem (
1027 &FormTags->Tags[QuestionIndex].Key,
1028 &((EFI_IFR_ONE_OF_OPTION *) &RawFormSet[Index])->Key,
1029 sizeof (UINT16)
1030 );
1031 FormTags->Tags[QuestionIndex].ResetRequired = (BOOLEAN) (FormTags->Tags[QuestionIndex].Flags & EFI_IFR_FLAG_RESET_REQUIRED);
1032 break;
1033
1034 case EFI_IFR_CHECKBOX_OP:
1035 GetQuestionHeader (&FormTags->Tags[CurrTag], RawFormSet, Index, FileFormTags, CurrentVariable);
1036 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1037 break;
1038
1039 case EFI_IFR_NUMERIC_OP:
1040 GetNumericHeader (&FormTags->Tags[CurrTag], RawFormSet, Index, (UINT16) 1, FileFormTags, CurrentVariable);
1041 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1042 break;
1043
1044 case EFI_IFR_DATE_OP:
1045 //
1046 // Date elements come in as a Year, Month, Day. We need to process them as a country-based
1047 // Order. It is much easier to do it here than anywhere else.
1048 //
1049 // For US standards - we want Month/Day/Year, thus we advance "Index" +1, +2, +0 while CurrTag is +0, +1, +2
1050 //
1051 GetNumericHeader (
1052 &FormTags->Tags[CurrTag],
1053 RawFormSet,
1054 (UINT16) (Index + TagLength),
1055 (UINT16) 0,
1056 FileFormTags,
1057 CurrentVariable
1058 );
1059
1060 //
1061 // The current language selected + the Date operand
1062 //
1063 FormTags->Tags[CurrTag + 1].Operand = RawFormSet[Index];
1064 GetNumericHeader (
1065 &FormTags->Tags[CurrTag + 1],
1066 RawFormSet,
1067 (UINT16) (Index + TagLength + RawFormSet[Index + TagLength + 1]),
1068 (UINT16) 0,
1069 FileFormTags,
1070 CurrentVariable
1071 );
1072
1073 //
1074 // The current language selected + the Date operand
1075 //
1076 FormTags->Tags[CurrTag + 2].Operand = RawFormSet[Index];
1077 GetNumericHeader (&FormTags->Tags[CurrTag + 2], RawFormSet, Index, (UINT16) 1, FileFormTags, CurrentVariable);
1078
1079 CurrTag = (INT16) (CurrTag + 2);
1080
1081 Index = (UINT16) (Index + TagLength);
1082 //
1083 // get the length
1084 //
1085 TagLength = RawFormSet[Index + 1];
1086 Index = (UINT16) (Index + TagLength);
1087 //
1088 // get the length
1089 //
1090 TagLength = RawFormSet[Index + 1];
1091 break;
1092
1093 case EFI_IFR_TIME_OP:
1094 GetNumericHeader (&FormTags->Tags[CurrTag], RawFormSet, Index, (UINT16) 0, FileFormTags, CurrentVariable);
1095
1096 if (Count == 2) {
1097 //
1098 // Override the GetQuestionHeader information - date/time are treated very differently
1099 //
1100 FormTags->Tags[CurrTag].NumberOfLines = 1;
1101 Count = 0;
1102 } else {
1103 //
1104 // The premise is that every date/time op-code have 3 elements, the first 2 have 0 lines
1105 // associated with them, and the third has 1 line to allow to space beyond the choice.
1106 //
1107 Count++;
1108 }
1109 break;
1110
1111 case EFI_IFR_PASSWORD_OP:
1112 case EFI_IFR_STRING_OP:
1113 GetQuestionHeader (&FormTags->Tags[CurrTag], RawFormSet, Index, FileFormTags, CurrentVariable);
1114 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1115 break;
1116
1117 case EFI_IFR_SUPPRESS_IF_OP:
1118 case EFI_IFR_GRAYOUT_IF_OP:
1119 InconsistentTags->Operand = ((EFI_IFR_INCONSISTENT *) &RawFormSet[Index])->Header.OpCode;
1120 gConsistencyId++;
1121
1122 //
1123 // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1124 // Unfortunately 0 is a valid offset value for a QuestionId
1125 //
1126 InconsistentTags->QuestionId1 = INVALID_OFFSET_VALUE;
1127 InconsistentTags->QuestionId2 = INVALID_OFFSET_VALUE;
1128
1129 //
1130 // Test for an allocated buffer. If already allocated this is due to having called this routine
1131 // once for sizing of the NV storage. We then loaded the NV variable and can correctly initialize
1132 // the tag structure with current values from the NV
1133 //
1134 if (InconsistentTags->Next == NULL) {
1135 AddNextInconsistentTag (&InconsistentTags);
1136 break;
1137 }
1138
1139 InconsistentTags = InconsistentTags->Next;
1140 break;
1141
1142 case EFI_IFR_FORM_SET_OP:
1143 CopyMem (
1144 &FormTags->Tags[CurrTag].GuidValue,
1145 &((EFI_IFR_FORM_SET *) &RawFormSet[Index])->Guid,
1146 sizeof (EFI_GUID)
1147 );
1148 CopyMem (
1149 &FormTags->Tags[CurrTag].CallbackHandle,
1150 &((EFI_IFR_FORM_SET *) &RawFormSet[Index])->CallbackHandle,
1151 sizeof (EFI_PHYSICAL_ADDRESS)
1152 );
1153 CopyMem (&FormTags->Tags[CurrTag].Class, &((EFI_IFR_FORM_SET *) &RawFormSet[Index])->Class, sizeof (UINT8));
1154 CopyMem (
1155 &FormTags->Tags[CurrTag].SubClass,
1156 &((EFI_IFR_FORM_SET *) &RawFormSet[Index])->SubClass,
1157 sizeof (UINT8)
1158 );
1159 CopyMem (
1160 &FormTags->Tags[CurrTag].NvDataSize,
1161 &((EFI_IFR_FORM_SET *) &RawFormSet[Index])->NvDataSize,
1162 sizeof (UINT16)
1163 );
1164 Class = ((EFI_IFR_FORM_SET *) &RawFormSet[Index])->Class;
1165 SubClass = ((EFI_IFR_FORM_SET *) &RawFormSet[Index])->SubClass;
1166 //
1167 // If the formset has a size value, that means someone must be using this, so create a variable
1168 // We also shall reserve the formid of 0 for this specific purpose.
1169 //
1170 if ((FileFormTags->VariableDefinitions == NULL) && (FormTags->Tags[CurrTag].NvDataSize > 0)) {
1171 FileFormTags->VariableDefinitions = AllocateZeroPool (sizeof (EFI_VARIABLE_DEFINITION));
1172 ASSERT (FileFormTags->VariableDefinitions != NULL);
1173 IfrToFormTag (
1174 RawFormSet[Index],
1175 &FormTags->Tags[CurrTag],
1176 (VOID *) &RawFormSet[Index],
1177 FileFormTags->VariableDefinitions
1178 );
1179 } else {
1180 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1181 }
1182 break;
1183
1184 case EFI_IFR_BANNER_OP:
1185 if (gClassOfVfr == EFI_FRONT_PAGE_SUBCLASS) {
1186 TempValue = 0;
1187 CopyMem (&TempValue, &((EFI_IFR_BANNER *) &RawFormSet[Index])->Alignment, sizeof (UINT8));
1188 //
1189 // If this is the special timeout value, we will dynamically figure out where to put it
1190 // Also the least significant byte refers to the TimeOut desired.
1191 //
1192 if (TempValue == EFI_IFR_BANNER_TIMEOUT) {
1193 CopyMem (&FrontPageTimeOutTitle, &((EFI_IFR_BANNER *) &RawFormSet[Index])->Title, sizeof (UINT16));
1194 if (FrontPageTimeOutValue != (INT16) -1) {
1195 CopyMem (&FrontPageTimeOutValue, &((EFI_IFR_BANNER *) &RawFormSet[Index])->LineNumber, sizeof (UINT16));
1196 }
1197 break;
1198 }
1199
1200 CopyMem (
1201 &BannerData->Banner[((EFI_IFR_BANNER *) &RawFormSet[Index])->LineNumber][
1202 ((EFI_IFR_BANNER *) &RawFormSet[Index])->Alignment],
1203 &((EFI_IFR_BANNER *) &RawFormSet[Index])->Title,
1204 sizeof (STRING_REF)
1205 );
1206 }
1207 break;
1208
1209 case EFI_IFR_INCONSISTENT_IF_OP:
1210 CopyMem (
1211 &FormTags->Tags[CurrTag].Text,
1212 &((EFI_IFR_INCONSISTENT *) &RawFormSet[Index])->Popup,
1213 sizeof (UINT16)
1214 );
1215 gConsistencyId++;
1216
1217 InconsistentTags->Operand = ((EFI_IFR_INCONSISTENT *) &RawFormSet[Index])->Header.OpCode;
1218 CopyMem (&InconsistentTags->Popup, &((EFI_IFR_INCONSISTENT *) &RawFormSet[Index])->Popup, sizeof (UINT16));
1219
1220 //
1221 // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1222 // Unfortunately 0 is a valid offset value for a QuestionId
1223 //
1224 InconsistentTags->QuestionId1 = INVALID_OFFSET_VALUE;
1225 InconsistentTags->QuestionId2 = INVALID_OFFSET_VALUE;
1226
1227 InconsistentTags->VariableNumber = CurrentVariable;
1228
1229 //
1230 // Test for an allocated buffer. If already allocated this is due to having called this routine
1231 // once for sizing of the NV storage. We then loaded the NV variable and can correctly initialize
1232 // the tag structure with current values from the NV
1233 //
1234 if (InconsistentTags->Next == NULL) {
1235 AddNextInconsistentTag (&InconsistentTags);
1236 break;
1237 }
1238
1239 InconsistentTags = InconsistentTags->Next;
1240 break;
1241
1242 case EFI_IFR_EQ_ID_VAL_OP:
1243 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1244
1245 InconsistentTags->Operand = ((EFI_IFR_EQ_ID_VAL *) &RawFormSet[Index])->Header.OpCode;
1246 CopyMem (&InconsistentTags->Value, &((EFI_IFR_EQ_ID_VAL *) &RawFormSet[Index])->Value, sizeof (UINT16));
1247 CopyMem (
1248 &InconsistentTags->QuestionId1,
1249 &((EFI_IFR_EQ_ID_VAL *) &RawFormSet[Index])->QuestionId,
1250 sizeof (UINT16)
1251 );
1252
1253 //
1254 // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1255 // Unfortunately 0 is a valid offset value for a QuestionId
1256 //
1257 InconsistentTags->Width = FormTags->Tags[CurrTag].StorageWidth;
1258 InconsistentTags->QuestionId2 = INVALID_OFFSET_VALUE;
1259 InconsistentTags->ConsistencyId = gConsistencyId;
1260 FormTags->Tags[CurrTag].ConsistencyId = gConsistencyId;
1261
1262 InconsistentTags->VariableNumber = CurrentVariable;
1263
1264 //
1265 // Test for an allocated buffer. If already allocated this is due to having called this routine
1266 // once for sizing of the NV storage. We then loaded the NV variable and can correctly initialize
1267 // the tag structure with current values from the NV
1268 //
1269 if (InconsistentTags->Next == NULL) {
1270 AddNextInconsistentTag (&InconsistentTags);
1271 break;
1272 }
1273
1274 InconsistentTags = InconsistentTags->Next;
1275 break;
1276
1277 case EFI_IFR_EQ_VAR_VAL_OP:
1278 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1279
1280 InconsistentTags->Operand = ((EFI_IFR_EQ_VAR_VAL *) &RawFormSet[Index])->Header.OpCode;
1281 CopyMem (&InconsistentTags->Value, &((EFI_IFR_EQ_VAR_VAL *) &RawFormSet[Index])->Value, sizeof (UINT16));
1282 CopyMem (
1283 &InconsistentTags->QuestionId1,
1284 &((EFI_IFR_EQ_VAR_VAL *) &RawFormSet[Index])->VariableId,
1285 sizeof (UINT16)
1286 );
1287
1288 //
1289 // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1290 // Unfortunately 0 is a valid offset value for a QuestionId
1291 //
1292 InconsistentTags->QuestionId2 = INVALID_OFFSET_VALUE;
1293 InconsistentTags->ConsistencyId = gConsistencyId;
1294 FormTags->Tags[CurrTag].ConsistencyId = gConsistencyId;
1295
1296 InconsistentTags->VariableNumber = CurrentVariable;
1297
1298 //
1299 // Test for an allocated buffer. If already allocated this is due to having called this routine
1300 // once for sizing of the NV storage. We then loaded the NV variable and can correctly initialize
1301 // the tag structure with current values from the NV
1302 //
1303 if (InconsistentTags->Next == NULL) {
1304 AddNextInconsistentTag (&InconsistentTags);
1305 break;
1306 }
1307
1308 InconsistentTags = InconsistentTags->Next;
1309 break;
1310
1311 case EFI_IFR_EQ_ID_ID_OP:
1312 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1313
1314 InconsistentTags->Operand = ((EFI_IFR_EQ_ID_ID *) &RawFormSet[Index])->Header.OpCode;
1315 CopyMem (
1316 &InconsistentTags->QuestionId1,
1317 &((EFI_IFR_EQ_ID_ID *) &RawFormSet[Index])->QuestionId1,
1318 sizeof (UINT16)
1319 );
1320 CopyMem (
1321 &InconsistentTags->QuestionId2,
1322 &((EFI_IFR_EQ_ID_ID *) &RawFormSet[Index])->QuestionId2,
1323 sizeof (UINT16)
1324 );
1325
1326 InconsistentTags->Width = FormTags->Tags[CurrTag].StorageWidth;
1327 InconsistentTags->ConsistencyId = gConsistencyId;
1328 FormTags->Tags[CurrTag].ConsistencyId = gConsistencyId;
1329
1330 InconsistentTags->VariableNumber = CurrentVariable;
1331 InconsistentTags->VariableNumber2 = CurrentVariable2;
1332
1333 //
1334 // Test for an allocated buffer. If already allocated this is due to having called this routine
1335 // once for sizing of the NV storage. We then loaded the NV variable and can correctly initialize
1336 // the tag structure with current values from the NV
1337 //
1338 if (InconsistentTags->Next == NULL) {
1339 AddNextInconsistentTag (&InconsistentTags);
1340 break;
1341 }
1342
1343 InconsistentTags = InconsistentTags->Next;
1344 break;
1345
1346 case EFI_IFR_AND_OP:
1347 case EFI_IFR_OR_OP:
1348 case EFI_IFR_NOT_OP:
1349 case EFI_IFR_GT_OP:
1350 case EFI_IFR_GE_OP:
1351 case EFI_IFR_TRUE_OP:
1352 case EFI_IFR_FALSE_OP:
1353 InconsistentTags->Operand = ((EFI_IFR_NOT *) &RawFormSet[Index])->Header.OpCode;
1354
1355 //
1356 // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1357 // Unfortunately 0 is a valid offset value for a QuestionId
1358 //
1359
1360 //
1361 // Reserve INVALID_OFFSET_VALUE - 1 for TRUE or FALSE because they are inconsistency tags also, but
1362 // have no coresponding id. The examination of id is needed by evaluating boolean expression.
1363 //
1364 if (RawFormSet[Index] == EFI_IFR_TRUE_OP ||
1365 RawFormSet[Index] == EFI_IFR_FALSE_OP) {
1366 InconsistentTags->QuestionId1 = INVALID_OFFSET_VALUE - 1;
1367 } else {
1368 InconsistentTags->QuestionId1 = INVALID_OFFSET_VALUE;
1369 }
1370 InconsistentTags->QuestionId2 = INVALID_OFFSET_VALUE;
1371 InconsistentTags->ConsistencyId = gConsistencyId;
1372 FormTags->Tags[CurrTag].ConsistencyId = gConsistencyId;
1373
1374 //
1375 // Test for an allocated buffer. If already allocated this is due to having called this routine
1376 // once for sizing of the NV storage. We then loaded the NV variable and can correctly initialize
1377 // the tag structure with current values from the NV
1378 //
1379 if (InconsistentTags->Next == NULL) {
1380 AddNextInconsistentTag (&InconsistentTags);
1381 break;
1382 }
1383
1384 InconsistentTags = InconsistentTags->Next;
1385 break;
1386
1387 case EFI_IFR_EQ_ID_LIST_OP:
1388 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1389
1390 InconsistentTags->Operand = ((EFI_IFR_EQ_ID_LIST *) &RawFormSet[Index])->Header.OpCode;
1391 CopyMem (
1392 &InconsistentTags->QuestionId1,
1393 &((EFI_IFR_EQ_ID_LIST *) &RawFormSet[Index])->QuestionId,
1394 sizeof (UINT16)
1395 );
1396 CopyMem (
1397 &InconsistentTags->ListLength,
1398 &((EFI_IFR_EQ_ID_LIST *) &RawFormSet[Index])->ListLength,
1399 sizeof (UINT16)
1400 );
1401 InconsistentTags->ValueList = FormTags->Tags[CurrTag].IntList;
1402
1403 //
1404 // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1405 // Unfortunately 0 is a valid offset value for a QuestionId
1406 //
1407 InconsistentTags->Width = FormTags->Tags[CurrTag].StorageWidth;
1408 InconsistentTags->QuestionId2 = INVALID_OFFSET_VALUE;
1409 InconsistentTags->ConsistencyId = gConsistencyId;
1410 FormTags->Tags[CurrTag].ConsistencyId = gConsistencyId;
1411
1412 //
1413 // Test for an allocated buffer. If already allocated this is due to having called this routine
1414 // once for sizing of the NV storage. We then loaded the NV variable and can correctly initialize
1415 // the tag structure with current values from the NV
1416 //
1417 if (InconsistentTags->Next == NULL) {
1418 AddNextInconsistentTag (&InconsistentTags);
1419 break;
1420 }
1421
1422 InconsistentTags = InconsistentTags->Next;
1423 break;
1424
1425 case EFI_IFR_END_IF_OP:
1426 InconsistentTags->Operand = ((EFI_IFR_END_EXPR *) &RawFormSet[Index])->Header.OpCode;
1427
1428 //
1429 // Since this op-code doesn't use the next field(s), initialize them with something invalid.
1430 // Unfortunately 0 is a valid offset value for a QuestionId
1431 //
1432 InconsistentTags->QuestionId1 = INVALID_OFFSET_VALUE;
1433 InconsistentTags->QuestionId2 = INVALID_OFFSET_VALUE;
1434
1435 //
1436 // Test for an allocated buffer. If already allocated this is due to having called this routine
1437 // once for sizing of the NV storage. We then loaded the NV variable and can correctly initialize
1438 // the tag structure with current values from the NV
1439 //
1440 if (InconsistentTags->Next == NULL) {
1441 AddNextInconsistentTag (&InconsistentTags);
1442 break;
1443 }
1444
1445 InconsistentTags = InconsistentTags->Next;
1446 break;
1447
1448 case EFI_IFR_END_ONE_OF_OP:
1449 break;
1450
1451 default:
1452 break;
1453 }
1454 //
1455 // End of switch
1456 //
1457 // Per spec., we ignore ops that we don't know how to deal with. Skip to next tag
1458 //
1459 Index = (UINT16) (Index + TagLength);
1460 }
1461 //
1462 // End of Index
1463 //
1464 // When we eventually exit, make sure we mark the last tag with an op-code
1465 //
1466 FormTags->Tags[CurrTag].Operand = RawFormSet[Index];
1467
1468 IfrToFormTag (RawFormSet[Index], &FormTags->Tags[CurrTag], (VOID *) &RawFormSet[Index], NULL);
1469
1470 //
1471 // Place this as an end of the database marker
1472 //
1473 InconsistentTags->Operand = 0xFF;
1474
1475 //
1476 // This is the Head of the linked list of pages. Each page is an array of tags
1477 //
1478 FormTags = &FileFormTags->FormTags;
1479 InconsistentTags = FileFormTags->InconsistentTags;
1480
1481 for (; InconsistentTags->Operand != 0xFF;) {
1482 if (InconsistentTags->QuestionId1 != INVALID_OFFSET_VALUE) {
1483 //
1484 // Search the tags for the tag which corresponds to this ID
1485 //
1486 for (CurrTag = 0; FormTags->Tags[0].Operand != EFI_IFR_END_FORM_SET_OP; CurrTag++) {
1487 //
1488 // If we hit the end of a form, go to the next set of Tags.
1489 // Remember - EndFormSet op-codes sit on their own page after an end form.
1490 //
1491 if (FormTags->Tags[CurrTag].Operand == EFI_IFR_END_FORM_OP) {
1492 //
1493 // Reset the CurrTag value (it will be incremented, after this case statement
1494 // so set to a negative one so that we get the desired effect.) Fish can beat me later.
1495 //
1496 CurrTag = -1;
1497 FormTags = FormTags->Next;
1498 continue;
1499 }
1500
1501 if (FormTags->Tags[CurrTag].Id == InconsistentTags->QuestionId1) {
1502 FormTags->Tags[CurrTag].Consistency++;
1503 }
1504 }
1505 }
1506
1507 FormTags = &FileFormTags->FormTags;
1508
1509 if (InconsistentTags->QuestionId2 != INVALID_OFFSET_VALUE) {
1510 //
1511 // Search the tags for the tag which corresponds to this ID
1512 //
1513 for (CurrTag = 0; FormTags->Tags[CurrTag].Operand != EFI_IFR_END_FORM_SET_OP; CurrTag++) {
1514 //
1515 // If we hit the end of a form, go to the next set of Tags.
1516 // Remember - EndFormSet op-codes sit on their own page after an end form.
1517 //
1518 if (FormTags->Tags[CurrTag].Operand == EFI_IFR_END_FORM_OP) {
1519 //
1520 // Reset the CurrTag value (it will be incremented, after this case statement
1521 // so set to a negative one so that we get the desired effect.) Fish can beat me later.
1522 //
1523 CurrTag = -1;
1524 FormTags = FormTags->Next;
1525 continue;
1526 }
1527
1528 if (FormTags->Tags[CurrTag].Id == InconsistentTags->QuestionId2) {
1529 FormTags->Tags[CurrTag].Consistency++;
1530 }
1531 }
1532 }
1533
1534 InconsistentTags = InconsistentTags->Next;
1535 }
1536
1537 return Status;
1538 }
1539
1540 VOID
1541 InitPage (
1542 VOID
1543 )
1544 {
1545 CHAR16 *HomePageString;
1546 CHAR16 *HomeEscapeString;
1547
1548 //
1549 // Displays the Header and Footer borders
1550 //
1551 DisplayPageFrame ();
1552
1553 HomePageString = GetToken (STRING_TOKEN (HOME_PAGE_TITLE), gHiiHandle);
1554 HomeEscapeString = GetToken (STRING_TOKEN (HOME_ESCAPE_STRING), gHiiHandle);
1555
1556 gST->ConOut->SetAttribute (gST->ConOut, EFI_YELLOW | EFI_BRIGHT);
1557 //
1558 // PrintStringAt ((gScreenDimensions.RightColumn - GetStringWidth(HomePageString)/2)/2, 1, HomePageString);
1559 //
1560 PrintStringAt (
1561 (gScreenDimensions.RightColumn + gScreenDimensions.LeftColumn - GetStringWidth (HomePageString) / 2) / 2,
1562 1,
1563 HomePageString
1564 );
1565 PrintAt (
1566 gScreenDimensions.LeftColumn + 2,
1567 gScreenDimensions.BottomRow - 3,
1568 (CHAR16 *) L"%c%c%s",
1569 ARROW_UP,
1570 ARROW_DOWN,
1571 gMoveHighlight
1572 );
1573 PrintAt (
1574 gScreenDimensions.RightColumn - (GetStringWidth (HomeEscapeString) / 2) - 2,
1575 gScreenDimensions.BottomRow - 3,
1576 (CHAR16 *) L" %s",
1577 HomeEscapeString
1578 );
1579 gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
1580 FreePool (HomeEscapeString);
1581 FreePool (HomePageString);
1582
1583 return ;
1584 }
1585
1586 CHAR16 *
1587 GetToken (
1588 IN STRING_REF Token,
1589 IN EFI_HII_HANDLE HiiHandle
1590 )
1591 /*++
1592
1593 Routine Description:
1594
1595 Get the string based on the TokenID and HII Handle.
1596
1597 Arguments:
1598
1599 Token - The Token ID.
1600 HiiHandle - Handle of Ifr to be fetched.
1601
1602 Returns:
1603
1604 The output string.
1605
1606 --*/
1607 {
1608 CHAR16 *Buffer;
1609 UINTN BufferLength;
1610 EFI_STATUS Status;
1611
1612 //
1613 // Set default string size assumption at no more than 256 bytes
1614 //
1615 BufferLength = 0x100;
1616
1617 Buffer = AllocateZeroPool (BufferLength);
1618 ASSERT (Buffer != NULL);
1619
1620 Status = Hii->GetString (Hii, HiiHandle, Token, TRUE, NULL, &BufferLength, Buffer);
1621
1622 if (EFI_ERROR (Status)) {
1623 if (Status == EFI_BUFFER_TOO_SMALL) {
1624 //
1625 // Free the old pool
1626 //
1627 FreePool (Buffer);
1628
1629 //
1630 // Allocate new pool with correct value
1631 //
1632 Buffer = AllocatePool (BufferLength);
1633 ASSERT (Buffer != NULL);
1634
1635 Status = Hii->GetString (Hii, HiiHandle, Token, TRUE, NULL, &BufferLength, Buffer);
1636
1637 if (!EFI_ERROR (Status)) {
1638 return Buffer;
1639 }
1640 }
1641
1642 ASSERT_EFI_ERROR (Status);
1643 }
1644
1645 return Buffer;
1646 }
1647
1648 STATIC
1649 EFI_STATUS
1650 PopulateHomePage (
1651 IN UINTN NumberOfIfrImages,
1652 IN EFI_FILE_FORM_TAGS *FileFormTagsHead
1653 )
1654 {
1655 EFI_STATUS Status;
1656 UINTN Index;
1657 EFI_IFR_BINARY *IfrBinary;
1658 CHAR16 *StringPtr;
1659 EFI_FILE_FORM_TAGS *FileFormTags;
1660 EFI_FORM_TAGS LocalTags;
1661
1662 FileFormTags = FileFormTagsHead;
1663
1664 UiInitMenu ();
1665
1666 Status = EFI_SUCCESS;
1667
1668 //
1669 // If there are no images
1670 //
1671 if (NumberOfIfrImages == 0) {
1672 Status = EFI_NO_MEDIA;
1673 return Status;
1674 }
1675 //
1676 // IfrBinary points to the beginning of the Binary data linked-list
1677 //
1678 IfrBinary = gBinaryDataHead;
1679
1680 //
1681 // Print the entries which were in the default language.
1682 //
1683 for (Index = 0; Index < NumberOfIfrImages; Index++) {
1684 LocalTags = FileFormTags->FormTags;
1685
1686 //
1687 // Populate the Menu
1688 //
1689 StringPtr = GetToken (IfrBinary->TitleToken, IfrBinary->Handle);
1690
1691 //
1692 // If the default language doesn't exist, don't add a menu option yet
1693 //
1694 if (StringPtr[0] != CHAR_NULL) {
1695 //
1696 // We are NOT!! removing this StringPtr buffer via FreePool since it is being used in the menuoptions, we will do
1697 // it in UiFreeMenu.
1698 //
1699 UiAddMenuOption (StringPtr, IfrBinary->Handle, LocalTags.Tags, IfrBinary->FormBinary, Index);
1700 }
1701 //
1702 // Advance to the next HII handle
1703 //
1704 IfrBinary = IfrBinary->Next;
1705 FileFormTags = FileFormTags->NextFile;
1706 }
1707
1708 return Status;
1709 }
1710
1711 STATIC
1712 UI_MENU_OPTION *
1713 DisplayHomePage (
1714 IN UINTN NumberOfIfrImages,
1715 IN EFI_FILE_FORM_TAGS *FileFormTagsHead,
1716 IN UINT8 *CallbackData
1717 )
1718 {
1719 EFI_STATUS Status;
1720 UI_MENU_OPTION *Selection;
1721
1722 //
1723 // This prints the basic home page template which the user sees
1724 //
1725 InitPage ();
1726
1727 Status = PopulateHomePage (NumberOfIfrImages, FileFormTagsHead);
1728
1729 if (EFI_ERROR (Status)) {
1730 Selection = NULL;
1731 return Selection;
1732 }
1733
1734 Selection = UiDisplayMenu (FALSE, FileFormTagsHead, (EFI_IFR_DATA_ARRAY *) CallbackData);
1735
1736 return Selection;
1737 }
1738
1739 STATIC
1740 EFI_STATUS
1741 InitializeBinaryStructures (
1742 IN EFI_HII_HANDLE *Handle,
1743 IN BOOLEAN UseDatabase,
1744 IN EFI_IFR_PACKET *Packet,
1745 IN UINT8 *NvMapOverride,
1746 IN UINTN NumberOfIfrImages,
1747 OUT EFI_FILE_FORM_TAGS **FileFormTagsHead
1748 )
1749 {
1750 UINTN HandleIndex;
1751 EFI_STATUS Status;
1752 EFI_IFR_BINARY *BinaryData;
1753 EFI_FILE_FORM_TAGS *FileFormTags;
1754 UINTN SizeOfNvStore;
1755 EFI_FORM_CALLBACK_PROTOCOL *FormCallback;
1756 EFI_VARIABLE_DEFINITION *VariableDefinition;
1757 EFI_VARIABLE_DEFINITION *OverrideDefinition;
1758 VOID *NvMap;
1759 UINTN NvMapSize;
1760 EFI_HII_VARIABLE_PACK_LIST *NvMapListHead;
1761 EFI_HII_VARIABLE_PACK_LIST *NvMapListNode;
1762
1763 //
1764 // Initialize some variables to avoid warnings
1765 //
1766 BinaryData = NULL;
1767 *FileFormTagsHead = NULL;
1768 FileFormTags = NULL;
1769 gBinaryDataHead = NULL;
1770 Status = EFI_SUCCESS;
1771 FormCallback = NULL;
1772 NvMap = NULL;
1773 NvMapSize = 0;
1774
1775 if (NumberOfIfrImages > 1) {
1776 NvMapOverride = NULL;
1777 }
1778
1779 for (HandleIndex = 0; HandleIndex < NumberOfIfrImages; HandleIndex += 1) {
1780 //
1781 // If the buffers are uninitialized, allocate them, otherwise work on the ->Next members
1782 //
1783 if ((BinaryData == NULL) || (FileFormTags == NULL)) {
1784 //
1785 // Allocate memory for our Binary Data
1786 //
1787 BinaryData = AllocateZeroPool (sizeof (EFI_IFR_BINARY));
1788 ASSERT (BinaryData);
1789
1790 //
1791 // Preserve the Head of what will be a linked-list.
1792 //
1793 gBinaryDataHead = BinaryData;
1794 gBinaryDataHead->Next = NULL;
1795
1796 if (UseDatabase) {
1797 Status = GetIfrBinaryData (Hii, Handle[HandleIndex], NULL, BinaryData);
1798 } else {
1799 Status = GetIfrBinaryData (Hii, Handle[HandleIndex], Packet, BinaryData);
1800 }
1801 //
1802 // Allocate memory for our File Form Tags
1803 //
1804 FileFormTags = AllocateZeroPool (sizeof (EFI_FILE_FORM_TAGS));
1805 ASSERT (FileFormTags);
1806
1807 //
1808 // Preserve the Head of what will be a linked-list.
1809 //
1810 *FileFormTagsHead = FileFormTags;
1811 (*FileFormTagsHead)->NextFile = NULL;
1812
1813 } else {
1814 //
1815 // Allocate memory for our Binary Data linked-list
1816 // Each handle represents a Binary and we will store that data away.
1817 //
1818 BinaryData->Next = AllocateZeroPool (sizeof (EFI_IFR_BINARY));
1819 ASSERT (BinaryData->Next);
1820
1821 BinaryData = BinaryData->Next;
1822 BinaryData->Next = NULL;
1823
1824 if (UseDatabase) {
1825 Status = GetIfrBinaryData (Hii, Handle[HandleIndex], NULL, BinaryData);
1826 } else {
1827 Status = GetIfrBinaryData (Hii, Handle[HandleIndex], Packet, BinaryData);
1828 }
1829
1830 if (EFI_ERROR (Status)) {
1831 return EFI_DEVICE_ERROR;
1832 }
1833 //
1834 // Allocate memory for our FileFormTags linked-list
1835 // Each allocation reserves handle represents a Binary and we will store that data away.
1836 //
1837 FileFormTags->NextFile = AllocateZeroPool (sizeof (EFI_FILE_FORM_TAGS));
1838 ASSERT (FileFormTags->NextFile);
1839
1840 FileFormTags = FileFormTags->NextFile;
1841 }
1842 //
1843 // endif
1844 //
1845 // Tag Structure Initialization
1846 //
1847 Status = InitializeTagStructures (BinaryData, FileFormTags);
1848
1849 VariableDefinition = FileFormTags->VariableDefinitions;
1850
1851 //
1852 // Allocate memory for our NVRAM Maps for all of our variables
1853 //
1854 for (; VariableDefinition != NULL; VariableDefinition = VariableDefinition->Next) {
1855 //
1856 // Pad the fake variable size accordingly - this value should reflect the size of information that is not accounted by
1857 // the mainstream NVRAM variable such as DATE/TIME information that the browser needs to track but is saved to an RTC
1858 //
1859 VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableSize + VariableDefinition->VariableFakeSize);
1860
1861 //
1862 // In the case where a file has no "real" NV data, we should pad the buffer accordingly
1863 //
1864 if (VariableDefinition->VariableSize == 0) {
1865 if (VariableDefinition->VariableFakeSize != 0) {
1866 VariableDefinition->NvRamMap = AllocateZeroPool (VariableDefinition->VariableFakeSize);
1867 ASSERT (VariableDefinition->NvRamMap != NULL);
1868 }
1869 } else {
1870 VariableDefinition->NvRamMap = AllocateZeroPool (VariableDefinition->VariableSize);
1871 ASSERT (VariableDefinition->NvRamMap != NULL);
1872 }
1873
1874 if (VariableDefinition->VariableFakeSize != 0) {
1875 VariableDefinition->FakeNvRamMap = AllocateZeroPool (VariableDefinition->VariableFakeSize);
1876 ASSERT (VariableDefinition->FakeNvRamMap != NULL);
1877 }
1878 }
1879
1880 Status = gBS->HandleProtocol (
1881 (VOID *) (UINTN) FileFormTags->FormTags.Tags[0].CallbackHandle,
1882 &gEfiFormCallbackProtocolGuid,
1883 (VOID **) &FormCallback
1884 );
1885
1886 //
1887 // Since we might have multiple variables, if there is an NvMapOverride we need to use the EFI_VARIABLE_DEFINITION
1888 // information as the information that we pass back and forth. NOTE that callbacks that are initiated will only have the
1889 // NVRAM data refreshed based on the op-code that initiated the callback. In other words, we will pass to the caller a single
1890 // NVRAM map for a single variable based on the op-code that the user selected.
1891 //
1892 if (NvMapOverride != NULL) {
1893 VariableDefinition = FileFormTags->VariableDefinitions;
1894 OverrideDefinition = ((EFI_VARIABLE_DEFINITION *) NvMapOverride);
1895
1896 //
1897 // Search through the variable definitions. There should be sufficient passed in settings for the variable op-codes specified
1898 //
1899 for (; VariableDefinition != NULL; VariableDefinition = VariableDefinition->Next) {
1900 if ((!CompareMem (VariableDefinition->VariableName, L"Setup", 10)) && (VariableDefinition->Next == NULL)) {
1901 if (VariableDefinition->VariableSize != 0) {
1902 CopyMem (VariableDefinition->NvRamMap, NvMapOverride, VariableDefinition->VariableSize);
1903 } else {
1904 CopyMem (VariableDefinition->NvRamMap, NvMapOverride, VariableDefinition->VariableFakeSize);
1905 }
1906 break;
1907 } else {
1908 VariableDefinition->NvRamMap = OverrideDefinition->NvRamMap;
1909 }
1910 //
1911 // There should NEVER be a ->Next for VariableDefinition and a NULL ->Next for the OverrideDefinition
1912 //
1913 ASSERT (OverrideDefinition->Next);
1914 OverrideDefinition = OverrideDefinition->Next;
1915 }
1916 } else {
1917 VariableDefinition = FileFormTags->VariableDefinitions;
1918
1919 //
1920 // Search through the variable definitions. There should be sufficient passed in settings for the variable op-codes specified
1921 //
1922 for (; VariableDefinition != NULL; VariableDefinition = VariableDefinition->Next) {
1923 SizeOfNvStore = VariableDefinition->VariableSize;
1924
1925 //
1926 // Getting the NvStore and placing it into our Global Data
1927 //
1928 if ((FormCallback != NULL) && (FormCallback->NvRead != NULL)) {
1929 Status = FormCallback->NvRead (
1930 FormCallback,
1931 VariableDefinition->VariableName,
1932 &VariableDefinition->Guid,
1933 NULL,
1934 &SizeOfNvStore,
1935 (VOID *) VariableDefinition->NvRamMap
1936 );
1937 } else {
1938 Status = gRT->GetVariable (
1939 VariableDefinition->VariableName,
1940 &VariableDefinition->Guid,
1941 NULL,
1942 &SizeOfNvStore,
1943 (VOID *) VariableDefinition->NvRamMap
1944 );
1945 }
1946
1947 if (EFI_ERROR (Status)) {
1948 //
1949 // If there is a variable that exists already and it is larger than what we calculated the
1950 // storage needs to be, we must assume the variable size from GetVariable is correct and not
1951 // allow the truncation of the variable. It is very possible that the user who created the IFR
1952 // we are cracking is not referring to a variable that was in a previous map, however we cannot
1953 // allow it's truncation.
1954 //
1955 if (Status == EFI_BUFFER_TOO_SMALL) {
1956 //
1957 // If the buffer was too small, we should have the expanded size requirement in SizeOfNvStore now.
1958 //
1959 VariableDefinition->VariableSize = (UINT16) SizeOfNvStore;
1960
1961 //
1962 // Free the buffer that was allocated that was too small
1963 //
1964 FreePool (VariableDefinition->NvRamMap);
1965 FreePool (VariableDefinition->FakeNvRamMap);
1966
1967 VariableDefinition->NvRamMap = AllocateZeroPool (SizeOfNvStore);
1968 VariableDefinition->FakeNvRamMap = AllocateZeroPool (SizeOfNvStore + VariableDefinition->VariableFakeSize);
1969 ASSERT (VariableDefinition->NvRamMap);
1970 ASSERT (VariableDefinition->FakeNvRamMap);
1971
1972 if ((FormCallback != NULL) && (FormCallback->NvRead != NULL)) {
1973 Status = FormCallback->NvRead (
1974 FormCallback,
1975 VariableDefinition->VariableName,
1976 &VariableDefinition->Guid,
1977 NULL,
1978 &SizeOfNvStore,
1979 (VOID *) VariableDefinition->NvRamMap
1980 );
1981 } else {
1982 Status = gRT->GetVariable (
1983 VariableDefinition->VariableName,
1984 &VariableDefinition->Guid,
1985 NULL,
1986 &SizeOfNvStore,
1987 (VOID *) VariableDefinition->NvRamMap
1988 );
1989 }
1990 }
1991 //
1992 // if the variable was not found, we will retrieve default values
1993 //
1994 if (Status == EFI_NOT_FOUND) {
1995
1996 if (0 == CompareMem (VariableDefinition->VariableName, L"Setup", 10)) {
1997
1998 NvMapListHead = NULL;
1999
2000 Status = Hii->GetDefaultImage (Hii, Handle[HandleIndex], EFI_IFR_FLAG_DEFAULT, &NvMapListHead);
2001
2002 if (!EFI_ERROR (Status)) {
2003 ASSERT_EFI_ERROR (NULL != NvMapListHead);
2004
2005 NvMapListNode = NvMapListHead;
2006
2007 while (NULL != NvMapListNode) {
2008 if (VariableDefinition->VariableId == NvMapListNode->VariablePack->VariableId) {
2009 NvMap = (VOID *) ((CHAR8 *) NvMapListNode->VariablePack + sizeof (EFI_HII_VARIABLE_PACK) + NvMapListNode->VariablePack->VariableNameLength);
2010 NvMapSize = NvMapListNode->VariablePack->Header.Length - sizeof (EFI_HII_VARIABLE_PACK) - NvMapListNode->VariablePack->VariableNameLength;
2011 break;
2012 }
2013 NvMapListNode = NvMapListNode->NextVariablePack;
2014 }
2015
2016 //
2017 // Free the buffer that was allocated.
2018 //
2019 FreePool (VariableDefinition->NvRamMap);
2020 FreePool (VariableDefinition->FakeNvRamMap);
2021
2022 //
2023 // Allocate, copy the NvRamMap.
2024 //
2025 VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableFakeSize - VariableDefinition->VariableSize);
2026 VariableDefinition->VariableSize = (UINT16) NvMapSize;
2027 VariableDefinition->VariableFakeSize = (UINT16) (VariableDefinition->VariableFakeSize + VariableDefinition->VariableSize);
2028
2029 VariableDefinition->NvRamMap = AllocateZeroPool (VariableDefinition->VariableSize);
2030 VariableDefinition->FakeNvRamMap = AllocateZeroPool (NvMapSize + VariableDefinition->VariableFakeSize);
2031
2032 CopyMem (VariableDefinition->NvRamMap, NvMap, NvMapSize);
2033 FreePool (NvMapListHead);
2034 }
2035
2036 }
2037 Status = EFI_SUCCESS;
2038 }
2039 }
2040 }
2041 }
2042
2043 InitializeTagStructures (BinaryData, FileFormTags);
2044 }
2045 //
2046 // endfor
2047 //
2048 return Status;
2049 }
2050
2051 STATIC
2052 EFI_STATUS
2053 GetIfrBinaryData (
2054 IN EFI_HII_PROTOCOL *Hii,
2055 IN EFI_HII_HANDLE HiiHandle,
2056 IN EFI_IFR_PACKET *Packet,
2057 IN OUT EFI_IFR_BINARY *BinaryData
2058 )
2059 /*++
2060
2061 Routine Description:
2062 Fetch the Ifr binary data.
2063
2064 Arguments:
2065 Hii - Point to HII protocol.
2066 HiiHandle - Handle of Ifr to be fetched.
2067 Packet - Pointer to IFR packet.
2068 BinaryData - Buffer to copy the string into
2069
2070 Returns:
2071 Returns the number of CHAR16 characters that were copied into the OutputString buffer.
2072
2073
2074 --*/
2075 {
2076 EFI_STATUS Status;
2077 EFI_HII_PACKAGES *PackageList;
2078 UINTN BufferSize;
2079 VOID *Buffer;
2080 UINT8 *RawFormBinary;
2081 EFI_IFR_FORM_SET *FormOp;
2082 UINT16 Index;
2083 UINT16 Index2;
2084 UINT16 TitleToken;
2085
2086 //
2087 // Initialize the TitleToken to 0 just in case not found
2088 //
2089 TitleToken = 0;
2090
2091 //
2092 // Try for a 32K Buffer
2093 //
2094 BufferSize = 0x8000;
2095
2096 //
2097 // Allocate memory for our Form binary
2098 //
2099 Buffer = AllocateZeroPool (BufferSize);
2100 ASSERT (Buffer);
2101
2102 if (Packet == NULL) {
2103 Status = Hii->GetForms (Hii, HiiHandle, 0, &BufferSize, Buffer);
2104
2105 if (Status == EFI_BUFFER_TOO_SMALL) {
2106
2107 FreePool (Buffer);
2108
2109 //
2110 // Allocate memory for our Form binary
2111 //
2112 Buffer = AllocatePool (BufferSize);
2113 ASSERT (Buffer);
2114
2115 Status = Hii->GetForms (Hii, HiiHandle, 0, &BufferSize, Buffer);
2116 }
2117 } else {
2118 //
2119 // Copies the data to local usable buffer
2120 //
2121 CopyMem (Buffer, Packet->IfrData, Packet->IfrData->Header.Length);
2122
2123 //
2124 // Register the string data with HII
2125 //
2126 PackageList = PreparePackages (2, NULL, Packet->IfrData, Packet->StringData);
2127
2128 Status = Hii->NewPack (Hii, PackageList, &HiiHandle);
2129
2130 FreePool (PackageList);
2131 }
2132
2133 if (EFI_ERROR (Status)) {
2134 return Status;
2135 }
2136 //
2137 // We now have the IFR binary in our Buffer
2138 //
2139 BinaryData->IfrPackage = Buffer;
2140 RawFormBinary = (UINT8 *) ((CHAR8 *) (Buffer) + sizeof (EFI_HII_PACK_HEADER));
2141 BinaryData->FormBinary = (UINT8 *) ((CHAR8 *) (Buffer) + sizeof (EFI_HII_PACK_HEADER));
2142 BinaryData->Handle = HiiHandle;
2143
2144 //
2145 // If a packet was passed in, remove the string data when exiting.
2146 //
2147 if (Packet != NULL) {
2148 BinaryData->UnRegisterOnExit = TRUE;
2149 } else {
2150 BinaryData->UnRegisterOnExit = FALSE;
2151 }
2152 //
2153 // Walk through the FormSet Opcodes looking for the FormSet opcode
2154 // If we hit EFI_IFR_END_SET_OP we know we hit the end of the FormSet.
2155 //
2156 for (Index = 0; RawFormBinary[Index] != EFI_IFR_END_FORM_SET_OP;) {
2157 FormOp = (EFI_IFR_FORM_SET *) &RawFormBinary[Index];
2158 Index = (UINT16) (Index + FormOp->Header.Length);
2159
2160 if (FormOp->Header.OpCode == EFI_IFR_FORM_SET_OP) {
2161 TitleToken = FormOp->FormSetTitle;
2162 //
2163 // If displaying FrontPage - set the flag signifying it
2164 //
2165 switch (FormOp->SubClass) {
2166 case EFI_FRONT_PAGE_SUBCLASS:
2167 FrontPageHandle = HiiHandle;
2168
2169 default:
2170 gClassOfVfr = FormOp->SubClass;
2171 }
2172 //
2173 // Match GUID to find out the function key setting. If match fail, use the default setting.
2174 //
2175 for (Index2 = 0; Index2 < sizeof (gFunctionKeySettingTable) / sizeof (FUNCTIION_KEY_SETTING); Index2++) {
2176 if (CompareGuid ((EFI_GUID *)(UINTN)&FormOp->Guid, &(gFunctionKeySettingTable[Index2].FormSetGuid))) {
2177 //
2178 // Update the function key setting.
2179 //
2180 gFunctionKeySetting = gFunctionKeySettingTable[Index2].KeySetting;
2181 //
2182 // Function key prompt can not be displayed if the function key has been disabled.
2183 //
2184 if ((gFunctionKeySetting & FUNCTION_ONE) != FUNCTION_ONE) {
2185 gFunctionOneString = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2186 }
2187
2188 if ((gFunctionKeySetting & FUNCTION_TWO) != FUNCTION_TWO) {
2189 gFunctionTwoString = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2190 }
2191
2192 if ((gFunctionKeySetting & FUNCTION_NINE) != FUNCTION_NINE) {
2193 gFunctionNineString = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2194 }
2195
2196 if ((gFunctionKeySetting & FUNCTION_TEN) != FUNCTION_TEN) {
2197 gFunctionTenString = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2198 }
2199 }
2200 }
2201 }
2202 }
2203
2204 BinaryData->TitleToken = TitleToken;
2205
2206 return Status;
2207 }
2208
2209 EFI_HANDLE PrintHandle = NULL;
2210 EFI_PRINT_PROTOCOL mPrintProtocol = { UnicodeVSPrint };
2211
2212 STATIC
2213 EFI_STATUS
2214 InstallPrint (
2215 VOID
2216 )
2217 {
2218 return gBS->InstallProtocolInterface (
2219 &PrintHandle,
2220 &gEfiPrintProtocolGuid,
2221 EFI_NATIVE_INTERFACE,
2222 &mPrintProtocol
2223 );
2224 }