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