EdkUnixPkg/Dxe/PlatformBds/Generic/FrontPage.c

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