MdeModulePkg: Refine the code in BootMaintenanceManagerUiLib
[mirror_edk2.git] / MdeModulePkg / Library / BootMaintenanceManagerUiLib / Variable.c
1 /** @file
2 Variable operation that will be used by bootmaint
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 Delete Boot Option that represent a Deleted state in BootOptionMenu.
19 After deleting this boot option, call Var_ChangeBootOrder to
20 make sure BootOrder is in valid state.
21
22 @retval EFI_SUCCESS If all boot load option EFI Variables corresponding to
23 BM_LOAD_CONTEXT marked for deletion is deleted.
24 @retval EFI_NOT_FOUND If can not find the boot option want to be deleted.
25 @return Others If failed to update the "BootOrder" variable after deletion.
26
27 **/
28 EFI_STATUS
29 Var_DelBootOption (
30 VOID
31 )
32 {
33 BM_MENU_ENTRY *NewMenuEntry;
34 BM_LOAD_CONTEXT *NewLoadContext;
35 UINT16 BootString[10];
36 EFI_STATUS Status;
37 UINTN Index;
38 UINTN Index2;
39
40 Status = EFI_SUCCESS;
41 Index2 = 0;
42 for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
43 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, (Index - Index2));
44 if (NULL == NewMenuEntry) {
45 return EFI_NOT_FOUND;
46 }
47
48 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
49 if (!NewLoadContext->Deleted) {
50 continue;
51 }
52
53 UnicodeSPrint (
54 BootString,
55 sizeof (BootString),
56 L"Boot%04x",
57 NewMenuEntry->OptionNumber
58 );
59
60 EfiLibDeleteVariable (BootString, &gEfiGlobalVariableGuid);
61 Index2++;
62 //
63 // If current Load Option is the same as BootNext,
64 // must delete BootNext in order to make sure
65 // there will be no panic on next boot
66 //
67 if (NewLoadContext->IsBootNext) {
68 EfiLibDeleteVariable (L"BootNext", &gEfiGlobalVariableGuid);
69 }
70
71 RemoveEntryList (&NewMenuEntry->Link);
72 BOpt_DestroyMenuEntry (NewMenuEntry);
73 NewMenuEntry = NULL;
74 }
75
76 BootOptionMenu.MenuNumber -= Index2;
77
78 Status = Var_ChangeBootOrder ();
79 return Status;
80 }
81
82 /**
83 After any operation on Boot####, there will be a discrepancy in BootOrder.
84 Since some are missing but in BootOrder, while some are present but are
85 not reflected by BootOrder. Then a function rebuild BootOrder from
86 scratch by content from BootOptionMenu is needed.
87
88
89
90
91 @retval EFI_SUCCESS The boot order is updated successfully.
92 @return EFI_STATUS other than EFI_SUCCESS if failed to
93 Set the "BootOrder" EFI Variable.
94
95 **/
96 EFI_STATUS
97 Var_ChangeBootOrder (
98 VOID
99 )
100 {
101
102 EFI_STATUS Status;
103 BM_MENU_ENTRY *NewMenuEntry;
104 UINT16 *BootOrderList;
105 UINT16 *BootOrderListPtr;
106 UINTN BootOrderListSize;
107 UINTN Index;
108
109 BootOrderList = NULL;
110 BootOrderListSize = 0;
111 //
112 // First check whether BootOrder is present in current configuration
113 //
114 GetEfiGlobalVariable2 (L"BootOrder", (VOID **) &BootOrderList, &BootOrderListSize);
115
116 //
117 // If exists, delete it to hold new BootOrder
118 //
119 if (BootOrderList != NULL) {
120 EfiLibDeleteVariable (L"BootOrder", &gEfiGlobalVariableGuid);
121 FreePool (BootOrderList);
122 BootOrderList = NULL;
123 }
124 //
125 // Maybe here should be some check method to ensure that
126 // no new added boot options will be added
127 // but the setup engine now will give only one callback
128 // that is to say, user are granted only one chance to
129 // decide whether the boot option will be added or not
130 // there should be no indictor to show whether this
131 // is a "new" boot option
132 //
133 BootOrderListSize = BootOptionMenu.MenuNumber;
134
135 if (BootOrderListSize > 0) {
136 BootOrderList = AllocateZeroPool (BootOrderListSize * sizeof (UINT16));
137 ASSERT (BootOrderList != NULL);
138 BootOrderListPtr = BootOrderList;
139
140 //
141 // Get all current used Boot#### from BootOptionMenu.
142 // OptionNumber in each BM_LOAD_OPTION is really its
143 // #### value.
144 //
145 for (Index = 0; Index < BootOrderListSize; Index++) {
146 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
147 *BootOrderList = (UINT16) NewMenuEntry->OptionNumber;
148 BootOrderList++;
149 }
150
151 BootOrderList = BootOrderListPtr;
152
153 //
154 // After building the BootOrderList, write it back
155 //
156 Status = gRT->SetVariable (
157 L"BootOrder",
158 &gEfiGlobalVariableGuid,
159 VAR_FLAG,
160 BootOrderListSize * sizeof (UINT16),
161 BootOrderList
162 );
163 if (EFI_ERROR (Status)) {
164 return Status;
165 }
166 }
167 return EFI_SUCCESS;
168 }
169
170 /**
171 Delete Load Option that represent a Deleted state in BootOptionMenu.
172 After deleting this Driver option, call Var_ChangeDriverOrder to
173 make sure DriverOrder is in valid state.
174
175 @retval EFI_SUCCESS Load Option is successfully updated.
176 @retval EFI_NOT_FOUND Fail to find the driver option want to be deleted.
177 @return Other value than EFI_SUCCESS if failed to update "Driver Order" EFI
178 Variable.
179
180 **/
181 EFI_STATUS
182 Var_DelDriverOption (
183 VOID
184 )
185 {
186 BM_MENU_ENTRY *NewMenuEntry;
187 BM_LOAD_CONTEXT *NewLoadContext;
188 UINT16 DriverString[12];
189 EFI_STATUS Status;
190 UINTN Index;
191 UINTN Index2;
192
193 Status = EFI_SUCCESS;
194 Index2 = 0;
195 for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
196 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, (Index - Index2));
197 if (NULL == NewMenuEntry) {
198 return EFI_NOT_FOUND;
199 }
200
201 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
202 if (!NewLoadContext->Deleted) {
203 continue;
204 }
205
206 UnicodeSPrint (
207 DriverString,
208 sizeof (DriverString),
209 L"Driver%04x",
210 NewMenuEntry->OptionNumber
211 );
212
213 EfiLibDeleteVariable (DriverString, &gEfiGlobalVariableGuid);
214 Index2++;
215
216 RemoveEntryList (&NewMenuEntry->Link);
217 BOpt_DestroyMenuEntry (NewMenuEntry);
218 NewMenuEntry = NULL;
219 }
220
221 DriverOptionMenu.MenuNumber -= Index2;
222
223 Status = Var_ChangeDriverOrder ();
224 return Status;
225 }
226
227 /**
228 After any operation on Driver####, there will be a discrepancy in
229 DriverOrder. Since some are missing but in DriverOrder, while some
230 are present but are not reflected by DriverOrder. Then a function
231 rebuild DriverOrder from scratch by content from DriverOptionMenu is
232 needed.
233
234 @retval EFI_SUCCESS The driver order is updated successfully.
235 @return Other status than EFI_SUCCESS if failed to set the "DriverOrder" EFI Variable.
236
237 **/
238 EFI_STATUS
239 Var_ChangeDriverOrder (
240 VOID
241 )
242 {
243 EFI_STATUS Status;
244 BM_MENU_ENTRY *NewMenuEntry;
245 UINT16 *DriverOrderList;
246 UINT16 *DriverOrderListPtr;
247 UINTN DriverOrderListSize;
248 UINTN Index;
249
250 DriverOrderList = NULL;
251 DriverOrderListSize = 0;
252
253 //
254 // First check whether DriverOrder is present in current configuration
255 //
256 GetEfiGlobalVariable2 (L"DriverOrder", (VOID **) &DriverOrderList, &DriverOrderListSize);
257 //
258 // If exists, delete it to hold new DriverOrder
259 //
260 if (DriverOrderList != NULL) {
261 EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
262 FreePool (DriverOrderList);
263 DriverOrderList = NULL;
264 }
265
266 DriverOrderListSize = DriverOptionMenu.MenuNumber;
267
268 if (DriverOrderListSize > 0) {
269 DriverOrderList = AllocateZeroPool (DriverOrderListSize * sizeof (UINT16));
270 ASSERT (DriverOrderList != NULL);
271 DriverOrderListPtr = DriverOrderList;
272
273 //
274 // Get all current used Driver#### from DriverOptionMenu.
275 // OptionNumber in each BM_LOAD_OPTION is really its
276 // #### value.
277 //
278 for (Index = 0; Index < DriverOrderListSize; Index++) {
279 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
280 *DriverOrderList = (UINT16) NewMenuEntry->OptionNumber;
281 DriverOrderList++;
282 }
283
284 DriverOrderList = DriverOrderListPtr;
285
286 //
287 // After building the DriverOrderList, write it back
288 //
289 Status = gRT->SetVariable (
290 L"DriverOrder",
291 &gEfiGlobalVariableGuid,
292 VAR_FLAG,
293 DriverOrderListSize * sizeof (UINT16),
294 DriverOrderList
295 );
296 if (EFI_ERROR (Status)) {
297 return Status;
298 }
299 }
300 return EFI_SUCCESS;
301 }
302
303 /**
304 Update the device path of "ConOut", "ConIn" and "ErrOut"
305 based on the new BaudRate, Data Bits, parity and Stop Bits
306 set.
307
308 **/
309 VOID
310 Var_UpdateAllConsoleOption (
311 VOID
312 )
313 {
314 EFI_DEVICE_PATH_PROTOCOL *OutDevicePath;
315 EFI_DEVICE_PATH_PROTOCOL *InpDevicePath;
316 EFI_DEVICE_PATH_PROTOCOL *ErrDevicePath;
317 EFI_STATUS Status;
318
319 GetEfiGlobalVariable2 (L"ConOut", (VOID**)&OutDevicePath, NULL);
320 GetEfiGlobalVariable2 (L"ConIn", (VOID**)&InpDevicePath, NULL);
321 GetEfiGlobalVariable2 (L"ErrOut", (VOID**)&ErrDevicePath, NULL);
322 if (OutDevicePath != NULL) {
323 ChangeVariableDevicePath (OutDevicePath);
324 Status = gRT->SetVariable (
325 L"ConOut",
326 &gEfiGlobalVariableGuid,
327 VAR_FLAG,
328 GetDevicePathSize (OutDevicePath),
329 OutDevicePath
330 );
331 ASSERT (!EFI_ERROR (Status));
332 }
333
334 if (InpDevicePath != NULL) {
335 ChangeVariableDevicePath (InpDevicePath);
336 Status = gRT->SetVariable (
337 L"ConIn",
338 &gEfiGlobalVariableGuid,
339 VAR_FLAG,
340 GetDevicePathSize (InpDevicePath),
341 InpDevicePath
342 );
343 ASSERT (!EFI_ERROR (Status));
344 }
345
346 if (ErrDevicePath != NULL) {
347 ChangeVariableDevicePath (ErrDevicePath);
348 Status = gRT->SetVariable (
349 L"ErrOut",
350 &gEfiGlobalVariableGuid,
351 VAR_FLAG,
352 GetDevicePathSize (ErrDevicePath),
353 ErrDevicePath
354 );
355 ASSERT (!EFI_ERROR (Status));
356 }
357 }
358
359 /**
360 This function delete and build multi-instance device path for
361 specified type of console device.
362
363 This function clear the EFI variable defined by ConsoleName and
364 gEfiGlobalVariableGuid. It then build the multi-instance device
365 path by appending the device path of the Console (In/Out/Err) instance
366 in ConsoleMenu. Then it scan all corresponding console device by
367 scanning Terminal (built from device supporting Serial I/O instances)
368 devices in TerminalMenu. At last, it save a EFI variable specifed
369 by ConsoleName and gEfiGlobalVariableGuid.
370
371 @param ConsoleName The name for the console device type. They are
372 usually "ConIn", "ConOut" and "ErrOut".
373 @param ConsoleMenu The console memu which is a list of console devices.
374 @param UpdatePageId The flag specifying which type of console device
375 to be processed.
376
377 @retval EFI_SUCCESS The function complete successfully.
378 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
379
380 **/
381 EFI_STATUS
382 Var_UpdateConsoleOption (
383 IN UINT16 *ConsoleName,
384 IN BM_MENU_OPTION *ConsoleMenu,
385 IN UINT16 UpdatePageId
386 )
387 {
388 EFI_DEVICE_PATH_PROTOCOL *ConDevicePath;
389 BM_MENU_ENTRY *NewMenuEntry;
390 BM_CONSOLE_CONTEXT *NewConsoleContext;
391 BM_TERMINAL_CONTEXT *NewTerminalContext;
392 EFI_STATUS Status;
393 VENDOR_DEVICE_PATH Vendor;
394 EFI_DEVICE_PATH_PROTOCOL *TerminalDevicePath;
395 UINTN Index;
396
397 GetEfiGlobalVariable2 (ConsoleName, (VOID**)&ConDevicePath, NULL);
398 if (ConDevicePath != NULL) {
399 EfiLibDeleteVariable (ConsoleName, &gEfiGlobalVariableGuid);
400 FreePool (ConDevicePath);
401 ConDevicePath = NULL;
402 };
403
404 //
405 // First add all console input device from console input menu
406 //
407 for (Index = 0; Index < ConsoleMenu->MenuNumber; Index++) {
408 NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index);
409
410 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
411 if (NewConsoleContext->IsActive) {
412 ConDevicePath = AppendDevicePathInstance (
413 ConDevicePath,
414 NewConsoleContext->DevicePath
415 );
416 }
417 }
418
419 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
420 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
421
422 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
423 if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
424 ((NewTerminalContext->IsConOut != 0) && (UpdatePageId == FORM_CON_OUT_ID)) ||
425 ((NewTerminalContext->IsStdErr != 0) && (UpdatePageId == FORM_CON_ERR_ID))
426 ) {
427 Vendor.Header.Type = MESSAGING_DEVICE_PATH;
428 Vendor.Header.SubType = MSG_VENDOR_DP;
429
430 ASSERT (NewTerminalContext->TerminalType < (sizeof (TerminalTypeGuid) / sizeof (TerminalTypeGuid[0])));
431 CopyMem (
432 &Vendor.Guid,
433 &TerminalTypeGuid[NewTerminalContext->TerminalType],
434 sizeof (EFI_GUID)
435 );
436 SetDevicePathNodeLength (&Vendor.Header, sizeof (VENDOR_DEVICE_PATH));
437 TerminalDevicePath = AppendDevicePathNode (
438 NewTerminalContext->DevicePath,
439 (EFI_DEVICE_PATH_PROTOCOL *) &Vendor
440 );
441 ASSERT (TerminalDevicePath != NULL);
442 ChangeTerminalDevicePath (TerminalDevicePath, TRUE);
443 ConDevicePath = AppendDevicePathInstance (
444 ConDevicePath,
445 TerminalDevicePath
446 );
447 }
448 }
449
450 if (ConDevicePath != NULL) {
451 Status = gRT->SetVariable (
452 ConsoleName,
453 &gEfiGlobalVariableGuid,
454 VAR_FLAG,
455 GetDevicePathSize (ConDevicePath),
456 ConDevicePath
457 );
458 if (EFI_ERROR (Status)) {
459 return Status;
460 }
461 }
462
463 return EFI_SUCCESS;
464
465 }
466
467 /**
468 This function delete and build multi-instance device path ConIn
469 console device.
470
471 @retval EFI_SUCCESS The function complete successfully.
472 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
473 **/
474 EFI_STATUS
475 Var_UpdateConsoleInpOption (
476 VOID
477 )
478 {
479 return Var_UpdateConsoleOption (L"ConIn", &ConsoleInpMenu, FORM_CON_IN_ID);
480 }
481
482 /**
483 This function delete and build multi-instance device path ConOut
484 console device.
485
486 @retval EFI_SUCCESS The function complete successfully.
487 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
488 **/
489 EFI_STATUS
490 Var_UpdateConsoleOutOption (
491 VOID
492 )
493 {
494 return Var_UpdateConsoleOption (L"ConOut", &ConsoleOutMenu, FORM_CON_OUT_ID);
495 }
496
497 /**
498 This function delete and build multi-instance device path ErrOut
499 console device.
500
501 @retval EFI_SUCCESS The function complete successfully.
502 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
503 **/
504 EFI_STATUS
505 Var_UpdateErrorOutOption (
506 VOID
507 )
508 {
509 return Var_UpdateConsoleOption (L"ErrOut", &ConsoleErrMenu, FORM_CON_ERR_ID);
510 }
511
512 /**
513 This function create a currently loaded Drive Option from
514 the BMM. It then appends this Driver Option to the end of
515 the "DriverOrder" list. It append this Driver Opotion to the end
516 of DriverOptionMenu.
517
518 @param CallbackData The BMM context data.
519 @param HiiHandle The HII handle associated with the BMM formset.
520 @param DescriptionData The description of this driver option.
521 @param OptionalData The optional load option.
522 @param ForceReconnect If to force reconnect.
523
524 @retval EFI_OUT_OF_RESOURCES If not enought memory to complete the operation.
525 @retval EFI_SUCCESS If function completes successfully.
526
527 **/
528 EFI_STATUS
529 Var_UpdateDriverOption (
530 IN BMM_CALLBACK_DATA *CallbackData,
531 IN EFI_HII_HANDLE HiiHandle,
532 IN UINT16 *DescriptionData,
533 IN UINT16 *OptionalData,
534 IN UINT8 ForceReconnect
535 )
536 {
537 UINT16 Index;
538 UINT16 DriverString[12];
539 BM_MENU_ENTRY *NewMenuEntry;
540 BM_LOAD_CONTEXT *NewLoadContext;
541 BOOLEAN OptionalDataExist;
542 EFI_STATUS Status;
543 EFI_BOOT_MANAGER_LOAD_OPTION LoadOption;
544 UINT8 *OptionalDesData;
545 UINT32 OptionalDataSize;
546
547 OptionalDataExist = FALSE;
548 OptionalDesData = NULL;
549 OptionalDataSize = 0;
550
551 Index = BOpt_GetDriverOptionNumber ();
552 UnicodeSPrint (
553 DriverString,
554 sizeof (DriverString),
555 L"Driver%04x",
556 Index
557 );
558
559 if (*DescriptionData == 0x0000) {
560 StrCpyS (DescriptionData, MAX_MENU_NUMBER, DriverString);
561 }
562
563 if (*OptionalData != 0x0000) {
564 OptionalDataExist = TRUE;
565 OptionalDesData = (UINT8 *)OptionalData;
566 OptionalDataSize = (UINT32)StrSize (OptionalData);
567 }
568
569 NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
570 if (NULL == NewMenuEntry) {
571 return EFI_OUT_OF_RESOURCES;
572 }
573
574 Status = EfiBootManagerInitializeLoadOption (
575 &LoadOption,
576 Index,
577 LoadOptionTypeDriver,
578 LOAD_OPTION_ACTIVE | (ForceReconnect << 1),
579 DescriptionData,
580 CallbackData->LoadContext->FilePathList,
581 OptionalDesData,
582 OptionalDataSize
583 );
584 if (!EFI_ERROR (Status)){
585 Status = EfiBootManagerAddLoadOptionVariable (&LoadOption,(UINTN) -1 );
586 }
587
588 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
589 NewLoadContext->Deleted = FALSE;
590 NewLoadContext->Attributes = LoadOption.Attributes;
591 NewLoadContext->FilePathListLength = (UINT16)GetDevicePathSize (LoadOption.FilePath);
592
593 NewLoadContext->Description = AllocateZeroPool (StrSize (DescriptionData));
594 ASSERT (NewLoadContext->Description != NULL);
595 NewMenuEntry->DisplayString = NewLoadContext->Description;
596 CopyMem (
597 NewLoadContext->Description,
598 LoadOption.Description,
599 StrSize (DescriptionData)
600 );
601
602 NewLoadContext->FilePathList = AllocateZeroPool (GetDevicePathSize (CallbackData->LoadContext->FilePathList));
603 ASSERT (NewLoadContext->FilePathList != NULL);
604 CopyMem (
605 NewLoadContext->FilePathList,
606 LoadOption.FilePath,
607 GetDevicePathSize (CallbackData->LoadContext->FilePathList)
608 );
609
610 NewMenuEntry->HelpString = UiDevicePathToStr (NewLoadContext->FilePathList);
611 NewMenuEntry->OptionNumber = Index;
612 NewMenuEntry->DisplayStringToken = HiiSetString (HiiHandle, 0, NewMenuEntry->DisplayString, NULL);
613 NewMenuEntry->HelpStringToken = HiiSetString (HiiHandle, 0, NewMenuEntry->HelpString, NULL);
614
615 if (OptionalDataExist) {
616 NewLoadContext->OptionalData = AllocateZeroPool (LoadOption.OptionalDataSize);
617 CopyMem (
618 NewLoadContext->OptionalData,
619 LoadOption.OptionalData,
620 LoadOption.OptionalDataSize
621 );
622 }
623
624 InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
625 DriverOptionMenu.MenuNumber++;
626
627 EfiBootManagerFreeLoadOption(&LoadOption);
628
629 return EFI_SUCCESS;
630 }
631
632 /**
633 This function create a currently loaded Boot Option from
634 the BMM. It then appends this Boot Option to the end of
635 the "BootOrder" list. It also append this Boot Opotion to the end
636 of BootOptionMenu.
637
638 @param CallbackData The BMM context data.
639
640 @retval EFI_OUT_OF_RESOURCES If not enought memory to complete the operation.
641 @retval EFI_SUCCESS If function completes successfully.
642
643 **/
644 EFI_STATUS
645 Var_UpdateBootOption (
646 IN BMM_CALLBACK_DATA *CallbackData
647 )
648 {
649 UINT16 BootString[10];
650 UINT16 Index;
651 BM_MENU_ENTRY *NewMenuEntry;
652 BM_LOAD_CONTEXT *NewLoadContext;
653 BOOLEAN OptionalDataExist;
654 EFI_STATUS Status;
655 BMM_FAKE_NV_DATA *NvRamMap;
656 EFI_BOOT_MANAGER_LOAD_OPTION LoadOption;
657 UINT8 *OptionalData;
658 UINT32 OptionalDataSize;
659
660 OptionalDataExist = FALSE;
661 NvRamMap = &CallbackData->BmmFakeNvData;
662 OptionalData = NULL;
663 OptionalDataSize = 0;
664
665 Index = BOpt_GetBootOptionNumber () ;
666 UnicodeSPrint (BootString, sizeof (BootString), L"Boot%04x", Index);
667
668 if (NvRamMap->BootDescriptionData[0] == 0x0000) {
669 StrCpyS (NvRamMap->BootDescriptionData, sizeof (NvRamMap->BootDescriptionData) / sizeof (NvRamMap->BootDescriptionData[0]), BootString);
670 }
671
672 if (NvRamMap->BootOptionalData[0] != 0x0000) {
673 OptionalDataExist = TRUE;
674 OptionalData = (UINT8 *)NvRamMap->BootOptionalData;
675 OptionalDataSize = (UINT32)StrSize (NvRamMap->BootOptionalData);
676 }
677
678 NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
679 if (NULL == NewMenuEntry) {
680 return EFI_OUT_OF_RESOURCES;
681 }
682
683 Status = EfiBootManagerInitializeLoadOption (
684 &LoadOption,
685 Index,
686 LoadOptionTypeBoot,
687 LOAD_OPTION_ACTIVE,
688 NvRamMap->BootDescriptionData,
689 CallbackData->LoadContext->FilePathList,
690 OptionalData,
691 OptionalDataSize
692 );
693 if (!EFI_ERROR (Status)){
694 Status = EfiBootManagerAddLoadOptionVariable (&LoadOption,(UINTN) -1 );
695 }
696
697 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
698 NewLoadContext->Deleted = FALSE;
699 NewLoadContext->Attributes = LoadOption.Attributes;
700 NewLoadContext->FilePathListLength = (UINT16) GetDevicePathSize (LoadOption.FilePath);
701
702 NewLoadContext->Description = AllocateZeroPool (StrSize (NvRamMap->BootDescriptionData));
703 ASSERT (NewLoadContext->Description != NULL);
704
705 NewMenuEntry->DisplayString = NewLoadContext->Description;
706
707 CopyMem (
708 NewLoadContext->Description,
709 LoadOption.Description,
710 StrSize (NvRamMap->BootDescriptionData)
711 );
712
713 NewLoadContext->FilePathList = AllocateZeroPool (GetDevicePathSize (CallbackData->LoadContext->FilePathList));
714 ASSERT (NewLoadContext->FilePathList != NULL);
715 CopyMem (
716 NewLoadContext->FilePathList,
717 LoadOption.FilePath,
718 GetDevicePathSize (CallbackData->LoadContext->FilePathList)
719 );
720
721 NewMenuEntry->HelpString = UiDevicePathToStr (NewLoadContext->FilePathList);
722 NewMenuEntry->OptionNumber = Index;
723 NewMenuEntry->DisplayStringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, NewMenuEntry->DisplayString, NULL);
724 NewMenuEntry->HelpStringToken = HiiSetString (CallbackData->BmmHiiHandle, 0, NewMenuEntry->HelpString, NULL);
725
726 if (OptionalDataExist) {
727 NewLoadContext->OptionalData = AllocateZeroPool (LoadOption.OptionalDataSize);
728 CopyMem (
729 NewLoadContext->OptionalData,
730 LoadOption.OptionalData,
731 LoadOption.OptionalDataSize
732 );
733 }
734
735 InsertTailList (&BootOptionMenu.Head, &NewMenuEntry->Link);
736 BootOptionMenu.MenuNumber++;
737
738 EfiBootManagerFreeLoadOption(&LoadOption);
739
740 return EFI_SUCCESS;
741 }
742
743 /**
744 This function update the "BootNext" EFI Variable. If there is
745 no "BootNext" specified in BMM, this EFI Variable is deleted.
746 It also update the BMM context data specified the "BootNext"
747 vaule.
748
749 @param CallbackData The BMM context data.
750
751 @retval EFI_SUCCESS The function complete successfully.
752 @return The EFI variable can be saved. See gRT->SetVariable
753 for detail return information.
754
755 **/
756 EFI_STATUS
757 Var_UpdateBootNext (
758 IN BMM_CALLBACK_DATA *CallbackData
759 )
760 {
761 BM_MENU_ENTRY *NewMenuEntry;
762 BM_LOAD_CONTEXT *NewLoadContext;
763 BMM_FAKE_NV_DATA *CurrentFakeNVMap;
764 UINT16 Index;
765 EFI_STATUS Status;
766
767 Status = EFI_SUCCESS;
768 CurrentFakeNVMap = &CallbackData->BmmFakeNvData;
769 for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
770 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
771 ASSERT (NULL != NewMenuEntry);
772
773 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
774 NewLoadContext->IsBootNext = FALSE;
775 }
776
777 if (CurrentFakeNVMap->BootNext == NONE_BOOTNEXT_VALUE) {
778 EfiLibDeleteVariable (L"BootNext", &gEfiGlobalVariableGuid);
779 return EFI_SUCCESS;
780 }
781
782 NewMenuEntry = BOpt_GetMenuEntry (
783 &BootOptionMenu,
784 CurrentFakeNVMap->BootNext
785 );
786 ASSERT (NewMenuEntry != NULL);
787
788 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
789 Status = gRT->SetVariable (
790 L"BootNext",
791 &gEfiGlobalVariableGuid,
792 VAR_FLAG,
793 sizeof (UINT16),
794 &NewMenuEntry->OptionNumber
795 );
796 NewLoadContext->IsBootNext = TRUE;
797 CallbackData->BmmOldFakeNVData.BootNext = CurrentFakeNVMap->BootNext;
798 return Status;
799 }
800
801 /**
802 This function update the "BootOrder" EFI Variable based on
803 BMM Formset's NV map. It then refresh BootOptionMenu
804 with the new "BootOrder" list.
805
806 @param CallbackData The BMM context data.
807
808 @retval EFI_SUCCESS The function complete successfully.
809 @retval EFI_OUT_OF_RESOURCES Not enough memory to complete the function.
810 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
811
812 **/
813 EFI_STATUS
814 Var_UpdateBootOrder (
815 IN BMM_CALLBACK_DATA *CallbackData
816 )
817 {
818 EFI_STATUS Status;
819 UINT16 Index;
820 UINT16 OrderIndex;
821 UINT16 *BootOrder;
822 UINTN BootOrderSize;
823 UINT16 OptionNumber;
824
825 //
826 // First check whether BootOrder is present in current configuration
827 //
828 GetEfiGlobalVariable2 (L"BootOrder", (VOID **) &BootOrder, &BootOrderSize);
829 if (BootOrder == NULL) {
830 return EFI_OUT_OF_RESOURCES;
831 }
832
833 ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.BootOptionOrder) / sizeof (CallbackData->BmmFakeNvData.BootOptionOrder[0])));
834
835 //
836 // OptionOrder is subset of BootOrder
837 //
838 for (OrderIndex = 0; (OrderIndex < BootOptionMenu.MenuNumber) && (CallbackData->BmmFakeNvData.BootOptionOrder[OrderIndex] != 0); OrderIndex++) {
839 for (Index = OrderIndex; Index < BootOrderSize / sizeof (UINT16); Index++) {
840 if ((BootOrder[Index] == (UINT16) (CallbackData->BmmFakeNvData.BootOptionOrder[OrderIndex] - 1)) && (OrderIndex != Index)) {
841 OptionNumber = BootOrder[Index];
842 CopyMem (&BootOrder[OrderIndex + 1], &BootOrder[OrderIndex], (Index - OrderIndex) * sizeof (UINT16));
843 BootOrder[OrderIndex] = OptionNumber;
844 }
845 }
846 }
847
848 Status = gRT->SetVariable (
849 L"BootOrder",
850 &gEfiGlobalVariableGuid,
851 VAR_FLAG,
852 BootOrderSize,
853 BootOrder
854 );
855 FreePool (BootOrder);
856
857 BOpt_FreeMenu (&BootOptionMenu);
858 BOpt_GetBootOptions (CallbackData);
859
860 return Status;
861
862 }
863
864 /**
865 This function update the "DriverOrder" EFI Variable based on
866 BMM Formset's NV map. It then refresh DriverOptionMenu
867 with the new "DriverOrder" list.
868
869 @param CallbackData The BMM context data.
870
871 @retval EFI_SUCCESS The function complete successfully.
872 @retval EFI_OUT_OF_RESOURCES Not enough memory to complete the function.
873 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
874
875 **/
876 EFI_STATUS
877 Var_UpdateDriverOrder (
878 IN BMM_CALLBACK_DATA *CallbackData
879 )
880 {
881 EFI_STATUS Status;
882 UINT16 Index;
883 UINT16 *DriverOrderList;
884 UINT16 *NewDriverOrderList;
885 UINTN DriverOrderListSize;
886
887 DriverOrderList = NULL;
888 DriverOrderListSize = 0;
889
890 //
891 // First check whether DriverOrder is present in current configuration
892 //
893 GetEfiGlobalVariable2 (L"DriverOrder", (VOID **) &DriverOrderList, &DriverOrderListSize);
894 NewDriverOrderList = AllocateZeroPool (DriverOrderListSize);
895
896 if (NewDriverOrderList == NULL) {
897 return EFI_OUT_OF_RESOURCES;
898 }
899 //
900 // If exists, delete it to hold new DriverOrder
901 //
902 if (DriverOrderList != NULL) {
903 EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
904 FreePool (DriverOrderList);
905 }
906
907 ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.DriverOptionOrder) / sizeof (CallbackData->BmmFakeNvData.DriverOptionOrder[0])));
908 for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
909 NewDriverOrderList[Index] = (UINT16) (CallbackData->BmmFakeNvData.DriverOptionOrder[Index] - 1);
910 }
911
912 Status = gRT->SetVariable (
913 L"DriverOrder",
914 &gEfiGlobalVariableGuid,
915 VAR_FLAG,
916 DriverOrderListSize,
917 NewDriverOrderList
918 );
919 if (EFI_ERROR (Status)) {
920 return Status;
921 }
922
923 BOpt_FreeMenu (&DriverOptionMenu);
924 BOpt_GetDriverOptions (CallbackData);
925 return EFI_SUCCESS;
926 }
927
928 /**
929 Update the Text Mode of Console.
930
931 @param CallbackData The context data for BMM.
932
933 @retval EFI_SUCCSS If the Text Mode of Console is updated.
934 @return Other value if the Text Mode of Console is not updated.
935
936 **/
937 EFI_STATUS
938 Var_UpdateConMode (
939 IN BMM_CALLBACK_DATA *CallbackData
940 )
941 {
942 EFI_STATUS Status;
943 UINTN Mode;
944 CONSOLE_OUT_MODE ModeInfo;
945
946 Mode = CallbackData->BmmFakeNvData.ConsoleOutMode;
947
948 Status = gST->ConOut->QueryMode (gST->ConOut, Mode, &(ModeInfo.Column), &(ModeInfo.Row));
949 if (!EFI_ERROR(Status)) {
950 Status = PcdSet32S (PcdSetupConOutColumn, (UINT32) ModeInfo.Column);
951 if (!EFI_ERROR (Status)) {
952 Status = PcdSet32S (PcdSetupConOutRow, (UINT32) ModeInfo.Row);
953 }
954 }
955
956 return Status;
957 }