Vlv2TbltDevicePkg/PlatformSetupDxe/PlatformSetupDxe.c

   1 /** @file
   2
   3   Copyright (c) 2004  - 2014, Intel Corporation. All rights reserved.<BR>
   4
   5   SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7
   8
   9 Module Name:
  10
  11 **/
  12
  13 #include "PlatformSetupDxe.h"
  14 #include "Guid/SetupVariable.h"
  15 #include <Protocol/FormBrowserEx2.h>
  16
  17
  18 #define EFI_CALLBACK_INFO_SIGNATURE SIGNATURE_32 ('C', 'l', 'b', 'k')
  19 #define EFI_CALLBACK_INFO_FROM_THIS(a)  CR (a, EFI_CALLBACK_INFO, ConfigAccess, EFI_CALLBACK_INFO_SIGNATURE)
  20
  21 typedef struct {
  22   UINTN                           Signature;
  23   EFI_HANDLE                      DriverHandle;
  24   EFI_HII_HANDLE                  RegisteredHandle;
  25   SYSTEM_CONFIGURATION            FakeNvData;
  26   SYSTEM_CONFIGURATION            BackupNvData;
  27   EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting;
  28   EFI_HII_CONFIG_ACCESS_PROTOCOL  ConfigAccess;
  29 } EFI_CALLBACK_INFO;
  30
  31 #pragma pack(1)
  32
  33 //
  34 // HII specific Vendor Device Path definition.
  35 //
  36 typedef struct {
  37   VENDOR_DEVICE_PATH             VendorDevicePath;
  38   EFI_DEVICE_PATH_PROTOCOL       End;
  39 } HII_VENDOR_DEVICE_PATH;
  40
  41 #pragma pack()
  42
  43 //
  44 // uni string and Vfr Binary data.
  45 //
  46 extern UINT8  VfrBin[];
  47 extern UINT8  PlatformSetupDxeStrings[];
  48
  49 EFI_HANDLE            mImageHandle;
  50
  51 //
  52 // module global data
  53 //
  54 #define EFI_NORMAL_SETUP_GUID \
  55   { 0xec87d643, 0xeba4, 0x4bb5, 0xa1, 0xe5, 0x3f, 0x3e, 0x36, 0xb2, 0xd, 0xa9 }
  56
  57 EFI_GUID                     mNormalSetupGuid = EFI_NORMAL_SETUP_GUID;
  58
  59 EFI_GUID                     mSystemConfigGuid = SYSTEM_CONFIGURATION_GUID;
  60 CHAR16                       mVariableName[] = L"Setup";
  61 CHAR16                       mSetupName[] = L"Setup";
  62 EFI_CALLBACK_INFO           *mCallbackInfo;
  63 BOOLEAN                      GlobalReset=FALSE;
  64
  65 HII_VENDOR_DEVICE_PATH  mHiiVendorDevicePath = {
  66   {
  67     {
  68       HARDWARE_DEVICE_PATH,
  69       HW_VENDOR_DP,
  70       {
  71         (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
  72         (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
  73       }
  74     },
  75     EFI_CALLER_ID_GUID
  76   },
  77   {
  78     END_DEVICE_PATH_TYPE,
  79     END_ENTIRE_DEVICE_PATH_SUBTYPE,
  80     {
  81       (UINT8) (END_DEVICE_PATH_LENGTH),
  82       (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
  83     }
  84   }
  85 };
  86
  87 /**
  88   This function allows a caller to extract the current configuration for one
  89   or more named elements from the target driver.
  90
  91   @param  This         Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
  92   @param  Request      A null-terminated Unicode string in <ConfigRequest> format.
  93   @param  Progress     On return, points to a character in the Request string.
  94                        Points to the string's null terminator if request was successful.
  95                        Points to the most recent '&' before the first failing name/value
  96                        pair (or the beginning of the string if the failure is in the
  97                        first name/value pair) if the request was not successful.
  98   @param  Results      A null-terminated Unicode string in <ConfigAltResp> format which
  99                        has all values filled in for the names in the Request string.
 100                        String to be allocated by the called function.
 101
 102   @retval EFI_SUCCESS            The Results is filled with the requested values.
 103   @retval EFI_OUT_OF_RESOURCES   Not enough memory to store the results.
 104   @retval EFI_INVALID_PARAMETER  Request is NULL, illegal syntax, or unknown name.
 105   @retval EFI_NOT_FOUND          Routing data doesn't match any storage in this driver.
 106
 107 **/
 108
 109 VOID
 110 CheckSystemConfigLoad(SYSTEM_CONFIGURATION *SystemConfigPtr);
 111
 112 VOID
 113 CheckSystemConfigSave(SYSTEM_CONFIGURATION *SystemConfigPtr);
 114
 115 VOID
 116 ConfirmSecureBootTest();
 117
 118 VOID
 119 LoadLpssDefaultValues (
 120   IN EFI_CALLBACK_INFO                       *Private
 121   )
 122 {
 123   //
 124   // Load LPSS and SCC default configurations for Android
 125   //
 126   Private->FakeNvData.LpsseMMCEnabled            = FALSE;
 127   Private->FakeNvData.LpssSdioEnabled            = TRUE;
 128   Private->FakeNvData.LpssSdcardEnabled          = TRUE;
 129   Private->FakeNvData.LpssSdCardSDR25Enabled     = FALSE;
 130   Private->FakeNvData.LpssSdCardDDR50Enabled     = TRUE;
 131   Private->FakeNvData.LpssMipiHsi                = FALSE;
 132   Private->FakeNvData.LpsseMMC45Enabled          = TRUE;
 133   Private->FakeNvData.LpsseMMC45DDR50Enabled     = TRUE;
 134   Private->FakeNvData.LpsseMMC45HS200Enabled     = FALSE;
 135   Private->FakeNvData.LpsseMMC45RetuneTimerValue = 8;
 136   Private->FakeNvData.eMMCBootMode               = 1;     // Auto Detect
 137
 138   Private->FakeNvData.GOPEnable = TRUE;
 139   Private->FakeNvData.SecureBoot = TRUE;
 140   Private->FakeNvData.UsbAutoMode = TRUE;
 141   Private->FakeNvData.UsbXhciSupport = TRUE;
 142   Private->FakeNvData.PchUsb30Mode = TRUE;
 143   Private->FakeNvData.LegacyUSBBooting = FALSE;
 144   Private->FakeNvData.PchUsb20 = FALSE;
 145 }
 146
 147
 148 EFI_STATUS
 149 EFIAPI
 150 SystemConfigExtractConfig (
 151   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 152   IN  CONST EFI_STRING                       Request,
 153   OUT EFI_STRING                             *Progress,
 154   OUT EFI_STRING                             *Results
 155   )
 156 {
 157   EFI_STATUS                       Status;
 158   EFI_CALLBACK_INFO                *Private;
 159   EFI_HII_CONFIG_ROUTING_PROTOCOL  *HiiConfigRouting;
 160   EFI_STRING                       ConfigRequestHdr;
 161   EFI_STRING                       ConfigRequest;
 162   BOOLEAN                          AllocatedRequest;
 163   UINTN                            Size;
 164   UINTN                            BufferSize;
 165   VOID                             *SystemConfigPtr;
 166
 167
 168   if (Progress == NULL || Results == NULL) {
 169     return EFI_INVALID_PARAMETER;
 170   }
 171
 172   *Progress = Request;
 173   if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &mSystemConfigGuid, mVariableName)) {
 174     return EFI_NOT_FOUND;
 175   }
 176
 177   ConfigRequestHdr = NULL;
 178   ConfigRequest    = NULL;
 179   Size             = 0;
 180   AllocatedRequest = FALSE;
 181
 182   Private          = EFI_CALLBACK_INFO_FROM_THIS (This);
 183
 184   SetupInfo();
 185
 186   HiiConfigRouting = Private->HiiConfigRouting;
 187   ConfigRequest = Request;
 188   if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) {
 189     //
 190     // Request has no request element, construct full request string.
 191     // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
 192     // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
 193     //
 194     ConfigRequestHdr = HiiConstructConfigHdr (&mSystemConfigGuid, mVariableName, Private->DriverHandle);
 195     Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
 196     ConfigRequest = AllocateZeroPool (Size);
 197     ASSERT (ConfigRequest != NULL);
 198     AllocatedRequest = TRUE;
 199     BufferSize = sizeof (SYSTEM_CONFIGURATION);
 200     UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);
 201     FreePool (ConfigRequestHdr);
 202   }
 203   SystemConfigPtr = GetVariable(mSetupName, &mNormalSetupGuid);
 204
 205
 206   if (SystemConfigPtr == NULL) {
 207     ZeroMem(&Private->FakeNvData, sizeof(SYSTEM_CONFIGURATION));
 208     ZeroMem(&Private->BackupNvData, sizeof(SYSTEM_CONFIGURATION));
 209   } else {
 210     CheckSystemConfigLoad(SystemConfigPtr);
 211     CopyMem(&Private->FakeNvData, SystemConfigPtr, sizeof(SYSTEM_CONFIGURATION));
 212     CopyMem(&Private->BackupNvData, SystemConfigPtr, sizeof(SYSTEM_CONFIGURATION));
 213     FreePool(SystemConfigPtr);
 214   }
 215
 216   //
 217   // Convert buffer data to <ConfigResp> by helper function BlockToConfig()
 218   //
 219   Status = HiiConfigRouting->BlockToConfig (
 220                                HiiConfigRouting,
 221                                ConfigRequest,
 222                                (UINT8 *) &Private->FakeNvData,
 223                                sizeof (SYSTEM_CONFIGURATION),
 224                                Results,
 225                                Progress
 226                                );
 227
 228   //
 229   // Free the allocated config request string.
 230   //
 231   if (AllocatedRequest) {
 232     FreePool (ConfigRequest);
 233     ConfigRequest = NULL;
 234   }
 235
 236   //
 237   // Set Progress string to the original request string.
 238   //
 239   if (Request == NULL) {
 240     *Progress = NULL;
 241   } else if (StrStr (Request, L"OFFSET") == NULL) {
 242     *Progress = Request + StrLen (Request);
 243   }
 244
 245   return Status;
 246 }
 247
 248 /**
 249   This function processes the results of changes in configuration.
 250
 251   @param  This            Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 252   @param  Configuration   A null-terminated Unicode string in <ConfigRequest> format.
 253   @param  Progress        A pointer to a string filled in with the offset of the most
 254                           recent '&' before the first failing name/value pair (or the
 255                           beginning of the string if the failure is in the first
 256                           name/value pair) or the terminating NULL if all was successful.
 257
 258   @retval EFI_SUCCESS            The Results is processed successfully.
 259   @retval EFI_INVALID_PARAMETER  Configuration is NULL.
 260   @retval EFI_NOT_FOUND          Routing data doesn't match any storage in this driver.
 261
 262 **/
 263 EFI_STATUS
 264 EFIAPI
 265 SystemConfigRouteConfig (
 266   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 267   IN  CONST EFI_STRING                       Configuration,
 268   OUT EFI_STRING                             *Progress
 269   )
 270 {
 271   EFI_CALLBACK_INFO                         *Private;
 272   SYSTEM_CONFIGURATION                       *FakeNvData;
 273
 274   if (Configuration == NULL || Progress == NULL) {
 275     return EFI_INVALID_PARAMETER;
 276   }
 277   *Progress = Configuration;
 278
 279   if (!HiiIsConfigHdrMatch (Configuration, &mSystemConfigGuid, mVariableName)) {
 280     return EFI_NOT_FOUND;
 281   }
 282
 283   *Progress = Configuration + StrLen (Configuration);
 284   Private    = EFI_CALLBACK_INFO_FROM_THIS (This);
 285   FakeNvData = &Private->FakeNvData;
 286   if (!HiiGetBrowserData (&mSystemConfigGuid, mVariableName, sizeof (SYSTEM_CONFIGURATION), (UINT8 *) FakeNvData)) {
 287     //
 288     // FakeNvData can't be got from SetupBrowser, which doesn't need to be set.
 289     //
 290     return EFI_SUCCESS;
 291   }
 292
 293   if (Private->FakeNvData.ReservedO != Private->BackupNvData.ReservedO) {
 294     Private->BackupNvData.ReservedO = Private->FakeNvData.ReservedO;
 295     LoadLpssDefaultValues (Private);
 296
 297     //
 298     // Pass changed uncommitted data back to Form Browser
 299     //
 300     HiiSetBrowserData (&mSystemConfigGuid, mVariableName, sizeof (SYSTEM_CONFIGURATION), (UINT8 *) FakeNvData, NULL);
 301   }
 302
 303   gRT->SetVariable(
 304          mSetupName,
 305          &mNormalSetupGuid,
 306          EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
 307          sizeof(SYSTEM_CONFIGURATION),
 308          &Private->FakeNvData
 309          );
 310
 311   CheckSystemConfigSave(&Private->FakeNvData);
 312   return EFI_SUCCESS;
 313 }
 314
 315 /**
 316   This is the function that is called to provide results data to the driver.  This data
 317   consists of a unique key which is used to identify what data is either being passed back
 318   or being asked for.
 319
 320   @param  This           Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 321   @param  Action         A null-terminated Unicode string in <ConfigRequest> format.
 322   @param  KeyValue       A unique Goto OpCode callback value which record user's selection.
 323                          0x100 <= KeyValue <0x500 : user select a controller item in the first page;
 324                          KeyValue == 0x1234       : user select 'Refresh' in first page, or user select 'Go to Previous Menu' in second page
 325                          KeyValue == 0x1235       : user select 'Pci device filter' in first page
 326                          KeyValue == 0x1500       : user select 'order ... priority' item in second page
 327                          KeyValue == 0x1800       : user select 'commint changes' in third page
 328                          KeyValue == 0x2000       : user select 'Go to Previous Menu' in third page
 329   @param  Type           The type of value for the question.
 330   @param  Value          A pointer to the data being sent to the original exporting driver.
 331   @param  ActionRequest  On return, points to the action requested by the callback function.
 332
 333   @retval EFI_SUCCESS    Always returned.
 334
 335 **/
 336 EFI_STATUS
 337 EFIAPI
 338 SystemConfigCallback (
 339   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 340   IN  EFI_BROWSER_ACTION                     Action,
 341   IN  EFI_QUESTION_ID                        KeyValue,
 342   IN  UINT8                                  Type,
 343   IN  EFI_IFR_TYPE_VALUE                     *Value,
 344   OUT EFI_BROWSER_ACTION_REQUEST             *ActionRequest
 345   )
 346 {
 347   EFI_CALLBACK_INFO             *Private;
 348   SYSTEM_CONFIGURATION          *FakeNvData;
 349   SYSTEM_CONFIGURATION          *SetupData;
 350   UINTN                         SizeOfNvStore;
 351   EFI_INPUT_KEY                 Key;
 352   CHAR16                        *StringBuffer1;
 353   CHAR16                        *StringBuffer2;
 354   CHAR16                        *StringBuffer3;
 355   EFI_STATUS                    Status;
 356   UINTN                         DataSize;
 357   UINT8                         OsSelection;
 358   EDKII_FORM_BROWSER_EXTENSION2_PROTOCOL *FormBrowserEx2;
 359
 360   StringBuffer1 = AllocateZeroPool (200 * sizeof (CHAR16));
 361   ASSERT (StringBuffer1 != NULL);
 362   StringBuffer2 = AllocateZeroPool (200 * sizeof (CHAR16));
 363   ASSERT (StringBuffer2 != NULL);
 364   StringBuffer3 = AllocateZeroPool (200 * sizeof (CHAR16));
 365   ASSERT (StringBuffer3 != NULL);
 366
 367   switch (Action) {
 368   case EFI_BROWSER_ACTION_CHANGING:
 369   {
 370     if (KeyValue == 0x1235) {
 371       StrCpy (StringBuffer1, L"Will you disable PTT ? ");
 372       StrCpy (StringBuffer2, L"Enter (YES)  /   Esc (NO)");
 373
 374       //
 375       // Popup a menu to notice user
 376       //
 377       do {
 378         CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, NULL);
 379       } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
 380
 381       //
 382       // If the user hits the YES Response key,
 383       //
 384       if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
 385
 386       }
 387     } else if (KeyValue == 0x1236) {
 388       StrCpy (StringBuffer1, L"Will you revoke trust ? ");
 389       StrCpy (StringBuffer2, L"Enter (YES)  /   Esc (NO)");
 390
 391       //
 392       // Popup a menu to notice user
 393       //
 394       do {
 395         CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, NULL);
 396       } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
 397
 398       //
 399       // If the user hits the YES Response key,
 400       //
 401       if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
 402
 403       }
 404          } else if (KeyValue == 0x1239) {
 405            if (Value->u8 == 0x00) {
 406        StrCpy (StringBuffer1, L"WARNING: SOC may be damaged due to high temperature");
 407        StrCpy (StringBuffer2, L"when DPTF is disabled and IGD turbo is enabled.");
 408        StrCpy (StringBuffer3, L"Press Enter/ESC to continue...");
 409
 410         //
 411         // Popup a menu to notice user
 412         //
 413         do {
 414           CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, StringBuffer3, NULL);
 415         } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
 416     }
 417     } else if (KeyValue == 0x1240) { // secure erase feature of eMMC
 418             //
 419       // Popup a menu to notice user
 420       //
 421       StrCpy (StringBuffer1, L"WARNING: All your data on the eMMC will be lost");
 422       StrCpy (StringBuffer2, L"Do you really want to enable secure erase on eMMC?");
 423       StrCpy (StringBuffer3, L"       Enter (YES)    /    Esc (NO)        ");
 424
 425       do {
 426         CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, StringBuffer3,NULL);
 427       } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
 428
 429       //
 430       // If the user hits the ESC Response key,
 431       //
 432       if (Key.ScanCode == SCAN_ESC) {
 433         Private = EFI_CALLBACK_INFO_FROM_THIS (This);
 434         FakeNvData = &Private->FakeNvData;
 435
 436         Status = HiiGetBrowserData (
 437                                &mSystemConfigGuid,
 438                                            mVariableName,
 439                                            sizeof (SYSTEM_CONFIGURATION),
 440                                            (UINT8 *) FakeNvData
 441                                            );
 442         if (!EFI_ERROR (Status)) {
 443              FakeNvData->SecureErase = 0;
 444              HiiSetBrowserData (
 445                &mSystemConfigGuid,
 446                mVariableName,
 447                sizeof (SYSTEM_CONFIGURATION),
 448                (UINT8 *) FakeNvData,
 449                NULL
 450                );
 451         }
 452         break;
 453       }
 454
 455       //
 456       // If the user hits the YES Response key
 457       //
 458       if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
 459         //
 460         // Save change
 461         //
 462         Private = EFI_CALLBACK_INFO_FROM_THIS (This);
 463         FakeNvData = &Private->FakeNvData;
 464
 465         Status = HiiGetBrowserData (
 466                                &mSystemConfigGuid,
 467                                            mVariableName,
 468                                            sizeof (SYSTEM_CONFIGURATION),
 469                                           (UINT8 *) FakeNvData
 470                                           );
 471         if (!EFI_ERROR (Status)) {
 472           Status = gRT->SetVariable (
 473                           L"Setup",
 474                           &mNormalSetupGuid,
 475                           EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
 476                           sizeof(SYSTEM_CONFIGURATION),
 477                           &Private->FakeNvData
 478                           );
 479         }
 480
 481         //
 482         // Reset system
 483         //
 484         gRT->ResetSystem(
 485                            EfiResetCold,
 486                                  EFI_SUCCESS,
 487                                  0,
 488                                  NULL
 489                                  );
 490
 491     }
 492
 493
 494     }
 495     else if (KeyValue == 0xF001) {
 496       //
 497       // Popup a menu to notice user
 498       //
 499       StrCpy (StringBuffer1, L"Do you want to Commit Changes and Exit?");
 500       StrCpy (StringBuffer2, L"         Enter (YES) / Esc (NO)        ");
 501
 502       do {
 503         CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, NULL);
 504       } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
 505
 506       //
 507       // If the user hits the YES Response key
 508       //
 509       if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
 510         //
 511         // Save change
 512         //
 513         Private = EFI_CALLBACK_INFO_FROM_THIS (This);
 514         FakeNvData = &Private->FakeNvData;
 515
 516         Status = HiiGetBrowserData (
 517                            &mSystemConfigGuid,
 518                                    mVariableName,
 519                                    sizeof (SYSTEM_CONFIGURATION),
 520                                    (UINT8 *) FakeNvData
 521                                    );
 522         if (!EFI_ERROR (Status)) {
 523           Status = gRT->SetVariable (
 524                           L"Setup",
 525                           &mNormalSetupGuid,
 526                           EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
 527                           sizeof(SYSTEM_CONFIGURATION),
 528                           &Private->FakeNvData
 529                           );
 530         }
 531
 532                 //
 533                 // Update Secure Boot configuration changes
 534                 //
 535         CheckSystemConfigSave(FakeNvData);
 536
 537         //
 538         // Reset system
 539         //
 540         if (GlobalReset == TRUE) {
 541           //
 542           // Issue full reset
 543           //
 544           IoWrite8 (
 545             (UINTN) 0XCF9,
 546             (UINT8) 0x02
 547             );
 548
 549           IoWrite8 (
 550             (UINTN) 0xCF9,
 551             (UINT8) 0x0E
 552             );
 553         } else {
 554                 gRT->ResetSystem(
 555                                EfiResetCold,
 556                                    EFI_SUCCESS,
 557                                    0,
 558                                    NULL
 559                                    );
 560         }
 561       }
 562     } else if (KeyValue == 0xF002) {
 563       //
 564       // Popup a menu to notice user
 565       //
 566       StrCpy (StringBuffer1, L"Do you want to Discard Changes and Exit?");
 567       StrCpy (StringBuffer2, L"         Enter (YES) / Esc (NO)         ");
 568
 569       do {
 570         CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, NULL);
 571       } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
 572
 573       //
 574       // If the user hits the YES Response key
 575       //
 576       if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
 577         //
 578         // Reset system
 579         //
 580         gRT->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL);
 581       }
 582     } else if (KeyValue == 0xF003) {
 583       //
 584       // Popup a menu to notice user
 585       //
 586       StrCpy (StringBuffer1, L"Do you want to load setup defaults and Exit?");
 587       StrCpy (StringBuffer2, L"         Enter (YES) / Esc (NO)             ");
 588
 589       do {
 590         CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, NULL);
 591       } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
 592
 593       //
 594       // If the user hits the YES Response key
 595       //
 596       if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
 597
 598         Status = gBS->LocateProtocol (&gEdkiiFormBrowserEx2ProtocolGuid, NULL, (VOID **) &FormBrowserEx2);
 599         FormBrowserEx2->ExecuteAction(BROWSER_ACTION_DEFAULT, EFI_HII_DEFAULT_CLASS_STANDARD);
 600
 601         FakeNvData = AllocateZeroPool (sizeof(SYSTEM_CONFIGURATION));
 602
 603         if (FakeNvData == NULL) {
 604           return EFI_OUT_OF_RESOURCES;
 605         }
 606
 607         Status = HiiGetBrowserData (
 608                            &mSystemConfigGuid,
 609                                    mVariableName,
 610                                    sizeof (SYSTEM_CONFIGURATION),
 611                                    (UINT8 *) FakeNvData
 612                                    );
 613
 614         if (!EFI_ERROR (Status)) {
 615           Status = gRT->SetVariable (
 616                           L"Setup",
 617                           &mNormalSetupGuid,
 618                             EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
 619                           sizeof(SYSTEM_CONFIGURATION),
 620                           FakeNvData
 621                           );
 622         }
 623
 624         FreePool (FakeNvData);
 625
 626         DataSize = sizeof(OsSelection);
 627         Status = gRT->GetVariable(
 628                         L"OsSelection",
 629                         &gOsSelectionVariableGuid,
 630                         NULL,
 631                         &DataSize,
 632                         &OsSelection
 633                         );
 634
 635         if (EFI_ERROR(Status) || (OsSelection != FakeNvData->ReservedO)) {
 636           OsSelection = FakeNvData->ReservedO;
 637           Status = gRT->SetVariable (
 638                           L"OsSelection",
 639                           &gOsSelectionVariableGuid,
 640                           EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
 641                           sizeof(OsSelection),
 642                           &OsSelection
 643                           );
 644         }
 645
 646         //
 647         // Reset system
 648         //
 649         gRT->ResetSystem(
 650                        EfiResetCold,
 651                            EFI_SUCCESS,
 652                            0,
 653                            NULL
 654                            );
 655       }
 656     } else if ((KeyValue == 0x123A) || (KeyValue == 0x123B) || (KeyValue == 0x123C)) {
 657         StrCpy (StringBuffer1, L"WARNING: Enable or disable USB Controllers will ");
 658         StrCpy (StringBuffer2, L"make global reset to restart system.");
 659         StrCpy (StringBuffer3, L"Press Enter/ESC to continue...");
 660         //
 661         // Popup a menu to notice user
 662         //
 663         do {
 664           CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, StringBuffer3, NULL);
 665         } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
 666
 667         FakeNvData = AllocateZeroPool (sizeof(SYSTEM_CONFIGURATION));
 668         Status = HiiGetBrowserData (
 669                            &mSystemConfigGuid,
 670                                    mVariableName,
 671                                    sizeof (SYSTEM_CONFIGURATION),
 672                                    (UINT8 *) FakeNvData
 673                                    );
 674         //
 675         // Get variable data
 676         //
 677         SizeOfNvStore = sizeof(SYSTEM_CONFIGURATION);
 678         SetupData = AllocateZeroPool (sizeof(SYSTEM_CONFIGURATION));
 679         Status = gRT->GetVariable(
 680                         L"Setup",
 681                         &mNormalSetupGuid,
 682                         NULL,
 683                         &SizeOfNvStore,
 684                         SetupData
 685                         );
 686         if ((SetupData->UsbAutoMode != FakeNvData->UsbAutoMode) ||
 687                    (SetupData->UsbXhciSupport != FakeNvData->UsbXhciSupport) ||
 688                    (SetupData->PchUsb20 != FakeNvData->PchUsb20)) {
 689           GlobalReset = TRUE;
 690         } else {
 691           GlobalReset = FALSE;
 692         }
 693
 694     }
 695   }
 696   break;
 697
 698   default:
 699     break;
 700   }
 701
 702   FreePool (StringBuffer1);
 703   FreePool (StringBuffer2);
 704   FreePool (StringBuffer3);
 705
 706   //
 707   // Workaround for Load Default for "DPTF Enable"
 708   //
 709   if (Action == EFI_BROWSER_ACTION_DEFAULT_STANDARD) {
 710     if (KeyValue == 0x1239) {
 711       return EFI_NOT_FOUND;
 712     }
 713   }
 714
 715   if (Action == EFI_BROWSER_ACTION_FORM_CLOSE) {
 716     //
 717     // Do nothing for UEFI OPEN/CLOSE Action
 718     //
 719     return EFI_SUCCESS;
 720   }
 721
 722   Private = EFI_CALLBACK_INFO_FROM_THIS (This);
 723   FakeNvData = &Private->FakeNvData;
 724   if (!HiiGetBrowserData (&mSystemConfigGuid, mVariableName, sizeof (SYSTEM_CONFIGURATION), (UINT8 *) FakeNvData)) {
 725     return EFI_NOT_FOUND;
 726   }
 727
 728   if ((Action == EFI_BROWSER_ACTION_FORM_OPEN) && (Private->FakeNvData.ReservedO != Private->BackupNvData.ReservedO)) {
 729     Private->BackupNvData.ReservedO = Private->FakeNvData.ReservedO;
 730     LoadLpssDefaultValues (Private);
 731   }
 732
 733   //
 734   // When user selected the secure erase, set it to disable
 735   //
 736   if((KeyValue == 0x1240) && (Action == EFI_BROWSER_ACTION_CHANGED)) {
 737     FakeNvData->SecureErase = 0;
 738   }
 739
 740   if ((Action == EFI_BROWSER_ACTION_FORM_OPEN) || (Action == EFI_BROWSER_ACTION_CHANGED)) {
 741     //
 742     // If function 0 is disabled, function 1 ~ 7 also required to be disabled.
 743     //
 744     if (Private->FakeNvData.LpssDma0Enabled == 0) {
 745       Private->FakeNvData.LpssHsuart0Enabled = 0;
 746       Private->FakeNvData.LpssHsuart1Enabled = 0;
 747       Private->FakeNvData.LpssPwm0Enabled    = 0;
 748       Private->FakeNvData.LpssPwm1Enabled    = 0;
 749       Private->FakeNvData.LpssSpiEnabled     = 0;
 750     }
 751
 752
 753     //
 754     // If function 0 is disabled, function 1 ~ 7 also required to be disabled.
 755     //
 756     if (Private->FakeNvData.LpssDma1Enabled == 0) {
 757       Private->FakeNvData.LpssI2C0Enabled = 0;
 758       Private->FakeNvData.LpssI2C1Enabled = 0;
 759       Private->FakeNvData.LpssI2C2Enabled = 0;
 760       Private->FakeNvData.LpssI2C3Enabled = 0;
 761       Private->FakeNvData.LpssI2C4Enabled = 0;
 762       Private->FakeNvData.LpssI2C5Enabled = 0;
 763       Private->FakeNvData.LpssI2C6Enabled = 0;
 764     }
 765   }
 766
 767
 768   //
 769   // Pass changed uncommitted data back to Form Browser
 770   //
 771   HiiSetBrowserData (&mSystemConfigGuid, mVariableName, sizeof (SYSTEM_CONFIGURATION), (UINT8 *) FakeNvData, NULL);
 772
 773   return EFI_SUCCESS;
 774 }
 775
 776
 777 /**
 778   The driver Entry Point. The function will export a disk device class formset and
 779   its callback function to hii database.
 780
 781   @param  ImageHandle    The firmware allocated handle for the EFI image.
 782   @param  SystemTable    A pointer to the EFI System Table.
 783
 784   @retval EFI_SUCCESS    The entry point is executed successfully.
 785   @retval other          Some error occurs when executing this entry point.
 786
 787 **/
 788 EFI_STATUS
 789 EFIAPI
 790 PlatformSetupDxeInit (
 791   IN EFI_HANDLE                   ImageHandle,
 792   IN EFI_SYSTEM_TABLE             *SystemTable
 793   )
 794 {
 795   EFI_STATUS                  Status;
 796   EFI_FORM_BROWSER2_PROTOCOL  *FormBrowser2;
 797
 798   mImageHandle = ImageHandle;
 799
 800   //
 801   // There should only be one Form Configuration protocol
 802   //
 803   Status = gBS->LocateProtocol (
 804                  &gEfiFormBrowser2ProtocolGuid,
 805                  NULL,
 806                  (VOID **) &FormBrowser2
 807                  );
 808   if (EFI_ERROR (Status)) {
 809     return Status;
 810   }
 811
 812   mCallbackInfo = AllocateZeroPool (sizeof (EFI_CALLBACK_INFO));
 813   if (mCallbackInfo == NULL) {
 814     return EFI_BAD_BUFFER_SIZE;
 815   }
 816
 817   mCallbackInfo->Signature = EFI_CALLBACK_INFO_SIGNATURE;
 818   mCallbackInfo->ConfigAccess.ExtractConfig = SystemConfigExtractConfig;
 819   mCallbackInfo->ConfigAccess.RouteConfig   = SystemConfigRouteConfig;
 820   mCallbackInfo->ConfigAccess.Callback      = SystemConfigCallback;
 821
 822   //
 823   // Install Device Path Protocol and Config Access protocol to driver handle
 824   // Install Platform Driver Override Protocol to driver handle
 825   //
 826   Status = gBS->InstallMultipleProtocolInterfaces (
 827                   &mCallbackInfo->DriverHandle,
 828                   &gEfiDevicePathProtocolGuid,
 829                   &mHiiVendorDevicePath,
 830                   &gEfiHiiConfigAccessProtocolGuid,
 831                   &mCallbackInfo->ConfigAccess,
 832                   NULL
 833                   );
 834   if (EFI_ERROR (Status)) {
 835     goto Finish;
 836   }
 837
 838   //
 839   // Publish our HII data
 840   //
 841   mCallbackInfo->RegisteredHandle = HiiAddPackages (
 842                                       &mSystemConfigGuid,
 843                                       mCallbackInfo->DriverHandle,
 844                                       VfrBin,
 845                                       PlatformSetupDxeStrings,
 846                                       NULL
 847                                       );
 848   if (mCallbackInfo->RegisteredHandle == NULL) {
 849     Status = EFI_OUT_OF_RESOURCES;
 850     goto Finish;
 851   }
 852
 853   mHiiHandle = mCallbackInfo->RegisteredHandle;
 854
 855   //
 856   // Locate ConfigRouting protocol
 857   //
 858   Status = gBS->LocateProtocol (
 859                   &gEfiHiiConfigRoutingProtocolGuid,
 860                   NULL,
 861                   (VOID **) &mCallbackInfo->HiiConfigRouting
 862                   );
 863   if (EFI_ERROR (Status)) {
 864     goto Finish;
 865   }
 866
 867   //
 868   // Clear all the globle variable
 869   //
 870   return EFI_SUCCESS;
 871
 872 Finish:
 873   if (mCallbackInfo->DriverHandle != NULL) {
 874     gBS->UninstallMultipleProtocolInterfaces (
 875            mCallbackInfo->DriverHandle,
 876            &gEfiDevicePathProtocolGuid,
 877            &mHiiVendorDevicePath,
 878            &gEfiHiiConfigAccessProtocolGuid,
 879            &mCallbackInfo->ConfigAccess,
 880            NULL
 881            );
 882   }
 883
 884   if (mCallbackInfo->RegisteredHandle != NULL) {
 885     HiiRemovePackages (mCallbackInfo->RegisteredHandle);
 886   }
 887
 888   if (mCallbackInfo != NULL) {
 889     FreePool (mCallbackInfo);
 890   }
 891
 892   return Status;
 893 }
 894
 895 /**
 896   Unload its installed protocol.
 897
 898   @param[in]  ImageHandle       Handle that identifies the image to be unloaded.
 899
 900   @retval EFI_SUCCESS           The image has been unloaded.
 901 **/
 902 EFI_STATUS
 903 EFIAPI
 904 PlatformSetupDxeUnload (
 905   IN EFI_HANDLE  ImageHandle
 906   )
 907 {
 908   if (mCallbackInfo != NULL) {
 909     if (mCallbackInfo->DriverHandle != NULL) {
 910       gBS->UninstallMultipleProtocolInterfaces (
 911              mCallbackInfo->DriverHandle,
 912              &gEfiDevicePathProtocolGuid,
 913              &mHiiVendorDevicePath,
 914              &gEfiHiiConfigAccessProtocolGuid,
 915              &mCallbackInfo->ConfigAccess,
 916              NULL
 917              );
 918     }
 919
 920     if (mCallbackInfo->RegisteredHandle != NULL) {
 921       HiiRemovePackages (mCallbackInfo->RegisteredHandle);
 922     }
 923
 924     FreePool (mCallbackInfo);
 925   }
 926
 927   return EFI_SUCCESS;
 928 }
 929