]> 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
Vlv2TbltDevicePkg/PlatformSetupDxe: rebase to ARRAY_SIZE()
[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
3cbfba02
DW		 523 EFI_SUBCLASS_TYPE1_HEADER *DataHeader;\r
524 CHAR16 *NewString;\r
525 CHAR16 *NewString2;\r
526 CHAR16 *NewStringToken;\r
527 STRING_REF TokenToUpdate;\r
528 EFI_PROCESSOR_VERSION_DATA *ProcessorVersion;\r
529 UINTN Index;\r
3cbfba02
DW		 530 UINTN DataOutput;\r
531\r
532 EFI_PROCESSOR_MICROCODE_REVISION_DATA *CpuUcodeRevisionData;\r
533 EFI_MEMORY_ARRAY_START_ADDRESS *MemoryArray;\r
534 EFI_MEMORY_ARRAY_LINK *MemoryArrayLink;\r
535 UINT64 MonotonicCount;\r
536\r
537 CHAR16 Version[100]; //Assuming that strings are < 100 UCHAR\r
538 CHAR16 ReleaseDate[100]; //Assuming that strings are < 100 UCHAR\r
539 CHAR16 ReleaseTime[100]; //Assuming that strings are < 100 UCHAR\r
540\r
541 NewString = AllocateZeroPool (0x100);\r
542 NewString2 = AllocateZeroPool (0x100);\r
543 SetMem(Version, sizeof(Version), 0);\r
544 SetMem(ReleaseDate, sizeof(ReleaseDate), 0);\r
545 SetMem(ReleaseTime, sizeof(ReleaseTime), 0);\r
546\r
3cbfba02
DW		 547 //\r
548 // Get the Data Hub Protocol. Assume only one instance\r
549 //\r
550 Status = gBS->LocateProtocol (&gEfiDataHubProtocolGuid, NULL, (void **)&DataHub);\r
551 ASSERT_EFI_ERROR(Status);\r
552\r
553 //\r
554 // Get all available data records from data hub\r
555 //\r
556 MonotonicCount = 0;\r
557 Record = NULL;\r
558\r
559 do {\r
560 Status = DataHub->GetNextRecord (DataHub, &MonotonicCount, NULL, &Record);\r
561 if (!EFI_ERROR(Status)) {\r
562 if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA) {\r
563 DataHeader = (EFI_SUBCLASS_TYPE1_HEADER *)(Record + 1);\r
564 SrcData = (UINT8 *)(DataHeader + 1);\r
3cbfba02
DW		 565\r
566 //\r
567 // Processor\r
568 //\r
569 if (CompareGuid(&Record->DataRecordGuid, &gEfiProcessorSubClassGuid)) {\r
570 CopyMem (&mProcessorProducerGuid, &Record->ProducerName, sizeof(EFI_GUID));\r
571 switch (DataHeader->RecordType) {\r
572 case ProcessorCoreFrequencyRecordType:\r
573 CopyMem(&mProcessorFrequency, SrcData, sizeof(EFI_EXP_BASE10_DATA));\r
574 Index = EfiValueToString (\r
575 NewString,\r
576 ConvertBase10ToRaw ((EFI_EXP_BASE10_DATA *)SrcData)/1000000000,\r
577 PREFIX_ZERO,\r
578 0\r
579 );\r
580 StrCat (NewString, L".");\r
581 EfiValueToString (\r
582 NewString + Index + 1,\r
583 ((ConvertBase10ToRaw ((EFI_EXP_BASE10_DATA *)SrcData)%1000000000)/10000000),\r
584 PREFIX_ZERO,\r
585 0\r
586 );\r
587 StrCat (NewString, L" GHz");\r
588 TokenToUpdate = (STRING_REF)STR_PROCESSOR_SPEED_VALUE;\r
589 HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);\r
590 break;\r
591\r
592 case ProcessorVersionRecordType:\r
593 ProcessorVersion = (EFI_PROCESSOR_VERSION_DATA *)SrcData;\r
594 NewStringToken = HiiGetPackageString(&mProcessorProducerGuid, *ProcessorVersion, NULL);\r
595 TokenToUpdate = (STRING_REF)STR_PROCESSOR_VERSION_VALUE;\r
596 HiiSetString(mHiiHandle, TokenToUpdate, NewStringToken, NULL);\r
597 break;\r
598 case CpuUcodeRevisionDataRecordType:\r
599 CpuUcodeRevisionData = (EFI_PROCESSOR_MICROCODE_REVISION_DATA *) SrcData;\r
600 if (CpuUcodeRevisionData->ProcessorMicrocodeRevisionNumber != 0) {\r
601 EfiValueToHexStr (\r
602 NewString,\r
603 CpuUcodeRevisionData->ProcessorMicrocodeRevisionNumber,\r
604 PREFIX_ZERO,\r
605 8\r
606 );\r
607 TokenToUpdate = (STRING_REF)STR_PROCESSOR_MICROCODE_VALUE;\r
608 HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);\r
609 }\r
610 break;\r
611 default:\r
612 break;\r
613 }\r
614\r
615 //\r
616 // Cache\r
617 //\r
618 } else if (CompareGuid(&Record->DataRecordGuid, &gEfiCacheSubClassGuid) &&\r
619 (DataHeader->RecordType == CacheSizeRecordType)) {\r
620 if (DataHeader->SubInstance == EFI_CACHE_L1) {\r
621 EFI_CACHE_TYPE_DATA CacheType;\r
622 if (EFI_SUCCESS == GetCacheType(DataHeader->Instance, DataHeader->SubInstance,&CacheType)){\r
623 if (CacheType == EfiCacheTypeData) {\r
624 TokenToUpdate = (STRING_REF)STR_PROCESSOR_L1_DATA_CACHE_VALUE;\r
625 } else if (CacheType == EfiCacheTypeInstruction) {\r
626 TokenToUpdate = (STRING_REF)STR_PROCESSOR_L1_INSTR_CACHE_VALUE;\r
627 } else {\r
628 continue;\r
629 }\r
630 } else {\r
631 continue;\r
632 }\r
633 }\r
634 else if (DataHeader->SubInstance == EFI_CACHE_L2) {\r
635 TokenToUpdate = (STRING_REF)STR_PROCESSOR_L2_CACHE_VALUE;\r
636 } else {\r
637 continue;\r
638 }\r
639 if (ConvertBase2ToRaw((EFI_EXP_BASE2_DATA *)SrcData)) {\r
640 DataOutput = ConvertBase2ToRaw((EFI_EXP_BASE2_DATA *)SrcData) >> 10;\r
641 EfiValueToString (NewString, DataOutput, PREFIX_ZERO, 0);\r
642\r
643 StrCat (NewString, L" KB");\r
644 if (DataHeader->SubInstance == EFI_CACHE_L3) {\r
645 HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);\r
646 } else if(DataHeader->SubInstance == EFI_CACHE_L2 && mPlatformCpuInfo.CpuPackage.CoresPerPhysicalPackage > 1){\r
647 //\r
648 // Show XxL2 string\r
649 //\r
650 EfiValueToString (\r
651 NewString2,\r
652 mPlatformCpuInfo.CpuPackage.CoresPerPhysicalPackage,\r
653 PREFIX_ZERO,\r
654 0\r
655 );\r
656 StrCat(NewString2, L"x ");\r
657 StrCat(NewString2, NewString);\r
658 HiiSetString(mHiiHandle, TokenToUpdate, NewString2, NULL);\r
659 } else {\r
660 HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);\r
661 }\r
662 }\r
663\r
664 //\r
665 // Memory\r
666 //\r
667 } else if (CompareGuid(&Record->DataRecordGuid, &gEfiMemorySubClassGuid)) {\r
668 switch (DataHeader->RecordType) {\r
669 case EFI_MEMORY_ARRAY_LINK_RECORD_NUMBER:\r
670 MemoryArrayLink = (EFI_MEMORY_ARRAY_LINK *)SrcData;\r
671\r
672 if (MemoryArrayLink->MemorySpeed > 0) {\r
673 //\r
674 // Save the lowest speed memory module\r
675 //\r
676 if (MemoryArrayLink->MemorySpeed < mMemorySpeed) {\r
677 mMemorySpeed = MemoryArrayLink->MemorySpeed;\r
678 }\r
679 switch (DataHeader->SubInstance) {\r
680 case 1:\r
681 mMemorySpeedChannelASlot0 = MemoryArrayLink->MemorySpeed;\r
682 mMemorySizeChannelASlot0 = MemoryArrayLink->MemoryDeviceSize;\r
683 break;\r
684 case 2:\r
685 mMemorySpeedChannelASlot1 = MemoryArrayLink->MemorySpeed;\r
686 mMemorySizeChannelASlot1 = MemoryArrayLink->MemoryDeviceSize;\r
687 break;\r
688 case 3:\r
689 mMemorySpeedChannelBSlot0 = MemoryArrayLink->MemorySpeed;\r
690 mMemorySizeChannelBSlot0 = MemoryArrayLink->MemoryDeviceSize;\r
691 break;\r
692 case 4:\r
693 mMemorySpeedChannelBSlot1 = MemoryArrayLink->MemorySpeed;\r
694 mMemorySizeChannelBSlot1 = MemoryArrayLink->MemoryDeviceSize;\r
695 break;\r
696 case 5:\r
697 mMemorySpeedChannelCSlot0 = MemoryArrayLink->MemorySpeed;\r
698 mMemorySizeChannelCSlot0 = MemoryArrayLink->MemoryDeviceSize;\r
699 break;\r
700 case 6:\r
701 mMemorySpeedChannelCSlot1 = MemoryArrayLink->MemorySpeed;\r
702 mMemorySizeChannelCSlot1 = MemoryArrayLink->MemoryDeviceSize;\r
703 break;\r
704 default:\r
705 break;\r
706 }\r
707 }\r
708 break;\r
709\r
710 case EFI_MEMORY_ARRAY_START_ADDRESS_RECORD_NUMBER:\r
711 MemoryArray = (EFI_MEMORY_ARRAY_START_ADDRESS *)SrcData;\r
712 if (MemoryArray->MemoryArrayEndAddress - MemoryArray->MemoryArrayStartAddress) {\r
713 DataOutput = (UINTN)RShiftU64((MemoryArray->MemoryArrayEndAddress - MemoryArray->MemoryArrayStartAddress + 1), 20);\r
714 EfiValueToString (NewString, DataOutput / 1024, PREFIX_ZERO, 0);\r
715 if(DataOutput % 1024) {\r
716 StrCat (NewString, L".");\r
717 DataOutput = ((DataOutput % 1024) * 1000) / 1024;\r
718 while(!(DataOutput % 10))\r
719 DataOutput = DataOutput / 10;\r
720 EfiValueToString (NewString2, DataOutput, PREFIX_ZERO, 0);\r
721 StrCat (NewString, NewString2);\r
722 }\r
723 StrCat (NewString, L" GB");\r
724 TokenToUpdate = (STRING_REF)STR_TOTAL_MEMORY_SIZE_VALUE;\r
725 HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);\r
726 }\r
727 break;\r
728\r
729 default:\r
730 break;\r
731 }\r
732 }\r
733 }\r
734 }\r
735 } while (!EFI_ERROR(Status) && (MonotonicCount != 0));\r
736\r
737 Status = GetBiosVersionDateTime (\r
738 Version,\r
739 ReleaseDate,\r
740 ReleaseTime\r
741 );\r
742\r
743 DEBUG ((EFI_D_ERROR, "GetBiosVersionDateTime :%s %s %s \n", Version, ReleaseDate, ReleaseTime));\r
744 if (!EFI_ERROR (Status)) {\r
745 UINTN Length = 0;\r
746 CHAR16 *BuildDateTime;\r
747\r
748 Length = StrLen(ReleaseDate) + StrLen(ReleaseTime);\r
749\r
750 BuildDateTime = AllocateZeroPool ((Length+2) * sizeof(CHAR16));\r
751 StrCpy (BuildDateTime, ReleaseDate);\r
752 StrCat (BuildDateTime, L" ");\r
753 StrCat (BuildDateTime, ReleaseTime);\r
754\r
755 TokenToUpdate = (STRING_REF)STR_BIOS_VERSION_VALUE;\r
756 DEBUG ((EFI_D_ERROR, "update STR_BIOS_VERSION_VALUE\n"));\r
757 HiiSetString(mHiiHandle, TokenToUpdate, Version, NULL);\r
758\r
759 TokenToUpdate = (STRING_REF)STR_BIOS_BUILD_TIME_VALUE;\r
760 DEBUG ((EFI_D_ERROR, "update STR_BIOS_BUILD_TIME_VALUE\n"));\r
761 HiiSetString(mHiiHandle, TokenToUpdate, BuildDateTime, NULL);\r
762 }\r
763\r
764 //\r
765 // Calculate and update memory speed display in Main Page\r
766 //\r
767 //\r
768 // Update the overall memory speed\r
769 //\r
770 if (mMemorySpeed != 0xffff) {\r
771 EfiValueToString (NewString, mMemorySpeed, PREFIX_ZERO, 0);\r
772 StrCat (NewString, L" MHz");\r
773\r
774 TokenToUpdate = (STRING_REF)STR_SYSTEM_MEMORY_SPEED_VALUE;\r
775 HiiSetString(mHiiHandle, TokenToUpdate, NewString, NULL);\r
776 }\r
777\r
778 gBS->FreePool(NewString);\r
779 gBS->FreePool(NewString2);\r
780\r
781 return;\r
782}\r
783\r
784/**\r
785\r
786 Routine Description: update the SETUP info for "Additional Information" which is SMBIOS info.\r
787\r
788 @retval EFI_STATUS\r
789\r
790**/\r
791EFI_STATUS\r
792UpdateAdditionalInformation (\r
793 )\r
794{\r
795 EFI_STATUS Status;\r
796 UINT64 MonotonicCount;\r
797 EFI_DATA_HUB_PROTOCOL *DataHub;\r
798 EFI_DATA_RECORD_HEADER *Record;\r
799 EFI_SUBCLASS_TYPE1_HEADER *DataHeader;\r
3cbfba02
DW		 800 EFI_SMBIOS_PROTOCOL *Smbios;\r
801 EFI_SMBIOS_HANDLE SmbiosHandle;\r
802 EFI_SMBIOS_TABLE_HEADER *SmbiosRecord;\r
803 SMBIOS_TABLE_TYPE0 *Type0Record;\r
804 UINT8 StrIndex;\r
805 CHAR16 *BiosVersion = NULL;\r
806 CHAR16 *IfwiVersion = NULL;\r
807 UINT16 SearchIndex;\r
808 EFI_STRING_ID TokenToUpdate;\r
53000664
GL		 809#if defined( RVP_SUPPORT ) && RVP_SUPPORT\r
810 EFI_MISC_SYSTEM_MANUFACTURER *SystemManufacturer;\r
811#endif\r
3cbfba02
DW		 812\r
813 Status = gBS->LocateProtocol (\r
814 &gEfiDataHubProtocolGuid,\r
815 NULL,\r
816 (void **)&DataHub\r
817 );\r
818\r
819 ASSERT_EFI_ERROR(Status);\r
820\r
3cbfba02
DW		 821 MonotonicCount = 0;\r
822 Record = NULL;\r
823 do {\r
824 Status = DataHub->GetNextRecord (\r
825 DataHub,\r
826 &MonotonicCount,\r
827 NULL,\r
828 &Record\r
829 );\r
830 if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA) {\r
831 DataHeader = (EFI_SUBCLASS_TYPE1_HEADER *)(Record + 1);\r
832\r
833 if (CompareGuid(&Record->DataRecordGuid, &gEfiMiscSubClassGuid) &&\r
834 (DataHeader->RecordType == EFI_MISC_SYSTEM_MANUFACTURER_RECORD_NUMBER)) {\r
53000664 835#if defined( RVP_SUPPORT ) && RVP_SUPPORT\r
3cbfba02
DW		 836 //\r
837 // System Information\r
838 //\r
839 SystemManufacturer = (EFI_MISC_SYSTEM_MANUFACTURER *)(DataHeader + 1);\r
840\r
3cbfba02
DW		 841 //\r
842 // UUID (System Information)\r
843 //\r
844 SMBIOSString = EfiLibAllocateZeroPool (0x100);\r
845 GuidToString ( &SystemManufacturer->SystemUuid, SMBIOSString, 0x00 );\r
846\r
847 TokenToUpdate = (STRING_REF)STR_SYSTEM_UUID_VALUE;\r
848 HiiSetString(mHiiHandle, TokenToUpdate, SMBIOSString, NULL);\r
849\r
850 gBS->FreePool(SMBIOSString);\r
851#endif\r
852 }\r
853 }\r
854 } while (!EFI_ERROR(Status) && (MonotonicCount != 0));\r
855\r
856 Status = gBS->LocateProtocol (\r
857 &gEfiSmbiosProtocolGuid,\r
858 NULL,\r
859 (VOID **) &Smbios\r
860 );\r
861 ASSERT_EFI_ERROR (Status);\r
862\r
863 SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;\r
864 do {\r
865 Status = Smbios->GetNext (\r
866 Smbios,\r
867 &SmbiosHandle,\r
868 NULL,\r
869 &SmbiosRecord,\r
870 NULL\r
871 );\r
872 if (SmbiosRecord->Type == EFI_SMBIOS_TYPE_BIOS_INFORMATION) {\r
873 Type0Record = (SMBIOS_TABLE_TYPE0 *) SmbiosRecord;\r
874 StrIndex = Type0Record->BiosVersion;\r
875 GetOptionalStringByIndex ((CHAR8*)((UINT8*)Type0Record + Type0Record->Hdr.Length), StrIndex, &BiosVersion);\r
876 TokenToUpdate = STRING_TOKEN (STR_BIOS_VERSION_VALUE);\r
877 for (SearchIndex = 0x0; SearchIndex < SMBIOS_STRING_MAX_LENGTH; SearchIndex++) {\r
878 if (BiosVersion[SearchIndex] == 0x0020) {\r
879 BiosVersion[SearchIndex] = 0x0000;\r
880 IfwiVersion = (CHAR16 *)(&BiosVersion[SearchIndex+1]);\r
881 break;\r
882 } else if (BiosVersion[SearchIndex] == 0x0000) {\r
883 break;\r
884 }\r
885 }\r
886 HiiSetString (mHiiHandle, TokenToUpdate, BiosVersion, NULL);\r
887\r
888 //\r
889 // Check IfwiVersion, to avoid no IFWI version in SMBIOS Type 0 strucntion\r
890 //\r
891 if(IfwiVersion) {\r
892 TokenToUpdate = STRING_TOKEN (STR_IFWI_VERSION_VALUE);\r
893 HiiSetString (mHiiHandle, TokenToUpdate, IfwiVersion, NULL);\r
894 }\r
895 }\r
896 } while (!EFI_ERROR(Status));\r
897\r
898 UpdateLatestBootTime();\r
899\r
900 return EFI_SUCCESS;\r
901}\r
902\r
903VOID\r
904UpdateCPUInformation ()\r
905{\r
906 CHAR16 Buffer[40];\r
907 UINT16 FamilyId;\r
908 UINT8 Model;\r
909 UINT8 SteppingId;\r
910 UINT8 ProcessorType;\r
911 EFI_STATUS Status;\r
912 EFI_MP_SERVICES_PROTOCOL *MpService;\r
913 UINTN MaximumNumberOfCPUs;\r
914 UINTN NumberOfEnabledCPUs;\r
915 UINT32 Buffer32 = 0xFFFFFFFF; // Keep buffer with unknown device\r
916\r
917 EfiCpuVersion (&FamilyId, &Model, &SteppingId, &ProcessorType);\r
918\r
919 //\r
920 //we need raw Model data\r
921 //\r
922 Model = Model & 0xf;\r
923\r
924 //\r
925 //Family/Model/Step\r
926 //\r
927 UnicodeSPrint (Buffer, sizeof (Buffer), L"%d/%d/%d", FamilyId, Model, SteppingId);\r
928 HiiSetString(mHiiHandle,STRING_TOKEN(STR_PROCESSOR_ID_VALUE), Buffer, NULL);\r
929\r
930 Status = gBS->LocateProtocol (\r
931 &gEfiMpServiceProtocolGuid,\r
932 NULL,\r
933 (void **)&MpService\r
934 );\r
935 if (!EFI_ERROR (Status)) {\r
936 //\r
937 // Determine the number of processors\r
938 //\r
939 MpService->GetNumberOfProcessors (\r
940 MpService,\r
941 &MaximumNumberOfCPUs,\r
942 &NumberOfEnabledCPUs\r
943 );\r
944 UnicodeSPrint (Buffer, sizeof (Buffer), L"%d", MaximumNumberOfCPUs);\r
945 HiiSetString(mHiiHandle,STRING_TOKEN(STR_PROCESSOR_CORE_VALUE), Buffer, NULL);\r
946 }\r
947 //\r
948 // Update Mobile / Desktop / Tablet SKU\r
949 //\r
950 Buffer32 =(UINT32) RShiftU64 (EfiReadMsr (MSR_IA32_PLATFORM_ID), 50) & 0x07;\r
951\r
952 switch(Buffer32){\r
953 case 0x0:\r
954 UnicodeSPrint (Buffer, sizeof (Buffer), L"(%d) - ISG SKU SOC", Buffer32);\r
955 break;\r
956 case 0x01:\r
957 UnicodeSPrint (Buffer, sizeof (Buffer), L"(%d) - Mobile SKU SOC", Buffer32);\r
958 break;\r
959 case 0x02:\r
960 UnicodeSPrint (Buffer, sizeof (Buffer), L"(%d) - Desktop SKU SOC", Buffer32);\r
961 break;\r
962 case 0x03:\r
963 UnicodeSPrint (Buffer, sizeof (Buffer), L"(%d) - Mobile SKU SOC", Buffer32);\r
964 break;\r
965 default:\r
966 UnicodeSPrint (Buffer, sizeof (Buffer), L"(%d) - Unknown SKU SOC", Buffer32);\r
967 break;\r
968 }\r
969 HiiSetString(mHiiHandle,STRING_TOKEN(STR_PROCESSOR_SKU_VALUE), Buffer, NULL);\r
970\r
971}\r
972\r
973\r
974EFI_STATUS\r
975SearchChildHandle(\r
976 EFI_HANDLE Father,\r
977 EFI_HANDLE *Child\r
978 )\r
979{\r
980 EFI_STATUS Status;\r
981 UINTN HandleIndex;\r
982 EFI_GUID **ProtocolGuidArray = NULL;\r
983 UINTN ArrayCount;\r
984 UINTN ProtocolIndex;\r
985 UINTN OpenInfoCount;\r
986 UINTN OpenInfoIndex;\r
987 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo = NULL;\r
988 UINTN mHandleCount;\r
989 EFI_HANDLE *mHandleBuffer= NULL;\r
990\r
991 //\r
992 // Retrieve the list of all handles from the handle database\r
993 //\r
994 Status = gBS->LocateHandleBuffer (\r
995 AllHandles,\r
996 NULL,\r
997 NULL,\r
998 &mHandleCount,\r
999 &mHandleBuffer\r
1000 );\r
1001\r
1002 for (HandleIndex = 0; HandleIndex < mHandleCount; HandleIndex++)\r
1003 {\r
1004 //\r
1005 // Retrieve the list of all the protocols on each handle\r
1006 //\r
1007 Status = gBS->ProtocolsPerHandle (\r
1008 mHandleBuffer[HandleIndex],\r
1009 &ProtocolGuidArray,\r
1010 &ArrayCount\r
1011 );\r
1012 if (!EFI_ERROR (Status))\r
1013 {\r
1014 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++)\r
1015 {\r
1016 Status = gBS->OpenProtocolInformation (\r
1017 mHandleBuffer[HandleIndex],\r
1018 ProtocolGuidArray[ProtocolIndex],\r
1019 &OpenInfo,\r
1020 &OpenInfoCount\r
1021 );\r
1022 if (!EFI_ERROR (Status))\r
1023 {\r
1024 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++)\r
1025 {\r
1026 if(OpenInfo[OpenInfoIndex].AgentHandle == Father)\r
1027 {\r
1028 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) == EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER)\r
1029 {\r
1030 *Child = mHandleBuffer[HandleIndex];\r
1031 Status = EFI_SUCCESS;\r
1032 goto TryReturn;\r
1033 }\r
1034 }\r
1035 }\r
1036 Status = EFI_NOT_FOUND;\r
1037 }\r
1038 }\r
1039 if(OpenInfo != NULL)\r
1040 {\r
1041 FreePool(OpenInfo);\r
1042 OpenInfo = NULL;\r
1043 }\r
1044 }\r
1045 FreePool (ProtocolGuidArray);\r
1046 ProtocolGuidArray = NULL;\r
1047 }\r
1048TryReturn:\r
1049 if(OpenInfo != NULL)\r
1050 {\r
1051 FreePool (OpenInfo);\r
1052 OpenInfo = NULL;\r
1053 }\r
1054 if(ProtocolGuidArray != NULL)\r
1055 {\r
1056 FreePool(ProtocolGuidArray);\r
1057 ProtocolGuidArray = NULL;\r
1058 }\r
1059 if(mHandleBuffer != NULL)\r
1060 {\r
1061 FreePool (mHandleBuffer);\r
1062 mHandleBuffer = NULL;\r
1063 }\r
1064 return Status;\r
1065}\r
1066\r
1067EFI_STATUS\r
1068JudgeHandleIsPCIDevice(\r
1069 EFI_HANDLE Handle,\r
1070 UINT8 Device,\r
1071 UINT8 Funs\r
1072 )\r
1073{\r
1074 EFI_STATUS Status;\r
1075 EFI_DEVICE_PATH *DPath;\r
3cbfba02
DW		 1076\r
1077 Status = gBS->HandleProtocol (\r
1078 Handle,\r
1079 &gEfiDevicePathProtocolGuid,\r
1080 (VOID **) &DPath\r
1081 );\r
1082 if(!EFI_ERROR(Status))\r
1083 {\r
3cbfba02
DW		 1084 while(!IsDevicePathEnd(DPath))\r
1085 {\r
1086 if((DPath->Type == HARDWARE_DEVICE_PATH) && (DPath->SubType == HW_PCI_DP))\r
1087 {\r
1088 PCI_DEVICE_PATH *PCIPath;\r
1089\r
1090 PCIPath = (PCI_DEVICE_PATH*) DPath;\r
1091 DPath = NextDevicePathNode(DPath);\r
1092 if(IsDevicePathEnd(DPath) && (PCIPath->Device == Device) && (PCIPath->Function == Funs))\r
1093 {\r
1094 return EFI_SUCCESS;\r
1095 }\r
1096 }\r
1097 else\r
1098 {\r
1099 DPath = NextDevicePathNode(DPath);\r
1100 }\r
1101 }\r
1102 }\r
1103 return EFI_UNSUPPORTED;\r
1104}\r
1105\r
1106EFI_STATUS\r
1107GetDriverName(\r
1108 EFI_HANDLE Handle,\r
1109 CHAR16 *Name\r
1110 )\r
1111{\r
1112 EFI_DRIVER_BINDING_PROTOCOL *BindHandle = NULL;\r
1113 EFI_STATUS Status;\r
1114 UINT32 Version;\r
1115 UINT16 *Ptr;\r
1116 Status = gBS->OpenProtocol(\r
1117 Handle,\r
1118 &gEfiDriverBindingProtocolGuid,\r
1119 (VOID**)&BindHandle,\r
1120 NULL,\r
1121 NULL,\r
1122 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
1123 );\r
1124\r
1125 if (EFI_ERROR(Status))\r
1126 {\r
1127 return EFI_NOT_FOUND;\r
1128 }\r
1129\r
1130 Version = BindHandle->Version;\r
1131 Ptr = (UINT16*)&Version;\r
1132 UnicodeSPrint(Name, 40, L"%d.%d.%d", Version >> 24 , (Version >>16)& 0x0f ,*(Ptr));\r
1133\r
1134 return EFI_SUCCESS;\r
1135}\r
1136\r
1137EFI_STATUS\r
1138GetGOPDriverName(\r
1139 CHAR16 *Name\r
1140 )\r
1141{\r
1142 UINTN HandleCount;\r
1143 EFI_HANDLE *Handles= NULL;\r
1144 UINTN Index;\r
1145 EFI_STATUS Status;\r
1146 EFI_HANDLE Child = 0;\r
1147\r
1148 Status = gBS->LocateHandleBuffer(\r
1149 ByProtocol,\r
1150 &gEfiDriverBindingProtocolGuid,\r
1151 NULL,\r
1152 &HandleCount,\r
1153 &Handles\r
1154 );\r
1155 for (Index = 0; Index < HandleCount ; Index++)\r
1156 {\r
1157 Status = SearchChildHandle(Handles[Index], &Child);\r
1158 if(!EFI_ERROR(Status))\r
1159 {\r
1160 Status = JudgeHandleIsPCIDevice(\r
1161 Child,\r
1162 0x02,\r
1163 0x00\r
1164 );\r
1165 if(!EFI_ERROR(Status))\r
1166 {\r
1167 return GetDriverName(Handles[Index], Name);\r
1168 }\r
1169 }\r
1170 }\r
1171 return EFI_UNSUPPORTED;\r
1172}\r
1173\r
1174EFI_STATUS\r
1175UpdatePlatformInformation (\r
1176 )\r
1177{\r
1178 UINT32 MicroCodeVersion;\r
1179 CHAR16 Buffer[40];\r
1180 UINT8 IgdVBIOSRevH;\r
1181 UINT8 IgdVBIOSRevL;\r
1182 UINT16 EDX;\r
1183 EFI_IA32_REGISTER_SET RegSet;\r
1184 EFI_LEGACY_BIOS_PROTOCOL *LegacyBios = NULL;\r
1185 EFI_STATUS Status;\r
1186 UINT8 CpuFlavor=0;\r
1187 EFI_PEI_HOB_POINTERS GuidHob;\r
1188 EFI_PLATFORM_INFO_HOB *mPlatformInfo=NULL;\r
1189 UINTN NumHandles;\r
1190 EFI_HANDLE *HandleBuffer;\r
1191 UINTN Index;\r
1192 DXE_PCH_PLATFORM_POLICY_PROTOCOL *PchPlatformPolicy;\r
1193 UINTN PciD31F0RegBase;\r
1194 UINT8 count;\r
1195 UINT8 Data8;\r
1196 UINT8 PIDData8;\r
1197\r
1198 CHAR16 Name[40];\r
1199 UINT32 MrcVersion;\r
1200\r
1201 //\r
1202 // Get the HOB list. If it is not present, then ASSERT.\r
1203 //\r
1204 GuidHob.Raw = GetHobList ();\r
1205 if (GuidHob.Raw != NULL) {\r
1206 if ((GuidHob.Raw = GetNextGuidHob (&gEfiPlatformInfoGuid, GuidHob.Raw)) != NULL) {\r
1207 mPlatformInfo = GET_GUID_HOB_DATA (GuidHob.Guid);\r
1208 }\r
1209 }\r
1210\r
1211 //\r
1212 //VBIOS version\r
1213 //\r
1214 Status = gBS->LocateProtocol(\r
1215 &gEfiLegacyBiosProtocolGuid,\r
1216 NULL,\r
1217 (void **)&LegacyBios\r
1218 );\r
1219 if (!EFI_ERROR (Status)) {\r
1220 RegSet.X.AX = 0x5f01;\r
1221 Status = LegacyBios->Int86 (LegacyBios, 0x10, &RegSet);\r
1222 ASSERT_EFI_ERROR(Status);\r
1223\r
1224 //\r
1225 // simulate AMI int15 (ax=5f01) handler\r
1226 // check NbInt15.asm in AMI code for asm edition\r
1227 //\r
1228 EDX = (UINT16)((RegSet.E.EBX >> 16) & 0xffff);\r
1229 IgdVBIOSRevH = (UINT8)(((EDX & 0x0F00) >> 4) | (EDX & 0x000F));\r
1230 IgdVBIOSRevL = (UINT8)(((RegSet.X.BX & 0x0F00) >> 4) | (RegSet.X.BX & 0x000F));\r
1231\r
1232 if (IgdVBIOSRevH==0 && IgdVBIOSRevL==0){\r
1233 HiiSetString(mHiiHandle, STRING_TOKEN(STR_CHIP_IGD_VBIOS_REV_VALUE), L"N/A", NULL);\r
1234 } else {\r
1235 UnicodeSPrint (Buffer, sizeof (Buffer), L"%02X%02X", IgdVBIOSRevH,IgdVBIOSRevL);\r
1236 HiiSetString(mHiiHandle, STRING_TOKEN(STR_CHIP_IGD_VBIOS_REV_VALUE), Buffer, NULL);\r
1237 }\r
1238 }\r
1239\r
1240 Status = GetGOPDriverName(Name);\r
1241\r
1242 if (!EFI_ERROR(Status))\r
1243 {\r
1244 HiiSetString(mHiiHandle, STRING_TOKEN(STR_GOP_VALUE), Name, NULL);\r
1245 }\r
1246\r
1247\r
1248 //\r
1249 // CpuFlavor\r
1250 // ISG-DC Tablet 000\r
1251 // VLV-QC Tablet 001\r
1252 // VLV-QC Desktop 010\r
1253 // VLV-QC Notebook 011\r
1254 //\r
1255 CpuFlavor = RShiftU64 (EfiReadMsr (MSR_IA32_PLATFORM_ID), 50) & 0x07;\r
1256\r
1257 switch(CpuFlavor){\r
1258 case 0x0:\r
1259 UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-DC Tablet", CpuFlavor);\r
1260 break;\r
1261 case 0x01:\r
1262 UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-QC Notebook", CpuFlavor);\r
1263 break;\r
1264 case 0x02:\r
1265 UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-QC Desktop", CpuFlavor);\r
1266 break;\r
1267 case 0x03:\r
1268 UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"VLV-QC Notebook", CpuFlavor);\r
1269 break;\r
1270 default:\r
1271 UnicodeSPrint (Buffer, sizeof (Buffer), L"%s (%01x)", L"Unknown CPU", CpuFlavor);\r
1272 break;\r
1273 }\r
1274 HiiSetString(mHiiHandle,STRING_TOKEN(STR_CPU_FLAVOR_VALUE), Buffer, NULL);\r
1275\r
1276 if ( NULL != mPlatformInfo) {\r
1277 //\r
1278 //BoardId\r
1279 //\r
1280 switch(mPlatformInfo->BoardId){\r
1281 case 0x2:\r
1282 UnicodeSPrint (Buffer, sizeof (Buffer), L"BAY LAKE RVP(%02x)", mPlatformInfo->BoardId);\r
1283 break;\r
1284\r
1285 case 0x4:\r
1286 UnicodeSPrint (Buffer, sizeof (Buffer), L"BAY LAKE FFRD(%02x)", mPlatformInfo->BoardId);\r
1287 break;\r
1288\r
1289 case 0x5:\r
1290 UnicodeSPrint (Buffer, sizeof (Buffer), L"BAY ROCK RVP DDR3L (%02x)", mPlatformInfo->BoardId);\r
1291 break;\r
1292\r
1293 case 0x20:\r
1294 UnicodeSPrint (Buffer, sizeof (Buffer), L"BAYLEY BAY (%02x)", mPlatformInfo->BoardId);\r
1295 break;\r
1296\r
1297 case 0x30:\r
1298 UnicodeSPrint (Buffer, sizeof (Buffer), L"BAKER SPORT (%02x)", mPlatformInfo->BoardId);\r
1299 break;\r
1300\r
1301 case 0x0:\r
1302 UnicodeSPrint (Buffer, sizeof (Buffer), L"ALPINE VALLEY (%x)", mPlatformInfo->BoardId);\r
1303 break;\r
1304\r
1305 case 0x3:\r
1306 UnicodeSPrint (Buffer, sizeof (Buffer), L"BAY LAKE FFD8 (%x)", mPlatformInfo->BoardId);\r
1307 break;\r
1308\r
1309 default:\r
1310 UnicodeSPrint (Buffer, sizeof (Buffer), L"Unknown BOARD (%02x)", mPlatformInfo->BoardId);\r
1311 break;\r
1312 }\r
1313 HiiSetString(mHiiHandle,STRING_TOKEN(STR_BOARD_ID_VALUE), Buffer, NULL);\r
1314\r
1315\r
1316 //\r
1317 // Get Board FAB ID Info from protocol, update into the NVS area.\r
1318 // bit0~bit3 are for Fab ID, 0x0F means unknow FAB.\r
1319 //\r
1320 if(mPlatformInfo->BoardRev == 0x0F) {\r
1321 UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", L"Unknown FAB");\r
1322 HiiSetString(mHiiHandle,STRING_TOKEN(STR_FAB_ID_VALUE), Buffer, NULL);\r
1323 } else {\r
1324 UnicodeSPrint (Buffer, sizeof (Buffer), L"%2x", mPlatformInfo->BoardRev);\r
1325 HiiSetString(mHiiHandle,STRING_TOKEN(STR_FAB_ID_VALUE), Buffer, NULL);\r
1326 }\r
1327 }\r
1328\r
1329 //\r
1330 //Update MRC Version\r
1331 //\r
1332 MrcVersion = 0x00000000;\r
1333 MrcVersion &= 0xffff;\r
1334 Index = EfiValueToString (Buffer, MrcVersion/100, PREFIX_ZERO, 0);\r
1335 StrCat (Buffer, L".");\r
1336 EfiValueToString (Buffer + Index + 1, (MrcVersion%100)/10, PREFIX_ZERO, 0);\r
1337 EfiValueToString (Buffer + Index + 2, (MrcVersion%100)%10, PREFIX_ZERO, 0);\r
1338 HiiSetString(mHiiHandle,STRING_TOKEN(STR_MRC_VERSION_VALUE), Buffer, NULL);\r
1339\r
1340 //\r
1341 //Update Soc Version\r
1342 //\r
1343\r
1344 //\r
1345 // Retrieve all instances of PCH Platform Policy protocol\r
1346 //\r
1347 Status = gBS->LocateHandleBuffer (\r
1348 ByProtocol,\r
1349 &gDxePchPlatformPolicyProtocolGuid,\r
1350 NULL,\r
1351 &NumHandles,\r
1352 &HandleBuffer\r
1353 );\r
1354 if (!EFI_ERROR (Status)) {\r
1355 //\r
1356 // Find the matching PCH Policy protocol\r
1357 //\r
1358 for (Index = 0; Index < NumHandles; Index++) {\r
1359 Status = gBS->HandleProtocol (\r
1360 HandleBuffer[Index],\r
1361 &gDxePchPlatformPolicyProtocolGuid,\r
1362 (void **)&PchPlatformPolicy\r
1363 );\r
1364 if (!EFI_ERROR (Status)) {\r
1365 PciD31F0RegBase = MmPciAddress (\r
1366 0,\r
1367 PchPlatformPolicy->BusNumber,\r
1368 PCI_DEVICE_NUMBER_PCH_LPC,\r
1369 PCI_FUNCTION_NUMBER_PCH_LPC,\r
1370 0\r
1371 );\r
1372\r
1373 Data8 = MmioRead8 (PciD31F0RegBase + R_PCH_LPC_RID_CC);\r
67f60d3b 1374 count = ARRAY_SIZE (SBRevisionTable);\r
3cbfba02
DW		 1375 for (Index = 0; Index < count; Index++) {\r
1376 if(Data8 == SBRevisionTable[Index].RevId) {\r
1377 UnicodeSPrint (Buffer, sizeof (Buffer), L"%02x %a", Data8, SBRevisionTable[Index].String);\r
1378 HiiSetString(mHiiHandle,STRING_TOKEN(STR_SOC_VALUE), Buffer, NULL);\r
1379 break;\r
1380 }\r
1381 }\r
1382 break;\r
1383 }\r
1384 }\r
1385 }\r
1386\r
1387 //\r
1388 // Microcode Revision\r
1389 //\r
1390 EfiWriteMsr (EFI_MSR_IA32_BIOS_SIGN_ID, 0);\r
1391 EfiCpuid (EFI_CPUID_VERSION_INFO, NULL);\r
1392 MicroCodeVersion = (UINT32) RShiftU64 (EfiReadMsr (EFI_MSR_IA32_BIOS_SIGN_ID), 32);\r
1393 UnicodeSPrint (Buffer, sizeof (Buffer), L"%x", MicroCodeVersion);\r
1394 HiiSetString(mHiiHandle,STRING_TOKEN(STR_PROCESSOR_MICROCODE_VALUE), Buffer, NULL);\r
1395\r
1396 //\r
1397 // Punit Version\r
1398 //\r
1399 Data8 = 0;\r
1400 UnicodeSPrint (Buffer, sizeof (Buffer), L"0x%x", Data8);\r
1401 HiiSetString(mHiiHandle,STRING_TOKEN(STR_PUNIT_FW_VALUE), Buffer, NULL);\r
1402\r
1403 //\r
1404 // PMC Version\r
1405 //\r
1406 Data8 = (UINT8)((MmioRead32 (PMC_BASE_ADDRESS + R_PCH_PMC_PRSTS)>>16)&0x00FF);\r
1407 PIDData8 = (UINT8)((MmioRead32 (PMC_BASE_ADDRESS + R_PCH_PMC_PRSTS)>>24)&0x00FF);\r
1408 UnicodeSPrint (Buffer, sizeof (Buffer), L"0x%X_%X",PIDData8, Data8);\r
1409 HiiSetString(mHiiHandle,STRING_TOKEN(STR_PMC_FW_VALUE), Buffer, NULL);\r
1410\r
1411 return EFI_SUCCESS;\r
1412}\r
1413\r
1414/**\r
1415\r
1416 Update SATA Drivesize Strings for Setup and Boot order\r
1417\r
1418 @param NewString - pointer to string.\r
1419 @param DeviceSpeed - speed of drive.\r
1420\r
1421**/\r
1422VOID\r
1423GetDeviceSpeedString (\r
1424 CHAR16 *NewString,\r
1425 IN UINTN DeviceSpeed\r
1426 )\r
1427{\r
1428 if (DeviceSpeed == 0x01) {\r
1429 StrCat (NewString, L"1.5Gb/s");\r
1430 } else if (DeviceSpeed == 0x02) {\r
1431 StrCat (NewString, L"3.0Gb/s");\r
1432 } else if (DeviceSpeed == 0x03) {\r
1433 StrCat (NewString, L"6.0Gb/s");\r
1434 } else if (DeviceSpeed == 0x0) {\r
1435\r
1436 }\r
1437}\r
1438\r
1439UINT8\r
1440GetChipsetSataPortSpeed (\r
1441 UINTN PortNum\r
1442 )\r
1443{\r
1444 UINT32 DeviceSpeed;\r
1445 UINT8 DeviceConfigStatus;\r
1446 UINT32 IdeAhciBar;\r
1447 EFI_PHYSICAL_ADDRESS MemBaseAddress = 0;\r
1448 UINT8 FunNum;\r
3cbfba02
DW		 1449\r
1450 DeviceSpeed = 0x01; // generation 1\r
1451\r
1452\r
1453 //\r
1454 // Allocate the AHCI BAR\r
1455 //\r
1456 FunNum = PCI_FUNCTION_NUMBER_PCH_SATA;\r
1457 MemBaseAddress = 0x0ffffffff;\r
53000664
GL		 1458 gDS->AllocateMemorySpace (\r
1459 EfiGcdAllocateMaxAddressSearchBottomUp,\r
1460 EfiGcdMemoryTypeMemoryMappedIo,\r
1461 N_PCH_SATA_ABAR_ALIGNMENT, // 2^11: 2K Alignment\r
1462 V_PCH_SATA_ABAR_LENGTH, // 2K Length\r
1463 &MemBaseAddress,\r
1464 mImageHandle,\r
1465 NULL\r
1466 );\r
3cbfba02
DW		 1467 IdeAhciBar = MmioRead32 (\r
1468 MmPciAddress (\r
1469 0,\r
1470 0,\r
1471 PCI_DEVICE_NUMBER_PCH_SATA,\r
1472 FunNum,\r
1473 R_PCH_SATA_ABAR\r
1474 )\r
1475 );\r
1476 IdeAhciBar &= 0xFFFFF800;\r
1477 DeviceConfigStatus = 0;\r
1478 if (IdeAhciBar == 0) {\r
1479 DeviceConfigStatus = 1;\r
1480 IdeAhciBar = (UINT32)MemBaseAddress;\r
1481 MmioWrite32 (\r
1482 MmPciAddress (0, 0, PCI_DEVICE_NUMBER_PCH_SATA, FunNum, R_PCH_SATA_ABAR),\r
1483 IdeAhciBar\r
1484 );\r
1485 MmioOr16 (\r
1486 MmPciAddress (0, 0, PCI_DEVICE_NUMBER_PCH_SATA, FunNum, R_PCH_SATA_COMMAND),\r
1487 B_PCH_SATA_COMMAND_MSE\r
1488 );\r
1489 }\r
1490\r
1491 if (mSystemConfiguration.SataType == PCH_SATA_MODE_IDE){\r
1492 //\r
1493 // Program the "Ports Implemented Register"\r
1494 //\r
1495 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		 1496 }\r
1497\r
1498 switch (PortNum)\r
1499 {\r
1500 case 0:\r
1501 DeviceSpeed = *(volatile UINT32 *)(UINTN)(IdeAhciBar + R_PCH_SATA_AHCI_P0SSTS);\r
1502 break;\r
1503 case 1:\r
1504 DeviceSpeed = *(volatile UINT32 *)(UINTN)(IdeAhciBar + R_PCH_SATA_AHCI_P1SSTS);\r
1505 break;\r
1506 }\r
1507\r
1508 if (MemBaseAddress) {\r
1509 gDS->FreeMemorySpace (\r
1510 MemBaseAddress,\r
1511 V_PCH_SATA_ABAR_LENGTH\r
1512 );\r
1513 }\r
1514\r
1515 if (DeviceConfigStatus) {\r
1516 IdeAhciBar = 0;\r
1517 MmioWrite32 (\r
1518 MmPciAddress (0, 0, PCI_DEVICE_NUMBER_PCH_SATA, FunNum, R_PCH_SATA_ABAR),\r
1519 IdeAhciBar\r
1520 );\r
1521 }\r
1522\r
1523 DeviceSpeed = (UINT8)((DeviceSpeed >> 4) & 0x0F);\r
1524\r
1525 return (UINT8)DeviceSpeed;\r
1526}\r
1527\r
1528/**\r
1529\r
1530 IDE data filter function.\r
1531\r
1532**/\r
1533void\r
1534IdeDataFilter (void)\r
1535{\r
1536 EFI_STATUS Status;\r
1537 UINTN HandleCount;\r
1538 EFI_HANDLE *HandleBuffer;\r
1539 EFI_DISK_INFO_PROTOCOL *DiskInfo;\r
1540 EFI_DEVICE_PATH_PROTOCOL *DevicePath, *DevicePathNode;\r
1541 PCI_DEVICE_PATH *PciDevicePath;\r
1542 UINTN Index;\r
1543 UINT8 Index1;\r
1544 UINT32 BufferSize;\r
1545 UINT32 DriveSize;\r
1546 UINT32 IdeChannel;\r
1547 UINT32 IdeDevice;\r
1548 EFI_ATA_IDENTIFY_DATA *IdentifyDriveInfo;\r
1549 CHAR16 *NewString;\r
1550 CHAR16 SizeString[20];\r
1551 STRING_REF NameToUpdate;\r
1552 CHAR8 StringBuffer[0x100];\r
1553 UINT32 DeviceSpeed;\r
1554 UINTN PortNumber;\r
1555\r
1556 //\r
1557 // Assume no line strings is longer than 256 bytes.\r
1558 //\r
1559 NewString = AllocateZeroPool (0x100);\r
1560 PciDevicePath = NULL;\r
1561\r
1562 //\r
1563 // Fill IDE Infomation\r
1564 //\r
1565 Status = gBS->LocateHandleBuffer (\r
1566 ByProtocol,\r
1567 &gEfiDiskInfoProtocolGuid,\r
1568 NULL,\r
1569 &HandleCount,\r
1570 &HandleBuffer\r
1571 );\r
1572\r
1573 if (EFI_ERROR (Status)) {\r
1574 return;\r
1575 }\r
1576\r
1577 for (Index = 0; Index < HandleCount; Index++) {\r
1578\r
1579 Status = gBS->HandleProtocol (\r
1580 HandleBuffer[Index],\r
1581 &gEfiDevicePathProtocolGuid,\r
1582 (VOID*)&DevicePath\r
1583 );\r
1584 ASSERT_EFI_ERROR (Status);\r
1585\r
1586 DevicePathNode = DevicePath;\r
1587 while (!IsDevicePathEnd (DevicePathNode) ) {\r
1588 if ((DevicePathType (DevicePathNode) == HARDWARE_DEVICE_PATH) &&\r
1589 ( DevicePathSubType (DevicePathNode) == HW_PCI_DP)) {\r
1590 PciDevicePath = (PCI_DEVICE_PATH *) DevicePathNode;\r
1591 break;\r
1592 }\r
1593 DevicePathNode = NextDevicePathNode (DevicePathNode);\r
1594 }\r
1595\r
1596 if (PciDevicePath == NULL) {\r
1597 continue;\r
1598 }\r
1599\r
1600 //\r
1601 // Check for onboard IDE\r
1602 //\r
1603 if (PciDevicePath->Device== PCI_DEVICE_NUMBER_PCH_SATA) {\r
1604 Status = gBS->HandleProtocol (\r
1605 HandleBuffer[Index],\r
1606 &gEfiDiskInfoProtocolGuid,\r
1607 (void **)&DiskInfo\r
1608 );\r
1609 ASSERT_EFI_ERROR (Status);\r
1610\r
1611 Status = DiskInfo->WhichIde (\r
1612 DiskInfo,\r
1613 &IdeChannel,\r
1614 &IdeDevice\r
1615 );\r
1616 ASSERT_EFI_ERROR (Status);\r
1617\r
1618 IdentifyDriveInfo = AllocatePool (sizeof(EFI_ATA_IDENTIFY_DATA));\r
1619\r
1620 BufferSize = sizeof(EFI_ATA_IDENTIFY_DATA);\r
1621 Status = DiskInfo->Identify (\r
1622 DiskInfo,\r
1623 IdentifyDriveInfo,\r
1624 &BufferSize\r
1625 );\r
1626 ASSERT_EFI_ERROR(Status);\r
1627\r
1628 //\r
1629 // Onboard SATA Devices\r
1630 //\r
1631 if (PciDevicePath->Function == PCI_FUNCTION_NUMBER_PCH_SATA) {\r
1632 if (IdeChannel == 0 && IdeDevice == 0) {\r
1633 NameToUpdate = (STRING_REF)STR_SATA0_NAME;\r
1634 } else if (IdeChannel == 1 && IdeDevice == 0) {\r
1635 NameToUpdate = (STRING_REF)STR_SATA1_NAME;\r
1636 } else {\r
1637 continue;\r
1638 }\r
1639 } else {\r
1640 continue;\r
1641 }\r
1642\r
1643 ZeroMem(StringBuffer, sizeof(StringBuffer));\r
1644 CopyMem(\r
1645 StringBuffer,\r
1646 (CHAR8 *)&IdentifyDriveInfo->ModelName,\r
1647 sizeof(IdentifyDriveInfo->ModelName)\r
1648 );\r
1649 SwapEntries(StringBuffer);\r
1650 AsciiToUnicode(StringBuffer, NewString);\r
1651\r
1652 //\r
1653 // Chap it off after 16 characters\r
1654 //\r
1655 NewString[16] = 0;\r
1656\r
1657 //\r
1658 // For HardDisk append the size. Otherwise display atapi\r
1659 //\r
1660 if ((IdentifyDriveInfo->config & 0x8000) == 00) {\r
1661 //\r
1662 // 48 bit address feature set is supported, get maximum capacity\r
1663 //\r
1664 if ((IdentifyDriveInfo->command_set_supported_83 & 0x0400) == 0) {\r
1665 DriveSize = (((((IdentifyDriveInfo->user_addressable_sectors_hi << 16) +\r
1666 IdentifyDriveInfo->user_addressable_sectors_lo) / 1000) * 512) / 1000);\r
1667 } else {\r
1668 DriveSize = IdentifyDriveInfo->maximum_lba_for_48bit_addressing[0];\r
1669 for (Index1 = 1; Index1 < 4; Index1++) {\r
1670 //\r
1671 // Lower byte goes first: word[100] is the lowest word, word[103] is highest\r
1672 //\r
1673 DriveSize |= LShiftU64(IdentifyDriveInfo->maximum_lba_for_48bit_addressing[Index1], 16 * Index1);\r
1674 }\r
1675 DriveSize = (UINT32) DivU64x32(MultU64x32(DivU64x32(DriveSize, 1000), 512), 1000);\r
1676 }\r
1677\r
1678 StrCat (NewString, L"(");\r
1679 EfiValueToString (SizeString, DriveSize/1000, PREFIX_BLANK, 0);\r
1680 StrCat (NewString, SizeString);\r
1681 StrCat (NewString, L".");\r
1682 EfiValueToString (SizeString, (DriveSize%1000)/100, PREFIX_BLANK, 0);\r
1683 StrCat (NewString, SizeString);\r
1684 StrCat (NewString, L"GB");\r
1685 } else {\r
1686 StrCat (NewString, L"(ATAPI");\r
1687 }\r
1688\r
1689 //\r
1690 // Update SPEED.\r
1691 //\r
1692 PortNumber = (IdeDevice << 1) + IdeChannel;\r
1693 DeviceSpeed = GetChipsetSataPortSpeed(PortNumber);\r
1694\r
1695 if (DeviceSpeed) {\r
1696 StrCat (NewString, L"-");\r
1697 GetDeviceSpeedString( NewString, DeviceSpeed);\r
1698 }\r
1699\r
1700 StrCat (NewString, L")");\r
1701\r
1702 HiiSetString(mHiiHandle, NameToUpdate, NewString, NULL);\r
1703\r
1704 }\r
1705 }\r
1706\r
1707 if (HandleBuffer != NULL) {\r
1708 gBS->FreePool (HandleBuffer);\r
1709 }\r
1710\r
1711 gBS->FreePool(NewString);\r
1712\r
1713 return;\r
1714}\r
1715\r
1716\r
1717VOID\r
1718EFIAPI\r
1719SetupInfo (void)\r
1720{\r
1721 EFI_STATUS Status;\r
1722 UINTN VarSize;\r
1723 EFI_PEI_HOB_POINTERS GuidHob;\r
1724\r
1725 if (mSetupInfoDone) {\r
1726 return;\r
1727 }\r
1728\r
1729 VarSize = sizeof(SYSTEM_CONFIGURATION);\r
1730 Status = gRT->GetVariable(\r
1731 NORMAL_SETUP_NAME,\r
1732 &gEfiNormalSetupGuid,\r
1733 NULL,\r
1734 &VarSize,\r
1735 &mSystemConfiguration\r
1736 );\r
1737\r
620f2891
TH		 1738 if (EFI_ERROR (Status) || VarSize != sizeof(SYSTEM_CONFIGURATION)) {\r
1739 //The setup variable is corrupted\r
1740 VarSize = sizeof(SYSTEM_CONFIGURATION);\r
1741 Status = gRT->GetVariable(\r
1742 L"SetupRecovery",\r
1743 &gEfiNormalSetupGuid,\r
1744 NULL,\r
1745 &VarSize,\r
1746 &mSystemConfiguration\r
1747 );\r
1748 ASSERT_EFI_ERROR (Status);\r
1749 } \r
3cbfba02
DW		 1750\r
1751 //\r
1752 // Update HOB variable for PCI resource information\r
1753 // Get the HOB list. If it is not present, then ASSERT.\r
1754 //\r
1755 GuidHob.Raw = GetHobList ();\r
1756 if (GuidHob.Raw != NULL) {\r
1757 if ((GuidHob.Raw = GetNextGuidHob (&gEfiPlatformInfoGuid, GuidHob.Raw)) != NULL) {\r
1758 mPlatformInfo = GET_GUID_HOB_DATA (GuidHob.Guid);\r
1759 }\r
1760 }\r
1761\r
1762\r
1763 PrepareSetupInformation();\r
1764 UpdateAdditionalInformation ();\r
1765 UpdatePlatformInformation();\r
1766 UpdateCPUInformation();\r
1767 IdeDataFilter();\r
1768 mSetupInfoDone = TRUE;\r
1769\r
1770 return;\r
1771}\r
1772\r
1773\r
1774#define EFI_SECURE_BOOT_MODE_NAME L"SecureBoot"\r
1775\r
1776VOID\r
1777CheckSystemConfigLoad(SYSTEM_CONFIGURATION *SystemConfigPtr)\r
1778{\r
1779 EFI_STATUS Status;\r
1780 UINT8 SecureBoot;\r
1781 UINTN DataSize;\r
1782\r
1783\r
1784 DataSize = sizeof(SecureBoot);\r
1785 Status = gRT->GetVariable (\r
1786 EFI_SECURE_BOOT_MODE_NAME,\r
1787 &gEfiGlobalVariableGuid,\r
1788 NULL,\r
1789 &DataSize,\r
1790 &SecureBoot\r
1791 );\r
1792\r
1793 if (EFI_ERROR(Status)) {\r
1794 SystemConfigPtr->SecureBoot = 0;\r
1795 } else {\r
1796 SystemConfigPtr->SecureBoot = SecureBoot;\r
1797 }\r
1798}\r
1799\r
1800\r
1801//\r
1802// "SecureBootEnable" variable for the Secure boot feature enable/disable.\r
1803//\r
1804#define EFI_SECURE_BOOT_ENABLE_NAME L"SecureBootEnable"\r
1805extern EFI_GUID gEfiSecureBootEnableDisableGuid;\r
1806\r
1807\r
1808VOID\r
1809CheckSystemConfigSave(SYSTEM_CONFIGURATION *SystemConfigPtr)\r
1810{\r
1811 EFI_STATUS Status;\r
1812 UINT8 SecureBootCfg;\r
1813 BOOLEAN SecureBootNotFound;\r
1814 UINTN DataSize;\r
1815\r
1816\r
1817 //\r
1818 // Secure Boot configuration changes\r
1819 //\r
1820 DataSize = sizeof(SecureBootCfg);\r
1821 SecureBootNotFound = FALSE;\r
1822 Status = gRT->GetVariable (\r
1823 EFI_SECURE_BOOT_ENABLE_NAME,\r
1824 &gEfiSecureBootEnableDisableGuid,\r
1825 NULL,\r
1826 &DataSize,\r
1827 &SecureBootCfg\r
1828 );\r
1829\r
1830 if (EFI_ERROR(Status)) {\r
1831 SecureBootNotFound = TRUE;\r
1832 }\r
1833 if (SecureBootNotFound) {\r
1834 Status = gRT->GetVariable (\r
1835 EFI_SECURE_BOOT_ENABLE_NAME,\r
1836 &gEfiSecureBootEnableDisableGuid,\r
1837 NULL,\r
1838 &DataSize,\r
1839 &SecureBootCfg\r
1840 );\r
1841 ASSERT_EFI_ERROR(Status);\r
1842 }\r
1843 if ((SecureBootCfg) != SystemConfigPtr->SecureBoot) {\r
1844 SecureBootCfg = !SecureBootCfg;\r
1845 Status = gRT->SetVariable (\r
1846 EFI_SECURE_BOOT_ENABLE_NAME,\r
1847 &gEfiSecureBootEnableDisableGuid,\r
1848 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
1849 sizeof (UINT8),\r
1850 &SecureBootCfg\r
1851 );\r
1852 }\r
1853\r
1854}\r
1855\r
1856VOID\r
1857ConfirmSecureBootTest()\r
1858{\r
1859\r
1860}\r
1861\r
EFI Development Kit II mirror for PVE