VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Application/UiApp/FrontPage.c@ 99404

Last change on this file since 99404 was 99404, checked in by vboxsync, 22 months ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 34.7 KB
Line 
1/** @file
2 FrontPage routines to handle the callbacks and browser calls
3
4Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR>
5(C) Copyright 2018 Hewlett Packard Enterprise Development LP<BR>
6SPDX-License-Identifier: BSD-2-Clause-Patent
7
8**/
9
10#include "FrontPage.h"
11#include "FrontPageCustomizedUi.h"
12
13#define MAX_STRING_LEN 200
14
15EFI_GUID mFrontPageGuid = FRONT_PAGE_FORMSET_GUID;
16
17BOOLEAN mResetRequired = FALSE;
18
19EFI_FORM_BROWSER2_PROTOCOL *gFormBrowser2;
20CHAR8 *mLanguageString;
21BOOLEAN mModeInitialized = FALSE;
22//
23// Boot video resolution and text mode.
24//
25UINT32 mBootHorizontalResolution = 0;
26UINT32 mBootVerticalResolution = 0;
27UINT32 mBootTextModeColumn = 0;
28UINT32 mBootTextModeRow = 0;
29//
30// BIOS setup video resolution and text mode.
31//
32UINT32 mSetupTextModeColumn = 0;
33UINT32 mSetupTextModeRow = 0;
34UINT32 mSetupHorizontalResolution = 0;
35UINT32 mSetupVerticalResolution = 0;
36
37FRONT_PAGE_CALLBACK_DATA gFrontPagePrivate = {
38 FRONT_PAGE_CALLBACK_DATA_SIGNATURE,
39 NULL,
40 NULL,
41 NULL,
42 {
43 FakeExtractConfig,
44 FakeRouteConfig,
45 FrontPageCallback
46 }
47};
48
49HII_VENDOR_DEVICE_PATH mFrontPageHiiVendorDevicePath = {
50 {
51 {
52 HARDWARE_DEVICE_PATH,
53 HW_VENDOR_DP,
54 {
55 (UINT8)(sizeof (VENDOR_DEVICE_PATH)),
56 (UINT8)((sizeof (VENDOR_DEVICE_PATH)) >> 8)
57 }
58 },
59 //
60 // {8E6D99EE-7531-48f8-8745-7F6144468FF2}
61 //
62 { 0x8e6d99ee, 0x7531, 0x48f8, { 0x87, 0x45, 0x7f, 0x61, 0x44, 0x46, 0x8f, 0xf2 }
63 }
64 },
65 {
66 END_DEVICE_PATH_TYPE,
67 END_ENTIRE_DEVICE_PATH_SUBTYPE,
68 {
69 (UINT8)(END_DEVICE_PATH_LENGTH),
70 (UINT8)((END_DEVICE_PATH_LENGTH) >> 8)
71 }
72 }
73};
74
75/**
76 Update the banner information for the Front Page based on Smbios information.
77
78**/
79VOID
80UpdateFrontPageBannerStrings (
81 VOID
82 );
83
84/**
85 This function allows a caller to extract the current configuration for one
86 or more named elements from the target driver.
87
88
89 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
90 @param Request A null-terminated Unicode string in <ConfigRequest> format.
91 @param Progress On return, points to a character in the Request string.
92 Points to the string's null terminator if request was successful.
93 Points to the most recent '&' before the first failing name/value
94 pair (or the beginning of the string if the failure is in the
95 first name/value pair) if the request was not successful.
96 @param Results A null-terminated Unicode string in <ConfigAltResp> format which
97 has all values filled in for the names in the Request string.
98 String to be allocated by the called function.
99
100 @retval EFI_SUCCESS The Results is filled with the requested values.
101 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results.
102 @retval EFI_INVALID_PARAMETER Request is illegal syntax, or unknown name.
103 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
104
105**/
106EFI_STATUS
107EFIAPI
108FakeExtractConfig (
109 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
110 IN CONST EFI_STRING Request,
111 OUT EFI_STRING *Progress,
112 OUT EFI_STRING *Results
113 )
114{
115 if ((Progress == NULL) || (Results == NULL)) {
116 return EFI_INVALID_PARAMETER;
117 }
118
119 *Progress = Request;
120 return EFI_NOT_FOUND;
121}
122
123/**
124 This function processes the results of changes in configuration.
125
126
127 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
128 @param Configuration A null-terminated Unicode string in <ConfigResp> format.
129 @param Progress A pointer to a string filled in with the offset of the most
130 recent '&' before the first failing name/value pair (or the
131 beginning of the string if the failure is in the first
132 name/value pair) or the terminating NULL if all was successful.
133
134 @retval EFI_SUCCESS The Results is processed successfully.
135 @retval EFI_INVALID_PARAMETER Configuration is NULL.
136 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this driver.
137
138**/
139EFI_STATUS
140EFIAPI
141FakeRouteConfig (
142 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
143 IN CONST EFI_STRING Configuration,
144 OUT EFI_STRING *Progress
145 )
146{
147 if ((Configuration == NULL) || (Progress == NULL)) {
148 return EFI_INVALID_PARAMETER;
149 }
150
151 *Progress = Configuration;
152
153 return EFI_NOT_FOUND;
154}
155
156/**
157 This function processes the results of changes in configuration.
158
159
160 @param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
161 @param Action Specifies the type of action taken by the browser.
162 @param QuestionId A unique value which is sent to the original exporting driver
163 so that it can identify the type of data to expect.
164 @param Type The type of value for the question.
165 @param Value A pointer to the data being sent to the original exporting driver.
166 @param ActionRequest On return, points to the action requested by the callback function.
167
168 @retval EFI_SUCCESS The callback successfully handled the action.
169 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the variable and its data.
170 @retval EFI_DEVICE_ERROR The variable could not be saved.
171 @retval EFI_UNSUPPORTED The specified Action is not supported by the callback.
172
173**/
174EFI_STATUS
175EFIAPI
176FrontPageCallback (
177 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
178 IN EFI_BROWSER_ACTION Action,
179 IN EFI_QUESTION_ID QuestionId,
180 IN UINT8 Type,
181 IN EFI_IFR_TYPE_VALUE *Value,
182 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
183 )
184{
185 return UiFrontPageCallbackHandler (gFrontPagePrivate.HiiHandle, Action, QuestionId, Type, Value, ActionRequest);
186}
187
188/**
189
190 Update the menus in the front page.
191
192**/
193VOID
194UpdateFrontPageForm (
195 VOID
196 )
197{
198 VOID *StartOpCodeHandle;
199 VOID *EndOpCodeHandle;
200 EFI_IFR_GUID_LABEL *StartGuidLabel;
201 EFI_IFR_GUID_LABEL *EndGuidLabel;
202
203 //
204 // Allocate space for creation of UpdateData Buffer
205 //
206 StartOpCodeHandle = HiiAllocateOpCodeHandle ();
207 ASSERT (StartOpCodeHandle != NULL);
208
209 EndOpCodeHandle = HiiAllocateOpCodeHandle ();
210 ASSERT (EndOpCodeHandle != NULL);
211 //
212 // Create Hii Extend Label OpCode as the start opcode
213 //
214 StartGuidLabel = (EFI_IFR_GUID_LABEL *)HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
215 StartGuidLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
216 StartGuidLabel->Number = LABEL_FRONTPAGE_INFORMATION;
217 //
218 // Create Hii Extend Label OpCode as the end opcode
219 //
220 EndGuidLabel = (EFI_IFR_GUID_LABEL *)HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL));
221 EndGuidLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
222 EndGuidLabel->Number = LABEL_END;
223
224 //
225 // Updata Front Page form
226 //
227 UiCustomizeFrontPage (
228 gFrontPagePrivate.HiiHandle,
229 StartOpCodeHandle
230 );
231
232 HiiUpdateForm (
233 gFrontPagePrivate.HiiHandle,
234 &mFrontPageGuid,
235 FRONT_PAGE_FORM_ID,
236 StartOpCodeHandle,
237 EndOpCodeHandle
238 );
239
240 HiiFreeOpCodeHandle (StartOpCodeHandle);
241 HiiFreeOpCodeHandle (EndOpCodeHandle);
242}
243
244/**
245 Initialize HII information for the FrontPage
246
247
248 @retval EFI_SUCCESS The operation is successful.
249 @retval EFI_DEVICE_ERROR If the dynamic opcode creation failed.
250
251**/
252EFI_STATUS
253InitializeFrontPage (
254 VOID
255 )
256{
257 EFI_STATUS Status;
258
259 //
260 // Locate Hii relative protocols
261 //
262 Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **)&gFormBrowser2);
263 if (EFI_ERROR (Status)) {
264 return Status;
265 }
266
267 //
268 // Install Device Path Protocol and Config Access protocol to driver handle
269 //
270 gFrontPagePrivate.DriverHandle = NULL;
271 Status = gBS->InstallMultipleProtocolInterfaces (
272 &gFrontPagePrivate.DriverHandle,
273 &gEfiDevicePathProtocolGuid,
274 &mFrontPageHiiVendorDevicePath,
275 &gEfiHiiConfigAccessProtocolGuid,
276 &gFrontPagePrivate.ConfigAccess,
277 NULL
278 );
279 ASSERT_EFI_ERROR (Status);
280
281 //
282 // Publish our HII data
283 //
284 gFrontPagePrivate.HiiHandle = HiiAddPackages (
285 &mFrontPageGuid,
286 gFrontPagePrivate.DriverHandle,
287 FrontPageVfrBin,
288 UiAppStrings,
289 NULL
290 );
291 ASSERT (gFrontPagePrivate.HiiHandle != NULL);
292
293 //
294 // Updata Front Page banner strings
295 //
296 UpdateFrontPageBannerStrings ();
297
298 //
299 // Update front page menus.
300 //
301 UpdateFrontPageForm ();
302
303 return Status;
304}
305
306/**
307 Call the browser and display the front page
308
309 @return Status code that will be returned by
310 EFI_FORM_BROWSER2_PROTOCOL.SendForm ().
311
312**/
313EFI_STATUS
314CallFrontPage (
315 VOID
316 )
317{
318 EFI_STATUS Status;
319 EFI_BROWSER_ACTION_REQUEST ActionRequest;
320
321 //
322 // Begin waiting for USER INPUT
323 //
324 REPORT_STATUS_CODE (
325 EFI_PROGRESS_CODE,
326 (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_PC_INPUT_WAIT)
327 );
328
329 ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE;
330 Status = gFormBrowser2->SendForm (
331 gFormBrowser2,
332 &gFrontPagePrivate.HiiHandle,
333 1,
334 &mFrontPageGuid,
335 0,
336 NULL,
337 &ActionRequest
338 );
339 //
340 // Check whether user change any option setting which needs a reset to be effective
341 //
342 if (ActionRequest == EFI_BROWSER_ACTION_REQUEST_RESET) {
343 EnableResetRequired ();
344 }
345
346 return Status;
347}
348
349/**
350 Remove the installed packages from the HiiDatabase.
351
352**/
353VOID
354FreeFrontPage (
355 VOID
356 )
357{
358 EFI_STATUS Status;
359
360 Status = gBS->UninstallMultipleProtocolInterfaces (
361 gFrontPagePrivate.DriverHandle,
362 &gEfiDevicePathProtocolGuid,
363 &mFrontPageHiiVendorDevicePath,
364 &gEfiHiiConfigAccessProtocolGuid,
365 &gFrontPagePrivate.ConfigAccess,
366 NULL
367 );
368 ASSERT_EFI_ERROR (Status);
369
370 //
371 // Publish our HII data
372 //
373 HiiRemovePackages (gFrontPagePrivate.HiiHandle);
374 if (gFrontPagePrivate.LanguageToken != NULL) {
375 FreePool (gFrontPagePrivate.LanguageToken);
376 gFrontPagePrivate.LanguageToken = NULL;
377 }
378}
379
380/**
381 Convert Processor Frequency Data to a string.
382
383 @param ProcessorFrequency The frequency data to process
384 @param Base10Exponent The exponent based on 10
385 @param String The string that is created
386
387**/
388VOID
389ConvertProcessorToString (
390 IN UINT16 ProcessorFrequency,
391 IN UINT16 Base10Exponent,
392 OUT CHAR16 **String
393 )
394{
395 CHAR16 *StringBuffer;
396 UINTN Index;
397 UINTN DestMax;
398 UINT32 FreqMhz;
399
400 if (Base10Exponent >= 6) {
401 FreqMhz = ProcessorFrequency;
402 for (Index = 0; Index < (UINT32)Base10Exponent - 6; Index++) {
403 FreqMhz *= 10;
404 }
405 } else {
406 FreqMhz = 0;
407 }
408
409 DestMax = 0x20 / sizeof (CHAR16);
410 StringBuffer = AllocateZeroPool (0x20);
411 ASSERT (StringBuffer != NULL);
412 UnicodeValueToStringS (StringBuffer, sizeof (CHAR16) * DestMax, LEFT_JUSTIFY, FreqMhz / 1000, 3);
413 Index = StrnLenS (StringBuffer, DestMax);
414 StrCatS (StringBuffer, DestMax, L".");
415 UnicodeValueToStringS (
416 StringBuffer + Index + 1,
417 sizeof (CHAR16) * (DestMax - (Index + 1)),
418 PREFIX_ZERO,
419 (FreqMhz % 1000) / 10,
420 2
421 );
422 StrCatS (StringBuffer, DestMax, L" GHz");
423 *String = (CHAR16 *)StringBuffer;
424 return;
425}
426
427/**
428 Convert Memory Size to a string.
429
430 @param MemorySize The size of the memory to process
431 @param String The string that is created
432
433**/
434VOID
435ConvertMemorySizeToString (
436 IN UINT32 MemorySize,
437 OUT CHAR16 **String
438 )
439{
440 CHAR16 *StringBuffer;
441
442 StringBuffer = AllocateZeroPool (0x24);
443 ASSERT (StringBuffer != NULL);
444 UnicodeValueToStringS (StringBuffer, 0x24, LEFT_JUSTIFY, MemorySize, 10);
445 StrCatS (StringBuffer, 0x24 / sizeof (CHAR16), L" MB RAM");
446
447 *String = (CHAR16 *)StringBuffer;
448
449 return;
450}
451
452/**
453
454 Acquire the string associated with the Index from smbios structure and return it.
455 The caller is responsible for free the string buffer.
456
457 @param OptionalStrStart The start position to search the string
458 @param Index The index of the string to extract
459 @param String The string that is extracted
460
461 @retval EFI_SUCCESS The function returns EFI_SUCCESS always.
462
463**/
464EFI_STATUS
465GetOptionalStringByIndex (
466 IN CHAR8 *OptionalStrStart,
467 IN UINT8 Index,
468 OUT CHAR16 **String
469 )
470{
471 UINTN StrSize;
472
473 if (Index == 0) {
474 *String = AllocateZeroPool (sizeof (CHAR16));
475 return EFI_SUCCESS;
476 }
477
478 StrSize = 0;
479 do {
480 Index--;
481 OptionalStrStart += StrSize;
482 StrSize = AsciiStrSize (OptionalStrStart);
483 } while (OptionalStrStart[StrSize] != 0 && Index != 0);
484
485 if ((Index != 0) || (StrSize == 1)) {
486 //
487 // Meet the end of strings set but Index is non-zero, or
488 // Find an empty string
489 //
490 *String = GetStringById (STRING_TOKEN (STR_MISSING_STRING));
491 } else {
492 *String = AllocatePool (StrSize * sizeof (CHAR16));
493 AsciiStrToUnicodeStrS (OptionalStrStart, *String, StrSize);
494 }
495
496 return EFI_SUCCESS;
497}
498
499/**
500
501 Update the banner information for the Front Page based on Smbios information.
502
503**/
504VOID
505UpdateFrontPageBannerStrings (
506 VOID
507 )
508{
509 UINT8 StrIndex;
510 CHAR16 *NewString;
511 CHAR16 *FirmwareVersionString;
512 EFI_STATUS Status;
513 EFI_SMBIOS_HANDLE SmbiosHandle;
514 EFI_SMBIOS_PROTOCOL *Smbios;
515 SMBIOS_TABLE_TYPE0 *Type0Record;
516 SMBIOS_TABLE_TYPE1 *Type1Record;
517 SMBIOS_TABLE_TYPE4 *Type4Record;
518 SMBIOS_TABLE_TYPE19 *Type19Record;
519 EFI_SMBIOS_TABLE_HEADER *Record;
520 UINT64 InstalledMemory;
521 BOOLEAN FoundCpu;
522
523 InstalledMemory = 0;
524 FoundCpu = 0;
525
526 //
527 // Update default banner string.
528 //
529 NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE4_LEFT), NULL);
530 UiCustomizeFrontPageBanner (4, TRUE, &NewString);
531 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE4_LEFT), NewString, NULL);
532 FreePool (NewString);
533
534 NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE4_RIGHT), NULL);
535 UiCustomizeFrontPageBanner (4, FALSE, &NewString);
536 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE4_RIGHT), NewString, NULL);
537 FreePool (NewString);
538
539 NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE5_LEFT), NULL);
540 UiCustomizeFrontPageBanner (5, TRUE, &NewString);
541 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE5_LEFT), NewString, NULL);
542 FreePool (NewString);
543
544 NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE5_RIGHT), NULL);
545 UiCustomizeFrontPageBanner (5, FALSE, &NewString);
546 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_CUSTOMIZE_BANNER_LINE5_RIGHT), NewString, NULL);
547 FreePool (NewString);
548
549 //
550 // Update Front Page banner strings base on SmBios Table.
551 //
552 Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID **)&Smbios);
553 if (EFI_ERROR (Status)) {
554 //
555 // Smbios protocol not found, get the default value.
556 //
557 NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_COMPUTER_MODEL), NULL);
558 UiCustomizeFrontPageBanner (1, TRUE, &NewString);
559 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_COMPUTER_MODEL), NewString, NULL);
560 FreePool (NewString);
561
562 NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_MODEL), NULL);
563 UiCustomizeFrontPageBanner (2, TRUE, &NewString);
564 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_MODEL), NewString, NULL);
565 FreePool (NewString);
566
567 NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_SPEED), NULL);
568 UiCustomizeFrontPageBanner (2, FALSE, &NewString);
569 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_SPEED), NewString, NULL);
570 FreePool (NewString);
571
572 NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_BIOS_VERSION), NULL);
573 UiCustomizeFrontPageBanner (3, TRUE, &NewString);
574 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_BIOS_VERSION), NewString, NULL);
575 FreePool (NewString);
576
577 NewString = HiiGetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_MEMORY_SIZE), NULL);
578 UiCustomizeFrontPageBanner (3, FALSE, &NewString);
579 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_MEMORY_SIZE), NewString, NULL);
580 FreePool (NewString);
581
582 return;
583 }
584
585 SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
586 Status = Smbios->GetNext (Smbios, &SmbiosHandle, NULL, &Record, NULL);
587 while (!EFI_ERROR (Status)) {
588 if (Record->Type == SMBIOS_TYPE_BIOS_INFORMATION) {
589 Type0Record = (SMBIOS_TABLE_TYPE0 *)Record;
590 StrIndex = Type0Record->BiosVersion;
591 GetOptionalStringByIndex ((CHAR8 *)((UINT8 *)Type0Record + Type0Record->Hdr.Length), StrIndex, &NewString);
592
593 FirmwareVersionString = (CHAR16 *)PcdGetPtr (PcdFirmwareVersionString);
594 if (*FirmwareVersionString != 0x0000 ) {
595 FreePool (NewString);
596 NewString = (CHAR16 *)PcdGetPtr (PcdFirmwareVersionString);
597 UiCustomizeFrontPageBanner (3, TRUE, &NewString);
598 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_BIOS_VERSION), NewString, NULL);
599 } else {
600 UiCustomizeFrontPageBanner (3, TRUE, &NewString);
601 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_BIOS_VERSION), NewString, NULL);
602 FreePool (NewString);
603 }
604 }
605
606 if (Record->Type == SMBIOS_TYPE_SYSTEM_INFORMATION) {
607 Type1Record = (SMBIOS_TABLE_TYPE1 *)Record;
608 StrIndex = Type1Record->ProductName;
609 GetOptionalStringByIndex ((CHAR8 *)((UINT8 *)Type1Record + Type1Record->Hdr.Length), StrIndex, &NewString);
610 UiCustomizeFrontPageBanner (1, TRUE, &NewString);
611 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_COMPUTER_MODEL), NewString, NULL);
612 FreePool (NewString);
613 }
614
615 if ((Record->Type == SMBIOS_TYPE_PROCESSOR_INFORMATION) && !FoundCpu) {
616 Type4Record = (SMBIOS_TABLE_TYPE4 *)Record;
617 //
618 // The information in the record should be only valid when the CPU Socket is populated.
619 //
620 if ((Type4Record->Status & SMBIOS_TYPE4_CPU_SOCKET_POPULATED) == SMBIOS_TYPE4_CPU_SOCKET_POPULATED) {
621 StrIndex = Type4Record->ProcessorVersion;
622 GetOptionalStringByIndex ((CHAR8 *)((UINT8 *)Type4Record + Type4Record->Hdr.Length), StrIndex, &NewString);
623 UiCustomizeFrontPageBanner (2, TRUE, &NewString);
624 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_MODEL), NewString, NULL);
625 FreePool (NewString);
626
627 ConvertProcessorToString (Type4Record->CurrentSpeed, 6, &NewString);
628 UiCustomizeFrontPageBanner (2, FALSE, &NewString);
629 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_CPU_SPEED), NewString, NULL);
630 FreePool (NewString);
631
632 FoundCpu = TRUE;
633 }
634 }
635
636 if ( Record->Type == SMBIOS_TYPE_MEMORY_ARRAY_MAPPED_ADDRESS ) {
637 Type19Record = (SMBIOS_TABLE_TYPE19 *)Record;
638 if (Type19Record->StartingAddress != 0xFFFFFFFF ) {
639 InstalledMemory += RShiftU64 (
640 Type19Record->EndingAddress -
641 Type19Record->StartingAddress + 1,
642 10
643 );
644 } else {
645 InstalledMemory += RShiftU64 (
646 Type19Record->ExtendedEndingAddress -
647 Type19Record->ExtendedStartingAddress + 1,
648 20
649 );
650 }
651 }
652
653 Status = Smbios->GetNext (Smbios, &SmbiosHandle, NULL, &Record, NULL);
654 }
655
656 //
657 // Now update the total installed RAM size
658 //
659 ConvertMemorySizeToString ((UINT32)InstalledMemory, &NewString);
660 UiCustomizeFrontPageBanner (3, FALSE, &NewString);
661 HiiSetString (gFrontPagePrivate.HiiHandle, STRING_TOKEN (STR_FRONT_PAGE_MEMORY_SIZE), NewString, NULL);
662 FreePool (NewString);
663}
664
665/**
666 This function will change video resolution and text mode
667 according to defined setup mode or defined boot mode
668
669 @param IsSetupMode Indicate mode is changed to setup mode or boot mode.
670
671 @retval EFI_SUCCESS Mode is changed successfully.
672 @retval Others Mode failed to be changed.
673
674**/
675EFI_STATUS
676UiSetConsoleMode (
677 BOOLEAN IsSetupMode
678 )
679{
680 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
681 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *SimpleTextOut;
682 UINTN SizeOfInfo;
683 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;
684 UINT32 MaxGopMode;
685 UINT32 MaxTextMode;
686 UINT32 ModeNumber;
687 UINT32 NewHorizontalResolution;
688 UINT32 NewVerticalResolution;
689 UINT32 NewColumns;
690 UINT32 NewRows;
691 UINTN HandleCount;
692 EFI_HANDLE *HandleBuffer;
693 EFI_STATUS Status;
694 UINTN Index;
695 UINTN CurrentColumn;
696 UINTN CurrentRow;
697
698 MaxGopMode = 0;
699 MaxTextMode = 0;
700
701 //
702 // Get current video resolution and text mode
703 //
704 Status = gBS->HandleProtocol (
705 gST->ConsoleOutHandle,
706 &gEfiGraphicsOutputProtocolGuid,
707 (VOID **)&GraphicsOutput
708 );
709 if (EFI_ERROR (Status)) {
710 GraphicsOutput = NULL;
711 }
712
713 Status = gBS->HandleProtocol (
714 gST->ConsoleOutHandle,
715 &gEfiSimpleTextOutProtocolGuid,
716 (VOID **)&SimpleTextOut
717 );
718 if (EFI_ERROR (Status)) {
719 SimpleTextOut = NULL;
720 }
721
722 if ((GraphicsOutput == NULL) || (SimpleTextOut == NULL)) {
723 return EFI_UNSUPPORTED;
724 }
725
726 if (IsSetupMode) {
727 //
728 // The required resolution and text mode is setup mode.
729 //
730 NewHorizontalResolution = mSetupHorizontalResolution;
731 NewVerticalResolution = mSetupVerticalResolution;
732 NewColumns = mSetupTextModeColumn;
733 NewRows = mSetupTextModeRow;
734 } else {
735 //
736 // The required resolution and text mode is boot mode.
737 //
738 NewHorizontalResolution = mBootHorizontalResolution;
739 NewVerticalResolution = mBootVerticalResolution;
740 NewColumns = mBootTextModeColumn;
741 NewRows = mBootTextModeRow;
742 }
743
744 if (GraphicsOutput != NULL) {
745 MaxGopMode = GraphicsOutput->Mode->MaxMode;
746 }
747
748 if (SimpleTextOut != NULL) {
749 MaxTextMode = SimpleTextOut->Mode->MaxMode;
750 }
751
752 //
753 // 1. If current video resolution is same with required video resolution,
754 // video resolution need not be changed.
755 // 1.1. If current text mode is same with required text mode, text mode need not be changed.
756 // 1.2. If current text mode is different from required text mode, text mode need be changed.
757 // 2. If current video resolution is different from required video resolution, we need restart whole console drivers.
758 //
759 for (ModeNumber = 0; ModeNumber < MaxGopMode; ModeNumber++) {
760 Status = GraphicsOutput->QueryMode (
761 GraphicsOutput,
762 ModeNumber,
763 &SizeOfInfo,
764 &Info
765 );
766 if (!EFI_ERROR (Status)) {
767 if ((Info->HorizontalResolution == NewHorizontalResolution) &&
768 (Info->VerticalResolution == NewVerticalResolution))
769 {
770 if ((GraphicsOutput->Mode->Info->HorizontalResolution == NewHorizontalResolution) &&
771 (GraphicsOutput->Mode->Info->VerticalResolution == NewVerticalResolution))
772 {
773 //
774 // Current resolution is same with required resolution, check if text mode need be set
775 //
776 Status = SimpleTextOut->QueryMode (SimpleTextOut, SimpleTextOut->Mode->Mode, &CurrentColumn, &CurrentRow);
777 ASSERT_EFI_ERROR (Status);
778 if ((CurrentColumn == NewColumns) && (CurrentRow == NewRows)) {
779 //
780 // If current text mode is same with required text mode. Do nothing
781 //
782 FreePool (Info);
783 return EFI_SUCCESS;
784 } else {
785 //
786 // If current text mode is different from required text mode. Set new video mode
787 //
788 for (Index = 0; Index < MaxTextMode; Index++) {
789 Status = SimpleTextOut->QueryMode (SimpleTextOut, Index, &CurrentColumn, &CurrentRow);
790 if (!EFI_ERROR (Status)) {
791 if ((CurrentColumn == NewColumns) && (CurrentRow == NewRows)) {
792 //
793 // Required text mode is supported, set it.
794 //
795 Status = SimpleTextOut->SetMode (SimpleTextOut, Index);
796 ASSERT_EFI_ERROR (Status);
797 //
798 // Update text mode PCD.
799 //
800 Status = PcdSet32S (PcdConOutColumn, mSetupTextModeColumn);
801 ASSERT_EFI_ERROR (Status);
802 Status = PcdSet32S (PcdConOutRow, mSetupTextModeRow);
803 ASSERT_EFI_ERROR (Status);
804 FreePool (Info);
805 return EFI_SUCCESS;
806 }
807 }
808 }
809
810 if (Index == MaxTextMode) {
811 //
812 // If required text mode is not supported, return error.
813 //
814 FreePool (Info);
815 return EFI_UNSUPPORTED;
816 }
817 }
818 } else {
819 //
820 // If current video resolution is not same with the new one, set new video resolution.
821 // In this case, the driver which produces simple text out need be restarted.
822 //
823 Status = GraphicsOutput->SetMode (GraphicsOutput, ModeNumber);
824 if (!EFI_ERROR (Status)) {
825 FreePool (Info);
826 break;
827 }
828 }
829 }
830
831 FreePool (Info);
832 }
833 }
834
835 if (ModeNumber == MaxGopMode) {
836 //
837 // If the resolution is not supported, return error.
838 //
839 return EFI_UNSUPPORTED;
840 }
841
842 //
843 // Set PCD to Inform GraphicsConsole to change video resolution.
844 // Set PCD to Inform Consplitter to change text mode.
845 //
846 Status = PcdSet32S (PcdVideoHorizontalResolution, NewHorizontalResolution);
847 ASSERT_EFI_ERROR (Status);
848 Status = PcdSet32S (PcdVideoVerticalResolution, NewVerticalResolution);
849 ASSERT_EFI_ERROR (Status);
850 Status = PcdSet32S (PcdConOutColumn, NewColumns);
851 ASSERT_EFI_ERROR (Status);
852 Status = PcdSet32S (PcdConOutRow, NewRows);
853 ASSERT_EFI_ERROR (Status);
854
855 //
856 // Video mode is changed, so restart graphics console driver and higher level driver.
857 // Reconnect graphics console driver and higher level driver.
858 // Locate all the handles with GOP protocol and reconnect it.
859 //
860 Status = gBS->LocateHandleBuffer (
861 ByProtocol,
862 &gEfiSimpleTextOutProtocolGuid,
863 NULL,
864 &HandleCount,
865 &HandleBuffer
866 );
867 if (!EFI_ERROR (Status)) {
868 for (Index = 0; Index < HandleCount; Index++) {
869 gBS->DisconnectController (HandleBuffer[Index], NULL, NULL);
870 }
871
872 for (Index = 0; Index < HandleCount; Index++) {
873 gBS->ConnectController (HandleBuffer[Index], NULL, NULL, TRUE);
874 }
875
876 if (HandleBuffer != NULL) {
877 FreePool (HandleBuffer);
878 }
879 }
880
881 return EFI_SUCCESS;
882}
883
884/**
885 The user Entry Point for Application. The user code starts with this function
886 as the real entry point for the image goes into a library that calls this
887 function.
888
889 @param[in] ImageHandle The firmware allocated handle for the EFI image.
890 @param[in] SystemTable A pointer to the EFI System Table.
891
892 @retval EFI_SUCCESS The entry point is executed successfully.
893 @retval other Some error occurs when executing this entry point.
894
895**/
896EFI_STATUS
897EFIAPI
898InitializeUserInterface (
899 IN EFI_HANDLE ImageHandle,
900 IN EFI_SYSTEM_TABLE *SystemTable
901 )
902{
903 EFI_HII_HANDLE HiiHandle;
904 EFI_STATUS Status;
905 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
906 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *SimpleTextOut;
907 UINTN BootTextColumn;
908 UINTN BootTextRow;
909
910 if (!mModeInitialized) {
911 //
912 // After the console is ready, get current video resolution
913 // and text mode before launching setup at first time.
914 //
915 Status = gBS->HandleProtocol (
916 gST->ConsoleOutHandle,
917 &gEfiGraphicsOutputProtocolGuid,
918 (VOID **)&GraphicsOutput
919 );
920 if (EFI_ERROR (Status)) {
921 GraphicsOutput = NULL;
922 }
923
924 Status = gBS->HandleProtocol (
925 gST->ConsoleOutHandle,
926 &gEfiSimpleTextOutProtocolGuid,
927 (VOID **)&SimpleTextOut
928 );
929 if (EFI_ERROR (Status)) {
930 SimpleTextOut = NULL;
931 }
932
933 if (GraphicsOutput != NULL) {
934 //
935 // Get current video resolution and text mode.
936 //
937 mBootHorizontalResolution = GraphicsOutput->Mode->Info->HorizontalResolution;
938 mBootVerticalResolution = GraphicsOutput->Mode->Info->VerticalResolution;
939 }
940
941 if (SimpleTextOut != NULL) {
942 Status = SimpleTextOut->QueryMode (
943 SimpleTextOut,
944 SimpleTextOut->Mode->Mode,
945 &BootTextColumn,
946 &BootTextRow
947 );
948 mBootTextModeColumn = (UINT32)BootTextColumn;
949 mBootTextModeRow = (UINT32)BootTextRow;
950 }
951
952 //
953 // Get user defined text mode for setup.
954 //
955 mSetupHorizontalResolution = PcdGet32 (PcdSetupVideoHorizontalResolution);
956 mSetupVerticalResolution = PcdGet32 (PcdSetupVideoVerticalResolution);
957 mSetupTextModeColumn = PcdGet32 (PcdSetupConOutColumn);
958 mSetupTextModeRow = PcdGet32 (PcdSetupConOutRow);
959
960 mModeInitialized = TRUE;
961 }
962
963 gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
964 gST->ConOut->ClearScreen (gST->ConOut);
965
966 //
967 // Install customized fonts needed by Front Page
968 //
969 HiiHandle = ExportFonts ();
970 ASSERT (HiiHandle != NULL);
971
972 InitializeStringSupport ();
973
974 UiSetConsoleMode (TRUE);
975 UiEntry (FALSE);
976 UiSetConsoleMode (FALSE);
977
978 UninitializeStringSupport ();
979 HiiRemovePackages (HiiHandle);
980
981 return EFI_SUCCESS;
982}
983
984/**
985 This function is the main entry of the UI entry.
986 The function will present the main menu of the system UI.
987
988 @param ConnectAllHappened Caller passes the value to UI to avoid unnecessary connect-all.
989
990**/
991VOID
992EFIAPI
993UiEntry (
994 IN BOOLEAN ConnectAllHappened
995 )
996{
997 EFI_STATUS Status;
998 EFI_BOOT_LOGO_PROTOCOL *BootLogo;
999
1000 //
1001 // Enter Setup page.
1002 //
1003 REPORT_STATUS_CODE (
1004 EFI_PROGRESS_CODE,
1005 (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_PC_USER_SETUP)
1006 );
1007
1008 //
1009 // Indicate if the connect all has been performed before.
1010 // If has not been performed before, do here.
1011 //
1012 if (!ConnectAllHappened) {
1013 EfiBootManagerConnectAll ();
1014 }
1015
1016 //
1017 // The boot option enumeration time is acceptable in Ui driver
1018 //
1019 EfiBootManagerRefreshAllBootOption ();
1020
1021 //
1022 // Boot Logo is corrupted, report it using Boot Logo protocol.
1023 //
1024 Status = gBS->LocateProtocol (&gEfiBootLogoProtocolGuid, NULL, (VOID **)&BootLogo);
1025 if (!EFI_ERROR (Status) && (BootLogo != NULL)) {
1026 BootLogo->SetBootLogo (BootLogo, NULL, 0, 0, 0, 0);
1027 }
1028
1029 InitializeFrontPage ();
1030
1031 CallFrontPage ();
1032
1033 FreeFrontPage ();
1034
1035 if (mLanguageString != NULL) {
1036 FreePool (mLanguageString);
1037 mLanguageString = NULL;
1038 }
1039
1040 //
1041 // Will leave browser, check any reset required change is applied? if yes, reset system
1042 //
1043 SetupResetReminder ();
1044}
1045
1046//
1047// Following are BDS Lib functions which contain all the code about setup browser reset reminder feature.
1048// Setup Browser reset reminder feature is that an reset reminder will be given before user leaves the setup browser if
1049// user change any option setting which needs a reset to be effective, and the reset will be applied according to the user selection.
1050//
1051
1052/**
1053 Record the info that a reset is required.
1054 A module boolean variable is used to record whether a reset is required.
1055
1056**/
1057VOID
1058EFIAPI
1059EnableResetRequired (
1060 VOID
1061 )
1062{
1063 mResetRequired = TRUE;
1064}
1065
1066/**
1067 Check if user changed any option setting which needs a system reset to be effective.
1068
1069**/
1070BOOLEAN
1071EFIAPI
1072IsResetRequired (
1073 VOID
1074 )
1075{
1076 return mResetRequired;
1077}
1078
1079/**
1080 Check whether a reset is needed, and finish the reset reminder feature.
1081 If a reset is needed, Popup a menu to notice user, and finish the feature
1082 according to the user selection.
1083
1084**/
1085VOID
1086EFIAPI
1087SetupResetReminder (
1088 VOID
1089 )
1090{
1091 EFI_INPUT_KEY Key;
1092 CHAR16 *StringBuffer1;
1093 CHAR16 *StringBuffer2;
1094
1095 //
1096 // check any reset required change is applied? if yes, reset system
1097 //
1098 if (IsResetRequired ()) {
1099 StringBuffer1 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
1100 ASSERT (StringBuffer1 != NULL);
1101 StringBuffer2 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
1102 ASSERT (StringBuffer2 != NULL);
1103 StrCpyS (StringBuffer1, MAX_STRING_LEN, L"Configuration changed. Reset to apply it Now.");
1104 StrCpyS (StringBuffer2, MAX_STRING_LEN, L"Press ENTER to reset");
1105 //
1106 // Popup a menu to notice user
1107 //
1108 do {
1109 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, NULL);
1110 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
1111
1112 FreePool (StringBuffer1);
1113 FreePool (StringBuffer2);
1114
1115 gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
1116 }
1117}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette