ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/PrintInfo.c

   1 /** @file
   2   Module for clarifying the content of the smbios structure element information.
   3
   4   Copyright (c) 2005 - 2015, Intel Corporation. All rights reserved.<BR>
   5   (C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "../UefiShellDebug1CommandsLib.h"
  17 #include "PrintInfo.h"
  18 #include "LibSmbiosView.h"
  19 #include "QueryTable.h"
  20 #include "EventLogInfo.h"
  21
  22
  23 //
  24 // Get the certain bit of 'value'
  25 //
  26 #define BIT(value, bit) ((value) & ((UINT64) 1) << (bit))
  27
  28 //
  29 // Check if above or equal to version
  30 //
  31 #define AE_SMBIOS_VERSION(MajorVersion, MinorVersion) \
  32   (SmbiosMajorVersion > (MajorVersion) || (SmbiosMajorVersion == (MajorVersion) && SmbiosMinorVersion >= (MinorVersion)))
  33
  34 //
  35 //////////////////////////////////////////////////////////
  36 //  Macros of print structure element, simplify coding.
  37 //
  38 #define PRINT_PENDING_STRING(pStruct, type, element) \
  39   do { \
  40     CHAR8 *StringBuf; \
  41     StringBuf = LibGetSmbiosString ((pStruct), (pStruct->type->element)); \
  42     ShellPrintEx(-1,-1,L"%a",#element); \
  43     ShellPrintEx(-1,-1,L": %a\n", (StringBuf != NULL) ? StringBuf: ""); \
  44   } while (0);
  45
  46 #define PRINT_SMBIOS_STRING(pStruct, stringnumber, element) \
  47   do { \
  48     CHAR8 *StringBuf; \
  49     StringBuf = LibGetSmbiosString ((pStruct), (stringnumber)); \
  50     ShellPrintEx(-1,-1,L"%a",#element); \
  51     ShellPrintEx(-1,-1,L": %a\n", (StringBuf != NULL) ? StringBuf: ""); \
  52   } while (0);
  53
  54 #define PRINT_STRUCT_VALUE(pStruct, type, element) \
  55   do { \
  56     ShellPrintEx(-1,-1,L"%a",#element); \
  57     ShellPrintEx(-1,-1,L": %d\n", (pStruct->type->element)); \
  58   } while (0);
  59
  60 #define PRINT_STRUCT_VALUE_H(pStruct, type, element) \
  61   do { \
  62     ShellPrintEx(-1,-1,L"%a",#element); \
  63     ShellPrintEx(-1,-1,L": 0x%x\n", (pStruct->type->element)); \
  64   } while (0);
  65
  66 #define PRINT_STRUCT_VALUE_LH(pStruct, type, element) \
  67   do { \
  68     ShellPrintEx(-1,-1,L"%a",#element); \
  69     ShellPrintEx(-1,-1,L": 0x%lx\n", (pStruct->type->element)); \
  70   } while (0);
  71
  72 #define PRINT_BIT_FIELD(pStruct, type, element, size) \
  73   do { \
  74     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DUMP), gShellDebug1HiiHandle); \
  75     ShellPrintEx(-1,-1,L"%a",#element); \
  76     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SIZE), gShellDebug1HiiHandle, size); \
  77     DumpHex (0, 0, size, &(pStruct->type->element)); \
  78   } while (0);
  79
  80 #define PRINT_SMBIOS_BIT_FIELD(pStruct, startaddress, element, size) \
  81   do { \
  82     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DUMP), gShellDebug1HiiHandle); \
  83     ShellPrintEx(-1,-1,L"%a",#element); \
  84     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SIZE), gShellDebug1HiiHandle, size); \
  85     DumpHex (0, 0, size, startaddress); \
  86   } while (0);
  87
  88 //
  89 /////////////////////////////////////////
  90 //
  91
  92 /**
  93   Copy Length of Src buffer to Dest buffer,
  94   add a NULL termination to Dest buffer.
  95
  96   @param[in, out] Dest  Destination buffer head.
  97   @param[in] Src        Source buffer head.
  98   @param[in] Length     Length of buffer to be copied.
  99 **/
 100 VOID
 101 MemToString (
 102   IN OUT VOID   *Dest,
 103   IN VOID       *Src,
 104   IN UINTN      Length
 105   )
 106 {
 107   UINT8 *SrcBuffer;
 108   UINT8 *DestBuffer;
 109   SrcBuffer   = (UINT8 *) Src;
 110   DestBuffer  = (UINT8 *) Dest;
 111   //
 112   // copy byte by byte
 113   //
 114   while ((Length--)!=0) {
 115     *DestBuffer++ = *SrcBuffer++;
 116   }
 117   //
 118   // append a NULL terminator
 119   //
 120   *DestBuffer = '\0';
 121 }
 122
 123 //
 124 //////////////////////////////////////////////
 125 //
 126 // Functions below is to show the information
 127 //
 128
 129 /**
 130   Print the info of EPS(Entry Point Structure).
 131
 132   @param[in] SmbiosTable    Pointer to the SMBIOS table entry point.
 133   @param[in] Option         Display option.
 134 **/
 135 VOID
 136 SmbiosPrintEPSInfo (
 137   IN  SMBIOS_TABLE_ENTRY_POINT  *SmbiosTable,
 138   IN  UINT8                     Option
 139   )
 140 {
 141   UINT8 Anchor[5];
 142   UINT8 InAnchor[6];
 143
 144   if (SmbiosTable == NULL) {
 145     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SMBIOSTABLE_NULL), gShellDebug1HiiHandle);
 146     return ;
 147   }
 148
 149   if (Option == SHOW_NONE) {
 150     return ;
 151   }
 152
 153   if (Option >= SHOW_NORMAL) {
 154     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENTRY_POINT_SIGN), gShellDebug1HiiHandle);
 155     MemToString (Anchor, SmbiosTable->AnchorString, 4);
 156     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ANCHOR_STR), gShellDebug1HiiHandle, Anchor);
 157     ShellPrintHiiEx(-1,-1,NULL,
 158       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_EPS_CHECKSUM),
 159       gShellDebug1HiiHandle,
 160       SmbiosTable->EntryPointStructureChecksum
 161      );
 162     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENTRY_POINT_LEN), gShellDebug1HiiHandle, SmbiosTable->EntryPointLength);
 163     ShellPrintHiiEx(-1,-1,NULL,
 164       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VERSION),
 165       gShellDebug1HiiHandle,
 166       SmbiosTable->MajorVersion,
 167       SmbiosTable->MinorVersion
 168      );
 169     ShellPrintHiiEx(-1,-1,NULL,
 170       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NUMBER_STRUCT),
 171       gShellDebug1HiiHandle,
 172       SmbiosTable->NumberOfSmbiosStructures
 173      );
 174     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MAX_STRUCT_SIZE), gShellDebug1HiiHandle, SmbiosTable->MaxStructureSize);
 175     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_TABLE_ADDR), gShellDebug1HiiHandle, SmbiosTable->TableAddress);
 176     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_TABLE_LENGTH), gShellDebug1HiiHandle, SmbiosTable->TableLength);
 177
 178   }
 179   //
 180   // If SHOW_ALL, also print followings.
 181   //
 182   if (Option >= SHOW_DETAIL) {
 183     ShellPrintHiiEx(-1,-1,NULL,
 184       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENTRY_POINT_REVISION),
 185       gShellDebug1HiiHandle,
 186       SmbiosTable->EntryPointRevision
 187      );
 188     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BCD_REVISION), gShellDebug1HiiHandle, SmbiosTable->SmbiosBcdRevision);
 189     //
 190     // Since raw data is not string, add a NULL terminater.
 191     //
 192     MemToString (InAnchor, SmbiosTable->IntermediateAnchorString, 5);
 193     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTER_ACHOR), gShellDebug1HiiHandle, InAnchor);
 194     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTER_CHECKSUM), gShellDebug1HiiHandle, SmbiosTable->IntermediateChecksum);
 195     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FORMATTED_AREA), gShellDebug1HiiHandle);
 196     DumpHex (2, 0, 5, SmbiosTable->FormattedArea);
 197   }
 198
 199   Print (L"\n");
 200 }
 201
 202 /**
 203   Print the info of 64-bit EPS(Entry Point Structure).
 204
 205   @param[in] SmbiosTable    Pointer to the SMBIOS table entry point.
 206   @param[in] Option         Display option.
 207 **/
 208 VOID
 209 Smbios64BitPrintEPSInfo (
 210   IN  SMBIOS_TABLE_3_0_ENTRY_POINT  *SmbiosTable,
 211   IN  UINT8                         Option
 212   )
 213 {
 214   UINT8 Anchor[5];
 215
 216   if (SmbiosTable == NULL) {
 217     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SMBIOSTABLE_NULL), gShellDebug1HiiHandle);
 218     return ;
 219   }
 220
 221   if (Option == SHOW_NONE) {
 222     return ;
 223   }
 224
 225   if (Option >= SHOW_NORMAL) {
 226     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_64_BIT_ENTRY_POINT_SIGN), gShellDebug1HiiHandle);
 227
 228     MemToString (Anchor, SmbiosTable->AnchorString, 5);
 229     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ANCHOR_STR), gShellDebug1HiiHandle, Anchor);
 230
 231     ShellPrintHiiEx(-1,-1,NULL,
 232       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_EPS_CHECKSUM),
 233       gShellDebug1HiiHandle,
 234       SmbiosTable->EntryPointStructureChecksum
 235      );
 236
 237     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENTRY_POINT_LEN), gShellDebug1HiiHandle, SmbiosTable->EntryPointLength);
 238
 239     ShellPrintHiiEx(-1,-1,NULL,
 240       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VERSION),
 241       gShellDebug1HiiHandle,
 242       SmbiosTable->MajorVersion,
 243       SmbiosTable->MinorVersion
 244      );
 245
 246     ShellPrintHiiEx(-1,-1,NULL,
 247       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DOCREV),
 248       gShellDebug1HiiHandle,
 249       SmbiosTable->DocRev
 250      );
 251
 252     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_TABLE_MAX_SIZE), gShellDebug1HiiHandle, SmbiosTable->TableMaximumSize);
 253
 254     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_TABLE_ADDR), gShellDebug1HiiHandle, SmbiosTable->TableAddress);
 255
 256   }
 257   //
 258   // If SHOW_ALL, also print followings.
 259   //
 260   if (Option >= SHOW_DETAIL) {
 261     ShellPrintHiiEx(-1,-1,NULL,
 262       STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENTRY_POINT_REVISION),
 263       gShellDebug1HiiHandle,
 264       SmbiosTable->EntryPointRevision
 265      );
 266   }
 267
 268   Print (L"\n");
 269 }
 270
 271 /**
 272   This function print the content of the structure pointed by Struct.
 273
 274   @param[in] Struct       Point to the structure to be printed.
 275   @param[in] Option       Print option of information detail.
 276
 277   @retval EFI_SUCCESS               Successfully Printing this function.
 278   @retval EFI_INVALID_PARAMETER     Invalid Structure.
 279   @retval EFI_UNSUPPORTED           Unsupported.
 280 **/
 281 EFI_STATUS
 282 SmbiosPrintStructure (
 283   IN  SMBIOS_STRUCTURE_POINTER  *Struct,
 284   IN  UINT8                     Option
 285   )
 286 {
 287   UINT8 Index;
 288   UINT8 *Buffer;
 289
 290   if (Struct == NULL) {
 291     return EFI_INVALID_PARAMETER;
 292   }
 293
 294   if (Option == SHOW_NONE) {
 295     return EFI_SUCCESS;
 296   }
 297
 298   Buffer = (UINT8 *) (UINTN) (Struct->Raw);
 299
 300   //
 301   // Display structure header
 302   //
 303   DisplayStructureTypeInfo (Struct->Hdr->Type, SHOW_DETAIL);
 304   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FORMAT_PART_LEN), gShellDebug1HiiHandle, Struct->Hdr->Length);
 305   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_STRUCT_HANDLE), gShellDebug1HiiHandle, Struct->Hdr->Handle);
 306
 307   if (Option == SHOW_OUTLINE) {
 308     return EFI_SUCCESS;
 309   }
 310
 311   switch (Struct->Hdr->Type) {
 312   //
 313   // BIOS Information (Type 0)
 314   //
 315   case 0:
 316     PRINT_PENDING_STRING (Struct, Type0, Vendor);
 317     PRINT_PENDING_STRING (Struct, Type0, BiosVersion);
 318     PRINT_STRUCT_VALUE (Struct, Type0, BiosSegment);
 319     PRINT_PENDING_STRING (Struct, Type0, BiosReleaseDate);
 320     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_SIZE), gShellDebug1HiiHandle, 64 * (Struct->Type0->BiosSize + 1));
 321
 322     DisplayBiosCharacteristics (ReadUnaligned64 ((UINT64 *) (UINTN) &(Struct->Type0->BiosCharacteristics)), Option);
 323
 324     if (Struct->Hdr->Length > 0x12) {
 325       DisplayBiosCharacteristicsExt1 (Struct->Type0->BIOSCharacteristicsExtensionBytes[0], Option);
 326     }
 327     if (Struct->Hdr->Length > 0x13) {
 328       DisplayBiosCharacteristicsExt2 (Struct->Type0->BIOSCharacteristicsExtensionBytes[1], Option);
 329     }
 330
 331     if (AE_SMBIOS_VERSION (0x2, 0x4) && (Struct->Hdr->Length > 0x14)) {
 332       PRINT_STRUCT_VALUE (Struct, Type0, SystemBiosMajorRelease);
 333       PRINT_STRUCT_VALUE (Struct, Type0, SystemBiosMinorRelease);
 334       PRINT_STRUCT_VALUE (Struct, Type0, EmbeddedControllerFirmwareMajorRelease);
 335       PRINT_STRUCT_VALUE (Struct, Type0, EmbeddedControllerFirmwareMinorRelease);
 336     }
 337
 338     break;
 339
 340   //
 341   // System Information (Type 1)
 342   //
 343   case 1:
 344     PRINT_PENDING_STRING (Struct, Type1, Manufacturer);
 345     PRINT_PENDING_STRING (Struct, Type1, ProductName);
 346     PRINT_PENDING_STRING (Struct, Type1, Version);
 347     PRINT_PENDING_STRING (Struct, Type1, SerialNumber);
 348     PRINT_BIT_FIELD (Struct, Type1, Uuid, 16);
 349     DisplaySystemWakeupType (Struct->Type1->WakeUpType, Option);
 350     if (AE_SMBIOS_VERSION (0x2, 0x4) && (Struct->Hdr->Length > 0x19)) {
 351       PRINT_PENDING_STRING (Struct, Type1, SKUNumber);
 352       PRINT_PENDING_STRING (Struct, Type1, Family);
 353     }
 354
 355     break;
 356
 357   //
 358   // Baseboard Information (Type 2)
 359   //
 360   case 2:
 361     PRINT_PENDING_STRING (Struct, Type2, Manufacturer);
 362     PRINT_PENDING_STRING (Struct, Type2, ProductName);
 363     PRINT_PENDING_STRING (Struct, Type2, Version);
 364     PRINT_PENDING_STRING (Struct, Type2, SerialNumber);
 365     if (Struct->Hdr->Length > 0x8) {
 366       PRINT_PENDING_STRING (Struct, Type2, AssetTag);
 367       DisplayBaseBoardFeatureFlags (*(UINT8 *) &Struct->Type2->FeatureFlag, Option);
 368       PRINT_PENDING_STRING (Struct, Type2, LocationInChassis);
 369       PRINT_STRUCT_VALUE_H (Struct, Type2, ChassisHandle);
 370       DisplayBaseBoardBoardType (Struct->Type2->BoardType, Option);
 371     }
 372     break;
 373
 374   //
 375   // System Enclosure (Type 3)
 376   //
 377   case 3:
 378     PRINT_PENDING_STRING (Struct, Type3, Manufacturer);
 379     PRINT_STRUCT_VALUE (Struct, Type3, Type);
 380     DisplaySystemEnclosureType (Struct->Type3->Type, Option);
 381     PRINT_PENDING_STRING (Struct, Type3, Version);
 382     PRINT_PENDING_STRING (Struct, Type3, SerialNumber);
 383     PRINT_PENDING_STRING (Struct, Type3, AssetTag);
 384     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BOOTUP_STATE), gShellDebug1HiiHandle);
 385     DisplaySystemEnclosureStatus (Struct->Type3->BootupState, Option);
 386     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_STATE), gShellDebug1HiiHandle);
 387     DisplaySystemEnclosureStatus (Struct->Type3->PowerSupplyState, Option);
 388     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_THERMAL_STATE), gShellDebug1HiiHandle);
 389     DisplaySystemEnclosureStatus (Struct->Type3->ThermalState, Option);
 390     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SECURITY_STATUS), gShellDebug1HiiHandle);
 391     DisplaySESecurityStatus (Struct->Type3->SecurityStatus, Option);
 392     if (AE_SMBIOS_VERSION (0x2, 0x3) && (Struct->Hdr->Length > 0xD)) {
 393       PRINT_BIT_FIELD (Struct, Type3, OemDefined, 4);
 394     }
 395     break;
 396
 397   //
 398   // Processor Information (Type 4)
 399   //
 400   case 4:
 401     PRINT_PENDING_STRING (Struct, Type4, Socket);
 402     DisplayProcessorType (Struct->Type4->ProcessorType, Option);
 403     if (AE_SMBIOS_VERSION (0x2, 0x6) && (Struct->Hdr->Length > 0x28) &&
 404         (Struct->Type4->ProcessorFamily == 0xFE)) {
 405       //
 406       // Get family from ProcessorFamily2 field
 407       //
 408       DisplayProcessorFamily2 (Struct->Type4->ProcessorFamily2, Option);
 409     } else {
 410       DisplayProcessorFamily (Struct->Type4->ProcessorFamily, Option);
 411     }
 412     PRINT_PENDING_STRING (Struct, Type4, ProcessorManufacture);
 413     PRINT_BIT_FIELD (Struct, Type4, ProcessorId, 8);
 414     PRINT_PENDING_STRING (Struct, Type4, ProcessorVersion);
 415     DisplayProcessorVoltage (*(UINT8 *) &(Struct->Type4->Voltage), Option);
 416     PRINT_STRUCT_VALUE (Struct, Type4, ExternalClock);
 417     PRINT_STRUCT_VALUE (Struct, Type4, MaxSpeed);
 418     PRINT_STRUCT_VALUE (Struct, Type4, CurrentSpeed);
 419     DisplayProcessorStatus (Struct->Type4->Status, Option);
 420     DisplayProcessorUpgrade (Struct->Type4->ProcessorUpgrade, Option);
 421     PRINT_STRUCT_VALUE_H (Struct, Type4, L1CacheHandle);
 422     PRINT_STRUCT_VALUE_H (Struct, Type4, L2CacheHandle);
 423     PRINT_STRUCT_VALUE_H (Struct, Type4, L3CacheHandle);
 424     if (AE_SMBIOS_VERSION (0x2, 0x3) && (Struct->Hdr->Length > 0x20)) {
 425       PRINT_PENDING_STRING (Struct, Type4, SerialNumber);
 426       PRINT_PENDING_STRING (Struct, Type4, AssetTag);
 427       PRINT_PENDING_STRING (Struct, Type4, PartNumber);
 428     }
 429     if (AE_SMBIOS_VERSION (0x2, 0x5) && (Struct->Hdr->Length > 0x23)) {
 430       PRINT_STRUCT_VALUE (Struct, Type4, CoreCount);
 431       PRINT_STRUCT_VALUE (Struct, Type4, EnabledCoreCount);
 432       PRINT_STRUCT_VALUE (Struct, Type4, ThreadCount);
 433       DisplayProcessorCharacteristics (Struct->Type4->ProcessorCharacteristics, Option);
 434     }
 435     if ((SmbiosMajorVersion >= 0x3) && (Struct->Hdr->Length > 0x2A)) {
 436       PRINT_STRUCT_VALUE (Struct, Type4, CoreCount2);
 437       PRINT_STRUCT_VALUE (Struct, Type4, EnabledCoreCount2);
 438       PRINT_STRUCT_VALUE (Struct, Type4, ThreadCount2);
 439     }
 440     break;
 441
 442   //
 443   // Memory Controller Information (Type 5)
 444   //
 445   case 5:
 446     {
 447       UINT8 SlotNum;
 448       SlotNum = Struct->Type5->AssociatedMemorySlotNum;
 449
 450       DisplayMcErrorDetectMethod (Struct->Type5->ErrDetectMethod, Option);
 451       DisplayMcErrorCorrectCapability (*(UINT8 *) &(Struct->Type5->ErrCorrectCapability), Option);
 452       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SUPOPRT), gShellDebug1HiiHandle);
 453       DisplayMcInterleaveSupport (Struct->Type5->SupportInterleave, Option);
 454       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CURRENT), gShellDebug1HiiHandle);
 455       DisplayMcInterleaveSupport (Struct->Type5->CurrentInterleave, Option);
 456       DisplayMaxMemoryModuleSize (Struct->Type5->MaxMemoryModuleSize, SlotNum, Option);
 457       DisplayMcMemorySpeeds (*(UINT16 *) &(Struct->Type5->SupportSpeed), Option);
 458       DisplayMmMemoryType (Struct->Type5->SupportMemoryType, Option);
 459       DisplayMemoryModuleVoltage (Struct->Type5->MemoryModuleVoltage, Option);
 460       PRINT_STRUCT_VALUE (Struct, Type5, AssociatedMemorySlotNum);
 461       //
 462       // According to SMBIOS Specification, offset 0x0F
 463       //
 464       DisplayMemoryModuleConfigHandles ((UINT16 *) (&Buffer[0x0F]), SlotNum, Option);
 465       DisplayMcErrorCorrectCapability (Buffer[0x0F + 2 * SlotNum], Option);
 466     }
 467     break;
 468
 469   //
 470   // Memory Module Information (Type 6)
 471   //
 472   case 6:
 473     PRINT_PENDING_STRING (Struct, Type6, SocketDesignation);
 474     DisplayMmBankConnections (Struct->Type6->BankConnections, Option);
 475     PRINT_STRUCT_VALUE (Struct, Type6, CurrentSpeed);
 476     DisplayMmMemoryType (*(UINT16 *) &(Struct->Type6->CurrentMemoryType), Option);
 477     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INSTALLED), gShellDebug1HiiHandle);
 478     DisplayMmMemorySize (*(UINT8 *) &(Struct->Type6->InstalledSize), Option);
 479     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED), gShellDebug1HiiHandle);
 480     DisplayMmMemorySize (*(UINT8 *) &(Struct->Type6->EnabledSize), Option);
 481     DisplayMmErrorStatus (Struct->Type6->ErrorStatus, Option);
 482     break;
 483
 484   //
 485   // Cache Information (Type 7)
 486   //
 487   case 7:
 488     PRINT_PENDING_STRING (Struct, Type7, SocketDesignation);
 489     DisplayCacheConfiguration (Struct->Type7->CacheConfiguration, Option);
 490     PRINT_STRUCT_VALUE_H (Struct, Type7, MaximumCacheSize);
 491     PRINT_STRUCT_VALUE_H (Struct, Type7, InstalledSize);
 492     PRINT_STRUCT_VALUE_H (Struct, Type7, SupportedSRAMType);
 493     PRINT_STRUCT_VALUE_H (Struct, Type7, CurrentSRAMType);
 494     DisplayCacheSRAMType (ReadUnaligned16 ((UINT16 *) (UINTN) &(Struct->Type7->CurrentSRAMType)), Option);
 495     PRINT_STRUCT_VALUE_H (Struct, Type7, CacheSpeed);
 496     DisplayCacheErrCorrectingType (Struct->Type7->ErrorCorrectionType, Option);
 497     DisplayCacheSystemCacheType (Struct->Type7->SystemCacheType, Option);
 498     DisplayCacheAssociativity (Struct->Type7->Associativity, Option);
 499     break;
 500
 501   //
 502   // Port Connector Information  (Type 8)
 503   //
 504   case 8:
 505     PRINT_PENDING_STRING (Struct, Type8, InternalReferenceDesignator);
 506     Print (L"Internal ");
 507     DisplayPortConnectorType (Struct->Type8->InternalConnectorType, Option);
 508     PRINT_PENDING_STRING (Struct, Type8, ExternalReferenceDesignator);
 509     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_EXTERNAL), gShellDebug1HiiHandle);
 510     DisplayPortConnectorType (Struct->Type8->ExternalConnectorType, Option);
 511     DisplayPortType (Struct->Type8->PortType, Option);
 512     break;
 513
 514   //
 515   // System Slots (Type 9)
 516   //
 517   case 9:
 518     PRINT_PENDING_STRING (Struct, Type9, SlotDesignation);
 519     DisplaySystemSlotType (Struct->Type9->SlotType, Option);
 520     DisplaySystemSlotDataBusWidth (Struct->Type9->SlotDataBusWidth, Option);
 521     DisplaySystemSlotCurrentUsage (Struct->Type9->CurrentUsage, Option);
 522     DisplaySystemSlotLength (Struct->Type9->SlotLength, Option);
 523     DisplaySystemSlotId (
 524       Struct->Type9->SlotID,
 525       Struct->Type9->SlotType,
 526       Option
 527      );
 528     DisplaySlotCharacteristics1 (*(UINT8 *) &(Struct->Type9->SlotCharacteristics1), Option);
 529     DisplaySlotCharacteristics2 (*(UINT8 *) &(Struct->Type9->SlotCharacteristics2), Option);
 530     if (AE_SMBIOS_VERSION (0x2, 0x6) && (Struct->Hdr->Length > 0xD)) {
 531       PRINT_STRUCT_VALUE_H (Struct, Type9, SegmentGroupNum);
 532       PRINT_STRUCT_VALUE_H (Struct, Type9, BusNum);
 533       PRINT_STRUCT_VALUE_H (Struct, Type9, DevFuncNum);
 534     }
 535     break;
 536
 537   //
 538   // On Board Devices Information (Type 10)
 539   //
 540   case 10:
 541     {
 542       UINTN NumOfDevice;
 543       NumOfDevice = (Struct->Type10->Hdr.Length - sizeof (SMBIOS_STRUCTURE)) / (2 * sizeof (UINT8));
 544       for (Index = 0; Index < NumOfDevice; Index++) {
 545         DisplayOnboardDeviceTypes (Struct->Type10->Device[Index].DeviceType, Option);
 546         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DESC_STRING), gShellDebug1HiiHandle);
 547         ShellPrintEx(-1,-1,L"%a\n",LibGetSmbiosString (Struct, Struct->Type10->Device[Index].DescriptionString));
 548       }
 549     }
 550     break;
 551
 552   //
 553   // Oem Strings (Type 11)
 554   //
 555   case 11:
 556     PRINT_STRUCT_VALUE (Struct, Type11, StringCount);
 557     for (Index = 1; Index <= Struct->Type11->StringCount; Index++) {
 558       ShellPrintEx(-1,-1,L"%a\n", LibGetSmbiosString (Struct, Index));
 559     }
 560     break;
 561
 562   //
 563   // System Configuration Options (Type 12)
 564   //
 565   case 12:
 566     PRINT_STRUCT_VALUE (Struct, Type12, StringCount);
 567     for (Index = 1; Index <= Struct->Type12->StringCount; Index++) {
 568       ShellPrintEx(-1,-1,L"%a\n", LibGetSmbiosString (Struct, Index));
 569     }
 570     break;
 571
 572   //
 573   // BIOS Language Information (Type 13)
 574   //
 575   case 13:
 576     PRINT_STRUCT_VALUE (Struct, Type13, InstallableLanguages);
 577     PRINT_STRUCT_VALUE (Struct, Type13, Flags);
 578     PRINT_BIT_FIELD (Struct, Type13, Reserved, 15);
 579     PRINT_PENDING_STRING (Struct, Type13, CurrentLanguages);
 580     break;
 581
 582   //
 583   // Group Associations (Type 14)
 584   //
 585   case 14:
 586     {
 587       UINT8 NumOfItem;
 588       NumOfItem = (Struct->Type14->Hdr.Length - 5) / 3;
 589       PRINT_PENDING_STRING (Struct, Type14, GroupName);
 590       for (Index = 0; Index < NumOfItem; Index++) {
 591         ShellPrintEx(-1,-1,L"ItemType %d: %d\n", Index + 1, Struct->Type14->Group[Index].ItemType);
 592         ShellPrintEx(-1,-1,L"ItemHandle %d: %d\n", Index + 1, Struct->Type14->Group[Index].ItemHandle);
 593       }
 594     }
 595     break;
 596
 597   //
 598   // System Event Log (Type 15)
 599   //
 600   case 15:
 601     {
 602       EVENT_LOG_TYPE  *Ptr;
 603       UINT8           Count;
 604       UINT8           *AccessMethodAddress;
 605
 606       PRINT_STRUCT_VALUE_H (Struct, Type15, LogAreaLength);
 607       PRINT_STRUCT_VALUE_H (Struct, Type15, LogHeaderStartOffset);
 608       PRINT_STRUCT_VALUE_H (Struct, Type15, LogDataStartOffset);
 609       DisplaySELAccessMethod (Struct->Type15->AccessMethod, Option);
 610       PRINT_STRUCT_VALUE_H (Struct, Type15, AccessMethodAddress);
 611       DisplaySELLogStatus (Struct->Type15->LogStatus, Option);
 612       PRINT_STRUCT_VALUE_H (Struct, Type15, LogChangeToken);
 613       DisplaySysEventLogHeaderFormat (Struct->Type15->LogHeaderFormat, Option);
 614       PRINT_STRUCT_VALUE_H (Struct, Type15, NumberOfSupportedLogTypeDescriptors);
 615       PRINT_STRUCT_VALUE_H (Struct, Type15, LengthOfLogTypeDescriptor);
 616
 617       Count = Struct->Type15->NumberOfSupportedLogTypeDescriptors;
 618       if (Count > 0) {
 619         Ptr = Struct->Type15->EventLogTypeDescriptors;
 620
 621         //
 622         // Display all Event Log type descriptors supported by system
 623         //
 624         for (Index = 0; Index < Count; Index++, Ptr++) {
 625           ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SUPOPRTED_EVENT), gShellDebug1HiiHandle, Index + 1);
 626           DisplaySELTypes (Ptr->LogType, Option);
 627           DisplaySELVarDataFormatType (Ptr->DataFormatType, Option);
 628         }
 629
 630         if (Option >= SHOW_DETAIL) {
 631           switch (Struct->Type15->AccessMethod) {
 632           case 03:
 633             AccessMethodAddress = (UINT8 *) (UINTN) (Struct->Type15->AccessMethodAddress);
 634             break;
 635
 636           case 00:
 637           case 01:
 638           case 02:
 639           case 04:
 640           default:
 641             ShellPrintHiiEx(-1,-1,NULL,
 642               STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ACCESS_METHOD_NOT_SUPOPRTED),
 643               gShellDebug1HiiHandle,
 644               Struct->Type15->AccessMethod
 645              );
 646             return EFI_UNSUPPORTED;
 647           }
 648           //
 649           // Display Event Log Header
 650           //
 651           // Starting offset (or index) within the nonvolatile storage
 652           // of the event-log's header, from the Access Method Address
 653           //
 654           DisplaySysEventLogHeader (
 655             Struct->Type15->LogHeaderFormat,
 656             AccessMethodAddress + Struct->Type15->LogHeaderStartOffset
 657            );
 658
 659           //
 660           // Display all Event Log data
 661           //
 662           // Starting offset (or index) within the nonvolatile storage
 663           // of the event-log's first data byte, from the Access Method Address(0x14)
 664           //
 665           DisplaySysEventLogData (
 666             AccessMethodAddress + Struct->Type15->LogDataStartOffset,
 667             (UINT16)
 668             (
 669               Struct->Type15->LogAreaLength -
 670               (Struct->Type15->LogDataStartOffset - Struct->Type15->LogHeaderStartOffset)
 671             )
 672            );
 673         }
 674
 675       }
 676     }
 677     break;
 678
 679   //
 680   // Physical Memory Array (Type 16)
 681   //
 682   case 16:
 683     DisplayPMALocation (Struct->Type16->Location, Option);
 684     DisplayPMAUse (Struct->Type16->Use, Option);
 685     DisplayPMAErrorCorrectionTypes (
 686       Struct->Type16->MemoryErrorCorrection,
 687       Option
 688      );
 689     PRINT_STRUCT_VALUE_H (Struct, Type16, MaximumCapacity);
 690     PRINT_STRUCT_VALUE_H (Struct, Type16, MemoryErrorInformationHandle);
 691     PRINT_STRUCT_VALUE_H (Struct, Type16, NumberOfMemoryDevices);
 692     if (AE_SMBIOS_VERSION (0x2, 0x7) && Struct->Hdr->Length > 0xF) {
 693       PRINT_STRUCT_VALUE_LH (Struct, Type16, ExtendedMaximumCapacity);
 694     }
 695     break;
 696
 697   //
 698   // Memory Device (Type 17)
 699   //
 700   case 17:
 701     PRINT_STRUCT_VALUE_H (Struct, Type17, MemoryArrayHandle);
 702     PRINT_STRUCT_VALUE_H (Struct, Type17, MemoryErrorInformationHandle);
 703     PRINT_STRUCT_VALUE (Struct, Type17, TotalWidth);
 704     PRINT_STRUCT_VALUE (Struct, Type17, DataWidth);
 705     PRINT_STRUCT_VALUE (Struct, Type17, Size);
 706     DisplayMemoryDeviceFormFactor (Struct->Type17->FormFactor, Option);
 707     PRINT_STRUCT_VALUE_H (Struct, Type17, DeviceSet);
 708     PRINT_PENDING_STRING (Struct, Type17, DeviceLocator);
 709     PRINT_PENDING_STRING (Struct, Type17, BankLocator);
 710     DisplayMemoryDeviceType (Struct->Type17->MemoryType, Option);
 711     DisplayMemoryDeviceTypeDetail (ReadUnaligned16 ((UINT16 *) (UINTN) &(Struct->Type17->TypeDetail)), Option);
 712     PRINT_STRUCT_VALUE_H (Struct, Type17, Speed);
 713     PRINT_PENDING_STRING (Struct, Type17, Manufacturer);
 714     PRINT_PENDING_STRING (Struct, Type17, SerialNumber);
 715     PRINT_PENDING_STRING (Struct, Type17, AssetTag);
 716     PRINT_PENDING_STRING (Struct, Type17, PartNumber);
 717     if (AE_SMBIOS_VERSION (0x2, 0x6) && (Struct->Hdr->Length > 0x1B)) {
 718       PRINT_STRUCT_VALUE_H (Struct, Type17, Attributes);
 719     }
 720     if (AE_SMBIOS_VERSION (0x2, 0x7) && (Struct->Hdr->Length > 0x1C)) {
 721       PRINT_STRUCT_VALUE (Struct, Type17, ExtendedSize);
 722       PRINT_STRUCT_VALUE (Struct, Type17, ConfiguredMemoryClockSpeed);
 723     }
 724     break;
 725
 726   //
 727   // 32-bit Memory Error Information (Type 18)
 728   //
 729   case 18:
 730     DisplayMemoryErrorType (Struct->Type18->ErrorType, Option);
 731     DisplayMemoryErrorGranularity (
 732       Struct->Type18->ErrorGranularity,
 733       Option
 734      );
 735     DisplayMemoryErrorOperation (Struct->Type18->ErrorOperation, Option);
 736     PRINT_STRUCT_VALUE_H (Struct, Type18, VendorSyndrome);
 737     PRINT_STRUCT_VALUE_H (Struct, Type18, MemoryArrayErrorAddress);
 738     PRINT_STRUCT_VALUE_H (Struct, Type18, DeviceErrorAddress);
 739     PRINT_STRUCT_VALUE_H (Struct, Type18, ErrorResolution);
 740     break;
 741
 742   //
 743   // Memory Array Mapped Address (Type 19)
 744   //
 745   case 19:
 746     PRINT_STRUCT_VALUE_H (Struct, Type19, StartingAddress);
 747     PRINT_STRUCT_VALUE_H (Struct, Type19, EndingAddress);
 748     PRINT_STRUCT_VALUE_H (Struct, Type19, MemoryArrayHandle);
 749     PRINT_STRUCT_VALUE_H (Struct, Type19, PartitionWidth);
 750     if (AE_SMBIOS_VERSION (0x2, 0x7) && (Struct->Hdr->Length > 0xF)) {
 751       PRINT_STRUCT_VALUE_LH (Struct, Type19, ExtendedStartingAddress);
 752       PRINT_STRUCT_VALUE_LH (Struct, Type19, ExtendedEndingAddress);
 753     }
 754     break;
 755
 756   //
 757   // Memory Device Mapped Address (Type 20)
 758   //
 759   case 20:
 760     PRINT_STRUCT_VALUE_H (Struct, Type20, StartingAddress);
 761     PRINT_STRUCT_VALUE_H (Struct, Type20, EndingAddress);
 762     PRINT_STRUCT_VALUE_H (Struct, Type20, MemoryDeviceHandle);
 763     PRINT_STRUCT_VALUE_H (Struct, Type20, MemoryArrayMappedAddressHandle);
 764     PRINT_STRUCT_VALUE_H (Struct, Type20, PartitionRowPosition);
 765     PRINT_STRUCT_VALUE_H (Struct, Type20, InterleavePosition);
 766     PRINT_STRUCT_VALUE_H (Struct, Type20, InterleavedDataDepth);
 767     if (AE_SMBIOS_VERSION (0x2, 0x7) && (Struct->Hdr->Length > 0x13)) {
 768       PRINT_STRUCT_VALUE_LH (Struct, Type19, ExtendedStartingAddress);
 769       PRINT_STRUCT_VALUE_LH (Struct, Type19, ExtendedEndingAddress);
 770     }
 771     break;
 772
 773   //
 774   // Built-in Pointing Device (Type 21)
 775   //
 776   case 21:
 777     DisplayPointingDeviceType (Struct->Type21->Type, Option);
 778     DisplayPointingDeviceInterface (Struct->Type21->Interface, Option);
 779     PRINT_STRUCT_VALUE (Struct, Type21, NumberOfButtons);
 780     break;
 781
 782   //
 783   // Portable Battery (Type 22)
 784   //
 785   case 22:
 786     PRINT_PENDING_STRING (Struct, Type22, Location);
 787     PRINT_PENDING_STRING (Struct, Type22, Manufacturer);
 788     PRINT_PENDING_STRING (Struct, Type22, ManufactureDate);
 789     PRINT_PENDING_STRING (Struct, Type22, SerialNumber);
 790     PRINT_PENDING_STRING (Struct, Type22, DeviceName);
 791     DisplayPBDeviceChemistry (
 792       Struct->Type22->DeviceChemistry,
 793       Option
 794      );
 795     PRINT_STRUCT_VALUE_H (Struct, Type22, DeviceCapacity);
 796     PRINT_STRUCT_VALUE_H (Struct, Type22, DesignVoltage);
 797     PRINT_PENDING_STRING (Struct, Type22, SBDSVersionNumber);
 798     PRINT_STRUCT_VALUE_H (Struct, Type22, MaximumErrorInBatteryData);
 799     PRINT_STRUCT_VALUE_H (Struct, Type22, SBDSSerialNumber);
 800     DisplaySBDSManufactureDate (
 801       Struct->Type22->SBDSManufactureDate,
 802       Option
 803      );
 804     PRINT_PENDING_STRING (Struct, Type22, SBDSDeviceChemistry);
 805     PRINT_STRUCT_VALUE_H (Struct, Type22, DesignCapacityMultiplier);
 806     PRINT_STRUCT_VALUE_H (Struct, Type22, OEMSpecific);
 807     break;
 808
 809   //
 810   // System Reset (Type 23)
 811   //
 812   case 23:
 813     DisplaySystemResetCapabilities (
 814       Struct->Type23->Capabilities,
 815       Option
 816      );
 817     PRINT_STRUCT_VALUE_H (Struct, Type23, ResetCount);
 818     PRINT_STRUCT_VALUE_H (Struct, Type23, ResetLimit);
 819     PRINT_STRUCT_VALUE_H (Struct, Type23, TimerInterval);
 820     PRINT_STRUCT_VALUE_H (Struct, Type23, Timeout);
 821     break;
 822
 823   //
 824   // Hardware Security (Type 24)
 825   //
 826   case 24:
 827     DisplayHardwareSecuritySettings (
 828       Struct->Type24->HardwareSecuritySettings,
 829       Option
 830      );
 831     break;
 832
 833   //
 834   // System Power Controls (Type 25)
 835   //
 836   case 25:
 837     PRINT_STRUCT_VALUE_H (Struct, Type25, NextScheduledPowerOnMonth);
 838     PRINT_STRUCT_VALUE_H (Struct, Type25, NextScheduledPowerOnDayOfMonth);
 839     PRINT_STRUCT_VALUE_H (Struct, Type25, NextScheduledPowerOnHour);
 840     PRINT_STRUCT_VALUE_H (Struct, Type25, NextScheduledPowerOnMinute);
 841     PRINT_STRUCT_VALUE_H (Struct, Type25, NextScheduledPowerOnSecond);
 842     break;
 843
 844   //
 845   // Voltage Probe (Type 26)
 846   //
 847   case 26:
 848     PRINT_PENDING_STRING (Struct, Type26, Description);
 849     DisplayVPLocation (*(UINT8 *) &(Struct->Type26->LocationAndStatus), Option);
 850     DisplayVPStatus (*(UINT8 *) &(Struct->Type26->LocationAndStatus), Option);
 851     PRINT_STRUCT_VALUE_H (Struct, Type26, MaximumValue);
 852     PRINT_STRUCT_VALUE_H (Struct, Type26, MinimumValue);
 853     PRINT_STRUCT_VALUE_H (Struct, Type26, Resolution);
 854     PRINT_STRUCT_VALUE_H (Struct, Type26, Tolerance);
 855     PRINT_STRUCT_VALUE_H (Struct, Type26, Accuracy);
 856     PRINT_STRUCT_VALUE_H (Struct, Type26, OEMDefined);
 857     PRINT_STRUCT_VALUE_H (Struct, Type26, NominalValue);
 858     break;
 859
 860   //
 861   // Cooling Device (Type 27)
 862   //
 863   case 27:
 864     PRINT_STRUCT_VALUE_H (Struct, Type27, TemperatureProbeHandle);
 865     DisplayCoolingDeviceStatus (*(UINT8 *) &(Struct->Type27->DeviceTypeAndStatus), Option);
 866     DisplayCoolingDeviceType (*(UINT8 *) &(Struct->Type27->DeviceTypeAndStatus), Option);
 867     PRINT_STRUCT_VALUE_H (Struct, Type27, CoolingUnitGroup);
 868     PRINT_STRUCT_VALUE_H (Struct, Type27, OEMDefined);
 869     PRINT_STRUCT_VALUE_H (Struct, Type27, NominalSpeed);
 870     if (AE_SMBIOS_VERSION (0x2, 0x7) && (Struct->Hdr->Length > 0xE)) {
 871       PRINT_PENDING_STRING (Struct, Type27, Description);
 872     }
 873     break;
 874
 875   //
 876   // Temperature Probe (Type 28)
 877   //
 878   case 28:
 879     PRINT_PENDING_STRING (Struct, Type28, Description);
 880     DisplayTemperatureProbeStatus (*(UINT8 *) &(Struct->Type28->LocationAndStatus), Option);
 881     DisplayTemperatureProbeLoc (*(UINT8 *) &(Struct->Type28->LocationAndStatus), Option);
 882     PRINT_STRUCT_VALUE_H (Struct, Type28, MaximumValue);
 883     PRINT_STRUCT_VALUE_H (Struct, Type28, MinimumValue);
 884     PRINT_STRUCT_VALUE_H (Struct, Type28, Resolution);
 885     PRINT_STRUCT_VALUE_H (Struct, Type28, Tolerance);
 886     PRINT_STRUCT_VALUE_H (Struct, Type28, Accuracy);
 887     PRINT_STRUCT_VALUE_H (Struct, Type28, OEMDefined);
 888     PRINT_STRUCT_VALUE_H (Struct, Type28, NominalValue);
 889     break;
 890
 891   //
 892   // Electrical Current Probe (Type 29)
 893   //
 894   case 29:
 895     PRINT_PENDING_STRING (Struct, Type29, Description);
 896     DisplayECPStatus (*(UINT8 *) &(Struct->Type29->LocationAndStatus), Option);
 897     DisplayECPLoc (*(UINT8 *) &(Struct->Type29->LocationAndStatus), Option);
 898     PRINT_STRUCT_VALUE_H (Struct, Type29, MaximumValue);
 899     PRINT_STRUCT_VALUE_H (Struct, Type29, MinimumValue);
 900     PRINT_STRUCT_VALUE_H (Struct, Type29, Resolution);
 901     PRINT_STRUCT_VALUE_H (Struct, Type29, Tolerance);
 902     PRINT_STRUCT_VALUE_H (Struct, Type29, Accuracy);
 903     PRINT_STRUCT_VALUE_H (Struct, Type29, OEMDefined);
 904     PRINT_STRUCT_VALUE_H (Struct, Type29, NominalValue);
 905     break;
 906
 907   //
 908   // Out-of-Band Remote Access (Type 30)
 909   //
 910   case 30:
 911     PRINT_PENDING_STRING (Struct, Type30, ManufacturerName);
 912     DisplayOBRAConnections (Struct->Type30->Connections, Option);
 913     break;
 914
 915   //
 916   // Boot Integrity Services (BIS) Entry Point (Type 31)
 917   //
 918   case 31:
 919     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_STRUCT_TYPE31), gShellDebug1HiiHandle);
 920     break;
 921
 922   //
 923   // System Boot Information (Type 32)
 924   //
 925   case 32:
 926     PRINT_BIT_FIELD (Struct, Type32, Reserved, 6);
 927     DisplaySystemBootStatus (Struct->Type32->BootStatus, Option);
 928     break;
 929
 930   //
 931   // 64-Bit Memory Error Information (Type 33)
 932   //
 933   case 33:
 934     DisplayMemoryErrorType (Struct->Type33->ErrorType, Option);
 935     DisplayMemoryErrorGranularity (
 936       Struct->Type33->ErrorGranularity,
 937       Option
 938      );
 939     DisplayMemoryErrorOperation (Struct->Type33->ErrorOperation, Option);
 940     PRINT_STRUCT_VALUE_H (Struct, Type33, VendorSyndrome);
 941     PRINT_STRUCT_VALUE_LH (Struct, Type33, MemoryArrayErrorAddress);
 942     PRINT_STRUCT_VALUE_LH (Struct, Type33, DeviceErrorAddress);
 943     PRINT_STRUCT_VALUE_H (Struct, Type33, ErrorResolution);
 944     break;
 945
 946   //
 947   // Management Device (Type 34)
 948   //
 949   case 34:
 950     PRINT_PENDING_STRING (Struct, Type34, Description);
 951     DisplayMDType (Struct->Type34->Type, Option);
 952     PRINT_STRUCT_VALUE_H (Struct, Type34, Address);
 953     DisplayMDAddressType (Struct->Type34->AddressType, Option);
 954     break;
 955
 956   //
 957   // Management Device Component (Type 35)
 958   //
 959   case 35:
 960     PRINT_PENDING_STRING (Struct, Type35, Description);
 961     PRINT_STRUCT_VALUE_H (Struct, Type35, ManagementDeviceHandle);
 962     PRINT_STRUCT_VALUE_H (Struct, Type35, ComponentHandle);
 963     PRINT_STRUCT_VALUE_H (Struct, Type35, ThresholdHandle);
 964     break;
 965
 966   //
 967   // Management Device Threshold Data (Type 36)
 968   //
 969   case 36:
 970     PRINT_STRUCT_VALUE_H (Struct, Type36, LowerThresholdNonCritical);
 971     PRINT_STRUCT_VALUE_H (Struct, Type36, UpperThresholdNonCritical);
 972     PRINT_STRUCT_VALUE_H (Struct, Type36, LowerThresholdCritical);
 973     PRINT_STRUCT_VALUE_H (Struct, Type36, UpperThresholdCritical);
 974     PRINT_STRUCT_VALUE_H (Struct, Type36, LowerThresholdNonRecoverable);
 975     PRINT_STRUCT_VALUE_H (Struct, Type36, UpperThresholdNonRecoverable);
 976     break;
 977
 978   //
 979   // Memory Channel (Type 37)
 980   //
 981   case 37:
 982     {
 983       UINT8          Count;
 984       MEMORY_DEVICE  *Ptr;
 985       DisplayMemoryChannelType (Struct->Type37->ChannelType, Option);
 986       PRINT_STRUCT_VALUE_H (Struct, Type37, MaximumChannelLoad);
 987       PRINT_STRUCT_VALUE_H (Struct, Type37, MemoryDeviceCount);
 988
 989       Count = Struct->Type37->MemoryDeviceCount;
 990       Ptr   = Struct->Type37->MemoryDevice;
 991       for (Index = 0; Index < Count; Index++) {
 992         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEM_DEVICE), gShellDebug1HiiHandle, Index + 1);
 993         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DEV_LOAD), gShellDebug1HiiHandle, Ptr[Index].DeviceLoad);
 994         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DEV_HANDLE), gShellDebug1HiiHandle, Ptr[Index].DeviceHandle);
 995       }
 996     }
 997     break;
 998
 999   //
1000   // IPMI Device Information (Type 38)
1001   //
1002   case 38:
1003     DisplayIPMIDIBMCInterfaceType (Struct->Type38->InterfaceType, Option);
1004     PRINT_STRUCT_VALUE_H (Struct, Type38, IPMISpecificationRevision);
1005     PRINT_STRUCT_VALUE_H (Struct, Type38, I2CSlaveAddress);
1006     PRINT_STRUCT_VALUE_H (Struct, Type38, NVStorageDeviceAddress);
1007     PRINT_STRUCT_VALUE_LH (Struct, Type38, BaseAddress);
1008     break;
1009
1010   //
1011   // System Power Supply (Type 39)
1012   //
1013   case 39:
1014     PRINT_STRUCT_VALUE_H (Struct, Type39, PowerUnitGroup);
1015     PRINT_PENDING_STRING (Struct, Type39, Location);
1016     PRINT_PENDING_STRING (Struct, Type39, DeviceName);
1017     PRINT_PENDING_STRING (Struct, Type39, Manufacturer);
1018     PRINT_PENDING_STRING (Struct, Type39, SerialNumber);
1019     PRINT_PENDING_STRING (Struct, Type39, AssetTagNumber);
1020     PRINT_PENDING_STRING (Struct, Type39, ModelPartNumber);
1021     PRINT_PENDING_STRING (Struct, Type39, RevisionLevel);
1022     PRINT_STRUCT_VALUE_H (Struct, Type39, MaxPowerCapacity);
1023     DisplaySPSCharacteristics (
1024       *(UINT16 *) &(Struct->Type39->PowerSupplyCharacteristics),
1025       Option
1026      );
1027     PRINT_STRUCT_VALUE_H (Struct, Type39, InputVoltageProbeHandle);
1028     PRINT_STRUCT_VALUE_H (Struct, Type39, CoolingDeviceHandle);
1029     PRINT_STRUCT_VALUE_H (Struct, Type39, InputCurrentProbeHandle);
1030     break;
1031
1032   //
1033   // Additional Information (Type 40)
1034   //
1035   case 40:
1036     {
1037       UINT8                          NumberOfEntries;
1038       UINT8                          EntryLength;
1039       ADDITIONAL_INFORMATION_ENTRY   *Entries;
1040
1041       EntryLength     = 0;
1042       Entries         = Struct->Type40->AdditionalInfoEntries;
1043       NumberOfEntries = Struct->Type40->NumberOfAdditionalInformationEntries;
1044
1045       PRINT_STRUCT_VALUE_H (Struct, Type40, NumberOfAdditionalInformationEntries);
1046
1047       for (Index = 0; Index < NumberOfEntries; Index++) {
1048         EntryLength = Entries->EntryLength;
1049         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_ENTRYLEN), gShellDebug1HiiHandle, EntryLength);
1050         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_REFERENCEDHANDLE), gShellDebug1HiiHandle, Entries->ReferencedHandle);
1051         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_REFERENCEDOFFSET), gShellDebug1HiiHandle, Entries->ReferencedOffset);
1052         PRINT_SMBIOS_STRING (Struct, Entries->EntryString, String);
1053         PRINT_SMBIOS_BIT_FIELD (Struct, Entries->Value, Value, EntryLength - 5);
1054         Entries = (ADDITIONAL_INFORMATION_ENTRY *) ((UINT8 *)Entries + EntryLength);
1055       }
1056     }
1057     break;
1058
1059   //
1060   // Onboard Devices Extended Information (Type 41)
1061   //
1062   case 41:
1063     PRINT_PENDING_STRING (Struct, Type41, ReferenceDesignation);
1064     ShellPrintEx(-1,-1,(((Struct->Type41->DeviceType) & 0x80) != 0) ? L"Device Enabled\n": L"Device Disabled\n");
1065     DisplayOnboardDeviceTypes ((Struct->Type41->DeviceType) & 0x7F, Option);
1066     PRINT_STRUCT_VALUE_H (Struct, Type41, DeviceTypeInstance);
1067     PRINT_STRUCT_VALUE_H (Struct, Type41, SegmentGroupNum);
1068     PRINT_STRUCT_VALUE_H (Struct, Type41, BusNum);
1069     PRINT_STRUCT_VALUE_H (Struct, Type41, DevFuncNum);
1070     break;
1071
1072   //
1073   // Management Controller Host Interface (Type 42)
1074   //
1075   case 42:
1076     PRINT_STRUCT_VALUE_H (Struct, Type42, InterfaceType);
1077     break;
1078
1079   //
1080   // Inactive (Type 126)
1081   //
1082   case 126:
1083     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INACTIVE_STRUCT), gShellDebug1HiiHandle);
1084     break;
1085
1086   //
1087   // End-of-Table (Type 127)
1088   //
1089   case 127:
1090     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_THIS_STRUCT_END_TABLE), gShellDebug1HiiHandle);
1091     break;
1092
1093   default:
1094     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_STRUCT_TYPE_UNDEFINED), gShellDebug1HiiHandle);
1095     break;
1096   }
1097
1098   return EFI_SUCCESS;
1099 }
1100
1101 /**
1102   Display BIOS Information (Type 0) information.
1103
1104   @param[in] Chara    The information bits.
1105   @param[in] Option   The optional information.
1106 **/
1107 VOID
1108 DisplayBiosCharacteristics (
1109   IN UINT64  Chara,
1110   IN UINT8   Option
1111   )
1112 {
1113   //
1114   // Print header
1115   //
1116   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_CHAR), gShellDebug1HiiHandle);
1117   //
1118   // print option
1119   //
1120   PRINT_INFO_OPTION (Chara, Option);
1121
1122   //
1123   // Check all the bits and print information
1124   // This function does not use Table because table of bits
1125   //   are designed not to deal with UINT64
1126   //
1127   if (BIT (Chara, 0) != 0) {
1128     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED_BIT), gShellDebug1HiiHandle);
1129   }
1130
1131   if (BIT (Chara, 1) != 0) {
1132     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED_BIT), gShellDebug1HiiHandle);
1133   }
1134
1135   if (BIT (Chara, 2) != 0) {
1136     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN_BIT), gShellDebug1HiiHandle);
1137   }
1138
1139   if (BIT (Chara, 3) != 0) {
1140     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_CHAR_NOT_SUPPORTED), gShellDebug1HiiHandle);
1141   }
1142
1143   if (BIT (Chara, 4) != 0) {
1144     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ISA_SUPPORTED), gShellDebug1HiiHandle);
1145   }
1146
1147   if (BIT (Chara, 5) != 0) {
1148     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MSA_SUPPORTED), gShellDebug1HiiHandle);
1149   }
1150
1151   if (BIT (Chara, 6) != 0) {
1152     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_EISA_SUPPORTED), gShellDebug1HiiHandle);
1153   }
1154
1155   if (BIT (Chara, 7) != 0) {
1156     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PCI_SUPPORTED), gShellDebug1HiiHandle);
1157   }
1158
1159   if (BIT (Chara, 8) != 0) {
1160     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PC_CARD_SUPPORTED), gShellDebug1HiiHandle);
1161   }
1162
1163   if (BIT (Chara, 9) != 0) {
1164     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PLUG_PLAY_SUPPORTED), gShellDebug1HiiHandle);
1165   }
1166
1167   if (BIT (Chara, 10) != 0) {
1168     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_APM_SUPPORTED), gShellDebug1HiiHandle);
1169   }
1170
1171   if (BIT (Chara, 11) != 0) {
1172     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_UPGRADEABLE), gShellDebug1HiiHandle);
1173   }
1174
1175   if (BIT (Chara, 12) != 0) {
1176     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_SHADOWING), gShellDebug1HiiHandle);
1177   }
1178
1179   if (BIT (Chara, 13) != 0) {
1180     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VESA_SUPPORTED), gShellDebug1HiiHandle);
1181   }
1182
1183   if (BIT (Chara, 14) != 0) {
1184     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ECSD_SUPPORT), gShellDebug1HiiHandle);
1185   }
1186
1187   if (BIT (Chara, 15) != 0) {
1188     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BOOT_FORM_CD_SUPPORTED), gShellDebug1HiiHandle);
1189   }
1190
1191   if (BIT (Chara, 16) != 0) {
1192     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SELECTED_BOOT_SUPPORTED), gShellDebug1HiiHandle);
1193   }
1194
1195   if (BIT (Chara, 17) != 0) {
1196     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_ROM_SOCKETED), gShellDebug1HiiHandle);
1197   }
1198
1199   if (BIT (Chara, 18) != 0) {
1200     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BOOT_FROM_PC_CARD), gShellDebug1HiiHandle);
1201   }
1202
1203   if (BIT (Chara, 19) != 0) {
1204     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_EDD_ENHANCED_DRIVER), gShellDebug1HiiHandle);
1205   }
1206
1207   if (BIT (Chara, 20) != 0) {
1208     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_JAPANESE_FLOPPY_NEC), gShellDebug1HiiHandle);
1209   }
1210
1211   if (BIT (Chara, 21) != 0) {
1212     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_JAPANESE_FLOPPY_TOSHIBA), gShellDebug1HiiHandle);
1213   }
1214
1215   if (BIT (Chara, 22) != 0) {
1216     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FLOPPY_SERVICES_SUPPORTED), gShellDebug1HiiHandle);
1217   }
1218
1219   if (BIT (Chara, 23) != 0) {
1220     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ONE_POINT_TWO_MB), gShellDebug1HiiHandle);
1221   }
1222
1223   if (BIT (Chara, 24) != 0) {
1224     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_720_KB), gShellDebug1HiiHandle);
1225   }
1226
1227   if (BIT (Chara, 25) != 0) {
1228     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_TWO_POINT_EIGHT_EIGHT_MB), gShellDebug1HiiHandle);
1229   }
1230
1231   if (BIT (Chara, 26) != 0) {
1232     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PRINT_SCREEN_SUPPORT), gShellDebug1HiiHandle);
1233   }
1234
1235   if (BIT (Chara, 27) != 0) {
1236     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_KEYBOARD_SERV_SUPPORT), gShellDebug1HiiHandle);
1237   }
1238
1239   if (BIT (Chara, 28) != 0) {
1240     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SERIAL_SERVICES_SUPPORT), gShellDebug1HiiHandle);
1241   }
1242
1243   if (BIT (Chara, 29) != 0) {
1244     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PRINTER_SERVICES_SUPPORT), gShellDebug1HiiHandle);
1245   }
1246
1247   if (BIT (Chara, 30) != 0) {
1248     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MONO_VIDEO_SUPPORT), gShellDebug1HiiHandle);
1249   }
1250
1251   if (BIT (Chara, 31) != 0) {
1252     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NEC_PC_98), gShellDebug1HiiHandle);
1253   }
1254   //
1255   // Just print the Reserved
1256   //
1257   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_32_47), gShellDebug1HiiHandle);
1258   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_48_64), gShellDebug1HiiHandle);
1259 }
1260
1261 /**
1262   Display Bios Characteristice extensions1 information.
1263
1264   @param[in] Byte1    The information.
1265   @param[in] Option   The optional information.
1266 **/
1267 VOID
1268 DisplayBiosCharacteristicsExt1 (
1269   IN UINT8 Byte1,
1270   IN UINT8 Option
1271   )
1272 {
1273   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_CHAR_EXTENSION), gShellDebug1HiiHandle);
1274   //
1275   // Print option
1276   //
1277   PRINT_INFO_OPTION (Byte1, Option);
1278
1279   //
1280   // check bit and print
1281   //
1282   if (BIT (Byte1, 0) != 0) {
1283     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ACPI_SUPPORTED), gShellDebug1HiiHandle);
1284   }
1285
1286   if (BIT (Byte1, 1) != 0) {
1287     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_USB_LEGACY_SUPPORTED), gShellDebug1HiiHandle);
1288   }
1289
1290   if (BIT (Byte1, 2) != 0) {
1291     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AGP_SUPPORTED), gShellDebug1HiiHandle);
1292   }
1293
1294   if (BIT (Byte1, 3) != 0) {
1295     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_I2O_BOOT_SUPPORTED), gShellDebug1HiiHandle);
1296   }
1297
1298   if (BIT (Byte1, 4) != 0) {
1299     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_LS_120_BOOT_SUPPORTED), gShellDebug1HiiHandle);
1300   }
1301
1302   if (BIT (Byte1, 5) != 0) {
1303     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ATAPI_ZIP_DRIVE), gShellDebug1HiiHandle);
1304   }
1305
1306   if (BIT (Byte1, 6) != 0) {
1307     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_1394_BOOT_SUPPORTED), gShellDebug1HiiHandle);
1308   }
1309
1310   if (BIT (Byte1, 7) != 0) {
1311     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SMART_BATTERY_SUPPORTED), gShellDebug1HiiHandle);
1312   }
1313 }
1314
1315 /**
1316   Display Bios Characteristice extensions2 information.
1317
1318   @param[in] byte2    The information.
1319   @param[in] Option   The optional information.
1320 **/
1321 VOID
1322 DisplayBiosCharacteristicsExt2 (
1323   IN UINT8 byte2,
1324   IN UINT8 Option
1325   )
1326 {
1327   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_CHAR_EXTENSION_2), gShellDebug1HiiHandle);
1328   //
1329   // Print option
1330   //
1331   PRINT_INFO_OPTION (byte2, Option);
1332
1333   if (BIT (byte2, 0) != 0) {
1334     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_BOOT_SPEC_SUPP), gShellDebug1HiiHandle);
1335   }
1336
1337   if (BIT (byte2, 1) != 0) {
1338     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FUNCTION_KEY_INIT), gShellDebug1HiiHandle);
1339   }
1340
1341   if (AE_SMBIOS_VERSION (0x2, 0x4)) {
1342     if (BIT (byte2, 2) != 0) {
1343       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLE_TAR_CONT_DIST), gShellDebug1HiiHandle);
1344     }
1345     if (AE_SMBIOS_VERSION (0x2, 0x7)) {
1346       if (BIT (byte2, 3) != 0) {
1347         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UEFI_SPEC_SUPPORT), gShellDebug1HiiHandle);
1348       }
1349       if (BIT (byte2, 4) != 0) {
1350         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VIRTUAL_MACHINE), gShellDebug1HiiHandle);
1351       }
1352       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RSVD_FOR_FUTURE), gShellDebug1HiiHandle, 5);
1353     } else {
1354       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RSVD_FOR_FUTURE), gShellDebug1HiiHandle, 3);
1355     }
1356   } else {
1357     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RSVD_FOR_FUTURE), gShellDebug1HiiHandle, 2);
1358   }
1359 }
1360
1361 /**
1362   Display Processor Information (Type 4) information.
1363
1364   @param[in] Family       The family value.
1365   @param[in] Option       The option value.
1366 **/
1367 VOID
1368 DisplayProcessorFamily (
1369   UINT8 Family,
1370   UINT8 Option
1371   )
1372 {
1373   //
1374   // Print prompt message
1375   //
1376   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PROCESSOR_FAMILY), gShellDebug1HiiHandle);
1377   //
1378   // Print option
1379   //
1380   PRINT_INFO_OPTION (Family, Option);
1381
1382   //
1383   // Use switch to check
1384   //
1385   switch (Family) {
1386   case 0x01:
1387     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTHER), gShellDebug1HiiHandle);
1388     break;
1389
1390   case 0x02:
1391     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
1392     break;
1393
1394   case 0x03:
1395     Print (L"8086\n");
1396     break;
1397
1398   case 0x04:
1399     Print (L"80286\n");
1400     break;
1401
1402   case 0x05:
1403     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL386_PROCESSOR), gShellDebug1HiiHandle);
1404     break;
1405
1406   case 0x06:
1407     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL486_PROCESSOR), gShellDebug1HiiHandle);
1408     break;
1409
1410   case 0x07:
1411     Print (L"8087\n");
1412     break;
1413
1414   case 0x08:
1415     Print (L"80287\n");
1416     break;
1417
1418   case 0x09:
1419     Print (L"80387\n");
1420     break;
1421
1422   case 0x0A:
1423     Print (L"80487\n");
1424     break;
1425
1426   case 0x0B:
1427     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_PROC_FAMILY), gShellDebug1HiiHandle);
1428     break;
1429
1430   case 0x0C:
1431     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_PRO_PROC), gShellDebug1HiiHandle);
1432     break;
1433
1434   case 0x0D:
1435     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_II_PROC), gShellDebug1HiiHandle);
1436     break;
1437
1438   case 0x0E:
1439     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_PROC_MMX), gShellDebug1HiiHandle);
1440     break;
1441
1442   case 0x0F:
1443     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CELERON_PROC), gShellDebug1HiiHandle);
1444     break;
1445
1446   case 0x10:
1447     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_XEON_PROC), gShellDebug1HiiHandle);
1448     break;
1449
1450   case 0x11:
1451     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_III_PROC), gShellDebug1HiiHandle);
1452     break;
1453
1454   case 0x12:
1455     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_M1_FAMILY), gShellDebug1HiiHandle);
1456     break;
1457
1458   case 0x13:
1459     Print (L"M2 Family\n");
1460     break;
1461
1462   case 0x14:
1463     Print (L"Intel Celeron M\n");
1464     break;
1465
1466   case 0x15:
1467     Print (L"Intel Pentium 4 HT\n");
1468     break;
1469
1470   case 0x18:
1471     Print (L"AMD Duron\n");
1472     break;
1473
1474   case 0x19:
1475     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_K5_FAMILY), gShellDebug1HiiHandle);
1476     break;
1477
1478   case 0x1A:
1479     Print (L"K6 Family\n");
1480     break;
1481
1482   case 0x1B:
1483     Print (L"K6-2\n");
1484     break;
1485
1486   case 0x1C:
1487     Print (L"K6-3\n");
1488     break;
1489
1490   case 0x1D:
1491     Print (L"AMD Althon Processor Family\n");
1492     break;
1493
1494   case 0x1E:
1495     Print (L"AMD 29000 Family\n");
1496     break;
1497
1498   case 0x1F:
1499     Print (L"K6-2+\n");
1500     break;
1501
1502   case 0x20:
1503     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_PC_FAMILY), gShellDebug1HiiHandle);
1504     break;
1505
1506   case 0x21:
1507     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_PC_601), gShellDebug1HiiHandle);
1508     break;
1509
1510   case 0x22:
1511     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_PC_603), gShellDebug1HiiHandle);
1512     break;
1513
1514   case 0x23:
1515     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_PC_603_PLUS), gShellDebug1HiiHandle);
1516     break;
1517
1518   case 0x24:
1519     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_PC_604), gShellDebug1HiiHandle);
1520     break;
1521
1522   case 0x25:
1523     Print (L"Power PC 620\n");
1524     break;
1525
1526   case 0x26:
1527     Print (L"Power PC 704\n");
1528     break;
1529
1530   case 0x27:
1531     Print (L"Power PC 750\n");
1532     break;
1533
1534   case 0x28:
1535     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CORE_DUO), gShellDebug1HiiHandle);
1536     break;
1537
1538   case 0x29:
1539     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CORE_DUO_MOBILE), gShellDebug1HiiHandle);
1540     break;
1541
1542   case 0x2A:
1543     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CORE_SOLO_MOBILE), gShellDebug1HiiHandle);
1544     break;
1545
1546   case 0x2B:
1547     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_ATOM), gShellDebug1HiiHandle);
1548     break;
1549
1550   case 0x30:
1551     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ALPHA_FAMILY_2), gShellDebug1HiiHandle);
1552     break;
1553
1554   case 0x31:
1555     Print (L"Alpha 21064\n");
1556     break;
1557
1558   case 0x32:
1559     Print (L"Alpha 21066\n");
1560     break;
1561
1562   case 0x33:
1563     Print (L"Alpha 21164\n");
1564     break;
1565
1566   case 0x34:
1567     Print (L"Alpha 21164PC\n");
1568     break;
1569
1570   case 0x35:
1571     Print (L"Alpha 21164a\n");
1572     break;
1573
1574   case 0x36:
1575     Print (L"Alpha 21264\n");
1576     break;
1577
1578   case 0x37:
1579     Print (L"Alpha 21364\n");
1580     break;
1581
1582   case 0x38:
1583     Print (L"AMD Turion II Ultra Dual-Core Mobile M Processor Family\n");
1584     break;
1585
1586   case 0x39:
1587     Print (L"AMD Turion II Dual-Core Mobile M Processor Family\n");
1588     break;
1589
1590   case 0x3A:
1591     Print (L"AMD Althon II Dual-Core M Processor Family\n");
1592     break;
1593
1594   case 0x3B:
1595     Print (L"AMD Opteron 6100 Series Processor\n");
1596     break;
1597
1598   case 0x3C:
1599     Print (L"AMD Opteron 4100 Series Processor\n");
1600     break;
1601
1602   case 0x3D:
1603     Print (L"AMD Opteron 6200 Series Processor\n");
1604     break;
1605
1606   case 0x3E:
1607     Print (L"AMD Opteron 4200 Series Processor\n");
1608     break;
1609
1610   case 0x3F:
1611     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_FX_SERIES), gShellDebug1HiiHandle);
1612     break;
1613
1614   case 0x40:
1615     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MIPS_FAMILY), gShellDebug1HiiHandle);
1616     break;
1617
1618   case 0x41:
1619     Print (L"MIPS R4000\n");
1620     break;
1621
1622   case 0x42:
1623     Print (L"MIPS R4200\n");
1624     break;
1625
1626   case 0x43:
1627     Print (L"MIPS R4400\n");
1628     break;
1629
1630   case 0x44:
1631     Print (L"MIPS R4600\n");
1632     break;
1633
1634   case 0x45:
1635     Print (L"MIPS R10000\n");
1636     break;
1637
1638   case 0x46:
1639     Print (L"AMD C-Series Processor\n");
1640     break;
1641
1642   case 0x47:
1643     Print (L"AMD E-Series Processor\n");
1644     break;
1645
1646   case 0x48:
1647     Print (L"AMD A-Series Processor\n");
1648     break;
1649
1650   case 0x49:
1651     Print (L"AMD G-Series Processor\n");
1652     break;
1653
1654   case 0x4A:
1655     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_Z_SERIES), gShellDebug1HiiHandle);
1656     break;
1657
1658   case 0x4B:
1659     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_R_SERIES), gShellDebug1HiiHandle);
1660     break;
1661
1662   case 0x4C:
1663     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_4300_SERIES), gShellDebug1HiiHandle);
1664     break;
1665
1666   case 0x4D:
1667     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_6300_SERIES), gShellDebug1HiiHandle);
1668     break;
1669
1670   case 0x4E:
1671     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_3300_SERIES), gShellDebug1HiiHandle);
1672     break;
1673
1674   case 0x4F:
1675     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_FIREPRO_SERIES), gShellDebug1HiiHandle);
1676     break;
1677
1678   case 0x50:
1679     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SPARC_FAMILY), gShellDebug1HiiHandle);
1680     break;
1681
1682   case 0x51:
1683     Print (L"SuperSparc\n");
1684     break;
1685
1686   case 0x52:
1687     Print (L"microSparc II\n");
1688     break;
1689
1690   case 0x53:
1691     Print (L"microSparc IIep\n");
1692     break;
1693
1694   case 0x54:
1695     Print (L"UltraSparc\n");
1696     break;
1697
1698   case 0x55:
1699     Print (L"UltraSparc II\n");
1700     break;
1701
1702   case 0x56:
1703     Print (L"UltraSparcIIi\n");
1704     break;
1705
1706   case 0x57:
1707     Print (L"UltraSparcIII\n");
1708     break;
1709
1710   case 0x58:
1711     Print (L"UltraSparcIIIi\n");
1712     break;
1713
1714   case 0x60:
1715     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_68040_FAMILY), gShellDebug1HiiHandle);
1716     break;
1717
1718   case 0x61:
1719     Print (L"68xx\n");
1720     break;
1721
1722   case 0x62:
1723     Print (L"68000\n");
1724     break;
1725
1726   case 0x63:
1727     Print (L"68010\n");
1728     break;
1729
1730   case 0x64:
1731     Print (L"68020\n");
1732     break;
1733
1734   case 0x65:
1735     Print (L"68030\n");
1736     break;
1737
1738   case 0x70:
1739     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_HOBBIT_FAMILY), gShellDebug1HiiHandle);
1740     break;
1741
1742   case 0x78:
1743     Print (L"Crusoe TM5000\n");
1744     break;
1745
1746   case 0x79:
1747     Print (L"Crusoe TM3000\n");
1748     break;
1749
1750   case 0x7A:
1751     Print (L"Efficeon TM8000\n");
1752     break;
1753
1754   case 0x80:
1755     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_WEITEK), gShellDebug1HiiHandle);
1756     break;
1757
1758   case 0x82:
1759     Print (L"Itanium\n");
1760     break;
1761
1762   case 0x83:
1763     Print (L"AMD Athlon64\n");
1764     break;
1765
1766   case 0x84:
1767     Print (L"AMD Opteron\n");
1768     break;
1769
1770   case 0x85:
1771     Print (L"AMD Sempron\n");
1772     break;
1773
1774   case 0x86:
1775     Print (L"AMD Turion64 Mobile\n");
1776     break;
1777
1778   case 0x87:
1779     Print (L"Dual-Core AMD Opteron\n");
1780     break;
1781
1782   case 0x88:
1783     Print (L"AMD Athlon 64X2 DualCore\n");
1784     break;
1785
1786   case 0x89:
1787     Print (L"AMD Turion 64X2 Mobile\n");
1788     break;
1789
1790   case 0x8A:
1791     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_QUAD_CORE), gShellDebug1HiiHandle);
1792     break;
1793
1794   case 0x8B:
1795     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_THIRD_GENERATION), gShellDebug1HiiHandle);
1796     break;
1797
1798   case 0x8C:
1799     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_PHENOM_FX_QUAD_CORE), gShellDebug1HiiHandle);
1800     break;
1801
1802   case 0x8D:
1803     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_PHENOM_X4_QUAD_CORE), gShellDebug1HiiHandle);
1804     break;
1805
1806   case 0x8E:
1807     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_PHENOM_X2_DUAL_CORE), gShellDebug1HiiHandle);
1808     break;
1809
1810   case 0x8F:
1811     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_ATHLON_X2_DUAL_CORE), gShellDebug1HiiHandle);
1812     break;
1813
1814   case 0x90:
1815     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PA_RISC_FAMILY), gShellDebug1HiiHandle);
1816     break;
1817
1818   case 0x91:
1819     Print (L"PA-RISC 8500\n");
1820     break;
1821
1822   case 0x92:
1823     Print (L"PA-RISC 8000\n");
1824     break;
1825
1826   case 0x93:
1827     Print (L"PA-RISC 7300LC\n");
1828     break;
1829
1830   case 0x94:
1831     Print (L"PA-RISC 7200\n");
1832     break;
1833
1834   case 0x95:
1835     Print (L"PA-RISC 7100LC\n");
1836     break;
1837
1838   case 0x96:
1839     Print (L"PA-RISC 7100\n");
1840     break;
1841
1842   case 0xA0:
1843     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_V30_FAMILY), gShellDebug1HiiHandle);
1844     break;
1845
1846   case 0xA1:
1847     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_3200_SERIES_QUAD_CORE), gShellDebug1HiiHandle);
1848     break;
1849
1850   case 0xA2:
1851     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_3000_SERIES_DUAL_CORE), gShellDebug1HiiHandle);
1852     break;
1853
1854   case 0xA3:
1855     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_5300_SERIES_QUAD_CORE), gShellDebug1HiiHandle);
1856     break;
1857
1858   case 0xA4:
1859     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_5100_SERIES_DUAL_CORE), gShellDebug1HiiHandle);
1860     break;
1861
1862   case 0xA5:
1863     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_5000_SERIES_DUAL_CORE), gShellDebug1HiiHandle);
1864     break;
1865
1866   case 0xA6:
1867     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_LV_DUAL_CORE), gShellDebug1HiiHandle);
1868     break;
1869
1870   case 0xA7:
1871     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_ULV_DUAL_CORE), gShellDebug1HiiHandle);
1872     break;
1873
1874   case 0xA8:
1875     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_7100_SERIES_DUAL_CORE), gShellDebug1HiiHandle);
1876     break;
1877
1878   case 0xA9:
1879     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_5400_SERIES_QUAD_CORE), gShellDebug1HiiHandle);
1880     break;
1881
1882   case 0xAA:
1883     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_QUAD_CORE), gShellDebug1HiiHandle);
1884     break;
1885
1886   case 0xAB:
1887     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_5200_SERIES_DUAL_CORE), gShellDebug1HiiHandle);
1888     break;
1889
1890   case 0xAC:
1891     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_7200_SERIES_DUAL_CORE), gShellDebug1HiiHandle);
1892     break;
1893
1894   case 0xAD:
1895     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_7300_SERIES_QUAD_CORE), gShellDebug1HiiHandle);
1896     break;
1897
1898   case 0xAE:
1899     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_7400_SERIES_QUAD_CORE), gShellDebug1HiiHandle);
1900     break;
1901
1902   case 0xAF:
1903     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_7400_SERIES_MULTI_CORE), gShellDebug1HiiHandle);
1904     break;
1905
1906   case 0xB0:
1907     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PENTIUM_III_XEON), gShellDebug1HiiHandle);
1908     break;
1909
1910   case 0xB1:
1911     Print (L"Pentium III Processorwith Intel SpeedStep Technology\n");
1912     break;
1913
1914   case 0xB2:
1915     Print (L"Pentium 4 processor\n");
1916     break;
1917
1918   case 0xB3:
1919     Print (L"Intel Xeon Processor\n");
1920     break;
1921
1922   case 0xB4:
1923     Print (L"AS400 Family\n");
1924     break;
1925
1926   case 0xB5:
1927     Print (L"Intel Xeon processor MP\n");
1928     break;
1929
1930   case 0xB6:
1931     Print (L"AMD Althon XP Processor Family\n");
1932     break;
1933
1934   case 0xB7:
1935     Print (L"AMD Althon MP Promcessor Family\n");
1936     break;
1937
1938   case 0xB8:
1939     Print (L"Intel Itanium 2 processor\n");
1940     break;
1941
1942   case 0xB9:
1943     Print (L"Intel Penium M processor\n");
1944     break;
1945
1946   case 0xBA:
1947     Print (L"Intel Celeron D processor\n");
1948     break;
1949
1950   case 0xBB:
1951     Print (L"Intel Pentium D processor\n");
1952     break;
1953
1954   case 0xBC:
1955     Print (L"Intel Pentium Processor Extreme Edition\n");
1956     break;
1957
1958   case 0xBD:
1959     Print (L"Intel Core Solo Processor\n");
1960     break;
1961
1962   case 0xBF:
1963     Print (L"Intel Core 2 Duo Processor\n");
1964     break;
1965
1966   case 0xC0:
1967     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CORE2_SOLO), gShellDebug1HiiHandle);
1968     break;
1969
1970   case 0xC1:
1971     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CORE2_EXTREME), gShellDebug1HiiHandle);
1972     break;
1973
1974   case 0xC2:
1975     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CORE2_QUAD), gShellDebug1HiiHandle);
1976     break;
1977
1978   case 0xC3:
1979     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CORE2_EXTREME), gShellDebug1HiiHandle);
1980     break;
1981
1982   case 0xC4:
1983     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CORE2_DUO_MOBILE), gShellDebug1HiiHandle);
1984     break;
1985
1986   case 0xC5:
1987     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CORE2_SOLO_MOBILE), gShellDebug1HiiHandle);
1988     break;
1989
1990   case 0xC6:
1991     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CORE_I7), gShellDebug1HiiHandle);
1992     break;
1993
1994   case 0xC7:
1995     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CELERON_DUAL_CORE), gShellDebug1HiiHandle);
1996     break;
1997
1998   case 0xC8:
1999     Print (L"IBM 390\n");
2000     break;
2001
2002   case 0xC9:
2003     Print (L"G4\n");
2004     break;
2005
2006   case 0xCA:
2007     Print (L"G5\n");
2008     break;
2009
2010   case 0xCB:
2011     Print (L"G6\n");
2012     break;
2013
2014   case 0xCC:
2015     Print (L"zArchitecture\n");
2016     break;
2017
2018   case 0xCD:
2019     Print (L"Intel Core i5 processor\n");
2020     break;
2021
2022   case 0xCE:
2023     Print (L"Intel Core i3 processor\n");
2024     break;
2025
2026   case 0xD2:
2027     Print (L"ViaC7M\n");
2028     break;
2029
2030   case 0xD3:
2031     Print (L"ViaC7D\n");
2032     break;
2033
2034   case 0xD4:
2035     Print (L"ViaC7\n");
2036     break;
2037
2038   case 0xD5:
2039     Print (L"Eden\n");
2040     break;
2041
2042   case 0xD6:
2043     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_MULTI_CORE), gShellDebug1HiiHandle);
2044     break;
2045
2046   case 0xD7:
2047     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_3_SERIES_DUAL_CORE), gShellDebug1HiiHandle);
2048     break;
2049
2050   case 0xD8:
2051     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_3_SERIES_QUAD_CORE), gShellDebug1HiiHandle);
2052     break;
2053
2054   case 0xDA:
2055     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_5_SERIES_DUAL_CORE), gShellDebug1HiiHandle);
2056     break;
2057
2058   case 0xDB:
2059     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_5_SERIES_QUAD_CORE), gShellDebug1HiiHandle);
2060     break;
2061
2062   case 0xDD:
2063     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_7_SERIES_DUAL_CORE), gShellDebug1HiiHandle);
2064     break;
2065
2066   case 0xDE:
2067     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_7_SERIES_QUAD_CORE), gShellDebug1HiiHandle);
2068     break;
2069
2070   case 0xDF:
2071     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_XEON_7_SERIES_MULTI_CORE), gShellDebug1HiiHandle);
2072     break;
2073
2074   case 0xE0:
2075     Print (L"Multi-Core Intel Xeon processor 3400 Series\n");
2076     break;
2077
2078   case 0xE4:
2079     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_3000_SERIES), gShellDebug1HiiHandle);
2080     break;
2081
2082   case 0xE5:
2083     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_SEMPRON_II), gShellDebug1HiiHandle);
2084     break;
2085
2086
2087   case 0xE6:
2088     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_EMBEDDED_OPTERON_QUAD_CORE), gShellDebug1HiiHandle);
2089     break;
2090
2091   case 0xE7:
2092     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_PHENOM_TRIPLE_CORE), gShellDebug1HiiHandle);
2093     break;
2094
2095   case 0xE8:
2096     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_TURION_ULTRA_DUAL_CORE_MOBILE), gShellDebug1HiiHandle);
2097     break;
2098
2099   case 0xE9:
2100     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_TURION_DUAL_CORE_MOBILE), gShellDebug1HiiHandle);
2101     break;
2102
2103   case 0xEA:
2104     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_ATHLON_DUAL_CORE), gShellDebug1HiiHandle);
2105     break;
2106
2107   case 0xEB:
2108     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_SEMPRON_SI), gShellDebug1HiiHandle);
2109     break;
2110
2111   case 0xEC:
2112     Print (L"AMD Phenom II Processor Family\n");
2113     break;
2114
2115   case 0xED:
2116     Print (L"AMD Althon II Processor Family\n");
2117     break;
2118
2119   case 0xEE:
2120     Print (L"Six-Core AMD Opteron Processor Family\n");
2121     break;
2122
2123   case 0xEF:
2124     Print (L"AMD Sempron M Processor Family\n");
2125     break;
2126
2127   case 0xFA:
2128     Print (L"i860\n");
2129     break;
2130
2131   case 0xFB:
2132     Print (L"i960\n");
2133     break;
2134
2135   default:
2136     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNDEFINED_PROC_FAMILY), gShellDebug1HiiHandle);
2137   }
2138   //
2139   // end switch
2140   //
2141 }
2142
2143 /**
2144   Display processor family information.
2145
2146   @param[in] Family2      The family value.
2147   @param[in] Option       The option value.
2148 **/
2149 VOID
2150 DisplayProcessorFamily2 (
2151   IN UINT16 Family2,
2152   IN UINT8  Option
2153   )
2154 {
2155   //
2156   // Print prompt message
2157   //
2158   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PROCESSOR_FAMILY), gShellDebug1HiiHandle);
2159
2160   //
2161   // Print option
2162   //
2163   PRINT_INFO_OPTION (Family2, Option);
2164
2165   //
2166   // Use switch to check
2167   //
2168   switch (Family2) {
2169     case 0x104:
2170       Print (L"SH-3\n");
2171       break;
2172
2173     case 0x105:
2174       Print (L"SH-4\n");
2175       break;
2176
2177     case 0x118:
2178       Print (L"ARM\n");
2179       break;
2180
2181     case 0x119:
2182       Print (L"StrongARM\n");
2183       break;
2184
2185     case 0x12C:
2186       Print (L"6x86\n");
2187       break;
2188
2189     case 0x12D:
2190       Print (L"MediaGX\n");
2191       break;
2192
2193     case 0x12E:
2194       Print (L"MII\n");
2195       break;
2196
2197     case 0x140:
2198       Print (L"WinChip\n");
2199       break;
2200
2201     case 0x15E:
2202       Print (L"DSP\n");
2203       break;
2204
2205     case 0x1F4:
2206       Print (L"Video Processor\n");
2207       break;
2208
2209     default:
2210      ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNDEFINED_PROC_FAMILY), gShellDebug1HiiHandle);
2211   }
2212
2213 }
2214
2215 /**
2216   Display processor voltage information.
2217
2218   @param[in] Voltage      The Voltage.
2219   Bit 7 Set to 0, indicating 'legacy' mode for processor voltage
2220   Bits 6:4  Reserved, must be zero
2221   Bits 3:0  Voltage Capability.
2222             A Set bit indicates that the voltage is supported.
2223     Bit 0 - 5V
2224     Bit 1 - 3.3V
2225     Bit 2 - 2.9V
2226     Bit 3 - Reserved, must be zero.
2227
2228   Note:
2229     Setting of multiple bits indicates the socket is configurable
2230     If bit 7 is set to 1, the remaining seven bits of the field are set to
2231     contain the processor's current voltage times 10.
2232     For example, the field value for a processor voltage of 1.8 volts would be
2233     92h = 80h + (1.8 * 10) = 80h + 18 = 80h +12h.
2234
2235   @param[in] Option       The option.
2236 **/
2237 VOID
2238 DisplayProcessorVoltage (
2239   IN UINT8 Voltage,
2240   IN UINT8 Option
2241   )
2242 {
2243   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PROC_INFO), gShellDebug1HiiHandle);
2244   //
2245   // Print option
2246   //
2247   PRINT_INFO_OPTION (Voltage, Option);
2248
2249   if (BIT (Voltage, 7) != 0) {
2250     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PROC_CURRENT_VOLTAGE), gShellDebug1HiiHandle, (Voltage - 0x80));
2251   } else {
2252     if (BIT (Voltage, 0) != 0) {
2253       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_5V_SUPOPRTED), gShellDebug1HiiHandle);
2254     }
2255
2256     if (BIT (Voltage, 1) != 0) {
2257       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_33V_SUPPORTED), gShellDebug1HiiHandle);
2258     }
2259
2260     if (BIT (Voltage, 2) != 0) {
2261       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_29V_SUPPORTED), gShellDebug1HiiHandle);
2262     }
2263     //
2264     // check the reserved zero bits:
2265     //
2266     if (BIT (Voltage, 3) != 0) {
2267       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT3_NOT_ZERO), gShellDebug1HiiHandle);
2268     }
2269
2270     if (BIT (Voltage, 4) != 0) {
2271       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT4_NOT_ZERO), gShellDebug1HiiHandle);
2272     }
2273
2274     if (BIT (Voltage, 5) != 0) {
2275       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT5_NOT_ZERO), gShellDebug1HiiHandle);
2276     }
2277
2278     if (BIT (Voltage, 6) != 0) {
2279       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT6_NOT_ZERO), gShellDebug1HiiHandle);
2280     }
2281   }
2282 }
2283
2284 /**
2285   Display processor information.
2286
2287   @param[in] Status   The status.
2288 Bit 7 Reserved, must be 0
2289 Bit 6 CPU Socket Populated
2290   1 - CPU Socket Populated
2291   0 - CPU Socket Unpopulated
2292 Bits 5:3 Reserved, must be zero
2293 Bits 2:0 CPU Status
2294   0h - Unknown
2295   1h - CPU Enabled
2296   2h - CPU Disabled by User via BIOS Setup
2297   3h - CPU Disabled By BIOS (POST Error)
2298   4h - CPU is Idle, waiting to be enabled.
2299   5-6h - Reserved
2300   7h - Other
2301
2302   @param[in] Option   The option
2303 **/
2304 VOID
2305 DisplayProcessorStatus (
2306   IN UINT8 Status,
2307   IN UINT8 Option
2308   )
2309 {
2310   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PROC_STATUS), gShellDebug1HiiHandle);
2311   PRINT_INFO_OPTION (Status, Option);
2312
2313   if (BIT (Status, 7) != 0) {
2314     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT7_NOT_ZERO), gShellDebug1HiiHandle);
2315   } else if (BIT (Status, 5) != 0) {
2316     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT5_NOT_ZERO), gShellDebug1HiiHandle);
2317   } else if (BIT (Status, 4) != 0) {
2318     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT4_NOT_ZERO), gShellDebug1HiiHandle);
2319   } else if (BIT (Status, 3) != 0) {
2320     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT3_NOT_ZERO), gShellDebug1HiiHandle);
2321   }
2322   //
2323   // Check BIT 6
2324   //
2325   if (BIT (Status, 6) != 0) {
2326     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_SOCKET_POPULATED), gShellDebug1HiiHandle);
2327   } else {
2328     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_SOCKET_UNPOPULATED), gShellDebug1HiiHandle);
2329   }
2330   //
2331   // Check BITs 2:0
2332   //
2333   switch (Status & 0x07) {
2334   case 0:
2335     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
2336     break;
2337
2338   case 1:
2339     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_ENABLED), gShellDebug1HiiHandle);
2340     break;
2341
2342   case 2:
2343     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_DISABLED_BY_USER), gShellDebug1HiiHandle);
2344     break;
2345
2346   case 3:
2347     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_DIABLED_BY_BIOS), gShellDebug1HiiHandle);
2348     break;
2349
2350   case 4:
2351     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CPU_IDLE), gShellDebug1HiiHandle);
2352     break;
2353
2354   case 7:
2355     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTHERS), gShellDebug1HiiHandle);
2356     break;
2357
2358   default:
2359     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED), gShellDebug1HiiHandle);
2360   }
2361 }
2362
2363 /**
2364   Display information about Memory Controller Information (Type 5).
2365
2366   @param[in] Size     Memory size.
2367   @param[in] SlotNum  Which slot is this about.
2368   @param[in] Option   Option for the level of detail output required.
2369 **/
2370 VOID
2371 DisplayMaxMemoryModuleSize (
2372   IN UINT8 Size,
2373   IN UINT8 SlotNum,
2374   IN UINT8 Option
2375   )
2376 {
2377   UINTN MaxSize;
2378   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SIZE_LARGEST_MEM), gShellDebug1HiiHandle);
2379   //
2380   // MaxSize is determined by follow formula
2381   //
2382   MaxSize = (UINTN) 1 << Size;
2383   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ONE_VAR_MB), gShellDebug1HiiHandle, MaxSize);
2384
2385   if (Option >= SHOW_DETAIL) {
2386     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MAX_AMOUNT_MEM), gShellDebug1HiiHandle);
2387     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ONE_VAR_MB), gShellDebug1HiiHandle, MaxSize, SlotNum, MaxSize * SlotNum);
2388   }
2389 }
2390
2391 /**
2392   Display information about memory configuration handles.
2393
2394   @param[in] Handles  The buffer of handles to output info on.
2395   @param[in] SlotNum  The number of handles in the above buffer.
2396   @param[in] Option   Option for the level of detail output required.
2397 **/
2398 VOID
2399 DisplayMemoryModuleConfigHandles (
2400   IN UINT16 *Handles,
2401   IN UINT8  SlotNum,
2402   IN UINT8  Option
2403   )
2404 {
2405   UINT8 Index;
2406   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_HANDLES_CONTROLLED), gShellDebug1HiiHandle, SlotNum);
2407
2408   if (Option >= SHOW_DETAIL) {
2409     //
2410     // No handle, Handles is INVALID.
2411     //
2412     if (SlotNum == 0) {
2413       return ;
2414     }
2415
2416     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_HANDLES_LIST_CONTROLLED), gShellDebug1HiiHandle);
2417     for (Index = 0; Index < SlotNum; Index++) {
2418       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_HANDLE), gShellDebug1HiiHandle, Index + 1, Handles[Index]);
2419     }
2420   }
2421 }
2422
2423 /**
2424   Display Memory Module Information (Type 6).
2425
2426   @param[in] BankConnections
2427   @param[in] Option
2428 **/
2429 VOID
2430 DisplayMmBankConnections (
2431   IN UINT8 BankConnections,
2432   IN UINT8 Option
2433   )
2434 {
2435   UINT8 High;
2436   UINT8 Low;
2437
2438   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BANK_CONNECTIONS), gShellDebug1HiiHandle);
2439   //
2440   // Print option
2441   //
2442   PRINT_INFO_OPTION (BankConnections, Option);
2443
2444   //
2445   // Divide it to high and low
2446   //
2447   High  = (UINT8) (BankConnections & 0xF0);
2448   Low   = (UINT8) (BankConnections & 0x0F);
2449   if (High != 0xF) {
2450     if (Low != 0xF) {
2451       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BANK_RAS), gShellDebug1HiiHandle, High, Low, High, Low);
2452     } else {
2453       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BANK_RAS_2), gShellDebug1HiiHandle, High, High);
2454     }
2455   } else {
2456     if (Low != 0xF) {
2457       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BANK_RAS_2), gShellDebug1HiiHandle, Low, Low);
2458     } else {
2459       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NO_BANKS_CONNECTED), gShellDebug1HiiHandle);
2460     }
2461   }
2462 }
2463
2464 /**
2465   Display memory informcation.
2466
2467   Bits 0:6  Size (n),
2468       where 2**n is the size in MB with three special-case values:
2469       7Dh Not determinable (Installed Size only)
2470       7Eh Module is installed, but no memory has been enabled
2471       7Fh Not installed
2472   Bit  7  Defines whether the memory module has a single- (0)
2473           or double-bank (1) connection.
2474
2475   @param[in] Size   - The size
2476   @param[in] Option - The option
2477 **/
2478 VOID
2479 DisplayMmMemorySize (
2480   IN UINT8 Size,
2481   IN UINT8 Option
2482   )
2483 {
2484   UINT8 Value;
2485   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEMORY_SIZE), gShellDebug1HiiHandle);
2486   //
2487   // Print option
2488   //
2489   PRINT_INFO_OPTION (Size, Option);
2490
2491   //
2492   // Get the low bits(0-6 bit)
2493   //
2494   Value = (UINT8) (Size & 0x7F);
2495   if (Value == 0x7D) {
2496     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEM_SIZE_NOT_DETERMINABLE), gShellDebug1HiiHandle);
2497   } else if (Value == 0x7E) {
2498     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MODULE_INSTALLED), gShellDebug1HiiHandle);
2499   } else if (Value == 0x7F) {
2500     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_INSTALLED), gShellDebug1HiiHandle);
2501   } else {
2502     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEM_SIZE), gShellDebug1HiiHandle, 1 << Value);
2503   }
2504
2505   if (BIT (Size, 7) != 0) {
2506     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEM_MODULE_DOUBLE_BANK), gShellDebug1HiiHandle);
2507   } else {
2508     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEM_MODULE_SINGLE_BANK), gShellDebug1HiiHandle);
2509   }
2510 }
2511
2512 /**
2513   Display Cache Configuration.
2514
2515   @param[in] CacheConfiguration   Cache Configuration.
2516 Bits 15:10 Reserved, must be 0
2517 Bits 9:8 Operational Mode
2518   0h - Write Through
2519   1h - Write Back
2520   2h - Varies with Memory Address
2521   3h - Unknown
2522 Bit 7 Enabled/Disabled
2523   1 - Enabled
2524   0 - Disabled
2525 Bits 6:5 Location
2526   0h - Internal
2527   1h - External
2528   2h - Reserved
2529   3h - Unknown
2530 Bit 4 Reserved, must be zero
2531 Bit 3 Cache Socketed
2532   1 - Socketed
2533   0 - Unsocketed
2534 Bits 2:0 Cache Level
2535   1 through 8 (For example, an L1 cache would
2536   use value 000b and an L3 cache would use 010b.)
2537
2538   @param[in] Option   The option
2539 **/
2540 VOID
2541 DisplayCacheConfiguration (
2542   IN UINT16 CacheConfiguration,
2543   IN UINT8 Option
2544   )
2545 {
2546   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_CONFIGURATION), gShellDebug1HiiHandle);
2547   PRINT_INFO_OPTION (CacheConfiguration, Option);
2548
2549   if (BIT (CacheConfiguration, 15) != 0) {
2550     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT15_NOT_ZERO), gShellDebug1HiiHandle);
2551   } else if (BIT (CacheConfiguration, 14) != 0) {
2552     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT14_NOT_ZERO), gShellDebug1HiiHandle);
2553   } else if (BIT (CacheConfiguration, 13) != 0) {
2554     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT13_NOT_ZERO), gShellDebug1HiiHandle);
2555   } else if (BIT (CacheConfiguration, 12) != 0) {
2556     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT12_NOT_ZERO), gShellDebug1HiiHandle);
2557   } else if (BIT (CacheConfiguration, 11) != 0) {
2558     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT11_NOT_ZERO), gShellDebug1HiiHandle);
2559   } else if (BIT (CacheConfiguration, 10) != 0) {
2560     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT10_NOT_ZERO), gShellDebug1HiiHandle);
2561   } else if (BIT (CacheConfiguration, 4) != 0) {
2562     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT4_NOT_ZERO), gShellDebug1HiiHandle);
2563   }
2564
2565   //
2566   // Check BITs 9:8
2567   //
2568   switch ((CacheConfiguration & 0x300) >> 8) {
2569   case 0:
2570     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_WRITE_THROUGH), gShellDebug1HiiHandle);
2571     break;
2572
2573   case 1:
2574     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_WRITE_BACK), gShellDebug1HiiHandle);
2575     break;
2576
2577   case 2:
2578     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_VARIES_WITH_MEM_ADDR), gShellDebug1HiiHandle);
2579     break;
2580
2581   case 3:
2582     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
2583     break;
2584   }
2585
2586   //
2587   // Check BIT 7
2588   //
2589   if (BIT (CacheConfiguration, 7) != 0) {
2590     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED), gShellDebug1HiiHandle);
2591   } else {
2592     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DISABLED), gShellDebug1HiiHandle);
2593   }
2594
2595   //
2596   // Check BITs 6:5
2597   //
2598   switch ((CacheConfiguration & 0x60) >> 5) {
2599   case 0:
2600     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_INTERNAL), gShellDebug1HiiHandle);
2601     break;
2602
2603   case 1:
2604     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_EXTERNAL), gShellDebug1HiiHandle);
2605     break;
2606
2607   case 2:
2608     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED), gShellDebug1HiiHandle);
2609     break;
2610
2611   case 3:
2612     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
2613     break;
2614   }
2615
2616   //
2617   // Check BIT 3
2618   //
2619   if (BIT (CacheConfiguration, 3) != 0) {
2620     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_SOCKETED), gShellDebug1HiiHandle);
2621   } else {
2622     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_NOT_SOCKETED), gShellDebug1HiiHandle);
2623   }
2624
2625
2626   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_LEVEL), gShellDebug1HiiHandle, (CacheConfiguration & 0x07) + 1);
2627 }
2628
2629 /**
2630   The Slot ID field of the System Slot structure provides a mechanism to
2631   correlate the physical attributes of the slot to its logical access method
2632   (which varies based on the Slot Type field).
2633
2634   @param[in] SlotId   - The slot ID
2635   @param[in] SlotType - The slot type
2636   @param[in] Option   - The Option
2637 **/
2638 VOID
2639 DisplaySystemSlotId (
2640   IN UINT16  SlotId,
2641   IN UINT8   SlotType,
2642   IN UINT8   Option
2643   )
2644 {
2645   //
2646   // Display slot type first
2647   //
2648   DisplaySystemSlotType (SlotType, Option);
2649
2650   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SLOT_ID), gShellDebug1HiiHandle);
2651   //
2652   // print option
2653   //
2654   PRINT_INFO_OPTION (SlotType, Option);
2655
2656   switch (SlotType) {
2657   //
2658   // Slot Type: MCA
2659   //
2660   case 0x04:
2661     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_LOGICAL_MICRO_CHAN), gShellDebug1HiiHandle);
2662     if (SlotId > 0 && SlotId < 15) {
2663       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ONE_VAR_D), gShellDebug1HiiHandle, SlotId);
2664     } else {
2665       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_NOT_1_15), gShellDebug1HiiHandle);
2666     }
2667     break;
2668
2669   //
2670   // EISA
2671   //
2672   case 0x05:
2673     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_LOGICAL_EISA_NUM), gShellDebug1HiiHandle);
2674     if (SlotId > 0 && SlotId < 15) {
2675       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ONE_VAR_D), gShellDebug1HiiHandle, SlotId);
2676     } else {
2677       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_NOT_1_15), gShellDebug1HiiHandle);
2678     }
2679     break;
2680
2681   //
2682   // Slot Type: PCI
2683   //
2684   case 0x06:
2685     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VALUE_PRESENT), gShellDebug1HiiHandle, SlotId);
2686     break;
2687
2688   //
2689   // PCMCIA
2690   //
2691   case 0x07:
2692     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_IDENTIFIES_ADAPTER_NUM), gShellDebug1HiiHandle, SlotId);
2693     break;
2694
2695   //
2696   // Slot Type: PCI-E
2697   //
2698   case 0xA5:
2699     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VALUE_PRESENT), gShellDebug1HiiHandle, SlotId);
2700     break;
2701
2702   default:
2703     if ((SlotType >= 0x0E && SlotType <= 0x12) || (SlotType >= 0xA6 && SlotType <= 0xB6)){
2704       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VALUE_PRESENT), gShellDebug1HiiHandle, SlotId);
2705     } else {
2706       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNDEFINED_SLOT_ID), gShellDebug1HiiHandle);
2707     }
2708   }
2709 }
2710
2711 /**
2712   Display System Boot Information (Type 32) information.
2713
2714   @param[in] Parameter      The parameter.
2715   @param[in] Option         The options.
2716 **/
2717 VOID
2718 DisplaySystemBootStatus (
2719   IN UINT8 Parameter,
2720   IN UINT8 Option
2721   )
2722 {
2723   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_BOOT_STATUS), gShellDebug1HiiHandle);
2724   //
2725   // Print option
2726   //
2727   PRINT_INFO_OPTION (Parameter, Option);
2728
2729   //
2730   // Check value and print
2731   //
2732   if (Parameter == 0) {
2733     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NO_ERRORS_DETECTED), gShellDebug1HiiHandle);
2734   } else if (Parameter == 1) {
2735     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NO_BOOTABLE_MEDIA), gShellDebug1HiiHandle);
2736   } else if (Parameter == 2) {
2737     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NORMAL_OP_SYSTEM), gShellDebug1HiiHandle);
2738   } else if (Parameter == 3) {
2739     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FIRMWARE_DETECTED), gShellDebug1HiiHandle);
2740   } else if (Parameter == 4) {
2741     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OP_SYSTEM), gShellDebug1HiiHandle);
2742   } else if (Parameter == 5) {
2743     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_USER_REQUESTED_BOOT), gShellDebug1HiiHandle);
2744   } else if (Parameter == 6) {
2745     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_SECURITY_VIOLATION), gShellDebug1HiiHandle);
2746   } else if (Parameter == 7) {
2747     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PREV_REQ_IMAGE), gShellDebug1HiiHandle);
2748   } else if (Parameter == 8) {
2749     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_WATCHDOG_TIMER), gShellDebug1HiiHandle);
2750   } else if (Parameter >= 9 && Parameter <= 127) {
2751     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RSVD_FUTURE_ASSIGNMENT), gShellDebug1HiiHandle);
2752   } else if (Parameter >= 128 && Parameter <= 191) {
2753     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VENDOR_OEM_SPECIFIC), gShellDebug1HiiHandle);
2754   } else if (Parameter >= 192) {
2755     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_PRODUCT_SPEC_IMPLMENTATION), gShellDebug1HiiHandle);
2756   } else {
2757     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_VALUE), gShellDebug1HiiHandle);
2758   }
2759 }
2760
2761 /**
2762   Display Portable Battery (Type 22) information.
2763
2764   The date the cell pack was manufactured, in packed format:
2765    Bits 15:9  Year, biased by 1980, in the range 0 to 127.
2766    Bits 8:5 Month, in the range 1 to 12.
2767    Bits 4:0 Date, in the range 1 to 31.
2768   For example, 01 February 2000 would be identified as
2769   0010 1000 0100 0001b (0x2841).
2770
2771   @param[in] Date     The date
2772   @param[in] Option   The option
2773 **/
2774 VOID
2775 DisplaySBDSManufactureDate (
2776   IN UINT16  Date,
2777   IN UINT8   Option
2778   )
2779 {
2780   UINTN Day;
2781   UINTN Month;
2782   UINTN Year;
2783
2784   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SBDS_MANUFACTURE_DATE), gShellDebug1HiiHandle);
2785   PRINT_INFO_OPTION (Date, Option);
2786   //
2787   // Print date
2788   //
2789   Day   = Date & 0x001F;
2790   Month = (Date & 0x01E0) >> 5;
2791   Year  = ((Date & 0xFE00) >> 9) + 1980;
2792   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MONTH_DAY_YEAR), gShellDebug1HiiHandle, Day, Month, Year);
2793
2794 }
2795
2796 /**
2797   Display System Reset (Type 23) information.
2798
2799
2800 Identifies the system-reset capabilities for the system.
2801  Bits 7:6 Reserved for future assignment via this specification, set to 00b.
2802  Bit 5  System contains a watchdog timer, either True (1) or False (0).
2803  Bits 4:3 Boot Option on Limit.
2804   Identifies the system action to be taken when the Reset Limit is reached, one of:
2805   00b Reserved, do not use.
2806   01b Operating system
2807   10b System utilities
2808   11b Do not rebootBits
2809  2:1  Boot Option.  Indicates the action to be taken following a watchdog reset, one of:
2810   00b Reserved, do not use.
2811   01b Operating system
2812   10b System utilities
2813   11b Do not reboot
2814  Bit 0  Status.
2815   1b The system reset is enabled by the user
2816   0b The system reset is not enabled by the user
2817
2818   @param[in] Reset   Reset
2819   @param[in] Option  The option
2820 **/
2821 VOID
2822 DisplaySystemResetCapabilities (
2823   IN UINT8 Reset,
2824   IN UINT8 Option
2825   )
2826 {
2827   UINTN Temp;
2828
2829   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_RESET_CAPABILITIES), gShellDebug1HiiHandle);
2830   PRINT_INFO_OPTION (Reset, Option);
2831
2832   //
2833   // Check reserved bits 7:6
2834   //
2835   if ((Reset & 0xC0) != 0) {
2836     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RESERVED_ZERO), gShellDebug1HiiHandle);
2837   }
2838   //
2839   // Watch dog
2840   //
2841   if (BIT (Reset, 5) != 0) {
2842     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_WATCHDOG_TIMER_2), gShellDebug1HiiHandle);
2843   } else {
2844     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_NOT_CONTAIN_TIMER), gShellDebug1HiiHandle);
2845   }
2846   //
2847   // Boot Option on Limit
2848   //
2849   Temp = (Reset & 0x18) >> 3;
2850   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BOOT_OPTION_LIMIT), gShellDebug1HiiHandle);
2851   switch (Temp) {
2852   case 0:
2853     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED), gShellDebug1HiiHandle);
2854     break;
2855
2856   case 1:
2857     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OP_SYSTEM_2), gShellDebug1HiiHandle);
2858     break;
2859
2860   case 2:
2861     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_UTIL), gShellDebug1HiiHandle);
2862     break;
2863
2864   case 3:
2865     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DO_NOT_REBOOT_BITS), gShellDebug1HiiHandle);
2866     break;
2867   }
2868   //
2869   // Boot Option
2870   //
2871   Temp = (Reset & 0x06) >> 1;
2872   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BOOT_OPTION), gShellDebug1HiiHandle);
2873   switch (Temp) {
2874   case 0:
2875     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED), gShellDebug1HiiHandle);
2876     break;
2877
2878   case 1:
2879     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OP_SYSTEM_2), gShellDebug1HiiHandle);
2880     break;
2881
2882   case 2:
2883     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SYSTEM_UTIL), gShellDebug1HiiHandle);
2884     break;
2885
2886   case 3:
2887     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DO_NOT_REBOOT), gShellDebug1HiiHandle);
2888     break;
2889   }
2890   //
2891   // Reset enable flag
2892   //
2893   if ((Reset & 0x01) != 0) {
2894     Print (L"The system reset is enabled by the user\n");
2895   } else {
2896     Print (L"The system reset is disabled by the user\n");
2897   }
2898 }
2899
2900 /**
2901   Display Hardware Security (Type 24) information.
2902
2903
2904 Identifies the password and reset status for the system:
2905
2906 Bits 7:6    Power-on Password Status, one of:
2907   00b Disabled
2908   01b Enabled
2909   10b Not Implemented
2910   11b Unknown
2911 Bits 5:4    Keyboard Password Status, one of:
2912   00b Disabled
2913   01b Enabled
2914   10b Not Implemented
2915   11b Unknown
2916 Bits 3:2    Administrator Password Status, one  of:
2917   00b Disabled
2918   01b Enabled
2919   10b Not Implemented
2920   11b Unknown
2921 Bits 1:0    Front Panel Reset Status, one of:
2922   00b Disabled
2923   01b Enabled
2924   10b Not Implemented
2925   11b Unknown
2926
2927   @param[in] Settings The device settings.
2928   @param[in] Option   The device options.
2929 **/
2930 VOID
2931 DisplayHardwareSecuritySettings (
2932   IN UINT8 Settings,
2933   IN UINT8 Option
2934   )
2935 {
2936   UINTN Temp;
2937
2938   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_HARDWARE_SECURITY_SET), gShellDebug1HiiHandle);
2939   PRINT_INFO_OPTION (Settings, Option);
2940
2941   //
2942   // Power-on Password Status
2943   //
2944   Temp = (Settings & 0xC0) >> 6;
2945   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_ON_PASSWORD), gShellDebug1HiiHandle);
2946   switch (Temp) {
2947   case 0:
2948     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DISABLED), gShellDebug1HiiHandle);
2949     break;
2950
2951   case 1:
2952     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED_NEWLINE), gShellDebug1HiiHandle);
2953     break;
2954
2955   case 2:
2956     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_IMPLEMENTED), gShellDebug1HiiHandle);
2957     break;
2958
2959   case 3:
2960     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
2961     break;
2962   }
2963   //
2964   // Keyboard Password Status
2965   //
2966   Temp = (Settings & 0x30) >> 4;
2967   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_KEYBOARD_PASSWORD), gShellDebug1HiiHandle);
2968   switch (Temp) {
2969   case 0:
2970     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DISABLED), gShellDebug1HiiHandle);
2971     break;
2972
2973   case 1:
2974     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED_NEWLINE), gShellDebug1HiiHandle);
2975     break;
2976
2977   case 2:
2978     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_IMPLEMENTED), gShellDebug1HiiHandle);
2979     break;
2980
2981   case 3:
2982     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
2983     break;
2984   }
2985   //
2986   // Administrator Password Status
2987   //
2988   Temp = (Settings & 0x0C) >> 2;
2989   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ADMIN_PASSWORD_STATUS), gShellDebug1HiiHandle);
2990   switch (Temp) {
2991   case 0:
2992     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DISABLED), gShellDebug1HiiHandle);
2993     break;
2994
2995   case 1:
2996     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED_NEWLINE), gShellDebug1HiiHandle);
2997     break;
2998
2999   case 2:
3000     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_IMPLEMENTED), gShellDebug1HiiHandle);
3001     break;
3002
3003   case 3:
3004     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
3005     break;
3006   }
3007   //
3008   // Front Panel Reset Status
3009   //
3010   Temp = Settings & 0x3;
3011   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_FRONT_PANEL_RESET), gShellDebug1HiiHandle);
3012   switch (Temp) {
3013   case 0:
3014     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DISABLED), gShellDebug1HiiHandle);
3015     break;
3016
3017   case 1:
3018     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED_NEWLINE), gShellDebug1HiiHandle);
3019     break;
3020
3021   case 2:
3022     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_IMPLEMENTED), gShellDebug1HiiHandle);
3023     break;
3024
3025   case 3:
3026     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
3027     break;
3028   }
3029 }
3030
3031 /**
3032   Display Out-of-Band Remote Access (Type 30) information.
3033
3034   @param[in] Connections        The device characteristics.
3035   @param[in] Option             The device options.
3036 **/
3037 VOID
3038 DisplayOBRAConnections (
3039   IN UINT8   Connections,
3040   IN UINT8   Option
3041   )
3042 {
3043   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CONNECTIONS), gShellDebug1HiiHandle);
3044   PRINT_INFO_OPTION (Connections, Option);
3045
3046   //
3047   // Check reserved bits 7:2
3048   //
3049   if ((Connections & 0xFC) != 0) {
3050     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RESERVED_ZERO_2), gShellDebug1HiiHandle);
3051   }
3052   //
3053   // Outbound Connection
3054   //
3055   if (BIT (Connections, 1) != 0) {
3056     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OUTBOUND_CONN_ENABLED), gShellDebug1HiiHandle);
3057   } else {
3058     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTUBOUND_CONN_DISABLED), gShellDebug1HiiHandle);
3059   }
3060   //
3061   // Inbound Connection
3062   //
3063   if (BIT (Connections, 0) != 0) {
3064     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INBOIUND_CONN_ENABLED), gShellDebug1HiiHandle);
3065   } else {
3066     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INBOUND_CONN_DISABLED), gShellDebug1HiiHandle);
3067   }
3068 }
3069
3070 /**
3071   Display System Power Supply (Type 39) information.
3072
3073   @param[in] Characteristics    The device characteristics.
3074   @param[in] Option             The device options.
3075 **/
3076 VOID
3077 DisplaySPSCharacteristics (
3078   IN UINT16  Characteristics,
3079   IN UINT8   Option
3080   )
3081 {
3082   UINTN Temp;
3083
3084   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_CHAR), gShellDebug1HiiHandle);
3085   PRINT_INFO_OPTION (Characteristics, Option);
3086
3087   //
3088   // Check reserved bits 15:14
3089   //
3090   if ((Characteristics & 0xC000) != 0) {
3091     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_15_14_RSVD), gShellDebug1HiiHandle);
3092   }
3093   //
3094   // Bits 13:10 - DMTF Power Supply Type
3095   //
3096   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_TYPE), gShellDebug1HiiHandle);
3097   Temp = (Characteristics & 0x1C00) << 10;
3098   switch (Temp) {
3099   case 1:
3100     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTHER_SPACE), gShellDebug1HiiHandle);
3101     break;
3102
3103   case 2:
3104     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
3105     break;
3106
3107   case 3:
3108     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_LINEAR), gShellDebug1HiiHandle);
3109     break;
3110
3111   case 4:
3112     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SWITCHING), gShellDebug1HiiHandle);
3113     break;
3114
3115   case 5:
3116     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BATTERY), gShellDebug1HiiHandle);
3117     break;
3118
3119   case 6:
3120     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UPS), gShellDebug1HiiHandle);
3121     break;
3122
3123   case 7:
3124     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CONVERTER), gShellDebug1HiiHandle);
3125     break;
3126
3127   case 8:
3128     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_REGULATOR), gShellDebug1HiiHandle);
3129     break;
3130
3131   default:
3132     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED_2), gShellDebug1HiiHandle);
3133   }
3134   //
3135   // Bits 9:7 - Status
3136   //
3137   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_STATUS_DASH), gShellDebug1HiiHandle);
3138   Temp = (Characteristics & 0x380) << 7;
3139   switch (Temp) {
3140   case 1:
3141     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTHER_SPACE), gShellDebug1HiiHandle);
3142     break;
3143
3144   case 2:
3145     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
3146     break;
3147
3148   case 3:
3149     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OK), gShellDebug1HiiHandle);
3150     break;
3151
3152   case 4:
3153     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NON_CRITICAL), gShellDebug1HiiHandle);
3154     break;
3155
3156   case 5:
3157     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CRITICAL_POWER_SUPPLY), gShellDebug1HiiHandle);
3158     break;
3159
3160   default:
3161     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNDEFINED), gShellDebug1HiiHandle);
3162   }
3163   //
3164   // Bits 6:3 - DMTF Input Voltage Range Switching
3165   //
3166   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INPUT_VOLTAGE_RANGE), gShellDebug1HiiHandle);
3167   Temp = (Characteristics & 0x78) << 3;
3168   switch (Temp) {
3169   case 1:
3170     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_OTHER_SPACE), gShellDebug1HiiHandle);
3171     break;
3172
3173   case 2:
3174     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
3175     break;
3176
3177   case 3:
3178     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MANUAL), gShellDebug1HiiHandle);
3179     break;
3180
3181   case 4:
3182     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AUTO_SWITCH), gShellDebug1HiiHandle);
3183     break;
3184
3185   case 5:
3186     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_WIDE_RANGE), gShellDebug1HiiHandle);
3187     break;
3188
3189   case 6:
3190     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_NOT_APPLICABLE), gShellDebug1HiiHandle);
3191     break;
3192
3193   default:
3194     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED_3), gShellDebug1HiiHandle);
3195     break;
3196   }
3197   //
3198   // Power supply is unplugged from the wall
3199   //
3200   if (BIT (Characteristics, 2) != 0) {
3201     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_UNPLUGGED), gShellDebug1HiiHandle);
3202   } else {
3203     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_PLUGGED), gShellDebug1HiiHandle);
3204   }
3205   //
3206   // Power supply is present
3207   //
3208   if (BIT (Characteristics, 1) != 0) {
3209     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_PRESENT), gShellDebug1HiiHandle);
3210   } else {
3211     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_NOT_PRESENT), gShellDebug1HiiHandle);
3212   }
3213   //
3214   // hot replaceable
3215   //
3216   if (BIT (Characteristics, 0) != 0) {
3217     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_REPLACE), gShellDebug1HiiHandle);
3218   } else {
3219     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_SUPPLY_NOT_REPLACE), gShellDebug1HiiHandle);
3220   }
3221 }