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