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