Vlv2TbltDevicePkg/PlatformSetupDxe/SetupInfoRecords.c

   1 /** @file
   2
   3   Copyright (c) 2004  - 2014, Intel Corporation. All rights reserved.<BR>
   4
   5   This program and the accompanying materials are licensed and made available under
   6   the terms and conditions of the BSD License that accompanies this distribution.
   7   The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php.
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13
  14
  15 Module Name:
  16
  17     SetupInfoRecords.c
  18
  19 Abstract:
  20
  21     This is the filter driver to retrieve data hub entries.
  22
  23 Revision History:
  24 --*/
  25
  26 #include "PlatformSetupDxe.h"
  27 #include <Protocol/LegacyBios.h>
  28 #include <Protocol/PciRootBridgeIo.h>
  29 #include <Protocol/SimpleNetwork.h>
  30 #include <Protocol/DevicePath.h>
  31 #include <Protocol/DiskInfo.h>
  32 #include <Protocol/IdeControllerInit.h>
  33 #include <Protocol/MpService.h>
  34 #include <Protocol/PchPlatformPolicy.h>
  35 #include <Protocol/CpuIo2.h>
  36 #include <Protocol/Smbios.h>
  37 #include <IndustryStandard/SmBios.h>
  38 #include <Library/IoLib.h>
  39 #include <Library/I2CLib.h>
  40 #include <Guid/GlobalVariable.h>
  41
  42 #include "Valleyview.h"
  43 #include "VlvAccess.h"
  44 #include "PchAccess.h"
  45 #include "SetupMode.h"
  46 #include "PchCommonDefinitions.h"
  47 #include <PlatformBaseAddresses.h>
  48
  49
  50 typedef struct {
  51   UINT8  ID;
  52   CHAR8  String[16];
  53 } VLV_REV;
  54
  55 typedef struct {
  56   UINT8 RevId;
  57   CHAR8 String[16];
  58 } SB_REV;
  59
  60 //
  61 // Silicon Steppings
  62 //
  63 SB_REV  SBRevisionTable[] = {
  64   {V_PCH_LPC_RID_0, "(A0 Stepping)"},
  65   {V_PCH_LPC_RID_1, "(A0 Stepping)"},
  66   {V_PCH_LPC_RID_2, "(A1 Stepping)"},
  67   {V_PCH_LPC_RID_3, "(A1 Stepping)"},
  68   {V_PCH_LPC_RID_4, "(B0 Stepping)"},
  69   {V_PCH_LPC_RID_5, "(B0 Stepping)"},
  70   {V_PCH_LPC_RID_6, "(B1 Stepping)"},
  71   {V_PCH_LPC_RID_7, "(B1 Stepping)"},
  72   {V_PCH_LPC_RID_8, "(B2 Stepping)"},
  73   {V_PCH_LPC_RID_9, "(B2 Stepping)"},
  74   {V_PCH_LPC_RID_A, "(B3 Stepping)"},
  75   {V_PCH_LPC_RID_B, "(B3 Stepping)"},
  76   {V_PCH_LPC_RID_C, "(C0 Stepping)"},
  77   {V_PCH_LPC_RID_D, "(C0 Stepping)"}
  78 };
  79
  80 #define LEFT_JUSTIFY  0x01
  81 #define PREFIX_SIGN   0x02
  82 #define PREFIX_BLANK  0x04
  83 #define COMMA_TYPE    0x08
  84 #define LONG_TYPE     0x10
  85 #define PREFIX_ZERO   0x20
  86
  87 #define ICH_REG_REV                 0x08
  88 #define MSR_IA32_PLATFORM_ID        0x17
  89
  90
  91 BOOLEAN                         mSetupInfoDone = FALSE;
  92 UINT8                           mUseProductKey = 0;
  93 EFI_EXP_BASE10_DATA             mProcessorFrequency;
  94 EFI_EXP_BASE10_DATA             mProcessorFsbFrequency;
  95
  96 EFI_GUID                        mProcessorProducerGuid;
  97 EFI_HII_HANDLE                  mHiiHandle;
  98 EFI_PLATFORM_CPU_INFO           mPlatformCpuInfo;
  99 SYSTEM_CONFIGURATION            mSystemConfiguration;
 100 EFI_PLATFORM_INFO_HOB           *mPlatformInfo;
 101
 102
 103 #define memset SetMem
 104
 105 UINT16                mMemorySpeed         = 0xffff;
 106 EFI_PHYSICAL_ADDRESS  mMemorySizeChannelASlot0  = 0;
 107 UINT16                mMemorySpeedChannelASlot0 = 0xffff;
 108 EFI_PHYSICAL_ADDRESS  mMemorySizeChannelASlot1  = 0;
 109 UINT16                mMemorySpeedChannelASlot1 = 0xffff;
 110 EFI_PHYSICAL_ADDRESS  mMemorySizeChannelBSlot0  = 0;
 111 UINT16                mMemorySpeedChannelBSlot0 = 0xffff;
 112 EFI_PHYSICAL_ADDRESS  mMemorySizeChannelBSlot1  = 0;
 113 UINT16                mMemorySpeedChannelBSlot1 = 0xffff;
 114 EFI_PHYSICAL_ADDRESS  mMemorySizeChannelCSlot0  = 0;
 115 UINT16                mMemorySpeedChannelCSlot0 = 0xffff;
 116 EFI_PHYSICAL_ADDRESS  mMemorySizeChannelCSlot1  = 0;
 117 UINT16                mMemorySpeedChannelCSlot1 = 0xffff;
 118 UINTN                 mMemoryMode          = 0xff;
 119
 120 #define CHARACTER_NUMBER_FOR_VALUE  30
 121   typedef struct {
 122   EFI_STRING_TOKEN            MemoryDeviceLocator;
 123   EFI_STRING_TOKEN            MemoryBankLocator;
 124   EFI_STRING_TOKEN            MemoryManufacturer;
 125   EFI_STRING_TOKEN            MemorySerialNumber;
 126   EFI_STRING_TOKEN            MemoryAssetTag;
 127   EFI_STRING_TOKEN            MemoryPartNumber;
 128   EFI_INTER_LINK_DATA         MemoryArrayLink;
 129   EFI_INTER_LINK_DATA         MemorySubArrayLink;
 130   UINT16                      MemoryTotalWidth;
 131   UINT16                      MemoryDataWidth;
 132   UINT64                      MemoryDeviceSize;
 133   EFI_MEMORY_FORM_FACTOR      MemoryFormFactor;
 134   UINT8                       MemoryDeviceSet;
 135   EFI_MEMORY_ARRAY_TYPE       MemoryType;
 136   EFI_MEMORY_TYPE_DETAIL      MemoryTypeDetail;
 137   UINT16                      MemorySpeed;
 138   EFI_MEMORY_STATE            MemoryState;
 139 } EFI_MEMORY_ARRAY_LINK;
 140
 141
 142 typedef struct {
 143   EFI_PHYSICAL_ADDRESS        MemoryArrayStartAddress;
 144   EFI_PHYSICAL_ADDRESS        MemoryArrayEndAddress;
 145   EFI_INTER_LINK_DATA         PhysicalMemoryArrayLink;
 146   UINT16                      MemoryArrayPartitionWidth;
 147 } EFI_MEMORY_ARRAY_START_ADDRESS;
 148
 149
 150 typedef enum {
 151   PCH_SATA_MODE_IDE = 0,
 152   PCH_SATA_MODE_AHCI,
 153   PCH_SATA_MODE_RAID,
 154   PCH_SATA_MODE_MAX
 155 } PCH_SATA_MODE;
 156
 157 /**
 158   Acquire the string associated with the Index from smbios structure and return it.
 159   The caller is responsible for free the string buffer.
 160
 161   @param OptionalStrStart   The start position to search the string
 162   @param Index              The index of the string to extract
 163   @param String             The string that is extracted
 164
 165   @retval EFI_SUCCESS       The function returns EFI_SUCCESS always.
 166
 167 **/
 168 EFI_STATUS
 169 GetOptionalStringByIndex (
 170   IN      CHAR8                   *OptionalStrStart,
 171   IN      UINT8                   Index,
 172   OUT     CHAR16                  **String
 173   )
 174 {
 175   UINTN          StrSize;
 176
 177   if (Index == 0) {
 178     *String = AllocateZeroPool (sizeof (CHAR16));
 179     return EFI_SUCCESS;
 180   }
 181
 182   StrSize = 0;
 183   do {
 184     Index--;
 185     OptionalStrStart += StrSize;
 186     StrSize           = AsciiStrSize (OptionalStrStart);
 187   } while (OptionalStrStart[StrSize] != 0 && Index != 0);
 188
 189   if ((Index != 0) || (StrSize == 1)) {
 190     //
 191     // Meet the end of strings set but Index is non-zero, or
 192     // Find an empty string
 193     //
 194     return EFI_NOT_FOUND;
 195   } else {
 196     *String = AllocatePool (StrSize * sizeof (CHAR16));
 197     AsciiStrToUnicodeStr (OptionalStrStart, *String);
 198   }
 199
 200   return EFI_SUCCESS;
 201 }
 202
 203 /**
 204   VSPrint worker function that prints a Value as a decimal number in Buffer
 205
 206   @param Buffer  Location to place ascii decimal number string of Value.
 207   @param Value   Decimal value to convert to a string in Buffer.
 208   @param Flags   Flags to use in printing decimal string, see file header for details.
 209   @param Width   Width of hex value.
 210
 211   Number of characters printed.
 212
 213 **/
 214 UINTN
 215 EfiValueToString (
 216   IN  OUT CHAR16  *Buffer,
 217   IN  INT64       Value,
 218   IN  UINTN       Flags,
 219   IN  UINTN       Width
 220   )
 221 {
 222   CHAR16    TempBuffer[CHARACTER_NUMBER_FOR_VALUE];
 223   CHAR16    *TempStr;
 224   CHAR16    *BufferPtr;
 225   UINTN     Count;
 226   UINTN     ValueCharNum;
 227   UINTN     Remainder;
 228   CHAR16    Prefix;
 229   UINTN     Index;
 230   BOOLEAN   ValueIsNegative;
 231   UINT64    TempValue;
 232
 233   TempStr         = TempBuffer;
 234   BufferPtr       = Buffer;
 235   Count           = 0;
 236   ValueCharNum    = 0;
 237   ValueIsNegative = FALSE;
 238
 239   if (Width > CHARACTER_NUMBER_FOR_VALUE - 1) {
 240     Width = CHARACTER_NUMBER_FOR_VALUE - 1;
 241   }
 242
 243   if (Value < 0) {
 244     Value           = -Value;
 245     ValueIsNegative = TRUE;
 246   }
 247
 248   do {
 249     TempValue = Value;
 250     Value = (INT64)DivU64x32 ((UINT64)Value, 10);
 251     Remainder = (UINTN)((UINT64)TempValue - 10 * Value);
 252     *(TempStr++) = (CHAR16)(Remainder + '0');
 253     ValueCharNum++;
 254     Count++;
 255     if ((Flags & COMMA_TYPE) == COMMA_TYPE) {
 256       if (ValueCharNum % 3 == 0 && Value != 0) {
 257         *(TempStr++) = ',';
 258         Count++;
 259       }
 260     }
 261   } while (Value != 0);
 262
 263   if (ValueIsNegative) {
 264     *(TempStr++)    = '-';
 265     Count++;
 266   }
 267
 268   if ((Flags & PREFIX_ZERO) && !ValueIsNegative) {
 269     Prefix = '0';
 270   } else {
 271     Prefix = ' ';
 272   }
 273
 274   Index = Count;
 275   if (!(Flags & LEFT_JUSTIFY)) {
 276     for (; Index < Width; Index++) {
 277       *(TempStr++) = Prefix;
 278     }
 279   }
 280
 281   //
 282   // Reverse temp string into Buffer.
 283   //
 284   if (Width > 0 && (UINTN) (TempStr - TempBuffer) > Width) {
 285     TempStr = TempBuffer + Width;
 286   }
 287   Index = 0;
 288   while (TempStr != TempBuffer) {
 289     *(BufferPtr++) = *(--TempStr);
 290     Index++;
 291   }
 292
 293   *BufferPtr = 0;
 294   return Index;
 295 }
 296
 297 static CHAR16 mHexStr[] = { L'0', L'1', L'2', L'3', L'4', L'5', L'6', L'7',
 298                             L'8', L'9', L'A', L'B', L'C', L'D', L'E', L'F' };
 299
 300 /**
 301   VSPrint worker function that prints a Value as a hex number in Buffer
 302
 303   @param  Buffer  Location to place ascii hex string of Value.
 304   @param  Value   Hex value to convert to a string in Buffer.
 305   @param  Flags   Flags to use in printing Hex string, see file header for details.
 306   @param  Width   Width of hex value.
 307
 308   @retval         Number of characters printed.
 309
 310 **/
 311 UINTN
 312 EfiValueToHexStr (
 313   IN  OUT CHAR16  *Buffer,
 314   IN  UINT64      Value,
 315   IN  UINTN       Flags,
 316   IN  UINTN       Width
 317   )
 318 {
 319   CHAR16  TempBuffer[CHARACTER_NUMBER_FOR_VALUE];
 320   CHAR16  *TempStr;
 321   CHAR16  Prefix;
 322   CHAR16  *BufferPtr;
 323   UINTN   Count;
 324   UINTN   Index;
 325
 326   TempStr   = TempBuffer;
 327   BufferPtr = Buffer;
 328
 329   //
 330   // Count starts at one since we will null terminate. Each iteration of the
 331   // loop picks off one nibble. Oh yea TempStr ends up backwards
 332   //
 333   Count = 0;
 334
 335   if (Width > CHARACTER_NUMBER_FOR_VALUE - 1) {
 336     Width = CHARACTER_NUMBER_FOR_VALUE - 1;
 337   }
 338
 339   do {
 340     Index = ((UINTN)Value & 0xf);
 341     *(TempStr++) = mHexStr[Index];
 342     Value = RShiftU64 (Value, 4);
 343     Count++;
 344   } while (Value != 0);
 345
 346   if (Flags & PREFIX_ZERO) {
 347     Prefix = '0';
 348   } else {
 349     Prefix = ' ';
 350   }
 351
 352   Index = Count;
 353   if (!(Flags & LEFT_JUSTIFY)) {
 354     for (; Index < Width; Index++) {
 355       *(TempStr++) = Prefix;
 356     }
 357   }
 358
 359   //
 360   // Reverse temp string into Buffer.
 361   //
 362   if (Width > 0 && (UINTN) (TempStr - TempBuffer) > Width) {
 363     TempStr = TempBuffer + Width;
 364   }
 365   Index = 0;
 366   while (TempStr != TempBuffer) {
 367     *(BufferPtr++) = *(--TempStr);
 368     Index++;
 369   }
 370
 371   *BufferPtr = 0;
 372   return Index;
 373 }
 374
 375 /*++
 376   Converts MAC address to Unicode string.
 377   The value is 64-bit and the resulting string will be 12
 378   digit hex number in pairs of digits separated by dashes.
 379
 380   @param  String    string that will contain the value
 381   @param  MacAddr   add argument and description to function comment
 382   @param  AddrSize  add argument and description to function comment
 383
 384 **/
 385 CHAR16 *
 386 StrMacToString (
 387   OUT CHAR16              *String,
 388   IN  EFI_MAC_ADDRESS     *MacAddr,
 389   IN  UINT32              AddrSize
 390   )
 391 {
 392   UINT32  i;
 393
 394   for (i = 0; i < AddrSize; i++) {
 395
 396     EfiValueToHexStr (
 397       &String[2 * i],
 398       MacAddr->Addr[i] & 0xFF,
 399       PREFIX_ZERO,
 400       2
 401       );
 402   }
 403
 404   //
 405   // Terminate the string.
 406   //
 407   String[2 * AddrSize] = L'\0';
 408
 409   return String;
 410 }
 411
 412 VOID UpdateLatestBootTime() {
 413   UINTN                         VarSize;
 414   EFI_STATUS                   Status;
 415   UINT64                       TimeValue;
 416   CHAR16                       Buffer[40];
 417   if (mSystemConfiguration.LogBootTime != 1) {
 418     return;
 419   }
 420   VarSize = sizeof(TimeValue);
 421   Status = gRT->GetVariable(
 422                   BOOT_TIME_NAME,
 423                   &gEfiNormalSetupGuid,
 424                   NULL,
 425                   &VarSize,
 426                   &TimeValue
 427                                           );
 428   if (EFI_ERROR(Status)) {
 429     return;
 430   }
 431   UnicodeSPrint (Buffer, sizeof (Buffer), L"%d ms", (UINT32)TimeValue);
 432   HiiSetString(mHiiHandle,STRING_TOKEN(STR_LOG_BOOT_TIME_VALUE), Buffer, NULL);
 433 }
 434
 435 /**
 436   Get Cache Type for the specified Cache. This function is invoked when there is data records
 437   available in the Data Hub.
 438
 439   Get Cache Type function arguments:
 440
 441   @param  Instance        The instance number of the subclass with the same ProducerName..
 442   @param  SubInstance     The instance number of the RecordType for the same Instance.
 443   @param  CacheType       Cache type, see definition of EFI_CACHE_TYPE_DATA.
 444
 445   @retval EFI_STATUS
 446
 447 **/
 448 EFI_STATUS
 449 GetCacheType(
 450   IN  UINT16                            Instance,
 451   IN  UINT16                            SubInstance,
 452   IN  EFI_CACHE_TYPE_DATA*              CacheType)
 453 {
 454   EFI_STATUS                  Status;
 455   EFI_DATA_HUB_PROTOCOL       *DataHub;
 456   EFI_DATA_RECORD_HEADER      *Record;
 457   UINT64                      MonotonicCount;
 458   EFI_CACHE_VARIABLE_RECORD*  CacheVariableRecord;
 459   EFI_SUBCLASS_TYPE1_HEADER   *DataHeader;
 460
 461   Status = gBS->LocateProtocol (
 462                   &gEfiDataHubProtocolGuid,
 463                   NULL,
 464                   (void **)&DataHub
 465                   );
 466   ASSERT_EFI_ERROR(Status);
 467
 468   //
 469   // Get all available data records from data hub
 470   //
 471   MonotonicCount = 0;
 472   Record = NULL;
 473
 474   do {
 475     Status = DataHub->GetNextRecord (
 476                             DataHub,
 477                                                 &MonotonicCount,
 478                                                 NULL,
 479                                                 &Record
 480                                                 );
 481     if (!EFI_ERROR(Status)) {
 482       if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA) {
 483         DataHeader  = (EFI_SUBCLASS_TYPE1_HEADER *)(Record + 1);
 484
 485         if(CompareGuid(&Record->DataRecordGuid, &gEfiCacheSubClassGuid) &&
 486           (DataHeader->RecordType == CacheTypeRecordType) &&
 487           (DataHeader->Instance == Instance) &&
 488           (DataHeader->SubInstance == SubInstance)) {
 489           CacheVariableRecord     = (EFI_CACHE_VARIABLE_RECORD  *)(DataHeader + 1);
 490           if(CacheType){
 491             *CacheType = CacheVariableRecord->CacheType;
 492             return EFI_SUCCESS;
 493           }
 494         }
 495       }
 496     }
 497   } while(!EFI_ERROR(Status) && (MonotonicCount != 0));
 498
 499   return EFI_NOT_FOUND;
 500 }
 501
 502 /**
 503   Setup data filter function. This function is invoked when there is data records
 504   available in the Data Hub.
 505
 506
 507   Standard event notification function arguments:
 508   @param Event          The event that is signaled.
 509   @param Context        Not used here.
 510
 511   @retval EFI_STATUS
 512
 513 **/
 514 VOID
 515 PrepareSetupInformation (
 516   )
 517 {
 518
 519   EFI_STATUS                  Status;
 520   EFI_DATA_HUB_PROTOCOL       *DataHub;
 521   EFI_DATA_RECORD_HEADER      *Record;
 522   UINT8                       *SrcData;
 523   EFI_SUBCLASS_TYPE1_HEADER   *DataHeader;
 524   CHAR16                      *NewString;
 525   CHAR16                      *NewString2;
 526   CHAR16                      *NewStringToken;
 527   STRING_REF                  TokenToUpdate;
 528   EFI_PROCESSOR_VERSION_DATA  *ProcessorVersion;
 529   UINTN                       Index;
 530   UINTN                       DataOutput;
 531
 532   EFI_PROCESSOR_MICROCODE_REVISION_DATA   *CpuUcodeRevisionData;
 533   EFI_MEMORY_ARRAY_START_ADDRESS          *MemoryArray;
 534   EFI_MEMORY_ARRAY_LINK                   *MemoryArrayLink;
 535   UINT64                      MonotonicCount;
 536
 537   CHAR16                      Version[100];         //Assuming that strings are < 100 UCHAR
 538   CHAR16                      ReleaseDate[100];     //Assuming that strings are < 100 UCHAR
 539   CHAR16                      ReleaseTime[100];     //Assuming that strings are < 100 UCHAR
 540
 541   NewString = AllocateZeroPool (0x100);
 542   NewString2 = AllocateZeroPool (0x100);
 543   SetMem(Version, sizeof(Version), 0);
 544   SetMem(ReleaseDate, sizeof(ReleaseDate), 0);
 545   SetMem(ReleaseTime, sizeof(ReleaseTime), 0);
 546
 547   //
 548   // Get the Data Hub Protocol. Assume only one instance
 549   //
 550   Status = gBS->LocateProtocol (&gEfiDataHubProtocolGuid, NULL, (void **)&DataHub);
 551   ASSERT_EFI_ERROR(Status);
 552
 553   //
 554   // Get all available data records from data hub
 555   //
 556   MonotonicCount = 0;
 557   Record = NULL;
 558
 559   do {
 560     Status = DataHub->GetNextRecord (DataHub, &MonotonicCount, NULL, &Record);
 561     if (!EFI_ERROR(Status)) {
 562       if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA) {
 563         DataHeader  = (EFI_SUBCLASS_TYPE1_HEADER *)(Record + 1);
 564         SrcData     = (UINT8  *)(DataHeader + 1);
 565
 566         //
 567         // Processor
 568         //
 569         if (CompareGuid(&Record->DataRecordGuid, &gEfiProcessorSubClassGuid)) {
 570           CopyMem (&mProcessorProducerGuid, &Record->ProducerName, sizeof(EFI_GUID));
 571           switch (DataHeader->RecordType) {
 572             case ProcessorCoreFrequencyRecordType:
 573               CopyMem(&mProcessorFrequency, SrcData, sizeof(EFI_EXP_BASE10_DATA));
 574               Index = EfiValueToString (
 575                                     NewString,
 576                                                 ConvertBase10ToRaw ((EFI_EXP_BASE10_DATA *)SrcData)/1000000000,
 577                                                 PREFIX_ZERO,
 578                                                 0
 579                                                 );
 580               StrCat (NewString, L".");
 581               EfiValueToString (
 582                             NewString + Index + 1,
 583                                 ((ConvertBase10ToRaw ((EFI_EXP_BASE10_DATA *)SrcData)%1000000000)/10000000),
 584                                 PREFIX_ZERO,
 585                                 0
 586                                 );
 587               StrCat (NewString, L" GHz");
 588               TokenToUpdate = (STRING_REF)STR_PROCESSOR_SPEED_VALUE;
 589               HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);
 590               break;
 591
 592             case ProcessorVersionRecordType:
 593               ProcessorVersion = (EFI_PROCESSOR_VERSION_DATA *)SrcData;
 594               NewStringToken = HiiGetPackageString(&mProcessorProducerGuid, *ProcessorVersion, NULL);
 595               TokenToUpdate = (STRING_REF)STR_PROCESSOR_VERSION_VALUE;
 596               HiiSetString(mHiiHandle, TokenToUpdate, NewStringToken, NULL);
 597               break;
 598             case CpuUcodeRevisionDataRecordType:
 599               CpuUcodeRevisionData = (EFI_PROCESSOR_MICROCODE_REVISION_DATA *) SrcData;
 600               if (CpuUcodeRevisionData->ProcessorMicrocodeRevisionNumber != 0) {
 601                 EfiValueToHexStr (
 602                                   NewString,
 603                   CpuUcodeRevisionData->ProcessorMicrocodeRevisionNumber,
 604                   PREFIX_ZERO,
 605                   8
 606                                   );
 607                 TokenToUpdate = (STRING_REF)STR_PROCESSOR_MICROCODE_VALUE;
 608                 HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);
 609               }
 610               break;
 611             default:
 612               break;
 613           }
 614
 615         //
 616         // Cache
 617         //
 618         } else if (CompareGuid(&Record->DataRecordGuid, &gEfiCacheSubClassGuid) &&
 619                    (DataHeader->RecordType == CacheSizeRecordType)) {
 620           if (DataHeader->SubInstance == EFI_CACHE_L1) {
 621             EFI_CACHE_TYPE_DATA              CacheType;
 622             if (EFI_SUCCESS == GetCacheType(DataHeader->Instance, DataHeader->SubInstance,&CacheType)){
 623               if (CacheType == EfiCacheTypeData) {
 624                 TokenToUpdate = (STRING_REF)STR_PROCESSOR_L1_DATA_CACHE_VALUE;
 625               } else if (CacheType == EfiCacheTypeInstruction) {
 626                   TokenToUpdate = (STRING_REF)STR_PROCESSOR_L1_INSTR_CACHE_VALUE;
 627               } else {
 628                 continue;
 629               }
 630             } else {
 631               continue;
 632             }
 633           }
 634           else if (DataHeader->SubInstance == EFI_CACHE_L2) {
 635             TokenToUpdate = (STRING_REF)STR_PROCESSOR_L2_CACHE_VALUE;
 636           } else {
 637             continue;
 638           }
 639           if (ConvertBase2ToRaw((EFI_EXP_BASE2_DATA *)SrcData)) {
 640             DataOutput = ConvertBase2ToRaw((EFI_EXP_BASE2_DATA *)SrcData) >> 10;
 641             EfiValueToString (NewString, DataOutput, PREFIX_ZERO, 0);
 642
 643             StrCat (NewString, L" KB");
 644             if (DataHeader->SubInstance == EFI_CACHE_L3) {
 645               HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);
 646             } else if(DataHeader->SubInstance == EFI_CACHE_L2 && mPlatformCpuInfo.CpuPackage.CoresPerPhysicalPackage > 1){
 647                           //
 648               // Show XxL2 string
 649                           //
 650               EfiValueToString (
 651                             NewString2,
 652                 mPlatformCpuInfo.CpuPackage.CoresPerPhysicalPackage,
 653                 PREFIX_ZERO,
 654                 0
 655                                 );
 656               StrCat(NewString2, L"x ");
 657               StrCat(NewString2, NewString);
 658               HiiSetString(mHiiHandle, TokenToUpdate, NewString2, NULL);
 659             } else {
 660               HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);
 661             }
 662           }
 663
 664         //
 665         // Memory
 666         //
 667         } else if (CompareGuid(&Record->DataRecordGuid, &gEfiMemorySubClassGuid)) {
 668           switch (DataHeader->RecordType) {
 669             case EFI_MEMORY_ARRAY_LINK_RECORD_NUMBER:
 670               MemoryArrayLink = (EFI_MEMORY_ARRAY_LINK *)SrcData;
 671
 672               if (MemoryArrayLink->MemorySpeed > 0) {
 673                 //
 674                 // Save the lowest speed memory module
 675                 //
 676                 if (MemoryArrayLink->MemorySpeed < mMemorySpeed) {
 677                   mMemorySpeed = MemoryArrayLink->MemorySpeed;
 678                 }
 679                 switch (DataHeader->SubInstance) {
 680                   case 1:
 681                     mMemorySpeedChannelASlot0 = MemoryArrayLink->MemorySpeed;
 682                     mMemorySizeChannelASlot0 = MemoryArrayLink->MemoryDeviceSize;
 683                     break;
 684                   case 2:
 685                     mMemorySpeedChannelASlot1 = MemoryArrayLink->MemorySpeed;
 686                     mMemorySizeChannelASlot1 = MemoryArrayLink->MemoryDeviceSize;
 687                     break;
 688                   case 3:
 689                     mMemorySpeedChannelBSlot0 = MemoryArrayLink->MemorySpeed;
 690                     mMemorySizeChannelBSlot0 = MemoryArrayLink->MemoryDeviceSize;
 691                     break;
 692                   case 4:
 693                     mMemorySpeedChannelBSlot1 = MemoryArrayLink->MemorySpeed;
 694                     mMemorySizeChannelBSlot1 = MemoryArrayLink->MemoryDeviceSize;
 695                     break;
 696                   case 5:
 697                     mMemorySpeedChannelCSlot0 = MemoryArrayLink->MemorySpeed;
 698                     mMemorySizeChannelCSlot0 = MemoryArrayLink->MemoryDeviceSize;
 699                     break;
 700                   case 6:
 701                     mMemorySpeedChannelCSlot1 = MemoryArrayLink->MemorySpeed;
 702                     mMemorySizeChannelCSlot1 = MemoryArrayLink->MemoryDeviceSize;
 703                     break;
 704                   default:
 705                     break;
 706                   }
 707               }
 708               break;
 709
 710             case EFI_MEMORY_ARRAY_START_ADDRESS_RECORD_NUMBER:
 711               MemoryArray = (EFI_MEMORY_ARRAY_START_ADDRESS *)SrcData;
 712               if (MemoryArray->MemoryArrayEndAddress - MemoryArray->MemoryArrayStartAddress) {
 713                 DataOutput = (UINTN)RShiftU64((MemoryArray->MemoryArrayEndAddress - MemoryArray->MemoryArrayStartAddress + 1), 20);
 714                 EfiValueToString (NewString, DataOutput / 1024, PREFIX_ZERO, 0);
 715                 if(DataOutput % 1024) {
 716                   StrCat (NewString, L".");
 717                   DataOutput = ((DataOutput % 1024) * 1000) / 1024;
 718                   while(!(DataOutput % 10))
 719                     DataOutput = DataOutput / 10;
 720                   EfiValueToString (NewString2, DataOutput, PREFIX_ZERO, 0);
 721                   StrCat (NewString, NewString2);
 722                 }
 723                 StrCat (NewString, L" GB");
 724                 TokenToUpdate = (STRING_REF)STR_TOTAL_MEMORY_SIZE_VALUE;
 725                 HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);
 726               }
 727               break;
 728
 729             default:
 730               break;
 731           }
 732         }
 733       }
 734     }
 735   } while (!EFI_ERROR(Status) && (MonotonicCount != 0));
 736
 737   Status = GetBiosVersionDateTime (
 738              Version,
 739                          ReleaseDate,
 740                          ReleaseTime
 741                          );
 742
 743   DEBUG ((EFI_D_ERROR, "GetBiosVersionDateTime :%s %s %s \n", Version, ReleaseDate, ReleaseTime));
 744   if (!EFI_ERROR (Status)) {
 745     UINTN         Length = 0;
 746     CHAR16        *BuildDateTime;
 747
 748     Length = StrLen(ReleaseDate) + StrLen(ReleaseTime);
 749
 750     BuildDateTime = AllocateZeroPool ((Length+2) * sizeof(CHAR16));
 751     StrCpy (BuildDateTime, ReleaseDate);
 752     StrCat (BuildDateTime, L" ");
 753     StrCat (BuildDateTime, ReleaseTime);
 754
 755     TokenToUpdate = (STRING_REF)STR_BIOS_VERSION_VALUE;
 756     DEBUG ((EFI_D_ERROR, "update STR_BIOS_VERSION_VALUE\n"));
 757     HiiSetString(mHiiHandle, TokenToUpdate, Version, NULL);
 758
 759     TokenToUpdate = (STRING_REF)STR_BIOS_BUILD_TIME_VALUE;
 760     DEBUG ((EFI_D_ERROR, "update STR_BIOS_BUILD_TIME_VALUE\n"));
 761     HiiSetString(mHiiHandle, TokenToUpdate, BuildDateTime, NULL);
 762   }
 763
 764   //
 765   // Calculate and update memory speed display in Main Page
 766   //
 767   //
 768   // Update the overall memory speed
 769   //
 770   if (mMemorySpeed != 0xffff) {
 771     EfiValueToString (NewString, mMemorySpeed, PREFIX_ZERO, 0);
 772     StrCat (NewString, L" MHz");
 773
 774     TokenToUpdate = (STRING_REF)STR_SYSTEM_MEMORY_SPEED_VALUE;
 775     HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);
 776   }
 777
 778   gBS->FreePool(NewString);
 779   gBS->FreePool(NewString2);
 780
 781   return;
 782 }
 783
 784 /**
 785
 786   Routine Description: update the SETUP info for "Additional Information" which is SMBIOS info.
 787
 788   @retval EFI_STATUS
 789
 790 **/
 791 EFI_STATUS
 792 UpdateAdditionalInformation (
 793   )
 794 {
 795   EFI_STATUS                      Status;
 796   UINT64                          MonotonicCount;
 797   EFI_DATA_HUB_PROTOCOL           *DataHub;
 798   EFI_DATA_RECORD_HEADER          *Record;
 799   EFI_SUBCLASS_TYPE1_HEADER       *DataHeader;
 800   EFI_SMBIOS_PROTOCOL             *Smbios;
 801   EFI_SMBIOS_HANDLE               SmbiosHandle;
 802   EFI_SMBIOS_TABLE_HEADER         *SmbiosRecord;
 803   SMBIOS_TABLE_TYPE0              *Type0Record;
 804   UINT8                           StrIndex;
 805   CHAR16                          *BiosVersion = NULL;
 806   CHAR16                          *IfwiVersion = NULL;
 807   UINT16                          SearchIndex;
 808   EFI_STRING_ID                   TokenToUpdate;
 809 #if defined( RVP_SUPPORT ) && RVP_SUPPORT
 810   EFI_MISC_SYSTEM_MANUFACTURER    *SystemManufacturer;
 811 #endif
 812
 813   Status = gBS->LocateProtocol (
 814                   &gEfiDataHubProtocolGuid,
 815                   NULL,
 816                   (void **)&DataHub
 817                   );
 818
 819   ASSERT_EFI_ERROR(Status);
 820
 821   MonotonicCount  = 0;
 822   Record = NULL;
 823   do {
 824     Status = DataHub->GetNextRecord (
 825                         DataHub,
 826                         &MonotonicCount,
 827                         NULL,
 828                         &Record
 829                         );
 830     if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA) {
 831       DataHeader  = (EFI_SUBCLASS_TYPE1_HEADER *)(Record + 1);
 832
 833       if (CompareGuid(&Record->DataRecordGuid, &gEfiMiscSubClassGuid) &&
 834           (DataHeader->RecordType == EFI_MISC_SYSTEM_MANUFACTURER_RECORD_NUMBER)) {
 835 #if defined( RVP_SUPPORT ) && RVP_SUPPORT
 836         //
 837         // System Information
 838         //
 839         SystemManufacturer = (EFI_MISC_SYSTEM_MANUFACTURER *)(DataHeader + 1);
 840
 841         //
 842         // UUID  (System Information)
 843         //
 844         SMBIOSString = EfiLibAllocateZeroPool (0x100);
 845         GuidToString ( &SystemManufacturer->SystemUuid, SMBIOSString, 0x00 );
 846
 847         TokenToUpdate = (STRING_REF)STR_SYSTEM_UUID_VALUE;
 848         HiiSetString(mHiiHandle, TokenToUpdate, SMBIOSString, NULL);
 849
 850         gBS->FreePool(SMBIOSString);
 851 #endif
 852       }
 853     }
 854   } while (!EFI_ERROR(Status) && (MonotonicCount != 0));
 855
 856   Status = gBS->LocateProtocol (
 857                   &gEfiSmbiosProtocolGuid,
 858                   NULL,
 859                   (VOID **) &Smbios
 860                   );
 861   ASSERT_EFI_ERROR (Status);
 862
 863   SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
 864   do {
 865     Status = Smbios->GetNext (
 866                        Smbios,
 867                        &SmbiosHandle,
 868                        NULL,
 869                        &SmbiosRecord,
 870                        NULL
 871                        );
 872     if (SmbiosRecord->Type == EFI_SMBIOS_TYPE_BIOS_INFORMATION) {
 873       Type0Record = (SMBIOS_TABLE_TYPE0 *) SmbiosRecord;
 874       StrIndex = Type0Record->BiosVersion;
 875       GetOptionalStringByIndex ((CHAR8*)((UINT8*)Type0Record + Type0Record->Hdr.Length), StrIndex, &BiosVersion);
 876       TokenToUpdate = STRING_TOKEN (STR_BIOS_VERSION_VALUE);
 877       for (SearchIndex = 0x0; SearchIndex < SMBIOS_STRING_MAX_LENGTH; SearchIndex++) {
 878         if (BiosVersion[SearchIndex] == 0x0020) {
 879           BiosVersion[SearchIndex] = 0x0000;
 880           IfwiVersion = (CHAR16 *)(&BiosVersion[SearchIndex+1]);
 881           break;
 882         } else if (BiosVersion[SearchIndex] == 0x0000) {
 883           break;
 884         }
 885       }
 886       HiiSetString (mHiiHandle, TokenToUpdate, BiosVersion, NULL);
 887
 888       //
 889       // Check IfwiVersion, to avoid no IFWI version in SMBIOS Type 0 strucntion
 890       //
 891       if(IfwiVersion) {
 892         TokenToUpdate = STRING_TOKEN (STR_IFWI_VERSION_VALUE);
 893         HiiSetString (mHiiHandle, TokenToUpdate, IfwiVersion, NULL);
 894       }
 895     }
 896   } while (!EFI_ERROR(Status));
 897
 898   UpdateLatestBootTime();
 899
 900   return  EFI_SUCCESS;
 901 }
 902
 903 VOID
 904 UpdateCPUInformation ()
 905 {
 906   CHAR16                                                                Buffer[40];
 907   UINT16                                FamilyId;
 908   UINT8                                 Model;
 909   UINT8                                 SteppingId;
 910   UINT8                                 ProcessorType;
 911   EFI_STATUS                            Status;
 912   EFI_MP_SERVICES_PROTOCOL              *MpService;
 913   UINTN                                 MaximumNumberOfCPUs;
 914   UINTN                                 NumberOfEnabledCPUs;
 915   UINT32                                                                Buffer32 = 0xFFFFFFFF;   // Keep buffer with unknown device
 916
 917   EfiCpuVersion (&FamilyId, &Model, &SteppingId, &ProcessorType);
 918
 919   //
 920   //we need raw Model data
 921   //
 922   Model = Model & 0xf;
 923
 924   //
 925   //Family/Model/Step
 926   //
 927   UnicodeSPrint (Buffer, sizeof (Buffer), L"%d/%d/%d", FamilyId,  Model, SteppingId);
 928   HiiSetString(mHiiHandle,STRING_TOKEN(STR_PROCESSOR_ID_VALUE), Buffer, NULL);
 929
 930   Status = gBS->LocateProtocol (
 931                   &gEfiMpServiceProtocolGuid,
 932                   NULL,
 933                   (void **)&MpService
 934                   );
 935   if (!EFI_ERROR (Status)) {
 936     //
 937     // Determine the number of processors
 938     //
 939     MpService->GetNumberOfProcessors (
 940                  MpService,
 941                  &MaximumNumberOfCPUs,
 942                  &NumberOfEnabledCPUs
 943                  );
 944     UnicodeSPrint (Buffer, sizeof (Buffer), L"%d", MaximumNumberOfCPUs);
 945     HiiSetString(mHiiHandle,STRING_TOKEN(STR_PROCESSOR_CORE_VALUE), Buffer, NULL);
 946   }
 947   //
 948   // Update Mobile / Desktop / Tablet SKU
 949   //
 950   Buffer32 =(UINT32) RShiftU64 (EfiReadMsr (MSR_IA32_PLATFORM_ID), 50) & 0x07;
 951
 952   switch(Buffer32){
 953       case 0x0:
 954         UnicodeSPrint (Buffer, sizeof (Buffer), L"(%d) - ISG SKU SOC", Buffer32);
 955         break;
 956       case 0x01:
 957         UnicodeSPrint (Buffer, sizeof (Buffer), L"(%d) - Mobile SKU SOC", Buffer32);
 958         break;
 959       case 0x02:
 960         UnicodeSPrint (Buffer, sizeof (Buffer), L"(%d) - Desktop SKU SOC", Buffer32);
 961         break;
 962       case 0x03:
 963         UnicodeSPrint (Buffer, sizeof (Buffer), L"(%d) - Mobile SKU SOC", Buffer32);
 964         break;
 965       default:
 966         UnicodeSPrint (Buffer, sizeof (Buffer), L"(%d) - Unknown SKU SOC", Buffer32);
 967         break;
 968     }
 969   HiiSetString(mHiiHandle,STRING_TOKEN(STR_PROCESSOR_SKU_VALUE), Buffer, NULL);
 970
 971 }
 972
 973
 974 EFI_STATUS
 975 SearchChildHandle(
 976   EFI_HANDLE Father,
 977   EFI_HANDLE *Child
 978   )
 979 {
 980   EFI_STATUS                                                 Status;
 981   UINTN                                                          HandleIndex;
 982   EFI_GUID                                                     **ProtocolGuidArray = NULL;
 983   UINTN                                                          ArrayCount;
 984   UINTN                                                          ProtocolIndex;
 985   UINTN                                                          OpenInfoCount;
 986   UINTN                                                          OpenInfoIndex;
 987   EFI_OPEN_PROTOCOL_INFORMATION_ENTRY  *OpenInfo = NULL;
 988   UINTN                                                          mHandleCount;
 989   EFI_HANDLE                                                 *mHandleBuffer= NULL;
 990
 991   //
 992   // Retrieve the list of all handles from the handle database
 993   //
 994   Status = gBS->LocateHandleBuffer (
 995                   AllHandles,
 996                   NULL,
 997                   NULL,
 998                   &mHandleCount,
 999                   &mHandleBuffer
1000                   );
1001
1002   for (HandleIndex = 0; HandleIndex < mHandleCount; HandleIndex++)
1003   {
1004     //
1005     // Retrieve the list of all the protocols on each handle
1006     //
1007     Status = gBS->ProtocolsPerHandle (
1008                     mHandleBuffer[HandleIndex],
1009                     &ProtocolGuidArray,
1010                     &ArrayCount
1011                     );
1012     if (!EFI_ERROR (Status))
1013     {
1014       for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++)
1015       {
1016         Status = gBS->OpenProtocolInformation (
1017                         mHandleBuffer[HandleIndex],
1018                         ProtocolGuidArray[ProtocolIndex],
1019                         &OpenInfo,
1020                         &OpenInfoCount
1021                         );
1022         if (!EFI_ERROR (Status))
1023         {
1024           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++)
1025           {
1026             if(OpenInfo[OpenInfoIndex].AgentHandle == Father)
1027             {
1028               if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) == EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER)
1029               {
1030                 *Child = mHandleBuffer[HandleIndex];
1031                   Status = EFI_SUCCESS;
1032                   goto TryReturn;
1033               }
1034             }
1035           }
1036            Status = EFI_NOT_FOUND;
1037         }
1038       }
1039       if(OpenInfo != NULL)
1040       {
1041         FreePool(OpenInfo);
1042          OpenInfo = NULL;
1043       }
1044     }
1045     FreePool (ProtocolGuidArray);
1046     ProtocolGuidArray = NULL;
1047   }
1048 TryReturn:
1049   if(OpenInfo != NULL)
1050   {
1051     FreePool (OpenInfo);
1052     OpenInfo = NULL;
1053   }
1054   if(ProtocolGuidArray != NULL)
1055   {
1056     FreePool(ProtocolGuidArray);
1057     ProtocolGuidArray = NULL;
1058   }
1059   if(mHandleBuffer != NULL)
1060   {
1061     FreePool (mHandleBuffer);
1062     mHandleBuffer = NULL;
1063   }
1064   return Status;
1065 }
1066
1067 EFI_STATUS
1068 JudgeHandleIsPCIDevice(
1069   EFI_HANDLE    Handle,
1070   UINT8            Device,
1071   UINT8            Funs
1072   )
1073 {
1074   EFI_STATUS  Status;
1075   EFI_DEVICE_PATH   *DPath;
1076
1077   Status = gBS->HandleProtocol (
1078                   Handle,
1079                   &gEfiDevicePathProtocolGuid,
1080                   (VOID **) &DPath
1081                   );
1082   if(!EFI_ERROR(Status))
1083   {
1084     while(!IsDevicePathEnd(DPath))
1085     {
1086       if((DPath->Type == HARDWARE_DEVICE_PATH) && (DPath->SubType == HW_PCI_DP))
1087       {
1088         PCI_DEVICE_PATH   *PCIPath;
1089
1090         PCIPath = (PCI_DEVICE_PATH*) DPath;
1091         DPath = NextDevicePathNode(DPath);
1092         if(IsDevicePathEnd(DPath) && (PCIPath->Device == Device) && (PCIPath->Function == Funs))
1093         {
1094           return EFI_SUCCESS;
1095         }
1096       }
1097       else
1098       {
1099         DPath = NextDevicePathNode(DPath);
1100       }
1101     }
1102   }
1103   return EFI_UNSUPPORTED;
1104 }
1105
1106 EFI_STATUS
1107 GetDriverName(
1108   EFI_HANDLE   Handle,
1109   CHAR16         *Name
1110   )
1111 {
1112   EFI_DRIVER_BINDING_PROTOCOL        *BindHandle = NULL;
1113   EFI_STATUS                                        Status;
1114   UINT32                                               Version;
1115   UINT16                                               *Ptr;
1116   Status = gBS->OpenProtocol(
1117                   Handle,
1118                   &gEfiDriverBindingProtocolGuid,
1119                   (VOID**)&BindHandle,
1120                   NULL,
1121                   NULL,
1122                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1123                   );
1124
1125   if (EFI_ERROR(Status))
1126   {
1127     return EFI_NOT_FOUND;
1128   }
1129
1130   Version = BindHandle->Version;
1131   Ptr = (UINT16*)&Version;
1132   UnicodeSPrint(Name, 40, L"%d.%d.%d", Version >> 24 , (Version >>16)& 0x0f ,*(Ptr));
1133
1134   return EFI_SUCCESS;
1135 }
1136
1137 EFI_STATUS
1138 GetGOPDriverName(
1139   CHAR16 *Name
1140   )
1141 {
1142   UINTN                         HandleCount;
1143   EFI_HANDLE                *Handles= NULL;
1144   UINTN                         Index;
1145   EFI_STATUS                Status;
1146   EFI_HANDLE                Child = 0;
1147
1148   Status = gBS->LocateHandleBuffer(
1149                               ByProtocol,
1150                               &gEfiDriverBindingProtocolGuid,
1151                               NULL,
1152                               &HandleCount,
1153                               &Handles
1154                   );
1155   for (Index = 0; Index < HandleCount ; Index++)
1156   {
1157     Status = SearchChildHandle(Handles[Index], &Child);
1158     if(!EFI_ERROR(Status))
1159     {
1160       Status = JudgeHandleIsPCIDevice(
1161                  Child,
1162                  0x02,
1163                  0x00
1164                  );
1165       if(!EFI_ERROR(Status))
1166       {
1167         return GetDriverName(Handles[Index], Name);
1168       }
1169     }
1170   }
1171   return EFI_UNSUPPORTED;
1172 }
1173
1174 EFI_STATUS
1175 UpdatePlatformInformation (
1176   )
1177 {
1178   UINT32                   MicroCodeVersion;
1179   CHAR16                   Buffer[40];
1180   UINT8                    IgdVBIOSRevH;
1181   UINT8                    IgdVBIOSRevL;
1182   UINT16                   EDX;
1183   EFI_IA32_REGISTER_SET    RegSet;
1184   EFI_LEGACY_BIOS_PROTOCOL *LegacyBios = NULL;
1185   EFI_STATUS               Status;
1186   UINT8                    CpuFlavor=0;
1187   EFI_PEI_HOB_POINTERS     GuidHob;
1188   UINTN                    NumHandles;
1189   EFI_HANDLE                        *HandleBuffer;
1190   UINTN                             Index;
1191   DXE_PCH_PLATFORM_POLICY_PROTOCOL  *PchPlatformPolicy;
1192   UINTN                             PciD31F0RegBase;
1193   UINT8                             count;
1194   UINT8                             Data8;
1195   UINT8                             PIDData8;
1196
1197   CHAR16                            Name[40];
1198   UINT32                            MrcVersion;
1199
1200   //
1201   // Get the HOB list.  If it is not present, then ASSERT.
1202   //
1203   GuidHob.Raw = GetHobList ();
1204   if (GuidHob.Raw != NULL) {
1205     if ((GuidHob.Raw = GetNextGuidHob (&gEfiPlatformInfoGuid, GuidHob.Raw)) != NULL) {
1206       mPlatformInfo = GET_GUID_HOB_DATA (GuidHob.Guid);
1207     }
1208   }
1209
1210   //
1211   //VBIOS version
1212   //
1213   Status = gBS->LocateProtocol(
1214                   &gEfiLegacyBiosProtocolGuid,
1215                   NULL,
1216                   (void **)&LegacyBios
1217                   );
1218   if (!EFI_ERROR (Status)) {
1219   RegSet.X.AX = 0x5f01;
1220   Status = LegacyBios->Int86 (LegacyBios, 0x10, &RegSet);
1221   ASSERT_EFI_ERROR(Status);
1222
1223   //
1224   // simulate AMI int15 (ax=5f01) handler
1225   // check NbInt15.asm in AMI code for asm edition
1226   //
1227   EDX = (UINT16)((RegSet.E.EBX >> 16) & 0xffff);
1228   IgdVBIOSRevH = (UINT8)(((EDX & 0x0F00) >> 4) | (EDX & 0x000F));
1229   IgdVBIOSRevL = (UINT8)(((RegSet.X.BX & 0x0F00) >> 4) | (RegSet.X.BX & 0x000F));
1230
1231   if (IgdVBIOSRevH==0 && IgdVBIOSRevL==0){
1232     HiiSetString(mHiiHandle, STRING_TOKEN(STR_CHIP_IGD_VBIOS_REV_VALUE), L"N/A", NULL);
1233   } else {
1234     UnicodeSPrint (Buffer, sizeof (Buffer), L"%02X%02X", IgdVBIOSRevH,IgdVBIOSRevL);
1235     HiiSetString(mHiiHandle, STRING_TOKEN(STR_CHIP_IGD_VBIOS_REV_VALUE), Buffer, NULL);
1236     }
1237   }
1238
1239   Status = GetGOPDriverName(Name);
1240
1241   if (!EFI_ERROR(Status))
1242   {
1243     HiiSetString(mHiiHandle, STRING_TOKEN(STR_GOP_VALUE), Name, NULL);
1244   }
1245
1246
1247   //
1248   // CpuFlavor
1249   // ISG-DC Tablet        000
1250   // VLV-QC Tablet        001
1251   // VLV-QC Desktop       010
1252   // VLV-QC Notebook      011
1253   //
1254   CpuFlavor = RShiftU64 (EfiReadMsr (MSR_IA32_PLATFORM_ID), 50) & 0x07;
1255
1256   switch(CpuFlavor){
1257     case 0x0:
1258       UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-DC Tablet", CpuFlavor);
1259       break;
1260     case 0x01:
1261       UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-QC Notebook", CpuFlavor);
1262       break;
1263     case 0x02:
1264       UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-QC Desktop", CpuFlavor);
1265       break;
1266     case 0x03:
1267       UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-QC Notebook", CpuFlavor);
1268       break;
1269     default:
1270       UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"Unknown CPU", CpuFlavor);
1271       break;
1272   }
1273   HiiSetString(mHiiHandle,STRING_TOKEN(STR_CPU_FLAVOR_VALUE), Buffer, NULL);
1274
1275   if ( NULL != mPlatformInfo) {
1276     //
1277     //BoardId
1278     //
1279     switch(mPlatformInfo->BoardId){
1280       case 0x2:
1281         UnicodeSPrint (Buffer, sizeof (Buffer), L"BAY LAKE RVP(%02x)", mPlatformInfo->BoardId);
1282         break;
1283
1284       case 0x4:
1285         UnicodeSPrint (Buffer, sizeof (Buffer), L"BAY LAKE FFRD(%02x)", mPlatformInfo->BoardId);
1286         break;
1287
1288       case 0x5:
1289         UnicodeSPrint (Buffer, sizeof (Buffer), L"BAY ROCK RVP DDR3L (%02x)", mPlatformInfo->BoardId);
1290         break;
1291
1292       case 0x20:
1293         UnicodeSPrint (Buffer, sizeof (Buffer), L"BAYLEY BAY (%02x)", mPlatformInfo->BoardId);
1294         break;
1295
1296       case 0x30:
1297         UnicodeSPrint (Buffer, sizeof (Buffer), L"BAKER SPORT (%02x)", mPlatformInfo->BoardId);
1298         break;
1299
1300       case 0x0:
1301         UnicodeSPrint (Buffer, sizeof (Buffer), L"ALPINE VALLEY (%x)", mPlatformInfo->BoardId);
1302         break;
1303
1304       case 0x3:
1305         UnicodeSPrint (Buffer, sizeof (Buffer), L"BAY LAKE FFD8 (%x)", mPlatformInfo->BoardId);
1306         break;
1307
1308       default:
1309         UnicodeSPrint (Buffer, sizeof (Buffer), L"Unknown BOARD (%02x)", mPlatformInfo->BoardId);
1310         break;
1311     }
1312     HiiSetString(mHiiHandle,STRING_TOKEN(STR_BOARD_ID_VALUE), Buffer, NULL);
1313
1314
1315     //
1316     // Get Board FAB ID Info from protocol, update into the NVS area.
1317     // bit0~bit3 are for Fab ID, 0x0F means unknow FAB.
1318     //
1319     if(mPlatformInfo->BoardRev == 0x0F) {
1320       UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", L"Unknown FAB");
1321       HiiSetString(mHiiHandle,STRING_TOKEN(STR_FAB_ID_VALUE), Buffer, NULL);
1322     } else {
1323       UnicodeSPrint (Buffer, sizeof (Buffer), L"%2x", mPlatformInfo->BoardRev);
1324       HiiSetString(mHiiHandle,STRING_TOKEN(STR_FAB_ID_VALUE), Buffer, NULL);
1325     }
1326   }
1327
1328   //
1329   //Update MRC Version
1330   //
1331   MrcVersion = 0x00000000;
1332   MrcVersion &= 0xffff;
1333   Index = EfiValueToString (Buffer, MrcVersion/100, PREFIX_ZERO, 0);
1334   StrCat (Buffer, L".");
1335   EfiValueToString (Buffer + Index + 1, (MrcVersion%100)/10, PREFIX_ZERO, 0);
1336   EfiValueToString (Buffer + Index + 2, (MrcVersion%100)%10, PREFIX_ZERO, 0);
1337   HiiSetString(mHiiHandle,STRING_TOKEN(STR_MRC_VERSION_VALUE), Buffer, NULL);
1338
1339   //
1340   //Update Soc Version
1341   //
1342
1343   //
1344   // Retrieve all instances of PCH Platform Policy protocol
1345   //
1346   Status = gBS->LocateHandleBuffer (
1347                   ByProtocol,
1348                   &gDxePchPlatformPolicyProtocolGuid,
1349                   NULL,
1350                   &NumHandles,
1351                   &HandleBuffer
1352                   );
1353   if (!EFI_ERROR (Status)) {
1354     //
1355     // Find the matching PCH Policy protocol
1356     //
1357     for (Index = 0; Index < NumHandles; Index++) {
1358       Status = gBS->HandleProtocol (
1359                       HandleBuffer[Index],
1360                       &gDxePchPlatformPolicyProtocolGuid,
1361                       (void **)&PchPlatformPolicy
1362                       );
1363       if (!EFI_ERROR (Status)) {
1364         PciD31F0RegBase = MmPciAddress (
1365                             0,
1366                             PchPlatformPolicy->BusNumber,
1367                             PCI_DEVICE_NUMBER_PCH_LPC,
1368                             PCI_FUNCTION_NUMBER_PCH_LPC,
1369                             0
1370                             );
1371
1372          Data8 = MmioRead8 (PciD31F0RegBase + R_PCH_LPC_RID_CC);
1373          count = ARRAY_SIZE (SBRevisionTable);
1374          for (Index = 0; Index < count; Index++) {
1375            if(Data8 == SBRevisionTable[Index].RevId) {
1376               UnicodeSPrint (Buffer, sizeof (Buffer), L"%02x %a", Data8, SBRevisionTable[Index].String);
1377               HiiSetString(mHiiHandle,STRING_TOKEN(STR_SOC_VALUE), Buffer, NULL);
1378              break;
1379            }
1380          }
1381         break;
1382       }
1383     }
1384   }
1385
1386   //
1387   // Microcode Revision
1388   //
1389   EfiWriteMsr (EFI_MSR_IA32_BIOS_SIGN_ID, 0);
1390   EfiCpuid (EFI_CPUID_VERSION_INFO, NULL);
1391   MicroCodeVersion = (UINT32) RShiftU64 (EfiReadMsr (EFI_MSR_IA32_BIOS_SIGN_ID), 32);
1392   UnicodeSPrint (Buffer, sizeof (Buffer), L"%x", MicroCodeVersion);
1393   HiiSetString(mHiiHandle,STRING_TOKEN(STR_PROCESSOR_MICROCODE_VALUE), Buffer, NULL);
1394
1395   //
1396   // Punit Version
1397   //
1398   Data8 = 0;
1399   UnicodeSPrint (Buffer, sizeof (Buffer), L"0x%x", Data8);
1400   HiiSetString(mHiiHandle,STRING_TOKEN(STR_PUNIT_FW_VALUE), Buffer, NULL);
1401
1402   //
1403   //  PMC Version
1404   //
1405   Data8 = (UINT8)((MmioRead32 (PMC_BASE_ADDRESS + R_PCH_PMC_PRSTS)>>16)&0x00FF);
1406   PIDData8 = (UINT8)((MmioRead32 (PMC_BASE_ADDRESS + R_PCH_PMC_PRSTS)>>24)&0x00FF);
1407   UnicodeSPrint (Buffer, sizeof (Buffer), L"0x%X_%X",PIDData8, Data8);
1408   HiiSetString(mHiiHandle,STRING_TOKEN(STR_PMC_FW_VALUE), Buffer, NULL);
1409
1410   return EFI_SUCCESS;
1411 }
1412
1413 /**
1414
1415   Update SATA Drivesize Strings for Setup and Boot order
1416
1417   @param NewString - pointer to string.
1418   @param DeviceSpeed - speed of drive.
1419
1420 **/
1421 VOID
1422 GetDeviceSpeedString (
1423   CHAR16                      *NewString,
1424   IN UINTN                    DeviceSpeed
1425   )
1426 {
1427   if (DeviceSpeed == 0x01) {
1428     StrCat (NewString, L"1.5Gb/s");
1429   } else if (DeviceSpeed == 0x02) {
1430     StrCat (NewString, L"3.0Gb/s");
1431   } else if (DeviceSpeed == 0x03) {
1432     StrCat (NewString, L"6.0Gb/s");
1433   } else if (DeviceSpeed == 0x0) {
1434
1435   }
1436 }
1437
1438 UINT8
1439 GetChipsetSataPortSpeed (
1440   UINTN PortNum
1441   )
1442 {
1443   UINT32                      DeviceSpeed;
1444   UINT8                       DeviceConfigStatus;
1445   UINT32                      IdeAhciBar;
1446   EFI_PHYSICAL_ADDRESS        MemBaseAddress = 0;
1447   UINT8                       FunNum;
1448
1449   DeviceSpeed = 0x01; // generation 1
1450
1451
1452   //
1453   // Allocate the AHCI BAR
1454   //
1455     FunNum = PCI_FUNCTION_NUMBER_PCH_SATA;
1456     MemBaseAddress = 0x0ffffffff;
1457     gDS->AllocateMemorySpace (
1458            EfiGcdAllocateMaxAddressSearchBottomUp,
1459            EfiGcdMemoryTypeMemoryMappedIo,
1460            N_PCH_SATA_ABAR_ALIGNMENT,  // 2^11: 2K Alignment
1461            V_PCH_SATA_ABAR_LENGTH,     // 2K Length
1462            &MemBaseAddress,
1463            mImageHandle,
1464            NULL
1465            );
1466     IdeAhciBar = MmioRead32 (
1467                    MmPciAddress (
1468                                      0,
1469                      0,
1470                      PCI_DEVICE_NUMBER_PCH_SATA,
1471                      FunNum,
1472                      R_PCH_SATA_ABAR
1473                      )
1474                    );
1475     IdeAhciBar &= 0xFFFFF800;
1476     DeviceConfigStatus = 0;
1477     if (IdeAhciBar == 0) {
1478       DeviceConfigStatus = 1;
1479       IdeAhciBar = (UINT32)MemBaseAddress;
1480       MmioWrite32 (
1481         MmPciAddress (0, 0, PCI_DEVICE_NUMBER_PCH_SATA, FunNum, R_PCH_SATA_ABAR),
1482         IdeAhciBar
1483         );
1484       MmioOr16 (
1485         MmPciAddress (0, 0, PCI_DEVICE_NUMBER_PCH_SATA, FunNum, R_PCH_SATA_COMMAND),
1486         B_PCH_SATA_COMMAND_MSE
1487         );
1488     }
1489
1490     if (mSystemConfiguration.SataType == PCH_SATA_MODE_IDE){
1491       //
1492       // Program the "Ports Implemented Register"
1493       //
1494       MmioAndThenOr32 (IdeAhciBar + R_PCH_SATA_AHCI_PI, (UINT32)~(B_PCH_SATA_PORT0_IMPLEMENTED + B_PCH_SATA_PORT1_IMPLEMENTED), (UINT32)(B_PCH_SATA_PORT0_IMPLEMENTED + B_PCH_SATA_PORT1_IMPLEMENTED));
1495     }
1496
1497     switch (PortNum)
1498     {
1499       case 0:
1500         DeviceSpeed = *(volatile UINT32 *)(UINTN)(IdeAhciBar + R_PCH_SATA_AHCI_P0SSTS);
1501         break;
1502       case 1:
1503         DeviceSpeed = *(volatile UINT32 *)(UINTN)(IdeAhciBar + R_PCH_SATA_AHCI_P1SSTS);
1504         break;
1505     }
1506
1507     if (MemBaseAddress) {
1508       gDS->FreeMemorySpace (
1509              MemBaseAddress,
1510              V_PCH_SATA_ABAR_LENGTH
1511              );
1512     }
1513
1514   if (DeviceConfigStatus) {
1515     IdeAhciBar = 0;
1516     MmioWrite32 (
1517       MmPciAddress (0, 0, PCI_DEVICE_NUMBER_PCH_SATA, FunNum, R_PCH_SATA_ABAR),
1518       IdeAhciBar
1519       );
1520   }
1521
1522   DeviceSpeed = (UINT8)((DeviceSpeed >> 4) & 0x0F);
1523
1524   return (UINT8)DeviceSpeed;
1525 }
1526
1527 /**
1528
1529   IDE data filter function.
1530
1531 **/
1532 void
1533 IdeDataFilter (void)
1534 {
1535   EFI_STATUS                  Status;
1536   UINTN                       HandleCount;
1537   EFI_HANDLE                  *HandleBuffer;
1538   EFI_DISK_INFO_PROTOCOL      *DiskInfo;
1539   EFI_DEVICE_PATH_PROTOCOL    *DevicePath, *DevicePathNode;
1540   PCI_DEVICE_PATH             *PciDevicePath;
1541   UINTN                       Index;
1542   UINT8                       Index1;
1543   UINT32                      BufferSize;
1544   UINT32                      DriveSize;
1545   UINT32                      IdeChannel;
1546   UINT32                      IdeDevice;
1547   EFI_ATA_IDENTIFY_DATA       *IdentifyDriveInfo;
1548   CHAR16                      *NewString;
1549   CHAR16                      SizeString[20];
1550   STRING_REF                  NameToUpdate;
1551   CHAR8                       StringBuffer[0x100];
1552   UINT32                      DeviceSpeed;
1553   UINTN                       PortNumber;
1554
1555   //
1556   // Assume no line strings is longer than 256 bytes.
1557   //
1558   NewString = AllocateZeroPool (0x100);
1559   PciDevicePath = NULL;
1560
1561   //
1562   // Fill IDE Infomation
1563   //
1564   Status = gBS->LocateHandleBuffer (
1565                   ByProtocol,
1566                   &gEfiDiskInfoProtocolGuid,
1567                   NULL,
1568                   &HandleCount,
1569                   &HandleBuffer
1570                                   );
1571
1572   if (EFI_ERROR (Status)) {
1573     return;
1574   }
1575
1576   for (Index = 0; Index < HandleCount; Index++) {
1577
1578     Status = gBS->HandleProtocol (
1579                     HandleBuffer[Index],
1580                     &gEfiDevicePathProtocolGuid,
1581                     (VOID*)&DevicePath
1582                                     );
1583     ASSERT_EFI_ERROR (Status);
1584
1585     DevicePathNode = DevicePath;
1586     while (!IsDevicePathEnd (DevicePathNode) ) {
1587       if  ((DevicePathType (DevicePathNode) == HARDWARE_DEVICE_PATH) &&
1588            ( DevicePathSubType (DevicePathNode) == HW_PCI_DP)) {
1589         PciDevicePath = (PCI_DEVICE_PATH *) DevicePathNode;
1590         break;
1591       }
1592       DevicePathNode    = NextDevicePathNode (DevicePathNode);
1593     }
1594
1595     if (PciDevicePath == NULL) {
1596       continue;
1597     }
1598
1599     //
1600     // Check for onboard IDE
1601     //
1602     if (PciDevicePath->Device== PCI_DEVICE_NUMBER_PCH_SATA) {
1603       Status = gBS->HandleProtocol (
1604                           HandleBuffer[Index],
1605                                           &gEfiDiskInfoProtocolGuid,
1606                                           (void **)&DiskInfo
1607                                           );
1608       ASSERT_EFI_ERROR (Status);
1609
1610       Status = DiskInfo->WhichIde (
1611                                DiskInfo,
1612                            &IdeChannel,
1613                            &IdeDevice
1614                                                    );
1615       ASSERT_EFI_ERROR (Status);
1616
1617       IdentifyDriveInfo = AllocatePool (sizeof(EFI_ATA_IDENTIFY_DATA));
1618
1619       BufferSize = sizeof(EFI_ATA_IDENTIFY_DATA);
1620       Status = DiskInfo->Identify (
1621                                DiskInfo,
1622                            IdentifyDriveInfo,
1623                            &BufferSize
1624                            );
1625       ASSERT_EFI_ERROR(Status);
1626
1627       //
1628       // Onboard SATA Devices
1629       //
1630       if (PciDevicePath->Function == PCI_FUNCTION_NUMBER_PCH_SATA) {
1631         if (IdeChannel == 0 && IdeDevice == 0) {
1632           NameToUpdate = (STRING_REF)STR_SATA0_NAME;
1633         } else if (IdeChannel == 1 && IdeDevice == 0) {
1634           NameToUpdate = (STRING_REF)STR_SATA1_NAME;
1635         } else {
1636           continue;
1637         }
1638       } else {
1639         continue;
1640       }
1641
1642       ZeroMem(StringBuffer, sizeof(StringBuffer));
1643       CopyMem(
1644         StringBuffer,
1645         (CHAR8 *)&IdentifyDriveInfo->ModelName,
1646         sizeof(IdentifyDriveInfo->ModelName)
1647         );
1648       SwapEntries(StringBuffer);
1649       AsciiToUnicode(StringBuffer, NewString);
1650
1651           //
1652       // Chap it off after 16 characters
1653           //
1654       NewString[16] = 0;
1655
1656       //
1657       // For HardDisk append the size. Otherwise display atapi
1658       //
1659       if ((IdentifyDriveInfo->config & 0x8000) == 00) {
1660         //
1661         // 48 bit address feature set is supported, get maximum capacity
1662         //
1663         if ((IdentifyDriveInfo->command_set_supported_83 & 0x0400) == 0) {
1664         DriveSize = (((((IdentifyDriveInfo->user_addressable_sectors_hi << 16) +
1665                       IdentifyDriveInfo->user_addressable_sectors_lo) / 1000) * 512) / 1000);
1666         } else {
1667           DriveSize    = IdentifyDriveInfo->maximum_lba_for_48bit_addressing[0];
1668           for (Index1 = 1; Index1 < 4; Index1++) {
1669             //
1670             // Lower byte goes first: word[100] is the lowest word, word[103] is highest
1671             //
1672             DriveSize |= LShiftU64(IdentifyDriveInfo->maximum_lba_for_48bit_addressing[Index1], 16 * Index1);
1673           }
1674           DriveSize = (UINT32) DivU64x32(MultU64x32(DivU64x32(DriveSize, 1000), 512), 1000);
1675         }
1676
1677         StrCat (NewString, L"(");
1678         EfiValueToString (SizeString, DriveSize/1000, PREFIX_BLANK, 0);
1679         StrCat (NewString, SizeString);
1680         StrCat (NewString, L".");
1681         EfiValueToString (SizeString, (DriveSize%1000)/100, PREFIX_BLANK, 0);
1682         StrCat (NewString, SizeString);
1683         StrCat (NewString, L"GB");
1684       } else {
1685         StrCat (NewString, L"(ATAPI");
1686       }
1687
1688       //
1689       // Update SPEED.
1690       //
1691       PortNumber = (IdeDevice << 1) + IdeChannel;
1692       DeviceSpeed = GetChipsetSataPortSpeed(PortNumber);
1693
1694       if (DeviceSpeed) {
1695         StrCat (NewString, L"-");
1696         GetDeviceSpeedString( NewString, DeviceSpeed);
1697       }
1698
1699       StrCat (NewString, L")");
1700
1701       HiiSetString(mHiiHandle, NameToUpdate, NewString, NULL);
1702
1703     }
1704   }
1705
1706   if (HandleBuffer != NULL) {
1707     gBS->FreePool (HandleBuffer);
1708   }
1709
1710   gBS->FreePool(NewString);
1711
1712   return;
1713 }
1714
1715
1716 VOID
1717 EFIAPI
1718 SetupInfo (void)
1719 {
1720   EFI_STATUS                  Status;
1721   UINTN                       VarSize;
1722   EFI_PEI_HOB_POINTERS        GuidHob;
1723
1724   if (mSetupInfoDone) {
1725       return;
1726   }
1727
1728   VarSize = sizeof(SYSTEM_CONFIGURATION);
1729   Status = gRT->GetVariable(
1730                   NORMAL_SETUP_NAME,
1731                   &gEfiNormalSetupGuid,
1732                   NULL,
1733                   &VarSize,
1734                   &mSystemConfiguration
1735                                   );
1736
1737   if (EFI_ERROR (Status) || VarSize != sizeof(SYSTEM_CONFIGURATION)) {
1738     //The setup variable is corrupted
1739     VarSize = sizeof(SYSTEM_CONFIGURATION);
1740     Status = gRT->GetVariable(
1741               L"SetupRecovery",
1742               &gEfiNormalSetupGuid,
1743               NULL,
1744               &VarSize,
1745               &mSystemConfiguration
1746               );
1747     ASSERT_EFI_ERROR (Status);
1748   }
1749
1750   //
1751   // Update HOB variable for PCI resource information
1752   // Get the HOB list.  If it is not present, then ASSERT.
1753   //
1754   GuidHob.Raw = GetHobList ();
1755   if (GuidHob.Raw != NULL) {
1756     if ((GuidHob.Raw = GetNextGuidHob (&gEfiPlatformInfoGuid, GuidHob.Raw)) != NULL) {
1757       mPlatformInfo = GET_GUID_HOB_DATA (GuidHob.Guid);
1758     }
1759   }
1760
1761
1762   PrepareSetupInformation();
1763   UpdateAdditionalInformation ();
1764   UpdatePlatformInformation();
1765   UpdateCPUInformation();
1766   IdeDataFilter();
1767   mSetupInfoDone = TRUE;
1768
1769   return;
1770 }
1771
1772
1773 #define EFI_SECURE_BOOT_MODE_NAME                   L"SecureBoot"
1774
1775 VOID
1776 CheckSystemConfigLoad(SYSTEM_CONFIGURATION *SystemConfigPtr)
1777 {
1778   EFI_STATUS              Status;
1779   UINT8                   SecureBoot;
1780   UINTN                   DataSize;
1781
1782
1783   DataSize = sizeof(SecureBoot);
1784   Status = gRT->GetVariable (
1785                   EFI_SECURE_BOOT_MODE_NAME,
1786                   &gEfiGlobalVariableGuid,
1787                   NULL,
1788                   &DataSize,
1789                   &SecureBoot
1790                   );
1791
1792   if (EFI_ERROR(Status)) {
1793     SystemConfigPtr->SecureBoot = 0;
1794   } else {
1795     SystemConfigPtr->SecureBoot = SecureBoot;
1796   }
1797 }
1798
1799
1800 //
1801 // "SecureBootEnable" variable for the Secure boot feature enable/disable.
1802 //
1803 #define EFI_SECURE_BOOT_ENABLE_NAME      L"SecureBootEnable"
1804 extern EFI_GUID gEfiSecureBootEnableDisableGuid;
1805
1806
1807 VOID
1808 CheckSystemConfigSave(SYSTEM_CONFIGURATION *SystemConfigPtr)
1809 {
1810   EFI_STATUS              Status;
1811   UINT8                   SecureBootCfg;
1812   BOOLEAN                 SecureBootNotFound;
1813   UINTN                   DataSize;
1814
1815
1816     //
1817     // Secure Boot configuration changes
1818         //
1819     DataSize = sizeof(SecureBootCfg);
1820     SecureBootNotFound = FALSE;
1821     Status = gRT->GetVariable (
1822                     EFI_SECURE_BOOT_ENABLE_NAME,
1823                     &gEfiSecureBootEnableDisableGuid,
1824                     NULL,
1825                     &DataSize,
1826                     &SecureBootCfg
1827                     );
1828
1829     if (EFI_ERROR(Status)) {
1830       SecureBootNotFound = TRUE;
1831     }
1832     if (SecureBootNotFound) {
1833       Status = gRT->GetVariable (
1834                       EFI_SECURE_BOOT_ENABLE_NAME,
1835                       &gEfiSecureBootEnableDisableGuid,
1836                       NULL,
1837                       &DataSize,
1838                       &SecureBootCfg
1839                       );
1840       ASSERT_EFI_ERROR(Status);
1841     }
1842     if ((SecureBootCfg) != SystemConfigPtr->SecureBoot) {
1843       SecureBootCfg = !SecureBootCfg;
1844       Status = gRT->SetVariable (
1845                       EFI_SECURE_BOOT_ENABLE_NAME,
1846                       &gEfiSecureBootEnableDisableGuid,
1847                       EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
1848                       sizeof (UINT8),
1849                       &SecureBootCfg
1850                       );
1851     }
1852
1853 }
1854
1855 VOID
1856 ConfirmSecureBootTest()
1857 {
1858
1859 }
1860