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


dede4b392f153a0690be5323d8bcabdc2ae365b8
[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 CallbackData->BmmOldFakeNVData.BootOptionDel[Index] = FALSE;
266 }
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 EFI_IFR_FLAG_CALLBACK,
276 0,
277 NULL
278 );
279 }
280 UpdatePageEnd (CallbackData);
281 }
282
283 /**
284 Create a lit of driver option from global DriverMenu.
285
286 @param CallbackData The BMM context data.
287
288 **/
289 VOID
290 UpdateDrvAddHandlePage (
291 IN BMM_CALLBACK_DATA *CallbackData
292 )
293 {
294 BM_MENU_ENTRY *NewMenuEntry;
295 UINT16 Index;
296
297 CallbackData->BmmAskSaveOrNot = FALSE;
298
299 UpdatePageStart (CallbackData);
300
301 for (Index = 0; Index < DriverMenu.MenuNumber; Index++) {
302 NewMenuEntry = BOpt_GetMenuEntry (&DriverMenu, Index);
303
304 HiiCreateGotoOpCode (
305 mStartOpCodeHandle,
306 FORM_DRV_ADD_HANDLE_DESC_ID,
307 NewMenuEntry->DisplayStringToken,
308 STRING_TOKEN (STR_NULL_STRING),
309 EFI_IFR_FLAG_CALLBACK,
310 (UINT16) (HANDLE_OPTION_OFFSET + Index)
311 );
312 }
313
314 UpdatePageEnd (CallbackData);
315 }
316
317 /**
318 Create a lit of driver option from global DriverOptionMenu. It
319 allow user to delete the driver option.
320
321 @param CallbackData The BMM context data.
322
323 **/
324 VOID
325 UpdateDrvDelPage (
326 IN BMM_CALLBACK_DATA *CallbackData
327 )
328 {
329 BM_MENU_ENTRY *NewMenuEntry;
330 BM_LOAD_CONTEXT *NewLoadContext;
331 UINT16 Index;
332
333 CallbackData->BmmAskSaveOrNot = TRUE;
334
335 UpdatePageStart (CallbackData);
336
337 ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.DriverOptionDel) / sizeof (CallbackData->BmmFakeNvData.DriverOptionDel[0])));
338 for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
339 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
340
341 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
342 NewLoadContext->Deleted = FALSE;
343
344 if (CallbackData->BmmFakeNvData.DriverOptionDel[Index] && !CallbackData->BmmFakeNvData.DriverOptionDelMark[Index]) {
345 //
346 // CallbackData->BmmFakeNvData.BootOptionDel[Index] == TRUE means browser knows this boot option is selected
347 // CallbackData->BmmFakeNvData.BootOptionDelMark[Index] = FALSE means BDS knows the selected boot option has
348 // deleted, browser maintains old useless info. So clear this info here, and later update this info to browser
349 // through HiiSetBrowserData function.
350 //
351 CallbackData->BmmFakeNvData.DriverOptionDel[Index] = FALSE;
352 CallbackData->BmmOldFakeNVData.DriverOptionDel[Index] = FALSE;
353 }
354 HiiCreateCheckBoxOpCode (
355 mStartOpCodeHandle,
356 (EFI_QUESTION_ID) (DRIVER_OPTION_DEL_QUESTION_ID + Index),
357 VARSTORE_ID_BOOT_MAINT,
358 (UINT16) (DRIVER_OPTION_DEL_VAR_OFFSET + Index),
359 NewMenuEntry->DisplayStringToken,
360 NewMenuEntry->HelpStringToken,
361 EFI_IFR_FLAG_CALLBACK,
362 0,
363 NULL
364 );
365 }
366
367 UpdatePageEnd (CallbackData);
368 }
369
370 /**
371 Prepare the page to allow user to add description for
372 a Driver Option.
373
374 @param CallbackData The BMM context data.
375
376 **/
377 VOID
378 UpdateDriverAddHandleDescPage (
379 IN BMM_CALLBACK_DATA *CallbackData
380 )
381 {
382 BM_MENU_ENTRY *NewMenuEntry;
383
384 CallbackData->BmmFakeNvData.DriverAddActive = 0x01;
385 CallbackData->BmmFakeNvData.DriverAddForceReconnect = 0x00;
386 CallbackData->BmmAskSaveOrNot = TRUE;
387 NewMenuEntry = CallbackData->MenuEntry;
388
389 UpdatePageStart (CallbackData);
390
391 HiiCreateSubTitleOpCode (
392 mStartOpCodeHandle,
393 NewMenuEntry->DisplayStringToken,
394 0,
395 0,
396 0
397 );
398
399 HiiCreateStringOpCode (
400 mStartOpCodeHandle,
401 (EFI_QUESTION_ID) DRV_ADD_HANDLE_DESC_QUESTION_ID,
402 VARSTORE_ID_BOOT_MAINT,
403 DRV_ADD_HANDLE_DESC_VAR_OFFSET,
404 STRING_TOKEN (STR_LOAD_OPTION_DESC),
405 STRING_TOKEN (STR_NULL_STRING),
406 0,
407 0,
408 6,
409 75,
410 NULL
411 );
412
413 HiiCreateCheckBoxOpCode (
414 mStartOpCodeHandle,
415 (EFI_QUESTION_ID) DRV_ADD_RECON_QUESTION_ID,
416 VARSTORE_ID_BOOT_MAINT,
417 DRV_ADD_RECON_VAR_OFFSET,
418 STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
419 STRING_TOKEN (STR_LOAD_OPTION_FORCE_RECON),
420 0,
421 0,
422 NULL
423 );
424
425 HiiCreateStringOpCode (
426 mStartOpCodeHandle,
427 (EFI_QUESTION_ID) DRIVER_ADD_OPTION_QUESTION_ID,
428 VARSTORE_ID_BOOT_MAINT,
429 DRIVER_ADD_OPTION_VAR_OFFSET,
430 STRING_TOKEN (STR_OPTIONAL_DATA),
431 STRING_TOKEN (STR_NULL_STRING),
432 0,
433 0,
434 6,
435 75,
436 NULL
437 );
438
439 UpdatePageEnd (CallbackData);
440 }
441
442 /**
443 Update console page.
444
445 @param UpdatePageId The form ID to be updated.
446 @param ConsoleMenu The console menu list.
447 @param CallbackData The BMM context data.
448
449 **/
450 VOID
451 UpdateConsolePage (
452 IN UINT16 UpdatePageId,
453 IN BM_MENU_OPTION *ConsoleMenu,
454 IN BMM_CALLBACK_DATA *CallbackData
455 )
456 {
457 BM_MENU_ENTRY *NewMenuEntry;
458 BM_CONSOLE_CONTEXT *NewConsoleContext;
459 BM_TERMINAL_CONTEXT *NewTerminalContext;
460 UINT16 Index;
461 UINT16 Index2;
462 UINT8 CheckFlags;
463 UINT8 *ConsoleCheck;
464 EFI_QUESTION_ID QuestionIdBase;
465 UINT16 VariableOffsetBase;
466
467 CallbackData->BmmAskSaveOrNot = TRUE;
468
469 UpdatePageStart (CallbackData);
470
471 ConsoleCheck = NULL;
472 QuestionIdBase = 0;
473 VariableOffsetBase = 0;
474
475 switch (UpdatePageId) {
476 case FORM_CON_IN_ID:
477 ConsoleCheck = &CallbackData->BmmFakeNvData.ConsoleInCheck[0];
478 QuestionIdBase = CON_IN_DEVICE_QUESTION_ID;
479 VariableOffsetBase = CON_IN_DEVICE_VAR_OFFSET;
480 break;
481
482 case FORM_CON_OUT_ID:
483 ConsoleCheck = &CallbackData->BmmFakeNvData.ConsoleOutCheck[0];
484 QuestionIdBase = CON_OUT_DEVICE_QUESTION_ID;
485 VariableOffsetBase = CON_OUT_DEVICE_VAR_OFFSET;
486 break;
487
488 case FORM_CON_ERR_ID:
489 ConsoleCheck = &CallbackData->BmmFakeNvData.ConsoleErrCheck[0];
490 QuestionIdBase = CON_ERR_DEVICE_QUESTION_ID;
491 VariableOffsetBase = CON_ERR_DEVICE_VAR_OFFSET;
492 break;
493 }
494 ASSERT (ConsoleCheck != NULL);
495
496 for (Index = 0; ((Index < ConsoleMenu->MenuNumber) && \
497 (Index < MAX_MENU_NUMBER)) ; Index++) {
498 CheckFlags = 0;
499 NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index);
500 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
501 if (NewConsoleContext->IsActive) {
502 CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
503 ConsoleCheck[Index] = TRUE;
504 } else {
505 ConsoleCheck[Index] = FALSE;
506 }
507 HiiCreateCheckBoxOpCode (
508 mStartOpCodeHandle,
509 (EFI_QUESTION_ID) (QuestionIdBase + Index),
510 VARSTORE_ID_BOOT_MAINT,
511 (UINT16) (VariableOffsetBase + Index),
512 NewMenuEntry->DisplayStringToken,
513 NewMenuEntry->HelpStringToken,
514 EFI_IFR_FLAG_CALLBACK,
515 CheckFlags,
516 NULL
517 );
518 }
519
520 for (Index2 = 0; ((Index2 < TerminalMenu.MenuNumber) && \
521 (Index2 < MAX_MENU_NUMBER)); Index2++) {
522 CheckFlags = 0;
523 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index2);
524 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
525
526 ASSERT (Index < MAX_MENU_NUMBER);
527 if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
528 ((NewTerminalContext->IsConOut != 0) && (UpdatePageId == FORM_CON_OUT_ID)) ||
529 ((NewTerminalContext->IsStdErr != 0) && (UpdatePageId == FORM_CON_ERR_ID))
530 ) {
531 CheckFlags |= EFI_IFR_CHECKBOX_DEFAULT;
532 ConsoleCheck[Index] = TRUE;
533 } else {
534 ConsoleCheck[Index] = FALSE;
535 }
536 HiiCreateCheckBoxOpCode (
537 mStartOpCodeHandle,
538 (EFI_QUESTION_ID) (QuestionIdBase + Index),
539 VARSTORE_ID_BOOT_MAINT,
540 (UINT16) (VariableOffsetBase + Index),
541 NewMenuEntry->DisplayStringToken,
542 NewMenuEntry->HelpStringToken,
543 EFI_IFR_FLAG_CALLBACK,
544 CheckFlags,
545 NULL
546 );
547
548 Index++;
549 }
550
551 UpdatePageEnd (CallbackData);
552 }
553
554 /**
555 Update the page's NV Map if user has changed the order
556 a list. This list can be Boot Order or Driver Order.
557
558 @param UpdatePageId The form ID to be updated.
559 @param OptionMenu The new list.
560 @param CallbackData The BMM context data.
561
562 **/
563 VOID
564 UpdateOrderPage (
565 IN UINT16 UpdatePageId,
566 IN BM_MENU_OPTION *OptionMenu,
567 IN BMM_CALLBACK_DATA *CallbackData
568 )
569 {
570 BM_MENU_ENTRY *NewMenuEntry;
571 UINT16 Index;
572 UINT16 OptionIndex;
573 VOID *OptionsOpCodeHandle;
574 BOOLEAN BootOptionFound;
575 UINT32 *OptionOrder;
576 EFI_QUESTION_ID QuestionId;
577 UINT16 VarOffset;
578
579 CallbackData->BmmAskSaveOrNot = TRUE;
580 UpdatePageStart (CallbackData);
581
582 OptionOrder = NULL;
583 QuestionId = 0;
584 VarOffset = 0;
585 switch (UpdatePageId) {
586
587 case FORM_BOOT_CHG_ID:
588 //
589 // If the BootOptionOrder in the BmmFakeNvData are same with the date in the BmmOldFakeNVData,
590 // means all Boot Options has been save in BootOptionMenu, we can get the date from the menu.
591 // else means browser maintains some uncommitted date which are not saved in BootOptionMenu,
592 // so we should not get the data from BootOptionMenu to show it.
593 //
594 if (CompareMem (CallbackData->BmmFakeNvData.BootOptionOrder, CallbackData->BmmOldFakeNVData.BootOptionOrder, sizeof (CallbackData->BmmFakeNvData.BootOptionOrder)) == 0) {
595 GetBootOrder (CallbackData);
596 }
597 OptionOrder = CallbackData->BmmFakeNvData.BootOptionOrder;
598 QuestionId = BOOT_OPTION_ORDER_QUESTION_ID;
599 VarOffset = BOOT_OPTION_ORDER_VAR_OFFSET;
600 break;
601
602 case FORM_DRV_CHG_ID:
603 //
604 // If the DriverOptionOrder in the BmmFakeNvData are same with the date in the BmmOldFakeNVData,
605 // means all Driver Options has been save in DriverOptionMenu, we can get the DriverOptionOrder from the menu.
606 // else means browser maintains some uncommitted date which are not saved in DriverOptionMenu,
607 // so we should not get the data from DriverOptionMenu to show it.
608 //
609 if (CompareMem (CallbackData->BmmFakeNvData.DriverOptionOrder, CallbackData->BmmOldFakeNVData.DriverOptionOrder, sizeof (CallbackData->BmmFakeNvData.DriverOptionOrder)) == 0) {
610 GetDriverOrder (CallbackData);
611 }
612 OptionOrder = CallbackData->BmmFakeNvData.DriverOptionOrder;
613 QuestionId = DRIVER_OPTION_ORDER_QUESTION_ID;
614 VarOffset = DRIVER_OPTION_ORDER_VAR_OFFSET;
615 break;
616 }
617 ASSERT (OptionOrder != NULL);
618
619 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
620 ASSERT (OptionsOpCodeHandle != NULL);
621
622 NewMenuEntry = NULL;
623 for (OptionIndex = 0; (OptionOrder[OptionIndex] != 0 && OptionIndex < MAX_MENU_NUMBER); OptionIndex++) {
624 BootOptionFound = FALSE;
625 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
626 NewMenuEntry = BOpt_GetMenuEntry (OptionMenu, Index);
627 if ((UINT32) (NewMenuEntry->OptionNumber + 1) == OptionOrder[OptionIndex]) {
628 BootOptionFound = TRUE;
629 break;
630 }
631 }
632 if (BootOptionFound) {
633 HiiCreateOneOfOptionOpCode (
634 OptionsOpCodeHandle,
635 NewMenuEntry->DisplayStringToken,
636 0,
637 EFI_IFR_TYPE_NUM_SIZE_32,
638 OptionOrder[OptionIndex]
639 );
640 }
641 }
642
643 if (OptionMenu->MenuNumber > 0) {
644 HiiCreateOrderedListOpCode (
645 mStartOpCodeHandle, // Container for dynamic created opcodes
646 QuestionId, // Question ID
647 VARSTORE_ID_BOOT_MAINT, // VarStore ID
648 VarOffset, // Offset in Buffer Storage
649 STRING_TOKEN (STR_CHANGE_ORDER), // Question prompt text
650 STRING_TOKEN (STR_CHANGE_ORDER), // Question help text
651 0, // Question flag
652 0, // Ordered list flag, e.g. EFI_IFR_UNIQUE_SET
653 EFI_IFR_TYPE_NUM_SIZE_32, // Data type of Question value
654 100, // Maximum container
655 OptionsOpCodeHandle, // Option Opcode list
656 NULL // Default Opcode is NULL
657 );
658 }
659
660 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
661
662 UpdatePageEnd (CallbackData);
663
664 }
665
666 /**
667 Refresh the text mode page.
668
669 @param CallbackData The BMM context data.
670
671 **/
672 VOID
673 UpdateConModePage (
674 IN BMM_CALLBACK_DATA *CallbackData
675 )
676 {
677 UINTN Mode;
678 UINTN Index;
679 UINTN Col;
680 UINTN Row;
681 CHAR16 ModeString[50];
682 CHAR16 *PStr;
683 UINTN MaxMode;
684 UINTN ValidMode;
685 EFI_STRING_ID *ModeToken;
686 EFI_STATUS Status;
687 VOID *OptionsOpCodeHandle;
688 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut;
689
690 ConOut = gST->ConOut;
691 Index = 0;
692 ValidMode = 0;
693 MaxMode = (UINTN) (ConOut->Mode->MaxMode);
694
695 CallbackData->BmmAskSaveOrNot = TRUE;
696
697 UpdatePageStart (CallbackData);
698
699 //
700 // Check valid mode
701 //
702 for (Mode = 0; Mode < MaxMode; Mode++) {
703 Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
704 if (EFI_ERROR (Status)) {
705 continue;
706 }
707 ValidMode++;
708 }
709
710 if (ValidMode == 0) {
711 return;
712 }
713
714 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
715 ASSERT (OptionsOpCodeHandle != NULL);
716
717 ModeToken = AllocateZeroPool (sizeof (EFI_STRING_ID) * ValidMode);
718 ASSERT(ModeToken != NULL);
719
720 //
721 // Determin which mode should be the first entry in menu
722 //
723 GetConsoleOutMode (CallbackData);
724
725 //
726 // Build text mode options
727 //
728 for (Mode = 0; Mode < MaxMode; Mode++) {
729 Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
730 if (EFI_ERROR (Status)) {
731 continue;
732 }
733
734 //
735 // Build mode string Column x Row
736 //
737 UnicodeValueToString (ModeString, 0, Col, 0);
738 PStr = &ModeString[0];
739 StrnCatS (PStr, ARRAY_SIZE (ModeString), L" x ", StrLen(L" x ") + 1);
740 PStr = PStr + StrLen (PStr);
741 UnicodeValueToString (PStr , 0, Row, 0);
742
743 ModeToken[Index] = HiiSetString (CallbackData->BmmHiiHandle, 0, ModeString, NULL);
744
745 if (Mode == CallbackData->BmmFakeNvData.ConsoleOutMode) {
746 HiiCreateOneOfOptionOpCode (
747 OptionsOpCodeHandle,
748 ModeToken[Index],
749 EFI_IFR_OPTION_DEFAULT,
750 EFI_IFR_TYPE_NUM_SIZE_16,
751 (UINT16) Mode
752 );
753 } else {
754 HiiCreateOneOfOptionOpCode (
755 OptionsOpCodeHandle,
756 ModeToken[Index],
757 0,
758 EFI_IFR_TYPE_NUM_SIZE_16,
759 (UINT16) Mode
760 );
761 }
762 Index++;
763 }
764
765 HiiCreateOneOfOpCode (
766 mStartOpCodeHandle,
767 (EFI_QUESTION_ID) CON_MODE_QUESTION_ID,
768 VARSTORE_ID_BOOT_MAINT,
769 CON_MODE_VAR_OFFSET,
770 STRING_TOKEN (STR_CON_MODE_SETUP),
771 STRING_TOKEN (STR_CON_MODE_SETUP),
772 EFI_IFR_FLAG_RESET_REQUIRED,
773 EFI_IFR_NUMERIC_SIZE_2,
774 OptionsOpCodeHandle,
775 NULL
776 );
777
778 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
779 FreePool (ModeToken);
780
781 UpdatePageEnd (CallbackData);
782 }
783
784 /**
785 Create the dynamic page which allows user to set the property such as Baud Rate, Data Bits,
786 Parity, Stop Bits, Terminal Type.
787
788 @param CallbackData The BMM context data.
789
790 **/
791 VOID
792 UpdateTerminalPage (
793 IN BMM_CALLBACK_DATA *CallbackData
794 )
795 {
796 UINT8 Index;
797 UINT8 CheckFlags;
798 BM_MENU_ENTRY *NewMenuEntry;
799 VOID *OptionsOpCodeHandle;
800 UINTN CurrentTerminal;
801
802 CallbackData->BmmAskSaveOrNot = TRUE;
803
804 UpdatePageStart (CallbackData);
805
806 CurrentTerminal = CallbackData->CurrentTerminal;
807 NewMenuEntry = BOpt_GetMenuEntry (
808 &TerminalMenu,
809 CurrentTerminal
810 );
811
812 if (NewMenuEntry == NULL) {
813 return ;
814 }
815
816 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
817 ASSERT (OptionsOpCodeHandle != NULL);
818
819 for (Index = 0; Index < sizeof (BaudRateList) / sizeof (BaudRateList [0]); Index++) {
820 CheckFlags = 0;
821 if (BaudRateList[Index].Value == 115200) {
822 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
823 }
824 HiiCreateOneOfOptionOpCode (
825 OptionsOpCodeHandle,
826 BaudRateList[Index].StringToken,
827 CheckFlags,
828 EFI_IFR_TYPE_NUM_SIZE_8,
829 Index
830 );
831 }
832
833 HiiCreateOneOfOpCode (
834 mStartOpCodeHandle,
835 (EFI_QUESTION_ID) (COM_BAUD_RATE_QUESTION_ID + CurrentTerminal),
836 VARSTORE_ID_BOOT_MAINT,
837 (UINT16) (COM_BAUD_RATE_VAR_OFFSET + CurrentTerminal),
838 STRING_TOKEN (STR_COM_BAUD_RATE),
839 STRING_TOKEN (STR_COM_BAUD_RATE),
840 EFI_IFR_FLAG_CALLBACK,
841 EFI_IFR_NUMERIC_SIZE_1,
842 OptionsOpCodeHandle,
843 NULL
844 );
845
846 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
847 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
848 ASSERT (OptionsOpCodeHandle != NULL);
849
850 for (Index = 0; Index < ARRAY_SIZE (DataBitsList); Index++) {
851 CheckFlags = 0;
852
853 if (DataBitsList[Index].Value == 8) {
854 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
855 }
856
857 HiiCreateOneOfOptionOpCode (
858 OptionsOpCodeHandle,
859 DataBitsList[Index].StringToken,
860 CheckFlags,
861 EFI_IFR_TYPE_NUM_SIZE_8,
862 Index
863 );
864 }
865
866 HiiCreateOneOfOpCode (
867 mStartOpCodeHandle,
868 (EFI_QUESTION_ID) (COM_DATA_RATE_QUESTION_ID + CurrentTerminal),
869 VARSTORE_ID_BOOT_MAINT,
870 (UINT16) (COM_DATA_RATE_VAR_OFFSET + CurrentTerminal),
871 STRING_TOKEN (STR_COM_DATA_BITS),
872 STRING_TOKEN (STR_COM_DATA_BITS),
873 EFI_IFR_FLAG_CALLBACK,
874 EFI_IFR_NUMERIC_SIZE_1,
875 OptionsOpCodeHandle,
876 NULL
877 );
878
879 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
880 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
881 ASSERT (OptionsOpCodeHandle != NULL);
882
883 for (Index = 0; Index < ARRAY_SIZE (ParityList); Index++) {
884 CheckFlags = 0;
885 if (ParityList[Index].Value == NoParity) {
886 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
887 }
888
889 HiiCreateOneOfOptionOpCode (
890 OptionsOpCodeHandle,
891 ParityList[Index].StringToken,
892 CheckFlags,
893 EFI_IFR_TYPE_NUM_SIZE_8,
894 Index
895 );
896 }
897
898 HiiCreateOneOfOpCode (
899 mStartOpCodeHandle,
900 (EFI_QUESTION_ID) (COM_PARITY_QUESTION_ID + CurrentTerminal),
901 VARSTORE_ID_BOOT_MAINT,
902 (UINT16) (COM_PARITY_VAR_OFFSET + CurrentTerminal),
903 STRING_TOKEN (STR_COM_PARITY),
904 STRING_TOKEN (STR_COM_PARITY),
905 EFI_IFR_FLAG_CALLBACK,
906 EFI_IFR_NUMERIC_SIZE_1,
907 OptionsOpCodeHandle,
908 NULL
909 );
910
911 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
912 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
913 ASSERT (OptionsOpCodeHandle != NULL);
914
915 for (Index = 0; Index < ARRAY_SIZE (StopBitsList); Index++) {
916 CheckFlags = 0;
917 if (StopBitsList[Index].Value == OneStopBit) {
918 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
919 }
920
921 HiiCreateOneOfOptionOpCode (
922 OptionsOpCodeHandle,
923 StopBitsList[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_STOP_BITS_QUESTION_ID + CurrentTerminal),
933 VARSTORE_ID_BOOT_MAINT,
934 (UINT16) (COM_STOP_BITS_VAR_OFFSET + CurrentTerminal),
935 STRING_TOKEN (STR_COM_STOP_BITS),
936 STRING_TOKEN (STR_COM_STOP_BITS),
937 EFI_IFR_FLAG_CALLBACK,
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 < ARRAY_SIZE (TerminalType); Index++) {
948 CheckFlags = 0;
949 if (Index == 0) {
950 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
951 }
952
953 HiiCreateOneOfOptionOpCode (
954 OptionsOpCodeHandle,
955 (EFI_STRING_ID) TerminalType[Index],
956 CheckFlags,
957 EFI_IFR_TYPE_NUM_SIZE_8,
958 Index
959 );
960 }
961
962 HiiCreateOneOfOpCode (
963 mStartOpCodeHandle,
964 (EFI_QUESTION_ID) (COM_TERMINAL_QUESTION_ID + CurrentTerminal),
965 VARSTORE_ID_BOOT_MAINT,
966 (UINT16) (COM_TERMINAL_VAR_OFFSET + CurrentTerminal),
967 STRING_TOKEN (STR_COM_TERMI_TYPE),
968 STRING_TOKEN (STR_COM_TERMI_TYPE),
969 EFI_IFR_FLAG_CALLBACK,
970 EFI_IFR_NUMERIC_SIZE_1,
971 OptionsOpCodeHandle,
972 NULL
973 );
974
975 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
976 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
977 ASSERT (OptionsOpCodeHandle != NULL);
978
979 for (Index = 0; Index < ARRAY_SIZE (mFlowControlType); Index++) {
980 CheckFlags = 0;
981 if (Index == 0) {
982 CheckFlags |= EFI_IFR_OPTION_DEFAULT;
983 }
984 HiiCreateOneOfOptionOpCode (
985 OptionsOpCodeHandle,
986 (EFI_STRING_ID) mFlowControlType[Index],
987 CheckFlags,
988 EFI_IFR_TYPE_NUM_SIZE_8,
989 mFlowControlValue[Index]
990 );
991 }
992
993 HiiCreateOneOfOpCode (
994 mStartOpCodeHandle,
995 (EFI_QUESTION_ID) (COM_FLOWCONTROL_QUESTION_ID + CurrentTerminal),
996 VARSTORE_ID_BOOT_MAINT,
997 (UINT16) (COM_FLOWCONTROL_VAR_OFFSET + CurrentTerminal),
998 STRING_TOKEN (STR_COM_FLOW_CONTROL),
999 STRING_TOKEN (STR_COM_FLOW_CONTROL),
1000 EFI_IFR_FLAG_CALLBACK,
1001 EFI_IFR_NUMERIC_SIZE_1,
1002 OptionsOpCodeHandle,
1003 NULL
1004 );
1005
1006 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
1007
1008 UpdatePageEnd (CallbackData);
1009 }
1010
1011 /**
1012 Update add boot/driver option page.
1013
1014 @param CallbackData The BMM context data.
1015 @param FormId The form ID to be updated.
1016 @param DevicePath Device path.
1017
1018 **/
1019 VOID
1020 UpdateOptionPage(
1021 IN BMM_CALLBACK_DATA *CallbackData,
1022 IN EFI_FORM_ID FormId,
1023 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
1024 )
1025 {
1026 CHAR16 *String;
1027 EFI_STRING_ID StringToken;
1028
1029 String = NULL;
1030
1031 if (DevicePath != NULL){
1032 String = ExtractFileNameFromDevicePath(DevicePath);
1033 }
1034 if (String == NULL) {
1035 String = HiiGetString (CallbackData->BmmHiiHandle, STRING_TOKEN (STR_NULL_STRING), NULL);
1036 ASSERT (String != NULL);
1037 }
1038
1039 StringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, String, NULL);
1040 FreePool (String);
1041
1042 if(FormId == FORM_BOOT_ADD_ID){
1043 if (!CallbackData->BmmFakeNvData.BootOptionChanged) {
1044 ZeroMem (CallbackData->BmmFakeNvData.BootOptionalData, sizeof (CallbackData->BmmFakeNvData.BootOptionalData));
1045 ZeroMem (CallbackData->BmmFakeNvData.BootDescriptionData, sizeof (CallbackData->BmmFakeNvData.BootDescriptionData));
1046 ZeroMem (CallbackData->BmmOldFakeNVData.BootOptionalData, sizeof (CallbackData->BmmOldFakeNVData.BootOptionalData));
1047 ZeroMem (CallbackData->BmmOldFakeNVData.BootDescriptionData, sizeof (CallbackData->BmmOldFakeNVData.BootDescriptionData));
1048 }
1049 } else if (FormId == FORM_DRV_ADD_FILE_ID){
1050 if (!CallbackData->BmmFakeNvData.DriverOptionChanged) {
1051 ZeroMem (CallbackData->BmmFakeNvData.DriverOptionalData, sizeof (CallbackData->BmmFakeNvData.DriverOptionalData));
1052 ZeroMem (CallbackData->BmmFakeNvData.DriverDescriptionData, sizeof (CallbackData->BmmFakeNvData.DriverDescriptionData));
1053 ZeroMem (CallbackData->BmmOldFakeNVData.DriverOptionalData, sizeof (CallbackData->BmmOldFakeNVData.DriverOptionalData));
1054 ZeroMem (CallbackData->BmmOldFakeNVData.DriverDescriptionData, sizeof (CallbackData->BmmOldFakeNVData.DriverDescriptionData));
1055 }
1056 }
1057
1058 RefreshUpdateData();
1059 mStartLabel->Number = FormId;
1060
1061 HiiCreateSubTitleOpCode (
1062 mStartOpCodeHandle,
1063 StringToken,
1064 0,
1065 0,
1066 0
1067 );
1068
1069 HiiUpdateForm (
1070 CallbackData->BmmHiiHandle,
1071 &mBootMaintGuid,
1072 FormId,
1073 mStartOpCodeHandle,// Label FormId
1074 mEndOpCodeHandle // LABEL_END
1075 );
1076 }
1077
1078 /**
1079 Dispatch the correct update page function to call based on
1080 the UpdatePageId.
1081
1082 @param UpdatePageId The form ID.
1083 @param CallbackData The BMM context data.
1084
1085 **/
1086 VOID
1087 UpdatePageBody (
1088 IN UINT16 UpdatePageId,
1089 IN BMM_CALLBACK_DATA *CallbackData
1090 )
1091 {
1092 CleanUpPage (UpdatePageId, CallbackData);
1093 switch (UpdatePageId) {
1094 case FORM_CON_IN_ID:
1095 UpdateConsolePage (UpdatePageId, &ConsoleInpMenu, CallbackData);
1096 break;
1097
1098 case FORM_CON_OUT_ID:
1099 UpdateConsolePage (UpdatePageId, &ConsoleOutMenu, CallbackData);
1100 break;
1101
1102 case FORM_CON_ERR_ID:
1103 UpdateConsolePage (UpdatePageId, &ConsoleErrMenu, CallbackData);
1104 break;
1105
1106 case FORM_BOOT_CHG_ID:
1107 UpdateOrderPage (UpdatePageId, &BootOptionMenu, CallbackData);
1108 break;
1109
1110 case FORM_DRV_CHG_ID:
1111 UpdateOrderPage (UpdatePageId, &DriverOptionMenu, CallbackData);
1112 break;
1113
1114 default:
1115 break;
1116 }
1117 }
1118
1119 /**
1120 Dispatch the display to the next page based on NewPageId.
1121
1122 @param Private The BMM context data.
1123 @param NewPageId The original page ID.
1124
1125 **/
1126 VOID
1127 UpdatePageId (
1128 BMM_CALLBACK_DATA *Private,
1129 UINT16 NewPageId
1130 )
1131 {
1132 if ((NewPageId < FILE_OPTION_OFFSET) && (NewPageId >= HANDLE_OPTION_OFFSET)) {
1133 //
1134 // If we select a handle to add driver option, advance to the add handle description page.
1135 //
1136 NewPageId = FORM_DRV_ADD_HANDLE_DESC_ID;
1137 } else if ((NewPageId == KEY_VALUE_SAVE_AND_EXIT) || (NewPageId == KEY_VALUE_NO_SAVE_AND_EXIT)) {
1138 //
1139 // Return to main page after "Save Changes" or "Discard Changes".
1140 //
1141 NewPageId = FORM_MAIN_ID;
1142 } else if ((NewPageId >= TERMINAL_OPTION_OFFSET) && (NewPageId < CONSOLE_OPTION_OFFSET)) {
1143 NewPageId = FORM_CON_COM_SETUP_ID;
1144 }
1145
1146 if ((NewPageId > 0) && (NewPageId < MAXIMUM_FORM_ID)) {
1147 Private->BmmPreviousPageId = Private->BmmCurrentPageId;
1148 Private->BmmCurrentPageId = NewPageId;
1149 }
1150 }
EFI Development Kit II mirror for PVE