93b27c5ed42574c533ac9844fd8cb2c2ce167b4e
[mirror_edk2.git] / Nt32Pkg / PlatformBdsDxe / Generic / FrontPage.c
1 /*++
2
3 Copyright (c) 2006 - 2007, 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 FrontPage.c
15
16 Abstract:
17
18 FrontPage routines to handle the callbacks and browser calls
19
20 --*/
21 #include "Bds.h"
22 #include "BdsPlatform.h"
23 #include "FrontPage.h"
24 #include "BdsString.h"
25
26 EFI_GUID mProcessorSubClass = EFI_PROCESSOR_SUBCLASS_GUID;
27 EFI_GUID mMemorySubClass = EFI_MEMORY_SUBCLASS_GUID;
28 EFI_GUID mMiscSubClass = EFI_MISC_SUBCLASS_GUID;
29
30 UINT16 mLastSelection;
31 EFI_HII_HANDLE gFrontPageHandle;
32 EFI_HANDLE FrontPageCallbackHandle;
33 EFI_FORM_CALLBACK_PROTOCOL FrontPageCallback;
34 EFI_FORM_BROWSER_PROTOCOL *gBrowser;
35 UINTN gCallbackKey;
36 BOOLEAN gConnectAllHappened = FALSE;
37
38 extern EFI_HII_HANDLE gFrontPageHandle;
39
40 EFI_STATUS
41 EFIAPI
42 FrontPageCallbackRoutine (
43 IN EFI_FORM_CALLBACK_PROTOCOL *This,
44 IN UINT16 KeyValue,
45 IN EFI_IFR_DATA_ARRAY *DataArray,
46 OUT EFI_HII_CALLBACK_PACKET **Packet
47 )
48 /*++
49
50 Routine Description:
51
52 This is the function that is called to provide results data to the driver. This data
53 consists of a unique key which is used to identify what data is either being passed back
54 or being asked for.
55
56 Arguments:
57
58 KeyValue - A unique value which is sent to the original exporting driver so that it
59 can identify the type of data to expect. The format of the data tends to
60 vary based on the op-code that geerated the callback.
61
62 Data - A pointer to the data being sent to the original exporting driver.
63
64 Returns:
65
66 --*/
67 {
68 CHAR16 *LanguageString;
69 UINTN Count;
70 CHAR16 UnicodeLang[3];
71 CHAR8 Lang[3];
72 EFI_STATUS Status;
73 UINTN Index;
74 CHAR16 *TmpStr;
75 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground;
76 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background;
77 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Color;
78
79 SetMem (&Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
80 SetMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
81 SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
82
83 Count = 0;
84
85 //
86 // The first 4 entries in the Front Page are to be GUARANTEED to remain constant so IHV's can
87 // describe to their customers in documentation how to find their setup information (namely
88 // under the device manager and specific buckets)
89 //
90 switch (KeyValue) {
91 case 0x0001:
92 //
93 // This is the continue - clear the screen and return an error to get out of FrontPage loop
94 //
95 gCallbackKey = 1;
96 break;
97
98 case 0x1234:
99 //
100 // Collect the languages from what our current Language support is based on our VFR
101 //
102 gHii->GetPrimaryLanguages (gHii, gFrontPageHandle, &LanguageString);
103
104 //
105 // Based on the DataArray->Data->Data value, we can determine
106 // which language was chosen by the user
107 //
108 for (Index = 0; Count != (UINTN) (((EFI_IFR_DATA_ENTRY *) (DataArray + 1))->Data); Index += 3) {
109 Count++;
110 }
111 //
112 // Preserve the choice the user made
113 //
114 mLastSelection = (UINT16) Count;
115
116 //
117 // The Language (in Unicode format) the user chose
118 //
119 CopyMem (UnicodeLang, &LanguageString[Index], 6);
120
121 //
122 // Convert Unicode to ASCII (Since the ISO standard assumes ASCII equivalent abbreviations
123 // we can be safe in converting this Unicode stream to ASCII without any loss in meaning.
124 //
125 for (Index = 0; Index < 3; Index++) {
126 Lang[Index] = (CHAR8) UnicodeLang[Index];
127 }
128
129 Status = gRT->SetVariable (
130 L"Lang",
131 &gEfiGlobalVariableGuid,
132 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
133 3,
134 Lang
135 );
136
137 FreePool (LanguageString);
138 gCallbackKey = 2;
139 break;
140
141 case 0x1064:
142 //
143 // Boot Manager
144 //
145 gCallbackKey = 3;
146 break;
147
148 case 0x8567:
149 //
150 // Device Manager
151 //
152 gCallbackKey = 4;
153 break;
154
155 case 0x9876:
156 //
157 // Boot Maintenance Manager
158 //
159 gCallbackKey = 5;
160 break;
161
162 case 0xFFFE:
163
164 break;
165
166 case 0xFFFF:
167 //
168 // FrontPage TimeOut Callback
169 //
170 TmpStr = GetStringById (STRING_TOKEN (STR_START_BOOT_OPTION));
171 if (TmpStr != NULL) {
172 PlatformBdsShowProgress (
173 Foreground,
174 Background,
175 TmpStr,
176 Color,
177 (UINTN) (((EFI_IFR_DATA_ENTRY *) (DataArray+1))->Data),
178 0
179 );
180 FreePool (TmpStr);
181 }
182 break;
183
184 default:
185 gCallbackKey = 0;
186 break;
187 }
188
189 return EFI_SUCCESS;
190 }
191
192 EFI_STATUS
193 InitializeFrontPage (
194 BOOLEAN ReInitializeStrings
195 )
196 /*++
197
198 Routine Description:
199
200 Initialize HII information for the FrontPage
201
202 Arguments:
203 None
204
205 Returns:
206 EFI_SUCCESS - The operation is successful.
207 EFI_DEVICE_ERROR - If the dynamic opcode creation failed.
208
209 --*/
210 {
211 EFI_STATUS Status;
212 EFI_HII_PACKAGES *PackageList;
213 EFI_HII_UPDATE_DATA *UpdateData;
214 IFR_OPTION *OptionList;
215 CHAR16 *LanguageString;
216 UINTN OptionCount;
217 UINTN Index;
218 STRING_REF Token;
219 UINT16 Key;
220 CHAR8 AsciiLang[4];
221 CHAR16 UnicodeLang[4];
222 CHAR16 Lang[4];
223 CHAR16 *StringBuffer;
224 UINTN BufferSize;
225 UINT8 *TempBuffer;
226
227 UpdateData = NULL;
228 OptionList = NULL;
229
230 if (ReInitializeStrings) {
231 //
232 // BugBug: Dont' use a goto
233 //
234 goto ReInitStrings;
235 }
236 //
237 // Go ahead and initialize the Device Manager
238 //
239 InitializeDeviceManager ();
240
241 //
242 // BugBug: if FrontPageVfrBin is generated by a tool, why are we patching it here
243 //
244 TempBuffer = (UINT8 *) FrontPageVfrBin;
245 TempBuffer = TempBuffer + sizeof (EFI_HII_PACK_HEADER);
246 TempBuffer = (UINT8 *) &((EFI_IFR_FORM_SET *) TempBuffer)->NvDataSize;
247 *TempBuffer = 1;
248
249 gCallbackKey = 0;
250
251 PackageList = PreparePackages (1, &gEfiCallerIdGuid, FrontPageVfrBin);
252
253 Status = gHii->NewPack (gHii, PackageList, &gFrontPageHandle);
254
255 FreePool (PackageList);
256
257 //
258 // There will be only one FormConfig in the system
259 // If there is another out there, someone is trying to install us
260 // again. Fail that scenario.
261 //
262 Status = gBS->LocateProtocol (
263 &gEfiFormBrowserProtocolGuid,
264 NULL,
265 &gBrowser
266 );
267
268 //
269 // This example does not implement worker functions
270 // for the NV accessor functions. Only a callback evaluator
271 //
272 FrontPageCallback.NvRead = NULL;
273 FrontPageCallback.NvWrite = NULL;
274 FrontPageCallback.Callback = FrontPageCallbackRoutine;
275
276 //
277 // Install protocol interface
278 //
279 FrontPageCallbackHandle = NULL;
280 Status = gBS->InstallProtocolInterface (
281 &FrontPageCallbackHandle,
282 &gEfiFormCallbackProtocolGuid,
283 EFI_NATIVE_INTERFACE,
284 &FrontPageCallback
285 );
286 ASSERT_EFI_ERROR (Status);
287
288 ReInitStrings:
289 //
290 // BugBug: This logic is in BdsInitLanguage. It should not be in two places!
291 //
292 BufferSize = 4;
293 Status = gRT->GetVariable (
294 L"Lang",
295 &gEfiGlobalVariableGuid,
296 NULL,
297 &BufferSize,
298 AsciiLang
299 );
300
301 for (Index = 0; Index < 3; Index++) {
302 UnicodeLang[Index] = (CHAR16) AsciiLang[Index];
303 }
304
305 UnicodeLang[3] = 0;
306
307 //
308 // Allocate space for creation of UpdateData Buffer
309 //
310 UpdateData = AllocateZeroPool (0x1000);
311 ASSERT (UpdateData != NULL);
312
313 OptionList = AllocateZeroPool (0x1000);
314 ASSERT (OptionList != NULL);
315
316 //
317 // Flag update pending in FormSet
318 //
319 UpdateData->FormSetUpdate = TRUE;
320 //
321 // Register CallbackHandle data for FormSet
322 //
323 UpdateData->FormCallbackHandle = (EFI_PHYSICAL_ADDRESS) (UINTN) FrontPageCallbackHandle;
324 UpdateData->FormUpdate = FALSE;
325 UpdateData->FormTitle = 0;
326 UpdateData->DataCount = 1;
327
328 //
329 // Collect the languages from what our current Language support is based on our VFR
330 //
331 gHii->GetPrimaryLanguages (gHii, gFrontPageHandle, &LanguageString);
332
333 OptionCount = 0;
334
335 //
336 // Try for a 512 byte Buffer
337 //
338 BufferSize = 0x200;
339
340 //
341 // Allocate memory for our Form binary
342 //
343 StringBuffer = AllocateZeroPool (BufferSize);
344 ASSERT (StringBuffer != NULL);
345
346 for (Index = 0; LanguageString[Index] != 0; Index += 3) {
347 Token = 0;
348 CopyMem (Lang, &LanguageString[Index], 6);
349 Lang[3] = 0;
350
351 if (!StrCmp (Lang, UnicodeLang)) {
352 mLastSelection = (UINT16) OptionCount;
353 }
354
355 Status = gHii->GetString (gHii, gStringPackHandle, 1, TRUE, Lang, &BufferSize, StringBuffer);
356 gHii->NewString (gHii, NULL, gStringPackHandle, &Token, StringBuffer);
357 CopyMem (&OptionList[OptionCount].StringToken, &Token, sizeof (UINT16));
358 CopyMem (&OptionList[OptionCount].Value, &OptionCount, sizeof (UINT16));
359 Key = 0x1234;
360 CopyMem (&OptionList[OptionCount].Key, &Key, sizeof (UINT16));
361 OptionList[OptionCount].Flags = EFI_IFR_FLAG_INTERACTIVE | EFI_IFR_FLAG_NV_ACCESS;
362 OptionCount++;
363 }
364
365 FreePool (LanguageString);
366
367 if (ReInitializeStrings) {
368 FreePool (StringBuffer);
369 FreePool (OptionList);
370 return EFI_SUCCESS;
371 }
372
373 Status = CreateOneOfOpCode (
374 FRONT_PAGE_QUESTION_ID, // Question ID
375 FRONT_PAGE_DATA_WIDTH, // Data Width
376 (STRING_REF) STRING_TOKEN (STR_LANGUAGE_SELECT), // Prompt Token
377 (STRING_REF) STRING_TOKEN (STR_LANGUAGE_SELECT_HELP), // Help Token
378 OptionList, // List of Options
379 OptionCount, // Number of Options
380 &UpdateData->Data // Data Buffer
381 );
382
383 //
384 // Assign the number of options and the oneof and endoneof op-codes to count
385 //
386 UpdateData->DataCount = (UINT8) (OptionCount + 2);
387
388 gHii->UpdateForm (gHii, gFrontPageHandle, (EFI_FORM_LABEL) 0x0002, TRUE, UpdateData);
389
390 FreePool (UpdateData);
391 //
392 // FreePool (OptionList);
393 //
394 FreePool (StringBuffer);
395 return Status;
396 }
397
398 EFI_STATUS
399 CallFrontPage (
400 VOID
401 )
402 /*++
403
404 Routine Description:
405
406 Call the browser and display the front page
407
408 Arguments:
409
410 None
411
412 Returns:
413
414 --*/
415 {
416 EFI_STATUS Status;
417 UINT8 FakeNvRamMap[1];
418 BOOLEAN FrontPageMenuResetRequired;
419
420 //
421 // Begin waiting for USER INPUT
422 //
423 REPORT_STATUS_CODE (
424 EFI_PROGRESS_CODE,
425 (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_PC_INPUT_WAIT)
426 );
427
428 FakeNvRamMap[0] = (UINT8) mLastSelection;
429 FrontPageMenuResetRequired = FALSE;
430 Status = gBrowser->SendForm (
431 gBrowser,
432 TRUE, // Use the database
433 &gFrontPageHandle, // The HII Handle
434 1,
435 NULL,
436 FrontPageCallbackHandle, // This is the handle that the interface to the callback was installed on
437 FakeNvRamMap,
438 NULL,
439 &FrontPageMenuResetRequired
440 );
441 //
442 // Check whether user change any option setting which needs a reset to be effective
443 //
444 if (FrontPageMenuResetRequired) {
445 EnableResetRequired ();
446 }
447
448 gHii->ResetStrings (gHii, gFrontPageHandle);
449
450 return Status;
451 }
452
453 EFI_STATUS
454 GetStringFromToken (
455 IN EFI_GUID *ProducerGuid,
456 IN STRING_REF Token,
457 OUT CHAR16 **String
458 )
459 /*++
460
461 Routine Description:
462
463 Acquire the string associated with the ProducerGuid and return it.
464
465 Arguments:
466
467 ProducerGuid - The Guid to search the HII database for
468 Token - The token value of the string to extract
469 String - The string that is extracted
470
471 Returns:
472
473 EFI_SUCCESS - The function returns EFI_SUCCESS always.
474
475 --*/
476 {
477 EFI_STATUS Status;
478 UINT16 HandleBufferLength;
479 EFI_HII_HANDLE *HiiHandleBuffer;
480 UINTN StringBufferLength;
481 UINTN NumberOfHiiHandles;
482 UINTN Index;
483 UINT16 Length;
484 EFI_GUID HiiGuid;
485
486 //
487 // Initialize params.
488 //
489 HandleBufferLength = 0;
490 HiiHandleBuffer = NULL;
491
492 //
493 // Get all the Hii handles
494 //
495 Status = BdsLibGetHiiHandles (gHii, &HandleBufferLength, &HiiHandleBuffer);
496 ASSERT_EFI_ERROR (Status);
497
498 //
499 // Get the gHii Handle that matches the StructureNode->ProducerName
500 //
501 NumberOfHiiHandles = HandleBufferLength / sizeof (EFI_HII_HANDLE);
502 for (Index = 0; Index < NumberOfHiiHandles; Index++) {
503 Length = 0;
504 Status = ExtractDataFromHiiHandle (
505 HiiHandleBuffer[Index],
506 &Length,
507 NULL,
508 &HiiGuid
509 );
510 if (CompareGuid (ProducerGuid, &HiiGuid)) {
511 break;
512 }
513 }
514 //
515 // Find the string based on the current language
516 //
517 StringBufferLength = 0x100;
518 *String = AllocateZeroPool (0x100);
519 Status = gHii->GetString (
520 gHii,
521 HiiHandleBuffer[Index],
522 Token,
523 FALSE,
524 NULL,
525 &StringBufferLength,
526 *String
527 );
528
529 if (EFI_ERROR (Status)) {
530 FreePool (*String);
531 *String = GetStringById (STRING_TOKEN (STR_MISSING_STRING));
532 }
533
534 FreePool (HiiHandleBuffer);
535 return EFI_SUCCESS;
536 }
537
538 VOID
539 ConvertProcessorToString (
540 IN EFI_PROCESSOR_CORE_FREQUENCY_DATA *ProcessorFrequency,
541 OUT CHAR16 **String
542 )
543 /*++
544
545 Routine Description:
546
547 Convert Processor Frequency Data to a string
548
549 Arguments:
550
551 ProcessorFrequency - The frequency data to process
552 String - The string that is created
553
554 Returns:
555
556 --*/
557 {
558 CHAR16 *StringBuffer;
559 UINTN Index;
560 UINT32 FreqMhz;
561
562 if (ProcessorFrequency->Exponent >= 6) {
563 FreqMhz = ProcessorFrequency->Value;
564 for (Index = 0; Index < (UINTN) (ProcessorFrequency->Exponent - 6); Index++) {
565 FreqMhz *= 10;
566 }
567 } else {
568 FreqMhz = 0;
569 }
570
571 StringBuffer = AllocateZeroPool (0x20);
572 ASSERT (StringBuffer != NULL);
573 Index = UnicodeValueToString (StringBuffer, LEFT_JUSTIFY, FreqMhz / 1000, 3);
574 StrCat (StringBuffer, L".");
575 UnicodeValueToString (StringBuffer + Index + 1, PREFIX_ZERO, (FreqMhz % 1000) / 10, 2);
576 StrCat (StringBuffer, L" GHz");
577
578 *String = (CHAR16 *) StringBuffer;
579
580 return ;
581 }
582
583 VOID
584 ConvertMemorySizeToString (
585 IN UINT32 MemorySize,
586 OUT CHAR16 **String
587 )
588 /*++
589
590 Routine Description:
591
592 Convert Memory Size to a string
593
594 Arguments:
595
596 MemorySize - The size of the memory to process
597 String - The string that is created
598
599 Returns:
600
601 --*/
602 {
603 CHAR16 *StringBuffer;
604
605 StringBuffer = AllocateZeroPool (0x20);
606 ASSERT (StringBuffer != NULL);
607 UnicodeValueToString (StringBuffer, LEFT_JUSTIFY, MemorySize, 6);
608 StrCat (StringBuffer, L" MB RAM");
609
610 *String = (CHAR16 *) StringBuffer;
611
612 return ;
613 }
614
615 VOID
616 UpdateFrontPageStrings (
617 VOID
618 )
619 /*++
620
621 Routine Description:
622
623 Update the banner information for the Front Page based on DataHub information
624
625 Arguments:
626
627 None
628
629 Returns:
630
631 --*/
632 {
633 EFI_STATUS Status;
634 STRING_REF TokenToUpdate;
635 CHAR16 *NewString;
636 UINT64 MonotonicCount;
637 EFI_DATA_HUB_PROTOCOL *DataHub;
638 EFI_DATA_RECORD_HEADER *Record;
639 EFI_SUBCLASS_TYPE1_HEADER *DataHeader;
640 EFI_MISC_BIOS_VENDOR_DATA *BiosVendor;
641 EFI_MISC_SYSTEM_MANUFACTURER_DATA *SystemManufacturer;
642 EFI_PROCESSOR_VERSION_DATA *ProcessorVersion;
643 EFI_PROCESSOR_CORE_FREQUENCY_DATA *ProcessorFrequency;
644 EFI_MEMORY_ARRAY_START_ADDRESS_DATA *MemoryArray;
645 CHAR8 LangCode[3];
646 CHAR16 Lang[3];
647 UINTN Size;
648 UINTN Index;
649 BOOLEAN Find[5];
650
651 ZeroMem (Find, sizeof (Find));
652
653 //
654 // Update Front Page strings
655 //
656 Status = gBS->LocateProtocol (
657 &gEfiDataHubProtocolGuid,
658 NULL,
659 &DataHub
660 );
661 ASSERT_EFI_ERROR (Status);
662
663 Size = 3;
664
665 Status = gRT->GetVariable (
666 L"Lang",
667 &gEfiGlobalVariableGuid,
668 NULL,
669 &Size,
670 LangCode
671 );
672
673 for (Index = 0; Index < 3; Index++) {
674 Lang[Index] = (CHAR16) LangCode[Index];
675 }
676
677 MonotonicCount = 0;
678 Record = NULL;
679 do {
680 Status = DataHub->GetNextRecord (DataHub, &MonotonicCount, NULL, &Record);
681 if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA) {
682 DataHeader = (EFI_SUBCLASS_TYPE1_HEADER *) (Record + 1);
683 if (CompareGuid (&Record->DataRecordGuid, &mMiscSubClass) &&
684 (DataHeader->RecordType == EFI_MISC_BIOS_VENDOR_RECORD_NUMBER)
685 ) {
686 BiosVendor = (EFI_MISC_BIOS_VENDOR_DATA *) (DataHeader + 1);
687 GetStringFromToken (&Record->ProducerName, BiosVendor->BiosVersion, &NewString);
688 TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_BIOS_VERSION;
689 gHii->NewString (gHii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
690 FreePool (NewString);
691 Find[0] = TRUE;
692 }
693
694 if (CompareGuid (&Record->DataRecordGuid, &mMiscSubClass) &&
695 (DataHeader->RecordType == EFI_MISC_SYSTEM_MANUFACTURER_RECORD_NUMBER)
696 ) {
697 SystemManufacturer = (EFI_MISC_SYSTEM_MANUFACTURER_DATA *) (DataHeader + 1);
698 GetStringFromToken (&Record->ProducerName, SystemManufacturer->SystemProductName, &NewString);
699 TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_COMPUTER_MODEL;
700 gHii->NewString (gHii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
701 FreePool (NewString);
702 Find[1] = TRUE;
703 }
704
705 if (CompareGuid (&Record->DataRecordGuid, &mProcessorSubClass) &&
706 (DataHeader->RecordType == ProcessorVersionRecordType)
707 ) {
708 ProcessorVersion = (EFI_PROCESSOR_VERSION_DATA *) (DataHeader + 1);
709 GetStringFromToken (&Record->ProducerName, *ProcessorVersion, &NewString);
710 TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_CPU_MODEL;
711 gHii->NewString (gHii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
712 FreePool (NewString);
713 Find[2] = TRUE;
714 }
715
716 if (CompareGuid (&Record->DataRecordGuid, &mProcessorSubClass) &&
717 (DataHeader->RecordType == ProcessorCoreFrequencyRecordType)
718 ) {
719 ProcessorFrequency = (EFI_PROCESSOR_CORE_FREQUENCY_DATA *) (DataHeader + 1);
720 ConvertProcessorToString (ProcessorFrequency, &NewString);
721 TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_CPU_SPEED;
722 gHii->NewString (gHii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
723 FreePool (NewString);
724 Find[3] = TRUE;
725 }
726
727 if (CompareGuid (&Record->DataRecordGuid, &mMemorySubClass) &&
728 (DataHeader->RecordType == EFI_MEMORY_ARRAY_START_ADDRESS_RECORD_NUMBER)
729 ) {
730 MemoryArray = (EFI_MEMORY_ARRAY_START_ADDRESS_DATA *) (DataHeader + 1);
731 ConvertMemorySizeToString((UINT32)(RShiftU64((MemoryArray->MemoryArrayEndAddress -
732 MemoryArray->MemoryArrayStartAddress + 1), 20)),
733 &NewString);
734 TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_MEMORY_SIZE;
735 gHii->NewString (gHii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
736 FreePool (NewString);
737 Find[4] = TRUE;
738 }
739 }
740 } while (!EFI_ERROR (Status) && (MonotonicCount != 0) && !(Find[0] && Find[1] && Find[2] && Find[3] && Find[4]));
741
742 return ;
743 }
744
745 VOID
746 PlatformBdsEnterFrontPage (
747 IN UINT16 TimeoutDefault,
748 IN BOOLEAN ConnectAllHappened
749 )
750 /*++
751
752 Routine Description:
753 This function is the main entry of the platform setup entry.
754 The function will present the main menu of the system setup,
755 this is the platform reference part and can be customize.
756
757 Arguments:
758 TimeoutDefault - The fault time out value before the system
759 continue to boot.
760 ConnectAllHappened - The indicater to check if the connect all have
761 already happended.
762
763 Returns:
764 None
765
766 --*/
767 {
768 EFI_STATUS Status;
769 EFI_HII_UPDATE_DATA *UpdateData;
770 EFI_CONSOLE_CONTROL_PROTOCOL *ConsoleControl;
771
772 //
773 // Indicate if we need connect all in the platform setup
774 //
775 if (ConnectAllHappened) {
776 gConnectAllHappened = TRUE;
777 }
778 //
779 // Allocate space for creation of Buffer
780 //
781 UpdateData = AllocateZeroPool (0x1000);
782 ASSERT (UpdateData != NULL);
783
784 UpdateData->FormSetUpdate = FALSE;
785 UpdateData->FormCallbackHandle = 0;
786 UpdateData->FormUpdate = FALSE;
787 UpdateData->FormTitle = 0;
788 UpdateData->DataCount = 1;
789
790 //
791 // Remove Banner Op-code if any at this label
792 //
793 gHii->UpdateForm (gHii, gFrontPageHandle, (EFI_FORM_LABEL) 0xFFFF, FALSE, UpdateData);
794
795 //
796 // Create Banner Op-code which reflects correct timeout value
797 //
798 CreateBannerOpCode (
799 STRING_TOKEN (STR_TIME_OUT_PROMPT),
800 TimeoutDefault,
801 (UINT8) EFI_IFR_BANNER_TIMEOUT,
802 &UpdateData->Data
803 );
804
805 //
806 // Add Banner Op-code at this label
807 //
808 gHii->UpdateForm (gHii, gFrontPageHandle, (EFI_FORM_LABEL) 0xFFFF, TRUE, UpdateData);
809
810 do {
811
812 InitializeFrontPage (TRUE);
813
814 //
815 // Update Front Page strings
816 //
817 UpdateFrontPageStrings ();
818
819 gCallbackKey = 0;
820 PERF_START (0, "BdsTimeOut", "BDS", 0);
821 Status = CallFrontPage ();
822 PERF_END (0, "BdsTimeOut", "BDS", 0);
823
824 //
825 // If gCallbackKey is greater than 1 and less or equal to 5,
826 // it will lauch configuration utilities.
827 // 2 = set language
828 // 3 = boot manager
829 // 4 = device manager
830 // 5 = boot maintainenance manager
831 //
832 if ((gCallbackKey > 0x0001) && (gCallbackKey <= 0x0005)) {
833 REPORT_STATUS_CODE (
834 EFI_PROGRESS_CODE,
835 (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_PC_USER_SETUP)
836 );
837 }
838 //
839 // Based on the key that was set, we can determine what to do
840 //
841 switch (gCallbackKey) {
842 //
843 // The first 4 entries in the Front Page are to be GUARANTEED to remain constant so IHV's can
844 // describe to their customers in documentation how to find their setup information (namely
845 // under the device manager and specific buckets)
846 //
847 // These entries consist of the Continue, Select language, Boot Manager, and Device Manager
848 //
849 case 0x0001:
850 //
851 // User hit continue
852 //
853 break;
854
855 case 0x0002:
856 //
857 // User made a language setting change - display front page again
858 //
859 break;
860
861 case 0x0003:
862 //
863 // User chose to run the Boot Manager
864 //
865 CallBootManager ();
866 break;
867
868 case 0x0004:
869 //
870 // Display the Device Manager
871 //
872 do {
873 CallDeviceManager();
874 } while (gCallbackKey == 4);
875 break;
876
877 case 0x0005:
878 //
879 // Display the Boot Maintenance Manager
880 //
881 BdsStartBootMaint ();
882 break;
883 }
884
885 } while ((Status == EFI_SUCCESS) && (gCallbackKey != 1));
886
887 //
888 //Will leave browser, check any reset required change is applied? if yes, reset system
889 //
890 SetupResetReminder ();
891
892 //
893 // Automatically load current entry
894 // Note: The following lines of code only execute when Auto boot
895 // takes affect
896 //
897 Status = gBS->LocateProtocol (&gEfiConsoleControlProtocolGuid, NULL, &ConsoleControl);
898 ConsoleControl->SetMode (ConsoleControl, EfiConsoleControlScreenText);
899
900 }