MiscOemType0x94Function.c 34 KB

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