Update for IntelFrameworkModulePkg.
[mirror_edk2.git] / IntelFrameworkModulePkg / Universal / BdsDxe / BootMaint / Variable.c
1 /** @file
2 Variable operation that will be used by bootmaint
3
4 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "BootMaint.h"
16
17 /**
18 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 //
113 // First check whether BootOrder is present in current configuration
114 //
115 BootOrderList = BdsLibGetVariableAndSize (
116 L"BootOrder",
117 &gEfiGlobalVariableGuid,
118 &BootOrderListSize
119 );
120
121 //
122 // If exists, delete it to hold new BootOrder
123 //
124 if (BootOrderList != NULL) {
125 EfiLibDeleteVariable (L"BootOrder", &gEfiGlobalVariableGuid);
126 FreePool (BootOrderList);
127 BootOrderList = NULL;
128 }
129 //
130 // Maybe here should be some check method to ensure that
131 // no new added boot options will be added
132 // but the setup engine now will give only one callback
133 // that is to say, user are granted only one chance to
134 // decide whether the boot option will be added or not
135 // there should be no indictor to show whether this
136 // is a "new" boot option
137 //
138 BootOrderListSize = BootOptionMenu.MenuNumber;
139
140 if (BootOrderListSize > 0) {
141 BootOrderList = AllocateZeroPool (BootOrderListSize * sizeof (UINT16));
142 ASSERT (BootOrderList != NULL);
143 BootOrderListPtr = BootOrderList;
144
145 //
146 // Get all current used Boot#### from BootOptionMenu.
147 // OptionNumber in each BM_LOAD_OPTION is really its
148 // #### value.
149 //
150 for (Index = 0; Index < BootOrderListSize; Index++) {
151 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
152 *BootOrderList = (UINT16) NewMenuEntry->OptionNumber;
153 BootOrderList++;
154 }
155
156 BootOrderList = BootOrderListPtr;
157
158 //
159 // After building the BootOrderList, write it back
160 //
161 Status = gRT->SetVariable (
162 L"BootOrder",
163 &gEfiGlobalVariableGuid,
164 VAR_FLAG,
165 BootOrderListSize * sizeof (UINT16),
166 BootOrderList
167 );
168 if (EFI_ERROR (Status)) {
169 return Status;
170 }
171 }
172 return EFI_SUCCESS;
173 }
174
175 /**
176 Delete Load Option that represent a Deleted state in BootOptionMenu.
177 After deleting this Driver option, call Var_ChangeDriverOrder to
178 make sure DriverOrder is in valid state.
179
180 @retval EFI_SUCCESS Load Option is successfully updated.
181 @retval EFI_NOT_FOUND Fail to find the driver option want to be deleted.
182 @return Other value than EFI_SUCCESS if failed to update "Driver Order" EFI
183 Variable.
184
185 **/
186 EFI_STATUS
187 Var_DelDriverOption (
188 VOID
189 )
190 {
191 BM_MENU_ENTRY *NewMenuEntry;
192 BM_LOAD_CONTEXT *NewLoadContext;
193 UINT16 DriverString[12];
194 EFI_STATUS Status;
195 UINTN Index;
196 UINTN Index2;
197
198 Status = EFI_SUCCESS;
199 Index2 = 0;
200 for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
201 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, (Index - Index2));
202 if (NULL == NewMenuEntry) {
203 return EFI_NOT_FOUND;
204 }
205
206 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
207 if (!NewLoadContext->Deleted) {
208 continue;
209 }
210
211 UnicodeSPrint (
212 DriverString,
213 sizeof (DriverString),
214 L"Driver%04x",
215 NewMenuEntry->OptionNumber
216 );
217
218 EfiLibDeleteVariable (DriverString, &gEfiGlobalVariableGuid);
219 Index2++;
220
221 RemoveEntryList (&NewMenuEntry->Link);
222 BOpt_DestroyMenuEntry (NewMenuEntry);
223 NewMenuEntry = NULL;
224 }
225
226 DriverOptionMenu.MenuNumber -= Index2;
227
228 Status = Var_ChangeDriverOrder ();
229 return Status;
230 }
231
232 /**
233 After any operation on Driver####, there will be a discrepancy in
234 DriverOrder. Since some are missing but in DriverOrder, while some
235 are present but are not reflected by DriverOrder. Then a function
236 rebuild DriverOrder from scratch by content from DriverOptionMenu is
237 needed.
238
239 @retval EFI_SUCCESS The driver order is updated successfully.
240 @return Other status than EFI_SUCCESS if failed to set the "DriverOrder" EFI Variable.
241
242 **/
243 EFI_STATUS
244 Var_ChangeDriverOrder (
245 VOID
246 )
247 {
248 EFI_STATUS Status;
249 BM_MENU_ENTRY *NewMenuEntry;
250 UINT16 *DriverOrderList;
251 UINT16 *DriverOrderListPtr;
252 UINTN DriverOrderListSize;
253 UINTN Index;
254
255 DriverOrderList = NULL;
256 DriverOrderListSize = 0;
257
258 //
259 // First check whether DriverOrder is present in current configuration
260 //
261 DriverOrderList = BdsLibGetVariableAndSize (
262 L"DriverOrder",
263 &gEfiGlobalVariableGuid,
264 &DriverOrderListSize
265 );
266
267 //
268 // If exists, delete it to hold new DriverOrder
269 //
270 if (DriverOrderList != NULL) {
271 EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
272 FreePool (DriverOrderList);
273 DriverOrderList = NULL;
274 }
275
276 DriverOrderListSize = DriverOptionMenu.MenuNumber;
277
278 if (DriverOrderListSize > 0) {
279 DriverOrderList = AllocateZeroPool (DriverOrderListSize * sizeof (UINT16));
280 ASSERT (DriverOrderList != NULL);
281 DriverOrderListPtr = DriverOrderList;
282
283 //
284 // Get all current used Driver#### from DriverOptionMenu.
285 // OptionNumber in each BM_LOAD_OPTION is really its
286 // #### value.
287 //
288 for (Index = 0; Index < DriverOrderListSize; Index++) {
289 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index);
290 *DriverOrderList = (UINT16) NewMenuEntry->OptionNumber;
291 DriverOrderList++;
292 }
293
294 DriverOrderList = DriverOrderListPtr;
295
296 //
297 // After building the DriverOrderList, write it back
298 //
299 Status = gRT->SetVariable (
300 L"DriverOrder",
301 &gEfiGlobalVariableGuid,
302 VAR_FLAG,
303 DriverOrderListSize * sizeof (UINT16),
304 DriverOrderList
305 );
306 if (EFI_ERROR (Status)) {
307 return Status;
308 }
309 }
310 return EFI_SUCCESS;
311 }
312
313 /**
314 Update the device path of "ConOut", "ConIn" and "ErrOut"
315 based on the new BaudRate, Data Bits, parity and Stop Bits
316 set.
317
318 **/
319 VOID
320 Var_UpdateAllConsoleOption (
321 VOID
322 )
323 {
324 EFI_DEVICE_PATH_PROTOCOL *OutDevicePath;
325 EFI_DEVICE_PATH_PROTOCOL *InpDevicePath;
326 EFI_DEVICE_PATH_PROTOCOL *ErrDevicePath;
327 EFI_STATUS Status;
328
329 OutDevicePath = EfiLibGetVariable (L"ConOut", &gEfiGlobalVariableGuid);
330 InpDevicePath = EfiLibGetVariable (L"ConIn", &gEfiGlobalVariableGuid);
331 ErrDevicePath = EfiLibGetVariable (L"ErrOut", &gEfiGlobalVariableGuid);
332 if (OutDevicePath != NULL) {
333 ChangeVariableDevicePath (OutDevicePath);
334 Status = gRT->SetVariable (
335 L"ConOut",
336 &gEfiGlobalVariableGuid,
337 VAR_FLAG,
338 GetDevicePathSize (OutDevicePath),
339 OutDevicePath
340 );
341 ASSERT (!EFI_ERROR (Status));
342 }
343
344 if (InpDevicePath != NULL) {
345 ChangeVariableDevicePath (InpDevicePath);
346 Status = gRT->SetVariable (
347 L"ConIn",
348 &gEfiGlobalVariableGuid,
349 VAR_FLAG,
350 GetDevicePathSize (InpDevicePath),
351 InpDevicePath
352 );
353 ASSERT (!EFI_ERROR (Status));
354 }
355
356 if (ErrDevicePath != NULL) {
357 ChangeVariableDevicePath (ErrDevicePath);
358 Status = gRT->SetVariable (
359 L"ErrOut",
360 &gEfiGlobalVariableGuid,
361 VAR_FLAG,
362 GetDevicePathSize (ErrDevicePath),
363 ErrDevicePath
364 );
365 ASSERT (!EFI_ERROR (Status));
366 }
367 }
368
369 /**
370 This function delete and build multi-instance device path for
371 specified type of console device.
372
373 This function clear the EFI variable defined by ConsoleName and
374 gEfiGlobalVariableGuid. It then build the multi-instance device
375 path by appending the device path of the Console (In/Out/Err) instance
376 in ConsoleMenu. Then it scan all corresponding console device by
377 scanning Terminal (built from device supporting Serial I/O instances)
378 devices in TerminalMenu. At last, it save a EFI variable specifed
379 by ConsoleName and gEfiGlobalVariableGuid.
380
381 @param ConsoleName The name for the console device type. They are
382 usually "ConIn", "ConOut" and "ErrOut".
383 @param ConsoleMenu The console memu which is a list of console devices.
384 @param UpdatePageId The flag specifying which type of console device
385 to be processed.
386
387 @retval EFI_SUCCESS The function complete successfully.
388 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
389
390 **/
391 EFI_STATUS
392 Var_UpdateConsoleOption (
393 IN UINT16 *ConsoleName,
394 IN BM_MENU_OPTION *ConsoleMenu,
395 IN UINT16 UpdatePageId
396 )
397 {
398 EFI_DEVICE_PATH_PROTOCOL *ConDevicePath;
399 BM_MENU_ENTRY *NewMenuEntry;
400 BM_CONSOLE_CONTEXT *NewConsoleContext;
401 BM_TERMINAL_CONTEXT *NewTerminalContext;
402 EFI_STATUS Status;
403 VENDOR_DEVICE_PATH Vendor;
404 EFI_DEVICE_PATH_PROTOCOL *TerminalDevicePath;
405 UINTN Index;
406
407 ConDevicePath = EfiLibGetVariable (ConsoleName, &gEfiGlobalVariableGuid);
408 if (ConDevicePath != NULL) {
409 EfiLibDeleteVariable (ConsoleName, &gEfiGlobalVariableGuid);
410 FreePool (ConDevicePath);
411 ConDevicePath = NULL;
412 };
413
414 //
415 // First add all console input device from console input menu
416 //
417 for (Index = 0; Index < ConsoleMenu->MenuNumber; Index++) {
418 NewMenuEntry = BOpt_GetMenuEntry (ConsoleMenu, Index);
419
420 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
421 if (NewConsoleContext->IsActive) {
422 ConDevicePath = AppendDevicePathInstance (
423 ConDevicePath,
424 NewConsoleContext->DevicePath
425 );
426 }
427 }
428
429 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
430 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
431
432 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
433 if (((NewTerminalContext->IsConIn != 0) && (UpdatePageId == FORM_CON_IN_ID)) ||
434 ((NewTerminalContext->IsConOut != 0) && (UpdatePageId == FORM_CON_OUT_ID)) ||
435 ((NewTerminalContext->IsStdErr != 0) && (UpdatePageId == FORM_CON_ERR_ID))
436 ) {
437 Vendor.Header.Type = MESSAGING_DEVICE_PATH;
438 Vendor.Header.SubType = MSG_VENDOR_DP;
439
440 ASSERT (NewTerminalContext->TerminalType < (sizeof (TerminalTypeGuid) / sizeof (TerminalTypeGuid[0])));
441 CopyMem (
442 &Vendor.Guid,
443 &TerminalTypeGuid[NewTerminalContext->TerminalType],
444 sizeof (EFI_GUID)
445 );
446 SetDevicePathNodeLength (&Vendor.Header, sizeof (VENDOR_DEVICE_PATH));
447 TerminalDevicePath = AppendDevicePathNode (
448 NewTerminalContext->DevicePath,
449 (EFI_DEVICE_PATH_PROTOCOL *) &Vendor
450 );
451 ASSERT (TerminalDevicePath != NULL);
452 ChangeTerminalDevicePath (&TerminalDevicePath, TRUE);
453 ConDevicePath = AppendDevicePathInstance (
454 ConDevicePath,
455 TerminalDevicePath
456 );
457 }
458 }
459
460 if (ConDevicePath != NULL) {
461 Status = gRT->SetVariable (
462 ConsoleName,
463 &gEfiGlobalVariableGuid,
464 VAR_FLAG,
465 GetDevicePathSize (ConDevicePath),
466 ConDevicePath
467 );
468 if (EFI_ERROR (Status)) {
469 return Status;
470 }
471 }
472
473 return EFI_SUCCESS;
474
475 }
476
477 /**
478 This function delete and build multi-instance device path ConIn
479 console device.
480
481 @retval EFI_SUCCESS The function complete successfully.
482 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
483 **/
484 EFI_STATUS
485 Var_UpdateConsoleInpOption (
486 VOID
487 )
488 {
489 return Var_UpdateConsoleOption (L"ConIn", &ConsoleInpMenu, FORM_CON_IN_ID);
490 }
491
492 /**
493 This function delete and build multi-instance device path ConOut
494 console device.
495
496 @retval EFI_SUCCESS The function complete successfully.
497 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
498 **/
499 EFI_STATUS
500 Var_UpdateConsoleOutOption (
501 VOID
502 )
503 {
504 return Var_UpdateConsoleOption (L"ConOut", &ConsoleOutMenu, FORM_CON_OUT_ID);
505 }
506
507 /**
508 This function delete and build multi-instance device path ErrOut
509 console device.
510
511 @retval EFI_SUCCESS The function complete successfully.
512 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
513 **/
514 EFI_STATUS
515 Var_UpdateErrorOutOption (
516 VOID
517 )
518 {
519 return Var_UpdateConsoleOption (L"ErrOut", &ConsoleErrMenu, FORM_CON_ERR_ID);
520 }
521
522 /**
523 This function create a currently loaded Drive Option from
524 the BMM. It then appends this Driver Option to the end of
525 the "DriverOrder" list. It append this Driver Opotion to the end
526 of DriverOptionMenu.
527
528 @param CallbackData The BMM context data.
529 @param HiiHandle The HII handle associated with the BMM formset.
530 @param DescriptionData The description of this driver option.
531 @param OptionalData The optional load option.
532 @param ForceReconnect If to force reconnect.
533
534 @retval EFI_OUT_OF_RESOURCES If not enought memory to complete the operation.
535 @retval EFI_SUCCESS If function completes successfully.
536
537 **/
538 EFI_STATUS
539 Var_UpdateDriverOption (
540 IN BMM_CALLBACK_DATA *CallbackData,
541 IN EFI_HII_HANDLE HiiHandle,
542 IN UINT16 *DescriptionData,
543 IN UINT16 *OptionalData,
544 IN UINT8 ForceReconnect
545 )
546 {
547 UINT16 Index;
548 UINT16 *DriverOrderList;
549 UINT16 *NewDriverOrderList;
550 UINT16 DriverString[12];
551 UINTN DriverOrderListSize;
552 VOID *Buffer;
553 UINTN BufferSize;
554 UINT8 *Ptr;
555 BM_MENU_ENTRY *NewMenuEntry;
556 BM_LOAD_CONTEXT *NewLoadContext;
557 BOOLEAN OptionalDataExist;
558 EFI_STATUS Status;
559
560 OptionalDataExist = FALSE;
561
562 Index = BOpt_GetDriverOptionNumber ();
563 UnicodeSPrint (
564 DriverString,
565 sizeof (DriverString),
566 L"Driver%04x",
567 Index
568 );
569
570 if (*DescriptionData == 0x0000) {
571 StrCpy (DescriptionData, DriverString);
572 }
573
574 BufferSize = sizeof (UINT32) + sizeof (UINT16) + StrSize (DescriptionData);
575 BufferSize += GetDevicePathSize (CallbackData->LoadContext->FilePathList);
576
577 if (*OptionalData != 0x0000) {
578 OptionalDataExist = TRUE;
579 BufferSize += StrSize (OptionalData);
580 }
581
582 Buffer = AllocateZeroPool (BufferSize);
583 if (NULL == Buffer) {
584 return EFI_OUT_OF_RESOURCES;
585 }
586
587 NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
588 if (NULL == NewMenuEntry) {
589 FreePool (Buffer);
590 return EFI_OUT_OF_RESOURCES;
591 }
592
593 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
594 NewLoadContext->Deleted = FALSE;
595 NewLoadContext->LoadOptionSize = BufferSize;
596 Ptr = (UINT8 *) Buffer;
597 NewLoadContext->LoadOption = Ptr;
598 *((UINT32 *) Ptr) = LOAD_OPTION_ACTIVE | (ForceReconnect << 1);
599 NewLoadContext->Attributes = *((UINT32 *) Ptr);
600 NewLoadContext->IsActive = TRUE;
601 NewLoadContext->ForceReconnect = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
602
603 Ptr += sizeof (UINT32);
604 *((UINT16 *) Ptr) = (UINT16) GetDevicePathSize (CallbackData->LoadContext->FilePathList);
605 NewLoadContext->FilePathListLength = *((UINT16 *) Ptr);
606
607 Ptr += sizeof (UINT16);
608 CopyMem (
609 Ptr,
610 DescriptionData,
611 StrSize (DescriptionData)
612 );
613
614 NewLoadContext->Description = AllocateZeroPool (StrSize (DescriptionData));
615 ASSERT (NewLoadContext->Description != NULL);
616 NewMenuEntry->DisplayString = NewLoadContext->Description;
617 CopyMem (
618 NewLoadContext->Description,
619 (VOID *) Ptr,
620 StrSize (DescriptionData)
621 );
622
623 Ptr += StrSize (DescriptionData);
624 CopyMem (
625 Ptr,
626 CallbackData->LoadContext->FilePathList,
627 GetDevicePathSize (CallbackData->LoadContext->FilePathList)
628 );
629
630 NewLoadContext->FilePathList = AllocateZeroPool (GetDevicePathSize (CallbackData->LoadContext->FilePathList));
631 ASSERT (NewLoadContext->FilePathList != NULL);
632
633 CopyMem (
634 NewLoadContext->FilePathList,
635 (VOID *) Ptr,
636 GetDevicePathSize (CallbackData->LoadContext->FilePathList)
637 );
638
639 NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
640 NewMenuEntry->OptionNumber = Index;
641 NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
642 CallbackData,
643 DriverOptionStrDepository
644 );
645 NewMenuEntry->DisplayStringToken = HiiSetString (HiiHandle, 0, NewMenuEntry->DisplayString, NULL);
646
647 NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
648 CallbackData,
649 DriverOptionHelpStrDepository
650 );
651 NewMenuEntry->HelpStringToken = HiiSetString (HiiHandle, 0, NewMenuEntry->HelpString, NULL);
652
653 if (OptionalDataExist) {
654 Ptr += (UINT8) GetDevicePathSize (CallbackData->LoadContext->FilePathList);
655
656 CopyMem (
657 Ptr,
658 OptionalData,
659 StrSize (OptionalData)
660 );
661 }
662
663 Status = gRT->SetVariable (
664 DriverString,
665 &gEfiGlobalVariableGuid,
666 VAR_FLAG,
667 BufferSize,
668 Buffer
669 );
670 ASSERT_EFI_ERROR (Status);
671 DriverOrderList = BdsLibGetVariableAndSize (
672 L"DriverOrder",
673 &gEfiGlobalVariableGuid,
674 &DriverOrderListSize
675 );
676 NewDriverOrderList = AllocateZeroPool (DriverOrderListSize + sizeof (UINT16));
677 ASSERT (NewDriverOrderList != NULL);
678 if (DriverOrderList != NULL) {
679 CopyMem (NewDriverOrderList, DriverOrderList, DriverOrderListSize);
680 EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
681 }
682 NewDriverOrderList[DriverOrderListSize / sizeof (UINT16)] = Index;
683
684 Status = gRT->SetVariable (
685 L"DriverOrder",
686 &gEfiGlobalVariableGuid,
687 VAR_FLAG,
688 DriverOrderListSize + sizeof (UINT16),
689 NewDriverOrderList
690 );
691 ASSERT_EFI_ERROR (Status);
692 if (DriverOrderList != NULL) {
693 FreePool (DriverOrderList);
694 }
695 DriverOrderList = NULL;
696 FreePool (NewDriverOrderList);
697 InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
698 DriverOptionMenu.MenuNumber++;
699
700 *DescriptionData = 0x0000;
701 *OptionalData = 0x0000;
702 return EFI_SUCCESS;
703 }
704
705 /**
706 This function create a currently loaded Boot Option from
707 the BMM. It then appends this Boot Option to the end of
708 the "BootOrder" list. It also append this Boot Opotion to the end
709 of BootOptionMenu.
710
711 @param CallbackData The BMM context data.
712 @param NvRamMap The file explorer formset internal state.
713
714 @retval EFI_OUT_OF_RESOURCES If not enought memory to complete the operation.
715 @retval EFI_SUCCESS If function completes successfully.
716
717 **/
718 EFI_STATUS
719 Var_UpdateBootOption (
720 IN BMM_CALLBACK_DATA *CallbackData,
721 IN FILE_EXPLORER_NV_DATA *NvRamMap
722 )
723 {
724 UINT16 *BootOrderList;
725 UINT16 *NewBootOrderList;
726 UINTN BootOrderListSize;
727 UINT16 BootString[10];
728 VOID *Buffer;
729 UINTN BufferSize;
730 UINT8 *Ptr;
731 UINT16 Index;
732 BM_MENU_ENTRY *NewMenuEntry;
733 BM_LOAD_CONTEXT *NewLoadContext;
734 BOOLEAN OptionalDataExist;
735 EFI_STATUS Status;
736
737 OptionalDataExist = FALSE;
738
739 Index = BOpt_GetBootOptionNumber () ;
740 UnicodeSPrint (BootString, sizeof (BootString), L"Boot%04x", Index);
741
742 if (NvRamMap->DescriptionData[0] == 0x0000) {
743 StrCpy (NvRamMap->DescriptionData, BootString);
744 }
745
746 BufferSize = sizeof (UINT32) + sizeof (UINT16) + StrSize (NvRamMap->DescriptionData);
747 BufferSize += GetDevicePathSize (CallbackData->LoadContext->FilePathList);
748
749 if (NvRamMap->OptionalData[0] != 0x0000) {
750 OptionalDataExist = TRUE;
751 BufferSize += StrSize (NvRamMap->OptionalData);
752 }
753
754 Buffer = AllocateZeroPool (BufferSize);
755 if (NULL == Buffer) {
756 return EFI_OUT_OF_RESOURCES;
757 }
758
759 NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
760 if (NULL == NewMenuEntry) {
761 return EFI_OUT_OF_RESOURCES;
762 }
763
764 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
765 NewLoadContext->Deleted = FALSE;
766 NewLoadContext->LoadOptionSize = BufferSize;
767 Ptr = (UINT8 *) Buffer;
768 NewLoadContext->LoadOption = Ptr;
769 *((UINT32 *) Ptr) = LOAD_OPTION_ACTIVE;
770 NewLoadContext->Attributes = *((UINT32 *) Ptr);
771 NewLoadContext->IsActive = TRUE;
772 NewLoadContext->ForceReconnect = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
773
774 Ptr += sizeof (UINT32);
775 *((UINT16 *) Ptr) = (UINT16) GetDevicePathSize (CallbackData->LoadContext->FilePathList);
776 NewLoadContext->FilePathListLength = *((UINT16 *) Ptr);
777 Ptr += sizeof (UINT16);
778
779 CopyMem (
780 Ptr,
781 NvRamMap->DescriptionData,
782 StrSize (NvRamMap->DescriptionData)
783 );
784
785 NewLoadContext->Description = AllocateZeroPool (StrSize (NvRamMap->DescriptionData));
786 ASSERT (NewLoadContext->Description != NULL);
787
788 NewMenuEntry->DisplayString = NewLoadContext->Description;
789 CopyMem (
790 NewLoadContext->Description,
791 (VOID *) Ptr,
792 StrSize (NvRamMap->DescriptionData)
793 );
794
795 Ptr += StrSize (NvRamMap->DescriptionData);
796 CopyMem (
797 Ptr,
798 CallbackData->LoadContext->FilePathList,
799 GetDevicePathSize (CallbackData->LoadContext->FilePathList)
800 );
801
802 NewLoadContext->FilePathList = AllocateZeroPool (GetDevicePathSize (CallbackData->LoadContext->FilePathList));
803 ASSERT (NewLoadContext->FilePathList != NULL);
804
805 CopyMem (
806 NewLoadContext->FilePathList,
807 (VOID *) Ptr,
808 GetDevicePathSize (CallbackData->LoadContext->FilePathList)
809 );
810
811 NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
812 NewMenuEntry->OptionNumber = Index;
813 NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
814 CallbackData,
815 BootOptionStrDepository
816 );
817 NewMenuEntry->DisplayStringToken = HiiSetString (CallbackData->FeHiiHandle, 0, NewMenuEntry->DisplayString, NULL);
818
819 NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
820 CallbackData,
821 BootOptionHelpStrDepository
822 );
823 NewMenuEntry->HelpStringToken = HiiSetString (CallbackData->FeHiiHandle, 0, NewMenuEntry->HelpString, NULL);
824
825 if (OptionalDataExist) {
826 Ptr += (UINT8) GetDevicePathSize (CallbackData->LoadContext->FilePathList);
827
828 CopyMem (Ptr, NvRamMap->OptionalData, StrSize (NvRamMap->OptionalData));
829 }
830
831 Status = gRT->SetVariable (
832 BootString,
833 &gEfiGlobalVariableGuid,
834 VAR_FLAG,
835 BufferSize,
836 Buffer
837 );
838 ASSERT_EFI_ERROR (Status);
839
840 BootOrderList = BdsLibGetVariableAndSize (
841 L"BootOrder",
842 &gEfiGlobalVariableGuid,
843 &BootOrderListSize
844 );
845 ASSERT (BootOrderList != NULL);
846 NewBootOrderList = AllocateZeroPool (BootOrderListSize + sizeof (UINT16));
847 ASSERT (NewBootOrderList != NULL);
848 CopyMem (NewBootOrderList, BootOrderList, BootOrderListSize);
849 NewBootOrderList[BootOrderListSize / sizeof (UINT16)] = Index;
850
851 if (BootOrderList != NULL) {
852 FreePool (BootOrderList);
853 }
854
855 Status = gRT->SetVariable (
856 L"BootOrder",
857 &gEfiGlobalVariableGuid,
858 VAR_FLAG,
859 BootOrderListSize + sizeof (UINT16),
860 NewBootOrderList
861 );
862 ASSERT_EFI_ERROR (Status);
863
864 FreePool (NewBootOrderList);
865 NewBootOrderList = NULL;
866 InsertTailList (&BootOptionMenu.Head, &NewMenuEntry->Link);
867 BootOptionMenu.MenuNumber++;
868
869 NvRamMap->DescriptionData[0] = 0x0000;
870 NvRamMap->OptionalData[0] = 0x0000;
871 return EFI_SUCCESS;
872 }
873
874 /**
875 This function update the "BootNext" EFI Variable. If there is
876 no "BootNext" specified in BMM, this EFI Variable is deleted.
877 It also update the BMM context data specified the "BootNext"
878 vaule.
879
880 @param CallbackData The BMM context data.
881
882 @retval EFI_SUCCESS The function complete successfully.
883 @return The EFI variable can be saved. See gRT->SetVariable
884 for detail return information.
885
886 **/
887 EFI_STATUS
888 Var_UpdateBootNext (
889 IN BMM_CALLBACK_DATA *CallbackData
890 )
891 {
892 BM_MENU_ENTRY *NewMenuEntry;
893 BM_LOAD_CONTEXT *NewLoadContext;
894 BMM_FAKE_NV_DATA *CurrentFakeNVMap;
895 UINT16 Index;
896 EFI_STATUS Status;
897
898 Status = EFI_SUCCESS;
899 CurrentFakeNVMap = &CallbackData->BmmFakeNvData;
900 for (Index = 0; Index < BootOptionMenu.MenuNumber; Index++) {
901 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index);
902 ASSERT (NULL != NewMenuEntry);
903
904 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
905 NewLoadContext->IsBootNext = FALSE;
906 }
907
908 if (CurrentFakeNVMap->BootNext == BootOptionMenu.MenuNumber) {
909 EfiLibDeleteVariable (L"BootNext", &gEfiGlobalVariableGuid);
910 return EFI_SUCCESS;
911 }
912
913 NewMenuEntry = BOpt_GetMenuEntry (
914 &BootOptionMenu,
915 CurrentFakeNVMap->BootNext
916 );
917 ASSERT (NewMenuEntry != NULL);
918
919 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
920 Status = gRT->SetVariable (
921 L"BootNext",
922 &gEfiGlobalVariableGuid,
923 VAR_FLAG,
924 sizeof (UINT16),
925 &NewMenuEntry->OptionNumber
926 );
927 NewLoadContext->IsBootNext = TRUE;
928 CallbackData->BmmOldFakeNVData.BootNext = CurrentFakeNVMap->BootNext;
929 return Status;
930 }
931
932 /**
933 This function update the "BootOrder" EFI Variable based on
934 BMM Formset's NV map. It then refresh BootOptionMenu
935 with the new "BootOrder" list.
936
937 @param CallbackData The BMM context data.
938
939 @retval EFI_SUCCESS The function complete successfully.
940 @retval EFI_OUT_OF_RESOURCES Not enough memory to complete the function.
941 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
942
943 **/
944 EFI_STATUS
945 Var_UpdateBootOrder (
946 IN BMM_CALLBACK_DATA *CallbackData
947 )
948 {
949 EFI_STATUS Status;
950 UINT16 Index;
951 UINT16 OrderIndex;
952 UINT16 *BootOrderList;
953 UINTN BootOrderListSize;
954 UINT16 OptionNumber;
955
956 BootOrderList = NULL;
957 BootOrderListSize = 0;
958
959 //
960 // First check whether BootOrder is present in current configuration
961 //
962 BootOrderList = BdsLibGetVariableAndSize (
963 L"BootOrder",
964 &gEfiGlobalVariableGuid,
965 &BootOrderListSize
966 );
967 if (BootOrderList == NULL) {
968 return EFI_OUT_OF_RESOURCES;
969 }
970
971 ASSERT (BootOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.OptionOrder) / sizeof (CallbackData->BmmFakeNvData.OptionOrder[0])));
972
973 for (OrderIndex = 0; (OrderIndex < BootOptionMenu.MenuNumber) && (CallbackData->BmmFakeNvData.OptionOrder[OrderIndex] != 0); OrderIndex++) {
974 for (Index = OrderIndex; Index < BootOrderListSize / sizeof (UINT16); Index++) {
975 if ((BootOrderList[Index] == (UINT16) (CallbackData->BmmFakeNvData.OptionOrder[OrderIndex] - 1)) && (OrderIndex != Index)) {
976 OptionNumber = BootOrderList[Index];
977 CopyMem (&BootOrderList[OrderIndex + 1], &BootOrderList[OrderIndex], (Index - OrderIndex) * sizeof (UINT16));
978 BootOrderList[OrderIndex] = OptionNumber;
979 }
980 }
981 }
982
983 GroupMultipleLegacyBootOption4SameType (
984 BootOrderList,
985 BootOrderListSize / sizeof (UINT16)
986 );
987
988 Status = gRT->SetVariable (
989 L"BootOrder",
990 &gEfiGlobalVariableGuid,
991 VAR_FLAG,
992 BootOrderListSize,
993 BootOrderList
994 );
995 FreePool (BootOrderList);
996
997 BOpt_FreeMenu (&BootOptionMenu);
998 BOpt_GetBootOptions (CallbackData);
999
1000 return Status;
1001
1002 }
1003
1004 /**
1005 This function update the "DriverOrder" EFI Variable based on
1006 BMM Formset's NV map. It then refresh DriverOptionMenu
1007 with the new "DriverOrder" list.
1008
1009 @param CallbackData The BMM context data.
1010
1011 @retval EFI_SUCCESS The function complete successfully.
1012 @retval EFI_OUT_OF_RESOURCES Not enough memory to complete the function.
1013 @return The EFI variable can not be saved. See gRT->SetVariable for detail return information.
1014
1015 **/
1016 EFI_STATUS
1017 Var_UpdateDriverOrder (
1018 IN BMM_CALLBACK_DATA *CallbackData
1019 )
1020 {
1021 EFI_STATUS Status;
1022 UINT16 Index;
1023 UINT16 *DriverOrderList;
1024 UINT16 *NewDriverOrderList;
1025 UINTN DriverOrderListSize;
1026
1027 DriverOrderList = NULL;
1028 DriverOrderListSize = 0;
1029
1030 //
1031 // First check whether DriverOrder is present in current configuration
1032 //
1033 DriverOrderList = BdsLibGetVariableAndSize (
1034 L"DriverOrder",
1035 &gEfiGlobalVariableGuid,
1036 &DriverOrderListSize
1037 );
1038
1039 NewDriverOrderList = AllocateZeroPool (DriverOrderListSize);
1040
1041 if (NewDriverOrderList == NULL) {
1042 return EFI_OUT_OF_RESOURCES;
1043 }
1044 //
1045 // If exists, delete it to hold new DriverOrder
1046 //
1047 if (DriverOrderList != NULL) {
1048 EfiLibDeleteVariable (L"DriverOrder", &gEfiGlobalVariableGuid);
1049 FreePool (DriverOrderList);
1050 }
1051
1052 ASSERT (DriverOptionMenu.MenuNumber <= (sizeof (CallbackData->BmmFakeNvData.OptionOrder) / sizeof (CallbackData->BmmFakeNvData.OptionOrder[0])));
1053 for (Index = 0; Index < DriverOptionMenu.MenuNumber; Index++) {
1054 NewDriverOrderList[Index] = (UINT16) (CallbackData->BmmFakeNvData.OptionOrder[Index] - 1);
1055 }
1056
1057 Status = gRT->SetVariable (
1058 L"DriverOrder",
1059 &gEfiGlobalVariableGuid,
1060 VAR_FLAG,
1061 DriverOrderListSize,
1062 NewDriverOrderList
1063 );
1064 if (EFI_ERROR (Status)) {
1065 return Status;
1066 }
1067
1068 BOpt_FreeMenu (&DriverOptionMenu);
1069 BOpt_GetDriverOptions (CallbackData);
1070 return EFI_SUCCESS;
1071 }
1072
1073 /**
1074 Update the legacy BBS boot option. VAR_LEGACY_DEV_ORDER and gEfiLegacyDevOrderVariableGuid EFI Variable
1075 is udpated with the new Legacy Boot order. The EFI Variable of "Boot####" and gEfiGlobalVariableGuid
1076 is also updated.
1077
1078 @param CallbackData The context data for BMM.
1079
1080 @return EFI_SUCCESS The function completed successfully.
1081 @retval EFI_NOT_FOUND If VAR_LEGACY_DEV_ORDER and gEfiLegacyDevOrderVariableGuid EFI Variable can be found.
1082 @retval EFI_OUT_OF_RESOURCES Fail to allocate memory resource
1083 **/
1084 EFI_STATUS
1085 Var_UpdateBBSOption (
1086 IN BMM_CALLBACK_DATA *CallbackData
1087 )
1088 {
1089 UINTN Index;
1090 UINTN Index2;
1091 VOID *BootOptionVar;
1092 CHAR16 VarName[100];
1093 UINTN OptionSize;
1094 EFI_STATUS Status;
1095 UINT32 *Attribute;
1096 BM_MENU_OPTION *OptionMenu;
1097 UINT8 *LegacyDev;
1098 UINT8 *VarData;
1099 UINTN VarSize;
1100 LEGACY_DEV_ORDER_ENTRY *DevOrder;
1101 UINT8 *OriginalPtr;
1102 UINT8 *DisMap;
1103 UINTN Pos;
1104 UINTN Bit;
1105 UINT16 *NewOrder;
1106 UINT16 Tmp;
1107 UINT16 *EnBootOption;
1108 UINTN EnBootOptionCount;
1109 UINT16 *DisBootOption;
1110 UINTN DisBootOptionCount;
1111 UINT16 *BootOrder;
1112
1113 DisMap = NULL;
1114 NewOrder = NULL;
1115
1116 switch (CallbackData->BmmPreviousPageId) {
1117 case FORM_SET_FD_ORDER_ID:
1118 OptionMenu = (BM_MENU_OPTION *) &LegacyFDMenu;
1119 LegacyDev = CallbackData->BmmFakeNvData.LegacyFD;
1120 CallbackData->BbsType = BBS_FLOPPY;
1121 break;
1122
1123 case FORM_SET_HD_ORDER_ID:
1124 OptionMenu = (BM_MENU_OPTION *) &LegacyHDMenu;
1125 LegacyDev = CallbackData->BmmFakeNvData.LegacyHD;
1126 CallbackData->BbsType = BBS_HARDDISK;
1127 break;
1128
1129 case FORM_SET_CD_ORDER_ID:
1130 OptionMenu = (BM_MENU_OPTION *) &LegacyCDMenu;
1131 LegacyDev = CallbackData->BmmFakeNvData.LegacyCD;
1132 CallbackData->BbsType = BBS_CDROM;
1133 break;
1134
1135 case FORM_SET_NET_ORDER_ID:
1136 OptionMenu = (BM_MENU_OPTION *) &LegacyNETMenu;
1137 LegacyDev = CallbackData->BmmFakeNvData.LegacyNET;
1138 CallbackData->BbsType = BBS_EMBED_NETWORK;
1139 break;
1140
1141 default:
1142 ASSERT (FORM_SET_BEV_ORDER_ID == CallbackData->BmmPreviousPageId);
1143 OptionMenu = (BM_MENU_OPTION *) &LegacyBEVMenu;
1144 LegacyDev = CallbackData->BmmFakeNvData.LegacyBEV;
1145 CallbackData->BbsType = BBS_BEV_DEVICE;
1146 break;
1147 }
1148
1149 DisMap = CallbackData->BmmOldFakeNVData.DisableMap;
1150 Status = EFI_SUCCESS;
1151
1152
1153 //
1154 // Update the Variable "LegacyDevOrder"
1155 //
1156 VarData = (UINT8 *) BdsLibGetVariableAndSize (
1157 VAR_LEGACY_DEV_ORDER,
1158 &gEfiLegacyDevOrderVariableGuid,
1159 &VarSize
1160 );
1161
1162 if (VarData == NULL) {
1163 return EFI_NOT_FOUND;
1164 }
1165
1166 OriginalPtr = VarData;
1167 DevOrder = (LEGACY_DEV_ORDER_ENTRY *) VarData;
1168
1169 while (VarData < OriginalPtr + VarSize) {
1170 if (DevOrder->BbsType == CallbackData->BbsType) {
1171 break;
1172 }
1173
1174 VarData += sizeof (BBS_TYPE) + DevOrder->Length;
1175 DevOrder = (LEGACY_DEV_ORDER_ENTRY *) VarData;
1176 }
1177
1178 if (VarData >= OriginalPtr + VarSize) {
1179 FreePool (OriginalPtr);
1180 return EFI_NOT_FOUND;
1181 }
1182
1183 NewOrder = AllocateZeroPool (DevOrder->Length - sizeof (DevOrder->Length));
1184 if (NewOrder == NULL) {
1185 FreePool (OriginalPtr);
1186 return EFI_OUT_OF_RESOURCES;
1187 }
1188
1189 for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
1190 if (0xFF == LegacyDev[Index]) {
1191 break;
1192 }
1193
1194 NewOrder[Index] = LegacyDev[Index];
1195 }
1196 //
1197 // Only the enable/disable state of each boot device with same device type can be changed,
1198 // so we can count on the index information in DevOrder.
1199 // DisMap bit array is the only reliable source to check a device's en/dis state,
1200 // so we use DisMap to set en/dis state of each item in NewOrder array
1201 //
1202 for (Index2 = 0; Index2 < OptionMenu->MenuNumber; Index2++) {
1203 Tmp = (UINT16) (DevOrder->Data[Index2] & 0xFF);
1204 Pos = Tmp / 8;
1205 Bit = 7 - (Tmp % 8);
1206 if ((DisMap[Pos] & (1 << Bit)) != 0) {
1207 NewOrder[Index] = (UINT16) (0xFF00 | Tmp);
1208 Index++;
1209 }
1210 }
1211
1212 CopyMem (
1213 DevOrder->Data,
1214 NewOrder,
1215 DevOrder->Length - sizeof (DevOrder->Length)
1216 );
1217 FreePool (NewOrder);
1218
1219 Status = gRT->SetVariable (
1220 VAR_LEGACY_DEV_ORDER,
1221 &gEfiLegacyDevOrderVariableGuid,
1222 VAR_FLAG,
1223 VarSize,
1224 OriginalPtr
1225 );
1226
1227
1228 //
1229 // Update BootOrder and Boot####.Attribute
1230 //
1231 // 1. Re-order the Option Number in BootOrder according to Legacy Dev Order
1232 //
1233 ASSERT (OptionMenu->MenuNumber == DevOrder->Length / sizeof (UINT16) - 1);
1234 BootOrder = BdsLibGetVariableAndSize (
1235 L"BootOrder",
1236 &gEfiGlobalVariableGuid,
1237 &VarSize
1238 );
1239 ASSERT (BootOrder != NULL);
1240
1241 DisBootOption = AllocatePool (VarSize);
1242 ASSERT (DisBootOption != NULL);
1243 EnBootOption = AllocatePool (VarSize);
1244 ASSERT (EnBootOption != NULL);
1245
1246 OrderLegacyBootOption4SameType (
1247 BootOrder,
1248 VarSize / sizeof (UINT16),
1249 DevOrder->Data,
1250 DevOrder->Length / sizeof (UINT16) - 1,
1251 EnBootOption,
1252 &EnBootOptionCount,
1253 DisBootOption,
1254 &DisBootOptionCount
1255 );
1256
1257 Status = gRT->SetVariable (
1258 L"BootOrder",
1259 &gEfiGlobalVariableGuid,
1260 VAR_FLAG,
1261 VarSize,
1262 BootOrder
1263 );
1264 ASSERT_EFI_ERROR (Status);
1265
1266 FreePool (BootOrder);
1267
1268 //
1269 // 2. Deactivate the DisBootOption and activate the EnBootOption
1270 //
1271 for (Index = 0; Index < DisBootOptionCount; Index++) {
1272 UnicodeSPrint (VarName, sizeof (VarName), L"Boot%04x", DisBootOption[Index]);
1273 BootOptionVar = BdsLibGetVariableAndSize (
1274 VarName,
1275 &gEfiGlobalVariableGuid,
1276 &OptionSize
1277 );
1278 if (BootOptionVar != NULL) {
1279 Attribute = (UINT32 *) BootOptionVar;
1280 *Attribute &= ~LOAD_OPTION_ACTIVE;
1281
1282 Status = gRT->SetVariable (
1283 VarName,
1284 &gEfiGlobalVariableGuid,
1285 VAR_FLAG,
1286 OptionSize,
1287 BootOptionVar
1288 );
1289
1290 FreePool (BootOptionVar);
1291 }
1292 }
1293
1294 for (Index = 0; Index < EnBootOptionCount; Index++) {
1295 UnicodeSPrint (VarName, sizeof (VarName), L"Boot%04x", EnBootOption[Index]);
1296 BootOptionVar = BdsLibGetVariableAndSize (
1297 VarName,
1298 &gEfiGlobalVariableGuid,
1299 &OptionSize
1300 );
1301 if (BootOptionVar != NULL) {
1302 Attribute = (UINT32 *) BootOptionVar;
1303 *Attribute |= LOAD_OPTION_ACTIVE;
1304
1305 Status = gRT->SetVariable (
1306 VarName,
1307 &gEfiGlobalVariableGuid,
1308 VAR_FLAG,
1309 OptionSize,
1310 BootOptionVar
1311 );
1312
1313 FreePool (BootOptionVar);
1314 }
1315 }
1316
1317 BOpt_GetBootOptions (CallbackData);
1318
1319 FreePool (OriginalPtr);
1320 FreePool (EnBootOption);
1321 FreePool (DisBootOption);
1322 return Status;
1323 }
1324
1325 /**
1326 Update the Text Mode of Console.
1327
1328 @param CallbackData The context data for BMM.
1329
1330 @retval EFI_SUCCSS If the Text Mode of Console is updated.
1331 @return Other value if the Text Mode of Console is not updated.
1332
1333 **/
1334 EFI_STATUS
1335 Var_UpdateConMode (
1336 IN BMM_CALLBACK_DATA *CallbackData
1337 )
1338 {
1339 EFI_STATUS Status;
1340 UINTN Mode;
1341 CONSOLE_OUT_MODE ModeInfo;
1342
1343 Mode = CallbackData->BmmFakeNvData.ConsoleOutMode;
1344
1345 Status = gST->ConOut->QueryMode (gST->ConOut, Mode, &(ModeInfo.Column), &(ModeInfo.Row));
1346 if (!EFI_ERROR(Status)) {
1347 PcdSet32 (PcdSetupConOutColumn, (UINT32) ModeInfo.Column);
1348 PcdSet32 (PcdSetupConOutRow, (UINT32) ModeInfo.Row);
1349 }
1350
1351 return EFI_SUCCESS;
1352 }