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