]> git.proxmox.com Git - mirror_edk2.git/blob - IntelFrameworkModulePkg/Universal/BdsDxe/BootMaint/UpdatePage.c
projects / mirror_edk2.git / blob
? search:


a3b9dd8928265975d87c79bafa52b183800a1a0f
[mirror_edk2.git] / IntelFrameworkModulePkg / Universal / BdsDxe / BootMaint / UpdatePage.c
1 /** @file
2 Dynamically update the pages.
3
4 Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>
5 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 "BootMaint.h"
16
17 /**
18 Refresh the global UpdateData structure.
19
20 **/
21 VOID
22 RefreshUpdateData (
23 VOID
24 )
25 {
26 //
27 // Free current updated date
28 //
29 if (mStartOpCodeHandle != NULL) {
30 HiiFreeOpCodeHandle (mStartOpCodeHandle);
31 }
32
33 //
34 // Create new OpCode Handle
35 //
36 mStartOpCodeHandle = HiiAllocateOpCodeHandle ();
37
38 //
39 // Create Hii Extend Label OpCode as the start opcode
40 //
41 mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mStartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
42 mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
43
44 }
45
46 /**
47 Add a "Go back to main page" tag in front of the form when there are no
48 "Apply changes" and "Discard changes" tags in the end of the form.
49
50 @param CallbackData The BMM context data.
51
52 **/
53 VOID
54 UpdatePageStart (
55 IN BMM_CALLBACK_DATA *CallbackData
56 )
57 {
58 RefreshUpdateData ();
59 mStartLabel->Number = CallbackData->BmmCurrentPageId;
60
61 if (!(CallbackData->BmmAskSaveOrNot)) {
62 //
63 // Add a "Go back to main page" tag in front of the form when there are no
64 // "Apply changes" and "Discard changes" tags in the end of the form.
65 //
66 HiiCreateGotoOpCode (
67 mStartOpCodeHandle,
68 FORM_MAIN_ID,
69 STRING_TOKEN (STR_FORM_GOTO_MAIN),
70 STRING_TOKEN (STR_FORM_GOTO_MAIN),
71 0,
72 FORM_MAIN_ID
73 );
74 }
75
76 }
77
78 /**
79 Create the "Apply changes" and "Discard changes" tags. And
80 ensure user can return to the main page.
81
82 @param CallbackData The BMM context data.
83
84 **/
85 VOID
86 UpdatePageEnd (
87 IN BMM_CALLBACK_DATA *CallbackData
88 )
89 {
90 //
91 // Create the "Apply changes" and "Discard changes" tags.
92 //
93 if (CallbackData->BmmAskSaveOrNot) {
94 HiiCreateSubTitleOpCode (
95 mStartOpCodeHandle,
96 STRING_TOKEN (STR_NULL_STRING),
97 0,
98 0,
99 0
100 );
101
102 HiiCreateActionOpCode (
103 mStartOpCodeHandle,
104 KEY_VALUE_SAVE_AND_EXIT,
105 STRING_TOKEN (STR_SAVE_AND_EXIT),
106 STRING_TOKEN (STR_NULL_STRING),
107 EFI_IFR_FLAG_CALLBACK,
108 0
109 );
110 }
111
112 //
113 // Ensure user can return to the main page.
114 //
115 HiiCreateActionOpCode (
116 mStartOpCodeHandle,
117 KEY_VALUE_NO_SAVE_AND_EXIT,
118 STRING_TOKEN (STR_NO_SAVE_AND_EXIT),
119 STRING_TOKEN (STR_NULL_STRING),
120 EFI_IFR_FLAG_CALLBACK,
121 0
122 );
123
124 HiiUpdateForm (
125 CallbackData->BmmHiiHandle,
126 &gBootMaintFormSetGuid,
127 CallbackData->BmmCurrentPageId,
128 mStartOpCodeHandle, // Label CallbackData->BmmCurrentPageId
129 mEndOpCodeHandle // LABEL_END
130 );
131 }
132
133 /**
134 Clean up the dynamic opcode at label and form specified by both LabelId.
135
136 @param LabelId It is both the Form ID and Label ID for opcode deletion.
137 @param CallbackData The BMM context data.
138
139 **/
140 VOID
141 CleanUpPage (
142 IN UINT16 LabelId,
143 IN BMM_CALLBACK_DATA *CallbackData
144 )
145 {
146 RefreshUpdateData ();
147
148 //
149 // Remove all op-codes from dynamic page
150 //
151 mStartLabel->Number = LabelId;
152 HiiUpdateForm (
153 CallbackData->BmmHiiHandle,
154 &gBootMaintFormSetGuid,
155 LabelId,
156 mStartOpCodeHandle, // Label LabelId
157 mEndOpCodeHandle // LABEL_END
158 );
159 }
160
161 /**
162 Boot a file selected by user at File Expoloer of BMM.
163
164 @param FileContext The file context data, which contains the device path
165 of the file to be boot from.
166
167 @retval EFI_SUCCESS The function completed successfull.
168 @return Other value if the boot from the file fails.
169
170 **/
171 EFI_STATUS
172 BootThisFile (
173 IN BM_FILE_CONTEXT *FileContext
174 )
175 {
176 EFI_STATUS Status;
177 UINTN ExitDataSize;
178 CHAR16 *ExitData;
179 BDS_COMMON_OPTION *Option;
180
181 Option = (BDS_COMMON_OPTION *) AllocatePool (sizeof (BDS_COMMON_OPTION));
182 ASSERT (Option != NULL);
183 Option->Description = (CHAR16 *) AllocateCopyPool (StrSize (FileContext->FileName), FileContext->FileName);
184 Option->DevicePath = FileContext->DevicePath;
185 Option->LoadOptionsSize = 0;
186 Option->LoadOptions = NULL;
187
188 //
189 // Since current no boot from removable media directly is allowed */
190 //
191 gST->ConOut->ClearScreen (gST->ConOut);
192
193 ExitDataSize = 0;
194
195 Status = BdsLibBootViaBootOption (Option, Option->DevicePath, &ExitDataSize, &ExitData);
196
197 return Status;
198
199 }
200
201 /**
202 Create a list of Goto Opcode for all terminal devices logged
203 by TerminaMenu. This list will be inserted to form FORM_CON_COM_SETUP_ID.
204
205 @param CallbackData The BMM context data.
206 **/
207 VOID
208 UpdateConCOMPage (
209 IN BMM_CALLBACK_DATA *CallbackData
210 )
211 {
212 BM_MENU_ENTRY *NewMenuEntry;
213 UINT16 Index;
214
215 CallbackData->BmmAskSaveOrNot = FALSE;
216
217 UpdatePageStart (CallbackData);
218
219
220 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
221 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
222
223 HiiCreateGotoOpCode (
224 mStartOpCodeHandle,
225 FORM_CON_COM_SETUP_ID,
226 NewMenuEntry->DisplayStringToken,
227 STRING_TOKEN (STR_NULL_STRING),
228 EFI_IFR_FLAG_CALLBACK,
229 (UINT16) (TERMINAL_OPTION_OFFSET + Index)
230 );
231 }
232
233 UpdatePageEnd (CallbackData);
234 }
235
236 /**
237 Create a lit of boot option from global BootOptionMenu. It
238 allow user to delete the boot option.
239
240 @param CallbackData The BMM context data.
241
242 **/
243 VOID
244 UpdateBootDelPage (
245 IN BMM_CALLBACK_DATA *CallbackData
246 )
247 {
248 BM_MENU_ENTRY *NewMenuEntry;
249 BM_LOAD_CONTEXT *NewLoadContext;
250 UINT16 Index;
251
252 CallbackData->BmmAskSaveOrNot = TRUE;
253
254 UpdatePageStart (CallbackData);
255 CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &BootOptionMenu);
256
257 ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.BootOptionDel) / sizeof (CallbackData->BmmFakeNvData.BootOptionDel[0])));
258 for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
259 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
260 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
261 if (NewLoadContext->IsLegacy) {
262 continue;
263 }
264
265 NewLoadContext->Deleted = FALSE;
266
267 if (CallbackData->BmmFakeNvData.BootOptionDel[Index] && !CallbackData->BmmFakeNvData.BootOptionDelMark[Index]) {
268 //
269 // CallbackData->BmmFakeNvData.BootOptionDel[Index] == TRUE means browser knows this boot option is selected
270 // CallbackData->BmmFakeNvData.BootOptionDelMark[Index] = FALSE means BDS knows the selected boot option has
271 // deleted, browser maintains old useless info. So clear this info here, and later update this info to browser
272 // through HiiSetBrowserData function.
273 //
274 CallbackData->BmmFakeNvData.BootOptionDel[Index] = FALSE;
275 }
276
277 HiiCreateCheckBoxOpCode (
278 mStartOpCodeHandle,
279 (EFI_QUESTION_ID) (BOOT_OPTION_DEL_QUESTION_ID + Index),
280 VARSTORE_ID_BOOT_MAINT,
281 (UINT16) (BOOT_OPTION_DEL_VAR_OFFSET + Index),
282 NewMenuEntry->DisplayStringToken,
283 NewMenuEntry->HelpStringToken,
284 EFI_IFR_FLAG_CALLBACK,
285 0,
286 NULL
287 );
288 }
289
290 UpdatePageEnd (CallbackData);
291 }
292
293 /**
294 Create a lit of driver option from global DriverMenu.
295
296 @param CallbackData The BMM context data.
297
298 **/
299 VOID
300 UpdateDrvAddHandlePage (
301 IN BMM_CALLBACK_DATA *CallbackData
302 )
303 {
304 BM_MENU_ENTRY *NewMenuEntry;
305 UINT16 Index;
306
307 CallbackData->BmmAskSaveOrNot = FALSE;
308
309 UpdatePageStart (CallbackData);
310
311 for (Index = 0; Index < DriverMenu.MenuNumber; Index++) {
312 NewMenuEntry = BOpt_GetMenuEntry (&DriverMenu, Index);
313
314 HiiCreateGotoOpCode (
315 mStartOpCodeHandle,
316 FORM_DRV_ADD_HANDLE_DESC_ID,
317 NewMenuEntry->DisplayStringToken,
318 STRING_TOKEN (STR_NULL_STRING),
319 EFI_IFR_FLAG_CALLBACK,
320 (UINT16) (HANDLE_OPTION_OFFSET + Index)
321 );
322 }
323
324 UpdatePageEnd (CallbackData);
325 }
326
327 /**
328 Create a lit of driver option from global DriverOptionMenu. It
329 allow user to delete the driver option.
330
331 @param CallbackData The BMM context data.
332
333 **/
334 VOID
335 UpdateDrvDelPage (
336 IN BMM_CALLBACK_DATA *CallbackData
337 )
338 {
339 BM_MENU_ENTRY *NewMenuEntry;
340 BM_LOAD_CONTEXT *NewLoadContext;
341 UINT16 Index;
342
343 CallbackData->BmmAskSaveOrNot = TRUE;
344
345 UpdatePageStart (CallbackData);
346
347 CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &DriverOptionMenu);
348
349 ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.DriverOptionDel) / sizeof (CallbackData->BmmFakeNvData.DriverOptionDel[0])));
350 for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
351 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
352
353 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
354 NewLoadContext->Deleted = FALSE;
355
356 if (CallbackData->BmmFakeNvData.DriverOptionDel[Index] && !CallbackData->BmmFakeNvData.DriverOptionDelMark[Index]) {
357 //
358 // CallbackData->BmmFakeNvData.BootOptionDel[Index] == TRUE means browser knows this boot option is selected
359 // CallbackData->BmmFakeNvData.BootOptionDelMark[Index] = FALSE means BDS knows the selected boot option has
360 // deleted, browser maintains old useless info. So clear this info here, and later update this info to browser
361 // through HiiSetBrowserData function.
362 //
363 CallbackData->BmmFakeNvData.DriverOptionDel[Index] = FALSE;
364 }
365
366 HiiCreateCheckBoxOpCode (
367 mStartOpCodeHandle,
368 (EFI_QUESTION_ID) (DRIVER_OPTION_DEL_QUESTION_ID + Index),
369 VARSTORE_ID_BOOT_MAINT,
370 (UINT16) (DRIVER_OPTION_DEL_VAR_OFFSET + Index),
371 NewMenuEntry->DisplayStringToken,
372 NewMenuEntry->HelpStringToken,
373 EFI_IFR_FLAG_CALLBACK,
374 0,
375 NULL
376 );
377 }
378
379 UpdatePageEnd (CallbackData);
380 }
381
382 /**
383 Prepare the page to allow user to add description for
384 a Driver Option.
385
386 @param CallbackData The BMM context data.
387
388 **/
389 VOID
390 UpdateDriverAddHandleDescPage (
391 IN BMM_CALLBACK_DATA *CallbackData
392 )
393 {
394 BM_MENU_ENTRY *NewMenuEntry;
395
396 CallbackData->BmmFakeNvData.DriverAddActive = 0x01;
397 CallbackData->BmmFakeNvData.DriverAddForceReconnect = 0x00;
398 CallbackData->BmmAskSaveOrNot = TRUE;
399 NewMenuEntry = CallbackData->MenuEntry;
400
401 UpdatePageStart (CallbackData);
402
403 HiiCreateSubTitleOpCode (
404 mStartOpCodeHandle,
405 NewMenuEntry->DisplayStringToken,
406 0,
407 0,
408 0
409 );
410
411 HiiCreateStringOpCode (
412 mStartOpCodeHandle,
413 (EFI_QUESTION_ID) DRV_ADD_HANDLE_DESC_QUESTION_ID,
414 VARSTORE_ID_BOOT_MAINT,
415 DRV_ADD_HANDLE_DESC_VAR_OFFSET,
416 STRING_TOKEN (STR_LOAD_OPTION_DESC),
417 STRING_TOKEN (STR_NULL_STRING),
418 0,
419 0,
420 6,
421 75,
422 NULL
423 );
424
425 HiiCreateCheckBoxOpCode (
426 mStartOpCodeHandle,
427 (EFI_QUESTION_ID) DRV_ADD_RECON_QUESTION_ID,
428 VARSTORE_ID_BOOT_MAINT,
429 DRV_ADD_RECON_VAR_OFFSET,
430 STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
431 STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
432 0,
433 0,
434 NULL
435 );
436
437 HiiCreateStringOpCode (
438 mStartOpCodeHandle,
439 (EFI_QUESTION_ID) DRIVER_ADD_OPTION_QUESTION_ID,
440 VARSTORE_ID_BOOT_MAINT,
441 DRIVER_ADD_OPTION_VAR_OFFSET,
442 STRING_TOKEN (STR_OPTIONAL_DATA),
443 STRING_TOKEN (STR_NULL_STRING),
444 0,
445 0,
446 6,
447 75,
448 NULL
449 );
450
451 UpdatePageEnd (CallbackData);
452 }
453
454 /**
455 Update console page.
456
457 @param UpdatePageId The form ID to be updated.
458 @param ConsoleMenu The console menu list.
459 @param CallbackData The BMM context data.
460
461 **/
462 VOID
463 UpdateConsolePage (
464 IN UINT16 UpdatePageId,
465 IN BM_MENU_OPTION *ConsoleMenu,
466 IN BMM_CALLBACK_DATA *CallbackData
467 )
468 {
469 BM_MENU_ENTRY *NewMenuEntry;
470 UINT16 Index;
471 UINT8 CheckFlags;
472 UINT8 *ConsoleCheck;
473 EFI_QUESTION_ID QuestionIdBase;
474 UINT16 VariableOffsetBase;
475
476 UpdatePageStart (CallbackData);
477
478 ConsoleCheck = NULL;
479 QuestionIdBase = 0;
480 VariableOffsetBase = 0;
481
482 switch (UpdatePageId) {
483 case FORM_CON_IN_ID:
484 ConsoleCheck = &CallbackData->BmmFakeNvData.ConsoleInCheck[0];
485 QuestionIdBase = CON_IN_DEVICE_QUESTION_ID;
486 VariableOffsetBase = CON_IN_DEVICE_VAR_OFFSET;
487 break;
488
489 case FORM_CON_OUT_ID:
490 ConsoleCheck = &CallbackData->BmmFakeNvData.ConsoleOutCheck[0];
491 QuestionIdBase = CON_OUT_DEVICE_QUESTION_ID;
492 VariableOffsetBase = CON_OUT_DEVICE_VAR_OFFSET;
493 break;
494
495 case FORM_CON_ERR_ID:
496 ConsoleCheck = &CallbackData->BmmFakeNvData.ConsoleErrCheck[0];
497 QuestionIdBase = CON_ERR_DEVICE_QUESTION_ID;
498 VariableOffsetBase = CON_ERR_DEVICE_VAR_OFFSET;
499 break;
500 }
501 ASSERT (ConsoleCheck != NULL);
502
503 for (Index = 0; ((Index < ConsoleMenu->MenuNumber) && \
504 (Index < MAX_MENU_NUMBER)) ; Index++) {
505 CheckFlags = 0;
506 if (UpdatePageId != FORM_CON_ERR_ID) {
507 CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
508 }
509 NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index);
510 HiiCreateCheckBoxOpCode (
511 mStartOpCodeHandle,
512 (EFI_QUESTION_ID) (QuestionIdBase + Index),
513 VARSTORE_ID_BOOT_MAINT,
514 (UINT16) (VariableOffsetBase + Index),
515 NewMenuEntry->DisplayStringToken,
516 NewMenuEntry->HelpStringToken,
517 0,
518 CheckFlags,
519 NULL
520 );
521 }
522
523 UpdatePageEnd (CallbackData);
524 }
525
526 /**
527 Update the page's NV Map if user has changed the order
528 a list. This list can be Boot Order or Driver Order.
529
530 @param UpdatePageId The form ID to be updated.
531 @param OptionMenu The new list.
532 @param CallbackData The BMM context data.
533
534 **/
535 VOID
536 UpdateOrderPage (
537 IN UINT16 UpdatePageId,
538 IN BM_MENU_OPTION *OptionMenu,
539 IN BMM_CALLBACK_DATA *CallbackData
540 )
541 {
542 BM_MENU_ENTRY *NewMenuEntry;
543 UINT16 Index;
544 UINT16 OptionIndex;
545 VOID *OptionsOpCodeHandle;
546 BM_LOAD_CONTEXT *NewLoadContext;
547 BOOLEAN BootOptionFound;
548 UINT32 *OptionOrder;
549 EFI_QUESTION_ID QuestionId;
550 UINT16 VarOffset;
551
552
553 UpdatePageStart (CallbackData);
554
555 CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, OptionMenu);
556
557 OptionOrder = NULL;
558 QuestionId = 0;
559 VarOffset = 0;
560 switch (UpdatePageId) {
561
562 case FORM_BOOT_CHG_ID:
563 //GetBootOrder (CallbackData);
564 OptionOrder = CallbackData->BmmFakeNvData.BootOptionOrder;
565 QuestionId = BOOT_OPTION_ORDER_QUESTION_ID;
566 VarOffset = BOOT_OPTION_ORDER_VAR_OFFSET;
567 break;
568
569 case FORM_DRV_CHG_ID:
570 //GetDriverOrder (CallbackData);
571 OptionOrder = CallbackData->BmmFakeNvData.DriverOptionOrder;
572 QuestionId = DRIVER_OPTION_ORDER_QUESTION_ID;
573 VarOffset = DRIVER_OPTION_ORDER_VAR_OFFSET;
574 break;
575 }
576 ASSERT (OptionOrder != NULL);
577
578 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
579 ASSERT (OptionsOpCodeHandle != NULL);
580
581 NewMenuEntry = NULL;
582 for (OptionIndex = 0; (OptionIndex < MAX_MENU_NUMBER && OptionOrder[OptionIndex] != 0); OptionIndex++) {
583 BootOptionFound = FALSE;
584 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
585 NewMenuEntry = BOpt_GetMenuEntry (OptionMenu, Index);
586 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
587 if ((UINT32) (NewMenuEntry->OptionNumber + 1) == OptionOrder[OptionIndex]) {
588 BootOptionFound = TRUE;
589 break;
590 }
591 }
592 if (BootOptionFound) {
593 HiiCreateOneOfOptionOpCode (
594 OptionsOpCodeHandle,
595 NewMenuEntry->DisplayStringToken,
596 0,
597 EFI_IFR_TYPE_NUM_SIZE_32,
598 OptionOrder[OptionIndex]
599 );
600 }
601 }
602
603 if (OptionMenu->MenuNumber > 0) {
604 HiiCreateOrderedListOpCode (
605 mStartOpCodeHandle, // Container for dynamic created opcodes
606 QuestionId, // Question ID
607 VARSTORE_ID_BOOT_MAINT, // VarStore ID
608 VarOffset, // Offset in Buffer Storage
609 STRING_TOKEN (STR_CHANGE_ORDER), // Question prompt text
610 STRING_TOKEN (STR_CHANGE_ORDER), // Question help text
611 0, // Question flag
612 0, // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
613 EFI_IFR_TYPE_NUM_SIZE_32, // Data type of Question value
614 100, // Maximum container
615 OptionsOpCodeHandle, // Option Opcode list
616 NULL // Default Opcode is NULL
617 );
618 }
619
620 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
621
622 UpdatePageEnd (CallbackData);
623 }
624
625 /**
626 Create the dynamic page to allow user to set
627 the "BootNext" value.
628
629 @param CallbackData The BMM context data.
630
631 **/
632 VOID
633 UpdateBootNextPage (
634 IN BMM_CALLBACK_DATA *CallbackData
635 )
636 {
637 BM_MENU_ENTRY *NewMenuEntry;
638 BM_LOAD_CONTEXT *NewLoadContext;
639 UINTN NumberOfOptions;
640 UINT16 Index;
641 VOID *OptionsOpCodeHandle;
642
643 NumberOfOptions = BootOptionMenu.MenuNumber;
644 CallbackData->BmmAskSaveOrNot = TRUE;
645
646 UpdatePageStart (CallbackData);
647 CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &BootOptionMenu);
648
649 if (NumberOfOptions > 0) {
650 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
651 ASSERT (OptionsOpCodeHandle != NULL);
652
653 //CallbackData->BmmFakeNvData.BootNext = (UINT16) (BootOptionMenu.MenuNumber);
654
655 for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
656 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
657 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
658
659 if (NewLoadContext->IsBootNext) {
660 HiiCreateOneOfOptionOpCode (
661 OptionsOpCodeHandle,
662 NewMenuEntry->DisplayStringToken,
663 EFI_IFR_OPTION_DEFAULT,
664 EFI_IFR_TYPE_NUM_SIZE_16,
665 Index
666 );
667 //CallbackData->BmmFakeNvData.BootNext = Index;
668 } else {
669 HiiCreateOneOfOptionOpCode (
670 OptionsOpCodeHandle,
671 NewMenuEntry->DisplayStringToken,
672 0,
673 EFI_IFR_TYPE_NUM_SIZE_16,
674 Index
675 );
676 }
677 }
678
679 if (CallbackData->BmmFakeNvData.BootNext == Index) {
680 HiiCreateOneOfOptionOpCode (
681 OptionsOpCodeHandle,
682 STRING_TOKEN (STR_NONE),
683 EFI_IFR_OPTION_DEFAULT,
684 EFI_IFR_TYPE_NUM_SIZE_16,
685 Index
686 );
687 } else {
688 HiiCreateOneOfOptionOpCode (
689 OptionsOpCodeHandle,
690 STRING_TOKEN (STR_NONE),
691 0,
692 EFI_IFR_TYPE_NUM_SIZE_16,
693 Index
694 );
695 }
696
697 HiiCreateOneOfOpCode (
698 mStartOpCodeHandle,
699 (EFI_QUESTION_ID) BOOT_NEXT_QUESTION_ID,
700 VARSTORE_ID_BOOT_MAINT,
701 BOOT_NEXT_VAR_OFFSET,
702 STRING_TOKEN (STR_BOOT_NEXT),
703 STRING_TOKEN (STR_BOOT_NEXT_HELP),
704 0,
705 EFI_IFR_NUMERIC_SIZE_2,
706 OptionsOpCodeHandle,
707 NULL
708 );
709
710 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
711 }
712
713 UpdatePageEnd (CallbackData);
714 }
715
716 /**
717 Create the dynamic page to allow user to set the "TimeOut" value.
718
719 @param CallbackData The BMM context data.
720
721 **/
722 VOID
723 UpdateTimeOutPage (
724 IN BMM_CALLBACK_DATA *CallbackData
725 )
726 {
727 UINT16 BootTimeOut;
728 VOID *DefaultOpCodeHandle;
729
730 CallbackData->BmmAskSaveOrNot = TRUE;
731
732 UpdatePageStart (CallbackData);
733
734 BootTimeOut = PcdGet16 (PcdPlatformBootTimeOut);
735
736 DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
737 ASSERT (DefaultOpCodeHandle != NULL);
738 HiiCreateDefaultOpCode (DefaultOpCodeHandle, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_NUM_SIZE_16, BootTimeOut);
739
740 HiiCreateNumericOpCode (
741 mStartOpCodeHandle,
742 (EFI_QUESTION_ID) BOOT_TIME_OUT_QUESTION_ID,
743 VARSTORE_ID_BOOT_MAINT,
744 BOOT_TIME_OUT_VAR_OFFSET,
745 STRING_TOKEN (STR_NUM_AUTO_BOOT),
746 STRING_TOKEN (STR_HLP_AUTO_BOOT),
747 0,
748 EFI_IFR_NUMERIC_SIZE_2 | EFI_IFR_DISPLAY_UINT_DEC,
749 0,
750 65535,
751 0,
752 DefaultOpCodeHandle
753 );
754
755 HiiFreeOpCodeHandle (DefaultOpCodeHandle);
756
757 //CallbackData->BmmFakeNvData.BootTimeOut = BootTimeOut;
758
759 UpdatePageEnd (CallbackData);
760 }
761
762 /**
763 Refresh the text mode page.
764
765 @param CallbackData The BMM context data.
766
767 **/
768 VOID
769 UpdateConModePage (
770 IN BMM_CALLBACK_DATA *CallbackData
771 )
772 {
773 UINTN Mode;
774 UINTN Index;
775 UINTN Col;
776 UINTN Row;
777 CHAR16 ModeString[50];
778 CHAR16 *PStr;
779 UINTN MaxMode;
780 UINTN ValidMode;
781 EFI_STRING_ID *ModeToken;
782 EFI_STATUS Status;
783 VOID *OptionsOpCodeHandle;
784 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut;
785
786 ConOut = gST->ConOut;
787 Index = 0;
788 ValidMode = 0;
789 MaxMode = (UINTN) (ConOut->Mode->MaxMode);
790
791 CallbackData->BmmAskSaveOrNot = TRUE;
792
793 UpdatePageStart (CallbackData);
794
795 //
796 // Check valid mode
797 //
798 for (Mode = 0; Mode < MaxMode; Mode++) {
799 Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
800 if (EFI_ERROR (Status)) {
801 continue;
802 }
803 ValidMode++;
804 }
805
806 if (ValidMode == 0) {
807 return;
808 }
809
810 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
811 ASSERT (OptionsOpCodeHandle != NULL);
812
813 ModeToken = AllocateZeroPool (sizeof (EFI_STRING_ID) * ValidMode);
814 ASSERT(ModeToken != NULL);
815
816 //
817 // Determin which mode should be the first entry in menu
818 //
819 // GetConsoleOutMode (CallbackData);
820
821 //
822 // Build text mode options
823 //
824 for (Mode = 0; Mode < MaxMode; Mode++) {
825 Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
826 if (EFI_ERROR (Status)) {
827 continue;
828 }
829
830 //
831 // Build mode string Column x Row
832 //
833 UnicodeValueToString (ModeString, 0, Col, 0);
834 PStr = &ModeString[0];
835 StrnCat (PStr, L" x ", StrLen(L" x ") + 1);
836 PStr = PStr + StrLen (PStr);
837 UnicodeValueToString (PStr , 0, Row, 0);
838
839 ModeToken[Index] = HiiSetString (CallbackData->BmmHiiHandle, 0, ModeString, NULL);
840
841 if (Mode == CallbackData->BmmFakeNvData.ConsoleOutMode) {
842 HiiCreateOneOfOptionOpCode (
843 OptionsOpCodeHandle,
844 ModeToken[Index],
845 EFI_IFR_OPTION_DEFAULT,
846 EFI_IFR_TYPE_NUM_SIZE_16,
847 (UINT16) Mode
848 );
849 } else {
850 HiiCreateOneOfOptionOpCode (
851 OptionsOpCodeHandle,
852 ModeToken[Index],
853 0,
854 EFI_IFR_TYPE_NUM_SIZE_16,
855 (UINT16) Mode
856 );
857 }
858 Index++;
859 }
860
861 HiiCreateOneOfOpCode (
862 mStartOpCodeHandle,
863 (EFI_QUESTION_ID) CON_MODE_QUESTION_ID,
864 VARSTORE_ID_BOOT_MAINT,
865 CON_MODE_VAR_OFFSET,
866 STRING_TOKEN (STR_CON_MODE_SETUP),
867 STRING_TOKEN (STR_CON_MODE_SETUP),
868 EFI_IFR_FLAG_RESET_REQUIRED,
869 EFI_IFR_NUMERIC_SIZE_2,
870 OptionsOpCodeHandle,
871 NULL
872 );
873
874 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
875 FreePool (ModeToken);
876
877 UpdatePageEnd (CallbackData);
878 }
879
880 /**
881 Create the dynamic page which allows user to set the property such as Baud Rate, Data Bits,
882 Parity, Stop Bits, Terminal Type.
883
884 @param CallbackData The BMM context data.
885
886 **/
887 VOID
888 UpdateTerminalPage (
889 IN BMM_CALLBACK_DATA *CallbackData
890 )
891 {
892 UINT8 Index;
893 UINT8 CheckFlags;
894 BM_MENU_ENTRY *NewMenuEntry;
895 BM_TERMINAL_CONTEXT *NewTerminalContext;
896 VOID *OptionsOpCodeHandle;
897 UINTN CurrentTerminal;
898
899 UpdatePageStart (CallbackData);
900
901 CurrentTerminal = CallbackData->CurrentTerminal;
902 NewMenuEntry = BOpt_GetMenuEntry (
903 &TerminalMenu,
904 CurrentTerminal
905 );
906
907 if (NewMenuEntry == NULL) {
908 return ;
909 }
910
911 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
912
913 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
914 ASSERT (OptionsOpCodeHandle != NULL);
915
916 for (Index = 0; Index < sizeof (BaudRateList) / sizeof (BaudRateList [0]); Index++) {
917 CheckFlags = 0;
918 if (BaudRateList[Index].Value == 115200) {
919 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
920 }
921 HiiCreateOneOfOptionOpCode (
922 OptionsOpCodeHandle,
923 BaudRateList[Index].StringToken,
924 CheckFlags,
925 EFI_IFR_TYPE_NUM_SIZE_8,
926 Index
927 );
928 }
929
930 HiiCreateOneOfOpCode (
931 mStartOpCodeHandle,
932 (EFI_QUESTION_ID) (COM_BAUD_RATE_QUESTION_ID + CurrentTerminal),
933 VARSTORE_ID_BOOT_MAINT,
934 (UINT16) (COM_BAUD_RATE_VAR_OFFSET + CurrentTerminal),
935 STRING_TOKEN (STR_COM_BAUD_RATE),
936 STRING_TOKEN (STR_COM_BAUD_RATE),
937 0,
938 EFI_IFR_NUMERIC_SIZE_1,
939 OptionsOpCodeHandle,
940 NULL
941 );
942
943 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
944 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
945 ASSERT (OptionsOpCodeHandle != NULL);
946
947 for (Index = 0; Index < sizeof (DataBitsList) / sizeof (DataBitsList[0]); Index++) {
948 CheckFlags = 0;
949
950 if (DataBitsList[Index].Value == 8) {
951 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
952 }
953
954 HiiCreateOneOfOptionOpCode (
955 OptionsOpCodeHandle,
956 DataBitsList[Index].StringToken,
957 CheckFlags,
958 EFI_IFR_TYPE_NUM_SIZE_8,
959 Index
960 );
961 }
962
963 HiiCreateOneOfOpCode (
964 mStartOpCodeHandle,
965 (EFI_QUESTION_ID) (COM_DATA_RATE_QUESTION_ID + CurrentTerminal),
966 VARSTORE_ID_BOOT_MAINT,
967 (UINT16) (COM_DATA_RATE_VAR_OFFSET + CurrentTerminal),
968 STRING_TOKEN (STR_COM_DATA_BITS),
969 STRING_TOKEN (STR_COM_DATA_BITS),
970 0,
971 EFI_IFR_NUMERIC_SIZE_1,
972 OptionsOpCodeHandle,
973 NULL
974 );
975
976 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
977 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
978 ASSERT (OptionsOpCodeHandle != NULL);
979
980 for (Index = 0; Index < sizeof (ParityList) / sizeof (ParityList[0]); Index++) {
981 CheckFlags = 0;
982 if (ParityList[Index].Value == NoParity) {
983 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
984 }
985
986 HiiCreateOneOfOptionOpCode (
987 OptionsOpCodeHandle,
988 ParityList[Index].StringToken,
989 CheckFlags,
990 EFI_IFR_TYPE_NUM_SIZE_8,
991 Index
992 );
993 }
994
995 HiiCreateOneOfOpCode (
996 mStartOpCodeHandle,
997 (EFI_QUESTION_ID) (COM_PARITY_QUESTION_ID + CurrentTerminal),
998 VARSTORE_ID_BOOT_MAINT,
999 (UINT16) (COM_PARITY_VAR_OFFSET + CurrentTerminal),
1000 STRING_TOKEN (STR_COM_PARITY),
1001 STRING_TOKEN (STR_COM_PARITY),
1002 0,
1003 EFI_IFR_NUMERIC_SIZE_1,
1004 OptionsOpCodeHandle,
1005 NULL
1006 );
1007
1008 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1009 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1010 ASSERT (OptionsOpCodeHandle != NULL);
1011
1012 for (Index = 0; Index < sizeof (StopBitsList) / sizeof (StopBitsList[0]); Index++) {
1013 CheckFlags = 0;
1014 if (StopBitsList[Index].Value == OneStopBit) {
1015 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1016 }
1017
1018 HiiCreateOneOfOptionOpCode (
1019 OptionsOpCodeHandle,
1020 StopBitsList[Index].StringToken,
1021 CheckFlags,
1022 EFI_IFR_TYPE_NUM_SIZE_8,
1023 Index
1024 );
1025 }
1026
1027 HiiCreateOneOfOpCode (
1028 mStartOpCodeHandle,
1029 (EFI_QUESTION_ID) (COM_STOP_BITS_QUESTION_ID + CurrentTerminal),
1030 VARSTORE_ID_BOOT_MAINT,
1031 (UINT16) (COM_STOP_BITS_VAR_OFFSET + CurrentTerminal),
1032 STRING_TOKEN (STR_COM_STOP_BITS),
1033 STRING_TOKEN (STR_COM_STOP_BITS),
1034 0,
1035 EFI_IFR_NUMERIC_SIZE_1,
1036 OptionsOpCodeHandle,
1037 NULL
1038 );
1039
1040 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1041 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1042 ASSERT (OptionsOpCodeHandle != NULL);
1043
1044 for (Index = 0; Index < 4; Index++) {
1045 CheckFlags = 0;
1046 if (Index == 0) {
1047 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1048 }
1049
1050 HiiCreateOneOfOptionOpCode (
1051 OptionsOpCodeHandle,
1052 (EFI_STRING_ID) TerminalType[Index],
1053 CheckFlags,
1054 EFI_IFR_TYPE_NUM_SIZE_8,
1055 Index
1056 );
1057 }
1058
1059 HiiCreateOneOfOpCode (
1060 mStartOpCodeHandle,
1061 (EFI_QUESTION_ID) (COM_TERMINAL_QUESTION_ID + CurrentTerminal),
1062 VARSTORE_ID_BOOT_MAINT,
1063 (UINT16) (COM_TERMINAL_VAR_OFFSET + CurrentTerminal),
1064 STRING_TOKEN (STR_COM_TERMI_TYPE),
1065 STRING_TOKEN (STR_COM_TERMI_TYPE),
1066 0,
1067 EFI_IFR_NUMERIC_SIZE_1,
1068 OptionsOpCodeHandle,
1069 NULL
1070 );
1071
1072 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1073 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1074 ASSERT (OptionsOpCodeHandle != NULL);
1075
1076 for (Index = 0; Index < sizeof (mFlowControlType) / sizeof (mFlowControlType[0]); Index++) {
1077 CheckFlags = 0;
1078 if (Index == 0) {
1079 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1080 }
1081 HiiCreateOneOfOptionOpCode (
1082 OptionsOpCodeHandle,
1083 (EFI_STRING_ID) mFlowControlType[Index],
1084 CheckFlags,
1085 EFI_IFR_TYPE_NUM_SIZE_8,
1086 mFlowControlValue[Index]
1087 );
1088 }
1089
1090 HiiCreateOneOfOpCode (
1091 mStartOpCodeHandle,
1092 (EFI_QUESTION_ID) (COM_FLOWCONTROL_QUESTION_ID + CurrentTerminal),
1093 VARSTORE_ID_BOOT_MAINT,
1094 (UINT16) (COM_FLOWCONTROL_VAR_OFFSET + CurrentTerminal),
1095 STRING_TOKEN (STR_COM_FLOW_CONTROL),
1096 STRING_TOKEN (STR_COM_FLOW_CONTROL),
1097 0,
1098 EFI_IFR_NUMERIC_SIZE_1,
1099 OptionsOpCodeHandle,
1100 NULL
1101 );
1102
1103 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1104
1105 UpdatePageEnd (CallbackData);
1106 }
1107
1108 /**
1109 Dispatch the correct update page function to call based on
1110 the UpdatePageId.
1111
1112 @param UpdatePageId The form ID.
1113 @param CallbackData The BMM context data.
1114
1115 **/
1116 VOID
1117 UpdatePageBody (
1118 IN UINT16 UpdatePageId,
1119 IN BMM_CALLBACK_DATA *CallbackData
1120 )
1121 {
1122 CleanUpPage (UpdatePageId, CallbackData);
1123 switch (UpdatePageId) {
1124 case FORM_CON_IN_ID:
1125 UpdateConsolePage (UpdatePageId, &ConsoleInpMenu, CallbackData);
1126 break;
1127
1128 case FORM_CON_OUT_ID:
1129 UpdateConsolePage (UpdatePageId, &ConsoleOutMenu, CallbackData);
1130 break;
1131
1132 case FORM_CON_ERR_ID:
1133 UpdateConsolePage (UpdatePageId, &ConsoleErrMenu, CallbackData);
1134 break;
1135
1136 case FORM_BOOT_CHG_ID:
1137 UpdateOrderPage (UpdatePageId, &BootOptionMenu, CallbackData);
1138 break;
1139
1140 case FORM_DRV_CHG_ID:
1141 UpdateOrderPage (UpdatePageId, &DriverOptionMenu, CallbackData);
1142 break;
1143
1144 default:
1145 break;
1146 }
1147 }
1148
1149 /**
1150 Create a dynamic page so that Legacy Device boot order
1151 can be set for specified device type.
1152
1153 @param UpdatePageId The form ID. It also spefies the legacy device type.
1154 @param CallbackData The BMM context data.
1155
1156
1157 **/
1158 VOID
1159 UpdateSetLegacyDeviceOrderPage (
1160 IN UINT16 UpdatePageId,
1161 IN BMM_CALLBACK_DATA *CallbackData
1162 )
1163 {
1164 LEGACY_DEV_ORDER_ENTRY *DevOrder;
1165 BM_MENU_OPTION *OptionMenu;
1166 BM_MENU_ENTRY *NewMenuEntry;
1167 EFI_STRING_ID StrRef;
1168 EFI_STRING_ID StrRefHelp;
1169 BBS_TYPE BbsType;
1170 UINTN VarSize;
1171 UINTN Pos;
1172 UINTN Bit;
1173 UINT16 Index;
1174 UINT16 Key;
1175 CHAR16 String[100];
1176 CHAR16 *TypeStr;
1177 CHAR16 *TypeStrHelp;
1178 UINT16 VarDevOrder;
1179 UINT8 *VarData;
1180 UINT8 *LegacyOrder;
1181 UINT8 *OldData;
1182 UINT8 *DisMap;
1183 VOID *OptionsOpCodeHandle;
1184
1185 OptionMenu = NULL;
1186 Key = 0;
1187 StrRef = 0;
1188 StrRefHelp = 0;
1189 TypeStr = NULL;
1190 TypeStrHelp = NULL;
1191 BbsType = BBS_FLOPPY;
1192 LegacyOrder = NULL;
1193 OldData = NULL;
1194 DisMap = NULL;
1195
1196 CallbackData->BmmAskSaveOrNot = TRUE;
1197 UpdatePageStart (CallbackData);
1198
1199 DisMap = ZeroMem (CallbackData->BmmOldFakeNVData.DisableMap, sizeof (CallbackData->BmmOldFakeNVData.DisableMap));
1200
1201 //
1202 // Create oneof option list
1203 //
1204 switch (UpdatePageId) {
1205 case FORM_SET_FD_ORDER_ID:
1206 OptionMenu = (BM_MENU_OPTION *) &LegacyFDMenu;
1207 Key = (UINT16) LEGACY_FD_QUESTION_ID;
1208 TypeStr = STR_FLOPPY;
1209 TypeStrHelp = STR_FLOPPY_HELP;
1210 BbsType = BBS_FLOPPY;
1211 LegacyOrder = CallbackData->BmmFakeNvData.LegacyFD;
1212 OldData = CallbackData->BmmOldFakeNVData.LegacyFD;
1213 break;
1214
1215 case FORM_SET_HD_ORDER_ID:
1216 OptionMenu = (BM_MENU_OPTION *) &LegacyHDMenu;
1217 Key = (UINT16) LEGACY_HD_QUESTION_ID;
1218 TypeStr = STR_HARDDISK;
1219 TypeStrHelp = STR_HARDDISK_HELP;
1220 BbsType = BBS_HARDDISK;
1221 LegacyOrder = CallbackData->BmmFakeNvData.LegacyHD;
1222 OldData = CallbackData->BmmOldFakeNVData.LegacyHD;
1223 break;
1224
1225 case FORM_SET_CD_ORDER_ID:
1226 OptionMenu = (BM_MENU_OPTION *) &LegacyCDMenu;
1227 Key = (UINT16) LEGACY_CD_QUESTION_ID;
1228 TypeStr = STR_CDROM;
1229 TypeStrHelp = STR_CDROM_HELP;
1230 BbsType = BBS_CDROM;
1231 LegacyOrder = CallbackData->BmmFakeNvData.LegacyCD;
1232 OldData = CallbackData->BmmOldFakeNVData.LegacyCD;
1233 break;
1234
1235 case FORM_SET_NET_ORDER_ID:
1236 OptionMenu = (BM_MENU_OPTION *) &LegacyNETMenu;
1237 Key = (UINT16) LEGACY_NET_QUESTION_ID;
1238 TypeStr = STR_NET;
1239 TypeStrHelp = STR_NET_HELP;
1240 BbsType = BBS_EMBED_NETWORK;
1241 LegacyOrder = CallbackData->BmmFakeNvData.LegacyNET;
1242 OldData = CallbackData->BmmOldFakeNVData.LegacyNET;
1243 break;
1244
1245 case FORM_SET_BEV_ORDER_ID:
1246 OptionMenu = (BM_MENU_OPTION *) &LegacyBEVMenu;
1247 Key = (UINT16) LEGACY_BEV_QUESTION_ID;
1248 TypeStr = STR_BEV;
1249 TypeStrHelp = STR_BEV_HELP;
1250 BbsType = BBS_BEV_DEVICE;
1251 LegacyOrder = CallbackData->BmmFakeNvData.LegacyBEV;
1252 OldData = CallbackData->BmmOldFakeNVData.LegacyBEV;
1253 break;
1254
1255 default:
1256 DEBUG ((EFI_D_ERROR, "Invalid command ID for updating page!\n"));
1257 return;
1258 }
1259
1260 CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, OptionMenu);
1261
1262 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1263 ASSERT (OptionsOpCodeHandle != NULL);
1264
1265 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1266 NewMenuEntry = BOpt_GetMenuEntry (OptionMenu, Index);
1267 //
1268 // Create OneOf for each legacy device
1269 //
1270 HiiCreateOneOfOptionOpCode (
1271 OptionsOpCodeHandle,
1272 NewMenuEntry->DisplayStringToken,
1273 0,
1274 EFI_IFR_TYPE_NUM_SIZE_8,
1275 (UINT8) ((BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext)->BbsIndex
1276 );
1277 }
1278
1279 //
1280 // Create OneOf for item "Disabled"
1281 //
1282 HiiCreateOneOfOptionOpCode (
1283 OptionsOpCodeHandle,
1284 STRING_TOKEN (STR_DISABLE_LEGACY_DEVICE),
1285 0,
1286 EFI_IFR_TYPE_NUM_SIZE_8,
1287 0xFF
1288 );
1289
1290 //
1291 // Get Device Order from variable
1292 //
1293 VarData = BdsLibGetVariableAndSize (
1294 VAR_LEGACY_DEV_ORDER,
1295 &gEfiLegacyDevOrderVariableGuid,
1296 &VarSize
1297 );
1298
1299 if (NULL != VarData) {
1300 DevOrder = (LEGACY_DEV_ORDER_ENTRY *) VarData;
1301 while (VarData < VarData + VarSize) {
1302 if (DevOrder->BbsType == BbsType) {
1303 break;
1304 }
1305
1306 VarData += sizeof (BBS_TYPE);
1307 VarData += *(UINT16 *) VarData;
1308 DevOrder = (LEGACY_DEV_ORDER_ENTRY *) VarData;
1309 }
1310 //
1311 // Create oneof tag here for FD/HD/CD #1 #2
1312 //
1313 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1314 //
1315 // Create the string for oneof tag
1316 //
1317 UnicodeSPrint (String, sizeof (String), TypeStr, Index);
1318 StrRef = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1319
1320 UnicodeSPrint (String, sizeof (String), TypeStrHelp, Index);
1321 StrRefHelp = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1322
1323 HiiCreateOneOfOpCode (
1324 mStartOpCodeHandle,
1325 (EFI_QUESTION_ID) (Key + Index),
1326 VARSTORE_ID_BOOT_MAINT,
1327 (UINT16) (Key + Index - CONFIG_OPTION_OFFSET),
1328 StrRef,
1329 StrRefHelp,
1330 EFI_IFR_FLAG_CALLBACK,
1331 EFI_IFR_NUMERIC_SIZE_1,
1332 OptionsOpCodeHandle,
1333 NULL
1334 );
1335
1336 VarDevOrder = *(UINT16 *) ((UINT8 *) DevOrder + sizeof (BBS_TYPE) + sizeof (UINT16) + Index * sizeof (UINT16));
1337
1338 if (0xFF00 == (VarDevOrder & 0xFF00)) {
1339 LegacyOrder[Index] = 0xFF;
1340 Pos = (VarDevOrder & 0xFF) / 8;
1341 Bit = 7 - ((VarDevOrder & 0xFF) % 8);
1342 DisMap[Pos] = (UINT8) (DisMap[Pos] | (UINT8) (1 << Bit));
1343 } else {
1344 LegacyOrder[Index] = (UINT8) (VarDevOrder & 0xFF);
1345 }
1346 }
1347 }
1348
1349 CopyMem (OldData, LegacyOrder, 100);
1350
1351 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1352
1353 UpdatePageEnd (CallbackData);
1354 }
1355
1356
1357 /**
1358 Dispatch the display to the next page based on NewPageId.
1359
1360 @param Private The BMM context data.
1361 @param NewPageId The original page ID.
1362
1363 **/
1364 VOID
1365 UpdatePageId (
1366 BMM_CALLBACK_DATA *Private,
1367 UINT16 NewPageId
1368 )
1369 {
1370 //
1371 // For the question don't impact the page update, just ignore it.
1372 //
1373 if (((NewPageId >= BOOT_OPTION_DEL_QUESTION_ID) && (NewPageId < BOOT_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER)) ||
1374 ((NewPageId >= DRIVER_OPTION_DEL_QUESTION_ID) && (NewPageId < DRIVER_OPTION_DEL_QUESTION_ID + MAX_MENU_NUMBER))) {
1375 return;
1376 }
1377
1378 if ((NewPageId < FILE_OPTION_OFFSET) && (NewPageId >= HANDLE_OPTION_OFFSET)) {
1379 //
1380 // If we select a handle to add driver option, advance to the add handle description page.
1381 //
1382 NewPageId = FORM_DRV_ADD_HANDLE_DESC_ID;
1383 } else if ((NewPageId == KEY_VALUE_SAVE_AND_EXIT) || (NewPageId == KEY_VALUE_NO_SAVE_AND_EXIT)) {
1384 //
1385 // Return to main page after "Save Changes" or "Discard Changes".
1386 //
1387 NewPageId = FORM_MAIN_ID;
1388 } else if ((NewPageId >= TERMINAL_OPTION_OFFSET) && (NewPageId < CONSOLE_OPTION_OFFSET)) {
1389 NewPageId = FORM_CON_COM_SETUP_ID;
1390 }
1391
1392 if ((NewPageId > 0) && (NewPageId < MAXIMUM_FORM_ID)) {
1393 Private->BmmPreviousPageId = Private->BmmCurrentPageId;
1394 Private->BmmCurrentPageId = NewPageId;
1395 }
1396 }
EFI Development Kit II mirror for PVE