]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Library/BootMaintenanceManagerUiLib/UpdatePage.c
projects / mirror_edk2.git / blob
? search:


960d0b0f9d89faba5f744ad90c51a3cb10a002f6
[mirror_edk2.git] / MdeModulePkg / Library / BootMaintenanceManagerUiLib / UpdatePage.c
1 /** @file
2 Dynamically update the pages.
3
4 Copyright (c) 2004 - 2016, 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 "BootMaintenanceManager.h"
16
17 /**
18 Create the global UpdateData structure.
19
20 **/
21 VOID
22 CreateUpdateData (
23 VOID
24 )
25 {
26 //
27 // Init OpCode Handle and Allocate space for creation of Buffer
28 //
29 mStartOpCodeHandle = HiiAllocateOpCodeHandle ();
30 ASSERT (mStartOpCodeHandle != NULL);
31
32 mEndOpCodeHandle = HiiAllocateOpCodeHandle ();
33 ASSERT (mEndOpCodeHandle != NULL);
34
35 //
36 // Create Hii Extend Label OpCode as the start opcode
37 //
38 mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mStartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
39 mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
40
41 //
42 // Create Hii Extend Label OpCode as the end opcode
43 //
44 mEndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mEndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
45 mEndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
46 mEndLabel->Number = LABEL_END;
47 }
48
49 /**
50 Refresh the global UpdateData structure.
51
52 **/
53 VOID
54 RefreshUpdateData (
55 VOID
56 )
57 {
58 //
59 // Free current updated date
60 //
61 if (mStartOpCodeHandle != NULL) {
62 HiiFreeOpCodeHandle (mStartOpCodeHandle);
63 }
64
65 //
66 // Create new OpCode Handle
67 //
68 mStartOpCodeHandle = HiiAllocateOpCodeHandle ();
69
70 //
71 // Create Hii Extend Label OpCode as the start opcode
72 //
73 mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (mStartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
74 mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
75
76 }
77
78 /**
79 Add a "Go back to main page" tag in front of the form when there are no
80 "Apply changes" and "Discard changes" tags in the end of the form.
81
82 @param CallbackData The BMM context data.
83
84 **/
85 VOID
86 UpdatePageStart (
87 IN BMM_CALLBACK_DATA *CallbackData
88 )
89 {
90 RefreshUpdateData ();
91 mStartLabel->Number = CallbackData->BmmCurrentPageId;
92
93 if (!(CallbackData->BmmAskSaveOrNot)) {
94 //
95 // Add a "Go back to main page" tag in front of the form when there are no
96 // "Apply changes" and "Discard changes" tags in the end of the form.
97 //
98 HiiCreateGotoOpCode (
99 mStartOpCodeHandle,
100 FORM_MAIN_ID,
101 STRING_TOKEN (STR_FORM_GOTO_MAIN),
102 STRING_TOKEN (STR_FORM_GOTO_MAIN),
103 0,
104 FORM_MAIN_ID
105 );
106 }
107 }
108
109 /**
110 Create the "Apply changes" and "Discard changes" tags. And
111 ensure user can return to the main page.
112
113 @param CallbackData The BMM context data.
114
115 **/
116 VOID
117 UpdatePageEnd (
118 IN BMM_CALLBACK_DATA *CallbackData
119 )
120 {
121 //
122 // Create the "Apply changes" and "Discard changes" tags.
123 //
124 if (CallbackData->BmmAskSaveOrNot) {
125 HiiCreateSubTitleOpCode (
126 mStartOpCodeHandle,
127 STRING_TOKEN (STR_NULL_STRING),
128 0,
129 0,
130 0
131 );
132
133 HiiCreateActionOpCode (
134 mStartOpCodeHandle,
135 KEY_VALUE_SAVE_AND_EXIT,
136 STRING_TOKEN (STR_SAVE_AND_EXIT),
137 STRING_TOKEN (STR_NULL_STRING),
138 EFI_IFR_FLAG_CALLBACK,
139 0
140 );
141 }
142
143 //
144 // Ensure user can return to the main page.
145 //
146 HiiCreateActionOpCode (
147 mStartOpCodeHandle,
148 KEY_VALUE_NO_SAVE_AND_EXIT,
149 STRING_TOKEN (STR_NO_SAVE_AND_EXIT),
150 STRING_TOKEN (STR_NULL_STRING),
151 EFI_IFR_FLAG_CALLBACK,
152 0
153 );
154
155 HiiUpdateForm (
156 CallbackData->BmmHiiHandle,
157 &mBootMaintGuid,
158 CallbackData->BmmCurrentPageId,
159 mStartOpCodeHandle, // Label CallbackData->BmmCurrentPageId
160 mEndOpCodeHandle // LABEL_END
161 );
162 }
163
164 /**
165 Clean up the dynamic opcode at label and form specified by both LabelId.
166
167 @param LabelId It is both the Form ID and Label ID for opcode deletion.
168 @param CallbackData The BMM context data.
169
170 **/
171 VOID
172 CleanUpPage (
173 IN UINT16 LabelId,
174 IN BMM_CALLBACK_DATA *CallbackData
175 )
176 {
177 RefreshUpdateData ();
178
179 //
180 // Remove all op-codes from dynamic page
181 //
182 mStartLabel->Number = LabelId;
183 HiiUpdateForm (
184 CallbackData->BmmHiiHandle,
185 &mBootMaintGuid,
186 LabelId,
187 mStartOpCodeHandle, // Label LabelId
188 mEndOpCodeHandle // LABEL_END
189 );
190 }
191
192 /**
193 Create a list of Goto Opcode for all terminal devices logged
194 by TerminaMenu. This list will be inserted to form FORM_CON_COM_SETUP_ID.
195
196 @param CallbackData The BMM context data.
197 **/
198 VOID
199 UpdateConCOMPage (
200 IN BMM_CALLBACK_DATA *CallbackData
201 )
202 {
203 BM_MENU_ENTRY *NewMenuEntry;
204 UINT16 Index;
205
206 CallbackData->BmmAskSaveOrNot = TRUE;
207
208 UpdatePageStart (CallbackData);
209
210 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
211 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
212
213 HiiCreateGotoOpCode (
214 mStartOpCodeHandle,
215 FORM_CON_COM_SETUP_ID,
216 NewMenuEntry->DisplayStringToken,
217 STRING_TOKEN (STR_NULL_STRING),
218 EFI_IFR_FLAG_CALLBACK,
219 (UINT16) (TERMINAL_OPTION_OFFSET + Index)
220 );
221 }
222
223 UpdatePageEnd (CallbackData);
224 }
225
226
227 /**
228 Create a list of boot option from global BootOptionMenu. It
229 allow user to delete the boot option.
230
231 @param CallbackData The BMM context data.
232
233 **/
234 VOID
235 UpdateBootDelPage (
236 IN BMM_CALLBACK_DATA *CallbackData
237 )
238 {
239 BM_MENU_ENTRY *NewMenuEntry;
240 BM_LOAD_CONTEXT *NewLoadContext;
241 UINT16 Index;
242
243 CallbackData->BmmAskSaveOrNot = TRUE;
244
245 UpdatePageStart (CallbackData);
246
247 ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.BootOptionDel) / sizeof (CallbackData->BmmFakeNvData.BootOptionDel[0])));
248 for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
249 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
250 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
251 if (NewLoadContext->IsLegacy) {
252 continue;
253 }
254
255 NewLoadContext->Deleted = FALSE;
256
257 if (CallbackData->BmmFakeNvData.BootOptionDel[Index] && !CallbackData->BmmFakeNvData.BootOptionDelMark[Index]) {
258 //
259 // CallbackData->BmmFakeNvData.BootOptionDel[Index] == TRUE means browser knows this boot option is selected
260 // CallbackData->BmmFakeNvData.BootOptionDelMark[Index] = FALSE means BDS knows the selected boot option has
261 // deleted, browser maintains old useless info. So clear this info here, and later update this info to browser
262 // through HiiSetBrowserData function.
263 //
264 CallbackData->BmmFakeNvData.BootOptionDel[Index] = FALSE;
265 }
266
267 HiiCreateCheckBoxOpCode (
268 mStartOpCodeHandle,
269 (EFI_QUESTION_ID) (BOOT_OPTION_DEL_QUESTION_ID + Index),
270 VARSTORE_ID_BOOT_MAINT,
271 (UINT16) (BOOT_OPTION_DEL_VAR_OFFSET + Index),
272 NewMenuEntry->DisplayStringToken,
273 NewMenuEntry->HelpStringToken,
274 EFI_IFR_FLAG_CALLBACK,
275 0,
276 NULL
277 );
278 }
279 UpdatePageEnd (CallbackData);
280 }
281
282 /**
283 Create a lit of driver option from global DriverMenu.
284
285 @param CallbackData The BMM context data.
286
287 **/
288 VOID
289 UpdateDrvAddHandlePage (
290 IN BMM_CALLBACK_DATA *CallbackData
291 )
292 {
293 BM_MENU_ENTRY *NewMenuEntry;
294 UINT16 Index;
295
296 CallbackData->BmmAskSaveOrNot = FALSE;
297
298 UpdatePageStart (CallbackData);
299
300 for (Index = 0; Index < DriverMenu.MenuNumber; Index++) {
301 NewMenuEntry = BOpt_GetMenuEntry (&DriverMenu, Index);
302
303 HiiCreateGotoOpCode (
304 mStartOpCodeHandle,
305 FORM_DRV_ADD_HANDLE_DESC_ID,
306 NewMenuEntry->DisplayStringToken,
307 STRING_TOKEN (STR_NULL_STRING),
308 EFI_IFR_FLAG_CALLBACK,
309 (UINT16) (HANDLE_OPTION_OFFSET + Index)
310 );
311 }
312
313 UpdatePageEnd (CallbackData);
314 }
315
316 /**
317 Create a lit of driver option from global DriverOptionMenu. It
318 allow user to delete the driver option.
319
320 @param CallbackData The BMM context data.
321
322 **/
323 VOID
324 UpdateDrvDelPage (
325 IN BMM_CALLBACK_DATA *CallbackData
326 )
327 {
328 BM_MENU_ENTRY *NewMenuEntry;
329 BM_LOAD_CONTEXT *NewLoadContext;
330 UINT16 Index;
331
332 CallbackData->BmmAskSaveOrNot = TRUE;
333
334 UpdatePageStart (CallbackData);
335
336 ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.DriverOptionDel) / sizeof (CallbackData->BmmFakeNvData.DriverOptionDel[0])));
337 for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
338 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
339
340 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
341 NewLoadContext->Deleted = FALSE;
342
343 if (CallbackData->BmmFakeNvData.DriverOptionDel[Index] && !CallbackData->BmmFakeNvData.DriverOptionDelMark[Index]) {
344 //
345 // CallbackData->BmmFakeNvData.BootOptionDel[Index] == TRUE means browser knows this boot option is selected
346 // CallbackData->BmmFakeNvData.BootOptionDelMark[Index] = FALSE means BDS knows the selected boot option has
347 // deleted, browser maintains old useless info. So clear this info here, and later update this info to browser
348 // through HiiSetBrowserData function.
349 //
350 CallbackData->BmmFakeNvData.DriverOptionDel[Index] = FALSE;
351 }
352 HiiCreateCheckBoxOpCode (
353 mStartOpCodeHandle,
354 (EFI_QUESTION_ID) (DRIVER_OPTION_DEL_QUESTION_ID + Index),
355 VARSTORE_ID_BOOT_MAINT,
356 (UINT16) (DRIVER_OPTION_DEL_VAR_OFFSET + Index),
357 NewMenuEntry->DisplayStringToken,
358 NewMenuEntry->HelpStringToken,
359 EFI_IFR_FLAG_CALLBACK,
360 0,
361 NULL
362 );
363 }
364
365 UpdatePageEnd (CallbackData);
366 }
367
368 /**
369 Prepare the page to allow user to add description for
370 a Driver Option.
371
372 @param CallbackData The BMM context data.
373
374 **/
375 VOID
376 UpdateDriverAddHandleDescPage (
377 IN BMM_CALLBACK_DATA *CallbackData
378 )
379 {
380 BM_MENU_ENTRY *NewMenuEntry;
381
382 CallbackData->BmmFakeNvData.DriverAddActive = 0x01;
383 CallbackData->BmmFakeNvData.DriverAddForceReconnect = 0x00;
384 CallbackData->BmmAskSaveOrNot = TRUE;
385 NewMenuEntry = CallbackData->MenuEntry;
386
387 UpdatePageStart (CallbackData);
388
389 HiiCreateSubTitleOpCode (
390 mStartOpCodeHandle,
391 NewMenuEntry->DisplayStringToken,
392 0,
393 0,
394 0
395 );
396
397 HiiCreateStringOpCode (
398 mStartOpCodeHandle,
399 (EFI_QUESTION_ID) DRV_ADD_HANDLE_DESC_QUESTION_ID,
400 VARSTORE_ID_BOOT_MAINT,
401 DRV_ADD_HANDLE_DESC_VAR_OFFSET,
402 STRING_TOKEN (STR_LOAD_OPTION_DESC),
403 STRING_TOKEN (STR_NULL_STRING),
404 0,
405 0,
406 6,
407 75,
408 NULL
409 );
410
411 HiiCreateCheckBoxOpCode (
412 mStartOpCodeHandle,
413 (EFI_QUESTION_ID) DRV_ADD_RECON_QUESTION_ID,
414 VARSTORE_ID_BOOT_MAINT,
415 DRV_ADD_RECON_VAR_OFFSET,
416 STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
417 STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
418 0,
419 0,
420 NULL
421 );
422
423 HiiCreateStringOpCode (
424 mStartOpCodeHandle,
425 (EFI_QUESTION_ID) DRIVER_ADD_OPTION_QUESTION_ID,
426 VARSTORE_ID_BOOT_MAINT,
427 DRIVER_ADD_OPTION_VAR_OFFSET,
428 STRING_TOKEN (STR_OPTIONAL_DATA),
429 STRING_TOKEN (STR_NULL_STRING),
430 0,
431 0,
432 6,
433 75,
434 NULL
435 );
436
437 UpdatePageEnd (CallbackData);
438 }
439
440 /**
441 Update console page.
442
443 @param UpdatePageId The form ID to be updated.
444 @param ConsoleMenu The console menu list.
445 @param CallbackData The BMM context data.
446
447 **/
448 VOID
449 UpdateConsolePage (
450 IN UINT16 UpdatePageId,
451 IN BM_MENU_OPTION *ConsoleMenu,
452 IN BMM_CALLBACK_DATA *CallbackData
453 )
454 {
455 BM_MENU_ENTRY *NewMenuEntry;
456 BM_CONSOLE_CONTEXT *NewConsoleContext;
457 BM_TERMINAL_CONTEXT *NewTerminalContext;
458 UINT16 Index;
459 UINT16 Index2;
460 UINT8 CheckFlags;
461 UINT8 *ConsoleCheck;
462 EFI_QUESTION_ID QuestionIdBase;
463 UINT16 VariableOffsetBase;
464
465 CallbackData->BmmAskSaveOrNot = TRUE;
466
467 UpdatePageStart (CallbackData);
468
469 ConsoleCheck = NULL;
470 QuestionIdBase = 0;
471 VariableOffsetBase = 0;
472
473 switch (UpdatePageId) {
474 case FORM_CON_IN_ID:
475 ConsoleCheck = &CallbackData->BmmFakeNvData.ConsoleInCheck[0];
476 QuestionIdBase = CON_IN_DEVICE_QUESTION_ID;
477 VariableOffsetBase = CON_IN_DEVICE_VAR_OFFSET;
478 break;
479
480 case FORM_CON_OUT_ID:
481 ConsoleCheck = &CallbackData->BmmFakeNvData.ConsoleOutCheck[0];
482 QuestionIdBase = CON_OUT_DEVICE_QUESTION_ID;
483 VariableOffsetBase = CON_OUT_DEVICE_VAR_OFFSET;
484 break;
485
486 case FORM_CON_ERR_ID:
487 ConsoleCheck = &CallbackData->BmmFakeNvData.ConsoleErrCheck[0];
488 QuestionIdBase = CON_ERR_DEVICE_QUESTION_ID;
489 VariableOffsetBase = CON_ERR_DEVICE_VAR_OFFSET;
490 break;
491 }
492 ASSERT (ConsoleCheck != NULL);
493
494 for (Index = 0; ((Index < ConsoleMenu->MenuNumber) && \
495 (Index < MAX_MENU_NUMBER)) ; Index++) {
496 CheckFlags = 0;
497 NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index);
498 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
499 if (NewConsoleContext->IsActive) {
500 CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
501 ConsoleCheck[Index] = TRUE;
502 } else {
503 ConsoleCheck[Index] = FALSE;
504 }
505 HiiCreateCheckBoxOpCode (
506 mStartOpCodeHandle,
507 (EFI_QUESTION_ID) (QuestionIdBase + Index),
508 VARSTORE_ID_BOOT_MAINT,
509 (UINT16) (VariableOffsetBase + Index),
510 NewMenuEntry->DisplayStringToken,
511 NewMenuEntry->HelpStringToken,
512 EFI_IFR_FLAG_CALLBACK,
513 CheckFlags,
514 NULL
515 );
516 }
517
518 for (Index2 = 0; ((Index2 < TerminalMenu.MenuNumber) && \
519 (Index2 < MAX_MENU_NUMBER)); Index2++) {
520 CheckFlags = 0;
521 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index2);
522 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
523
524 ASSERT (Index < MAX_MENU_NUMBER);
525 if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
526 ((NewTerminalContext->IsConOut != 0) && (UpdatePageId == FORM_CON_OUT_ID)) ||
527 ((NewTerminalContext->IsStdErr != 0) && (UpdatePageId == FORM_CON_ERR_ID))
528 ) {
529 CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
530 ConsoleCheck[Index] = TRUE;
531 } else {
532 ConsoleCheck[Index] = FALSE;
533 }
534 HiiCreateCheckBoxOpCode (
535 mStartOpCodeHandle,
536 (EFI_QUESTION_ID) (QuestionIdBase + Index),
537 VARSTORE_ID_BOOT_MAINT,
538 (UINT16) (VariableOffsetBase + Index),
539 NewMenuEntry->DisplayStringToken,
540 NewMenuEntry->HelpStringToken,
541 EFI_IFR_FLAG_CALLBACK,
542 CheckFlags,
543 NULL
544 );
545
546 Index++;
547 }
548
549 UpdatePageEnd (CallbackData);
550 }
551
552 /**
553 Update the page's NV Map if user has changed the order
554 a list. This list can be Boot Order or Driver Order.
555
556 @param UpdatePageId The form ID to be updated.
557 @param OptionMenu The new list.
558 @param CallbackData The BMM context data.
559
560 **/
561 VOID
562 UpdateOrderPage (
563 IN UINT16 UpdatePageId,
564 IN BM_MENU_OPTION *OptionMenu,
565 IN BMM_CALLBACK_DATA *CallbackData
566 )
567 {
568 BM_MENU_ENTRY *NewMenuEntry;
569 UINT16 Index;
570 UINT16 OptionIndex;
571 VOID *OptionsOpCodeHandle;
572 BOOLEAN BootOptionFound;
573 UINT32 *OptionOrder;
574 EFI_QUESTION_ID QuestionId;
575 UINT16 VarOffset;
576
577 CallbackData->BmmAskSaveOrNot = TRUE;
578 UpdatePageStart (CallbackData);
579
580 OptionOrder = NULL;
581 QuestionId = 0;
582 VarOffset = 0;
583 switch (UpdatePageId) {
584
585 case FORM_BOOT_CHG_ID:
586 GetBootOrder (CallbackData);
587 OptionOrder = CallbackData->BmmFakeNvData.BootOptionOrder;
588 QuestionId = BOOT_OPTION_ORDER_QUESTION_ID;
589 VarOffset = BOOT_OPTION_ORDER_VAR_OFFSET;
590 break;
591
592 case FORM_DRV_CHG_ID:
593 GetDriverOrder (CallbackData);
594 OptionOrder = CallbackData->BmmFakeNvData.DriverOptionOrder;
595 QuestionId = DRIVER_OPTION_ORDER_QUESTION_ID;
596 VarOffset = DRIVER_OPTION_ORDER_VAR_OFFSET;
597 break;
598 }
599 ASSERT (OptionOrder != NULL);
600
601 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
602 ASSERT (OptionsOpCodeHandle != NULL);
603
604 NewMenuEntry = NULL;
605 for (OptionIndex = 0; (OptionOrder[OptionIndex] != 0 && OptionIndex < MAX_MENU_NUMBER); OptionIndex++) {
606 BootOptionFound = FALSE;
607 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
608 NewMenuEntry = BOpt_GetMenuEntry (OptionMenu, Index);
609 if ((UINT32) (NewMenuEntry->OptionNumber + 1) == OptionOrder[OptionIndex]) {
610 BootOptionFound = TRUE;
611 break;
612 }
613 }
614 if (BootOptionFound) {
615 HiiCreateOneOfOptionOpCode (
616 OptionsOpCodeHandle,
617 NewMenuEntry->DisplayStringToken,
618 0,
619 EFI_IFR_TYPE_NUM_SIZE_32,
620 OptionOrder[OptionIndex]
621 );
622 }
623 }
624
625 if (OptionMenu->MenuNumber > 0) {
626 HiiCreateOrderedListOpCode (
627 mStartOpCodeHandle, // Container for dynamic created opcodes
628 QuestionId, // Question ID
629 VARSTORE_ID_BOOT_MAINT, // VarStore ID
630 VarOffset, // Offset in Buffer Storage
631 STRING_TOKEN (STR_CHANGE_ORDER), // Question prompt text
632 STRING_TOKEN (STR_CHANGE_ORDER), // Question help text
633 0, // Question flag
634 0, // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
635 EFI_IFR_TYPE_NUM_SIZE_32, // Data type of Question value
636 100, // Maximum container
637 OptionsOpCodeHandle, // Option Opcode list
638 NULL // Default Opcode is NULL
639 );
640 }
641
642 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
643
644 UpdatePageEnd (CallbackData);
645
646 }
647
648 /**
649 Refresh the text mode page.
650
651 @param CallbackData The BMM context data.
652
653 **/
654 VOID
655 UpdateConModePage (
656 IN BMM_CALLBACK_DATA *CallbackData
657 )
658 {
659 UINTN Mode;
660 UINTN Index;
661 UINTN Col;
662 UINTN Row;
663 CHAR16 ModeString[50];
664 CHAR16 *PStr;
665 UINTN MaxMode;
666 UINTN ValidMode;
667 EFI_STRING_ID *ModeToken;
668 EFI_STATUS Status;
669 VOID *OptionsOpCodeHandle;
670 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut;
671
672 ConOut = gST->ConOut;
673 Index = 0;
674 ValidMode = 0;
675 MaxMode = (UINTN) (ConOut->Mode->MaxMode);
676
677 CallbackData->BmmAskSaveOrNot = TRUE;
678
679 UpdatePageStart (CallbackData);
680
681 //
682 // Check valid mode
683 //
684 for (Mode = 0; Mode < MaxMode; Mode++) {
685 Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
686 if (EFI_ERROR (Status)) {
687 continue;
688 }
689 ValidMode++;
690 }
691
692 if (ValidMode == 0) {
693 return;
694 }
695
696 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
697 ASSERT (OptionsOpCodeHandle != NULL);
698
699 ModeToken = AllocateZeroPool (sizeof (EFI_STRING_ID) * ValidMode);
700 ASSERT(ModeToken != NULL);
701
702 //
703 // Determin which mode should be the first entry in menu
704 //
705 GetConsoleOutMode (CallbackData);
706
707 //
708 // Build text mode options
709 //
710 for (Mode = 0; Mode < MaxMode; Mode++) {
711 Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
712 if (EFI_ERROR (Status)) {
713 continue;
714 }
715
716 //
717 // Build mode string Column x Row
718 //
719 UnicodeValueToString (ModeString, 0, Col, 0);
720 PStr = &ModeString[0];
721 StrnCatS (PStr, sizeof (ModeString) / sizeof (ModeString[0]), L" x ", StrLen(L" x ") + 1);
722 PStr = PStr + StrLen (PStr);
723 UnicodeValueToString (PStr , 0, Row, 0);
724
725 ModeToken[Index] = HiiSetString (CallbackData->BmmHiiHandle, 0, ModeString, NULL);
726
727 if (Mode == CallbackData->BmmFakeNvData.ConsoleOutMode) {
728 HiiCreateOneOfOptionOpCode (
729 OptionsOpCodeHandle,
730 ModeToken[Index],
731 EFI_IFR_OPTION_DEFAULT,
732 EFI_IFR_TYPE_NUM_SIZE_16,
733 (UINT16) Mode
734 );
735 } else {
736 HiiCreateOneOfOptionOpCode (
737 OptionsOpCodeHandle,
738 ModeToken[Index],
739 0,
740 EFI_IFR_TYPE_NUM_SIZE_16,
741 (UINT16) Mode
742 );
743 }
744 Index++;
745 }
746
747 HiiCreateOneOfOpCode (
748 mStartOpCodeHandle,
749 (EFI_QUESTION_ID) CON_MODE_QUESTION_ID,
750 VARSTORE_ID_BOOT_MAINT,
751 CON_MODE_VAR_OFFSET,
752 STRING_TOKEN (STR_CON_MODE_SETUP),
753 STRING_TOKEN (STR_CON_MODE_SETUP),
754 EFI_IFR_FLAG_RESET_REQUIRED,
755 EFI_IFR_NUMERIC_SIZE_2,
756 OptionsOpCodeHandle,
757 NULL
758 );
759
760 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
761 FreePool (ModeToken);
762
763 UpdatePageEnd (CallbackData);
764 }
765
766 /**
767 Create the dynamic page which allows user to set the property such as Baud Rate, Data Bits,
768 Parity, Stop Bits, Terminal Type.
769
770 @param CallbackData The BMM context data.
771
772 **/
773 VOID
774 UpdateTerminalPage (
775 IN BMM_CALLBACK_DATA *CallbackData
776 )
777 {
778 UINT8 Index;
779 UINT8 CheckFlags;
780 BM_MENU_ENTRY *NewMenuEntry;
781 VOID *OptionsOpCodeHandle;
782 UINTN CurrentTerminal;
783
784 CallbackData->BmmAskSaveOrNot = TRUE;
785
786 UpdatePageStart (CallbackData);
787
788 CurrentTerminal = CallbackData->CurrentTerminal;
789 NewMenuEntry = BOpt_GetMenuEntry (
790 &TerminalMenu,
791 CurrentTerminal
792 );
793
794 if (NewMenuEntry == NULL) {
795 return ;
796 }
797
798 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
799 ASSERT (OptionsOpCodeHandle != NULL);
800
801 for (Index = 0; Index < sizeof (BaudRateList) / sizeof (BaudRateList [0]); Index++) {
802 CheckFlags = 0;
803 if (BaudRateList[Index].Value == 115200) {
804 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
805 }
806 HiiCreateOneOfOptionOpCode (
807 OptionsOpCodeHandle,
808 BaudRateList[Index].StringToken,
809 CheckFlags,
810 EFI_IFR_TYPE_NUM_SIZE_8,
811 Index
812 );
813 }
814
815 HiiCreateOneOfOpCode (
816 mStartOpCodeHandle,
817 (EFI_QUESTION_ID) (COM_BAUD_RATE_QUESTION_ID + CurrentTerminal),
818 VARSTORE_ID_BOOT_MAINT,
819 (UINT16) (COM_BAUD_RATE_VAR_OFFSET + CurrentTerminal),
820 STRING_TOKEN (STR_COM_BAUD_RATE),
821 STRING_TOKEN (STR_COM_BAUD_RATE),
822 EFI_IFR_FLAG_CALLBACK,
823 EFI_IFR_NUMERIC_SIZE_1,
824 OptionsOpCodeHandle,
825 NULL
826 );
827
828 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
829 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
830 ASSERT (OptionsOpCodeHandle != NULL);
831
832 for (Index = 0; Index < sizeof (DataBitsList) / sizeof (DataBitsList[0]); Index++) {
833 CheckFlags = 0;
834
835 if (DataBitsList[Index].Value == 8) {
836 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
837 }
838
839 HiiCreateOneOfOptionOpCode (
840 OptionsOpCodeHandle,
841 DataBitsList[Index].StringToken,
842 CheckFlags,
843 EFI_IFR_TYPE_NUM_SIZE_8,
844 Index
845 );
846 }
847
848 HiiCreateOneOfOpCode (
849 mStartOpCodeHandle,
850 (EFI_QUESTION_ID) (COM_DATA_RATE_QUESTION_ID + CurrentTerminal),
851 VARSTORE_ID_BOOT_MAINT,
852 (UINT16) (COM_DATA_RATE_VAR_OFFSET + CurrentTerminal),
853 STRING_TOKEN (STR_COM_DATA_BITS),
854 STRING_TOKEN (STR_COM_DATA_BITS),
855 EFI_IFR_FLAG_CALLBACK,
856 EFI_IFR_NUMERIC_SIZE_1,
857 OptionsOpCodeHandle,
858 NULL
859 );
860
861 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
862 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
863 ASSERT (OptionsOpCodeHandle != NULL);
864
865 for (Index = 0; Index < sizeof (ParityList) / sizeof (ParityList[0]); Index++) {
866 CheckFlags = 0;
867 if (ParityList[Index].Value == NoParity) {
868 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
869 }
870
871 HiiCreateOneOfOptionOpCode (
872 OptionsOpCodeHandle,
873 ParityList[Index].StringToken,
874 CheckFlags,
875 EFI_IFR_TYPE_NUM_SIZE_8,
876 Index
877 );
878 }
879
880 HiiCreateOneOfOpCode (
881 mStartOpCodeHandle,
882 (EFI_QUESTION_ID) (COM_PARITY_QUESTION_ID + CurrentTerminal),
883 VARSTORE_ID_BOOT_MAINT,
884 (UINT16) (COM_PARITY_VAR_OFFSET + CurrentTerminal),
885 STRING_TOKEN (STR_COM_PARITY),
886 STRING_TOKEN (STR_COM_PARITY),
887 EFI_IFR_FLAG_CALLBACK,
888 EFI_IFR_NUMERIC_SIZE_1,
889 OptionsOpCodeHandle,
890 NULL
891 );
892
893 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
894 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
895 ASSERT (OptionsOpCodeHandle != NULL);
896
897 for (Index = 0; Index < sizeof (StopBitsList) / sizeof (StopBitsList[0]); Index++) {
898 CheckFlags = 0;
899 if (StopBitsList[Index].Value == OneStopBit) {
900 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
901 }
902
903 HiiCreateOneOfOptionOpCode (
904 OptionsOpCodeHandle,
905 StopBitsList[Index].StringToken,
906 CheckFlags,
907 EFI_IFR_TYPE_NUM_SIZE_8,
908 Index
909 );
910 }
911
912 HiiCreateOneOfOpCode (
913 mStartOpCodeHandle,
914 (EFI_QUESTION_ID) (COM_STOP_BITS_QUESTION_ID + CurrentTerminal),
915 VARSTORE_ID_BOOT_MAINT,
916 (UINT16) (COM_STOP_BITS_VAR_OFFSET + CurrentTerminal),
917 STRING_TOKEN (STR_COM_STOP_BITS),
918 STRING_TOKEN (STR_COM_STOP_BITS),
919 EFI_IFR_FLAG_CALLBACK,
920 EFI_IFR_NUMERIC_SIZE_1,
921 OptionsOpCodeHandle,
922 NULL
923 );
924
925 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
926 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
927 ASSERT (OptionsOpCodeHandle != NULL);
928
929 for (Index = 0; Index < sizeof (TerminalType) / sizeof (TerminalType[0]); Index++) {
930 CheckFlags = 0;
931 if (Index == 0) {
932 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
933 }
934
935 HiiCreateOneOfOptionOpCode (
936 OptionsOpCodeHandle,
937 (EFI_STRING_ID) TerminalType[Index],
938 CheckFlags,
939 EFI_IFR_TYPE_NUM_SIZE_8,
940 Index
941 );
942 }
943
944 HiiCreateOneOfOpCode (
945 mStartOpCodeHandle,
946 (EFI_QUESTION_ID) (COM_TERMINAL_QUESTION_ID + CurrentTerminal),
947 VARSTORE_ID_BOOT_MAINT,
948 (UINT16) (COM_TERMINAL_VAR_OFFSET + CurrentTerminal),
949 STRING_TOKEN (STR_COM_TERMI_TYPE),
950 STRING_TOKEN (STR_COM_TERMI_TYPE),
951 EFI_IFR_FLAG_CALLBACK,
952 EFI_IFR_NUMERIC_SIZE_1,
953 OptionsOpCodeHandle,
954 NULL
955 );
956
957 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
958 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
959 ASSERT (OptionsOpCodeHandle != NULL);
960
961 for (Index = 0; Index < sizeof (mFlowControlType) / sizeof (mFlowControlType[0]); Index++) {
962 CheckFlags = 0;
963 if (Index == 0) {
964 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
965 }
966 HiiCreateOneOfOptionOpCode (
967 OptionsOpCodeHandle,
968 (EFI_STRING_ID) mFlowControlType[Index],
969 CheckFlags,
970 EFI_IFR_TYPE_NUM_SIZE_8,
971 mFlowControlValue[Index]
972 );
973 }
974
975 HiiCreateOneOfOpCode (
976 mStartOpCodeHandle,
977 (EFI_QUESTION_ID) (COM_FLOWCONTROL_QUESTION_ID + CurrentTerminal),
978 VARSTORE_ID_BOOT_MAINT,
979 (UINT16) (COM_FLOWCONTROL_VAR_OFFSET + CurrentTerminal),
980 STRING_TOKEN (STR_COM_FLOW_CONTROL),
981 STRING_TOKEN (STR_COM_FLOW_CONTROL),
982 EFI_IFR_FLAG_CALLBACK,
983 EFI_IFR_NUMERIC_SIZE_1,
984 OptionsOpCodeHandle,
985 NULL
986 );
987
988 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
989
990 UpdatePageEnd (CallbackData);
991 }
992
993 /**
994 Update add boot/driver option page.
995
996 @param CallbackData The BMM context data.
997 @param FormId The form ID to be updated.
998 @param DevicePath Device path.
999
1000 **/
1001 VOID
1002 UpdateOptionPage(
1003 IN BMM_CALLBACK_DATA *CallbackData,
1004 IN EFI_FORM_ID FormId,
1005 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
1006 )
1007 {
1008 CHAR16 *String;
1009 EFI_STRING_ID StringToken;
1010
1011 String = NULL;
1012
1013 if (DevicePath != NULL){
1014 String = ExtractFileNameFromDevicePath(DevicePath);
1015 }
1016 if (String == NULL) {
1017 String = HiiGetString (CallbackData->BmmHiiHandle, STRING_TOKEN (STR_NULL_STRING), NULL);
1018 ASSERT (String != NULL);
1019 }
1020
1021 StringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1022 FreePool (String);
1023
1024 if(FormId == FORM_BOOT_ADD_ID){
1025 if (!CallbackData->BmmFakeNvData.BootOptionChanged) {
1026 ZeroMem (CallbackData->BmmFakeNvData.BootOptionalData, sizeof (CallbackData->BmmFakeNvData.BootOptionalData));
1027 ZeroMem (CallbackData->BmmFakeNvData.BootDescriptionData, sizeof (CallbackData->BmmFakeNvData.BootDescriptionData));
1028 }
1029 } else if (FormId == FORM_DRV_ADD_FILE_ID){
1030 if (!CallbackData->BmmFakeNvData.DriverOptionChanged) {
1031 ZeroMem (CallbackData->BmmFakeNvData.DriverOptionalData, sizeof (CallbackData->BmmFakeNvData.DriverOptionalData));
1032 ZeroMem (CallbackData->BmmFakeNvData.DriverDescriptionData, sizeof (CallbackData->BmmFakeNvData.DriverDescriptionData));
1033 }
1034 }
1035
1036 RefreshUpdateData();
1037 mStartLabel->Number = FormId;
1038
1039 HiiCreateSubTitleOpCode (
1040 mStartOpCodeHandle,
1041 StringToken,
1042 0,
1043 0,
1044 0
1045 );
1046
1047 HiiUpdateForm (
1048 CallbackData->BmmHiiHandle,
1049 &mBootMaintGuid,
1050 FormId,
1051 mStartOpCodeHandle,// Label FormId
1052 mEndOpCodeHandle // LABEL_END
1053 );
1054 }
1055
1056 /**
1057 Dispatch the correct update page function to call based on
1058 the UpdatePageId.
1059
1060 @param UpdatePageId The form ID.
1061 @param CallbackData The BMM context data.
1062
1063 **/
1064 VOID
1065 UpdatePageBody (
1066 IN UINT16 UpdatePageId,
1067 IN BMM_CALLBACK_DATA *CallbackData
1068 )
1069 {
1070 CleanUpPage (UpdatePageId, CallbackData);
1071 switch (UpdatePageId) {
1072 case FORM_CON_IN_ID:
1073 UpdateConsolePage (UpdatePageId, &ConsoleInpMenu, CallbackData);
1074 break;
1075
1076 case FORM_CON_OUT_ID:
1077 UpdateConsolePage (UpdatePageId, &ConsoleOutMenu, CallbackData);
1078 break;
1079
1080 case FORM_CON_ERR_ID:
1081 UpdateConsolePage (UpdatePageId, &ConsoleErrMenu, CallbackData);
1082 break;
1083
1084 case FORM_BOOT_CHG_ID:
1085 UpdateOrderPage (UpdatePageId, &BootOptionMenu, CallbackData);
1086 break;
1087
1088 case FORM_DRV_CHG_ID:
1089 UpdateOrderPage (UpdatePageId, &DriverOptionMenu, CallbackData);
1090 break;
1091
1092 default:
1093 break;
1094 }
1095 }
1096
1097 /**
1098 Dispatch the display to the next page based on NewPageId.
1099
1100 @param Private The BMM context data.
1101 @param NewPageId The original page ID.
1102
1103 **/
1104 VOID
1105 UpdatePageId (
1106 BMM_CALLBACK_DATA *Private,
1107 UINT16 NewPageId
1108 )
1109 {
1110 if ((NewPageId < FILE_OPTION_OFFSET) && (NewPageId >= HANDLE_OPTION_OFFSET)) {
1111 //
1112 // If we select a handle to add driver option, advance to the add handle description page.
1113 //
1114 NewPageId = FORM_DRV_ADD_HANDLE_DESC_ID;
1115 } else if ((NewPageId == KEY_VALUE_SAVE_AND_EXIT) || (NewPageId == KEY_VALUE_NO_SAVE_AND_EXIT)) {
1116 //
1117 // Return to main page after "Save Changes" or "Discard Changes".
1118 //
1119 NewPageId = FORM_MAIN_ID;
1120 } else if ((NewPageId >= TERMINAL_OPTION_OFFSET) && (NewPageId < CONSOLE_OPTION_OFFSET)) {
1121 NewPageId = FORM_CON_COM_SETUP_ID;
1122 }
1123
1124 if ((NewPageId > 0) && (NewPageId < MAXIMUM_FORM_ID)) {
1125 Private->BmmPreviousPageId = Private->BmmCurrentPageId;
1126 Private->BmmCurrentPageId = NewPageId;
1127 }
1128 }
EFI Development Kit II mirror for PVE