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