EdkNt32Pkg/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_UGA_PIXEL Foreground;
  78   EFI_UGA_PIXEL Background;
  79   EFI_UGA_PIXEL Color;
  80
  81   SetMem (&Foreground, sizeof (EFI_UGA_PIXEL), 0xff);
  82   SetMem (&Background, sizeof (EFI_UGA_PIXEL), 0x0);
  83   SetMem (&Color, sizeof (EFI_UGA_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
 421   //
 422   // Begin waiting for USER INPUT
 423   //
 424   REPORT_STATUS_CODE (
 425         EFI_PROGRESS_CODE,
 426         (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_PC_INPUT_WAIT)
 427         );
 428
 429   FakeNvRamMap[0] = (UINT8) mLastSelection;
 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                       NULL
 440                       );
 441
 442   Hii->ResetStrings (Hii, gFrontPageHandle);
 443
 444   return Status;
 445 }
 446
 447 EFI_STATUS
 448 GetStringFromToken (
 449   IN      EFI_GUID                  *ProducerGuid,
 450   IN      STRING_REF                Token,
 451   OUT     CHAR16                    **String
 452   )
 453 /*++
 454
 455 Routine Description:
 456
 457   Acquire the string associated with the ProducerGuid and return it.
 458
 459 Arguments:
 460
 461   ProducerGuid - The Guid to search the HII database for
 462   Token - The token value of the string to extract
 463   String - The string that is extracted
 464
 465 Returns:
 466
 467   EFI_SUCCESS - The function returns EFI_SUCCESS always.
 468
 469 --*/
 470 {
 471   EFI_STATUS      Status;
 472   UINT16          HandleBufferLength;
 473   EFI_HII_HANDLE  *HiiHandleBuffer;
 474   UINTN           StringBufferLength;
 475   UINTN           NumberOfHiiHandles;
 476   UINTN           Index;
 477   UINT16          Length;
 478   EFI_GUID        HiiGuid;
 479
 480   HandleBufferLength  = 0x1000;
 481   HiiHandleBuffer     = NULL;
 482
 483   //
 484   // Get all the Hii handles
 485   //
 486   HiiHandleBuffer = AllocateZeroPool (HandleBufferLength);
 487
 488   Status          = Hii->FindHandles (Hii, &HandleBufferLength, HiiHandleBuffer);
 489   ASSERT_EFI_ERROR (Status);
 490
 491   //
 492   // Get the Hii Handle that matches the StructureNode->ProducerName
 493   //
 494   NumberOfHiiHandles = HandleBufferLength / sizeof (EFI_HII_HANDLE);
 495   for (Index = 0; Index < NumberOfHiiHandles; Index++) {
 496     Length = 0;
 497     Status = ExtractDataFromHiiHandle (
 498               HiiHandleBuffer[Index],
 499               &Length,
 500               NULL,
 501               &HiiGuid
 502               );
 503     if (CompareGuid (ProducerGuid, &HiiGuid)) {
 504       break;
 505     }
 506   }
 507   //
 508   // Find the string based on the current language
 509   //
 510   StringBufferLength  = 0x100;
 511   *String             = AllocateZeroPool (0x100);
 512   Status = Hii->GetString (
 513                   Hii,
 514                   HiiHandleBuffer[Index],
 515                   Token,
 516                   FALSE,
 517                   NULL,
 518                   &StringBufferLength,
 519                   *String
 520                   );
 521
 522   if (EFI_ERROR (Status)) {
 523     gBS->FreePool (*String);
 524     *String = GetStringById (STRING_TOKEN (STR_MISSING_STRING));
 525   }
 526
 527   gBS->FreePool (HiiHandleBuffer);
 528   return EFI_SUCCESS;
 529 }
 530
 531 VOID
 532 ConvertProcessorToString (
 533   IN  EFI_PROCESSOR_CORE_FREQUENCY_DATA *ProcessorFrequency,
 534   OUT CHAR16                            **String
 535   )
 536 /*++
 537
 538 Routine Description:
 539
 540   Convert Processor Frequency Data to a string
 541
 542 Arguments:
 543
 544   ProcessorFrequency - The frequency data to process
 545   String - The string that is created
 546
 547 Returns:
 548
 549 --*/
 550 {
 551   CHAR16  *StringBuffer;
 552   UINTN   Index;
 553   UINT32  FreqMhz;
 554
 555   if (ProcessorFrequency->Exponent >= 6) {
 556     FreqMhz = ProcessorFrequency->Value;
 557     for (Index = 0; Index < (UINTN) (ProcessorFrequency->Exponent - 6); Index++) {
 558       FreqMhz *= 10;
 559     }
 560   } else {
 561     FreqMhz = 0;
 562   }
 563
 564   StringBuffer = AllocateZeroPool (0x20);
 565   ASSERT (StringBuffer != NULL);
 566   Index = UnicodeValueToString (StringBuffer, LEFT_JUSTIFY, FreqMhz / 1000, 3);
 567   StrCat (StringBuffer, L".");
 568   UnicodeValueToString (StringBuffer + Index + 1, PREFIX_ZERO, (FreqMhz % 1000) / 10, 2);
 569   StrCat (StringBuffer, L" GHz");
 570
 571   *String = (CHAR16 *) StringBuffer;
 572
 573   return ;
 574 }
 575
 576 VOID
 577 ConvertMemorySizeToString (
 578   IN  UINT32          MemorySize,
 579   OUT CHAR16          **String
 580   )
 581 /*++
 582
 583 Routine Description:
 584
 585   Convert Memory Size to a string
 586
 587 Arguments:
 588
 589   MemorySize - The size of the memory to process
 590   String - The string that is created
 591
 592 Returns:
 593
 594 --*/
 595 {
 596   CHAR16  *StringBuffer;
 597
 598   StringBuffer = AllocateZeroPool (0x20);
 599   ASSERT (StringBuffer != NULL);
 600   UnicodeValueToString (StringBuffer, LEFT_JUSTIFY, MemorySize, 6);
 601   StrCat (StringBuffer, L" MB RAM");
 602
 603   *String = (CHAR16 *) StringBuffer;
 604
 605   return ;
 606 }
 607
 608 VOID
 609 UpdateFrontPageStrings (
 610   VOID
 611   )
 612 /*++
 613
 614 Routine Description:
 615
 616   Update the banner information for the Front Page based on DataHub information
 617
 618 Arguments:
 619
 620   None
 621
 622 Returns:
 623
 624 --*/
 625 {
 626   EFI_STATUS                        Status;
 627   STRING_REF                        TokenToUpdate;
 628   CHAR16                            *NewString;
 629   UINT64                            MonotonicCount;
 630   EFI_DATA_HUB_PROTOCOL             *DataHub;
 631   EFI_DATA_RECORD_HEADER            *Record;
 632   EFI_SUBCLASS_TYPE1_HEADER         *DataHeader;
 633   EFI_MISC_BIOS_VENDOR_DATA         *BiosVendor;
 634   EFI_MISC_SYSTEM_MANUFACTURER_DATA *SystemManufacturer;
 635   EFI_PROCESSOR_VERSION_DATA        *ProcessorVersion;
 636   EFI_PROCESSOR_CORE_FREQUENCY_DATA *ProcessorFrequency;
 637   EFI_MEMORY_ARRAY_START_ADDRESS_DATA *MemoryArray;
 638   CHAR8                             LangCode[3];
 639   CHAR16                            Lang[3];
 640   UINTN                             Size;
 641   UINTN                             Index;
 642   BOOLEAN                           Find[5];
 643
 644   ZeroMem (Find, sizeof (Find));
 645
 646   //
 647   // Update Front Page strings
 648   //
 649   Status = gBS->LocateProtocol (
 650                   &gEfiDataHubProtocolGuid,
 651                   NULL,
 652                   &DataHub
 653                   );
 654   ASSERT_EFI_ERROR (Status);
 655
 656   Size = 3;
 657
 658   Status = gRT->GetVariable (
 659                   L"Lang",
 660                   &gEfiGlobalVariableGuid,
 661                   NULL,
 662                   &Size,
 663                   LangCode
 664                   );
 665
 666   for (Index = 0; Index < 3; Index++) {
 667     Lang[Index] = (CHAR16) LangCode[Index];
 668   }
 669
 670   MonotonicCount  = 0;
 671   Record          = NULL;
 672   do {
 673     Status = DataHub->GetNextRecord (DataHub, &MonotonicCount, NULL, &Record);
 674     if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA) {
 675       DataHeader = (EFI_SUBCLASS_TYPE1_HEADER *) (Record + 1);
 676       if (CompareGuid (&Record->DataRecordGuid, &mMiscSubClass) &&
 677           (DataHeader->RecordType == EFI_MISC_BIOS_VENDOR_RECORD_NUMBER)
 678           ) {
 679         BiosVendor = (EFI_MISC_BIOS_VENDOR_DATA *) (DataHeader + 1);
 680         GetStringFromToken (&Record->ProducerName, BiosVendor->BiosVersion, &NewString);
 681         TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_BIOS_VERSION;
 682         Hii->NewString (Hii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
 683         gBS->FreePool (NewString);
 684         Find[0] = TRUE;
 685       }
 686
 687       if (CompareGuid (&Record->DataRecordGuid, &mMiscSubClass) &&
 688           (DataHeader->RecordType == EFI_MISC_SYSTEM_MANUFACTURER_RECORD_NUMBER)
 689           ) {
 690         SystemManufacturer = (EFI_MISC_SYSTEM_MANUFACTURER_DATA *) (DataHeader + 1);
 691         GetStringFromToken (&Record->ProducerName, SystemManufacturer->SystemProductName, &NewString);
 692         TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_COMPUTER_MODEL;
 693         Hii->NewString (Hii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
 694         gBS->FreePool (NewString);
 695         Find[1] = TRUE;
 696       }
 697
 698       if (CompareGuid (&Record->DataRecordGuid, &mProcessorSubClass) &&
 699           (DataHeader->RecordType == ProcessorVersionRecordType)
 700           ) {
 701         ProcessorVersion = (EFI_PROCESSOR_VERSION_DATA *) (DataHeader + 1);
 702         GetStringFromToken (&Record->ProducerName, *ProcessorVersion, &NewString);
 703         TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_CPU_MODEL;
 704         Hii->NewString (Hii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
 705         gBS->FreePool (NewString);
 706         Find[2] = TRUE;
 707       }
 708
 709       if (CompareGuid (&Record->DataRecordGuid, &mProcessorSubClass) &&
 710           (DataHeader->RecordType == ProcessorCoreFrequencyRecordType)
 711           ) {
 712         ProcessorFrequency = (EFI_PROCESSOR_CORE_FREQUENCY_DATA *) (DataHeader + 1);
 713         ConvertProcessorToString (ProcessorFrequency, &NewString);
 714         TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_CPU_SPEED;
 715         Hii->NewString (Hii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
 716         gBS->FreePool (NewString);
 717         Find[3] = TRUE;
 718       }
 719
 720       if (CompareGuid (&Record->DataRecordGuid, &mMemorySubClass) &&
 721           (DataHeader->RecordType == EFI_MEMORY_ARRAY_START_ADDRESS_RECORD_NUMBER)
 722           ) {
 723         MemoryArray = (EFI_MEMORY_ARRAY_START_ADDRESS_DATA *) (DataHeader + 1);
 724         ConvertMemorySizeToString((UINT32)(RShiftU64((MemoryArray->MemoryArrayEndAddress -
 725                                   MemoryArray->MemoryArrayStartAddress + 1), 20)),
 726                                   &NewString);
 727         TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_MEMORY_SIZE;
 728         Hii->NewString (Hii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
 729         gBS->FreePool (NewString);
 730         Find[4] = TRUE;
 731       }
 732     }
 733   } while (!EFI_ERROR (Status) && (MonotonicCount != 0) && !(Find[0] && Find[1] && Find[2] && Find[3] && Find[4]));
 734
 735   return ;
 736 }
 737
 738 VOID
 739 PlatformBdsEnterFrontPage (
 740   IN UINT16                       TimeoutDefault,
 741   IN BOOLEAN                      ConnectAllHappened
 742   )
 743 /*++
 744
 745 Routine Description:
 746   This function is the main entry of the platform setup entry.
 747   The function will present the main menu of the system setup,
 748   this is the platform reference part and can be customize.
 749
 750 Arguments:
 751   TimeoutDefault     - The fault time out value before the system
 752                        continue to boot.
 753   ConnectAllHappened - The indicater to check if the connect all have
 754                        already happended.
 755
 756 Returns:
 757   None
 758
 759 --*/
 760 {
 761   EFI_STATUS                    Status;
 762   EFI_HII_UPDATE_DATA           *UpdateData;
 763   EFI_CONSOLE_CONTROL_PROTOCOL  *ConsoleControl;
 764
 765   //
 766   // Indicate if we need connect all in the platform setup
 767   //
 768   if (ConnectAllHappened) {
 769     gConnectAllHappened = TRUE;
 770   }
 771   //
 772   // Allocate space for creation of Buffer
 773   //
 774   UpdateData = AllocateZeroPool (0x1000);
 775   ASSERT (UpdateData != NULL);
 776
 777   UpdateData->FormSetUpdate       = FALSE;
 778   UpdateData->FormCallbackHandle  = 0;
 779   UpdateData->FormUpdate          = FALSE;
 780   UpdateData->FormTitle           = 0;
 781   UpdateData->DataCount           = 1;
 782
 783   //
 784   // Remove Banner Op-code if any at this label
 785   //
 786   Hii->UpdateForm (Hii, gFrontPageHandle, (EFI_FORM_LABEL) 0xFFFF, FALSE, UpdateData);
 787
 788   //
 789   // Create Banner Op-code which reflects correct timeout value
 790   //
 791   CreateBannerOpCode (
 792     STRING_TOKEN (STR_TIME_OUT_PROMPT),
 793     TimeoutDefault,
 794     (UINT8) EFI_IFR_BANNER_TIMEOUT,
 795     &UpdateData->Data
 796     );
 797
 798   //
 799   // Add Banner Op-code at this label
 800   //
 801   Hii->UpdateForm (Hii, gFrontPageHandle, (EFI_FORM_LABEL) 0xFFFF, TRUE, UpdateData);
 802
 803   do {
 804
 805     InitializeFrontPage (TRUE);
 806
 807     //
 808     // Update Front Page strings
 809     //
 810     UpdateFrontPageStrings ();
 811
 812     gCallbackKey = 0;
 813     PERF_START (0, "BdsTimeOut", "BDS", 0);
 814     Status = CallFrontPage ();
 815     PERF_END (0, "BdsTimeOut", "BDS", 0);
 816
 817     //
 818     // If gCallbackKey is greater than 1 and less or equal to 5,
 819     // it will lauch configuration utilities.
 820     // 2 = set language
 821     // 3 = boot manager
 822     // 4 = device manager
 823     // 5 = boot maintainenance manager
 824     //
 825     if ((gCallbackKey > 0x0001) && (gCallbackKey <= 0x0005)) {
 826       REPORT_STATUS_CODE (
 827             EFI_PROGRESS_CODE,
 828             (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_PC_USER_SETUP)
 829             );
 830     }
 831     //
 832     // Based on the key that was set, we can determine what to do
 833     //
 834     switch (gCallbackKey) {
 835     //
 836     // The first 4 entries in the Front Page are to be GUARANTEED to remain constant so IHV's can
 837     // describe to their customers in documentation how to find their setup information (namely
 838     // under the device manager and specific buckets)
 839     //
 840     // These entries consist of the Continue, Select language, Boot Manager, and Device Manager
 841     //
 842     case 0x0001:
 843       //
 844       // User hit continue
 845       //
 846       break;
 847
 848     case 0x0002:
 849       //
 850       // User made a language setting change - display front page again
 851       //
 852       break;
 853
 854     case 0x0003:
 855       //
 856       // User chose to run the Boot Manager
 857       //
 858       CallBootManager ();
 859       break;
 860
 861     case 0x0004:
 862       //
 863       // Display the Device Manager
 864       //
 865       do {
 866         CallDeviceManager();
 867       } while (gCallbackKey == 4);
 868       break;
 869
 870     case 0x0005:
 871       //
 872       // Display the Boot Maintenance Manager
 873       //
 874       BdsStartBootMaint ();
 875       break;
 876     }
 877
 878   } while ((Status == EFI_SUCCESS) && (gCallbackKey != 1));
 879
 880   //
 881   // Automatically load current entry
 882   // Note: The following lines of code only execute when Auto boot
 883   // takes affect
 884   //
 885   Status = gBS->LocateProtocol (&gEfiConsoleControlProtocolGuid, NULL, &ConsoleControl);
 886   ConsoleControl->SetMode (ConsoleControl, EfiConsoleControlScreenText);
 887
 888 }