]> git.proxmox.com Git - mirror_edk2.git/blob - IntelFrameworkModulePkg/Universal/BdsDxe/BootMaint/UpdatePage.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix some potential buffer overflow issue.
[mirror_edk2.git] / IntelFrameworkModulePkg / Universal / BdsDxe / BootMaint / UpdatePage.c
1 /** @file
2 Dynamically update the pages.
3
4 Copyright (c) 2004 - 2008, 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 #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 HiiCreateGotoOpCode (
103 mStartOpCodeHandle,
104 FORM_MAIN_ID,
105 STRING_TOKEN (STR_SAVE_AND_EXIT),
106 STRING_TOKEN (STR_NULL_STRING),
107 EFI_IFR_FLAG_CALLBACK,
108 KEY_VALUE_SAVE_AND_EXIT
109 );
110 }
111
112 //
113 // Ensure user can return to the main page.
114 //
115 HiiCreateGotoOpCode (
116 mStartOpCodeHandle,
117 FORM_MAIN_ID,
118 STRING_TOKEN (STR_NO_SAVE_AND_EXIT),
119 STRING_TOKEN (STR_NULL_STRING),
120 EFI_IFR_FLAG_CALLBACK,
121 KEY_VALUE_NO_SAVE_AND_EXIT
122 );
123
124 HiiUpdateForm (
125 CallbackData->BmmHiiHandle,
126 &mBootMaintGuid,
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 &mBootMaintGuid,
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 = 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 CallbackData->BmmFakeNvData.BootOptionDel[Index] = 0x00;
267
268 HiiCreateCheckBoxOpCode (
269 mStartOpCodeHandle,
270 (EFI_QUESTION_ID) (BOOT_OPTION_DEL_QUESTION_ID + Index),
271 VARSTORE_ID_BOOT_MAINT,
272 (UINT16) (BOOT_OPTION_DEL_VAR_OFFSET + Index),
273 NewMenuEntry->DisplayStringToken,
274 NewMenuEntry->HelpStringToken,
275 0,
276 0,
277 NULL
278 );
279 }
280
281 UpdatePageEnd (CallbackData);
282 }
283
284 /**
285 Create a lit of driver option from global DriverMenu.
286
287 @param CallbackData The BMM context data.
288
289 **/
290 VOID
291 UpdateDrvAddHandlePage (
292 IN BMM_CALLBACK_DATA *CallbackData
293 )
294 {
295 BM_MENU_ENTRY *NewMenuEntry;
296 UINT16 Index;
297
298 CallbackData->BmmAskSaveOrNot = FALSE;
299
300 UpdatePageStart (CallbackData);
301
302 for (Index = 0; Index < DriverMenu.MenuNumber; Index++) {
303 NewMenuEntry = BOpt_GetMenuEntry (&DriverMenu, Index);
304
305 HiiCreateGotoOpCode (
306 mStartOpCodeHandle,
307 FORM_DRV_ADD_HANDLE_DESC_ID,
308 NewMenuEntry->DisplayStringToken,
309 STRING_TOKEN (STR_NULL_STRING),
310 EFI_IFR_FLAG_CALLBACK,
311 (UINT16) (HANDLE_OPTION_OFFSET + Index)
312 );
313 }
314
315 UpdatePageEnd (CallbackData);
316 }
317
318 /**
319 Create a lit of driver option from global DriverOptionMenu. It
320 allow user to delete the driver option.
321
322 @param CallbackData The BMM context data.
323
324 **/
325 VOID
326 UpdateDrvDelPage (
327 IN BMM_CALLBACK_DATA *CallbackData
328 )
329 {
330 BM_MENU_ENTRY *NewMenuEntry;
331 BM_LOAD_CONTEXT *NewLoadContext;
332 UINT16 Index;
333
334 CallbackData->BmmAskSaveOrNot = TRUE;
335
336 UpdatePageStart (CallbackData);
337
338 CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &DriverOptionMenu);
339
340 ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.DriverOptionDel) / sizeof (CallbackData->BmmFakeNvData.DriverOptionDel[0])));
341 for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
342 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
343
344 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
345 NewLoadContext->Deleted = FALSE;
346 CallbackData->BmmFakeNvData.DriverOptionDel[Index] = 0x00;
347
348 HiiCreateCheckBoxOpCode (
349 mStartOpCodeHandle,
350 (EFI_QUESTION_ID) (DRIVER_OPTION_DEL_QUESTION_ID + Index),
351 VARSTORE_ID_BOOT_MAINT,
352 (UINT16) (DRIVER_OPTION_DEL_VAR_OFFSET + Index),
353 NewMenuEntry->DisplayStringToken,
354 NewMenuEntry->HelpStringToken,
355 0,
356 0,
357 NULL
358 );
359 }
360
361 UpdatePageEnd (CallbackData);
362 }
363
364 /**
365 Prepare the page to allow user to add description for
366 a Driver Option.
367
368 @param CallbackData The BMM context data.
369
370 **/
371 VOID
372 UpdateDriverAddHandleDescPage (
373 IN BMM_CALLBACK_DATA *CallbackData
374 )
375 {
376 BM_MENU_ENTRY *NewMenuEntry;
377
378 CallbackData->BmmFakeNvData.DriverAddActive = 0x01;
379 CallbackData->BmmFakeNvData.DriverAddForceReconnect = 0x00;
380 CallbackData->BmmAskSaveOrNot = TRUE;
381 NewMenuEntry = CallbackData->MenuEntry;
382
383 UpdatePageStart (CallbackData);
384
385 HiiCreateSubTitleOpCode (
386 mStartOpCodeHandle,
387 NewMenuEntry->DisplayStringToken,
388 0,
389 0,
390 0
391 );
392
393 HiiCreateStringOpCode (
394 mStartOpCodeHandle,
395 (EFI_QUESTION_ID) DRV_ADD_HANDLE_DESC_QUESTION_ID,
396 VARSTORE_ID_BOOT_MAINT,
397 DRV_ADD_HANDLE_DESC_VAR_OFFSET,
398 STRING_TOKEN (STR_LOAD_OPTION_DESC),
399 STRING_TOKEN (STR_NULL_STRING),
400 0,
401 0,
402 6,
403 75,
404 NULL
405 );
406
407 HiiCreateCheckBoxOpCode (
408 mStartOpCodeHandle,
409 (EFI_QUESTION_ID) DRV_ADD_RECON_QUESTION_ID,
410 VARSTORE_ID_BOOT_MAINT,
411 DRV_ADD_RECON_VAR_OFFSET,
412 STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
413 STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
414 0,
415 0,
416 NULL
417 );
418
419 HiiCreateStringOpCode (
420 mStartOpCodeHandle,
421 (EFI_QUESTION_ID) DRIVER_ADD_OPTION_QUESTION_ID,
422 VARSTORE_ID_BOOT_MAINT,
423 DRIVER_ADD_OPTION_VAR_OFFSET,
424 STRING_TOKEN (STR_OPTIONAL_DATA),
425 STRING_TOKEN (STR_NULL_STRING),
426 0,
427 0,
428 6,
429 75,
430 NULL
431 );
432
433 UpdatePageEnd (CallbackData);
434 }
435
436 /**
437 Update console page.
438
439 @param UpdatePageId The form ID to be updated.
440 @param ConsoleMenu The console menu list.
441 @param CallbackData The BMM context data.
442
443 **/
444 VOID
445 UpdateConsolePage (
446 IN UINT16 UpdatePageId,
447 IN BM_MENU_OPTION *ConsoleMenu,
448 IN BMM_CALLBACK_DATA *CallbackData
449 )
450 {
451 BM_MENU_ENTRY *NewMenuEntry;
452 BM_CONSOLE_CONTEXT *NewConsoleContext;
453 BM_TERMINAL_CONTEXT *NewTerminalContext;
454 UINT16 Index;
455 UINT16 Index2;
456 UINT8 CheckFlags;
457
458 CallbackData->BmmAskSaveOrNot = TRUE;
459
460 UpdatePageStart (CallbackData);
461
462 for (Index = 0; ((Index < ConsoleMenu->MenuNumber) && \
463 (Index < (sizeof (CallbackData->BmmFakeNvData.ConsoleCheck) / sizeof (UINT8)))) ; Index++) {
464 NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index);
465 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
466 CheckFlags = 0;
467 if (NewConsoleContext->IsActive) {
468 CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
469 CallbackData->BmmFakeNvData.ConsoleCheck[Index] = TRUE;
470 } else {
471 CallbackData->BmmFakeNvData.ConsoleCheck[Index] = FALSE;
472 }
473
474 HiiCreateCheckBoxOpCode (
475 mStartOpCodeHandle,
476 (EFI_QUESTION_ID) (CON_DEVICE_QUESTION_ID + Index),
477 VARSTORE_ID_BOOT_MAINT,
478 (UINT16) (CON_DEVICE_VAR_OFFSET + Index),
479 NewMenuEntry->DisplayStringToken,
480 NewMenuEntry->HelpStringToken,
481 0,
482 CheckFlags,
483 NULL
484 );
485 }
486
487 for (Index2 = 0; ((Index2 < TerminalMenu.MenuNumber) && \
488 (Index2 < (sizeof (CallbackData->BmmFakeNvData.ConsoleCheck) / sizeof (UINT8)))); Index2++) {
489 CheckFlags = 0;
490 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index2);
491 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
492
493 if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
494 ((NewTerminalContext->IsConOut != 0) && (UpdatePageId == FORM_CON_OUT_ID)) ||
495 ((NewTerminalContext->IsStdErr != 0) && (UpdatePageId == FORM_CON_ERR_ID))
496 ) {
497 CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
498 CallbackData->BmmFakeNvData.ConsoleCheck[Index] = TRUE;
499 } else {
500 CallbackData->BmmFakeNvData.ConsoleCheck[Index] = FALSE;
501 }
502
503 HiiCreateCheckBoxOpCode (
504 mStartOpCodeHandle,
505 (EFI_QUESTION_ID) (CON_DEVICE_QUESTION_ID + Index),
506 VARSTORE_ID_BOOT_MAINT,
507 (UINT16) (CON_DEVICE_VAR_OFFSET + Index),
508 NewMenuEntry->DisplayStringToken,
509 NewMenuEntry->HelpStringToken,
510 0,
511 CheckFlags,
512 NULL
513 );
514
515 Index++;
516 }
517
518 UpdatePageEnd (CallbackData);
519 }
520
521 /**
522 Update the page's NV Map if user has changed the order
523 a list. This list can be Boot Order or Driver Order.
524
525 @param UpdatePageId The form ID to be updated.
526 @param OptionMenu The new list.
527 @param CallbackData The BMM context data.
528
529 **/
530 VOID
531 UpdateOrderPage (
532 IN UINT16 UpdatePageId,
533 IN BM_MENU_OPTION *OptionMenu,
534 IN BMM_CALLBACK_DATA *CallbackData
535 )
536 {
537 BM_MENU_ENTRY *NewMenuEntry;
538 UINT16 Index;
539 VOID *OptionsOpCodeHandle;
540
541 CallbackData->BmmAskSaveOrNot = TRUE;
542
543 UpdatePageStart (CallbackData);
544
545 CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, OptionMenu);
546
547 ZeroMem (CallbackData->BmmFakeNvData.OptionOrder, 100);
548
549 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
550 ASSERT (OptionsOpCodeHandle != NULL);
551
552 for (Index = 0; ((Index < OptionMenu->MenuNumber) && \
553 (Index < (sizeof (CallbackData->BmmFakeNvData.OptionOrder) / sizeof (UINT8))))); Index++) {
554 NewMenuEntry = BOpt_GetMenuEntry (OptionMenu, Index);
555 HiiCreateOneOfOptionOpCode (
556 OptionsOpCodeHandle,
557 NewMenuEntry->DisplayStringToken,
558 0,
559 EFI_IFR_NUMERIC_SIZE_1,
560 (UINT8) (NewMenuEntry->OptionNumber + 1)
561 );
562 CallbackData->BmmFakeNvData.OptionOrder[Index] = (UINT8) (NewMenuEntry->OptionNumber + 1);
563 }
564
565 if (OptionMenu->MenuNumber > 0) {
566 HiiCreateOrderedListOpCode (
567 mStartOpCodeHandle, // Container for dynamic created opcodes
568 (EFI_QUESTION_ID) OPTION_ORDER_QUESTION_ID, // Question ID
569 VARSTORE_ID_BOOT_MAINT, // VarStore ID
570 OPTION_ORDER_VAR_OFFSET, // Offset in Buffer Storage
571 STRING_TOKEN (STR_CHANGE_ORDER), // Question prompt text
572 STRING_TOKEN (STR_CHANGE_ORDER), // Question help text
573 0, // Question flag
574 0, // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
575 EFI_IFR_NUMERIC_SIZE_1, // Data type of Question value
576 100, // Maximum container
577 OptionsOpCodeHandle, // Option Opcode list
578 NULL // Default Opcode is NULL
579 );
580 }
581
582 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
583
584 UpdatePageEnd (CallbackData);
585
586 CopyMem (
587 CallbackData->BmmOldFakeNVData.OptionOrder,
588 CallbackData->BmmFakeNvData.OptionOrder,
589 100
590 );
591 }
592
593 /**
594 Create the dynamic page to allow user to set
595 the "BootNext" value.
596
597 @param CallbackData The BMM context data.
598
599 **/
600 VOID
601 UpdateBootNextPage (
602 IN BMM_CALLBACK_DATA *CallbackData
603 )
604 {
605 BM_MENU_ENTRY *NewMenuEntry;
606 BM_LOAD_CONTEXT *NewLoadContext;
607 UINTN NumberOfOptions;
608 UINT16 Index;
609 VOID *OptionsOpCodeHandle;
610
611 NumberOfOptions = BootOptionMenu.MenuNumber;
612 CallbackData->BmmAskSaveOrNot = TRUE;
613
614 UpdatePageStart (CallbackData);
615 CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, &BootOptionMenu);
616
617 if (NumberOfOptions > 0) {
618 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
619 ASSERT (OptionsOpCodeHandle != NULL);
620
621 CallbackData->BmmFakeNvData.BootNext = (UINT16) (BootOptionMenu.MenuNumber);
622
623 for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
624 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
625 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
626
627 if (NewLoadContext->IsBootNext) {
628 HiiCreateOneOfOptionOpCode (
629 OptionsOpCodeHandle,
630 NewMenuEntry->DisplayStringToken,
631 EFI_IFR_OPTION_DEFAULT,
632 EFI_IFR_NUMERIC_SIZE_2,
633 Index
634 );
635 CallbackData->BmmFakeNvData.BootNext = Index;
636 } else {
637 HiiCreateOneOfOptionOpCode (
638 OptionsOpCodeHandle,
639 NewMenuEntry->DisplayStringToken,
640 0,
641 EFI_IFR_NUMERIC_SIZE_2,
642 Index
643 );
644 }
645 }
646
647 if (CallbackData->BmmFakeNvData.BootNext == Index) {
648 HiiCreateOneOfOptionOpCode (
649 OptionsOpCodeHandle,
650 STRING_TOKEN (STR_NONE),
651 EFI_IFR_OPTION_DEFAULT,
652 EFI_IFR_NUMERIC_SIZE_2,
653 Index
654 );
655 } else {
656 HiiCreateOneOfOptionOpCode (
657 OptionsOpCodeHandle,
658 STRING_TOKEN (STR_NONE),
659 0,
660 EFI_IFR_NUMERIC_SIZE_2,
661 Index
662 );
663 }
664
665 HiiCreateOneOfOpCode (
666 mStartOpCodeHandle,
667 (EFI_QUESTION_ID) BOOT_NEXT_QUESTION_ID,
668 VARSTORE_ID_BOOT_MAINT,
669 BOOT_NEXT_VAR_OFFSET,
670 STRING_TOKEN (STR_BOOT_NEXT),
671 STRING_TOKEN (STR_BOOT_NEXT_HELP),
672 0,
673 EFI_IFR_NUMERIC_SIZE_2,
674 OptionsOpCodeHandle,
675 NULL
676 );
677
678 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
679 }
680
681 UpdatePageEnd (CallbackData);
682 }
683
684 /**
685 Create the dynamic page to allow user to set the "TimeOut" value.
686
687 @param CallbackData The BMM context data.
688
689 **/
690 VOID
691 UpdateTimeOutPage (
692 IN BMM_CALLBACK_DATA *CallbackData
693 )
694 {
695 UINT16 BootTimeOut;
696 VOID *DefaultOpCodeHandle;
697
698 CallbackData->BmmAskSaveOrNot = TRUE;
699
700 UpdatePageStart (CallbackData);
701
702 BootTimeOut = PcdGet16 (PcdPlatformBootTimeOut);
703
704 DefaultOpCodeHandle = HiiAllocateOpCodeHandle ();
705 ASSERT (DefaultOpCodeHandle != NULL);
706 HiiCreateDefaultOpCode (DefaultOpCodeHandle, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_NUMERIC_SIZE_2, BootTimeOut);
707
708 HiiCreateNumericOpCode (
709 mStartOpCodeHandle,
710 (EFI_QUESTION_ID) BOOT_TIME_OUT_QUESTION_ID,
711 VARSTORE_ID_BOOT_MAINT,
712 BOOT_TIME_OUT_VAR_OFFSET,
713 STRING_TOKEN (STR_NUM_AUTO_BOOT),
714 STRING_TOKEN (STR_HLP_AUTO_BOOT),
715 0,
716 EFI_IFR_NUMERIC_SIZE_2 | EFI_IFR_DISPLAY_UINT_DEC,
717 0,
718 65535,
719 0,
720 DefaultOpCodeHandle
721 );
722
723 HiiFreeOpCodeHandle (DefaultOpCodeHandle);
724
725 CallbackData->BmmFakeNvData.BootTimeOut = BootTimeOut;
726
727 UpdatePageEnd (CallbackData);
728 }
729
730 /**
731 Refresh the text mode page.
732
733 @param CallbackData The BMM context data.
734
735 **/
736 VOID
737 UpdateConModePage (
738 IN BMM_CALLBACK_DATA *CallbackData
739 )
740 {
741 UINTN Mode;
742 UINTN Index;
743 UINTN Col;
744 UINTN Row;
745 CHAR16 RowString[50];
746 CHAR16 ModeString[50];
747 UINTN TempStringLen;
748 UINTN MaxMode;
749 UINTN ValidMode;
750 EFI_STRING_ID *ModeToken;
751 EFI_STATUS Status;
752 VOID *OptionsOpCodeHandle;
753 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut;
754
755 ConOut = gST->ConOut;
756 Index = 0;
757 ValidMode = 0;
758 MaxMode = (UINTN) (ConOut->Mode->MaxMode);
759
760 CallbackData->BmmAskSaveOrNot = TRUE;
761
762 UpdatePageStart (CallbackData);
763
764 //
765 // Check valid mode
766 //
767 for (Mode = 0; Mode < MaxMode; Mode++) {
768 Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
769 if (EFI_ERROR (Status)) {
770 continue;
771 }
772 ValidMode++;
773 }
774
775 if (ValidMode == 0) {
776 return;
777 }
778
779 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
780 ASSERT (OptionsOpCodeHandle != NULL);
781
782 ModeToken = AllocateZeroPool (sizeof (EFI_STRING_ID) * ValidMode);
783 ASSERT(ModeToken != NULL);
784
785 //
786 // Determin which mode should be the first entry in menu
787 //
788 GetConsoleOutMode (CallbackData);
789
790 //
791 // Build text mode options
792 //
793 for (Mode = 0; Mode < MaxMode; Mode++) {
794 Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
795 if (EFI_ERROR (Status)) {
796 continue;
797 }
798
799 //
800 // Build mode string Column x Row
801 //
802 TempStringLen = UnicodeValueToString (ModeString, 0, Col, 0);
803 ASSERT ((TempStringLen + StrLen (L" x ")) < (sizeof (ModeString) / sizeof (ModeString[0])));
804 StrCat (ModeString, L" x ");
805 TempStringLen = UnicodeValueToString (RowString, 0, Row, 0);
806 ASSERT ((StrLen (ModeString) + TempStringLen) < (sizeof (ModeString) / sizeof (ModeString[0])));
807 StrCat (ModeString, RowString);
808
809 ModeToken[Index] = HiiSetString (CallbackData->BmmHiiHandle, 0, ModeString, NULL);
810
811 if (Mode == CallbackData->BmmFakeNvData.ConsoleOutMode) {
812 HiiCreateOneOfOptionOpCode (
813 OptionsOpCodeHandle,
814 ModeToken[Index],
815 EFI_IFR_OPTION_DEFAULT,
816 EFI_IFR_NUMERIC_SIZE_2,
817 (UINT16) Mode
818 );
819 } else {
820 HiiCreateOneOfOptionOpCode (
821 OptionsOpCodeHandle,
822 ModeToken[Index],
823 0,
824 EFI_IFR_NUMERIC_SIZE_2,
825 (UINT16) Mode
826 );
827 }
828 Index++;
829 }
830
831 HiiCreateOneOfOpCode (
832 mStartOpCodeHandle,
833 (EFI_QUESTION_ID) CON_MODE_QUESTION_ID,
834 VARSTORE_ID_BOOT_MAINT,
835 CON_MODE_VAR_OFFSET,
836 STRING_TOKEN (STR_CON_MODE_SETUP),
837 STRING_TOKEN (STR_CON_MODE_SETUP),
838 EFI_IFR_FLAG_RESET_REQUIRED,
839 EFI_IFR_NUMERIC_SIZE_2,
840 OptionsOpCodeHandle,
841 NULL
842 );
843
844 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
845 FreePool (ModeToken);
846
847 UpdatePageEnd (CallbackData);
848 }
849
850 /**
851 Create the dynamic page which allows user to set the property such as Baud Rate, Data Bits,
852 Parity, Stop Bits, Terminal Type.
853
854 @param CallbackData The BMM context data.
855
856 **/
857 VOID
858 UpdateTerminalPage (
859 IN BMM_CALLBACK_DATA *CallbackData
860 )
861 {
862 UINT8 Index;
863 UINT8 CheckFlags;
864 BM_MENU_ENTRY *NewMenuEntry;
865 BM_TERMINAL_CONTEXT *NewTerminalContext;
866 VOID *OptionsOpCodeHandle;
867
868 CallbackData->BmmAskSaveOrNot = TRUE;
869
870 UpdatePageStart (CallbackData);
871
872 NewMenuEntry = BOpt_GetMenuEntry (
873 &TerminalMenu,
874 CallbackData->CurrentTerminal
875 );
876
877 if (NewMenuEntry == NULL) {
878 return ;
879 }
880
881 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
882
883 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
884 ASSERT (OptionsOpCodeHandle != NULL);
885
886 for (Index = 0; Index < sizeof (BaudRateList) / sizeof (BaudRateList [0]); Index++) {
887 CheckFlags = 0;
888 if (NewTerminalContext->BaudRate == (UINT64) (BaudRateList[Index].Value)) {
889 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
890 NewTerminalContext->BaudRateIndex = Index;
891 CallbackData->BmmFakeNvData.COMBaudRate = NewTerminalContext->BaudRateIndex;
892 }
893
894 HiiCreateOneOfOptionOpCode (
895 OptionsOpCodeHandle,
896 BaudRateList[Index].StringToken,
897 CheckFlags,
898 EFI_IFR_NUMERIC_SIZE_1,
899 Index
900 );
901 }
902
903 HiiCreateOneOfOpCode (
904 mStartOpCodeHandle,
905 (EFI_QUESTION_ID) COM_BAUD_RATE_QUESTION_ID,
906 VARSTORE_ID_BOOT_MAINT,
907 COM_BAUD_RATE_VAR_OFFSET,
908 STRING_TOKEN (STR_COM_BAUD_RATE),
909 STRING_TOKEN (STR_COM_BAUD_RATE),
910 0,
911 EFI_IFR_NUMERIC_SIZE_1,
912 OptionsOpCodeHandle,
913 NULL
914 );
915
916 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
917 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
918 ASSERT (OptionsOpCodeHandle != NULL);
919
920 for (Index = 0; Index < sizeof (DataBitsList) / sizeof (DataBitsList[0]); Index++) {
921 CheckFlags = 0;
922
923 if (NewTerminalContext->DataBits == DataBitsList[Index].Value) {
924 NewTerminalContext->DataBitsIndex = Index;
925 CallbackData->BmmFakeNvData.COMDataRate = NewTerminalContext->DataBitsIndex;
926 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
927 }
928
929 HiiCreateOneOfOptionOpCode (
930 OptionsOpCodeHandle,
931 DataBitsList[Index].StringToken,
932 CheckFlags,
933 EFI_IFR_NUMERIC_SIZE_1,
934 Index
935 );
936 }
937
938 HiiCreateOneOfOpCode (
939 mStartOpCodeHandle,
940 (EFI_QUESTION_ID) COM_DATA_RATE_QUESTION_ID,
941 VARSTORE_ID_BOOT_MAINT,
942 COM_DATA_RATE_VAR_OFFSET,
943 STRING_TOKEN (STR_COM_DATA_BITS),
944 STRING_TOKEN (STR_COM_DATA_BITS),
945 0,
946 EFI_IFR_NUMERIC_SIZE_1,
947 OptionsOpCodeHandle,
948 NULL
949 );
950
951 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
952 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
953 ASSERT (OptionsOpCodeHandle != NULL);
954
955 for (Index = 0; Index < sizeof (ParityList) / sizeof (ParityList[0]); Index++) {
956 CheckFlags = 0;
957 if (NewTerminalContext->Parity == ParityList[Index].Value) {
958 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
959 NewTerminalContext->ParityIndex = (UINT8) Index;
960 CallbackData->BmmFakeNvData.COMParity = NewTerminalContext->ParityIndex;
961 }
962
963 HiiCreateOneOfOptionOpCode (
964 OptionsOpCodeHandle,
965 ParityList[Index].StringToken,
966 CheckFlags,
967 EFI_IFR_NUMERIC_SIZE_1,
968 Index
969 );
970 }
971
972 HiiCreateOneOfOpCode (
973 mStartOpCodeHandle,
974 (EFI_QUESTION_ID) COM_PARITY_QUESTION_ID,
975 VARSTORE_ID_BOOT_MAINT,
976 COM_PARITY_VAR_OFFSET,
977 STRING_TOKEN (STR_COM_PARITY),
978 STRING_TOKEN (STR_COM_PARITY),
979 0,
980 EFI_IFR_NUMERIC_SIZE_1,
981 OptionsOpCodeHandle,
982 NULL
983 );
984
985 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
986 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
987 ASSERT (OptionsOpCodeHandle != NULL);
988
989 for (Index = 0; Index < sizeof (StopBitsList) / sizeof (StopBitsList[0]); Index++) {
990 CheckFlags = 0;
991 if (NewTerminalContext->StopBits == StopBitsList[Index].Value) {
992 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
993 NewTerminalContext->StopBitsIndex = (UINT8) Index;
994 CallbackData->BmmFakeNvData.COMStopBits = NewTerminalContext->StopBitsIndex;
995 }
996
997 HiiCreateOneOfOptionOpCode (
998 OptionsOpCodeHandle,
999 StopBitsList[Index].StringToken,
1000 CheckFlags,
1001 EFI_IFR_NUMERIC_SIZE_1,
1002 Index
1003 );
1004 }
1005
1006 HiiCreateOneOfOpCode (
1007 mStartOpCodeHandle,
1008 (EFI_QUESTION_ID) COM_STOP_BITS_QUESTION_ID,
1009 VARSTORE_ID_BOOT_MAINT,
1010 COM_STOP_BITS_VAR_OFFSET,
1011 STRING_TOKEN (STR_COM_STOP_BITS),
1012 STRING_TOKEN (STR_COM_STOP_BITS),
1013 0,
1014 EFI_IFR_NUMERIC_SIZE_1,
1015 OptionsOpCodeHandle,
1016 NULL
1017 );
1018
1019 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1020 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1021 ASSERT (OptionsOpCodeHandle != NULL);
1022
1023 for (Index = 0; Index < 4; Index++) {
1024 CheckFlags = 0;
1025 if (NewTerminalContext->TerminalType == Index) {
1026 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
1027 CallbackData->BmmFakeNvData.COMTerminalType = NewTerminalContext->TerminalType;
1028 }
1029
1030 HiiCreateOneOfOptionOpCode (
1031 OptionsOpCodeHandle,
1032 (EFI_STRING_ID) TerminalType[Index],
1033 CheckFlags,
1034 EFI_IFR_NUMERIC_SIZE_1,
1035 Index
1036 );
1037 }
1038
1039 HiiCreateOneOfOpCode (
1040 mStartOpCodeHandle,
1041 (EFI_QUESTION_ID) COM_TERMINAL_QUESTION_ID,
1042 VARSTORE_ID_BOOT_MAINT,
1043 COM_TERMINAL_VAR_OFFSET,
1044 STRING_TOKEN (STR_COM_TERMI_TYPE),
1045 STRING_TOKEN (STR_COM_TERMI_TYPE),
1046 0,
1047 EFI_IFR_NUMERIC_SIZE_1,
1048 OptionsOpCodeHandle,
1049 NULL
1050 );
1051
1052 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1053
1054 UpdatePageEnd (CallbackData);
1055 }
1056
1057 /**
1058 Dispatch the correct update page function to call based on
1059 the UpdatePageId.
1060
1061 @param UpdatePageId The form ID.
1062 @param CallbackData The BMM context data.
1063
1064 **/
1065 VOID
1066 UpdatePageBody (
1067 IN UINT16 UpdatePageId,
1068 IN BMM_CALLBACK_DATA *CallbackData
1069 )
1070 {
1071 CleanUpPage (UpdatePageId, CallbackData);
1072 switch (UpdatePageId) {
1073 case FORM_CON_IN_ID:
1074 UpdateConsolePage (UpdatePageId, &ConsoleInpMenu, CallbackData);
1075 break;
1076
1077 case FORM_CON_OUT_ID:
1078 UpdateConsolePage (UpdatePageId, &ConsoleOutMenu, CallbackData);
1079 break;
1080
1081 case FORM_CON_ERR_ID:
1082 UpdateConsolePage (UpdatePageId, &ConsoleErrMenu, CallbackData);
1083 break;
1084
1085 case FORM_BOOT_CHG_ID:
1086 UpdateOrderPage (UpdatePageId, &BootOptionMenu, CallbackData);
1087 break;
1088
1089 case FORM_DRV_CHG_ID:
1090 UpdateOrderPage (UpdatePageId, &DriverOptionMenu, CallbackData);
1091 break;
1092
1093 default:
1094 break;
1095 }
1096 }
1097
1098 /**
1099 Get the index number (#### in Boot####) for the boot option pointed to a BBS legacy device type
1100 specified by DeviceType.
1101
1102 @param DeviceType The legacy device type. It can be floppy, network, harddisk, cdrom,
1103 etc.
1104 @param OptionIndex Returns the index number (#### in Boot####).
1105 @param OptionSize Return the size of the Boot### variable.
1106
1107 **/
1108 VOID *
1109 GetLegacyBootOptionVar (
1110 IN UINTN DeviceType,
1111 OUT UINTN *OptionIndex,
1112 OUT UINTN *OptionSize
1113 )
1114 {
1115 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
1116 VOID *OptionBuffer;
1117 UINTN OrderSize;
1118 UINTN Index;
1119 UINT16 *OrderBuffer;
1120 CHAR16 StrTemp[100];
1121 UINT16 FilePathSize;
1122 UINT8 *Ptr;
1123 UINT8 *OptionalData;
1124
1125 //
1126 // Get Boot Option number from the size of BootOrder
1127 //
1128 OrderBuffer = BdsLibGetVariableAndSize (
1129 L"BootOrder",
1130 &gEfiGlobalVariableGuid,
1131 &OrderSize
1132 );
1133
1134 if (OrderBuffer == NULL) {
1135 return NULL;
1136 }
1137
1138 for (Index = 0; Index < OrderSize / sizeof (UINT16); Index++) {
1139 UnicodeSPrint (StrTemp, 100, L"Boot%04x", OrderBuffer[Index]);
1140 OptionBuffer = BdsLibGetVariableAndSize (
1141 StrTemp,
1142 &gEfiGlobalVariableGuid,
1143 OptionSize
1144 );
1145 if (NULL == OptionBuffer) {
1146 continue;
1147 }
1148
1149 Ptr = (UINT8 *) OptionBuffer;
1150 Ptr += sizeof (UINT32);
1151
1152 FilePathSize = *(UINT16 *) Ptr;
1153 Ptr += sizeof (UINT16);
1154
1155 Ptr += StrSize ((CHAR16 *) Ptr);
1156
1157 //
1158 // Now Ptr point to Device Path
1159 //
1160 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
1161 Ptr += FilePathSize;
1162
1163 //
1164 // Now Ptr point to Optional Data
1165 //
1166 OptionalData = Ptr;
1167
1168 if ((DeviceType == ((BBS_TABLE *) OptionalData)->DeviceType) &&
1169 (BBS_DEVICE_PATH == DevicePath->Type) &&
1170 (BBS_BBS_DP == DevicePath->SubType)
1171 ) {
1172 *OptionIndex = OrderBuffer[Index];
1173 FreePool (OrderBuffer);
1174 return OptionBuffer;
1175 } else {
1176 FreePool (OptionBuffer);
1177 }
1178 }
1179
1180 FreePool (OrderBuffer);
1181 return NULL;
1182 }
1183
1184 /**
1185 Create a dynamic page so that Legacy Device boot order
1186 can be set for specified device type.
1187
1188 @param UpdatePageId The form ID. It also spefies the legacy device type.
1189 @param CallbackData The BMM context data.
1190
1191
1192 **/
1193 VOID
1194 UpdateSetLegacyDeviceOrderPage (
1195 IN UINT16 UpdatePageId,
1196 IN BMM_CALLBACK_DATA *CallbackData
1197 )
1198 {
1199 BM_LEGACY_DEV_ORDER_CONTEXT *DevOrder;
1200 BM_MENU_OPTION *OptionMenu;
1201 BM_MENU_ENTRY *NewMenuEntry;
1202 EFI_STRING_ID StrRef;
1203 EFI_STRING_ID StrRefHelp;
1204 BBS_TYPE BbsType;
1205 UINTN VarSize;
1206 UINTN Pos;
1207 UINTN Bit;
1208 UINT16 Index;
1209 UINT16 Key;
1210 CHAR16 String[100];
1211 CHAR16 *TypeStr;
1212 CHAR16 *TypeStrHelp;
1213 UINT16 VarDevOrder;
1214 UINT8 *VarData;
1215 UINT8 *LegacyOrder;
1216 UINT8 *OldData;
1217 UINT8 *DisMap;
1218 VOID *OptionsOpCodeHandle;
1219
1220 OptionMenu = NULL;
1221 Key = 0;
1222 StrRef = 0;
1223 StrRefHelp = 0;
1224 TypeStr = NULL;
1225 TypeStrHelp = NULL;
1226 BbsType = BBS_FLOPPY;
1227 LegacyOrder = NULL;
1228 OldData = NULL;
1229 DisMap = NULL;
1230
1231 CallbackData->BmmAskSaveOrNot = TRUE;
1232 UpdatePageStart (CallbackData);
1233
1234 DisMap = CallbackData->BmmOldFakeNVData.DisableMap;
1235
1236 SetMem (DisMap, 32, 0);
1237 //
1238 // Create oneof option list
1239 //
1240 switch (UpdatePageId) {
1241 case FORM_SET_FD_ORDER_ID:
1242 OptionMenu = (BM_MENU_OPTION *) &LegacyFDMenu;
1243 Key = (UINT16) LEGACY_FD_QUESTION_ID;
1244 TypeStr = STR_FLOPPY;
1245 TypeStrHelp = STR_FLOPPY_HELP;
1246 BbsType = BBS_FLOPPY;
1247 LegacyOrder = CallbackData->BmmFakeNvData.LegacyFD;
1248 OldData = CallbackData->BmmOldFakeNVData.LegacyFD;
1249 break;
1250
1251 case FORM_SET_HD_ORDER_ID:
1252 OptionMenu = (BM_MENU_OPTION *) &LegacyHDMenu;
1253 Key = (UINT16) LEGACY_HD_QUESTION_ID;
1254 TypeStr = STR_HARDDISK;
1255 TypeStrHelp = STR_HARDDISK_HELP;
1256 BbsType = BBS_HARDDISK;
1257 LegacyOrder = CallbackData->BmmFakeNvData.LegacyHD;
1258 OldData = CallbackData->BmmOldFakeNVData.LegacyHD;
1259 break;
1260
1261 case FORM_SET_CD_ORDER_ID:
1262 OptionMenu = (BM_MENU_OPTION *) &LegacyCDMenu;
1263 Key = (UINT16) LEGACY_CD_QUESTION_ID;
1264 TypeStr = STR_CDROM;
1265 TypeStrHelp = STR_CDROM_HELP;
1266 BbsType = BBS_CDROM;
1267 LegacyOrder = CallbackData->BmmFakeNvData.LegacyCD;
1268 OldData = CallbackData->BmmOldFakeNVData.LegacyCD;
1269 break;
1270
1271 case FORM_SET_NET_ORDER_ID:
1272 OptionMenu = (BM_MENU_OPTION *) &LegacyNETMenu;
1273 Key = (UINT16) LEGACY_NET_QUESTION_ID;
1274 TypeStr = STR_NET;
1275 TypeStrHelp = STR_NET_HELP;
1276 BbsType = BBS_EMBED_NETWORK;
1277 LegacyOrder = CallbackData->BmmFakeNvData.LegacyNET;
1278 OldData = CallbackData->BmmOldFakeNVData.LegacyNET;
1279 break;
1280
1281 case FORM_SET_BEV_ORDER_ID:
1282 OptionMenu = (BM_MENU_OPTION *) &LegacyBEVMenu;
1283 Key = (UINT16) LEGACY_BEV_QUESTION_ID;
1284 TypeStr = STR_BEV;
1285 TypeStrHelp = STR_BEV_HELP;
1286 BbsType = BBS_BEV_DEVICE;
1287 LegacyOrder = CallbackData->BmmFakeNvData.LegacyBEV;
1288 OldData = CallbackData->BmmOldFakeNVData.LegacyBEV;
1289 break;
1290
1291 default:
1292 DEBUG ((EFI_D_ERROR, "Invalid command ID for updating page!\n"));
1293 return;
1294 }
1295
1296 CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, OptionMenu);
1297
1298 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
1299 ASSERT (OptionsOpCodeHandle != NULL);
1300
1301 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1302 NewMenuEntry = BOpt_GetMenuEntry (OptionMenu, Index);
1303
1304 if (Index == 0) {
1305 HiiCreateOneOfOptionOpCode (
1306 OptionsOpCodeHandle,
1307 NewMenuEntry->DisplayStringToken,
1308 EFI_IFR_OPTION_DEFAULT,
1309 EFI_IFR_NUMERIC_SIZE_1,
1310 (UINT8) ((BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext)->Index
1311 );
1312 }
1313
1314 HiiCreateOneOfOptionOpCode (
1315 OptionsOpCodeHandle,
1316 NewMenuEntry->DisplayStringToken,
1317 0,
1318 EFI_IFR_NUMERIC_SIZE_1,
1319 (UINT8) ((BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext)->Index
1320 );
1321 }
1322
1323 //
1324 // for item "Disabled"
1325 //
1326 HiiCreateOneOfOptionOpCode (
1327 OptionsOpCodeHandle,
1328 STRING_TOKEN (STR_DISABLE_LEGACY_DEVICE),
1329 0,
1330 EFI_IFR_NUMERIC_SIZE_1,
1331 0xFF
1332 );
1333
1334 //
1335 // Get Device Order from variable
1336 //
1337 VarData = BdsLibGetVariableAndSize (
1338 VAR_LEGACY_DEV_ORDER,
1339 &EfiLegacyDevOrderGuid,
1340 &VarSize
1341 );
1342
1343 if (NULL != VarData) {
1344 DevOrder = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData;
1345 while (VarData < VarData + VarSize) {
1346 if (DevOrder->BbsType == BbsType) {
1347 break;
1348 }
1349
1350 VarData += sizeof (BBS_TYPE);
1351 VarData += *(UINT16 *) VarData;
1352 DevOrder = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData;
1353 }
1354 //
1355 // Create oneof tag here for FD/HD/CD #1 #2
1356 //
1357 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1358 //
1359 // Create the string for oneof tag
1360 //
1361 UnicodeSPrint (String, sizeof (String), TypeStr, Index);
1362 StrRef = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1363
1364 UnicodeSPrint (String, sizeof (String), TypeStrHelp, Index);
1365 StrRefHelp = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1366
1367 HiiCreateOneOfOpCode (
1368 mStartOpCodeHandle,
1369 (EFI_QUESTION_ID) (Key + Index),
1370 VARSTORE_ID_BOOT_MAINT,
1371 (UINT16) (Key + Index - CONFIG_OPTION_OFFSET),
1372 StrRef,
1373 StrRefHelp,
1374 EFI_IFR_FLAG_CALLBACK,
1375 EFI_IFR_NUMERIC_SIZE_1,
1376 OptionsOpCodeHandle,
1377 NULL
1378 );
1379
1380 VarDevOrder = *(UINT16 *) ((UINT8 *) DevOrder + sizeof (BBS_TYPE) + sizeof (UINT16) + Index * sizeof (UINT16));
1381
1382 if (0xFF00 == (VarDevOrder & 0xFF00)) {
1383 LegacyOrder[Index] = 0xFF;
1384 Pos = (VarDevOrder & 0xFF) / 8;
1385 Bit = 7 - ((VarDevOrder & 0xFF) % 8);
1386 DisMap[Pos] = (UINT8) (DisMap[Pos] | (UINT8) (1 << Bit));
1387 } else {
1388 LegacyOrder[Index] = (UINT8) (VarDevOrder & 0xFF);
1389 }
1390 }
1391 }
1392
1393 CopyMem (OldData, LegacyOrder, 100);
1394
1395 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1396
1397 UpdatePageEnd (CallbackData);
1398 }
1399
1400 /**
1401 Dispatch the display to the next page based on NewPageId.
1402
1403 @param Private The BMM context data.
1404 @param NewPageId The original page ID.
1405
1406 **/
1407 VOID
1408 UpdatePageId (
1409 BMM_CALLBACK_DATA *Private,
1410 UINT16 NewPageId
1411 )
1412 {
1413 if ((NewPageId < FILE_OPTION_OFFSET) && (NewPageId >= HANDLE_OPTION_OFFSET)) {
1414 //
1415 // If we select a handle to add driver option, advance to the add handle description page.
1416 //
1417 NewPageId = FORM_DRV_ADD_HANDLE_DESC_ID;
1418 } else if ((NewPageId == KEY_VALUE_SAVE_AND_EXIT) || (NewPageId == KEY_VALUE_NO_SAVE_AND_EXIT)) {
1419 //
1420 // Return to main page after "Save Changes" or "Discard Changes".
1421 //
1422 NewPageId = FORM_MAIN_ID;
1423 } else if ((NewPageId >= TERMINAL_OPTION_OFFSET) && (NewPageId < CONSOLE_OPTION_OFFSET)) {
1424 NewPageId = FORM_CON_COM_SETUP_ID;
1425 }
1426
1427 if ((NewPageId > 0) && (NewPageId < MAXIMUM_FORM_ID)) {
1428 Private->BmmPreviousPageId = Private->BmmCurrentPageId;
1429 Private->BmmCurrentPageId = NewPageId;
1430 }
1431 }
EFI Development Kit II mirror for PVE