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