]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Application/UiApp/FrontPage.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
MdeModulePkg: Replace deprecated function.
[mirror_edk2.git] / MdeModulePkg / Application / UiApp / FrontPage.c
1 /** @file
2 FrontPage routines to handle the callbacks and browser calls
3
4 Copyright (c) 2004 - 2015, 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 "FrontPage.h"
16 #include "Language.h"
17 #define MAX_STRING_LEN 200
18
19 EFI_GUID mFrontPageGuid = FRONT_PAGE_FORMSET_GUID;
20
21 BOOLEAN gConnectAllHappened = FALSE;
22 BOOLEAN mFeaturerSwitch = TRUE;
23 BOOLEAN mResetRequired = FALSE;
24 BOOLEAN mEnterBmm = FALSE;
25
26 EFI_FORM_BROWSER2_PROTOCOL *gFormBrowser2;
27 CHAR8 *mLanguageString;
28 BOOLEAN mModeInitialized = FALSE;
29 //
30 // Boot video resolution and text mode.
31 //
32 UINT32 mBootHorizontalResolution = 0;
33 UINT32 mBootVerticalResolution = 0;
34 UINT32 mBootTextModeColumn = 0;
35 UINT32 mBootTextModeRow = 0;
36 //
37 // BIOS setup video resolution and text mode.
38 //
39 UINT32 mSetupTextModeColumn = 0;
40 UINT32 mSetupTextModeRow = 0;
41 UINT32 mSetupHorizontalResolution = 0;
42 UINT32 mSetupVerticalResolution = 0;
43
44 FRONT_PAGE_CALLBACK_DATA gFrontPagePrivate = {
45 FRONT_PAGE_CALLBACK_DATA_SIGNATURE,
46 NULL,
47 NULL,
48 NULL,
49 {
50 FakeExtractConfig,
51 FakeRouteConfig,
52 FrontPageCallback
53 }
54 };
55
56 HII_VENDOR_DEVICE_PATH mFrontPageHiiVendorDevicePath = {
57 {
58 {
59 HARDWARE_DEVICE_PATH,
60 HW_VENDOR_DP,
61 {
62 (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
63 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
64 }
65 },
66 //
67 // {8E6D99EE-7531-48f8-8745-7F6144468FF2}
68 //
69 { 0x8e6d99ee, 0x7531, 0x48f8, { 0x87, 0x45, 0x7f, 0x61, 0x44, 0x46, 0x8f, 0xf2 } }
70 },
71 {
72 END_DEVICE_PATH_TYPE,
73 END_ENTIRE_DEVICE_PATH_SUBTYPE,
74 {
75 (UINT8) (END_DEVICE_PATH_LENGTH),
76 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
77 }
78 }
79 };
80
81 /**
82 Update the banner information for the Front Page based on Smbios information.
83
84 **/
85 VOID
86 UpdateFrontPageStrings (
87 VOID
88 );
89
90 /**
91 This function allows a caller to extract the current configuration for one
92 or more named elements from the target driver.
93
94
95 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
96 @param Request A null-terminated Unicode string in <ConfigRequest> format.
97 @param Progress On return, points to a character in the Request string.
98 Points to the string's null terminator if request was successful.
99 Points to the most recent '&' before the first failing name/value
100 pair (or the beginning of the string if the failure is in the
101 first name/value pair) if the request was not successful.
102 @param Results A null-terminated Unicode string in <ConfigAltResp> format which
103 has all values filled in for the names in the Request string.
104 String to be allocated by the called function.
105
106 @retval EFI_SUCCESS The Results is filled with the requested values.
107 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results.
108 @retval EFI_INVALID_PARAMETER Request is illegal syntax, or unknown name.
109 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
110
111 **/
112 EFI_STATUS
113 EFIAPI
114 FakeExtractConfig (
115 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
116 IN CONST EFI_STRING Request,
117 OUT EFI_STRING *Progress,
118 OUT EFI_STRING *Results
119 )
120 {
121 if (Progress == NULL || Results == NULL) {
122 return EFI_INVALID_PARAMETER;
123 }
124 *Progress = Request;
125 return EFI_NOT_FOUND;
126 }
127
128 /**
129 This function processes the results of changes in configuration.
130
131
132 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
133 @param Configuration A null-terminated Unicode string in <ConfigResp> format.
134 @param Progress A pointer to a string filled in with the offset of the most
135 recent '&' before the first failing name/value pair (or the
136 beginning of the string if the failure is in the first
137 name/value pair) or the terminating NULL if all was successful.
138
139 @retval EFI_SUCCESS The Results is processed successfully.
140 @retval EFI_INVALID_PARAMETER Configuration is NULL.
141 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
142
143 **/
144 EFI_STATUS
145 EFIAPI
146 FakeRouteConfig (
147 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
148 IN CONST EFI_STRING Configuration,
149 OUT EFI_STRING *Progress
150 )
151 {
152 if (Configuration == NULL || Progress == NULL) {
153 return EFI_INVALID_PARAMETER;
154 }
155
156 *Progress = Configuration;
157 if (!HiiIsConfigHdrMatch (Configuration, &mBootMaintGuid, mBootMaintStorageName)
158 && !HiiIsConfigHdrMatch (Configuration, &mFileExplorerGuid, mFileExplorerStorageName)) {
159 return EFI_NOT_FOUND;
160 }
161
162 *Progress = Configuration + StrLen (Configuration);
163 return EFI_SUCCESS;
164 }
165
166 /**
167 Create oneof options for language.
168
169 **/
170 VOID
171 InitializeLanguage (
172 VOID
173 )
174 {
175 EFI_STATUS Status;
176 CHAR8 *LangCode;
177 CHAR8 *Lang;
178 CHAR8 *CurrentLang;
179 UINTN OptionCount;
180 CHAR16 *StringBuffer;
181 EFI_HII_HANDLE HiiHandle;
182 VOID *OptionsOpCodeHandle;
183 VOID *StartOpCodeHandle;
184 VOID *EndOpCodeHandle;
185 EFI_IFR_GUID_LABEL *StartLabel;
186 EFI_IFR_GUID_LABEL *EndLabel;
187 EFI_HII_STRING_PROTOCOL *HiiString;
188 UINTN StringSize;
189
190 Lang = NULL;
191 StringBuffer = NULL;
192
193 //
194 // Init OpCode Handle and Allocate space for creation of UpdateData Buffer
195 //
196 StartOpCodeHandle = HiiAllocateOpCodeHandle ();
197 ASSERT (StartOpCodeHandle != NULL);
198
199 EndOpCodeHandle = HiiAllocateOpCodeHandle ();
200 ASSERT (EndOpCodeHandle != NULL);
201
202 OptionsOpCodeHandle = HiiAllocateOpCodeHandle ();
203 ASSERT (OptionsOpCodeHandle != NULL);
204 //
205 // Create Hii Extend Label OpCode as the start opcode
206 //
207 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
208 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
209 StartLabel->Number = LABEL_SELECT_LANGUAGE;
210
211 //
212 // Create Hii Extend Label OpCode as the end opcode
213 //
214 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
215 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
216 EndLabel->Number = LABEL_END;
217 //
218 // Collect the languages from what our current Language support is based on our VFR
219 //
220 HiiHandle = gFrontPagePrivate.HiiHandle;
221
222 GetEfiGlobalVariable2 (L"PlatformLang", (VOID**)&CurrentLang, NULL);
223
224 if (mLanguageString == NULL) {
225 //
226 // Get Support language list from variable.
227 //
228 GetEfiGlobalVariable2 (L"PlatformLangCodes", (VOID**)&mLanguageString, NULL);
229 if (mLanguageString == NULL) {
230 mLanguageString = AllocateCopyPool (
231 AsciiStrSize ((CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLangCodes)),
232 (CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLangCodes)
233 );
234 ASSERT (mLanguageString != NULL);
235 }
236 }
237
238 if (gFrontPagePrivate.LanguageToken == NULL) {
239 //
240 // Count the language list number.
241 //
242 LangCode = mLanguageString;
243 Lang = AllocatePool (AsciiStrSize (mLanguageString));
244 ASSERT (Lang != NULL);
245 OptionCount = 0;
246 while (*LangCode != 0) {
247 GetNextLanguage (&LangCode, Lang);
248 OptionCount ++;
249 }
250
251 //
252 // Allocate extra 1 as the end tag.
253 //
254 gFrontPagePrivate.LanguageToken = AllocateZeroPool ((OptionCount + 1) * sizeof (EFI_STRING_ID));
255 ASSERT (gFrontPagePrivate.LanguageToken != NULL);
256
257 Status = gBS->LocateProtocol (&gEfiHiiStringProtocolGuid, NULL, (VOID **) &HiiString);
258 ASSERT_EFI_ERROR (Status);
259
260 LangCode = mLanguageString;
261 OptionCount = 0;
262 while (*LangCode != 0) {
263 GetNextLanguage (&LangCode, Lang);
264
265 StringSize = 0;
266 Status = HiiString->GetString (HiiString, Lang, HiiHandle, PRINTABLE_LANGUAGE_NAME_STRING_ID, StringBuffer, &StringSize, NULL);
267 if (Status == EFI_BUFFER_TOO_SMALL) {
268 StringBuffer = AllocateZeroPool (StringSize);
269 ASSERT (StringBuffer != NULL);
270 Status = HiiString->GetString (HiiString, Lang, HiiHandle, PRINTABLE_LANGUAGE_NAME_STRING_ID, StringBuffer, &StringSize, NULL);
271 ASSERT_EFI_ERROR (Status);
272 }
273
274 if (EFI_ERROR (Status)) {
275 StringBuffer = AllocatePool (AsciiStrSize (Lang) * sizeof (CHAR16));
276 ASSERT (StringBuffer != NULL);
277 AsciiStrToUnicodeStr (Lang, StringBuffer);
278 }
279
280 ASSERT (StringBuffer != NULL);
281 gFrontPagePrivate.LanguageToken[OptionCount] = HiiSetString (HiiHandle, 0, StringBuffer, NULL);
282 FreePool (StringBuffer);
283
284 OptionCount++;
285 }
286 }
287
288 ASSERT (gFrontPagePrivate.LanguageToken != NULL);
289 LangCode = mLanguageString;
290 OptionCount = 0;
291 if (Lang == NULL) {
292 Lang = AllocatePool (AsciiStrSize (mLanguageString));
293 ASSERT (Lang != NULL);
294 }
295 while (*LangCode != 0) {
296 GetNextLanguage (&LangCode, Lang);
297
298 if (CurrentLang != NULL && AsciiStrCmp (Lang, CurrentLang) == 0) {
299 HiiCreateOneOfOptionOpCode (
300 OptionsOpCodeHandle,
301 gFrontPagePrivate.LanguageToken[OptionCount],
302 EFI_IFR_OPTION_DEFAULT,
303 EFI_IFR_NUMERIC_SIZE_1,
304 (UINT8) OptionCount
305 );
306 } else {
307 HiiCreateOneOfOptionOpCode (
308 OptionsOpCodeHandle,
309 gFrontPagePrivate.LanguageToken[OptionCount],
310 0,
311 EFI_IFR_NUMERIC_SIZE_1,
312 (UINT8) OptionCount
313 );
314 }
315
316 OptionCount++;
317 }
318
319 if (CurrentLang != NULL) {
320 FreePool (CurrentLang);
321 }
322 FreePool (Lang);
323
324 HiiCreateOneOfOpCode (
325 StartOpCodeHandle,
326 FRONT_PAGE_KEY_LANGUAGE,
327 0,
328 0,
329 STRING_TOKEN (STR_LANGUAGE_SELECT),
330 STRING_TOKEN (STR_LANGUAGE_SELECT_HELP),
331 EFI_IFR_FLAG_CALLBACK,
332 EFI_IFR_NUMERIC_SIZE_1,
333 OptionsOpCodeHandle,
334 NULL
335 );
336
337 Status = HiiUpdateForm (
338 HiiHandle,
339 &mFrontPageGuid,
340 FRONT_PAGE_FORM_ID,
341 StartOpCodeHandle, // LABEL_SELECT_LANGUAGE
342 EndOpCodeHandle // LABEL_END
343 );
344
345 HiiFreeOpCodeHandle (StartOpCodeHandle);
346 HiiFreeOpCodeHandle (EndOpCodeHandle);
347 HiiFreeOpCodeHandle (OptionsOpCodeHandle);
348 }
349
350 /**
351 This function processes the results of changes in configuration.
352
353
354 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
355 @param Action Specifies the type of action taken by the browser.
356 @param QuestionId A unique value which is sent to the original exporting driver
357 so that it can identify the type of data to expect.
358 @param Type The type of value for the question.
359 @param Value A pointer to the data being sent to the original exporting driver.
360 @param ActionRequest On return, points to the action requested by the callback function.
361
362 @retval EFI_SUCCESS The callback successfully handled the action.
363 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the variable and its data.
364 @retval EFI_DEVICE_ERROR The variable could not be saved.
365 @retval EFI_UNSUPPORTED The specified Action is not supported by the callback.
366
367 **/
368 EFI_STATUS
369 EFIAPI
370 FrontPageCallback (
371 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
372 IN EFI_BROWSER_ACTION Action,
373 IN EFI_QUESTION_ID QuestionId,
374 IN UINT8 Type,
375 IN EFI_IFR_TYPE_VALUE *Value,
376 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
377 )
378 {
379 CHAR8 *LangCode;
380 CHAR8 *Lang;
381 UINTN Index;
382 EFI_STATUS Status;
383
384 //
385 //Chech whether exit from BMM and reenter frontpage,if yes,reclaim string depositories
386 //
387 if (Action == EFI_BROWSER_ACTION_FORM_OPEN){
388 if (mEnterBmm){
389 ReclaimStringDepository();
390 mEnterBmm = FALSE;
391 }
392 }
393
394 if (Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_CHANGED) {
395 //
396 // Do nothing for other UEFI Action. Only do call back when data is changed.
397 //
398 return EFI_UNSUPPORTED;
399 }
400
401 if (Action == EFI_BROWSER_ACTION_CHANGED) {
402 if ((Value == NULL) || (ActionRequest == NULL)) {
403 return EFI_INVALID_PARAMETER;
404 }
405
406 switch (QuestionId) {
407 case FRONT_PAGE_KEY_CONTINUE:
408 //
409 // This is the continue - clear the screen and return an error to get out of FrontPage loop
410 //
411 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
412 break;
413
414 case FRONT_PAGE_KEY_LANGUAGE:
415 //
416 // Allocate working buffer for RFC 4646 language in supported LanguageString.
417 //
418 Lang = AllocatePool (AsciiStrSize (mLanguageString));
419 ASSERT (Lang != NULL);
420
421 Index = 0;
422 LangCode = mLanguageString;
423 while (*LangCode != 0) {
424 GetNextLanguage (&LangCode, Lang);
425
426 if (Index == Value->u8) {
427 break;
428 }
429
430 Index++;
431 }
432
433 if (Index == Value->u8) {
434 Status = gRT->SetVariable (
435 L"PlatformLang",
436 &gEfiGlobalVariableGuid,
437 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
438 AsciiStrSize (Lang),
439 Lang
440 );
441 ASSERT_EFI_ERROR(Status);
442 } else {
443 ASSERT (FALSE);
444 }
445 FreePool (Lang);
446 //
447 //Current language of platform is changed,recreate oneof options for language.
448 //
449 InitializeLanguage();
450 break;
451
452 default:
453 break;
454 }
455 } else if (Action == EFI_BROWSER_ACTION_CHANGING) {
456 if (Value == NULL) {
457 return EFI_INVALID_PARAMETER;
458 }
459
460 //
461 // The first 4 entries in the Front Page are to be GUARANTEED to remain constant so IHV's can
462 // describe to their customers in documentation how to find their setup information (namely
463 // under the device manager and specific buckets)
464 //
465 switch (QuestionId) {
466 case FRONT_PAGE_KEY_BOOT_MANAGER:
467 //
468 // Boot Manager
469 //
470 EnumerateBootOptions ();
471 break;
472
473 case FRONT_PAGE_KEY_DEVICE_MANAGER:
474 //
475 // Device Manager
476 //
477 CreateDeviceManagerForm(DEVICE_MANAGER_FORM_ID);
478 break;
479
480 case FRONT_PAGE_KEY_BOOT_MAINTAIN:
481 //
482 // Boot Maintenance Manager
483 //
484 InitializeBM ();
485 mEnterBmm = TRUE;
486 break;
487
488 default:
489 break;
490 }
491 }
492
493 return EFI_SUCCESS;
494 }
495
496 /**
497 Initialize HII information for the FrontPage
498
499
500 @retval EFI_SUCCESS The operation is successful.
501 @retval EFI_DEVICE_ERROR If the dynamic opcode creation failed.
502
503 **/
504 EFI_STATUS
505 InitializeFrontPage (
506 VOID
507 )
508 {
509 EFI_STATUS Status;
510
511 //
512 // Locate Hii relative protocols
513 //
514 Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &gFormBrowser2);
515 if (EFI_ERROR (Status)) {
516 return Status;
517 }
518
519 //
520 // Install Device Path Protocol and Config Access protocol to driver handle
521 //
522 gFrontPagePrivate.DriverHandle = NULL;
523 Status = gBS->InstallMultipleProtocolInterfaces (
524 &gFrontPagePrivate.DriverHandle,
525 &gEfiDevicePathProtocolGuid,
526 &mFrontPageHiiVendorDevicePath,
527 &gEfiHiiConfigAccessProtocolGuid,
528 &gFrontPagePrivate.ConfigAccess,
529 NULL
530 );
531 ASSERT_EFI_ERROR (Status);
532
533 //
534 // Publish our HII data
535 //
536 gFrontPagePrivate.HiiHandle = HiiAddPackages (
537 &mFrontPageGuid,
538 gFrontPagePrivate.DriverHandle,
539 FrontPageVfrBin,
540 UiAppStrings,
541 NULL
542 );
543 ASSERT (gFrontPagePrivate.HiiHandle != NULL);
544
545 //
546 //Updata Front Page strings
547 //
548 UpdateFrontPageStrings ();
549
550 //
551 // Initialize laguage options
552 //
553 InitializeLanguage ();
554
555 return Status;
556 }
557
558 /**
559 Call the browser and display the front page
560
561 @return Status code that will be returned by
562 EFI_FORM_BROWSER2_PROTOCOL.SendForm ().
563
564 **/
565 EFI_STATUS
566 CallFrontPage (
567 VOID
568 )
569 {
570 EFI_STATUS Status;
571 EFI_BROWSER_ACTION_REQUEST ActionRequest;
572
573 //
574 // Begin waiting for USER INPUT
575 //
576 REPORT_STATUS_CODE (
577 EFI_PROGRESS_CODE,
578 (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_PC_INPUT_WAIT)
579 );
580
581 ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE;
582 Status = gFormBrowser2->SendForm (
583 gFormBrowser2,
584 &gFrontPagePrivate.HiiHandle,
585 1,
586 &mFrontPageGuid,
587 0,
588 NULL,
589 &ActionRequest
590 );
591 //
592 // Check whether user change any option setting which needs a reset to be effective
593 //
594 if (ActionRequest == EFI_BROWSER_ACTION_REQUEST_RESET) {
595 EnableResetRequired ();
596 }
597
598 return Status;
599 }
600
601 /**
602 Remove the installed packages from the HiiDatabase.
603
604 **/
605 VOID
606 FreeFrontPage(
607 VOID
608 )
609 {
610 EFI_STATUS Status;
611 Status = gBS->UninstallMultipleProtocolInterfaces (
612 gFrontPagePrivate.DriverHandle,
613 &gEfiDevicePathProtocolGuid,
614 &mFrontPageHiiVendorDevicePath,
615 &gEfiHiiConfigAccessProtocolGuid,
616 &gFrontPagePrivate.ConfigAccess,
617 NULL
618 );
619 ASSERT_EFI_ERROR (Status);
620
621 //
622 // Publish our HII data
623 //
624 HiiRemovePackages (gFrontPagePrivate.HiiHandle);
625 if (gFrontPagePrivate.LanguageToken != NULL) {
626 FreePool (gFrontPagePrivate.LanguageToken);
627 gFrontPagePrivate.LanguageToken = NULL;
628 }
629 }
630
631 /**
632 Convert Processor Frequency Data to a string.
633
634 @param ProcessorFrequency The frequency data to process
635 @param Base10Exponent The exponent based on 10
636 @param String The string that is created
637
638 **/
639 VOID
640 ConvertProcessorToString (
641 IN UINT16 ProcessorFrequency,
642 IN UINT16 Base10Exponent,
643 OUT CHAR16 **String
644 )
645 {
646 CHAR16 *StringBuffer;
647 UINTN Index;
648 UINTN DestMax;
649 UINT32 FreqMhz;
650
651 if (Base10Exponent >= 6) {
652 FreqMhz = ProcessorFrequency;
653 for (Index = 0; Index < (UINTN) (Base10Exponent - 6); Index++) {
654 FreqMhz *= 10;
655 }
656 } else {
657 FreqMhz = 0;
658 }
659 DestMax = 0x20 / sizeof (CHAR16);
660 StringBuffer = AllocateZeroPool (0x20);
661 ASSERT (StringBuffer != NULL);
662 Index = UnicodeValueToString (StringBuffer, LEFT_JUSTIFY, FreqMhz / 1000, 3);
663 StrCatS (StringBuffer, DestMax, L".");
664 UnicodeValueToString (StringBuffer + Index + 1, PREFIX_ZERO, (FreqMhz % 1000) / 10, 2);
665 StrCatS (StringBuffer, DestMax, L" GHz");
666 *String = (CHAR16 *) StringBuffer;
667 return ;
668 }
669
670
671 /**
672 Convert Memory Size to a string.
673
674 @param MemorySize The size of the memory to process
675 @param String The string that is created
676
677 **/
678 VOID
679 ConvertMemorySizeToString (
680 IN UINT32 MemorySize,
681 OUT CHAR16 **String
682 )
683 {
684 CHAR16 *StringBuffer;
685
686 StringBuffer = AllocateZeroPool (0x24);
687 ASSERT (StringBuffer != NULL);
688 UnicodeValueToString (StringBuffer, LEFT_JUSTIFY, MemorySize, 10);
689 StrCatS (StringBuffer, 0x24 / sizeof (CHAR16), L" MB RAM");
690
691 *String = (CHAR16 *) StringBuffer;
692
693 return ;
694 }
695
696 /**
697
698 Acquire the string associated with the Index from smbios structure and return it.
699 The caller is responsible for free the string buffer.
700
701 @param OptionalStrStart The start position to search the string
702 @param Index The index of the string to extract
703 @param String The string that is extracted
704
705 @retval EFI_SUCCESS The function returns EFI_SUCCESS always.
706
707 **/
708 EFI_STATUS
709 GetOptionalStringByIndex (
710 IN CHAR8 *OptionalStrStart,
711 IN UINT8 Index,
712 OUT CHAR16 **String
713 )
714 {
715 UINTN StrSize;
716
717 if (Index == 0) {
718 *String = AllocateZeroPool (sizeof (CHAR16));
719 return EFI_SUCCESS;
720 }
721
722 StrSize = 0;
723 do {
724 Index--;
725 OptionalStrStart += StrSize;
726 StrSize = AsciiStrSize (OptionalStrStart);
727 } while (OptionalStrStart[StrSize] != 0 && Index != 0);
728
729 if ((Index != 0) || (StrSize == 1)) {
730 //
731 // Meet the end of strings set but Index is non-zero, or
732 // Find an empty string
733 //
734 *String = GetStringById (STRING_TOKEN (STR_MISSING_STRING));
735 } else {
736 *String = AllocatePool (StrSize * sizeof (CHAR16));
737 AsciiStrToUnicodeStr (OptionalStrStart, *String);
738 }
739
740 return EFI_SUCCESS;
741 }
742
743
744 /**
745 Update the banner information for the Front Page based on Smbios information.
746 **/
747 VOID
748 UpdateFrontPageStrings (
749 VOID
750 )
751 {
752 UINT8 StrIndex;
753 CHAR16 *NewString;
754 CHAR16 *FirmwareVersionString;
755 BOOLEAN Find[5];
756 EFI_STATUS Status;
757 EFI_STRING_ID TokenToUpdate;
758 EFI_SMBIOS_HANDLE SmbiosHandle;
759 EFI_SMBIOS_PROTOCOL *Smbios;
760 SMBIOS_TABLE_TYPE0 *Type0Record;
761 SMBIOS_TABLE_TYPE1 *Type1Record;
762 SMBIOS_TABLE_TYPE4 *Type4Record;
763 SMBIOS_TABLE_TYPE19 *Type19Record;
764 EFI_SMBIOS_TABLE_HEADER *Record;
765
766 ZeroMem (Find, sizeof (Find));
767
768 //
769 // Update Front Page strings
770 //
771 Status = gBS->LocateProtocol (
772 &gEfiSmbiosProtocolGuid,
773 NULL,
774 (VOID **) &Smbios
775 );
776 if (EFI_ERROR (Status)) {
777 return ;
778 }
779
780 SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
781 do {
782 Status = Smbios->GetNext (Smbios, &SmbiosHandle, NULL, &Record, NULL);
783 if (EFI_ERROR(Status)) {
784 break;
785 }
786
787 if (Record->Type == EFI_SMBIOS_TYPE_BIOS_INFORMATION) {
788 Type0Record = (SMBIOS_TABLE_TYPE0 *) Record;
789 StrIndex = Type0Record->BiosVersion;
790 GetOptionalStringByIndex ((CHAR8*)((UINT8*)Type0Record + Type0Record->Hdr.Length), StrIndex, &NewString);
791 TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_BIOS_VERSION);
792 FirmwareVersionString = (CHAR16 *) PcdGetPtr (PcdFirmwareVersionString);
793 if (*FirmwareVersionString != 0x0000 ) {
794 FreePool (NewString);
795 NewString = (CHAR16 *) PcdGetPtr (PcdFirmwareVersionString);
796 HiiSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString, NULL);
797 } else {
798 HiiSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString, NULL);
799 FreePool (NewString);
800 }
801 Find[0] = TRUE;
802 }
803
804 if (Record->Type == EFI_SMBIOS_TYPE_SYSTEM_INFORMATION) {
805 Type1Record = (SMBIOS_TABLE_TYPE1 *) Record;
806 StrIndex = Type1Record->ProductName;
807 GetOptionalStringByIndex ((CHAR8*)((UINT8*)Type1Record + Type1Record->Hdr.Length), StrIndex, &NewString);
808 TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_COMPUTER_MODEL);
809 HiiSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString, NULL);
810 FreePool (NewString);
811 Find[1] = TRUE;
812 }
813
814 if ((Record->Type == EFI_SMBIOS_TYPE_PROCESSOR_INFORMATION) && !Find[2]) {
815 Type4Record = (SMBIOS_TABLE_TYPE4 *) Record;
816 //
817 // The information in the record should be only valid when the CPU Socket is populated.
818 //
819 if ((Type4Record->Status & SMBIOS_TYPE4_CPU_SOCKET_POPULATED) == SMBIOS_TYPE4_CPU_SOCKET_POPULATED) {
820 StrIndex = Type4Record->ProcessorVersion;
821 GetOptionalStringByIndex ((CHAR8*)((UINT8*)Type4Record + Type4Record->Hdr.Length), StrIndex, &NewString);
822 TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_CPU_MODEL);
823 HiiSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString, NULL);
824 FreePool (NewString);
825 Find[2] = TRUE;
826 }
827 }
828
829 if ((Record->Type == EFI_SMBIOS_TYPE_PROCESSOR_INFORMATION) && !Find[3]) {
830 Type4Record = (SMBIOS_TABLE_TYPE4 *) Record;
831 //
832 // The information in the record should be only valid when the CPU Socket is populated.
833 //
834 if ((Type4Record->Status & SMBIOS_TYPE4_CPU_SOCKET_POPULATED) == SMBIOS_TYPE4_CPU_SOCKET_POPULATED) {
835 ConvertProcessorToString(Type4Record->CurrentSpeed, 6, &NewString);
836 TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_CPU_SPEED);
837 HiiSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString, NULL);
838 FreePool (NewString);
839 Find[3] = TRUE;
840 }
841 }
842
843 if ( Record->Type == EFI_SMBIOS_TYPE_MEMORY_ARRAY_MAPPED_ADDRESS ) {
844 Type19Record = (SMBIOS_TABLE_TYPE19 *) Record;
845 ConvertMemorySizeToString (
846 (UINT32)(RShiftU64((Type19Record->EndingAddress - Type19Record->StartingAddress + 1), 10)),
847 &NewString
848 );
849 TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_MEMORY_SIZE);
850 HiiSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString, NULL);
851 FreePool (NewString);
852 Find[4] = TRUE;
853 }
854 } while ( !(Find[0] && Find[1] && Find[2] && Find[3] && Find[4]));
855 return ;
856 }
857
858 /**
859 This function will change video resolution and text mode
860 according to defined setup mode or defined boot mode
861
862 @param IsSetupMode Indicate mode is changed to setup mode or boot mode.
863
864 @retval EFI_SUCCESS Mode is changed successfully.
865 @retval Others Mode failed to be changed.
866
867 **/
868 EFI_STATUS
869 EFIAPI
870 BdsSetConsoleMode (
871 BOOLEAN IsSetupMode
872 )
873 {
874 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
875 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *SimpleTextOut;
876 UINTN SizeOfInfo;
877 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;
878 UINT32 MaxGopMode;
879 UINT32 MaxTextMode;
880 UINT32 ModeNumber;
881 UINT32 NewHorizontalResolution;
882 UINT32 NewVerticalResolution;
883 UINT32 NewColumns;
884 UINT32 NewRows;
885 UINTN HandleCount;
886 EFI_HANDLE *HandleBuffer;
887 EFI_STATUS Status;
888 UINTN Index;
889 UINTN CurrentColumn;
890 UINTN CurrentRow;
891
892 MaxGopMode = 0;
893 MaxTextMode = 0;
894
895 //
896 // Get current video resolution and text mode
897 //
898 Status = gBS->HandleProtocol (
899 gST->ConsoleOutHandle,
900 &gEfiGraphicsOutputProtocolGuid,
901 (VOID**)&GraphicsOutput
902 );
903 if (EFI_ERROR (Status)) {
904 GraphicsOutput = NULL;
905 }
906
907 Status = gBS->HandleProtocol (
908 gST->ConsoleOutHandle,
909 &gEfiSimpleTextOutProtocolGuid,
910 (VOID**)&SimpleTextOut
911 );
912 if (EFI_ERROR (Status)) {
913 SimpleTextOut = NULL;
914 }
915
916 if ((GraphicsOutput == NULL) || (SimpleTextOut == NULL)) {
917 return EFI_UNSUPPORTED;
918 }
919
920 if (IsSetupMode) {
921 //
922 // The requried resolution and text mode is setup mode.
923 //
924 NewHorizontalResolution = mSetupHorizontalResolution;
925 NewVerticalResolution = mSetupVerticalResolution;
926 NewColumns = mSetupTextModeColumn;
927 NewRows = mSetupTextModeRow;
928 } else {
929 //
930 // The required resolution and text mode is boot mode.
931 //
932 NewHorizontalResolution = mBootHorizontalResolution;
933 NewVerticalResolution = mBootVerticalResolution;
934 NewColumns = mBootTextModeColumn;
935 NewRows = mBootTextModeRow;
936 }
937
938 if (GraphicsOutput != NULL) {
939 MaxGopMode = GraphicsOutput->Mode->MaxMode;
940 }
941
942 if (SimpleTextOut != NULL) {
943 MaxTextMode = SimpleTextOut->Mode->MaxMode;
944 }
945
946 //
947 // 1. If current video resolution is same with required video resolution,
948 // video resolution need not be changed.
949 // 1.1. If current text mode is same with required text mode, text mode need not be changed.
950 // 1.2. If current text mode is different from required text mode, text mode need be changed.
951 // 2. If current video resolution is different from required video resolution, we need restart whole console drivers.
952 //
953 for (ModeNumber = 0; ModeNumber < MaxGopMode; ModeNumber++) {
954 Status = GraphicsOutput->QueryMode (
955 GraphicsOutput,
956 ModeNumber,
957 &SizeOfInfo,
958 &Info
959 );
960 if (!EFI_ERROR (Status)) {
961 if ((Info->HorizontalResolution == NewHorizontalResolution) &&
962 (Info->VerticalResolution == NewVerticalResolution)) {
963 if ((GraphicsOutput->Mode->Info->HorizontalResolution == NewHorizontalResolution) &&
964 (GraphicsOutput->Mode->Info->VerticalResolution == NewVerticalResolution)) {
965 //
966 // Current resolution is same with required resolution, check if text mode need be set
967 //
968 Status = SimpleTextOut->QueryMode (SimpleTextOut, SimpleTextOut->Mode->Mode, &CurrentColumn, &CurrentRow);
969 ASSERT_EFI_ERROR (Status);
970 if (CurrentColumn == NewColumns && CurrentRow == NewRows) {
971 //
972 // If current text mode is same with required text mode. Do nothing
973 //
974 FreePool (Info);
975 return EFI_SUCCESS;
976 } else {
977 //
978 // If current text mode is different from requried text mode. Set new video mode
979 //
980 for (Index = 0; Index < MaxTextMode; Index++) {
981 Status = SimpleTextOut->QueryMode (SimpleTextOut, Index, &CurrentColumn, &CurrentRow);
982 if (!EFI_ERROR(Status)) {
983 if ((CurrentColumn == NewColumns) && (CurrentRow == NewRows)) {
984 //
985 // Required text mode is supported, set it.
986 //
987 Status = SimpleTextOut->SetMode (SimpleTextOut, Index);
988 ASSERT_EFI_ERROR (Status);
989 //
990 // Update text mode PCD.
991 //
992 PcdSet32 (PcdConOutColumn, mSetupTextModeColumn);
993 PcdSet32 (PcdConOutRow, mSetupTextModeRow);
994 FreePool (Info);
995 return EFI_SUCCESS;
996 }
997 }
998 }
999 if (Index == MaxTextMode) {
1000 //
1001 // If requried text mode is not supported, return error.
1002 //
1003 FreePool (Info);
1004 return EFI_UNSUPPORTED;
1005 }
1006 }
1007 } else {
1008 //
1009 // If current video resolution is not same with the new one, set new video resolution.
1010 // In this case, the driver which produces simple text out need be restarted.
1011 //
1012 Status = GraphicsOutput->SetMode (GraphicsOutput, ModeNumber);
1013 if (!EFI_ERROR (Status)) {
1014 FreePool (Info);
1015 break;
1016 }
1017 }
1018 }
1019 FreePool (Info);
1020 }
1021 }
1022
1023 if (ModeNumber == MaxGopMode) {
1024 //
1025 // If the resolution is not supported, return error.
1026 //
1027 return EFI_UNSUPPORTED;
1028 }
1029
1030 //
1031 // Set PCD to Inform GraphicsConsole to change video resolution.
1032 // Set PCD to Inform Consplitter to change text mode.
1033 //
1034 PcdSet32 (PcdVideoHorizontalResolution, NewHorizontalResolution);
1035 PcdSet32 (PcdVideoVerticalResolution, NewVerticalResolution);
1036 PcdSet32 (PcdConOutColumn, NewColumns);
1037 PcdSet32 (PcdConOutRow, NewRows);
1038
1039
1040 //
1041 // Video mode is changed, so restart graphics console driver and higher level driver.
1042 // Reconnect graphics console driver and higher level driver.
1043 // Locate all the handles with GOP protocol and reconnect it.
1044 //
1045 Status = gBS->LocateHandleBuffer (
1046 ByProtocol,
1047 &gEfiSimpleTextOutProtocolGuid,
1048 NULL,
1049 &HandleCount,
1050 &HandleBuffer
1051 );
1052 if (!EFI_ERROR (Status)) {
1053 for (Index = 0; Index < HandleCount; Index++) {
1054 gBS->DisconnectController (HandleBuffer[Index], NULL, NULL);
1055 }
1056 for (Index = 0; Index < HandleCount; Index++) {
1057 gBS->ConnectController (HandleBuffer[Index], NULL, NULL, TRUE);
1058 }
1059 if (HandleBuffer != NULL) {
1060 FreePool (HandleBuffer);
1061 }
1062 }
1063
1064 return EFI_SUCCESS;
1065 }
1066
1067 /**
1068 The user Entry Point for Application. The user code starts with this function
1069 as the real entry point for the image goes into a library that calls this
1070 function.
1071
1072 @param[in] ImageHandle The firmware allocated handle for the EFI image.
1073 @param[in] SystemTable A pointer to the EFI System Table.
1074
1075 @retval EFI_SUCCESS The entry point is executed successfully.
1076 @retval other Some error occurs when executing this entry point.
1077
1078 **/
1079 EFI_STATUS
1080 EFIAPI
1081 InitializeUserInterface (
1082 IN EFI_HANDLE ImageHandle,
1083 IN EFI_SYSTEM_TABLE *SystemTable
1084 )
1085 {
1086 EFI_HII_HANDLE HiiHandle;
1087 EFI_STATUS Status;
1088 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
1089 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *SimpleTextOut;
1090 UINTN BootTextColumn;
1091 UINTN BootTextRow;
1092
1093 if (!mModeInitialized) {
1094 //
1095 // After the console is ready, get current video resolution
1096 // and text mode before launching setup at first time.
1097 //
1098 Status = gBS->HandleProtocol (
1099 gST->ConsoleOutHandle,
1100 &gEfiGraphicsOutputProtocolGuid,
1101 (VOID**)&GraphicsOutput
1102 );
1103 if (EFI_ERROR (Status)) {
1104 GraphicsOutput = NULL;
1105 }
1106
1107 Status = gBS->HandleProtocol (
1108 gST->ConsoleOutHandle,
1109 &gEfiSimpleTextOutProtocolGuid,
1110 (VOID**)&SimpleTextOut
1111 );
1112 if (EFI_ERROR (Status)) {
1113 SimpleTextOut = NULL;
1114 }
1115
1116 if (GraphicsOutput != NULL) {
1117 //
1118 // Get current video resolution and text mode.
1119 //
1120 mBootHorizontalResolution = GraphicsOutput->Mode->Info->HorizontalResolution;
1121 mBootVerticalResolution = GraphicsOutput->Mode->Info->VerticalResolution;
1122 }
1123
1124 if (SimpleTextOut != NULL) {
1125 Status = SimpleTextOut->QueryMode (
1126 SimpleTextOut,
1127 SimpleTextOut->Mode->Mode,
1128 &BootTextColumn,
1129 &BootTextRow
1130 );
1131 mBootTextModeColumn = (UINT32)BootTextColumn;
1132 mBootTextModeRow = (UINT32)BootTextRow;
1133 }
1134
1135 //
1136 // Get user defined text mode for setup.
1137 //
1138 mSetupHorizontalResolution = PcdGet32 (PcdSetupVideoHorizontalResolution);
1139 mSetupVerticalResolution = PcdGet32 (PcdSetupVideoVerticalResolution);
1140 mSetupTextModeColumn = PcdGet32 (PcdSetupConOutColumn);
1141 mSetupTextModeRow = PcdGet32 (PcdSetupConOutRow);
1142
1143 mModeInitialized = TRUE;
1144 }
1145
1146 gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
1147 gST->ConOut->ClearScreen (gST->ConOut);
1148
1149 //
1150 // Install customized fonts needed by Front Page
1151 //
1152
1153 HiiHandle = ExportFonts ();
1154 ASSERT (HiiHandle != NULL);
1155
1156 InitializeStringSupport ();
1157
1158 BdsSetConsoleMode (TRUE);
1159 UiEntry (FALSE);
1160 BdsSetConsoleMode (FALSE);
1161
1162 UninitializeStringSupport ();
1163 HiiRemovePackages (HiiHandle);
1164
1165 return EFI_SUCCESS;
1166 }
1167
1168 /**
1169 This function is the main entry of the UI entry.
1170 The function will present the main menu of the system UI.
1171
1172 @param ConnectAllHappened Caller passes the value to UI to avoid unnecessary connect-all.
1173
1174 **/
1175 VOID
1176 EFIAPI
1177 UiEntry (
1178 IN BOOLEAN ConnectAllHappened
1179 )
1180 {
1181 EFI_STATUS Status;
1182 EFI_BOOT_LOGO_PROTOCOL *BootLogo;
1183
1184 //
1185 // Indicate if the connect all has been performed before.
1186 //
1187 if (ConnectAllHappened) {
1188 gConnectAllHappened = TRUE;
1189 }
1190
1191 //
1192 // The boot option enumeration time is acceptable in Ui driver
1193 //
1194 EfiBootManagerRefreshAllBootOption ();
1195
1196 //
1197 // Boot Logo is corrupted, report it using Boot Logo protocol.
1198 //
1199 Status = gBS->LocateProtocol (&gEfiBootLogoProtocolGuid, NULL, (VOID **) &BootLogo);
1200 if (!EFI_ERROR (Status) && (BootLogo != NULL)) {
1201 BootLogo->SetBootLogo (BootLogo, NULL, 0, 0, 0, 0);
1202 }
1203
1204 InitializeFrontPage ();
1205 InitializeDeviceManager ();
1206 InitializeBootManager ();
1207 InitBootMaintenance();
1208
1209 CallFrontPage ();
1210
1211 FreeBMPackage ();
1212 FreeBootManager ();
1213 FreeDeviceManager ();
1214 FreeFrontPage ();
1215
1216 if (mLanguageString != NULL) {
1217 FreePool (mLanguageString);
1218 mLanguageString = NULL;
1219 }
1220
1221 //
1222 //Will leave browser, check any reset required change is applied? if yes, reset system
1223 //
1224 SetupResetReminder ();
1225 }
1226
1227 /**
1228 Extract device path for given HII handle and class guid.
1229
1230 @param Handle The HII handle.
1231
1232 @retval NULL Fail to get the device path string.
1233 @return PathString Get the device path string.
1234
1235 **/
1236 CHAR16 *
1237 ExtractDevicePathFromHiiHandle (
1238 IN EFI_HII_HANDLE Handle
1239 )
1240 {
1241 EFI_STATUS Status;
1242 EFI_HANDLE DriverHandle;
1243 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
1244 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *PathToText;
1245 CHAR16 *NewString;
1246
1247 ASSERT (Handle != NULL);
1248
1249 if (Handle == NULL) {
1250 return NULL;
1251 }
1252
1253 Status = gHiiDatabase->GetPackageListHandle (gHiiDatabase, Handle, &DriverHandle);
1254 if (EFI_ERROR (Status)) {
1255 return NULL;
1256 }
1257
1258 //
1259 // Get the device path by the got Driver handle .
1260 //
1261 Status = gBS->HandleProtocol (DriverHandle, &gEfiDevicePathProtocolGuid, (VOID **) &DevicePath);
1262 if (EFI_ERROR (Status)) {
1263 return NULL;
1264 }
1265
1266 Status = gBS->LocateProtocol (
1267 &gEfiDevicePathToTextProtocolGuid,
1268 NULL,
1269 (VOID **) &PathToText
1270 );
1271 if (EFI_ERROR (Status)) {
1272 return NULL;
1273 }
1274
1275 //
1276 // Get device path string.
1277 //
1278 NewString = PathToText->ConvertDevicePathToText(DevicePath, FALSE, FALSE);
1279
1280 return NewString;
1281 }
1282
1283 /**
1284 Extract the displayed formset for given HII handle and class guid.
1285
1286 @param Handle The HII handle.
1287 @param SetupClassGuid The class guid specifies which form set will be displayed.
1288 @param SkipCount Skip some formsets which has processed before.
1289 @param FormSetTitle Formset title string.
1290 @param FormSetHelp Formset help string.
1291 @param FormSetGuid Formset Guid.
1292
1293 @retval TRUE The formset for given HII handle will be displayed.
1294 @return FALSE The formset for given HII handle will not be displayed.
1295
1296 **/
1297 BOOLEAN
1298 ExtractDisplayedHiiFormFromHiiHandle (
1299 IN EFI_HII_HANDLE Handle,
1300 IN EFI_GUID *SetupClassGuid,
1301 IN UINTN SkipCount,
1302 OUT EFI_STRING_ID *FormSetTitle,
1303 OUT EFI_STRING_ID *FormSetHelp,
1304 OUT EFI_GUID *FormSetGuid
1305 )
1306 {
1307 EFI_STATUS Status;
1308 UINTN BufferSize;
1309 EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList;
1310 UINT8 *Package;
1311 UINT8 *OpCodeData;
1312 UINT32 Offset;
1313 UINT32 Offset2;
1314 UINT32 PackageListLength;
1315 EFI_HII_PACKAGE_HEADER PackageHeader;
1316 EFI_GUID *ClassGuid;
1317 UINT8 ClassGuidNum;
1318 BOOLEAN FoundAndSkip;
1319
1320 ASSERT (Handle != NULL);
1321 ASSERT (SetupClassGuid != NULL && FormSetTitle != NULL && FormSetHelp != NULL && FormSetGuid != NULL);
1322
1323 *FormSetTitle = 0;
1324 *FormSetHelp = 0;
1325 ClassGuidNum = 0;
1326 ClassGuid = NULL;
1327 FoundAndSkip = FALSE;
1328
1329 //
1330 // Get HII PackageList
1331 //
1332 BufferSize = 0;
1333 HiiPackageList = NULL;
1334 Status = gHiiDatabase->ExportPackageLists (gHiiDatabase, Handle, &BufferSize, HiiPackageList);
1335 //
1336 // Handle is a invalid handle. Check if Handle is corrupted.
1337 //
1338 ASSERT (Status != EFI_NOT_FOUND);
1339 //
1340 // The return status should always be EFI_BUFFER_TOO_SMALL as input buffer's size is 0.
1341 //
1342 ASSERT (Status == EFI_BUFFER_TOO_SMALL);
1343
1344 HiiPackageList = AllocatePool (BufferSize);
1345 ASSERT (HiiPackageList != NULL);
1346
1347 Status = gHiiDatabase->ExportPackageLists (gHiiDatabase, Handle, &BufferSize, HiiPackageList);
1348 if (EFI_ERROR (Status)) {
1349 return FALSE;
1350 }
1351
1352 //
1353 // Get Form package from this HII package List
1354 //
1355 Offset = sizeof (EFI_HII_PACKAGE_LIST_HEADER);
1356 PackageListLength = ReadUnaligned32 (&HiiPackageList->PackageLength);
1357
1358 while (Offset < PackageListLength) {
1359 Package = ((UINT8 *) HiiPackageList) + Offset;
1360 CopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER));
1361 Offset += PackageHeader.Length;
1362
1363 if (PackageHeader.Type == EFI_HII_PACKAGE_FORMS) {
1364 //
1365 // Search FormSet Opcode in this Form Package
1366 //
1367 Offset2 = sizeof (EFI_HII_PACKAGE_HEADER);
1368 while (Offset2 < PackageHeader.Length) {
1369 OpCodeData = Package + Offset2;
1370 Offset2 += ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
1371
1372 if (((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode == EFI_IFR_FORM_SET_OP) {
1373 if (((EFI_IFR_OP_HEADER *) OpCodeData)->Length > OFFSET_OF (EFI_IFR_FORM_SET, Flags)) {
1374 //
1375 // Find FormSet OpCode
1376 //
1377 ClassGuidNum = (UINT8) (((EFI_IFR_FORM_SET *) OpCodeData)->Flags & 0x3);
1378 ClassGuid = (EFI_GUID *) (VOID *)(OpCodeData + sizeof (EFI_IFR_FORM_SET));
1379 while (ClassGuidNum-- > 0) {
1380 if (CompareGuid (SetupClassGuid, ClassGuid)) {
1381 //
1382 // Check whether need to skip the formset.
1383 //
1384 if (SkipCount != 0) {
1385 SkipCount--;
1386 FoundAndSkip = TRUE;
1387 break;
1388 }
1389 CopyMem (FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID));
1390 CopyMem (FormSetHelp, &((EFI_IFR_FORM_SET *) OpCodeData)->Help, sizeof (EFI_STRING_ID));
1391 CopyGuid (FormSetGuid, (CONST EFI_GUID *)(&((EFI_IFR_FORM_SET *) OpCodeData)->Guid));
1392 FreePool (HiiPackageList);
1393 return TRUE;
1394 }
1395 ClassGuid ++;
1396 }
1397 if (FoundAndSkip) {
1398 break;
1399 }
1400 } else if (CompareGuid (SetupClassGuid, &gEfiHiiPlatformSetupFormsetGuid)) {
1401 //
1402 // Check whether need to skip the formset.
1403 //
1404 if (SkipCount != 0) {
1405 SkipCount--;
1406 break;
1407 }
1408 CopyMem (FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID));
1409 CopyMem (FormSetHelp, &((EFI_IFR_FORM_SET *) OpCodeData)->Help, sizeof (EFI_STRING_ID));
1410 CopyGuid (FormSetGuid, (CONST EFI_GUID *)(&((EFI_IFR_FORM_SET *) OpCodeData)->Guid));
1411 FreePool (HiiPackageList);
1412 return TRUE;
1413 }
1414 }
1415 }
1416 }
1417 }
1418
1419 FreePool (HiiPackageList);
1420
1421 return FALSE;
1422 }
1423
1424 //
1425 // Following are BDS Lib functions which contain all the code about setup browser reset reminder feature.
1426 // Setup Browser reset reminder feature is that an reset reminder will be given before user leaves the setup browser if
1427 // user change any option setting which needs a reset to be effective, and the reset will be applied according to the user selection.
1428 //
1429
1430
1431 /**
1432 Enable the setup browser reset reminder feature.
1433 This routine is used in platform tip. If the platform policy need the feature, use the routine to enable it.
1434
1435 **/
1436 VOID
1437 EFIAPI
1438 EnableResetReminderFeature (
1439 VOID
1440 )
1441 {
1442 mFeaturerSwitch = TRUE;
1443 }
1444
1445
1446 /**
1447 Disable the setup browser reset reminder feature.
1448 This routine is used in platform tip. If the platform policy do not want the feature, use the routine to disable it.
1449
1450 **/
1451 VOID
1452 EFIAPI
1453 DisableResetReminderFeature (
1454 VOID
1455 )
1456 {
1457 mFeaturerSwitch = FALSE;
1458 }
1459
1460
1461 /**
1462 Record the info that a reset is required.
1463 A module boolean variable is used to record whether a reset is required.
1464
1465 **/
1466 VOID
1467 EFIAPI
1468 EnableResetRequired (
1469 VOID
1470 )
1471 {
1472 mResetRequired = TRUE;
1473 }
1474
1475
1476 /**
1477 Record the info that no reset is required.
1478 A module boolean variable is used to record whether a reset is required.
1479
1480 **/
1481 VOID
1482 EFIAPI
1483 DisableResetRequired (
1484 VOID
1485 )
1486 {
1487 mResetRequired = FALSE;
1488 }
1489
1490
1491 /**
1492 Check whether platform policy enable the reset reminder feature. The default is enabled.
1493
1494 **/
1495 BOOLEAN
1496 EFIAPI
1497 IsResetReminderFeatureEnable (
1498 VOID
1499 )
1500 {
1501 return mFeaturerSwitch;
1502 }
1503
1504
1505 /**
1506 Check if user changed any option setting which needs a system reset to be effective.
1507
1508 **/
1509 BOOLEAN
1510 EFIAPI
1511 IsResetRequired (
1512 VOID
1513 )
1514 {
1515 return mResetRequired;
1516 }
1517
1518
1519 /**
1520 Check whether a reset is needed, and finish the reset reminder feature.
1521 If a reset is needed, Popup a menu to notice user, and finish the feature
1522 according to the user selection.
1523
1524 **/
1525 VOID
1526 EFIAPI
1527 SetupResetReminder (
1528 VOID
1529 )
1530 {
1531 EFI_INPUT_KEY Key;
1532 CHAR16 *StringBuffer1;
1533 CHAR16 *StringBuffer2;
1534
1535
1536 //
1537 //check any reset required change is applied? if yes, reset system
1538 //
1539 if (IsResetReminderFeatureEnable ()) {
1540 if (IsResetRequired ()) {
1541
1542 StringBuffer1 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
1543 ASSERT (StringBuffer1 != NULL);
1544 StringBuffer2 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
1545 ASSERT (StringBuffer2 != NULL);
1546 StrCpyS (StringBuffer1, MAX_STRING_LEN, L"Configuration changed. Reset to apply it Now.");
1547 StrCpyS (StringBuffer2, MAX_STRING_LEN, L"Press ENTER to reset");
1548 //
1549 // Popup a menu to notice user
1550 //
1551 do {
1552 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, NULL);
1553 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
1554
1555 FreePool (StringBuffer1);
1556 FreePool (StringBuffer2);
1557
1558 gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
1559 }
1560 }
1561 }
1562
1563
1564 /**
1565 This function converts an input device structure to a Unicode string.
1566
1567 @param DevPath A pointer to the device path structure.
1568
1569 @return A new allocated Unicode string that represents the device path.
1570
1571 **/
1572 CHAR16 *
1573 UiDevicePathToStr (
1574 IN EFI_DEVICE_PATH_PROTOCOL *DevPath
1575 )
1576 {
1577 EFI_STATUS Status;
1578 CHAR16 *ToText;
1579 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *DevPathToText;
1580
1581 if (DevPath == NULL) {
1582 return NULL;
1583 }
1584
1585 Status = gBS->LocateProtocol (
1586 &gEfiDevicePathToTextProtocolGuid,
1587 NULL,
1588 (VOID **) &DevPathToText
1589 );
1590 ASSERT_EFI_ERROR (Status);
1591 ToText = DevPathToText->ConvertDevicePathToText (
1592 DevPath,
1593 FALSE,
1594 TRUE
1595 );
1596 ASSERT (ToText != NULL);
1597 return ToText;
1598 }
EFI Development Kit II mirror for PVE