b6d164bceb
Create a sandbox test for the smbios command. This checks that the expected output is produced. Drop the unnecessary 0x before each address, since U-Boot uses hex by default. Co-developed-by: Claude <noreply@anthropic.com> Signed-off-by: Simon Glass <sjg@chromium.org>
541 lines
19 KiB
C
541 lines
19 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* The 'smbios' command displays information from the SMBIOS table.
|
|
*
|
|
* Copyright (c) 2023, Heinrich Schuchardt <heinrich.schuchardt@canonical.com>
|
|
*/
|
|
|
|
#include <command.h>
|
|
#include <errno.h>
|
|
#include <hexdump.h>
|
|
#include <mapmem.h>
|
|
#include <smbios.h>
|
|
#include <tables_csum.h>
|
|
#include <asm/global_data.h>
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
static const struct str_lookup_table wakeup_type_strings[] = {
|
|
{ SMBIOS_WAKEUP_TYPE_RESERVED, "Reserved" },
|
|
{ SMBIOS_WAKEUP_TYPE_OTHER, "Other" },
|
|
{ SMBIOS_WAKEUP_TYPE_UNKNOWN, "Unknown" },
|
|
{ SMBIOS_WAKEUP_TYPE_APM_TIMER, "APM Timer" },
|
|
{ SMBIOS_WAKEUP_TYPE_MODEM_RING, "Modem Ring" },
|
|
{ SMBIOS_WAKEUP_TYPE_LAN_REMOTE, "Lan Remote" },
|
|
{ SMBIOS_WAKEUP_TYPE_POWER_SWITCH, "Power Switch" },
|
|
{ SMBIOS_WAKEUP_TYPE_PCI_PME, "PCI PME#" },
|
|
{ SMBIOS_WAKEUP_TYPE_AC_POWER_RESTORED, "AC Power Restored" },
|
|
};
|
|
|
|
static const struct str_lookup_table boardtype_strings[] = {
|
|
{ SMBIOS_BOARD_TYPE_UNKNOWN, "Unknown" },
|
|
{ SMBIOS_BOARD_TYPE_OTHER, "Other" },
|
|
{ SMBIOS_BOARD_TYPE_SERVER_BLADE, "Server Blade" },
|
|
{ SMBIOS_BOARD_TYPE_CON_SWITCH, "Connectivity Switch" },
|
|
{ SMBIOS_BOARD_TYPE_SM_MODULE, "System Management Module" },
|
|
{ SMBIOS_BOARD_TYPE_PROCESSOR_MODULE, "Processor Module" },
|
|
{ SMBIOS_BOARD_TYPE_IO_MODULE, "I/O Module" },
|
|
{ SMBIOS_BOARD_TYPE_MEM_MODULE, "Memory Module" },
|
|
{ SMBIOS_BOARD_TYPE_DAUGHTER_BOARD, "Daughter board" },
|
|
{ SMBIOS_BOARD_TYPE_MOTHERBOARD, "Motherboard" },
|
|
{ SMBIOS_BOARD_TYPE_PROC_MEM_MODULE, "Processor/Memory Module" },
|
|
{ SMBIOS_BOARD_TYPE_PROC_IO_MODULE, "Processor/IO Module" },
|
|
{ SMBIOS_BOARD_TYPE_INTERCON, "Interconnect board" },
|
|
};
|
|
|
|
static const struct str_lookup_table chassis_state_strings[] = {
|
|
{ SMBIOS_STATE_OTHER, "Other" },
|
|
{ SMBIOS_STATE_UNKNOWN, "Unknown" },
|
|
{ SMBIOS_STATE_SAFE, "Safe" },
|
|
{ SMBIOS_STATE_WARNING, "Warning" },
|
|
{ SMBIOS_STATE_CRITICAL, "Critical" },
|
|
{ SMBIOS_STATE_NONRECOVERABLE, "Non-recoverable" },
|
|
};
|
|
|
|
static const struct str_lookup_table chassis_security_strings[] = {
|
|
{ SMBIOS_SECURITY_OTHER, "Other" },
|
|
{ SMBIOS_SECURITY_UNKNOWN, "Unknown" },
|
|
{ SMBIOS_SECURITY_NONE, "None" },
|
|
{ SMBIOS_SECURITY_EXTINT_LOCK, "External interface locked out" },
|
|
{ SMBIOS_SECURITY_EXTINT_EN, "External interface enabled" },
|
|
};
|
|
|
|
static const struct str_lookup_table processor_type_strings[] = {
|
|
{ SMBIOS_PROCESSOR_TYPE_OTHER, "Other" },
|
|
{ SMBIOS_PROCESSOR_TYPE_UNKNOWN, "Unknown" },
|
|
{ SMBIOS_PROCESSOR_TYPE_CENTRAL, "Central Processor" },
|
|
{ SMBIOS_PROCESSOR_TYPE_MATH, "Math Processor" },
|
|
{ SMBIOS_PROCESSOR_TYPE_DSP, "DSP Processor" },
|
|
{ SMBIOS_PROCESSOR_TYPE_VIDEO, "Video Processor" },
|
|
};
|
|
|
|
static const struct str_lookup_table processor_family_strings[] = {
|
|
{ SMBIOS_PROCESSOR_FAMILY_OTHER, "Other" },
|
|
{ SMBIOS_PROCESSOR_FAMILY_UNKNOWN, "Unknown" },
|
|
{ SMBIOS_PROCESSOR_FAMILY_RSVD, "Reserved" },
|
|
{ SMBIOS_PROCESSOR_FAMILY_ARMV7, "ARMv7" },
|
|
{ SMBIOS_PROCESSOR_FAMILY_ARMV8, "ARMv8" },
|
|
{ SMBIOS_PROCESSOR_FAMILY_RV32, "RISC-V RV32" },
|
|
{ SMBIOS_PROCESSOR_FAMILY_RV64, "RISC-V RV64" },
|
|
};
|
|
|
|
static const struct str_lookup_table processor_upgrade_strings[] = {
|
|
{ SMBIOS_PROCESSOR_UPGRADE_OTHER, "Other" },
|
|
{ SMBIOS_PROCESSOR_UPGRADE_UNKNOWN, "Unknown" },
|
|
{ SMBIOS_PROCESSOR_UPGRADE_NONE, "None" },
|
|
};
|
|
|
|
static const struct str_lookup_table err_corr_type_strings[] = {
|
|
{ SMBIOS_CACHE_ERRCORR_OTHER, "Other" },
|
|
{ SMBIOS_CACHE_ERRCORR_UNKNOWN, "Unknown" },
|
|
{ SMBIOS_CACHE_ERRCORR_NONE, "None" },
|
|
{ SMBIOS_CACHE_ERRCORR_PARITY, "Parity" },
|
|
{ SMBIOS_CACHE_ERRCORR_SBITECC, "Single-bit ECC" },
|
|
{ SMBIOS_CACHE_ERRCORR_MBITECC, "Multi-bit ECC" },
|
|
};
|
|
|
|
static const struct str_lookup_table sys_cache_type_strings[] = {
|
|
{ SMBIOS_CACHE_SYSCACHE_TYPE_OTHER, "Other" },
|
|
{ SMBIOS_CACHE_SYSCACHE_TYPE_UNKNOWN, "Unknown" },
|
|
{ SMBIOS_CACHE_SYSCACHE_TYPE_INST, "Instruction" },
|
|
{ SMBIOS_CACHE_SYSCACHE_TYPE_DATA, "Data" },
|
|
{ SMBIOS_CACHE_SYSCACHE_TYPE_UNIFIED, "Unified" },
|
|
};
|
|
|
|
static const struct str_lookup_table associativity_strings[] = {
|
|
{ SMBIOS_CACHE_ASSOC_OTHER, "Other" },
|
|
{ SMBIOS_CACHE_ASSOC_UNKNOWN, "Unknown" },
|
|
{ SMBIOS_CACHE_ASSOC_DMAPPED, "Direct Mapped" },
|
|
{ SMBIOS_CACHE_ASSOC_2WAY, "2-way Set-Associative" },
|
|
{ SMBIOS_CACHE_ASSOC_4WAY, "4-way Set-Associative" },
|
|
{ SMBIOS_CACHE_ASSOC_FULLY, "Fully Associative" },
|
|
{ SMBIOS_CACHE_ASSOC_8WAY, "8-way Set-Associative" },
|
|
{ SMBIOS_CACHE_ASSOC_16WAY, "16-way Set-Associative" },
|
|
{ SMBIOS_CACHE_ASSOC_12WAY, "12-way Set-Associative" },
|
|
{ SMBIOS_CACHE_ASSOC_24WAY, "24-way Set-Associative" },
|
|
{ SMBIOS_CACHE_ASSOC_32WAY, "32-way Set-Associative" },
|
|
{ SMBIOS_CACHE_ASSOC_48WAY, "48-way Set-Associative" },
|
|
{ SMBIOS_CACHE_ASSOC_64WAY, "64-way Set-Associative" },
|
|
{ SMBIOS_CACHE_ASSOC_20WAY, "20-way Set-Associative" },
|
|
};
|
|
|
|
static const struct str_lookup_table mem_array_location_strings[] = {
|
|
{ 0x01, "Other" },
|
|
{ 0x02, "Unknown" },
|
|
{ 0x03, "System board or motherboard" },
|
|
{ 0x04, "ISA add-on card" },
|
|
{ 0x05, "EISA add-on card" },
|
|
{ 0x06, "PCI add-on card" },
|
|
{ 0x07, "MCA add-on card" },
|
|
{ 0x08, "PCMCIA add-on card" },
|
|
{ 0x09, "Proprietary add-on card" },
|
|
{ 0x0A, "NuBus" },
|
|
{ 0xA0, "PC-98/C20 add-on card" },
|
|
{ 0xA1, "PC-98/C24 add-on card" },
|
|
{ 0xA2, "PC-98/E add-on card" },
|
|
{ 0xA3, "PC-98/Local bus add-on card" },
|
|
};
|
|
|
|
static const struct str_lookup_table mem_array_use_strings[] = {
|
|
{ 0x01, "Other" },
|
|
{ 0x02, "Unknown" },
|
|
{ 0x03, "System memory" },
|
|
{ 0x04, "Video memory" },
|
|
{ 0x05, "Flash memory" },
|
|
{ 0x06, "Non-volatile RAM" },
|
|
{ 0x07, "Cache memory" },
|
|
};
|
|
|
|
static const struct str_lookup_table mem_err_corr_strings[] = {
|
|
{ 0x01, "Other" },
|
|
{ 0x02, "Unknown" },
|
|
{ 0x03, "None" },
|
|
{ 0x04, "Parity" },
|
|
{ 0x05, "Single-bit ECC" },
|
|
{ 0x06, "Multi-bit ECC" },
|
|
{ 0x07, "CRC" },
|
|
};
|
|
|
|
static void smbios_print_generic(const struct smbios_header *table)
|
|
{
|
|
char *str = (char *)table + table->length;
|
|
|
|
if (CONFIG_IS_ENABLED(HEXDUMP)) {
|
|
printf("Header and Data:\n");
|
|
print_hex_dump("\t", DUMP_PREFIX_OFFSET, 16, 1,
|
|
table, table->length, false);
|
|
}
|
|
if (*str) {
|
|
printf("Strings:\n");
|
|
for (int index = 1; *str; ++index) {
|
|
printf("\tString %u: %s\n", index, str);
|
|
str += strlen(str) + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void smbios_print_str(const char *label, void *table, u8 index)
|
|
{
|
|
printf("\t%s: %s\n", label, smbios_get_string(table, index));
|
|
}
|
|
|
|
static void smbios_print_lookup_str(const struct str_lookup_table *table,
|
|
u16 index, u16 array_size,
|
|
const char *prefix)
|
|
{
|
|
int i;
|
|
const char *str = NULL;
|
|
|
|
for (i = 0; i < array_size; i++) {
|
|
if ((table + i)->idx == index)
|
|
str = (table + i)->str;
|
|
}
|
|
|
|
if (str)
|
|
printf("\t%s: %s\n", prefix, str);
|
|
else
|
|
printf("\t%s: [%04x]\n", prefix, index);
|
|
}
|
|
|
|
static void smbios_print_type0(struct smbios_type0 *table)
|
|
{
|
|
printf("BIOS Information\n");
|
|
smbios_print_str("Vendor", table, table->vendor);
|
|
smbios_print_str("BIOS Version", table, table->bios_ver);
|
|
/* Keep table->bios_start_segment as 0 for UEFI-based systems */
|
|
smbios_print_str("BIOS Release Date", table, table->bios_release_date);
|
|
printf("\tBIOS ROM Size: 0x%02x\n", table->bios_rom_size);
|
|
printf("\tBIOS Characteristics: 0x%016llx\n",
|
|
table->bios_characteristics);
|
|
printf("\tBIOS Characteristics Extension Byte 1: 0x%02x\n",
|
|
table->bios_characteristics_ext1);
|
|
printf("\tBIOS Characteristics Extension Byte 2: 0x%02x\n",
|
|
table->bios_characteristics_ext2);
|
|
printf("\tSystem BIOS Major Release: 0x%02x\n",
|
|
table->bios_major_release);
|
|
printf("\tSystem BIOS Minor Release: 0x%02x\n",
|
|
table->bios_minor_release);
|
|
printf("\tEmbedded Controller Firmware Major Release: 0x%02x\n",
|
|
table->ec_major_release);
|
|
printf("\tEmbedded Controller Firmware Minor Release: 0x%02x\n",
|
|
table->ec_minor_release);
|
|
printf("\tExtended BIOS ROM Size: 0x%04x\n",
|
|
table->extended_bios_rom_size);
|
|
}
|
|
|
|
static void smbios_print_type1(struct smbios_type1 *table)
|
|
{
|
|
printf("System Information\n");
|
|
smbios_print_str("Manufacturer", table, table->manufacturer);
|
|
smbios_print_str("Product Name", table, table->product_name);
|
|
smbios_print_str("Version", table, table->version);
|
|
smbios_print_str("Serial Number", table, table->serial_number);
|
|
if (table->hdr.length >= SMBIOS_TYPE1_LENGTH_V21) {
|
|
printf("\tUUID: %pUl\n", table->uuid);
|
|
smbios_print_lookup_str(wakeup_type_strings,
|
|
table->wakeup_type,
|
|
ARRAY_SIZE(wakeup_type_strings),
|
|
"Wake-up Type");
|
|
}
|
|
if (table->hdr.length >= SMBIOS_TYPE1_LENGTH_V24) {
|
|
smbios_print_str("SKU Number", table, table->sku_number);
|
|
smbios_print_str("Family", table, table->family);
|
|
}
|
|
}
|
|
|
|
static void smbios_print_type2(struct smbios_type2 *table)
|
|
{
|
|
int i;
|
|
u8 *addr = (u8 *)table + offsetof(struct smbios_type2, eos);
|
|
|
|
printf("Baseboard Information\n");
|
|
smbios_print_str("Manufacturer", table, table->manufacturer);
|
|
smbios_print_str("Product Name", table, table->product_name);
|
|
smbios_print_str("Version", table, table->version);
|
|
smbios_print_str("Serial Number", table, table->serial_number);
|
|
smbios_print_str("Asset Tag", table, table->asset_tag_number);
|
|
printf("\tFeature Flags: 0x%02x\n", table->feature_flags);
|
|
smbios_print_str("Chassis Location", table, table->chassis_location);
|
|
printf("\tChassis Handle: 0x%04x\n", table->chassis_handle);
|
|
smbios_print_lookup_str(boardtype_strings,
|
|
table->board_type,
|
|
ARRAY_SIZE(boardtype_strings),
|
|
"Board Type");
|
|
printf("\tNumber of Contained Object Handles: 0x%02x\n",
|
|
table->number_contained_objects);
|
|
if (!table->number_contained_objects)
|
|
return;
|
|
|
|
printf("\tContained Object Handles:\n");
|
|
for (i = 0; i < table->number_contained_objects; i++) {
|
|
printf("\t\tObject[%03d]:\n", i);
|
|
if (CONFIG_IS_ENABLED(HEXDUMP))
|
|
print_hex_dump("\t\t", DUMP_PREFIX_OFFSET, 16, 1, addr,
|
|
sizeof(u16), false);
|
|
addr += sizeof(u16);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
static void smbios_print_type3(struct smbios_type3 *table)
|
|
{
|
|
int i;
|
|
u8 *addr = (u8 *)table + offsetof(struct smbios_type3, sku_number);
|
|
|
|
printf("Baseboard Information\n");
|
|
smbios_print_str("Manufacturer", table, table->manufacturer);
|
|
printf("\tType: 0x%02x\n", table->chassis_type);
|
|
smbios_print_str("Version", table, table->version);
|
|
smbios_print_str("Serial Number", table, table->serial_number);
|
|
smbios_print_str("Asset Tag", table, table->asset_tag_number);
|
|
smbios_print_lookup_str(chassis_state_strings,
|
|
table->bootup_state,
|
|
ARRAY_SIZE(chassis_state_strings),
|
|
"Boot-up State");
|
|
smbios_print_lookup_str(chassis_state_strings,
|
|
table->power_supply_state,
|
|
ARRAY_SIZE(chassis_state_strings),
|
|
"Power Supply State");
|
|
smbios_print_lookup_str(chassis_state_strings,
|
|
table->thermal_state,
|
|
ARRAY_SIZE(chassis_state_strings),
|
|
"Thermal State");
|
|
smbios_print_lookup_str(chassis_security_strings,
|
|
table->security_status,
|
|
ARRAY_SIZE(chassis_security_strings),
|
|
"Security Status");
|
|
printf("\tOEM-defined: 0x%08x\n", table->oem_defined);
|
|
printf("\tHeight: 0x%02x\n", table->height);
|
|
printf("\tNumber of Power Cords: 0x%02x\n",
|
|
table->number_of_power_cords);
|
|
printf("\tContained Element Count: 0x%02x\n", table->element_count);
|
|
printf("\tContained Element Record Length: 0x%02x\n",
|
|
table->element_record_length);
|
|
if (table->element_count) {
|
|
printf("\tContained Elements:\n");
|
|
for (i = 0; i < table->element_count; i++) {
|
|
printf("\t\tElement[%03d]:\n", i);
|
|
if (CONFIG_IS_ENABLED(HEXDUMP))
|
|
print_hex_dump("\t\t", DUMP_PREFIX_OFFSET, 16,
|
|
1, addr,
|
|
table->element_record_length,
|
|
false);
|
|
printf("\t\tContained Element Type: 0x%02x\n", *addr);
|
|
printf("\t\tContained Element Minimum: 0x%02x\n",
|
|
*(addr + 1));
|
|
printf("\t\tContained Element Maximum: 0x%02x\n",
|
|
*(addr + 2));
|
|
addr += table->element_record_length;
|
|
}
|
|
}
|
|
smbios_print_str("SKU Number", table, *addr);
|
|
}
|
|
|
|
static void smbios_print_type4(struct smbios_type4 *table)
|
|
{
|
|
printf("Processor Information:\n");
|
|
smbios_print_str("Socket Designation", table, table->socket_design);
|
|
smbios_print_lookup_str(processor_type_strings,
|
|
table->processor_type,
|
|
ARRAY_SIZE(processor_type_strings),
|
|
"Processor Type");
|
|
smbios_print_lookup_str(processor_family_strings,
|
|
table->processor_family,
|
|
ARRAY_SIZE(processor_family_strings),
|
|
"Processor Family");
|
|
smbios_print_str("Processor Manufacturer", table,
|
|
table->processor_manufacturer);
|
|
printf("\tProcessor ID word 0: 0x%08x\n", table->processor_id[0]);
|
|
printf("\tProcessor ID word 1: 0x%08x\n", table->processor_id[1]);
|
|
smbios_print_str("Processor Version", table, table->processor_version);
|
|
printf("\tVoltage: 0x%02x\n", table->voltage);
|
|
printf("\tExternal Clock: 0x%04x\n", table->external_clock);
|
|
printf("\tMax Speed: 0x%04x\n", table->max_speed);
|
|
printf("\tCurrent Speed: 0x%04x\n", table->current_speed);
|
|
printf("\tStatus: 0x%02x\n", table->status);
|
|
smbios_print_lookup_str(processor_upgrade_strings,
|
|
table->processor_upgrade,
|
|
ARRAY_SIZE(processor_upgrade_strings),
|
|
"Processor Upgrade");
|
|
printf("\tL1 Cache Handle: 0x%04x\n", table->l1_cache_handle);
|
|
printf("\tL2 Cache Handle: 0x%04x\n", table->l2_cache_handle);
|
|
printf("\tL3 Cache Handle: 0x%04x\n", table->l3_cache_handle);
|
|
smbios_print_str("Serial Number", table, table->serial_number);
|
|
smbios_print_str("Asset Tag", table, table->asset_tag);
|
|
smbios_print_str("Part Number", table, table->part_number);
|
|
printf("\tCore Count: 0x%02x\n", table->core_count);
|
|
printf("\tCore Enabled: 0x%02x\n", table->core_enabled);
|
|
printf("\tThread Count: 0x%02x\n", table->thread_count);
|
|
printf("\tProcessor Characteristics: 0x%04x\n",
|
|
table->processor_characteristics);
|
|
smbios_print_lookup_str(processor_family_strings,
|
|
table->processor_family2,
|
|
ARRAY_SIZE(processor_family_strings),
|
|
"Processor Family 2");
|
|
printf("\tCore Count 2: 0x%04x\n", table->core_count2);
|
|
printf("\tCore Enabled 2: 0x%04x\n", table->core_enabled2);
|
|
printf("\tThread Count 2: 0x%04x\n", table->thread_count2);
|
|
printf("\tThread Enabled: 0x%04x\n", table->thread_enabled);
|
|
}
|
|
|
|
static void smbios_print_type7(struct smbios_type7 *table)
|
|
{
|
|
printf("Cache Information:\n");
|
|
smbios_print_str("Socket Designation", table,
|
|
table->socket_design);
|
|
printf("\tCache Configuration: 0x%04x\n", table->config.data);
|
|
printf("\tMaximum Cache Size: 0x%04x\n", table->max_size.data);
|
|
printf("\tInstalled Size: 0x%04x\n", table->inst_size.data);
|
|
printf("\tSupported SRAM Type: 0x%04x\n", table->supp_sram_type.data);
|
|
printf("\tCurrent SRAM Type: 0x%04x\n", table->curr_sram_type.data);
|
|
printf("\tCache Speed: 0x%02x\n", table->speed);
|
|
smbios_print_lookup_str(err_corr_type_strings,
|
|
table->err_corr_type,
|
|
ARRAY_SIZE(err_corr_type_strings),
|
|
"Error Correction Type");
|
|
smbios_print_lookup_str(sys_cache_type_strings,
|
|
table->sys_cache_type,
|
|
ARRAY_SIZE(sys_cache_type_strings),
|
|
"System Cache Type");
|
|
smbios_print_lookup_str(associativity_strings,
|
|
table->associativity,
|
|
ARRAY_SIZE(associativity_strings),
|
|
"Associativity");
|
|
printf("\tMaximum Cache Size 2: 0x%08x\n", table->max_size2.data);
|
|
printf("\tInstalled Cache Size 2: 0x%08x\n", table->inst_size2.data);
|
|
}
|
|
|
|
static void smbios_print_type16(struct smbios_type16 *table)
|
|
{
|
|
u64 capacity;
|
|
|
|
printf("Physical Memory Array\n");
|
|
smbios_print_lookup_str(mem_array_location_strings, table->location,
|
|
ARRAY_SIZE(mem_array_location_strings),
|
|
"Location");
|
|
smbios_print_lookup_str(mem_array_use_strings, table->use,
|
|
ARRAY_SIZE(mem_array_use_strings), "Use");
|
|
smbios_print_lookup_str(mem_err_corr_strings, table->error_correction,
|
|
ARRAY_SIZE(mem_err_corr_strings),
|
|
"Error Correction");
|
|
|
|
capacity = table->maximum_capacity;
|
|
if (capacity == 0x7fffffff &&
|
|
table->hdr.length >= offsetof(struct smbios_type16,
|
|
extended_maximum_capacity)) {
|
|
capacity = table->extended_maximum_capacity;
|
|
printf("\tMaximum Capacity: %llu GB\n", capacity >> 30);
|
|
} else if (capacity > 0) {
|
|
printf("\tMaximum Capacity: %llu MB\n", capacity >> 10);
|
|
} else {
|
|
printf("\tMaximum Capacity: No limit\n");
|
|
}
|
|
|
|
printf("\tError Information Handle: 0x%04x\n",
|
|
table->error_information_handle);
|
|
printf("\tNumber Of Devices: %u\n", table->number_of_memory_devices);
|
|
}
|
|
|
|
static void smbios_print_type19(struct smbios_type19 *table)
|
|
{
|
|
u64 start_addr, end_addr;
|
|
|
|
printf("Memory Array Mapped Address\n");
|
|
|
|
/* Check if extended address fields are present (SMBIOS v2.7+) */
|
|
if (table->hdr.length >= 0x1f) {
|
|
start_addr = table->extended_starting_address;
|
|
end_addr = table->extended_ending_address;
|
|
} else {
|
|
start_addr = table->starting_address;
|
|
end_addr = table->ending_address;
|
|
}
|
|
|
|
/* The ending address is the address of the last 1KB block */
|
|
if (end_addr != 0xffffffff && end_addr != 0xffffffffffffffff)
|
|
end_addr = (end_addr + 1) * 1024 - 1;
|
|
|
|
printf("\tStarting Address: 0x%016llx\n", start_addr);
|
|
printf("\tEnding Address: 0x%016llx\n", end_addr);
|
|
printf("\tMemory Array Handle: 0x%04x\n", table->memory_array_handle);
|
|
printf("\tPartition Width: %u\n", table->partition_width);
|
|
}
|
|
|
|
static void smbios_print_type127(struct smbios_type127 *table)
|
|
{
|
|
printf("End Of Table\n");
|
|
}
|
|
|
|
static int do_smbios(struct cmd_tbl *cmdtp, int flag, int argc,
|
|
char *const argv[])
|
|
{
|
|
struct smbios_info info;
|
|
int ret;
|
|
|
|
ret = smbios_locate(gd_smbios_start(), &info);
|
|
if (ret == -ENOENT) {
|
|
log_warning("SMBIOS not available\n");
|
|
return CMD_RET_FAILURE;
|
|
}
|
|
if (ret == -EINVAL) {
|
|
log_err("Unknown SMBIOS anchor format\n");
|
|
return CMD_RET_FAILURE;
|
|
}
|
|
if (ret == -EIO) {
|
|
log_err("Invalid anchor checksum\n");
|
|
return CMD_RET_FAILURE;
|
|
}
|
|
printf("SMBIOS %d.%d.%d present.\n", info.version >> 16,
|
|
(info.version >> 8) & 0xff, info.version & 0xff);
|
|
|
|
printf("%d structures occupying %d bytes\n", info.count, info.max_size);
|
|
printf("Table at %llx\n",
|
|
(unsigned long long)map_to_sysmem(info.table));
|
|
|
|
for (struct smbios_header *pos = info.table; pos;
|
|
pos = smbios_next_table(&info, pos)) {
|
|
printf("\nHandle 0x%04x, DMI type %d, %d bytes at %llx\n",
|
|
pos->handle, pos->type, pos->length,
|
|
(unsigned long long)map_to_sysmem(pos));
|
|
switch (pos->type) {
|
|
case SMBIOS_BIOS_INFORMATION:
|
|
smbios_print_type0((struct smbios_type0 *)pos);
|
|
break;
|
|
case SMBIOS_SYSTEM_INFORMATION:
|
|
smbios_print_type1((struct smbios_type1 *)pos);
|
|
break;
|
|
case SMBIOS_BOARD_INFORMATION:
|
|
smbios_print_type2((struct smbios_type2 *)pos);
|
|
break;
|
|
case SMBIOS_SYSTEM_ENCLOSURE:
|
|
smbios_print_type3((struct smbios_type3 *)pos);
|
|
break;
|
|
case SMBIOS_PROCESSOR_INFORMATION:
|
|
smbios_print_type4((struct smbios_type4 *)pos);
|
|
break;
|
|
case SMBIOS_CACHE_INFORMATION:
|
|
smbios_print_type7((struct smbios_type7 *)pos);
|
|
break;
|
|
case SMBIOS_PHYS_MEMORY_ARRAY:
|
|
smbios_print_type16((struct smbios_type16 *)pos);
|
|
break;
|
|
case SMBIOS_MEMORY_ARRAY_MAPPED_ADDRESS:
|
|
smbios_print_type19((struct smbios_type19 *)pos);
|
|
break;
|
|
case SMBIOS_END_OF_TABLE:
|
|
smbios_print_type127((struct smbios_type127 *)pos);
|
|
break;
|
|
default:
|
|
smbios_print_generic(pos);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return CMD_RET_SUCCESS;
|
|
}
|
|
|
|
U_BOOT_LONGHELP(smbios, "- display SMBIOS information");
|
|
|
|
U_BOOT_CMD(smbios, 1, 0, do_smbios, "display SMBIOS information",
|
|
smbios_help_text);
|