Vlv2TbltDevicePkg/SmBiosMiscDxe/MiscOemType0x94Function.c

   1 /*++
   2
   3 Copyright (c) 1999  - 2014, Intel Corporation.  All rights reserved.
   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
  16 Module Name:
  17
  18   MiscOemType0x94Function.c
  19
  20 Abstract:
  21
  22   The function that processes the Smbios data type 0x94.
  23
  24 --*/
  25
  26 #include "CommonHeader.h"
  27
  28 #include "MiscSubclassDriver.h"
  29 #include <Protocol/DataHub.h>
  30 #include <Library/HiiLib.h>
  31 #include <Protocol/CpuIo2.h>
  32 #include <Library/PrintLib.h>
  33 #include <Protocol/PciRootBridgeIo.h>
  34 #include <Protocol/SimpleNetwork.h>
  35 #include <Protocol/DevicePath.h>
  36 #include <Protocol/DiskInfo.h>
  37 #include <Protocol/IdeControllerInit.h>
  38 #include <Protocol/MpService.h>
  39 #include <Protocol/PchPlatformPolicy.h>
  40 #include <Protocol/CpuIo2.h>
  41 #include <Protocol/I2cBus.h>
  42
  43 #include <Library/IoLib.h>
  44 #include <Library/I2CLib.h>
  45 #include <Library/CpuIA32.h>
  46 #include <Library/UefiRuntimeServicesTableLib.h>
  47 #include <Guid/PlatformInfo.h>
  48 #include <Guid/SetupVariable.h>
  49 #include <Guid/Vlv2Variable.h>
  50
  51 #include "Valleyview.h"
  52 #include "VlvAccess.h"
  53 #include "PchAccess.h"
  54 #include "SetupMode.h"
  55 #include "PchCommonDefinitions.h"
  56 #include <PlatformBaseAddresses.h>
  57
  58 typedef struct {
  59   UINT8 RevId;
  60   CHAR8 String[16];
  61 } SB_REV;
  62
  63 //
  64 // Silicon Steppings
  65 //
  66 SB_REV  SBRevisionTable[] = {
  67   {V_PCH_LPC_RID_0, "(A0 Stepping)"},
  68   {V_PCH_LPC_RID_1, "(A0 Stepping)"},
  69   {V_PCH_LPC_RID_2, "(A1 Stepping)"},
  70   {V_PCH_LPC_RID_3, "(A1 Stepping)"},
  71   {V_PCH_LPC_RID_4, "(B0 Stepping)"},
  72   {V_PCH_LPC_RID_5, "(B0 Stepping)"},
  73   {V_PCH_LPC_RID_6, "(B1 Stepping)"},
  74   {V_PCH_LPC_RID_7, "(B1 Stepping)"},
  75   {V_PCH_LPC_RID_8, "(B2 Stepping)"},
  76   {V_PCH_LPC_RID_9, "(B2 Stepping)"},
  77   {V_PCH_LPC_RID_A, "(B3 Stepping)"},
  78   {V_PCH_LPC_RID_B, "(B3 Stepping)"}
  79 };
  80
  81 #define LEFT_JUSTIFY  0x01
  82 #define PREFIX_SIGN   0x02
  83 #define PREFIX_BLANK  0x04
  84 #define COMMA_TYPE    0x08
  85 #define LONG_TYPE     0x10
  86 #define PREFIX_ZERO   0x20
  87
  88 #define ICH_REG_REV                 0x08
  89 #define MSR_IA32_PLATFORM_ID        0x17
  90 #define CHARACTER_NUMBER_FOR_VALUE  30
  91
  92
  93 UINT8  ReadBuffer[20];  //Version report length
  94 UINT8  WriteBuffer[22] = {0x40,0x01,0x14,0x00,0x06,0x51,0x02,0x07,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //Version request
  95
  96 /**
  97
  98   VSPrint worker function that prints a Value as a decimal number in Buffer
  99
 100   @param Buffer  Location to place ascii decimal number string of Value.
 101   @param Value   Decimal value to convert to a string in Buffer.
 102   @param Flags   Flags to use in printing decimal string, see file header for details.
 103   @param Width   Width of hex value.
 104
 105   @retval Number of characters printed.
 106
 107 **/
 108 UINTN
 109 EfiValueToString (
 110   IN  OUT CHAR16  *Buffer,
 111   IN  INT64       Value,
 112   IN  UINTN       Flags,
 113   IN  UINTN       Width
 114   )
 115 {
 116   CHAR16    TempBuffer[CHARACTER_NUMBER_FOR_VALUE];
 117   CHAR16    *TempStr;
 118   CHAR16    *BufferPtr;
 119   UINTN     Count;
 120   UINTN     ValueCharNum;
 121   UINTN     Remainder;
 122   CHAR16    Prefix;
 123   UINTN     Index;
 124   BOOLEAN   ValueIsNegative;
 125   UINT64    TempValue;
 126
 127   TempStr         = TempBuffer;
 128   BufferPtr       = Buffer;
 129   Count           = 0;
 130   ValueCharNum    = 0;
 131   ValueIsNegative = FALSE;
 132
 133   if (Width > CHARACTER_NUMBER_FOR_VALUE - 1) {
 134     Width = CHARACTER_NUMBER_FOR_VALUE - 1;
 135   }
 136
 137   if (Value < 0) {
 138     Value           = -Value;
 139     ValueIsNegative = TRUE;
 140   }
 141
 142   do {
 143     TempValue = Value;
 144     Value = (INT64)DivU64x32 ((UINT64)Value, 10);
 145     Remainder = (UINTN)((UINT64)TempValue - 10 * Value);
 146     *(TempStr++) = (CHAR16)(Remainder + '0');
 147     ValueCharNum++;
 148     Count++;
 149     if ((Flags & COMMA_TYPE) == COMMA_TYPE) {
 150       if (ValueCharNum % 3 == 0 && Value != 0) {
 151         *(TempStr++) = ',';
 152         Count++;
 153       }
 154     }
 155   } while (Value != 0);
 156
 157   if (ValueIsNegative) {
 158     *(TempStr++)    = '-';
 159     Count++;
 160   }
 161
 162   if ((Flags & PREFIX_ZERO) && !ValueIsNegative) {
 163     Prefix = '0';
 164   } else {
 165     Prefix = ' ';
 166   }
 167
 168   Index = Count;
 169   if (!(Flags & LEFT_JUSTIFY)) {
 170     for (; Index < Width; Index++) {
 171       *(TempStr++) = Prefix;
 172     }
 173   }
 174
 175   //
 176   // Reverse temp string into Buffer.
 177   //
 178   if (Width > 0 && (UINTN) (TempStr - TempBuffer) > Width) {
 179     TempStr = TempBuffer + Width;
 180   }
 181   Index = 0;
 182   while (TempStr != TempBuffer) {
 183     *(BufferPtr++) = *(--TempStr);
 184     Index++;
 185   }
 186
 187   *BufferPtr = 0;
 188   return Index;
 189 }
 190
 191 static CHAR16 mHexStr[] = { L'0', L'1', L'2', L'3', L'4', L'5', L'6', L'7',
 192                             L'8', L'9', L'A', L'B', L'C', L'D', L'E', L'F' };
 193 /**
 194   VSPrint worker function that prints a Value as a hex number in Buffer
 195
 196   @param Buffer   Location to place ascii hex string of Value.
 197   @param Value    Hex value to convert to a string in Buffer.
 198   @param Flags    Flags to use in printing Hex string, see file header for details.
 199   @param Width    Width of hex value.
 200
 201   @retval Number of characters printed.
 202
 203 **/
 204 UINTN
 205 EfiValueToHexStr (
 206   IN  OUT CHAR16  *Buffer,
 207   IN  UINT64      Value,
 208   IN  UINTN       Flags,
 209   IN  UINTN       Width
 210   )
 211 {
 212   CHAR16  TempBuffer[CHARACTER_NUMBER_FOR_VALUE];
 213   CHAR16  *TempStr;
 214   CHAR16  Prefix;
 215   CHAR16  *BufferPtr;
 216   UINTN   Count;
 217   UINTN   Index;
 218
 219   TempStr   = TempBuffer;
 220   BufferPtr = Buffer;
 221
 222   //
 223   // Count starts at one since we will null terminate. Each iteration of the
 224   // loop picks off one nibble. Oh yea TempStr ends up backwards
 225   //
 226   Count = 0;
 227
 228   if (Width > CHARACTER_NUMBER_FOR_VALUE - 1) {
 229     Width = CHARACTER_NUMBER_FOR_VALUE - 1;
 230   }
 231
 232   do {
 233     Index = ((UINTN)Value & 0xf);
 234     *(TempStr++) = mHexStr[Index];
 235     Value = RShiftU64 (Value, 4);
 236     Count++;
 237   } while (Value != 0);
 238
 239   if (Flags & PREFIX_ZERO) {
 240     Prefix = '0';
 241   } else {
 242     Prefix = ' ';
 243   }
 244
 245   Index = Count;
 246   if (!(Flags & LEFT_JUSTIFY)) {
 247     for (; Index < Width; Index++) {
 248       *(TempStr++) = Prefix;
 249     }
 250   }
 251
 252   //
 253   // Reverse temp string into Buffer.
 254   //
 255   if (Width > 0 && (UINTN) (TempStr - TempBuffer) > Width) {
 256     TempStr = TempBuffer + Width;
 257   }
 258   Index = 0;
 259   while (TempStr != TempBuffer) {
 260     *(BufferPtr++) = *(--TempStr);
 261     Index++;
 262   }
 263
 264   *BufferPtr = 0;
 265   return Index;
 266 }
 267
 268 /**
 269   Converts MAC address to Unicode string.
 270   The value is 64-bit and the resulting string will be 12
 271   digit hex number in pairs of digits separated by dashes.
 272
 273   @param String - string that will contain the value
 274   @param Val    - value to convert
 275
 276 **/
 277 CHAR16 *
 278 StrMacToString (
 279   OUT CHAR16              *String,
 280   IN  EFI_MAC_ADDRESS     *MacAddr,
 281   IN  UINT32              AddrSize
 282   )
 283 {
 284   UINT32  i;
 285
 286   for (i = 0; i < AddrSize; i++) {
 287
 288     EfiValueToHexStr (
 289       &String[2 * i],
 290       MacAddr->Addr[i] & 0xFF,
 291       PREFIX_ZERO,
 292       2
 293       );
 294   }
 295
 296   //
 297   // Terminate the string.
 298   //
 299   String[2 * AddrSize] = L'\0';
 300
 301   return String;
 302 }
 303
 304
 305
 306 EFI_STATUS
 307 TJudgeHandleIsPCIDevice(
 308   EFI_HANDLE    Handle,
 309   UINT8            Device,
 310   UINT8            Funs
 311 )
 312 {
 313   EFI_STATUS  Status;
 314   EFI_DEVICE_PATH   *DPath;
 315   EFI_DEVICE_PATH   *DevicePath;
 316
 317   Status = gBS->HandleProtocol (
 318                   Handle,
 319                   &gEfiDevicePathProtocolGuid,
 320                   (VOID **) &DPath
 321                   );
 322   if(!EFI_ERROR(Status))
 323   {
 324     DevicePath = DPath;
 325     while(!IsDevicePathEnd(DPath))
 326     {
 327       if((DPath->Type == HARDWARE_DEVICE_PATH) && (DPath->SubType == HW_PCI_DP))
 328       {
 329         PCI_DEVICE_PATH   *PCIPath;
 330
 331         PCIPath = (PCI_DEVICE_PATH*) DPath;
 332         DPath = NextDevicePathNode(DPath);
 333         if(IsDevicePathEnd(DPath) && (PCIPath->Device == Device) && (PCIPath->Function == Funs))
 334         {
 335           return EFI_SUCCESS;
 336         }
 337       }
 338       else
 339       {
 340         DPath = NextDevicePathNode(DPath);
 341       }
 342     }
 343   }
 344   return EFI_UNSUPPORTED;
 345 }
 346
 347 EFI_STATUS
 348 TSearchChildHandle(
 349   EFI_HANDLE Father,
 350   EFI_HANDLE *Child
 351   )
 352 {
 353   EFI_STATUS                                                 Status;
 354   UINTN                                                          HandleIndex;
 355   EFI_GUID                                                     **ProtocolGuidArray = NULL;
 356   UINTN                                                          ArrayCount;
 357   UINTN                                                          ProtocolIndex;
 358   UINTN                                                          OpenInfoCount;
 359   UINTN                                                          OpenInfoIndex;
 360   EFI_OPEN_PROTOCOL_INFORMATION_ENTRY  *OpenInfo = NULL;
 361   UINTN                                                          mHandleCount;
 362   EFI_HANDLE                                                 *mHandleBuffer= NULL;
 363
 364   //
 365   // Retrieve the list of all handles from the handle database
 366   //
 367   Status = gBS->LocateHandleBuffer (
 368                   AllHandles,
 369                   NULL,
 370                   NULL,
 371                   &mHandleCount,
 372                   &mHandleBuffer
 373                   );
 374
 375   for (HandleIndex = 0; HandleIndex < mHandleCount; HandleIndex++)
 376   {
 377     //
 378     // Retrieve the list of all the protocols on each handle
 379     //
 380     Status = gBS->ProtocolsPerHandle (
 381                     mHandleBuffer[HandleIndex],
 382                     &ProtocolGuidArray,
 383                     &ArrayCount
 384                     );
 385     if (!EFI_ERROR (Status))
 386     {
 387       for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++)
 388       {
 389         Status = gBS->OpenProtocolInformation (
 390                         mHandleBuffer[HandleIndex],
 391                         ProtocolGuidArray[ProtocolIndex],
 392                         &OpenInfo,
 393                         &OpenInfoCount
 394                         );
 395         if (!EFI_ERROR (Status))
 396         {
 397           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++)
 398           {
 399             if(OpenInfo[OpenInfoIndex].AgentHandle == Father)
 400             {
 401               if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) == EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER)
 402               {
 403                 *Child = mHandleBuffer[HandleIndex];
 404                   Status = EFI_SUCCESS;
 405                   goto TryReturn;
 406               }
 407             }
 408           }
 409            Status = EFI_NOT_FOUND;
 410         }
 411       }
 412       if(OpenInfo != NULL)
 413       {
 414         FreePool(OpenInfo);
 415          OpenInfo = NULL;
 416       }
 417     }
 418     FreePool (ProtocolGuidArray);
 419     ProtocolGuidArray = NULL;
 420   }
 421 TryReturn:
 422   if(OpenInfo != NULL)
 423   {
 424     FreePool (OpenInfo);
 425     OpenInfo = NULL;
 426   }
 427   if(ProtocolGuidArray != NULL)
 428   {
 429     FreePool(ProtocolGuidArray);
 430     ProtocolGuidArray = NULL;
 431   }
 432   if(mHandleBuffer != NULL)
 433   {
 434     FreePool (mHandleBuffer);
 435     mHandleBuffer = NULL;
 436   }
 437   return Status;
 438 }
 439
 440 EFI_STATUS
 441 TGetDriverName(
 442   EFI_HANDLE   Handle,
 443   CHAR16         *Name
 444 )
 445 {
 446   EFI_DRIVER_BINDING_PROTOCOL        *BindHandle = NULL;
 447   EFI_STATUS                                        Status;
 448   UINT32                                               Version;
 449   UINT16                                               *Ptr;
 450   Status = gBS->OpenProtocol(
 451                   Handle,
 452                   &gEfiDriverBindingProtocolGuid,
 453                                    (VOID**)&BindHandle,
 454                   NULL,
 455                   NULL,
 456                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 457                   );
 458
 459   if (EFI_ERROR(Status))
 460   {
 461     return EFI_NOT_FOUND;
 462   }
 463
 464   Version = BindHandle->Version;
 465   Ptr = (UINT16*)&Version;
 466   UnicodeSPrint(Name, 40, L"%d.%d.%d", Version >> 24 , (Version >>16)& 0x0f ,*(Ptr));
 467   return EFI_SUCCESS;
 468 }
 469
 470 EFI_STATUS
 471 TGetGOPDriverName(
 472   CHAR16 *Name
 473 )
 474 {
 475   UINTN                         HandleCount;
 476   EFI_HANDLE                *Handles= NULL;
 477   UINTN                         Index;
 478   EFI_STATUS                Status;
 479   EFI_HANDLE                Child = 0;
 480
 481   Status = gBS->LocateHandleBuffer(
 482                               ByProtocol,
 483                               &gEfiDriverBindingProtocolGuid,
 484                               NULL,
 485                               &HandleCount,
 486                               &Handles
 487                   );
 488   for (Index = 0; Index < HandleCount ; Index++)
 489   {
 490     Status = TSearchChildHandle(Handles[Index], &Child);
 491     if(!EFI_ERROR(Status))
 492     {
 493       Status = TJudgeHandleIsPCIDevice(Child, 0x02, 0x00);
 494       if(!EFI_ERROR(Status))
 495       {
 496         return TGetDriverName(Handles[Index], Name);
 497       }
 498     }
 499   }
 500   return EFI_UNSUPPORTED;
 501 }
 502
 503 EFI_STATUS
 504 TGetTouchFirmwareVersion(
 505  )
 506 {
 507  EFI_STATUS rc=EFI_SUCCESS;
 508  UINTN      TouchVer = 0;
 509  UINTN     Size = sizeof(UINTN);
 510
 511
 512  CHAR16     Buffer[40];
 513
 514  rc = gRT->GetVariable(
 515              L"TouchVer",
 516              &gEfiVlv2VariableGuid,
 517              NULL,
 518              &Size,
 519              &TouchVer
 520              );
 521  if(!EFI_ERROR(rc)){
 522   UnicodeSPrint(Buffer, sizeof(Buffer), L"%02x.%02x", (TouchVer&0xFFFF)>>8,TouchVer&0xFF);
 523   HiiSetString(mHiiHandle, STRING_TOKEN(STR_MISC_TOUCH_VERSION), Buffer, NULL);
 524  }
 525
 526  return EFI_SUCCESS;
 527 }
 528
 529 EFI_STATUS
 530 UpdatePlatformInformation (
 531   )
 532 {
 533   UINT32                   MicroCodeVersion;
 534   CHAR16                   Buffer[40];
 535   UINT8                    IgdVBIOSRevH;
 536   UINT8                    IgdVBIOSRevL;
 537   UINT16                   EDX;
 538   EFI_IA32_REGISTER_SET    RegSet;
 539   EFI_LEGACY_BIOS_PROTOCOL *LegacyBios = NULL;
 540   EFI_STATUS               Status;
 541   UINT8                    CpuFlavor=0;
 542   EFI_PEI_HOB_POINTERS     GuidHob;
 543   EFI_PLATFORM_INFO_HOB    *mPlatformInfo=NULL;
 544   UINTN                    NumHandles;
 545   EFI_HANDLE                        *HandleBuffer;
 546   UINTN                             Index;
 547   DXE_PCH_PLATFORM_POLICY_PROTOCOL  *PchPlatformPolicy;
 548   UINTN                             PciD31F0RegBase;
 549   UINT8                             count;
 550   UINT8                             Data8;
 551   UINT8                             Data8_1;
 552
 553   CHAR16                            Name[40];
 554   UINT32                            MrcVersion;
 555
 556   UINT8                                 KscFwRevH =0;
 557   UINT8                                 KscFwRevL =0;
 558
 559   //
 560   // Get the HOB list.  If it is not present, then ASSERT.
 561   //
 562   GuidHob.Raw = GetHobList ();
 563   if (GuidHob.Raw != NULL) {
 564     if ((GuidHob.Raw = GetNextGuidHob (&gEfiPlatformInfoGuid, GuidHob.Raw)) != NULL) {
 565       mPlatformInfo = GET_GUID_HOB_DATA (GuidHob.Guid);
 566     }
 567   }
 568
 569   //
 570   //VBIOS version
 571   //
 572   Status = gBS->LocateProtocol(
 573                   &gEfiLegacyBiosProtocolGuid,
 574                   NULL,
 575                   (VOID **)&LegacyBios
 576                   );
 577
 578   RegSet.X.AX = 0x5f01;
 579   Status = LegacyBios->Int86 (LegacyBios, 0x10, &RegSet);
 580   ASSERT_EFI_ERROR(Status);
 581
 582   //
 583   // simulate AMI int15 (ax=5f01) handler
 584   // check NbInt15.asm in AMI code for asm edition
 585   //
 586   EDX = (UINT16)((RegSet.E.EBX >> 16) & 0xffff);
 587   IgdVBIOSRevH = (UINT8)(((EDX & 0x0F00) >> 4) | (EDX & 0x000F));
 588   IgdVBIOSRevL = (UINT8)(((RegSet.X.BX & 0x0F00) >> 4) | (RegSet.X.BX & 0x000F));
 589
 590   if (IgdVBIOSRevH==0 && IgdVBIOSRevL==0) {
 591     HiiSetString(mHiiHandle, STRING_TOKEN(STR_CHIP_IGD_VBIOS_REV_VALUE), L"N/A", NULL);
 592   } else {
 593     UnicodeSPrint (Buffer, sizeof (Buffer), L"%02X%02X", IgdVBIOSRevH,IgdVBIOSRevL);
 594     HiiSetString(mHiiHandle, STRING_TOKEN(STR_CHIP_IGD_VBIOS_REV_VALUE), Buffer, NULL);
 595   }
 596
 597   Status = TGetGOPDriverName(Name);
 598
 599   if(!EFI_ERROR(Status))
 600   {
 601     HiiSetString(mHiiHandle, STRING_TOKEN(STR_MISC_GOP_VERSION), Name, NULL);
 602   }
 603
 604   //
 605   //CpuFlavor
 606   //
 607   //VLV
 608   //VLV-DC Tablet        000
 609   //VLV-QC Notebook      001
 610   //VLV-QC Desktop       010
 611   //
 612   //CPU flavor
 613   //
 614   CpuFlavor = RShiftU64 (EfiReadMsr (MSR_IA32_PLATFORM_ID), 50) & 0x07;
 615
 616   switch(CpuFlavor){
 617     case 0x0:
 618         UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-DC Tablet", CpuFlavor);
 619         break;
 620     case 0x01:
 621         UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-QC Notebook", CpuFlavor);
 622         break;
 623     case 0x02:
 624         UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-QC Desktop", CpuFlavor);
 625         break;
 626     case 0x03:
 627         UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-QC Notebook", CpuFlavor);
 628         break;
 629     default:
 630         UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"Unknown CPU", CpuFlavor);
 631         break;
 632   }
 633   HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_CPU_FLAVOR_VALUE), Buffer, NULL);
 634
 635   if ( NULL != mPlatformInfo) {
 636     //
 637     // Board Id
 638     //
 639     UnicodeSPrint (Buffer, sizeof (Buffer), L"%x", mPlatformInfo->BoardId);
 640     HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_BOARD_ID_VALUE), Buffer, NULL);
 641
 642     //
 643     // FAB ID
 644     //
 645     UnicodeSPrint (Buffer, sizeof (Buffer), L"%x", mPlatformInfo->BoardRev);
 646     HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_FAB_ID_VALUE), Buffer, NULL);
 647   }
 648
 649   //
 650   //Update MRC Version
 651   //
 652   MrcVersion = MmioRead32 (MmPciAddress (0, 0, 0, 0, 0xF0));
 653   MrcVersion &= 0xffff;
 654   Index = EfiValueToString (Buffer, MrcVersion/100, PREFIX_ZERO, 0);
 655   StrCat (Buffer, L".");
 656   EfiValueToString (Buffer + Index + 1, (MrcVersion%100)/10, PREFIX_ZERO, 0);
 657   EfiValueToString (Buffer + Index + 2, (MrcVersion%100)%10, PREFIX_ZERO, 0);
 658   HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_MRC_VERSION_VALUE), Buffer, NULL);
 659
 660   //
 661   //Update Soc Version
 662   //
 663
 664   //
 665   // Retrieve all instances of PCH Platform Policy protocol
 666   //
 667   Status = gBS->LocateHandleBuffer (
 668                   ByProtocol,
 669                   &gDxePchPlatformPolicyProtocolGuid,
 670                   NULL,
 671                   &NumHandles,
 672                   &HandleBuffer
 673                   );
 674   if (!EFI_ERROR (Status)) {
 675     //
 676     // Find the matching PCH Policy protocol
 677     //
 678     for (Index = 0; Index < NumHandles; Index++) {
 679       Status = gBS->HandleProtocol (
 680                       HandleBuffer[Index],
 681                       &gDxePchPlatformPolicyProtocolGuid,
 682                       (VOID **) &PchPlatformPolicy
 683                       );
 684       if (!EFI_ERROR (Status)) {
 685         PciD31F0RegBase = MmPciAddress (
 686                             0,
 687                             PchPlatformPolicy->BusNumber,
 688                             PCI_DEVICE_NUMBER_PCH_LPC,
 689                             PCI_FUNCTION_NUMBER_PCH_LPC,
 690                             0
 691                             );
 692
 693          Data8 = MmioRead8 (PciD31F0RegBase + R_PCH_LPC_RID_CC);
 694          count = sizeof (SBRevisionTable) / sizeof (SBRevisionTable[0]);
 695          for (Index = 0; Index < count; Index++) {
 696            if(Data8 == SBRevisionTable[Index].RevId) {
 697               UnicodeSPrint (Buffer, sizeof (Buffer), L"%02x %a", Data8, SBRevisionTable[Index].String);
 698               HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_SOC_VALUE), Buffer, NULL);
 699              break;
 700            }
 701          }
 702         break;
 703       }
 704     }
 705   }
 706
 707   //
 708   // Microcode Revision
 709   //
 710   EfiWriteMsr (EFI_MSR_IA32_BIOS_SIGN_ID, 0);
 711   EfiCpuid (EFI_CPUID_VERSION_INFO, NULL);
 712   MicroCodeVersion = (UINT32) RShiftU64 (EfiReadMsr (EFI_MSR_IA32_BIOS_SIGN_ID), 32);
 713   UnicodeSPrint (Buffer, sizeof (Buffer), L"%x", MicroCodeVersion);
 714   HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_PROCESSOR_MICROCODE_VALUE), Buffer, NULL);
 715
 716
 717   //
 718   //Secure boot
 719   //
 720   Data8 = SystemConfiguration.SecureBoot;
 721   UnicodeSPrint (Buffer, sizeof(Buffer), L"%x", Data8);
 722   HiiSetString(mHiiHandle, STRING_TOKEN(STR_MISC_SECURE_BOOT), Buffer, NULL);
 723
 724   //
 725   //Bootmode
 726   //
 727   BootMode = GetBootModeHob();
 728   UnicodeSPrint (Buffer, sizeof(Buffer), L"%x", BootMode);
 729   HiiSetString(mHiiHandle, STRING_TOKEN(STR_MISC_BOOT_MODE), Buffer, NULL);
 730
 731   //
 732   //SpeedStep
 733   //
 734   Data8 = 1;
 735   UnicodeSPrint (Buffer, sizeof(Buffer), L"%x", Data8);
 736   HiiSetString(mHiiHandle, STRING_TOKEN(STR_MISC_SPEED_STEP), Buffer, NULL);
 737
 738   //
 739   //CPU Turbo
 740   //
 741   Data8 = 2;
 742   UnicodeSPrint (Buffer, sizeof(Buffer), L"%x", Data8);
 743   HiiSetString(mHiiHandle, STRING_TOKEN(STR_MISC_CPU_TURBO), Buffer, NULL);
 744
 745   //
 746   //CState
 747   //
 748   Data8 = 3;
 749   UnicodeSPrint (Buffer, sizeof(Buffer), L"%x", Data8);
 750   HiiSetString(mHiiHandle, STRING_TOKEN(STR_MISC_CSTATE), Buffer, NULL);
 751
 752   //
 753   //GFX Turbo
 754   //
 755   Data8 = SystemConfiguration.IgdTurboEnabled;
 756   UnicodeSPrint (Buffer, sizeof(Buffer), L"%x", Data8);
 757   HiiSetString(mHiiHandle, STRING_TOKEN(STR_MISC_GFX_TURBO), Buffer, NULL);
 758
 759   Data8 = 0;
 760   UnicodeSPrint (Buffer, sizeof(Buffer), L"%x", Data8);
 761   HiiSetString(mHiiHandle, STRING_TOKEN(STR_MISC_S0IX_VALUE), Buffer, NULL);
 762
 763   //
 764   //RC6
 765   //
 766   Data8 = 0;
 767   UnicodeSPrint (Buffer, sizeof(Buffer), L"%x", Data8);
 768   HiiSetString(mHiiHandle, STRING_TOKEN(STR_MISC_RC6_VALUE), Buffer, NULL);
 769
 770   //
 771   // Punit Version
 772   //
 773   Data8 = 0;
 774   UnicodeSPrint (Buffer, sizeof (Buffer), L"0x%x", Data8);
 775   HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_PUNIT_FW_VALUE), Buffer, NULL);
 776
 777   //
 778   //  PMC Version
 779   //
 780   Data8 = (UINT8)((MmioRead32 (PMC_BASE_ADDRESS + R_PCH_PMC_PRSTS)>>16)&0x00FF);
 781   Data8_1 = (UINT8)((MmioRead32 (PMC_BASE_ADDRESS + R_PCH_PMC_PRSTS)>>24)&0x00FF);
 782   UnicodeSPrint (Buffer, sizeof (Buffer), L"0x%X_%X", Data8_1, Data8);
 783   HiiSetString(mHiiHandle,STRING_TOKEN(STR_MISC_PMC_FW_VALUE), Buffer, NULL);
 784
 785   //
 786   //PMIC Version
 787   //
 788   Status = ByteReadI2C(PMICI2cBus, PMICI2cAdd, PMICVendorOffset, 1, &Data8);
 789   if(!EFI_ERROR(Status)){
 790         Status = ByteReadI2C(PMICI2cBus, PMICI2cAdd, PMICRevOffset, 1, &Data8_1);
 791         if(!EFI_ERROR(Status)){
 792       UnicodeSPrint(Buffer, sizeof(Buffer), L"%02x.%02x", Data8, Data8_1);
 793       HiiSetString(mHiiHandle, STRING_TOKEN(STR_MISC_PMIC_VERSION), Buffer, NULL);
 794         }
 795   }
 796
 797   TGetTouchFirmwareVersion();
 798
 799   return EFI_SUCCESS;
 800 }
 801
 802
 803 /**
 804   Smbios OEM type 0x94 callback.
 805
 806   @param Event    Event whose notification function is being invoked.
 807   @param Context  Pointer to the notification functions context, which is implementation dependent.
 808
 809   @retval None
 810
 811 **/
 812 VOID
 813 AddSmbiosT0x94Callback (
 814   IN EFI_EVENT  Event,
 815   IN VOID       *Context
 816   )
 817 {
 818   EFI_STATUS            Status;
 819   UINTN                 SECVerStrLen = 0;
 820   UINTN                 uCodeVerStrLen = 0;
 821   UINTN                 GOPStrLen = 0;
 822   UINTN                 MRCVersionStrLen = 0;
 823   UINTN                 PMCVersionStrLen = 0;
 824   UINTN                 ULPMCVersionStrLen = 0;
 825   UINTN                 PUNITVersionStrLen = 0;
 826   UINTN                 SOCVersionStrLen = 0;
 827   UINTN                 BOARDVersionStrLen = 0;
 828   UINTN                 FABVersionStrLen = 0;
 829   UINTN                 CPUFLAVORStrLen = 0;
 830   UINTN                 BIOSVersionStrLen = 0;
 831   UINTN                 PMICVersionStrLen = 0;
 832   UINTN                 TOUCHVersionStrLen = 0;
 833   UINTN                 SecureBootModeLen = 0;
 834   UINTN                 BootModeLen = 0;
 835   UINTN                 SpeedStepModeLen = 0;
 836   UINTN                 MaxCStateLen = 0;
 837   UINTN                 CpuTurboLen = 0;
 838   UINTN                 GfxTurboLen = 0;
 839   UINTN                 IdleReserveLen = 0;
 840   UINTN                 RC6Len = 0;
 841
 842   SMBIOS_TABLE_TYPE94    *SmbiosRecord;
 843   EFI_SMBIOS_HANDLE     SmbiosHandle;
 844   EFI_MISC_OEM_TYPE_0x94  *ForType94InputData;
 845   CHAR16                *SECVer;
 846   CHAR16                *uCodeVer;
 847   CHAR16                *GOPVer;
 848   CHAR16                *MrcVer;
 849   CHAR16                *PmcVer;
 850   CHAR16                *UlpmcVer;
 851   CHAR16                *PunitVer;
 852   CHAR16                *SocVer;
 853   CHAR16                *BoardVer;
 854   CHAR16                *FabVer;
 855   CHAR16                *CpuFlavor;
 856   CHAR16                *BiosVer;
 857   CHAR16                *PmicVer;
 858   CHAR16                *TouchVer = L"15.16";
 859   CHAR16                *SecureBootMode;
 860   CHAR16                *BootMode;
 861   CHAR16                *SpeedStepMode;
 862   CHAR16                *MaxCState;
 863   CHAR16                *CpuTurbo;
 864   CHAR16                *GfxTurbo;
 865   CHAR16                *IdleReserve;
 866   CHAR16                *RC6;
 867
 868   UINTN                 RecordLen = 0;
 869   UINTN                 StrIdx = 0;
 870
 871
 872   STRING_REF            TokenToGet;
 873   CHAR8                 *OptionalStrStart;
 874   EFI_SMBIOS_PROTOCOL               *SmbiosProtocol;
 875
 876   ForType94InputData        = (EFI_MISC_OEM_TYPE_0x94 *)Context;
 877
 878   DEBUG ((EFI_D_INFO, "Executing SMBIOS T0x94 callback.\n"));
 879
 880   gBS->CloseEvent (Event);    // Unload this event.
 881
 882   //
 883   // First check for invalid parameters.
 884   //
 885   if (Context == NULL) {
 886     return;
 887   }
 888
 889   UpdatePlatformInformation();
 890
 891   Status = gBS->LocateProtocol (
 892                   &gEfiSmbiosProtocolGuid,
 893                   NULL,
 894                   (VOID **) &SmbiosProtocol
 895                   );
 896   ASSERT_EFI_ERROR (Status);
 897
 898   TokenToGet = STRING_TOKEN (STR_MISC_SEC_VERSION);
 899   SECVer = SmbiosMiscGetString (TokenToGet);
 900   SECVerStrLen = StrLen(SECVer);
 901   if (SECVerStrLen > SMBIOS_STRING_MAX_LENGTH) {
 902     return;
 903   }
 904
 905   TokenToGet = STRING_TOKEN (STR_MISC_UCODE_VERSION);
 906   uCodeVer = SmbiosMiscGetString (TokenToGet);
 907   uCodeVerStrLen = StrLen(uCodeVer);
 908   if (uCodeVerStrLen > SMBIOS_STRING_MAX_LENGTH) {
 909     return;
 910   }
 911
 912   TokenToGet = STRING_TOKEN (STR_MISC_GOP_VERSION);
 913   GOPVer = SmbiosMiscGetString (TokenToGet);
 914   GOPStrLen = StrLen(GOPVer);
 915   if (GOPStrLen > SMBIOS_STRING_MAX_LENGTH) {
 916     return;
 917   }
 918
 919   TokenToGet = STRING_TOKEN (STR_MISC_MRC_VERSION_VALUE);
 920   MrcVer = SmbiosMiscGetString (TokenToGet);
 921   MRCVersionStrLen = StrLen(MrcVer);
 922   if (MRCVersionStrLen > SMBIOS_STRING_MAX_LENGTH) {
 923     return;
 924   }
 925
 926   TokenToGet = STRING_TOKEN (STR_MISC_PMC_FW_VALUE);
 927   PmcVer = SmbiosMiscGetString (TokenToGet);
 928   PMCVersionStrLen = StrLen(PmcVer);
 929   if (PMCVersionStrLen > SMBIOS_STRING_MAX_LENGTH) {
 930     return;
 931   }
 932
 933   TokenToGet = STRING_TOKEN (STR_MISC_ULPMC_FW_VALUE);
 934   UlpmcVer = SmbiosMiscGetString (TokenToGet);
 935   ULPMCVersionStrLen = StrLen(UlpmcVer);
 936   if (ULPMCVersionStrLen > SMBIOS_STRING_MAX_LENGTH) {
 937     return;
 938   }
 939
 940   TokenToGet = STRING_TOKEN (STR_MISC_PUNIT_FW_VALUE);
 941   PunitVer = SmbiosMiscGetString (TokenToGet);
 942   PUNITVersionStrLen = StrLen(PunitVer);
 943   if (PUNITVersionStrLen > SMBIOS_STRING_MAX_LENGTH) {
 944     return;
 945   }
 946
 947   TokenToGet = STRING_TOKEN (STR_MISC_SOC_VALUE);
 948   SocVer = SmbiosMiscGetString (TokenToGet);
 949   SOCVersionStrLen = StrLen(SocVer);
 950   if (SOCVersionStrLen > SMBIOS_STRING_MAX_LENGTH) {
 951     return;
 952   }
 953
 954   TokenToGet = STRING_TOKEN (STR_MISC_BOARD_ID_VALUE);
 955   BoardVer = SmbiosMiscGetString (TokenToGet);
 956   BOARDVersionStrLen = StrLen(BoardVer);
 957   if (BOARDVersionStrLen > SMBIOS_STRING_MAX_LENGTH) {
 958     return;
 959   }
 960
 961   TokenToGet = STRING_TOKEN (STR_MISC_FAB_ID_VALUE);
 962   FabVer = SmbiosMiscGetString (TokenToGet);
 963   FABVersionStrLen = StrLen(FabVer);
 964   if (FABVersionStrLen > SMBIOS_STRING_MAX_LENGTH) {
 965     return;
 966   }
 967
 968   TokenToGet = STRING_TOKEN (STR_MISC_CPU_FLAVOR_VALUE);
 969   CpuFlavor = SmbiosMiscGetString (TokenToGet);
 970   CPUFLAVORStrLen = StrLen(CpuFlavor);
 971   if (CPUFLAVORStrLen > SMBIOS_STRING_MAX_LENGTH) {
 972     return;
 973   }
 974
 975   TokenToGet = STRING_TOKEN (STR_MISC_BIOS_VERSION);
 976   BiosVer = SmbiosMiscGetString (TokenToGet);
 977   BIOSVersionStrLen = StrLen(BiosVer);
 978   if (BIOSVersionStrLen > SMBIOS_STRING_MAX_LENGTH) {
 979     return;
 980   }
 981
 982   TokenToGet = STRING_TOKEN (STR_MISC_PMIC_VERSION);
 983   PmicVer = SmbiosMiscGetString (TokenToGet);
 984   PMICVersionStrLen = StrLen(PmicVer);
 985   if (PMICVersionStrLen > SMBIOS_STRING_MAX_LENGTH) {
 986     return;
 987   }
 988
 989   TokenToGet = STRING_TOKEN (STR_MISC_TOUCH_VERSION);
 990   TouchVer = SmbiosMiscGetString (TokenToGet);
 991   TOUCHVersionStrLen = StrLen(TouchVer);
 992   if (TOUCHVersionStrLen > SMBIOS_STRING_MAX_LENGTH) {
 993     return;
 994   }
 995
 996   TokenToGet = STRING_TOKEN (STR_MISC_SECURE_BOOT);
 997   SecureBootMode = SmbiosMiscGetString(TokenToGet);
 998   SecureBootModeLen = StrLen(SecureBootMode);
 999   if (SecureBootModeLen > SMBIOS_STRING_MAX_LENGTH) {
1000         return;
1001   }
1002
1003   TokenToGet = STRING_TOKEN (STR_MISC_BOOT_MODE);
1004   BootMode = SmbiosMiscGetString(TokenToGet);
1005   BootModeLen = StrLen(BootMode);
1006   if (BootModeLen > SMBIOS_STRING_MAX_LENGTH) {
1007         return;
1008   }
1009
1010   TokenToGet = STRING_TOKEN (STR_MISC_SPEED_STEP);
1011   SpeedStepMode = SmbiosMiscGetString(TokenToGet);
1012   SpeedStepModeLen = StrLen(SpeedStepMode);
1013   if (SpeedStepModeLen > SMBIOS_STRING_MAX_LENGTH) {
1014         return;
1015   }
1016
1017   TokenToGet = STRING_TOKEN (STR_MISC_CPU_TURBO);
1018   CpuTurbo = SmbiosMiscGetString(TokenToGet);
1019   CpuTurboLen = StrLen(CpuTurbo);
1020   if (CpuTurboLen > SMBIOS_STRING_MAX_LENGTH) {
1021         return;
1022   }
1023
1024   TokenToGet = STRING_TOKEN (STR_MISC_CSTATE);
1025   MaxCState = SmbiosMiscGetString(TokenToGet);
1026   MaxCStateLen = StrLen(MaxCState);
1027   if (MaxCStateLen > SMBIOS_STRING_MAX_LENGTH) {
1028         return;
1029   }
1030
1031   TokenToGet = STRING_TOKEN (STR_MISC_GFX_TURBO);
1032   GfxTurbo = SmbiosMiscGetString(TokenToGet);
1033   GfxTurboLen = StrLen(GfxTurbo);
1034   if (GfxTurboLen > SMBIOS_STRING_MAX_LENGTH) {
1035         return;
1036   }
1037
1038   TokenToGet = STRING_TOKEN (STR_MISC_S0IX_VALUE);
1039   IdleReserve = SmbiosMiscGetString(TokenToGet);
1040   IdleReserveLen = StrLen(IdleReserve);
1041   if (S0ixLen > SMBIOS_STRING_MAX_LENGTH) {
1042     return;
1043   }
1044
1045   TokenToGet = STRING_TOKEN (STR_MISC_RC6_VALUE);
1046   RC6 = SmbiosMiscGetString(TokenToGet);
1047   RC6Len = StrLen(RC6);
1048   if (RC6Len > SMBIOS_STRING_MAX_LENGTH) {
1049     return;
1050   }
1051
1052   RecordLen = sizeof (SMBIOS_TABLE_TYPE94) + SECVerStrLen + 1 + uCodeVerStrLen + 1 + GOPStrLen + 1 + PMCVersionStrLen + 1 + \
1053                       TOUCHVersionStrLen + 1 + PMICVersionStrLen + 1 + BIOSVersionStrLen + 1 + CPUFLAVORStrLen + 1 + \
1054                       BOARDVersionStrLen + 1 + FABVersionStrLen + 1 + PUNITVersionStrLen+ 1 + ULPMCVersionStrLen + 1 + \
1055                       MRCVersionStrLen + 1 + SOCVersionStrLen + 1 + SecureBootModeLen + 1 + BootModeLen + 1 + \
1056                       SpeedStepModeLen + 1 + CpuTurboLen + 1 + MaxCStateLen + 1 + GfxTurboLen + 1 + + RC6Len + 1 + 1;
1057
1058   SmbiosRecord = AllocatePool(RecordLen);
1059
1060   ZeroMem(SmbiosRecord, RecordLen);
1061
1062   SmbiosRecord->Hdr.Type = EFI_SMBIOS_TYPE_MISC_VERSION_INFO;
1063   SmbiosRecord->Hdr.Length = sizeof (SMBIOS_TABLE_TYPE94);
1064
1065   //
1066   // Make handle chosen by smbios protocol.add automatically.
1067   //
1068   SmbiosRecord->Hdr.Handle = 0;
1069
1070   SmbiosRecord->GopVersion = 1;
1071
1072   SmbiosRecord->SECVersion = 2;
1073
1074   SmbiosRecord->MRCVersion = 3;
1075
1076   SmbiosRecord->uCodeVersion = 4;
1077
1078   SmbiosRecord->PUnitVersion = 5;
1079
1080   SmbiosRecord->PMCVersion = 6;
1081
1082   SmbiosRecord->ULPMCVersion = 7;
1083
1084   SmbiosRecord->SoCVersion = 8;
1085
1086   SmbiosRecord->BoardVersion = 9;
1087
1088   SmbiosRecord->FabVersion = 10;
1089
1090   SmbiosRecord->CPUFlavor = 11;
1091
1092   SmbiosRecord->BiosVersion = 12;
1093
1094   SmbiosRecord->PmicVersion = 13;
1095
1096   SmbiosRecord->TouchVersion = 14;
1097
1098   SmbiosRecord->SecureBoot = 15;
1099
1100   SmbiosRecord->BootMode = 16;
1101
1102   SmbiosRecord->SpeedStepMode= 17;
1103
1104   SmbiosRecord->CPUTurboMode = 18;
1105
1106   SmbiosRecord->MaxCState = 19;
1107
1108   SmbiosRecord->GfxTurbo = 20;
1109   SmbiosRecord->IdleReserve = 21;
1110
1111   SmbiosRecord->RC6 = 22;
1112
1113
1114   OptionalStrStart = (CHAR8 *)(SmbiosRecord + 1);
1115   UnicodeStrToAsciiStr(GOPVer, OptionalStrStart);
1116   StrIdx +=  GOPStrLen + 1;
1117
1118   UnicodeStrToAsciiStr(SECVer, OptionalStrStart + StrIdx);
1119   StrIdx +=  SECVerStrLen + 1;
1120
1121   UnicodeStrToAsciiStr(MrcVer, OptionalStrStart + StrIdx);
1122   StrIdx +=  MRCVersionStrLen + 1;
1123
1124   UnicodeStrToAsciiStr(uCodeVer, OptionalStrStart + StrIdx);
1125   StrIdx +=  uCodeVerStrLen + 1;
1126
1127   UnicodeStrToAsciiStr(PunitVer, OptionalStrStart + StrIdx);
1128   StrIdx +=  PUNITVersionStrLen + 1;
1129
1130   UnicodeStrToAsciiStr(PmcVer, OptionalStrStart + StrIdx);
1131   StrIdx +=  PMCVersionStrLen + 1;
1132
1133   UnicodeStrToAsciiStr(UlpmcVer, OptionalStrStart + StrIdx);
1134   StrIdx +=  ULPMCVersionStrLen + 1;
1135
1136
1137   UnicodeStrToAsciiStr(SocVer, OptionalStrStart + StrIdx);
1138   StrIdx +=  SOCVersionStrLen +1;
1139
1140   UnicodeStrToAsciiStr(BoardVer, OptionalStrStart + StrIdx);
1141   StrIdx +=  BOARDVersionStrLen + 1;
1142
1143   UnicodeStrToAsciiStr(FabVer, OptionalStrStart + StrIdx);
1144   StrIdx +=  FABVersionStrLen + 1;
1145
1146   UnicodeStrToAsciiStr(CpuFlavor, OptionalStrStart + StrIdx);
1147   StrIdx +=  CPUFLAVORStrLen + 1;
1148
1149   UnicodeStrToAsciiStr(BiosVer, OptionalStrStart + StrIdx);
1150   StrIdx +=  BIOSVersionStrLen + 1;
1151
1152   UnicodeStrToAsciiStr(PmicVer, OptionalStrStart + StrIdx);
1153   StrIdx +=  PMICVersionStrLen + 1;
1154
1155   UnicodeStrToAsciiStr(TouchVer, OptionalStrStart + StrIdx);
1156   StrIdx +=  TOUCHVersionStrLen + 1;
1157
1158   UnicodeStrToAsciiStr(SecureBootMode, OptionalStrStart + StrIdx);
1159   StrIdx +=  SecureBootModeLen + 1;
1160
1161   UnicodeStrToAsciiStr(BootMode, OptionalStrStart + StrIdx);
1162   StrIdx +=  BootModeLen + 1;
1163
1164   UnicodeStrToAsciiStr(SpeedStepMode, OptionalStrStart + StrIdx);
1165   StrIdx +=  SpeedStepModeLen + 1;
1166
1167   UnicodeStrToAsciiStr(CpuTurbo, OptionalStrStart + StrIdx);
1168   StrIdx +=  CpuTurboLen + 1;
1169
1170   UnicodeStrToAsciiStr(MaxCState, OptionalStrStart + StrIdx);
1171   StrIdx +=  MaxCStateLen + 1;
1172
1173   UnicodeStrToAsciiStr(GfxTurbo, OptionalStrStart + StrIdx);
1174   StrIdx +=  GfxTurboLen + 1;
1175
1176   UnicodeStrToAsciiStr(IdleReserve, OptionalStrStart + StrIdx);
1177   StrIdx +=  S0ixLen + 1;
1178
1179   UnicodeStrToAsciiStr(RC6, OptionalStrStart + StrIdx);
1180   StrIdx +=  RC6Len + 1;
1181
1182   //
1183   // Now we have got the full smbios record, call smbios protocol to add this record.
1184   //
1185   SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
1186   Status = SmbiosProtocol-> Add (
1187                               SmbiosProtocol,
1188                               NULL,
1189                               &SmbiosHandle,
1190                               (EFI_SMBIOS_TABLE_HEADER *) SmbiosRecord
1191                               );
1192
1193   FreePool(SmbiosRecord);
1194   return;
1195 }
1196
1197 /**
1198   This function makes boot time changes to the contents of the
1199   MiscOemType0x94 (Type 0x94).
1200
1201   @param  RecordData                 Pointer to copy of RecordData from the Data Table.
1202
1203   @retval EFI_SUCCESS                All parameters were valid.
1204   @retval EFI_UNSUPPORTED            Unexpected RecordType value.
1205   @retval EFI_INVALID_PARAMETER      Invalid parameter was found.
1206
1207 **/
1208 MISC_SMBIOS_TABLE_FUNCTION(MiscOemType0x94)
1209 {
1210   EFI_STATUS                    Status;
1211   EFI_EVENT                     AddSmbiosT0x94CallbackEvent;
1212
1213   Status = EfiCreateEventReadyToBootEx (
1214              TPL_CALLBACK,
1215              AddSmbiosT0x94Callback,
1216              RecordData,
1217              &AddSmbiosT0x94CallbackEvent
1218              );
1219
1220   ASSERT_EFI_ERROR (Status);
1221   return Status;
1222
1223 }