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