Original BdsLibMatchDevicePaths() excludes end node when comparing 2 devices paths...
[mirror_edk2.git] / EdkNt32Pkg / Library / EdkGenericBdsLib / BdsMisc.c
1 /*++
2
3 Copyright (c) 2006, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 BdsMisc.c
15
16 Abstract:
17
18 Misc BDS library function
19
20 --*/
21
22 #define MAX_STRING_LEN 200
23 static BOOLEAN mFeaturerSwitch = TRUE;
24 static BOOLEAN mResetRequired = FALSE;
25 extern UINT16 gPlatformBootTimeOutDefault;
26
27 UINT16
28 BdsLibGetTimeout (
29 VOID
30 )
31 /*++
32
33 Routine Description:
34
35 Return the default value for system Timeout variable.
36
37 Arguments:
38
39 None
40
41 Returns:
42
43 Timeout value.
44
45 --*/
46 {
47 UINT16 Timeout;
48 UINTN Size;
49 EFI_STATUS Status;
50
51 //
52 // Return Timeout variable or 0xffff if no valid
53 // Timeout variable exists.
54 //
55 Size = sizeof (UINT16);
56 Status = gRT->GetVariable (L"Timeout", &gEfiGlobalVariableGuid, NULL, &Size, &Timeout);
57 if (!EFI_ERROR (Status)) {
58 return Timeout;
59 }
60 //
61 // To make the current EFI Automatic-Test activity possible, just add
62 // following code to make AutoBoot enabled when this variable is not
63 // present.
64 // This code should be removed later.
65 //
66 Timeout = gPlatformBootTimeOutDefault;
67
68 //
69 // Notes: Platform should set default variable if non exists on all error cases!!!
70 //
71 Status = gRT->SetVariable (
72 L"Timeout",
73 &gEfiGlobalVariableGuid,
74 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
75 sizeof (UINT16),
76 &Timeout
77 );
78 return Timeout;
79 }
80
81 VOID
82 BdsLibLoadDrivers (
83 IN LIST_ENTRY *BdsDriverLists
84 )
85 /*++
86
87 Routine Description:
88
89 The function will go through the driver optoin link list, load and start
90 every driver the driver optoin device path point to.
91
92 Arguments:
93
94 BdsDriverLists - The header of the current driver option link list
95
96 Returns:
97
98 None
99
100 --*/
101 {
102 EFI_STATUS Status;
103 LIST_ENTRY *Link;
104 BDS_COMMON_OPTION *Option;
105 EFI_HANDLE ImageHandle;
106 EFI_LOADED_IMAGE_PROTOCOL *ImageInfo;
107 UINTN ExitDataSize;
108 CHAR16 *ExitData;
109 BOOLEAN ReconnectAll;
110
111 ReconnectAll = FALSE;
112
113 //
114 // Process the driver option
115 //
116 for (Link = BdsDriverLists->ForwardLink; Link != BdsDriverLists; Link = Link->ForwardLink) {
117 Option = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);
118 //
119 // If a load option is not marked as LOAD_OPTION_ACTIVE,
120 // the boot manager will not automatically load the option.
121 //
122 if (!IS_LOAD_OPTION_TYPE (Option->Attribute, LOAD_OPTION_ACTIVE)) {
123 continue;
124 }
125 //
126 // If a driver load option is marked as LOAD_OPTION_FORCE_RECONNECT,
127 // then all of the EFI drivers in the system will be disconnected and
128 // reconnected after the last driver load option is processed.
129 //
130 if (IS_LOAD_OPTION_TYPE (Option->Attribute, LOAD_OPTION_FORCE_RECONNECT)) {
131 ReconnectAll = TRUE;
132 }
133 //
134 // Make sure the driver path is connected.
135 //
136 BdsLibConnectDevicePath (Option->DevicePath);
137
138 //
139 // Load and start the image that Driver#### describes
140 //
141 Status = gBS->LoadImage (
142 FALSE,
143 mBdsImageHandle,
144 Option->DevicePath,
145 NULL,
146 0,
147 &ImageHandle
148 );
149
150 if (!EFI_ERROR (Status)) {
151 gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid, &ImageInfo);
152
153 //
154 // Verify whether this image is a driver, if not,
155 // exit it and continue to parse next load option
156 //
157 if (ImageInfo->ImageCodeType != EfiBootServicesCode && ImageInfo->ImageCodeType != EfiRuntimeServicesCode) {
158 gBS->Exit (ImageHandle, EFI_INVALID_PARAMETER, 0, NULL);
159 continue;
160 }
161
162 if (Option->LoadOptionsSize != 0) {
163 ImageInfo->LoadOptionsSize = Option->LoadOptionsSize;
164 ImageInfo->LoadOptions = Option->LoadOptions;
165 }
166 //
167 // Before calling the image, enable the Watchdog Timer for
168 // the 5 Minute period
169 //
170 gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);
171
172 Status = gBS->StartImage (ImageHandle, &ExitDataSize, &ExitData);
173 DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Driver Return Status = %r\n", Status));
174
175 //
176 // Clear the Watchdog Timer after the image returns
177 //
178 gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
179 }
180 }
181 //
182 // Process the LOAD_OPTION_FORCE_RECONNECT driver option
183 //
184 if (ReconnectAll) {
185 BdsLibDisconnectAllEfi ();
186 BdsLibConnectAll ();
187 }
188
189 }
190
191 EFI_STATUS
192 BdsLibRegisterNewOption (
193 IN LIST_ENTRY *BdsOptionList,
194 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
195 IN CHAR16 *String,
196 IN CHAR16 *VariableName
197 )
198 /*++
199
200 Routine Description:
201
202 This function will register the new boot#### or driver#### option base on
203 the VariableName. The new registered boot#### or driver#### will be linked
204 to BdsOptionList and also update to the VariableName. After the boot#### or
205 driver#### updated, the BootOrder or DriverOrder will also be updated.
206
207 Arguments:
208
209 BdsOptionList - The header of the boot#### or driver#### link list
210
211 DevicePath - The device path which the boot####
212 or driver#### option present
213
214 String - The description of the boot#### or driver####
215
216 VariableName - Indicate if the boot#### or driver#### option
217
218 Returns:
219
220 EFI_SUCCESS - The boot#### or driver#### have been success registered
221
222 EFI_STATUS - Return the status of gRT->SetVariable ().
223
224 --*/
225 {
226 EFI_STATUS Status;
227 UINTN Index;
228 UINT16 MaxOptionNumber;
229 UINT16 RegisterOptionNumber;
230 UINT16 *TempOptionPtr;
231 UINTN TempOptionSize;
232 UINT16 *OptionOrderPtr;
233 VOID *OptionPtr;
234 UINTN OptionSize;
235 UINT8 *TempPtr;
236 EFI_DEVICE_PATH_PROTOCOL *OptionDevicePath;
237 CHAR16 *Description;
238 CHAR16 OptionName[10];
239 BOOLEAN UpdateBootDevicePath;
240
241 OptionPtr = NULL;
242 OptionSize = 0;
243 TempPtr = NULL;
244 OptionDevicePath = NULL;
245 Description = NULL;
246 MaxOptionNumber = 0;
247 OptionOrderPtr = NULL;
248 UpdateBootDevicePath = FALSE;
249 ZeroMem (OptionName, sizeof (OptionName));
250
251 TempOptionSize = 0;
252 TempOptionPtr = BdsLibGetVariableAndSize (
253 VariableName,
254 &gEfiGlobalVariableGuid,
255 &TempOptionSize
256 );
257 //
258 // Compare with current option variable
259 //
260 for (Index = 0; Index < TempOptionSize / sizeof (UINT16); Index++) {
261 //
262 // Got the max option#### number
263 //
264 if (MaxOptionNumber < TempOptionPtr[Index]) {
265 MaxOptionNumber = TempOptionPtr[Index];
266 }
267
268 if (*VariableName == 'B') {
269 UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", TempOptionPtr[Index]);
270 } else {
271 UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", TempOptionPtr[Index]);
272 }
273
274 OptionPtr = BdsLibGetVariableAndSize (
275 OptionName,
276 &gEfiGlobalVariableGuid,
277 &OptionSize
278 );
279 TempPtr = OptionPtr;
280 TempPtr += sizeof (UINT32) + sizeof (UINT16);
281 Description = (CHAR16 *) TempPtr;
282 TempPtr += StrSize ((CHAR16 *) TempPtr);
283 OptionDevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;
284
285 //
286 // Notes: the description may will change base on the GetStringToken
287 //
288 if (CompareMem (Description, String, StrSize (Description)) == 0) {
289 if (CompareMem (OptionDevicePath, DevicePath, GetDevicePathSize (OptionDevicePath)) == 0) {
290 //
291 // Got the option, so just return
292 //
293 gBS->FreePool (OptionPtr);
294 gBS->FreePool (TempOptionPtr);
295 return EFI_SUCCESS;
296 } else {
297 //
298 // Boot device path changed, need update.
299 //
300 UpdateBootDevicePath = TRUE;
301 break;
302 }
303 }
304
305 gBS->FreePool (OptionPtr);
306 }
307
308 OptionSize = sizeof (UINT32) + sizeof (UINT16) + StrSize (String) + GetDevicePathSize (DevicePath);
309 OptionPtr = AllocateZeroPool (OptionSize);
310 TempPtr = OptionPtr;
311 *(UINT32 *) TempPtr = LOAD_OPTION_ACTIVE;
312 TempPtr += sizeof (UINT32);
313 *(UINT16 *) TempPtr = (UINT16) GetDevicePathSize (DevicePath);
314 TempPtr += sizeof (UINT16);
315 CopyMem (TempPtr, String, StrSize (String));
316 TempPtr += StrSize (String);
317 CopyMem (TempPtr, DevicePath, GetDevicePathSize (DevicePath));
318
319 if (UpdateBootDevicePath) {
320 //
321 // The number in option#### to be updated
322 //
323 RegisterOptionNumber = TempOptionPtr[Index];
324 } else {
325 //
326 // The new option#### number
327 //
328 RegisterOptionNumber = MaxOptionNumber + 1;
329 }
330
331 if (*VariableName == 'B') {
332 UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", RegisterOptionNumber);
333 } else {
334 UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", RegisterOptionNumber);
335 }
336
337 Status = gRT->SetVariable (
338 OptionName,
339 &gEfiGlobalVariableGuid,
340 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
341 OptionSize,
342 OptionPtr
343 );
344 if (EFI_ERROR (Status) || UpdateBootDevicePath) {
345 gBS->FreePool (OptionPtr);
346 gBS->FreePool (TempOptionPtr);
347 return Status;
348 }
349
350 gBS->FreePool (OptionPtr);
351
352 //
353 // Update the option order variable
354 //
355 OptionOrderPtr = AllocateZeroPool ((Index + 1) * sizeof (UINT16));
356 CopyMem (OptionOrderPtr, TempOptionPtr, Index * sizeof (UINT16));
357 OptionOrderPtr[Index] = RegisterOptionNumber;
358 Status = gRT->SetVariable (
359 VariableName,
360 &gEfiGlobalVariableGuid,
361 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
362 (Index + 1) * sizeof (UINT16),
363 OptionOrderPtr
364 );
365 if (EFI_ERROR (Status)) {
366 gBS->FreePool (TempOptionPtr);
367 gBS->FreePool (OptionOrderPtr);
368 return Status;
369 }
370
371 gBS->FreePool (TempOptionPtr);
372 gBS->FreePool (OptionOrderPtr);
373
374 return EFI_SUCCESS;
375 }
376
377 BDS_COMMON_OPTION *
378 BdsLibVariableToOption (
379 IN OUT LIST_ENTRY *BdsCommonOptionList,
380 IN CHAR16 *VariableName
381 )
382 /*++
383
384 Routine Description:
385
386 Build the boot#### or driver#### option from the VariableName, the
387 build boot#### or driver#### will also be linked to BdsCommonOptionList
388
389 Arguments:
390
391 BdsCommonOptionList - The header of the boot#### or driver#### option link list
392
393 VariableName - EFI Variable name indicate if it is boot#### or driver####
394
395 Returns:
396
397 BDS_COMMON_OPTION - Get the option just been created
398
399 NULL - Failed to get the new option
400
401 --*/
402 {
403 UINT32 Attribute;
404 UINT16 FilePathSize;
405 UINT8 *Variable;
406 UINT8 *TempPtr;
407 UINTN VariableSize;
408 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
409 BDS_COMMON_OPTION *Option;
410 VOID *LoadOptions;
411 UINT32 LoadOptionsSize;
412 CHAR16 *Description;
413
414 //
415 // Read the variable. We will never free this data.
416 //
417 Variable = BdsLibGetVariableAndSize (
418 VariableName,
419 &gEfiGlobalVariableGuid,
420 &VariableSize
421 );
422 if (Variable == NULL) {
423 return NULL;
424 }
425 //
426 // Notes: careful defined the variable of Boot#### or
427 // Driver####, consider use some macro to abstract the code
428 //
429 //
430 // Get the option attribute
431 //
432 TempPtr = Variable;
433 Attribute = *(UINT32 *) Variable;
434 TempPtr += sizeof (UINT32);
435
436 //
437 // Get the option's device path size
438 //
439 FilePathSize = *(UINT16 *) TempPtr;
440 TempPtr += sizeof (UINT16);
441
442 //
443 // Get the option's description string
444 //
445 Description = (CHAR16 *) TempPtr;
446
447 //
448 // Get the option's description string size
449 //
450 TempPtr += StrSize ((CHAR16 *) TempPtr);
451
452 //
453 // Get the option's device path
454 //
455 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;
456 TempPtr += FilePathSize;
457
458 LoadOptions = TempPtr;
459 LoadOptionsSize = (UINT32) (VariableSize - (UINTN) (TempPtr - Variable));
460
461 //
462 // The Console variables may have multiple device paths, so make
463 // an Entry for each one.
464 //
465 Option = AllocateZeroPool (sizeof (BDS_COMMON_OPTION));
466 if (Option == NULL) {
467 return NULL;
468 }
469
470 Option->Signature = BDS_LOAD_OPTION_SIGNATURE;
471 Option->DevicePath = AllocateZeroPool (GetDevicePathSize (DevicePath));
472 CopyMem (Option->DevicePath, DevicePath, GetDevicePathSize (DevicePath));
473 Option->Attribute = Attribute;
474 Option->Description = AllocateZeroPool (StrSize (Description));
475 CopyMem (Option->Description, Description, StrSize (Description));
476 Option->LoadOptions = AllocateZeroPool (LoadOptionsSize);
477 CopyMem (Option->LoadOptions, LoadOptions, LoadOptionsSize);
478 Option->LoadOptionsSize = LoadOptionsSize;
479
480 //
481 // Insert active entry to BdsDeviceList
482 //
483 if ((Option->Attribute & LOAD_OPTION_ACTIVE) == LOAD_OPTION_ACTIVE) {
484 InsertTailList (BdsCommonOptionList, &Option->Link);
485 gBS->FreePool (Variable);
486 return Option;
487 }
488
489 gBS->FreePool (Variable);
490 gBS->FreePool (Option);
491 return NULL;
492
493 }
494
495 EFI_STATUS
496 BdsLibBuildOptionFromVar (
497 IN LIST_ENTRY *BdsCommonOptionList,
498 IN CHAR16 *VariableName
499 )
500 /*++
501
502 Routine Description:
503
504 Process BootOrder, or DriverOrder variables, by calling
505 BdsLibVariableToOption () for each UINT16 in the variables.
506
507 Arguments:
508
509 BdsCommonOptionList - The header of the option list base on variable
510 VariableName
511
512 VariableName - EFI Variable name indicate the BootOrder or DriverOrder
513
514 Returns:
515
516 EFI_SUCCESS - Success create the boot option or driver option list
517
518 EFI_OUT_OF_RESOURCES - Failed to get the boot option or driver option list
519
520 --*/
521 {
522 UINT16 *OptionOrder;
523 UINTN OptionOrderSize;
524 UINTN Index;
525 BDS_COMMON_OPTION *Option;
526 CHAR16 OptionName[20];
527
528 //
529 // Zero Buffer in order to get all BOOT#### variables
530 //
531 ZeroMem (OptionName, sizeof (OptionName));
532
533 //
534 // Read the BootOrder, or DriverOrder variable.
535 //
536 OptionOrder = BdsLibGetVariableAndSize (
537 VariableName,
538 &gEfiGlobalVariableGuid,
539 &OptionOrderSize
540 );
541 if (OptionOrder == NULL) {
542 return EFI_OUT_OF_RESOURCES;
543 }
544
545 for (Index = 0; Index < OptionOrderSize / sizeof (UINT16); Index++) {
546 if (*VariableName == 'B') {
547 UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", OptionOrder[Index]);
548 } else {
549 UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", OptionOrder[Index]);
550 }
551 Option = BdsLibVariableToOption (BdsCommonOptionList, OptionName);
552 Option->BootCurrent = OptionOrder[Index];
553
554 }
555
556 gBS->FreePool (OptionOrder);
557
558 return EFI_SUCCESS;
559 }
560
561 EFI_STATUS
562 BdsLibGetBootMode (
563 OUT EFI_BOOT_MODE *BootMode
564 )
565 /*++
566
567 Routine Description:
568
569 Get boot mode by looking up configuration table and parsing HOB list
570
571 Arguments:
572
573 BootMode - Boot mode from PEI handoff HOB.
574
575 Returns:
576
577 EFI_SUCCESS - Successfully get boot mode
578
579 EFI_NOT_FOUND - Can not find the current system boot mode
580
581 --*/
582 {
583 EFI_HOB_HANDOFF_INFO_TABLE *HobList;
584
585 HobList = GetHobList ();
586 ASSERT (HobList->Header.HobType == EFI_HOB_TYPE_HANDOFF);
587 *BootMode = HobList->BootMode;
588
589 return EFI_SUCCESS;
590 }
591
592 VOID *
593 BdsLibGetVariableAndSize (
594 IN CHAR16 *Name,
595 IN EFI_GUID *VendorGuid,
596 OUT UINTN *VariableSize
597 )
598 /*++
599
600 Routine Description:
601
602 Read the EFI variable (VendorGuid/Name) and return a dynamically allocated
603 buffer, and the size of the buffer. If failure return NULL.
604
605 Arguments:
606
607 Name - String part of EFI variable name
608
609 VendorGuid - GUID part of EFI variable name
610
611 VariableSize - Returns the size of the EFI variable that was read
612
613 Returns:
614
615 Dynamically allocated memory that contains a copy of the EFI variable.
616 Caller is responsible freeing the buffer.
617
618 NULL - Variable was not read
619
620 --*/
621 {
622 EFI_STATUS Status;
623 UINTN BufferSize;
624 VOID *Buffer;
625
626 Buffer = NULL;
627
628 //
629 // Pass in a zero size buffer to find the required buffer size.
630 //
631 BufferSize = 0;
632 Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
633 if (Status == EFI_BUFFER_TOO_SMALL) {
634 //
635 // Allocate the buffer to return
636 //
637 Buffer = AllocateZeroPool (BufferSize);
638 if (Buffer == NULL) {
639 return NULL;
640 }
641 //
642 // Read variable into the allocated buffer.
643 //
644 Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
645 if (EFI_ERROR (Status)) {
646 BufferSize = 0;
647 }
648 }
649
650 *VariableSize = BufferSize;
651 return Buffer;
652 }
653
654 BOOLEAN
655 BdsLibMatchDevicePaths (
656 IN EFI_DEVICE_PATH_PROTOCOL *Multi,
657 IN EFI_DEVICE_PATH_PROTOCOL *Single
658 )
659 /*++
660
661 Routine Description:
662
663 Function compares a device path data structure to that of all the nodes of a
664 second device path instance.
665
666 Arguments:
667
668 Multi - A pointer to a multi-instance device path data structure.
669
670 Single - A pointer to a single-instance device path data structure.
671
672 Returns:
673
674 TRUE - If the Single is contained within Multi
675
676 FALSE - The Single is not match within Multi
677
678
679 --*/
680 {
681 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
682 EFI_DEVICE_PATH_PROTOCOL *DevicePathInst;
683 UINTN Size;
684
685 if (!Multi || !Single) {
686 return FALSE;
687 }
688
689 DevicePath = Multi;
690 DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
691
692 //
693 // Search for the match of 'Single' in 'Multi'
694 //
695 while (DevicePathInst != NULL) {
696 //
697 // If the single device path is found in multiple device paths,
698 // return success
699 //
700 if (CompareMem (Single, DevicePathInst, Size) == 0) {
701 gBS->FreePool (DevicePathInst);
702 return TRUE;
703 }
704
705 gBS->FreePool (DevicePathInst);
706 DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
707 }
708
709 return FALSE;
710 }
711
712 EFI_STATUS
713 BdsLibOutputStrings (
714 IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *ConOut,
715 ...
716 )
717 /*++
718
719 Routine Description:
720
721 This function prints a series of strings.
722
723 Arguments:
724
725 ConOut - Pointer to EFI_SIMPLE_TEXT_OUT_PROTOCOL
726
727 ... - A variable argument list containing series of strings,
728 the last string must be NULL.
729
730 Returns:
731
732 EFI_SUCCESS - Success print out the string using ConOut.
733
734 EFI_STATUS - Return the status of the ConOut->OutputString ().
735
736 --*/
737 {
738 VA_LIST args;
739 EFI_STATUS Status;
740 CHAR16 *String;
741
742 Status = EFI_SUCCESS;
743 VA_START (args, ConOut);
744
745 while (!EFI_ERROR (Status)) {
746 //
747 // If String is NULL, then it's the end of the list
748 //
749 String = VA_ARG (args, CHAR16 *);
750 if (!String) {
751 break;
752 }
753
754 Status = ConOut->OutputString (ConOut, String);
755
756 if (EFI_ERROR (Status)) {
757 break;
758 }
759 }
760
761 return Status;
762 }
763
764 //
765 // Following are BDS Lib functions which contain all the code about setup browser reset reminder feature.
766 // Setup Browser reset reminder feature is that an reset reminder will be given before user leaves the setup browser if
767 // user change any option setting which needs a reset to be effective, and the reset will be applied according to the user selection.
768 //
769
770 VOID
771 EnableResetReminderFeature (
772 VOID
773 )
774 /*++
775
776 Routine Description:
777
778 Enable the setup browser reset reminder feature.
779 This routine is used in platform tip. If the platform policy need the feature, use the routine to enable it.
780
781 Arguments:
782
783 VOID
784
785 Returns:
786
787 VOID
788
789 --*/
790 {
791 mFeaturerSwitch = TRUE;
792 }
793
794 VOID
795 DisableResetReminderFeature (
796 VOID
797 )
798 /*++
799
800 Routine Description:
801
802 Disable the setup browser reset reminder feature.
803 This routine is used in platform tip. If the platform policy do not want the feature, use the routine to disable it.
804
805 Arguments:
806
807 VOID
808
809 Returns:
810
811 VOID
812
813 --*/
814 {
815 mFeaturerSwitch = FALSE;
816 }
817
818 VOID
819 EnableResetRequired (
820 VOID
821 )
822 /*++
823
824 Routine Description:
825
826 Record the info that a reset is required.
827 A module boolean variable is used to record whether a reset is required.
828
829 Arguments:
830
831 VOID
832
833 Returns:
834
835 VOID
836
837 --*/
838 {
839 mResetRequired = TRUE;
840 }
841
842 VOID
843 DisableResetRequired (
844 VOID
845 )
846 /*++
847
848 Routine Description:
849
850 Record the info that no reset is required.
851 A module boolean variable is used to record whether a reset is required.
852
853 Arguments:
854
855 VOID
856
857 Returns:
858
859 VOID
860
861 --*/
862 {
863 mResetRequired = FALSE;
864 }
865
866 BOOLEAN
867 IsResetReminderFeatureEnable (
868 VOID
869 )
870 /*++
871
872 Routine Description:
873
874 Check whether platform policy enable the reset reminder feature. The default is enabled.
875
876 Arguments:
877
878 VOID
879
880 Returns:
881
882 VOID
883
884 --*/
885 {
886 return mFeaturerSwitch;
887 }
888
889 BOOLEAN
890 IsResetRequired (
891 VOID
892 )
893 /*++
894
895 Routine Description:
896
897 Check if user changed any option setting which needs a system reset to be effective.
898
899 Arguments:
900
901 VOID
902
903 Returns:
904
905 VOID
906
907 --*/
908 {
909 return mResetRequired;
910 }
911
912 VOID
913 SetupResetReminder (
914 VOID
915 )
916 /*++
917
918 Routine Description:
919
920 Check whether a reset is needed, and finish the reset reminder feature.
921 If a reset is needed, Popup a menu to notice user, and finish the feature
922 according to the user selection.
923
924 Arguments:
925
926 VOID
927
928 Returns:
929
930 VOID
931
932 --*/
933 {
934 EFI_STATUS Status;
935 EFI_FORM_BROWSER_PROTOCOL *Browser;
936 EFI_INPUT_KEY Key;
937 CHAR16 *StringBuffer1;
938 CHAR16 *StringBuffer2;
939
940
941 //
942 //check any reset required change is applied? if yes, reset system
943 //
944 if (IsResetReminderFeatureEnable ()) {
945 if (IsResetRequired ()) {
946
947 Status = gBS->LocateProtocol (
948 &gEfiFormBrowserProtocolGuid,
949 NULL,
950 &Browser
951 );
952
953 StringBuffer1 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
954 ASSERT (StringBuffer1 != NULL);
955 StringBuffer2 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
956 ASSERT (StringBuffer2 != NULL);
957 StrCpy (StringBuffer1, L"Configuration changed. Reset to apply it Now ? ");
958 StrCpy (StringBuffer2, L"Enter (YES) / Esc (NO)");
959 //
960 // Popup a menu to notice user
961 //
962 do {
963 Browser->CreatePopUp (2, TRUE, 0, NULL, &Key, StringBuffer1, StringBuffer2);
964 } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
965
966 gBS->FreePool (StringBuffer1);
967 gBS->FreePool (StringBuffer2);
968 //
969 // If the user hits the YES Response key, reset
970 //
971 if ((Key.UnicodeChar == CHAR_CARRIAGE_RETURN)) {
972 gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
973 }
974 gST->ConOut->ClearScreen (gST->ConOut);
975 }
976 }
977 }