5e4f9a62439913aef3ad65a7bc1610f70b4c3a16
[efi/shell/.git] / SmbiosView / PrintInfo.c
1 /*++
2
3 Copyright (c) 2005 - 2008, Intel Corporation                                                         
4 All rights reserved. This program and the accompanying materials                          
5 are licensed and made available under the terms and conditions of the BSD License         
6 which accompanies this distribution. The full text of the license may be found at         
7 http://opensource.org/licenses/bsd-license.php                                            
8                                                                                           
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
11
12 Module Name:
13
14     PrintInfo.c
15     
16 Abstract:
17
18     Module for clarifying the content of the smbios structure element information.
19
20 Revision History
21
22 --*/
23
24 #include "EfiShellLib.h"
25 #include "PrintInfo.h"
26 #include "LibSmbiosView.h"
27 #include "QueryTable.h"
28 #include "EventLogInfo.h"
29 #include "smbios.h"
30 #include STRING_DEFINES_FILE
31
32 //
33 // Get the certain bit of 'value'
34 //
35 #define BIT(value, bit) ((value) & ((UINT64) 1) << (bit))
36
37 //
38 //////////////////////////////////////////////////////////
39 //  Macros of print structure element, simplify coding.
40 //
41 #define PrintPendingString(pStruct, type, element) \
42   do { \
43     CHAR8 StringBuf[64]; \
44     SetMem (StringBuf, sizeof (StringBuf), 0x00); \
45     SmbiosGetPendingString ((pStruct), (pStruct->type->element), StringBuf); \
46     APrint (#element); \
47     APrint (": %a\n", StringBuf); \
48   } while (0);
49
50 #define PrintSmbiosString(pStruct, stringnumber, element) \
51   do { \
52     CHAR8 StringBuf[64]; \
53     SetMem (StringBuf, sizeof (StringBuf), 0x00); \
54     SmbiosGetPendingString ((pStruct), (stringnumber), StringBuf); \
55     APrint (#element); \
56     APrint (": %a\n", StringBuf); \
57   } while (0);
58
59 #define PrintStructValue(pStruct, type, element) \
60   do { \
61     APrint (#element); \
62     APrint (": %d\n", (pStruct->type->element)); \
63   } while (0);
64
65 #define PrintStructValueH(pStruct, type, element) \
66   do { \
67     APrint (#element); \
68     APrint (": 0x%x\n", (pStruct->type->element)); \
69   } while (0);
70
71 #define PrintBitField(pStruct, type, element, size) \
72   do { \
73     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DUMP), HiiHandle); \
74     APrint (#element); \
75     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SIZE), HiiHandle, size); \
76     DumpHex (0, 0, size, &(pStruct->type->element)); \
77   } while (0);
78
79 #define PrintSmbiosBitField(pStruct, startaddress, element, size) \
80   do { \
81     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DUMP), HiiHandle); \
82     APrint (#element); \
83     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SIZE), HiiHandle, size); \
84     DumpHex (0, 0, size, startaddress); \
85   } while (0);
86
87 //
88 /////////////////////////////////////////
89 //
90 STATIC
91 VOID
92 MemToString (
93   IN OUT VOID   *Dest,
94   IN VOID       *Src,
95   IN UINTN      Length
96   )
97 /*++
98
99 Routine Description:
100   Copy Length of Src buffer to Dest buffer, 
101   add a NULL termination to Dest buffer.
102
103 Arguments:
104   Dest      - Destination buffer head
105   Src       - Source buffer head
106   Length    - Length of buffer to be copied
107
108 Returns:
109   None.
110
111 --*/
112 {
113   UINT8 *SrcBuffer;
114   UINT8 *DestBuffer;
115   SrcBuffer   = (UINT8 *) Src;
116   DestBuffer  = (UINT8 *) Dest;
117   //
118   // copy byte by byte
119   //
120   while (Length--) {
121     *DestBuffer++ = *SrcBuffer++;
122   }
123   //
124   // append a NULL terminator
125   //
126   *DestBuffer = '\0';
127 }
128
129 //
130 //////////////////////////////////////////////
131 //
132 // Functions below is to show the information
133 //
134 VOID
135 SmbiosPrintEPSInfo (
136   IN  SMBIOS_STRUCTURE_TABLE  *SmbiosTable,
137   IN  UINT8                   Option
138   )
139 /*++
140
141 Routine Description:
142   Print the info of EPS(Entry Point Structure)
143
144 Arguments:
145   SmbiosTable    - Pointer to the SMBIOS table entry point
146   Option         - Display option
147
148 Returns: None
149
150 --*/
151 {
152   UINT8 Anchor[5];
153   UINT8 InAnchor[6];
154
155   if (SmbiosTable == NULL) {
156     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SMBIOSTABLE_NULL), HiiHandle);
157     return ;
158   }
159
160   if (Option == SHOW_NONE) {
161     return ;
162   }
163
164   if (Option >= SHOW_NORMAL) {
165     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENTRY_POINT_SIGN), HiiHandle);
166     MemToString (Anchor, SmbiosTable->AnchorString, 4);
167     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ANCHOR_STR), HiiHandle, Anchor);
168     PrintToken (
169       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_EPS_CHECKSUM),
170       HiiHandle,
171       SmbiosTable->EntryPointStructureChecksum
172       );
173     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENTRY_POINT_LEN), HiiHandle, SmbiosTable->EntryPointLength);
174     PrintToken (
175       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VERSION),
176       HiiHandle,
177       SmbiosTable->MajorVersion,
178       SmbiosTable->MinorVersion
179       );
180     PrintToken (
181       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NUMBER_STRUCT),
182       HiiHandle,
183       SmbiosTable->NumberOfSmbiosStructures
184       );
185     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MAX_STRUCT_SIZE), HiiHandle, SmbiosTable->MaxStructureSize);
186     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_TABLE_ADDR), HiiHandle, SmbiosTable->TableAddress);
187     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_TABLE_LENGTH), HiiHandle, SmbiosTable->TableLength);
188
189   }
190   //
191   // If SHOW_ALL, also print followings.
192   //
193   if (Option >= SHOW_DETAIL) {
194     PrintToken (
195       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENTRY_POINT_REVISION),
196       HiiHandle,
197       SmbiosTable->EntryPointRevision
198       );
199     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BCD_REVISION), HiiHandle, SmbiosTable->SmbiosBcdRevision);
200     //
201     // Since raw data is not string, add a NULL terminater.
202     //
203     MemToString (InAnchor, SmbiosTable->IntermediateAnchorString, 5);
204     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTER_ACHOR), HiiHandle, InAnchor);
205     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTER_CHECKSUM), HiiHandle, SmbiosTable->IntermediateChecksum);
206     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FORMATTED_AREA), HiiHandle);
207     DumpHex (2, 0, 5, SmbiosTable->FormattedArea);
208   }
209
210   Print (L"\n");
211 }
212
213 EFI_STATUS
214 SmbiosPrintStructure (
215   IN  SMBIOS_STRUCTURE_POINTER  *pStruct,
216   IN  UINT8                     Option
217   )
218 /*++
219
220 Routine Description:
221   This function print the content of the structure pointed by pStruct
222
223 Arguments:
224   pStruct     - point to the structure to be printed
225   Option      - print option of information detail
226
227 Returns:
228   EFI_SUCCESS             - Successfully Printing this function 
229   EFI_INVALID_PARAMETER   - Invalid Structure
230   EFI_UNSUPPORTED         - Unsupported
231
232 --*/
233 {
234   UINT8 Index;
235   UINT8 *Buffer;
236
237   Buffer = (UINT8 *) (UINTN) (pStruct->Raw);
238
239   if (pStruct == NULL) {
240     return EFI_INVALID_PARAMETER;
241   }
242
243   if (Option == SHOW_NONE) {
244     return EFI_SUCCESS;
245   }
246   //
247   // Display structure header
248   //
249   DisplayStructureTypeInfo (pStruct->Hdr->Type, SHOW_DETAIL);
250   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FORMAT_PART_LEN), HiiHandle, pStruct->Hdr->Length);
251   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_STRUCT_HANDLE), HiiHandle, pStruct->Hdr->Handle);
252
253   if (Option == SHOW_OUTLINE) {
254     return EFI_SUCCESS;
255   }
256
257   switch (pStruct->Hdr->Type) {
258   //
259   //
260   //
261   case 0:
262     PrintPendingString (pStruct, Type0, Vendor);
263     PrintPendingString (pStruct, Type0, BiosVersion);
264     PrintStructValue (pStruct, Type0, BiosSegment);
265     PrintPendingString (pStruct, Type0, BiosReleaseDate);
266     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_SIZE), HiiHandle, 64 * (pStruct->Type0->BiosSize + 1));
267
268     if (Option < SHOW_DETAIL) {
269       PrintStructValueH (pStruct, Type0, BiosCharacteristics);
270     } else {
271       DisplayBiosCharacteristics (pStruct->Type0->BiosCharacteristics, Option);
272
273       //
274       // The length of above format part is 0x12 bytes,
275       // Ext bytes are following, size = 'len-0x12'.
276       // If len-0x12 > 0, then
277       //    there are extension bytes (byte1, byte2, byte3...)
278       // And byte3 not stated in spec, so dump all extension bytes(1, 2, 3..)
279       //
280       if ((Buffer[1] - (CHAR8) 0x12) > 0) {
281         DisplayBiosCharacteristicsExt1 (Buffer[0x12], Option);
282       }
283
284       if ((Buffer[1] - (CHAR8) 0x12) > 1) {
285         DisplayBiosCharacteristicsExt2 (Buffer[0x13], Option);
286       }
287
288       if ((Buffer[1] - (CHAR8) 0x12) > 2) {
289         PrintBitField (
290           pStruct,
291           Type0,
292           BiosCharacteristics,
293           Buffer[1] - (CHAR8) 0x12
294           );
295       }
296     }
297     break;
298
299   //
300   // System Information (Type 1)
301   //
302   case 1:
303     PrintPendingString (pStruct, Type1, Manufacturer);
304     PrintPendingString (pStruct, Type1, ProductName);
305     PrintPendingString (pStruct, Type1, Version);
306     PrintPendingString (pStruct, Type1, SerialNumber);
307     PrintBitField (pStruct, Type1, Uuid, 16);
308     DisplaySystemWakeupType (pStruct->Type1->WakeUpType, Option);
309     break;
310
311   case 2:
312     PrintPendingString (pStruct, Type2, Manufacturer);
313     PrintPendingString (pStruct, Type2, ProductName);
314     PrintPendingString (pStruct, Type2, Version);
315     PrintPendingString (pStruct, Type2, SerialNumber);
316     break;
317
318   //
319   // System Enclosure (Type 3)
320   //
321   case 3:
322     PrintPendingString (pStruct, Type3, Manufacturer);
323     PrintStructValue (pStruct, Type3, Type);
324     DisplaySystemEnclosureType (pStruct->Type3->Type, Option);
325     PrintPendingString (pStruct, Type3, Version);
326     PrintPendingString (pStruct, Type3, SerialNumber);
327     PrintPendingString (pStruct, Type3, AssetTag);
328     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BOOTUP_STATE), HiiHandle);
329     DisplaySystemEnclosureStatus (pStruct->Type3->BootupState, Option);
330     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_STATE), HiiHandle);
331     DisplaySystemEnclosureStatus (pStruct->Type3->PowerSupplyState, Option);
332     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_THERMAL_STATE), HiiHandle);
333     DisplaySystemEnclosureStatus (pStruct->Type3->ThermalState, Option);
334     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SECURITY_STATUS), HiiHandle);
335     DisplaySESecurityStatus (pStruct->Type3->SecurityStatus, Option);
336     PrintBitField (pStruct, Type3, OemDefined, 4);
337     break;
338
339   //
340   // Processor Information (Type 4)
341   //
342   case 4:
343     PrintStructValue (pStruct, Type4, Socket);
344     DisplayProcessorType (pStruct->Type4->ProcessorType, Option);
345     if ((SmbiosMajorVersion > 0x2 || (SmbiosMajorVersion == 0x2 && SmbiosMinorVersion >= 0x6)) && 
346         (pStruct->Type4->ProcessorFamily == 0xFE)) {
347       //
348       // Get family from ProcessorFamily2 field
349       //
350       DisplayProcessorFamily2 (pStruct->Type4->ProcessorFamily2, Option);
351     } else {
352       DisplayProcessorFamily (pStruct->Type4->ProcessorFamily, Option);
353     }
354     PrintPendingString (pStruct, Type4, ProcessorManufacture);
355     PrintBitField (pStruct, Type4, ProcessorId, 8);
356     PrintPendingString (pStruct, Type4, ProcessorVersion);
357     DisplayProcessorVoltage (pStruct->Type4->Voltage, Option);
358     PrintStructValue (pStruct, Type4, ExternalClock);
359     PrintStructValue (pStruct, Type4, MaxSpeed);
360     PrintStructValue (pStruct, Type4, CurrentSpeed);
361     DisplayProcessorStatus (pStruct->Type4->Status, Option);
362     DisplayProcessorUpgrade (pStruct->Type4->ProcessorUpgrade, Option);
363     PrintStructValueH (pStruct, Type4, L1CacheHandle);
364     PrintStructValueH (pStruct, Type4, L2CacheHandle);
365     PrintStructValueH (pStruct, Type4, L3CacheHandle);
366     PrintPendingString (pStruct, Type4, SerialNumber);
367     PrintPendingString (pStruct, Type4, AssetTag);
368     PrintPendingString (pStruct, Type4, PartNumber);
369     if (SmbiosMajorVersion > 0x2 || (SmbiosMajorVersion == 0x2 && SmbiosMinorVersion >= 0x5)) {
370       PrintStructValue (pStruct, Type4, CoreCount);
371       PrintStructValue (pStruct, Type4, EnabledCoreCount);
372       PrintStructValue (pStruct, Type4, ThreadCount);
373       PrintStructValueH (pStruct, Type4, ProcessorCharacteristics);
374     }
375     break;
376
377   //
378   // Memory Controller Information (Type 5)
379   //
380   case 5:
381     {
382       UINT8 SlotNum;
383       SlotNum = pStruct->Type5->AssociatedMemorySlotNum;
384
385       DisplayMcErrorDetectMethod (pStruct->Type5->ErrDetectMethod, Option);
386       DisplayMcErrorCorrectCapability (pStruct->Type5->ErrCorrectCapability, Option);
387       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SUPOPRT), HiiHandle);
388       DisplayMcInterleaveSupport (pStruct->Type5->SupportInterleave, Option);
389       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CURRENT), HiiHandle);
390       DisplayMcInterleaveSupport (pStruct->Type5->CurrentInterleave, Option);
391       DisplayMaxMemoryModuleSize (pStruct->Type5->MaxMemoryModuleSize, SlotNum, Option);
392       DisplayMcMemorySpeeds (pStruct->Type5->SupportSpeed, Option);
393       DisplayMmMemoryType (pStruct->Type5->SupportMemoryType, Option);
394       DisplayMemoryModuleVoltage (pStruct->Type5->MemoryModuleVoltage, Option);
395       PrintStructValue (pStruct, Type5, AssociatedMemorySlotNum);
396       //
397       // According to SMBIOS Specification, offset 0x0F
398       //
399       DisplayMemoryModuleConfigHandles ((UINT16 *) (&Buffer[0x0F]), SlotNum, Option);
400       DisplayMcErrorCorrectCapability (Buffer[0x0F + 2 * SlotNum], Option);
401     }
402     break;
403
404   //
405   // Memory Module Information (Type 6)
406   //
407   case 6:
408     PrintPendingString (pStruct, Type6, SocketDesignation);
409     DisplayMmBankConnections (pStruct->Type6->BankConnections, Option);
410     PrintStructValue (pStruct, Type6, CurrentSpeed);
411     DisplayMmMemoryType (pStruct->Type6->CurrentMemoryType, Option);
412     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INSTALLED), HiiHandle);
413     DisplayMmMemorySize (pStruct->Type6->InstalledSize, Option);
414     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED), HiiHandle);
415     DisplayMmMemorySize (pStruct->Type6->EnabledSize, Option);
416     DisplayMmErrorStatus (pStruct->Type6->ErrorStatus, Option);
417     break;
418
419   //
420   // Cache Information (Type 7)
421   //
422   case 7:
423     PrintPendingString (pStruct, Type7, SocketDesignation);
424     PrintStructValueH (pStruct, Type7, CacheConfiguration);
425     PrintStructValueH (pStruct, Type7, MaximumCacheSize);
426     PrintStructValueH (pStruct, Type7, InstalledSize);
427     PrintStructValueH (pStruct, Type7, SupportedSRAMType);
428     PrintStructValueH (pStruct, Type7, CurrentSRAMType);
429     DisplayCacheSRAMType (pStruct->Type7->CurrentSRAMType, Option);
430     PrintStructValueH (pStruct, Type7, CacheSpeed);
431     DisplayCacheErrCorrectingType (pStruct->Type7->ErrorCorrectionType, Option);
432     DisplayCacheSystemCacheType (pStruct->Type7->SystemCacheType, Option);
433     DisplayCacheAssociativity (pStruct->Type7->Associativity, Option);
434     break;
435
436   //
437   // Port Connector Information  (Type 8)
438   //
439   case 8:
440     PrintPendingString (pStruct, Type8, InternalReferenceDesignator);
441     Print (L"Internal ");
442     DisplayPortConnectorType (pStruct->Type8->InternalConnectorType, Option);
443     PrintPendingString (pStruct, Type8, ExternalReferenceDesignator);
444     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_EXTERNAL), HiiHandle);
445     DisplayPortConnectorType (pStruct->Type8->ExternalConnectorType, Option);
446     DisplayPortType (pStruct->Type8->PortType, Option);
447     break;
448
449   //
450   // System Slots (Type 9)
451   //
452   case 9:
453     PrintPendingString (pStruct, Type9, SlotDesignation);
454     DisplaySystemSlotType (pStruct->Type9->SlotType, Option);
455     DisplaySystemSlotDataBusWidth (pStruct->Type9->SlotDataBusWidth, Option);
456     DisplaySystemSlotCurrentUsage (pStruct->Type9->CurrentUsage, Option);
457     DisplaySystemSlotLength (pStruct->Type9->SlotLength, Option);
458     DisplaySystemSlotId (
459       pStruct->Type9->SlotID,
460       pStruct->Type9->SlotType,
461       Option
462       );
463     DisplaySlotCharacteristics1 (pStruct->Type9->SlotCharacteristics1, Option);
464     DisplaySlotCharacteristics2 (pStruct->Type9->SlotCharacteristics2, Option);
465     if (SmbiosMajorVersion > 0x2 || (SmbiosMajorVersion == 0x2 && SmbiosMinorVersion >= 0x6)) {
466       PrintStructValueH (pStruct, Type9, SegmentGroupNum);
467       PrintStructValueH (pStruct, Type9, BusNum);
468       PrintStructValueH (pStruct, Type9, DevFuncNum);
469     }
470     break;
471
472   //
473   // On Board Devices Information (Type 10)
474   //
475   case 10:
476     {
477       UINTN NumOfDevice;
478       NumOfDevice = (pStruct->Type10->Hdr.Length - sizeof (SMBIOS_HEADER)) / (2 * sizeof (UINT8));
479       for (Index = 0; Index < NumOfDevice; Index++) {
480         DisplayOnboardDeviceTypes (pStruct->Type10->Device[Index].DeviceType, Option);
481         PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DESC_STRING), HiiHandle);
482         APrint (LibGetSmbiosString (pStruct, pStruct->Type10->Device[Index].DescriptionString));
483       }
484     }
485     break;
486
487   case 11:
488     PrintStructValue (pStruct, Type11, StringCount);
489     for (Index = 1; Index <= pStruct->Type11->StringCount; Index++) {
490       APrint ("%a\n", LibGetSmbiosString (pStruct, Index));
491     }
492     break;
493
494   case 12:
495     PrintStructValue (pStruct, Type12, StringCount);
496     for (Index = 1; Index <= pStruct->Type12->StringCount; Index++) {
497       APrint ("%a\n", LibGetSmbiosString (pStruct, Index));
498     }
499     break;
500
501   case 13:
502     PrintStructValue (pStruct, Type13, InstallableLanguages);
503     PrintStructValue (pStruct, Type13, Flags);
504     PrintBitField (pStruct, Type13, reserved, 15);
505     PrintPendingString (pStruct, Type13, CurrentLanguages);
506     break;
507
508   case 14:
509     PrintPendingString (pStruct, Type14, GroupName);
510     PrintStructValue (pStruct, Type14, ItemType);
511     PrintStructValue (pStruct, Type14, ItemHandle);
512     break;
513
514   //
515   // System Event Log (Type 15)
516   //
517   case 15:
518     {
519       EVENTLOGTYPE  *Ptr;
520       UINT8         Count;
521       UINT8         *AccessMethodAddress;
522
523       PrintStructValueH (pStruct, Type15, LogAreaLength);
524       PrintStructValueH (pStruct, Type15, LogHeaderStartOffset);
525       PrintStructValueH (pStruct, Type15, LogDataStartOffset);
526       DisplaySELAccessMethod (pStruct->Type15->AccessMethod, Option);
527       PrintStructValueH (pStruct, Type15, AccessMethodAddress);
528       DisplaySELLogStatus (pStruct->Type15->LogStatus, Option);
529       PrintStructValueH (pStruct, Type15, LogChangeToken);
530       DisplaySysEventLogHeaderFormat (pStruct->Type15->LogHeaderFormat, Option);
531       PrintStructValueH (pStruct, Type15, NumberOfSupportedLogTypeDescriptors);
532       PrintStructValueH (pStruct, Type15, LengthOfLogTypeDescriptor);
533
534       Count = pStruct->Type15->NumberOfSupportedLogTypeDescriptors;
535       if (Count > 0) {
536         Ptr = pStruct->Type15->EventLogTypeDescriptors;
537
538         //
539         // Display all Event Log type descriptors supported by system
540         //
541         for (Index = 0; Index < Count; Index++, Ptr++) {
542           PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SUPOPRTED_EVENT), HiiHandle, Index + 1);
543           DisplaySELTypes (Ptr->LogType, Option);
544           DisplaySELVarDataFormatType (Ptr->DataFormatType, Option);
545         }
546
547         if (Option >= SHOW_DETAIL) {
548           switch (pStruct->Type15->AccessMethod) {
549           case 03:
550             AccessMethodAddress = (UINT8 *) (UINTN) (pStruct->Type15->AccessMethodAddress);
551             break;
552
553           case 00:
554           case 01:
555           case 02:
556           case 04:
557           default:
558             PrintToken (
559               STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ACCESS_METHOD_NOT_SUPOPRTED),
560               HiiHandle,
561               pStruct->Type15->AccessMethod
562               );
563             return EFI_UNSUPPORTED;
564           }
565           //
566           // Display Event Log Header
567           //
568           // Starting offset (or index) within the nonvolatile storage
569           // of the event-log's header, from the Access Method Address
570           //
571           DisplaySysEventLogHeader (
572             pStruct->Type15->LogHeaderFormat,
573             AccessMethodAddress + pStruct->Type15->LogHeaderStartOffset
574             );
575
576           //
577           // Display all Event Log data
578           //
579           // Starting offset (or index) within the nonvolatile storage
580           // of the event-log's first data byte, from the Access Method Address(0x14)
581           //
582           DisplaySysEventLogData (
583             AccessMethodAddress + pStruct->Type15->LogDataStartOffset,
584             (UINT16)
585             (
586             pStruct->Type15->LogAreaLength -
587             (pStruct->Type15->LogDataStartOffset - pStruct->Type15->LogDataStartOffset)
588             )
589             );
590         }
591
592       }
593     }
594     break;
595
596   //
597   // Physical Memory Array (Type 16)
598   //
599   case 16:
600     DisplayPMALocation (pStruct->Type16->Location, Option);
601     DisplayPMAUse (pStruct->Type16->Use, Option);
602     DisplayPMAErrorCorrectionTypes (
603       pStruct->Type16->MemoryErrorCorrection,
604       Option
605       );
606     PrintStructValueH (pStruct, Type16, MaximumCapacity);
607     PrintStructValueH (pStruct, Type16, MemoryErrorInformationHandle);
608     PrintStructValueH (pStruct, Type16, NumberOfMemoryDevices);
609     break;
610
611   //
612   // Memory Device (Type 17)
613   //
614   case 17:
615     PrintStructValueH (pStruct, Type17, MemoryArrayHandle);
616     PrintStructValueH (pStruct, Type17, MemoryErrorInformationHandle);
617     PrintStructValue (pStruct, Type17, TotalWidth);
618     PrintStructValue (pStruct, Type17, DataWidth);
619     PrintStructValue (pStruct, Type17, Size);
620     DisplayMemoryDeviceFormFactor (pStruct->Type17->FormFactor, Option);
621     PrintStructValueH (pStruct, Type17, DeviceSet);
622     PrintPendingString (pStruct, Type17, DeviceLocator);
623     PrintPendingString (pStruct, Type17, BankLocator);
624     DisplayMemoryDeviceType (pStruct->Type17->MemoryType, Option);
625     DisplayMemoryDeviceTypeDetail (pStruct->Type17->TypeDetail, Option);
626     PrintStructValueH (pStruct, Type17, Speed);
627     PrintPendingString (pStruct, Type17, Manufacturer);
628     PrintPendingString (pStruct, Type17, SerialNumber);
629     PrintPendingString (pStruct, Type17, AssetTag);
630     PrintPendingString (pStruct, Type17, PartNumber);
631     if (SmbiosMajorVersion > 0x2 || (SmbiosMajorVersion == 0x2 && SmbiosMinorVersion >= 0x6)) { 
632       PrintStructValueH (pStruct, Type17, Attributes);
633     }
634     break;
635
636   //
637   // 32-bit Memory Error Information (Type 18)
638   //
639   case 18:
640     DisplayMemoryErrorType (pStruct->Type18->ErrorType, Option);
641     DisplayMemoryErrorGranularity (
642       pStruct->Type18->ErrorGranularity,
643       Option
644       );
645     DisplayMemoryErrorOperation (pStruct->Type18->ErrorOperation, Option);
646     PrintStructValueH (pStruct, Type18, VendorSyndrome);
647     PrintStructValueH (pStruct, Type18, MemoryArrayErrorAddress);
648     PrintStructValueH (pStruct, Type18, DeviceErrorAddress);
649     PrintStructValueH (pStruct, Type18, ErrorResolution);
650     break;
651
652   //
653   // Memory Array Mapped Address (Type 19)
654   //
655   case 19:
656     PrintStructValueH (pStruct, Type19, StartingAddress);
657     PrintStructValueH (pStruct, Type19, EndingAddress);
658     PrintStructValueH (pStruct, Type19, MemoryArrayHandle);
659     PrintStructValueH (pStruct, Type19, PartitionWidth);
660     break;
661
662   //
663   // Memory Device Mapped Address  (Type 20)
664   //
665   case 20:
666     PrintStructValueH (pStruct, Type20, StartingAddress);
667     PrintStructValueH (pStruct, Type20, EndingAddress);
668     PrintStructValueH (pStruct, Type20, MemoryDeviceHandle);
669     PrintStructValueH (pStruct, Type20, MemoryArrayMappedAddressHandle);
670     PrintStructValueH (pStruct, Type20, PartitionRowPosition);
671     PrintStructValueH (pStruct, Type20, InterleavePosition);
672     PrintStructValueH (pStruct, Type20, InterleavedDataDepth);
673     break;
674
675   //
676   // Built-in Pointing Device  (Type 21)
677   //
678   case 21:
679     DisplayPointingDeviceType (pStruct->Type21->Type, Option);
680     DisplayPointingDeviceInterface (pStruct->Type21->Interface, Option);
681     PrintStructValue (pStruct, Type21, NumberOfButtons);
682     break;
683
684   //
685   // Portable Battery  (Type 22)
686   //
687   case 22:
688     PrintPendingString (pStruct, Type22, Location);
689     PrintPendingString (pStruct, Type22, Manufacturer);
690     PrintPendingString (pStruct, Type22, ManufactureDate);
691     PrintPendingString (pStruct, Type22, SerialNumber);
692     PrintPendingString (pStruct, Type22, DeviceName);
693     DisplayPBDeviceChemistry (
694       pStruct->Type22->DeviceChemistry,
695       Option
696       );
697     PrintStructValueH (pStruct, Type22, DeviceCapacity);
698     PrintStructValueH (pStruct, Type22, DesignVoltage);
699     PrintPendingString (pStruct, Type22, SBDSVersionNumber);
700     PrintStructValueH (pStruct, Type22, MaximumErrorInBatteryData);
701     PrintStructValueH (pStruct, Type22, SBDSSerialNumber);
702     DisplaySBDSManufactureDate (
703       pStruct->Type22->SBDSManufactureDate,
704       Option
705       );
706     PrintPendingString (pStruct, Type22, SBDSDeviceChemistry);
707     PrintStructValueH (pStruct, Type22, DesignCapacityMultiplier);
708     PrintStructValueH (pStruct, Type22, OEMSpecific);
709     break;
710
711   case 23:
712     DisplaySystemResetCapabilities (
713       pStruct->Type23->Capabilities,
714       Option
715       );
716     PrintStructValueH (pStruct, Type23, ResetCount);
717     PrintStructValueH (pStruct, Type23, ResetLimit);
718     PrintStructValueH (pStruct, Type23, TimerInterval);
719     PrintStructValueH (pStruct, Type23, Timeout);
720     break;
721
722   case 24:
723     DisplayHardwareSecuritySettings (
724       pStruct->Type24->HardwareSecuritySettings,
725       Option
726       );
727     break;
728
729   case 25:
730     PrintStructValueH (pStruct, Type25, NextScheduledPowerOnMonth);
731     PrintStructValueH (pStruct, Type25, NextScheduledPowerOnDayOfMonth);
732     PrintStructValueH (pStruct, Type25, NextScheduledPowerOnHour);
733     PrintStructValueH (pStruct, Type25, NextScheduledPowerOnMinute);
734     PrintStructValueH (pStruct, Type25, NextScheduledPowerOnSecond);
735     break;
736
737   case 26:
738     PrintPendingString (pStruct, Type26, Description);
739     DisplayVPLocation (pStruct->Type26->LocationAndStatus, Option);
740     DisplayVPStatus (pStruct->Type26->LocationAndStatus, Option);
741     PrintStructValueH (pStruct, Type26, MaximumValue);
742     PrintStructValueH (pStruct, Type26, MinimumValue);
743     PrintStructValueH (pStruct, Type26, Resolution);
744     PrintStructValueH (pStruct, Type26, Tolerance);
745     PrintStructValueH (pStruct, Type26, Accuracy);
746     PrintStructValueH (pStruct, Type26, OEMDefined);
747     PrintStructValueH (pStruct, Type26, NominalValue);
748     break;
749
750   case 27:
751     PrintStructValueH (pStruct, Type27, TemperatureProbeHandle);
752     DisplayCoolingDeviceStatus (pStruct->Type27->DeviceTypeAndStatus, Option);
753     DisplayCoolingDeviceType (pStruct->Type27->DeviceTypeAndStatus, Option);
754     PrintStructValueH (pStruct, Type27, CoolingUnitGroup);
755     PrintStructValueH (pStruct, Type27, OEMDefined);
756     PrintStructValueH (pStruct, Type27, NominalSpeed);
757     break;
758
759   case 28:
760     PrintPendingString (pStruct, Type28, Description);
761     DisplayTemperatureProbeStatus (pStruct->Type28->LocationAndStatus, Option);
762     DisplayTemperatureProbeLoc (pStruct->Type28->LocationAndStatus, Option);
763     PrintStructValueH (pStruct, Type28, MaximumValue);
764     PrintStructValueH (pStruct, Type28, MinimumValue);
765     PrintStructValueH (pStruct, Type28, Resolution);
766     PrintStructValueH (pStruct, Type28, Tolerance);
767     PrintStructValueH (pStruct, Type28, Accuracy);
768     PrintStructValueH (pStruct, Type28, OEMDefined);
769     PrintStructValueH (pStruct, Type28, NominalValue);
770     break;
771
772   case 29:
773     PrintPendingString (pStruct, Type29, Description);
774     DisplayECPStatus (pStruct->Type29->LocationAndStatus, Option);
775     DisplayECPLoc (pStruct->Type29->LocationAndStatus, Option);
776     PrintStructValueH (pStruct, Type29, MaximumValue);
777     PrintStructValueH (pStruct, Type29, MinimumValue);
778     PrintStructValueH (pStruct, Type29, Resolution);
779     PrintStructValueH (pStruct, Type29, Tolerance);
780     PrintStructValueH (pStruct, Type29, Accuracy);
781     PrintStructValueH (pStruct, Type29, OEMDefined);
782     PrintStructValueH (pStruct, Type29, NominalValue);
783     break;
784
785   case 30:
786     PrintPendingString (pStruct, Type30, ManufacturerName);
787     DisplayOBRAConnections (pStruct->Type30->Connections, Option);
788     break;
789
790   case 31:
791     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_STRUCT_TYPE31), HiiHandle);
792     break;
793
794   case 32:
795     PrintBitField (pStruct, Type32, Reserved, 6);
796     DisplaySystemBootStatus (pStruct->Type32->BootStatus[0], Option);
797     break;
798
799   case 33:
800     DisplayMemoryErrorType (pStruct->Type33->ErrorType, Option);
801     DisplayMemoryErrorGranularity (
802       pStruct->Type33->ErrorGranularity,
803       Option
804       );
805     DisplayMemoryErrorOperation (pStruct->Type33->ErrorOperation, Option);
806     PrintStructValueH (pStruct, Type33, VendorSyndrome);
807     PrintStructValueH (pStruct, Type33, MemoryArrayErrorAddress);
808     PrintStructValueH (pStruct, Type33, DeviceErrorAddress);
809     PrintStructValueH (pStruct, Type33, ErrorResolution);
810     break;
811
812   //
813   // Management Device  (Type 34)
814   //
815   case 34:
816     PrintPendingString (pStruct, Type34, Description);
817     DisplayMDType (pStruct->Type34->Type, Option);
818     PrintStructValueH (pStruct, Type34, Address);
819     PrintStructValueH (pStruct, Type34, AddressType);
820     break;
821
822   case 35:
823     PrintPendingString (pStruct, Type35, Description);
824     PrintStructValueH (pStruct, Type35, ManagementDeviceHandle);
825     PrintStructValueH (pStruct, Type35, ComponentHandle);
826     PrintStructValueH (pStruct, Type35, ThresholdHandle);
827     break;
828
829   case 36:
830     PrintStructValueH (pStruct, Type36, LowerThresholdNonCritical);
831     PrintStructValueH (pStruct, Type36, UpperThresholdNonCritical);
832     PrintStructValueH (pStruct, Type36, LowerThresholdCritical);
833     PrintStructValueH (pStruct, Type36, UpperThresholdCritical);
834     PrintStructValueH (pStruct, Type36, LowerThresholdNonRecoverable);
835     PrintStructValueH (pStruct, Type36, UpperThresholdNonRecoverable);
836     break;
837
838   //
839   // Memory Channel  (Type 37)
840   //
841   case 37:
842     {
843       UINT8         Count;
844       MEMORYDEVICE  *Ptr;
845       DisplayMemoryChannelType (pStruct->Type37->ChannelType, Option);
846       PrintStructValueH (pStruct, Type37, MaximumChannelLoad);
847       PrintStructValueH (pStruct, Type37, MemoryDeviceCount);
848
849       Count = pStruct->Type37->MemoryDeviceCount;
850       Ptr   = pStruct->Type37->MemoryDevice;
851       for (Index = 0; Index < Count; Index++) {
852         PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEM_DEVICE), HiiHandle, Index + 1);
853         PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DEV_LOAD), HiiHandle, Ptr->DeviceLoad);
854         PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DEV_HANDLE), HiiHandle, Ptr->DeviceHandle);
855       }
856     }
857     break;
858
859   //
860   // IPMI Device Information  (Type 38)
861   //
862   case 38:
863     DisplayIPMIDIBMCInterfaceType (pStruct->Type38->InterfaceType, Option);
864     PrintStructValueH (pStruct, Type38, IPMISpecificationRevision);
865     PrintStructValueH (pStruct, Type38, I2CSlaveAddress);
866     PrintStructValueH (pStruct, Type38, NVStorageDeviceAddress);
867     PrintStructValueH (pStruct, Type38, BaseAddress);
868     break;
869
870   //
871   // System Power Supply (Type 39)
872   //
873   case 39:
874     PrintStructValueH (pStruct, Type39, PowerUnitGroup);
875     PrintPendingString (pStruct, Type39, Location);
876     PrintPendingString (pStruct, Type39, DeviceName);
877     PrintPendingString (pStruct, Type39, Manufacturer);
878     PrintPendingString (pStruct, Type39, SerialNumber);
879     PrintPendingString (pStruct, Type39, AssetTagNumber);
880     PrintPendingString (pStruct, Type39, ModelPartNumber);
881     PrintPendingString (pStruct, Type39, RevisionLevel);
882     PrintStructValueH (pStruct, Type39, MaxPowerCapacity);
883     DisplaySPSCharacteristics (
884       pStruct->Type39->PowerSupplyCharacteristics,
885       Option
886       );
887     PrintStructValueH (pStruct, Type39, InputVoltageProbeHandle);
888     PrintStructValueH (pStruct, Type39, CoolingDeviceHandle);
889     PrintStructValueH (pStruct, Type39, InputCurrentProbeHandle);
890     break;
891
892   //
893   // Additional Information (Type 40)
894   //
895   case 40:
896     {
897       UINT8                          NumberOfEntries;
898       UINT8                          EntryLength;
899       ADDITIONAL_INFORMATION_ENTRY   *Entries;
900       
901       EntryLength     = 0;
902       Entries         = pStruct->Type40->AdditionalInfoEntries;
903       NumberOfEntries = pStruct->Type40->NumberOfAdditionalInformationEntries;
904     
905       PrintStructValueH (pStruct, Type40, NumberOfAdditionalInformationEntries);
906       
907       for (Index = 0; Index < NumberOfEntries; Index++) {
908         EntryLength = Entries->EntryLength;
909         PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_ENTRYLEN), HiiHandle, EntryLength);
910         PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_REFERENCEDHANDLE), HiiHandle, Entries->ReferencedHandle);
911         PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_REFERENCEDOFFSET), HiiHandle, Entries->ReferencedOffset);
912         PrintSmbiosString (pStruct, Entries->EntryString, String);
913         PrintSmbiosBitField (pStruct, Entries->Value, Value, EntryLength - 5);
914         Entries = (ADDITIONAL_INFORMATION_ENTRY *) ((UINT8 *)Entries + EntryLength);
915       }
916     }
917     break;
918     
919   //
920   // Onboard Devices Extended Information (Type 41)
921   //
922   case 41:   
923     PrintPendingString (pStruct, Type41, ReferenceDesignation);
924     PrintStructValueH (pStruct, Type41, DeviceType);
925     PrintStructValueH (pStruct, Type41, DeviceTypeInstance);
926     PrintStructValueH (pStruct, Type41, SegmentGroupNum);
927     PrintStructValueH (pStruct, Type41, BusNum);
928     PrintStructValueH (pStruct, Type41, DevFuncNum);
929     break;
930
931   case 126:
932     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INACTIVE_STRUCT), HiiHandle);
933     break;
934
935   case 127:
936     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_THIS_STRUCT_END_TABLE), HiiHandle);
937     break;
938
939   default:
940     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_STRUCT_TYPE_UNDEFINED), HiiHandle);
941     break;
942   }
943
944   return EFI_SUCCESS;
945 }
946
947 VOID
948 DisplayBiosCharacteristics (
949   UINT64  chara,
950   UINT8   Option
951   )
952 {
953   //
954   // Print header
955   //
956   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_CHAR), HiiHandle);
957   //
958   // print option
959   //
960   PRINT_INFO_OPTION (chara, Option);
961
962   //
963   // Check all the bits and print information
964   // This function does not use Table because table of bits
965   //   are designed not to deal with UINT64
966   //
967   if (BIT (chara, 0) != 0) {
968     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED_BIT), HiiHandle);
969   }
970
971   if (BIT (chara, 1) != 0) {
972     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED_BIT), HiiHandle);
973   }
974
975   if (BIT (chara, 2) != 0) {
976     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN_BIT), HiiHandle);
977   }
978
979   if (BIT (chara, 3) != 0) {
980     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_CHAR_NOT_SUPPORTED), HiiHandle);
981   }
982
983   if (BIT (chara, 4) != 0) {
984     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ISA_SUPPORTED), HiiHandle);
985   }
986
987   if (BIT (chara, 5) != 0) {
988     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MSA_SUPPORTED), HiiHandle);
989   }
990
991   if (BIT (chara, 6) != 0) {
992     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_EISA_SUPPORTED), HiiHandle);
993   }
994
995   if (BIT (chara, 7) != 0) {
996     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PCI_SUPPORTED), HiiHandle);
997   }
998
999   if (BIT (chara, 8) != 0) {
1000     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PC_CARD_SUPPORTED), HiiHandle);
1001   }
1002
1003   if (BIT (chara, 9) != 0) {
1004     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PLUG_PLAY_SUPPORTED), HiiHandle);
1005   }
1006
1007   if (BIT (chara, 10) != 0) {
1008     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_APM_SUPPORTED), HiiHandle);
1009   }
1010
1011   if (BIT (chara, 11) != 0) {
1012     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_UPGRADEABLE), HiiHandle);
1013   }
1014
1015   if (BIT (chara, 12) != 0) {
1016     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_SHADOWING), HiiHandle);
1017   }
1018
1019   if (BIT (chara, 13) != 0) {
1020     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VESA_SUPPORTED), HiiHandle);
1021   }
1022
1023   if (BIT (chara, 14) != 0) {
1024     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ECSD_SUPPORT), HiiHandle);
1025   }
1026
1027   if (BIT (chara, 15) != 0) {
1028     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BOOT_FORM_CD_SUPPORTED), HiiHandle);
1029   }
1030
1031   if (BIT (chara, 16) != 0) {
1032     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SELECTED_BOOT_SUPPORTED), HiiHandle);
1033   }
1034
1035   if (BIT (chara, 17) != 0) {
1036     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_ROM_SOCKETED), HiiHandle);
1037   }
1038
1039   if (BIT (chara, 18) != 0) {
1040     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BOOT_FROM_PC_CARD), HiiHandle);
1041   }
1042
1043   if (BIT (chara, 19) != 0) {
1044     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_EDD_ENHANCED_DRIVER), HiiHandle);
1045   }
1046
1047   if (BIT (chara, 20) != 0) {
1048     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_JAPANESE_FLOPPY_NEC), HiiHandle);
1049   }
1050
1051   if (BIT (chara, 21) != 0) {
1052     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_JAPANESE_FLOPPY_TOSHIBA), HiiHandle);
1053   }
1054
1055   if (BIT (chara, 22) != 0) {
1056     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FLOPPY_SERVICES_SUPPORTED), HiiHandle);
1057   }
1058
1059   if (BIT (chara, 23) != 0) {
1060     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ONE_POINT_TWO_MB), HiiHandle);
1061   }
1062
1063   if (BIT (chara, 24) != 0) {
1064     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_720_KB), HiiHandle);
1065   }
1066
1067   if (BIT (chara, 25) != 0) {
1068     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_TWO_POINT_EIGHT_EIGHT_MB), HiiHandle);
1069   }
1070
1071   if (BIT (chara, 26) != 0) {
1072     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PRINT_SCREEN_SUPPORT), HiiHandle);
1073   }
1074
1075   if (BIT (chara, 27) != 0) {
1076     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_KEYBOARD_SERV_SUPPORT), HiiHandle);
1077   }
1078
1079   if (BIT (chara, 28) != 0) {
1080     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SERIAL_SERVICES_SUPPORT), HiiHandle);
1081   }
1082
1083   if (BIT (chara, 29) != 0) {
1084     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PRINTER_SERVICES_SUPPORT), HiiHandle);
1085   }
1086
1087   if (BIT (chara, 30) != 0) {
1088     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MONO_VIDEO_SUPPORT), HiiHandle);
1089   }
1090
1091   if (BIT (chara, 31) != 0) {
1092     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NEC_PC_98), HiiHandle);
1093   }
1094   //
1095   // Just print the reserved
1096   //
1097   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_32_47), HiiHandle);
1098   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_48_64), HiiHandle);
1099 }
1100
1101 VOID
1102 DisplayBiosCharacteristicsExt1 (
1103   UINT8 byte1,
1104   UINT8 Option
1105   )
1106 {
1107   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_CHAR_EXTENSION), HiiHandle);
1108   //
1109   // Print option
1110   //
1111   PRINT_INFO_OPTION (byte1, Option);
1112
1113   //
1114   // check bit and print
1115   //
1116   if (BIT (byte1, 0) != 0) {
1117     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ACPI_SUPPORTED), HiiHandle);
1118   }
1119
1120   if (BIT (byte1, 1) != 0) {
1121     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_USB_LEGACY_SUPPORTED), HiiHandle);
1122   }
1123
1124   if (BIT (byte1, 2) != 0) {
1125     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AGP_SUPPORTED), HiiHandle);
1126   }
1127
1128   if (BIT (byte1, 3) != 0) {
1129     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_I2O_BOOT_SUPPORTED), HiiHandle);
1130   }
1131
1132   if (BIT (byte1, 4) != 0) {
1133     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_LS_120_BOOT_SUPPORTED), HiiHandle);
1134   }
1135
1136   if (BIT (byte1, 5) != 0) {
1137     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ATAPI_ZIP_DRIVE), HiiHandle);
1138   }
1139
1140   if (BIT (byte1, 6) != 0) {
1141     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_1394_BOOT_SUPPORTED), HiiHandle);
1142   }
1143
1144   if (BIT (byte1, 7) != 0) {
1145     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SMART_BATTERY_SUPPORTED), HiiHandle);
1146   }
1147 }
1148
1149 VOID
1150 DisplayBiosCharacteristicsExt2 (
1151   UINT8 byte2,
1152   UINT8 Option
1153   )
1154 {
1155   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_CHAR_EXTENSION_2), HiiHandle);
1156   //
1157   // Print option
1158   //
1159   PRINT_INFO_OPTION (byte2, Option);
1160
1161   if (BIT (byte2, 0) != 0) {
1162     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_BOOT_SPEC_SUPP), HiiHandle);
1163   }
1164
1165   if (BIT (byte2, 1) != 0) {
1166     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FUNCTION_KEY_INIT), HiiHandle);
1167   }
1168
1169   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RSVD_FOR_FUTURE), HiiHandle);
1170 }
1171
1172 VOID
1173 DisplayProcessorFamily (
1174   UINT8 Family,
1175   UINT8 Option
1176   )
1177 {
1178   //
1179   // Print prompt message
1180   //
1181   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PROCESSOR_FAMILY), HiiHandle);
1182   //
1183   // Print option
1184   //
1185   PRINT_INFO_OPTION (Family, Option);
1186
1187   //
1188   // Use switch to check
1189   //
1190   switch (Family) {
1191   case 0x01:
1192     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTHER), HiiHandle);
1193     break;
1194
1195   case 0x02:
1196     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), HiiHandle);
1197     break;
1198
1199   case 0x03:
1200     Print (L"8086\n");
1201     break;
1202
1203   case 0x04:
1204     Print (L"80286\n");
1205     break;
1206
1207   case 0x05:
1208     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL386_PROCESSOR), HiiHandle);
1209     break;
1210
1211   case 0x06:
1212     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL486_PROCESSOR), HiiHandle);
1213     break;
1214
1215   case 0x07:
1216     Print (L"8087\n");
1217     break;
1218
1219   case 0x08:
1220     Print (L"80287\n");
1221     break;
1222
1223   case 0x09:
1224     Print (L"80387\n");
1225     break;
1226
1227   case 0x0A:
1228     Print (L"80487\n");
1229     break;
1230
1231   case 0x0B:
1232     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_PROC_FAMILY), HiiHandle);
1233     break;
1234
1235   case 0x0C:
1236     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_PRO_PROC), HiiHandle);
1237     break;
1238
1239   case 0x0D:
1240     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_II_PROC), HiiHandle);
1241     break;
1242
1243   case 0x0E:
1244     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_PROC_MMX), HiiHandle);
1245     break;
1246
1247   case 0x0F:
1248     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CELERON_PROC), HiiHandle);
1249     break;
1250
1251   case 0x10:
1252     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_XEON_PROC), HiiHandle);
1253     break;
1254
1255   case 0x11:
1256     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_III_PROC), HiiHandle);
1257     break;
1258
1259   case 0x12:
1260     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_M1_FAMILY), HiiHandle);
1261     break;
1262
1263   case 0x18:
1264     Print (L"AMD Duron\n");
1265     break;
1266
1267   case 0x19:
1268     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_K5_FAMILY), HiiHandle);
1269     break;
1270
1271   case 0x20:
1272     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_PC_FAMILY), HiiHandle);
1273     break;
1274
1275   case 0x21:
1276     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_PC_601), HiiHandle);
1277     break;
1278
1279   case 0x22:
1280     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_PC_603), HiiHandle);
1281     break;
1282
1283   case 0x23:
1284     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_PC_603_PLUS), HiiHandle);
1285     break;
1286
1287   case 0x24:
1288     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_PC_604), HiiHandle);
1289     break;
1290
1291   case 0x25:
1292     Print (L"Power PC 620\n");
1293     break;
1294
1295   case 0x26:
1296     Print (L"Power PC 704\n");
1297     break;
1298
1299   case 0x27:
1300     Print (L"Power PC 750\n");
1301     break;
1302
1303   case 0x30:
1304     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ALPHA_FAMILY_2), HiiHandle);
1305     break;
1306
1307   case 0x31:
1308     Print (L"Alpha 21064\n");
1309     break;
1310
1311   case 0x32:
1312     Print (L"Alpha 21066\n");
1313     break;
1314
1315   case 0x33:
1316     Print (L"Alpha 21164\n");
1317     break;
1318
1319   case 0x34:
1320     Print (L"Alpha 21164PC\n");
1321     break;
1322
1323   case 0x35:
1324     Print (L"Alpha 21164a\n");
1325     break;
1326
1327   case 0x36:
1328     Print (L"Alpha 21264\n");
1329     break;
1330
1331   case 0x37:
1332     Print (L"Alpha 21364\n");
1333     break;
1334
1335   case 0x40:
1336     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MIPS_FAMILY), HiiHandle);
1337     break;
1338
1339   case 0x41:
1340     Print (L"MIPS R4000\n");
1341     break;
1342
1343   case 0x42:
1344     Print (L"MIPS R4200\n");
1345     break;
1346
1347   case 0x43:
1348     Print (L"MIPS R4400\n");
1349     break;
1350
1351   case 0x44:
1352     Print (L"MIPS R4600\n");
1353     break;
1354
1355   case 0x45:
1356     Print (L"MIPS R10000\n");
1357     break;
1358
1359   case 0x50:
1360     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SPARC_FAMILY), HiiHandle);
1361     break;
1362
1363   case 0x51:
1364     Print (L"SuperSparc\n");
1365     break;
1366
1367   case 0x52:
1368     Print (L"microSparc II\n");
1369     break;
1370
1371   case 0x53:
1372     Print (L"microSparc IIep\n");
1373     break;
1374
1375   case 0x54:
1376     Print (L"UltraSparc\n");
1377     break;
1378
1379   case 0x55:
1380     Print (L"UltraSparc II\n");
1381     break;
1382
1383   case 0x56:
1384     Print (L"UltraSparcIIi\n");
1385     break;
1386
1387   case 0x57:
1388     Print (L"UltraSparcIII\n");
1389     break;
1390
1391   case 0x58:
1392     Print (L"UltraSparcIIIi\n");
1393     break;
1394
1395   case 0x60:
1396     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_68040_FAMILY), HiiHandle);
1397     break;
1398
1399   case 0x61:
1400     Print (L"68xx\n");
1401     break;
1402
1403   case 0x62:
1404     Print (L"68000\n");
1405     break;
1406
1407   case 0x63:
1408     Print (L"68010\n");
1409     break;
1410
1411   case 0x64:
1412     Print (L"68020\n");
1413     break;
1414
1415   case 0x65:
1416     Print (L"68030\n");
1417     break;
1418
1419   case 0x70:
1420     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_HOBBIT_FAMILY), HiiHandle);
1421     break;
1422
1423   case 0x78:
1424     Print (L"Crusoe TM5000\n");
1425     break;
1426
1427   case 0x79:
1428     Print (L"Crusoe TM3000\n");
1429     break;
1430
1431   case 0x7A:
1432     Print (L"Efficeon TM8000\n");
1433     break;
1434
1435   case 0x80:
1436     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_WEITEK), HiiHandle);
1437     break;
1438
1439   case 0x82:
1440     Print (L"Itanium\n");
1441     break;
1442
1443   case 0x83:
1444     Print (L"AMD Athlon64\n");
1445     break;
1446
1447   case 0x84:
1448     Print (L"AMD Opteron\n");
1449     break;
1450
1451   case 0x85:
1452     Print (L"AMD Sempron\n");
1453     break;
1454
1455   case 0x86:
1456     Print (L"AMD Turion64 Mobile\n");
1457     break;
1458
1459   case 0x87:
1460     Print (L"Dual-Core AMD Opteron\n");
1461     break;
1462
1463   case 0x88:
1464     Print (L"AMD Athlon 64X2 DualCore\n");
1465     break;
1466
1467   case 0x89:
1468     Print (L"AMD Turion 64X2 Mobile\n");
1469     break;
1470
1471   case 0x90:
1472     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PA_RISC_FAMILY), HiiHandle);
1473     break;
1474
1475   case 0xA0:
1476     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_V30_FAMILY), HiiHandle);
1477     break;
1478
1479   case 0xB0:
1480     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_III_XEON), HiiHandle);
1481     break;
1482
1483   case 0xC8:
1484     Print (L"IBM 390\n");
1485     break;
1486
1487   case 0xC9:
1488     Print (L"G4\n");
1489     break;
1490
1491   case 0xCA:
1492     Print (L"G5\n");
1493     break;
1494
1495   case 0xCB:
1496     Print (L"G6\n");
1497     break;
1498
1499   case 0xCC:
1500     Print (L"zArchitectur\n");
1501     break;
1502
1503   case 0xD2:
1504     Print (L"ViaC7M\n");
1505     break;
1506
1507   case 0xD3:
1508     Print (L"ViaC7D\n");
1509     break;
1510
1511   case 0xD4:
1512     Print (L"ViaC7\n");
1513     break;
1514
1515   case 0xD5:
1516     Print (L"Eden\n");
1517     break;
1518
1519   case 0xFA:
1520     Print (L"i860\n");
1521     break;
1522
1523   case 0xFB:
1524     Print (L"i960\n");
1525     break;
1526
1527   default:
1528     //
1529     // In order to reduce code quality notice of
1530     // case & break not pair, so
1531     // move multiple case into the else part and
1532     // use if/else to check value.
1533     //
1534     if (Family >= 0x13 && Family <= 0x17) {
1535       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RSVD_FOR_SPEC_M1), HiiHandle);
1536     } else if (Family >= 0x1A && Family <= 0x1F) {
1537       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RSVD_FOR_SPEC_K5), HiiHandle);
1538     } else if (Family >= 0xB1 && Family <= 0xBF) {
1539       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RSVD_FOR_SPEC_PENTIUM), HiiHandle);
1540     } else {
1541       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNDEFINED_PROC_FAMILY), HiiHandle);
1542     }
1543   }
1544   //
1545   // end switch
1546   //
1547 }
1548
1549 VOID
1550 DisplayProcessorFamily2 (
1551   UINT16 Family2,
1552   UINT8  Option
1553   )
1554 {
1555   //
1556   // Print prompt message
1557   //
1558   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PROCESSOR_FAMILY), HiiHandle);
1559   
1560   //
1561   // Print option
1562   //
1563   PRINT_INFO_OPTION (Family2, Option);
1564
1565   //
1566   // Use switch to check
1567   //
1568   switch (Family2) {
1569     case 0x104:
1570       Print (L"SH-3\n");
1571       break;
1572     
1573     case 0x105:
1574       Print (L"SH-4\n");
1575       break;
1576       
1577     case 0x118:
1578       Print (L"ARM\n");
1579       break;
1580
1581     case 0x119:
1582       Print (L"StrongARM\n");
1583       break; 
1584
1585     case 0x12C:
1586       Print (L"6x86\n");
1587       break;
1588
1589     case 0x12D:
1590       Print (L"MediaGX\n");
1591       break;
1592  
1593     case 0x12E:
1594       Print (L"MII\n");
1595       break; 
1596       
1597     case 0x140:
1598       Print (L"WinChip\n");
1599       break;
1600
1601     case 0x15E:
1602       Print (L"DSP\n");
1603       break;
1604
1605     case 0x1F4:
1606       Print (L"Video Processor\n");
1607       break;
1608     
1609     default:
1610      PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNDEFINED_PROC_FAMILY), HiiHandle);
1611   }
1612   
1613 }
1614
1615 VOID
1616 DisplayProcessorVoltage (
1617   UINT8 Voltage,
1618   UINT8 Option
1619   )
1620 /*++
1621 Routine Description:
1622   Bit 7 Set to 0, indicating 'legacy' mode for processor voltage
1623   Bits 6:4  Reserved, must be zero
1624   Bits 3:0  Voltage Capability. 
1625             A Set bit indicates that the voltage is supported.
1626     Bit 0 - 5V
1627     Bit 1 - 3.3V
1628     Bit 2 - 2.9V
1629     Bit 3 - Reserved, must be zero. 
1630
1631   Note: 
1632     Setting of multiple bits indicates the socket is configurable
1633     If bit 7 is set to 1, the remaining seven bits of the field are set to 
1634     contain the processor's current voltage times 10.  
1635     For example, the field value for a processor voltage of 1.8 volts would be 
1636     92h = 80h + (1.8 * 10) = 80h + 18 = 80h +12h.
1637
1638 Arguments:
1639   Voltage  - The Voltage
1640   Option   - The option
1641   
1642 Returns:
1643
1644 --*/
1645 {
1646   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PROC_INFO), HiiHandle);
1647   //
1648   // Print option
1649   //
1650   PRINT_INFO_OPTION (Voltage, Option);
1651
1652   if (BIT (Voltage, 7) != 0) {
1653     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PROC_CURRENT_VOLTAGE), HiiHandle, (Voltage - 0x80));
1654   } else {
1655     if (BIT (Voltage, 0) != 0) {
1656       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_5V_SUPOPRTED), HiiHandle);
1657     }
1658
1659     if (BIT (Voltage, 1) != 0) {
1660       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_33V_SUPPORTED), HiiHandle);
1661     }
1662
1663     if (BIT (Voltage, 2) != 0) {
1664       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_29V_SUPPORTED), HiiHandle);
1665     }
1666     //
1667     // check the reserved zero bits:
1668     //
1669     if (BIT (Voltage, 3) != 0) {
1670       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT3_NOT_ZERO), HiiHandle);
1671     }
1672
1673     if (BIT (Voltage, 4) != 0) {
1674       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT4_NOT_ZERO), HiiHandle);
1675     }
1676
1677     if (BIT (Voltage, 5) != 0) {
1678       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT5_NOT_ZERO), HiiHandle);
1679     }
1680
1681     if (BIT (Voltage, 6) != 0) {
1682       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT6_NOT_ZERO), HiiHandle);
1683     }
1684   }
1685 }
1686
1687 VOID
1688 DisplayProcessorStatus (
1689   UINT8 Status,
1690   UINT8 Option
1691   )
1692 /*++
1693 Routine Description:
1694
1695 Bit 7 Reserved, must be 0
1696 Bit 6   CPU Socket Populated  
1697  1 - CPU Socket Populated 
1698  0 - CPU Socket UnpopulatedBits 
1699  5:3  Reserved, must be zero
1700  Bits 2:0 CPU Status  
1701   0h - Unknown  
1702   1h - CPU Enabled  
1703   2h - CPU Disabled by User via BIOS Setup  
1704   3h - CPU Disabled By BIOS (POST Error)  
1705   4h - CPU is Idle, waiting to be enabled.  
1706   5-6h - Reserved   
1707   7h - Other
1708
1709 Arguments:
1710   Status  - The status
1711   Option  - The option
1712   
1713 Returns:
1714
1715 --*/
1716 {
1717   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PROC_STATUS), HiiHandle);
1718   PRINT_INFO_OPTION (Status, Option);
1719
1720   if (BIT (Status, 7) != 0) {
1721     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_BIT7), HiiHandle);
1722   } else if (BIT (Status, 5) != 0) {
1723     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_BIT5), HiiHandle);
1724   } else if (BIT (Status, 4) != 0) {
1725     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_BIT4), HiiHandle);
1726   } else if (BIT (Status, 3) != 0) {
1727     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_BIT3), HiiHandle);
1728   }
1729   //
1730   // Check BIT 6
1731   //
1732   if (BIT (Status, 6) != 0) {
1733     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_SOCKET_POPULATED), HiiHandle);
1734   } else {
1735     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_SOCKET_UNPOPULATED), HiiHandle);
1736   }
1737   //
1738   // Check BITs 2:0
1739   //
1740   switch (Status & 0x07) {
1741   case 0:
1742     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), HiiHandle);
1743     break;
1744
1745   case 1:
1746     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_ENABLED), HiiHandle);
1747     break;
1748
1749   case 2:
1750     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_DISABLED_BY_USER), HiiHandle);
1751     break;
1752
1753   case 3:
1754     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_DIABLED_BY_BIOS), HiiHandle);
1755     break;
1756
1757   case 4:
1758     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_IDLE), HiiHandle);
1759     break;
1760
1761   case 7:
1762     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTHERS), HiiHandle);
1763     break;
1764
1765   default:
1766     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED), HiiHandle);
1767   }
1768 }
1769
1770 VOID
1771 DisplayMaxMemoryModuleSize (
1772   UINT8 Size,
1773   UINT8 SlotNum,
1774   UINT8 Option
1775   )
1776 {
1777   UINTN MaxSize;
1778   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SIZE_LARGEST_MEM), HiiHandle);
1779   //
1780   // MaxSize is determined by follow formula
1781   //
1782   MaxSize = (UINTN) 1 << Size;
1783   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ONE_VAR_MB), HiiHandle, MaxSize);
1784
1785   if (Option >= SHOW_DETAIL) {
1786     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MAX_AMOUNT_MEM), HiiHandle);
1787     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ONE_VAR_MB), HiiHandle, MaxSize, SlotNum, MaxSize * SlotNum);
1788   }
1789 }
1790
1791 VOID
1792 DisplayMemoryModuleConfigHandles (
1793   UINT16 *Handles,
1794   UINT8  SlotNum,
1795   UINT8  Option
1796   )
1797 {
1798   UINT8 Index;
1799   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_HANDLES_CONTROLLED), HiiHandle, SlotNum);
1800
1801   if (Option >= SHOW_DETAIL) {
1802     //
1803     // No handle, Handles is INVALID.
1804     //
1805     if (SlotNum == 0) {
1806       return ;
1807     }
1808
1809     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_HANDLES_LIST_CONTROLLED), HiiHandle);
1810     for (Index = 0; Index < SlotNum; Index++) {
1811       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_HANDLE), HiiHandle, Index + 1, Handles[Index]);
1812     }
1813   }
1814 }
1815 //
1816 // Memory Module Information (Type 6)
1817 //
1818 VOID
1819 DisplayMmBankConnections (
1820   UINT8 BankConnections,
1821   UINT8 Option
1822   )
1823 {
1824   UINT8 High;
1825   UINT8 Low;
1826
1827   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BANK_CONNECTIONS), HiiHandle);
1828   //
1829   // Print option
1830   //
1831   PRINT_INFO_OPTION (BankConnections, Option);
1832
1833   //
1834   // Divide it to high and low
1835   //
1836   High  = (UINT8) (BankConnections & 0xF0);
1837   Low   = (UINT8) (BankConnections & 0x0F);
1838   if (High != 0xF) {
1839     if (Low != 0xF) {
1840       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BANK_RAS), HiiHandle, High, Low, High, Low);
1841     } else {
1842       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BANK_RAS_2), HiiHandle, High, High);
1843     }
1844   } else {
1845     if (Low != 0xF) {
1846       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BANK_RAS_2), HiiHandle, Low, Low);
1847     } else {
1848       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NO_BANKS_CONNECTED), HiiHandle);
1849     }
1850   }
1851 }
1852
1853 VOID
1854 DisplayMmMemorySize (
1855   UINT8 Size,
1856   UINT8 Option
1857   )
1858 /*++
1859 Routine Description:
1860   Bits 0:6  Size (n), 
1861       where 2**n is the size in MB with three special-case values:
1862       7Dh Not determinable (Installed Size only)
1863       7Eh Module is installed, but no memory has been enabled
1864       7Fh Not installed
1865   Bit  7  Defines whether the memory module has a single- (0) 
1866           or double-bank (1) connection.
1867           
1868 Arguments:
1869   Size   - The size
1870   Option - The option
1871   
1872 Returns:
1873
1874 --*/
1875 {
1876   UINT8 Value;
1877   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEMORY_SIZE), HiiHandle);
1878   //
1879   // Print option
1880   //
1881   PRINT_INFO_OPTION (Size, Option);
1882
1883   //
1884   // Get the low bits(0-6 bit)
1885   //
1886   Value = (UINT8) (Size & 0x7F);
1887   if (Value == 0x7D) {
1888     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEM_SIZE_NOT_DETERMINABLE), HiiHandle);
1889   } else if (Value == 0x7E) {
1890     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MODULE_INSTALLED), HiiHandle);
1891   } else if (Value == 0x7F) {
1892     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_INSTALLED), HiiHandle);
1893   } else {
1894     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEM_SIZE), HiiHandle, 1 << Value);
1895   }
1896
1897   if (BIT (Size, 7) != 0) {
1898     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEM_MODULE_DOUBLE_BANK), HiiHandle);
1899   } else {
1900     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEM_MODULE_SINGLE_BANK), HiiHandle);
1901   }
1902 }
1903
1904 VOID
1905 DisplaySystemSlotId (
1906   UINT16  SlotId,
1907   UINT8   SlotType,
1908   UINT8   Option
1909   )
1910 /*++
1911 Routine Description:
1912
1913   The Slot ID field of the System Slot structure provides a mechanism to 
1914   correlate the physical attributes of the slot to its logical access method 
1915   (which varies based on the Slot Type field). 
1916
1917 Arguments:
1918
1919   SlotId   - The slot ID
1920   SlotType - The slot type
1921   Option   - The Option
1922   
1923 Returns:
1924
1925 --*/
1926 {
1927   //
1928   // Display slot type first
1929   //
1930   DisplaySystemSlotType (SlotType, Option);
1931
1932   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SLOT_ID), HiiHandle);
1933   //
1934   // print option
1935   //
1936   PRINT_INFO_OPTION (SlotType, Option);
1937
1938   switch (SlotType) {
1939   //
1940   // Slot Type: MCA
1941   //
1942   case 0x04:
1943     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_LOGICAL_MICRO_CHAN), HiiHandle);
1944     if (SlotId > 0 && SlotId < 15) {
1945       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ONE_VAR_D), HiiHandle, SlotId);
1946     } else {
1947       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_NOT_1_15), HiiHandle);
1948     }
1949     break;
1950
1951   //
1952   // EISA
1953   //
1954   case 0x05:
1955     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_LOGICAL_EISA_NUM), HiiHandle);
1956     if (SlotId > 0 && SlotId < 15) {
1957       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ONE_VAR_D), HiiHandle, SlotId);
1958     } else {
1959       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_NOT_1_15), HiiHandle);
1960     }
1961     break;
1962
1963   //
1964   // Slot Type: PCI
1965   //
1966   case 0x06:
1967     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VALUE_PRESENT), HiiHandle, SlotId);
1968     break;
1969
1970   //
1971   // PCMCIA
1972   //
1973   case 0x07:
1974     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_IDENTIFIES_ADAPTER_NUM), HiiHandle, SlotId);
1975     break;
1976         
1977   //
1978   // Slot Type: PCI-E
1979   //
1980   case 0xA5:
1981     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VALUE_PRESENT), HiiHandle, SlotId);
1982     break;
1983
1984   default:
1985     if (SlotType >= 0x0E && SlotType <= 0x12) {
1986       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VALUE_PRESENT), HiiHandle, SlotId);
1987     } else {
1988       PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNDEFINED_SLOT_ID), HiiHandle);
1989     }
1990   }
1991 }
1992
1993 VOID
1994 DisplaySystemBootStatus (
1995   UINT8 Parameter,
1996   UINT8 Option
1997   )
1998 {
1999   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_BOOT_STATUS), HiiHandle);
2000   //
2001   // Print option
2002   //
2003   PRINT_INFO_OPTION (Parameter, Option);
2004
2005   //
2006   // Check value and print
2007   //
2008   if (Parameter == 0) {
2009     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NO_ERRORS_DETECTED), HiiHandle);
2010   } else if (Parameter == 1) {
2011     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NO_BOOTABLE_MEDIA), HiiHandle);
2012   } else if (Parameter == 2) {
2013     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NORMAL_OP_SYSTEM), HiiHandle);
2014   } else if (Parameter == 3) {
2015     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FIRMWARE_DETECTED), HiiHandle);
2016   } else if (Parameter == 4) {
2017     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OP_SYSTEM), HiiHandle);
2018   } else if (Parameter == 5) {
2019     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_USER_REQUESTED_BOOT), HiiHandle);
2020   } else if (Parameter == 6) {
2021     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_SECURITY_VIOLATION), HiiHandle);
2022   } else if (Parameter == 7) {
2023     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PREV_REQ_IMAGE), HiiHandle);
2024   } else if (Parameter == 8) {
2025     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_WATCHDOG_TIMER), HiiHandle);
2026   } else if (Parameter >= 9 && Parameter <= 127) {
2027     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RSVD_FUTURE_ASSIGNMENT), HiiHandle);
2028   } else if (Parameter >= 128 && Parameter <= 191) {
2029     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VENDOR_OEM_SPECIFIC), HiiHandle);
2030   } else if (Parameter >= 192 && Parameter <= 255) {
2031     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PRODUCT_SPEC_IMPLMENTATION), HiiHandle);
2032   } else {
2033     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_VALUE), HiiHandle);
2034   }
2035 }
2036 //
2037 // Portable Battery (Type 22)
2038 //
2039 VOID
2040 DisplaySBDSManufactureDate (
2041   UINT16  Date,
2042   UINT8   Option
2043   )
2044 /*++
2045 Routine Description:
2046   The date the cell pack was manufactured, in packed format:
2047    Bits 15:9  Year, biased by 1980, in the range 0 to 127.
2048    Bits 8:5 Month, in the range 1 to 12.
2049    Bits 4:0 Date, in the range 1 to 31.
2050   For example, 01 February 2000 would be identified as 
2051   0010 1000 0100 0001b (0x2841).
2052
2053 Arguments:
2054   Date   - The date
2055   Option - The option
2056   
2057 Returns:
2058
2059 --*/
2060 {
2061   UINTN Day;
2062   UINTN Month;
2063   UINTN Year;
2064
2065   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SBDS_MANUFACTURE_DATE), HiiHandle);
2066   PRINT_INFO_OPTION (Date, Option);
2067   //
2068   // Print date
2069   //
2070   Day   = Date & 0x001F;
2071   Month = (Date & 0x00E0) >> 5;
2072   Year  = ((Date & 0xFF00) >> 8) + 1980;
2073   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MONTH_DAY_YEAR), HiiHandle, Day, Month, Year);
2074
2075 }
2076 //
2077 // System Reset  (Type 23)
2078 //
2079 VOID
2080 DisplaySystemResetCapabilities (
2081   UINT8 Reset,
2082   UINT8 Option
2083   )
2084 /*++
2085 Routine Description:
2086 Identifies the system-reset capabilities for the system.
2087  Bits 7:6 Reserved for future assignment via this specification, set to 00b.
2088  Bit 5  System contains a watchdog timer, either True (1) or False (0).
2089  Bits 4:3 Boot Option on Limit.  
2090   Identifies the system action to be taken when the Reset Limit is reached, one of:
2091   00b Reserved, do not use. 
2092   01b Operating system  
2093   10b System utilities  
2094   11b Do not rebootBits 
2095  2:1  Boot Option.  Indicates the action to be taken following a watchdog reset, one of:    
2096   00b Reserved, do not use. 
2097   01b Operating system  
2098   10b System utilities  
2099   11b Do not reboot
2100  Bit 0  Status.  
2101   1b The system reset is enabled by the user
2102   0b The system reset is not enabled by the user
2103
2104 Arguments:
2105   Reset   - Reset
2106   Option  - The option
2107   
2108 Returns:
2109
2110 --*/
2111 {
2112   UINTN Temp;
2113
2114   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_RESET_CAPABILITIES), HiiHandle);
2115   PRINT_INFO_OPTION (Reset, Option);
2116
2117   //
2118   // Check reserved bits 7:6
2119   //
2120   if ((Reset & 0xC0) != 0) {
2121     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RESERVED_ZERO), HiiHandle);
2122   }
2123   //
2124   // Watch dog
2125   //
2126   if (BIT (Reset, 5) != 0) {
2127     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_WATCHDOG_TIMER_2), HiiHandle);
2128   } else {
2129     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_NOT_CONTAIN_TIMER), HiiHandle);
2130   }
2131   //
2132   // Boot Option on Limit
2133   //
2134   Temp = (Reset & 0x18) >> 3;
2135   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BOOT_OPTION_LIMIT), HiiHandle);
2136   switch (Temp) {
2137   case 0:
2138     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED), HiiHandle);
2139     break;
2140
2141   case 1:
2142     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OP_SYSTEM_2), HiiHandle);
2143     break;
2144
2145   case 2:
2146     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_UTIL), HiiHandle);
2147     break;
2148
2149   case 3:
2150     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DO_NOT_REBOOT_BITS), HiiHandle);
2151     break;
2152   }
2153   //
2154   // Boot Option
2155   //
2156   Temp = (Reset & 0x06) >> 1;
2157   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BOOT_OPTION), HiiHandle);
2158   switch (Temp) {
2159   case 0:
2160     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED), HiiHandle);
2161     break;
2162
2163   case 1:
2164     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OP_SYSTEM_2), HiiHandle);
2165     break;
2166
2167   case 2:
2168     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_UTIL), HiiHandle);
2169     break;
2170
2171   case 3:
2172     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DO_NOT_REBOOT), HiiHandle);
2173     break;
2174   }
2175   //
2176   // Reset enable flag
2177   //
2178   if ((Reset & 0x01) != 0) {
2179     Print (L"The system reset is enabled by the user\n");
2180   } else {
2181     Print (L"The system reset is disabled by the user\n");
2182   }
2183 }
2184 //
2185 // Hardware Security (Type 24)
2186 //
2187 VOID
2188 DisplayHardwareSecuritySettings (
2189   UINT8 Settings,
2190   UINT8 Option
2191   )
2192 /*++
2193 Routine Description:
2194 Identifies the password and reset status for the system:
2195
2196 Bits 7:6    Power-on Password Status, one of:   
2197   00b Disabled    
2198   01b Enabled   
2199   10b Not Implemented   
2200   11b Unknown 
2201 Bits 5:4    Keyboard Password Status, one of:   
2202   00b Disabled    
2203   01b Enabled   
2204   10b Not Implemented   
2205   11b Unknown 
2206 Bits 3:2    Administrator Password Status, one  of:   
2207   00b Disabled    
2208   01b Enabled   
2209   10b Not Implemented   
2210   11b Unknown
2211 Bits 1:0    Front Panel Reset Status, one of:   
2212   00b Disabled    
2213   01b Enabled   
2214   10b Not Implemented   
2215   11b Unknown
2216
2217 Arguments:
2218   Settings    - The settings
2219   Option      - the option
2220   
2221 Returns:
2222
2223 --*/
2224 {
2225   UINTN Temp;
2226
2227   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_HARDWARE_SECURITY_SET), HiiHandle);
2228   PRINT_INFO_OPTION (Settings, Option);
2229
2230   //
2231   // Power-on Password Status
2232   //
2233   Temp = (Settings & 0xC0) >> 6;
2234   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_ON_PASSWORD), HiiHandle);
2235   switch (Temp) {
2236   case 0:
2237     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DISABLED), HiiHandle);
2238     break;
2239
2240   case 1:
2241     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED_NEWLINE), HiiHandle);
2242     break;
2243
2244   case 2:
2245     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_IMPLEMENTED), HiiHandle);
2246     break;
2247
2248   case 3:
2249     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), HiiHandle);
2250     break;
2251   }
2252   //
2253   // Keyboard Password Status
2254   //
2255   Temp = (Settings & 0x30) >> 4;
2256   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_KEYBOARD_PASSWORD), HiiHandle);
2257   switch (Temp) {
2258   case 0:
2259     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DISABLED), HiiHandle);
2260     break;
2261
2262   case 1:
2263     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED_NEWLINE), HiiHandle);
2264     break;
2265
2266   case 2:
2267     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_IMPLEMENTED), HiiHandle);
2268     break;
2269
2270   case 3:
2271     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), HiiHandle);
2272     break;
2273   }
2274   //
2275   // Administrator Password Status
2276   //
2277   Temp = (Settings & 0x0C) >> 2;
2278   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ADMIN_PASSWORD_STATUS), HiiHandle);
2279   switch (Temp) {
2280   case 0:
2281     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DISABLED), HiiHandle);
2282     break;
2283
2284   case 1:
2285     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED_NEWLINE), HiiHandle);
2286     break;
2287
2288   case 2:
2289     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_IMPLEMENTED), HiiHandle);
2290     break;
2291
2292   case 3:
2293     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), HiiHandle);
2294     break;
2295   }
2296   //
2297   // Front Panel Reset Status
2298   //
2299   Temp = Settings & 0x3;
2300   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FRONT_PANEL_RESET), HiiHandle);
2301   switch (Temp) {
2302   case 0:
2303     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DISABLED), HiiHandle);
2304     break;
2305
2306   case 1:
2307     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED_NEWLINE), HiiHandle);
2308     break;
2309
2310   case 2:
2311     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_IMPLEMENTED), HiiHandle);
2312     break;
2313
2314   case 3:
2315     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), HiiHandle);
2316     break;
2317   }
2318 }
2319 //
2320 // Out-of-Band Remote Access (Type 30)
2321 //
2322 VOID
2323 DisplayOBRAConnections (
2324   UINT8   Connections,
2325   UINT8   Option
2326   )
2327 {
2328   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CONNECTIONS), HiiHandle);
2329   PRINT_INFO_OPTION (Connections, Option);
2330
2331   //
2332   // Check reserved bits 7:2
2333   //
2334   if ((Connections & 0xFC) != 0) {
2335     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RESERVED_ZERO_2), HiiHandle);
2336   }
2337   //
2338   // Outbound Connection
2339   //
2340   if (BIT (Connections, 1) != 0) {
2341     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OUTBOUND_CONN_ENABLED), HiiHandle);
2342   } else {
2343     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTUBOUND_CONN_DISABLED), HiiHandle);
2344   }
2345   //
2346   // Inbound Connection
2347   //
2348   if (BIT (Connections, 0) != 0) {
2349     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INBOIUND_CONN_ENABLED), HiiHandle);
2350   } else {
2351     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INBOUND_CONN_DISABLED), HiiHandle);
2352   }
2353 }
2354 //
2355 // System Power Supply (Type 39)
2356 //
2357 VOID
2358 DisplaySPSCharacteristics (
2359   UINT16  Characteristics,
2360   UINT8   Option
2361   )
2362 {
2363   UINTN Temp;
2364
2365   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_CHAR), HiiHandle);
2366   PRINT_INFO_OPTION (Characteristics, Option);
2367
2368   //
2369   // Check reserved bits 15:14
2370   //
2371   if ((Characteristics & 0xC000) != 0) {
2372     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_15_14_RSVD), HiiHandle);
2373   }
2374   //
2375   // Bits 13:10 - DMTF Power Supply Type
2376   //
2377   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_TYPE), HiiHandle);
2378   Temp = (Characteristics & 0x1C00) << 10;
2379   switch (Temp) {
2380   case 1:
2381     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTHER_SPACE), HiiHandle);
2382     break;
2383
2384   case 2:
2385     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), HiiHandle);
2386     break;
2387
2388   case 3:
2389     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_LINEAR), HiiHandle);
2390     break;
2391
2392   case 4:
2393     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SWITCHING), HiiHandle);
2394     break;
2395
2396   case 5:
2397     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BATTERY), HiiHandle);
2398     break;
2399
2400   case 6:
2401     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UPS), HiiHandle);
2402     break;
2403
2404   case 7:
2405     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CONVERTER), HiiHandle);
2406     break;
2407
2408   case 8:
2409     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_REGULATOR), HiiHandle);
2410     break;
2411
2412   default:
2413     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED_2), HiiHandle);
2414   }
2415   //
2416   // Bits 9:7 - Status
2417   //
2418   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_STATUS_DASH), HiiHandle);
2419   Temp = (Characteristics & 0x380) << 7;
2420   switch (Temp) {
2421   case 1:
2422     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTHER_SPACE), HiiHandle);
2423     break;
2424
2425   case 2:
2426     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), HiiHandle);
2427     break;
2428
2429   case 3:
2430     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OK), HiiHandle);
2431     break;
2432
2433   case 4:
2434     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NON_CRITICAL), HiiHandle);
2435     break;
2436
2437   case 5:
2438     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CRITICAL_POWER_SUPPLY), HiiHandle);
2439     break;
2440
2441   default:
2442     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNDEFINED), HiiHandle);
2443   }
2444   //
2445   // Bits 6:3 - DMTF Input Voltage Range Switching
2446   //
2447   PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INPUT_VOLTAGE_RANGE), HiiHandle);
2448   Temp = (Characteristics & 0x78) << 3;
2449   switch (Temp) {
2450   case 1:
2451     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTHER_SPACE), HiiHandle);
2452     break;
2453
2454   case 2:
2455     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), HiiHandle);
2456     break;
2457
2458   case 3:
2459     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MANUAL), HiiHandle);
2460     break;
2461
2462   case 4:
2463     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AUTO_SWITCH), HiiHandle);
2464     break;
2465
2466   case 5:
2467     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_WIDE_RANGE), HiiHandle);
2468     break;
2469
2470   case 6:
2471     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_APPLICABLE), HiiHandle);
2472     break;
2473
2474   default:
2475     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED_3), HiiHandle);
2476     break;
2477   }
2478   //
2479   // Power supply is unplugged from the wall
2480   //
2481   if (BIT (Characteristics, 2) != 0) {
2482     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_UNPLUGGED), HiiHandle);
2483   } else {
2484     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_PLUGGED), HiiHandle);
2485   }
2486   //
2487   // Power supply is present
2488   //
2489   if (BIT (Characteristics, 1) != 0) {
2490     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_PRESENT), HiiHandle);
2491   } else {
2492     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_NOT_PRESENT), HiiHandle);
2493   }
2494   //
2495   // hot replaceable
2496   //
2497   if (BIT (Characteristics, 0) != 0) {
2498     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_REPLACE), HiiHandle);
2499   } else {
2500     PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_NOT_REPLACE), HiiHandle);
2501   }
2502 }