diff options
Diffstat (limited to 'contrib/syslinux-4.02/com32/gpllib/dmi/dmi.c')
| -rw-r--r-- | contrib/syslinux-4.02/com32/gpllib/dmi/dmi.c | 1004 |
1 files changed, 1004 insertions, 0 deletions
diff --git a/contrib/syslinux-4.02/com32/gpllib/dmi/dmi.c b/contrib/syslinux-4.02/com32/gpllib/dmi/dmi.c new file mode 100644 index 0000000..507b11a --- /dev/null +++ b/contrib/syslinux-4.02/com32/gpllib/dmi/dmi.c @@ -0,0 +1,1004 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 2006 Erwan Velu - All Rights Reserved + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom + * the Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall + * be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * ----------------------------------------------------------------------- +*/ + +#include <stdio.h> +#include <string.h> +#include "dmi/dmi.h" + +const char *out_of_spec = "<OUT OF SPEC>"; +const char *bad_index = "<BAD INDEX>"; + +/* + * Misc. util stuff + */ + +/* + * 3.3.11 On Board Devices Information (Type 10) + */ + +static const char *dmi_on_board_devices_type(uint8_t code) +{ + /* 3.3.11.1 */ + static const char *type[] = { + "Other", /* 0x01 */ + "Unknown", + "Video", + "SCSI Controller", + "Ethernet", + "Token Ring", + "Sound", + "PATA Controller", + "SATA Controller", + "SAS Controller" /* 0x0A */ + }; + + if (code >= 0x01 && code <= 0x0A) + return type[code - 0x01]; + return out_of_spec; +} + +static void dmi_on_board_devices(struct dmi_header *h, s_dmi * dmi) +{ + uint8_t *p = h->data + 4; + uint8_t count = (h->length - 0x04) / 2; + unsigned int i; + + for (i = 0; + i < count + && i < + sizeof dmi->base_board.devices_information / + sizeof *dmi->base_board.devices_information; i++) { + strlcpy(dmi->base_board.devices_information[i].type, + dmi_on_board_devices_type(p[2 * i] & 0x7F), + sizeof dmi->base_board.devices_information[i].type); + dmi->base_board.devices_information[i].status = p[2 * i] & 0x80; + strlcpy(dmi->base_board.devices_information[i].description, + dmi_string(h, p[2 * i + 1]), + sizeof dmi->base_board.devices_information[i].description); + } +} + +/* + * 3.3.24 System Reset (Type 23) + */ + +static const char *dmi_system_reset_boot_option(uint8_t code) +{ + static const char *option[] = { + "Operating System", /* 0x1 */ + "System Utilities", + "Do Not Reboot" /* 0x3 */ + }; + + if (code >= 0x1) + return option[code - 0x1]; + return out_of_spec; +} + +static void dmi_system_reset_count(uint16_t code, char *array) +{ + if (code == 0xFFFF) + strlcpy(array, "Unknown", sizeof array); + else + snprintf(array, sizeof array, "%u", code); +} + +static void dmi_system_reset_timer(uint16_t code, char *array) +{ + if (code == 0xFFFF) + strlcpy(array, "Unknown", sizeof array); + else + snprintf(array, sizeof array, "%u min", code); +} + +/* + * 3.3.25 Hardware Security (Type 24) + */ + +static const char *dmi_hardware_security_status(uint8_t code) +{ + static const char *status[] = { + "Disabled", /* 0x00 */ + "Enabled", + "Not Implemented", + "Unknown" /* 0x03 */ + }; + + return status[code]; +} + +/* + * 3.3.12 OEM Strings (Type 11) + */ + +static void dmi_oem_strings(struct dmi_header *h, const char *prefix, + s_dmi * dmi) +{ + uint8_t *p = h->data + 4; + uint8_t count = p[0x00]; + int i; + + for (i = 1; i <= count; i++) + snprintf(dmi->oem_strings, OEM_STRINGS_SIZE, "%s %s %s\n", + dmi->oem_strings, prefix, dmi_string(h, i)); +} + +/* + * 3.3.13 System Configuration Options (Type 12) + */ +static void dmi_system_configuration_options(struct dmi_header *h, + const char *prefix, s_dmi * dmi) +{ + uint8_t *p = h->data + 4; + uint8_t count = p[0x00]; + int i; + + for (i = 1; i <= count; i++) + snprintf(dmi->system.configuration_options, + SYSTEM_CONFIGURATION_OPTIONS_SIZE, "%s %s %s\n", + dmi->system.configuration_options, prefix, dmi_string(h, i)); +} + +static void dmi_system_boot_status(uint8_t code, char *array) +{ + static const char *status[] = { + "No errors detected", /* 0 */ + "No bootable media", + "Operating system failed to load", + "Firmware-detected hardware failure", + "Operating system-detected hardware failure", + "User-requested boot", + "System security violation", + "Previously-requested image", + "System watchdog timer expired" /* 8 */ + }; + + if (code <= 8) + strlcpy(array, status[code], SYSTEM_BOOT_STATUS_SIZE); + if (code >= 128 && code <= 191) + strlcpy(array, "OEM-specific", SYSTEM_BOOT_STATUS_SIZE); + if (code >= 192) + strlcpy(array, "Product-specific", SYSTEM_BOOT_STATUS_SIZE); +} + +void dmi_bios_runtime_size(uint32_t code, s_dmi * dmi) +{ + if (code & 0x000003FF) { + dmi->bios.runtime_size = code; + strlcpy(dmi->bios.runtime_size_unit, "bytes", + sizeof(dmi->bios.runtime_size_unit)); + } else { + dmi->bios.runtime_size = code >> 10; + strlcpy(dmi->bios.runtime_size_unit, "KB", + sizeof(dmi->bios.runtime_size_unit)); + + } +} + +void dmi_bios_characteristics(uint64_t code, s_dmi * dmi) +{ + int i; + /* + * This isn't very clear what this bit is supposed to mean + */ + //if(code.l&(1<<3)) + if (code && (1 << 3)) { + ((bool *) (&dmi->bios.characteristics))[0] = true; + return; + } + + for (i = 4; i <= 31; i++) + //if(code.l&(1<<i)) + if (code & (1 << i)) + ((bool *) (&dmi->bios.characteristics))[i - 3] = true; +} + +void dmi_bios_characteristics_x1(uint8_t code, s_dmi * dmi) +{ + int i; + + for (i = 0; i <= 7; i++) + if (code & (1 << i)) + ((bool *) (&dmi->bios.characteristics_x1))[i] = true; +} + +void dmi_bios_characteristics_x2(uint8_t code, s_dmi * dmi) +{ + int i; + + for (i = 0; i <= 2; i++) + if (code & (1 << i)) + ((bool *) (&dmi->bios.characteristics_x2))[i] = true; +} + +void dmi_system_uuid(uint8_t * p, s_dmi * dmi) +{ + int only0xFF = 1, only0x00 = 1; + int i; + + for (i = 0; i < 16 && (only0x00 || only0xFF); i++) { + if (p[i] != 0x00) + only0x00 = 0; + if (p[i] != 0xFF) + only0xFF = 0; + } + + if (only0xFF) { + sprintf(dmi->system.uuid, "Not Present"); + return; + } + if (only0x00) { + sprintf(dmi->system.uuid, "Not Settable"); + return; + } + + sprintf(dmi->system.uuid, + "%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", + p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10], + p[11], p[12], p[13], p[14], p[15]); +} + +void dmi_system_wake_up_type(uint8_t code, s_dmi * dmi) +{ + /* 3.3.2.1 */ + static const char *type[] = { + "Reserved", /* 0x00 */ + "Other", + "Unknown", + "APM Timer", + "Modem Ring", + "LAN Remote", + "Power Switch", + "PCI PME#", + "AC Power Restored" /* 0x08 */ + }; + + if (code <= 0x08) { + strlcpy(dmi->system.wakeup_type, type[code], + sizeof(dmi->system.wakeup_type)); + } else { + strlcpy(dmi->system.wakeup_type, out_of_spec, + sizeof(dmi->system.wakeup_type)); + } + return; +} + +static void dmi_base_board_features(uint8_t code, s_dmi * dmi) +{ + if ((code & 0x1F) != 0) { + int i; + + for (i = 0; i <= 4; i++) + if (code & (1 << i)) + ((bool *) (&dmi->base_board.features))[i] = true; + } +} + +static void dmi_processor_voltage(uint8_t code, s_dmi * dmi) +{ + /* 3.3.5.4 */ + static const uint16_t voltage[] = { + 5000, + 3300, + 2900 + }; + int i; + + if (code & 0x80) + dmi->processor.voltage_mv = (code & 0x7f) * 100; + else { + for (i = 0; i <= 2; i++) + if (code & (1 << i)) + dmi->processor.voltage_mv = voltage[i]; + } +} + +static void dmi_processor_id(uint8_t type, uint8_t * p, const char *version, + s_dmi * dmi) +{ + /* + * Extra flags are now returned in the ECX register when one calls + * the CPUID instruction. Their meaning is explained in table 6, but + * DMI doesn't support this yet. + */ + uint32_t eax, edx; + int sig = 0; + + /* + * This might help learn about new processors supporting the + * CPUID instruction or another form of identification. + */ + sprintf(dmi->processor.id, "ID: %02X %02X %02X %02X %02X %02X %02X %02X\n", + p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); + + if (type == 0x05) { /* 80386 */ + uint16_t dx = WORD(p); + /* + * 80386 have a different signature. + */ + dmi->processor.signature.type = (dx >> 12); + dmi->processor.signature.family = ((dx >> 8) & 0xF); + dmi->processor.signature.stepping = (dx >> 4) & 0xF; + dmi->processor.signature.minor_stepping = (dx & 0xF); + return; + } + if (type == 0x06) { /* 80486 */ + uint16_t dx = WORD(p); + /* + * Not all 80486 CPU support the CPUID instruction, we have to find + * wether the one we have here does or not. Note that this trick + * works only because we know that 80486 must be little-endian. + */ + if ((dx & 0x0F00) == 0x0400 + && ((dx & 0x00F0) == 0x0040 || (dx & 0x00F0) >= 0x0070) + && ((dx & 0x000F) >= 0x0003)) + sig = 1; + else { + dmi->processor.signature.type = ((dx >> 12) & 0x3); + dmi->processor.signature.family = ((dx >> 8) & 0xF); + dmi->processor.signature.model = ((dx >> 4) & 0xF); + dmi->processor.signature.stepping = (dx & 0xF); + return; + } + } else if ((type >= 0x0B && type <= 0x13) /* Intel, Cyrix */ + ||(type >= 0xB0 && type <= 0xB3) /* Intel */ + ||type == 0xB5 /* Intel */ + || type == 0xB9) /* Intel */ + sig = 1; + else if ((type >= 0x18 && type <= 0x1D) /* AMD */ + ||type == 0x1F /* AMD */ + || (type >= 0xB6 && type <= 0xB7) /* AMD */ + ||(type >= 0x83 && type <= 0x85)) /* AMD */ + sig = 2; + else if (type == 0x01 || type == 0x02) { + /* + * Some X86-class CPU have family "Other" or "Unknown". In this case, + * we use the version string to determine if they are known to + * support the CPUID instruction. + */ + if (strncmp(version, "Pentium III MMX", 15) == 0) + sig = 1; + else if (strncmp(version, "AMD Athlon(TM)", 14) == 0 + || strncmp(version, "AMD Opteron(tm)", 15) == 0) + sig = 2; + else + return; + } else /* not X86-class */ + return; + + eax = DWORD(p); + edx = DWORD(p + 4); + switch (sig) { + case 1: /* Intel */ + dmi->processor.signature.type = ((eax >> 12) & 0x3); + dmi->processor.signature.family = + (((eax >> 16) & 0xFF0) + ((eax >> 8) & 0x00F)); + dmi->processor.signature.model = + (((eax >> 12) & 0xF0) + ((eax >> 4) & 0x0F)); + dmi->processor.signature.stepping = (eax & 0xF); + break; + case 2: /* AMD */ + dmi->processor.signature.family = + (((eax >> 8) & 0xF) == 0xF ? (eax >> 20) & 0xFF : (eax >> 8) & 0xF); + dmi->processor.signature.model = + (((eax >> 4) & 0xF) == 0xF ? (eax >> 16) & 0xF : (eax >> 4) & 0xF); + dmi->processor.signature.stepping = (eax & 0xF); + break; + } + + edx = DWORD(p + 4); + if ((edx & 0x3FF7FDFF) != 0) { + int i; + for (i = 0; i <= 31; i++) + if (cpu_flags_strings[i] != NULL && edx & (1 << i)) + ((bool *) (&dmi->processor.cpu_flags))[i] = true; + } +} + +void to_dmi_header(struct dmi_header *h, uint8_t * data) +{ + h->type = data[0]; + h->length = data[1]; + h->handle = WORD(data + 2); + h->data = data; +} + +const char *dmi_string(struct dmi_header *dm, uint8_t s) +{ + char *bp = (char *)dm->data; + size_t i, len; + + if (s == 0) + return "Not Specified"; + + bp += dm->length; + while (s > 1 && *bp) { + bp += strlen(bp); + bp++; + s--; + } + + if (!*bp) + return bad_index; + + /* ASCII filtering */ + len = strlen(bp); + for (i = 0; i < len; i++) + if (bp[i] < 32 || bp[i] == 127) + bp[i] = '.'; + + return bp; +} + +int checksum(uint8_t * buf, int len) +{ + uint8_t sum = 0; + int a; + + for (a = 0; a < len; a++) + sum += buf[a]; + return (sum == 0); +} + +static int smbios_decode(s_dmi * dmi, uint8_t * buf) +{ + + dmi->dmitable.ver = (buf[0x06] << 8) + buf[0x07]; + /* Some BIOS report weird SMBIOS version, fix that up */ + switch (dmi->dmitable.ver) { + case 0x021F: + dmi->dmitable.ver = 0x0203; + break; + case 0x0233: + dmi->dmitable.ver = 0x0206; + break; + } + dmi->dmitable.major_version = dmi->dmitable.ver >> 8; + dmi->dmitable.minor_version = dmi->dmitable.ver & 0xFF; + + return DMI_TABLE_PRESENT; +} + +static int legacy_decode(s_dmi * dmi, uint8_t * buf) +{ + dmi->dmitable.num = buf[13] << 8 | buf[12]; + dmi->dmitable.len = buf[7] << 8 | buf[6]; + dmi->dmitable.base = buf[11] << 24 | buf[10] << 16 | buf[9] << 8 | buf[8]; + + /* Version already found? */ + if (dmi->dmitable.ver > 0) + return DMI_TABLE_PRESENT; + + dmi->dmitable.ver = (buf[0x06] << 8) + buf[0x07]; + + /* + * DMI version 0.0 means that the real version is taken from + * the SMBIOS version, which we don't know at this point. + */ + if (buf[14] != 0) { + dmi->dmitable.major_version = buf[14] >> 4; + dmi->dmitable.minor_version = buf[14] & 0x0F; + } else { + dmi->dmitable.major_version = 0; + dmi->dmitable.minor_version = 0; + } + return DMI_TABLE_PRESENT; +} + +int dmi_iterate(s_dmi * dmi) +{ + uint8_t *p, *q; + int found = 0; + + /* Cleaning structures */ + memset(dmi, 0, sizeof(s_dmi)); + + memset(&dmi->base_board, 0, sizeof(s_base_board)); + memset(&dmi->battery, 0, sizeof(s_battery)); + memset(&dmi->bios, 0, sizeof(s_bios)); + memset(&dmi->chassis, 0, sizeof(s_chassis)); + for (int i = 0; i < MAX_DMI_MEMORY_ITEMS; i++) + memset(&dmi->memory[i], 0, sizeof(s_memory)); + memset(&dmi->processor, 0, sizeof(s_processor)); + memset(&dmi->system, 0, sizeof(s_system)); + + /* Until we found this elements in the dmitable, we consider them as not filled */ + dmi->base_board.filled = false; + dmi->battery.filled = false; + dmi->bios.filled = false; + dmi->chassis.filled = false; + for (int i = 0; i < MAX_DMI_MEMORY_ITEMS; i++) + dmi->memory[i].filled = false; + dmi->processor.filled = false; + dmi->system.filled = false; + + p = (uint8_t *) 0xF0000; /* The start address to look at the dmi table */ + /* The anchor-string is 16-bytes aligned */ + for (q = p; q < p + 0x10000; q += 16) { + /* To validate the presence of SMBIOS: + * + the overall checksum must be correct + * + the intermediate anchor-string must be _DMI_ + * + the intermediate checksum must be correct + */ + if (memcmp(q, "_SM_", 4) == 0 && + checksum(q, q[0x05]) && + memcmp(q + 0x10, "_DMI_", 5) == 0 && checksum(q + 0x10, 0x0F)) { + /* Do not return, legacy_decode will need to be called + * on the intermediate structure to get the table length + * and address + */ + smbios_decode(dmi, q); + } else if (memcmp(q, "_DMI_", 5) == 0 && checksum(q, 0x0F)) { + found = 1; + legacy_decode(dmi, q); + } + } + + if (found) + return DMI_TABLE_PRESENT; + + dmi->dmitable.base = 0; + dmi->dmitable.num = 0; + dmi->dmitable.ver = 0; + dmi->dmitable.len = 0; + return -ENODMITABLE; +} + +void dmi_decode(struct dmi_header *h, uint16_t ver, s_dmi * dmi) +{ + uint8_t *data = h->data; + + /* + * Note: DMI types 37, 38 and 39 are untested + */ + switch (h->type) { + case 0: /* 3.3.1 BIOS Information */ + if (h->length < 0x12) + break; + dmi->bios.filled = true; + strlcpy(dmi->bios.vendor, dmi_string(h, data[0x04]), + sizeof(dmi->bios.vendor)); + strlcpy(dmi->bios.version, dmi_string(h, data[0x05]), + sizeof(dmi->bios.version)); + strlcpy(dmi->bios.release_date, dmi_string(h, data[0x08]), + sizeof(dmi->bios.release_date)); + dmi->bios.address = WORD(data + 0x06); + dmi_bios_runtime_size((0x10000 - WORD(data + 0x06)) << 4, dmi); + dmi->bios.rom_size = (data[0x09] + 1) << 6; + strlcpy(dmi->bios.rom_size_unit, "kB", sizeof(dmi->bios.rom_size_unit)); + dmi_bios_characteristics(QWORD(data + 0x0A), dmi); + + if (h->length < 0x13) + break; + dmi_bios_characteristics_x1(data[0x12], dmi); + if (h->length < 0x14) + break; + dmi_bios_characteristics_x2(data[0x13], dmi); + if (h->length < 0x18) + break; + if (data[0x14] != 0xFF && data[0x15] != 0xFF) + snprintf(dmi->bios.bios_revision, sizeof(dmi->bios.bios_revision), + "%u.%u", data[0x14], data[0x15]); + if (data[0x16] != 0xFF && data[0x17] != 0xFF) + snprintf(dmi->bios.firmware_revision, + sizeof(dmi->bios.firmware_revision), "%u.%u", data[0x16], + data[0x17]); + break; + case 1: /* 3.3.2 System Information */ + if (h->length < 0x08) + break; + dmi->system.filled = true; + strlcpy(dmi->system.manufacturer, dmi_string(h, data[0x04]), + sizeof(dmi->system.manufacturer)); + strlcpy(dmi->system.product_name, dmi_string(h, data[0x05]), + sizeof(dmi->system.product_name)); + strlcpy(dmi->system.version, dmi_string(h, data[0x06]), + sizeof(dmi->system.version)); + strlcpy(dmi->system.serial, dmi_string(h, data[0x07]), + sizeof(dmi->system.serial)); + if (h->length < 0x19) + break; + dmi_system_uuid(data + 0x08, dmi); + dmi_system_wake_up_type(data[0x18], dmi); + if (h->length < 0x1B) + break; + strlcpy(dmi->system.sku_number, dmi_string(h, data[0x19]), + sizeof(dmi->system.sku_number)); + strlcpy(dmi->system.family, dmi_string(h, data[0x1A]), + sizeof(dmi->system.family)); + break; + + case 2: /* 3.3.3 Base Board Information */ + if (h->length < 0x08) + break; + dmi->base_board.filled = true; + strlcpy(dmi->base_board.manufacturer, dmi_string(h, data[0x04]), + sizeof(dmi->base_board.manufacturer)); + strlcpy(dmi->base_board.product_name, dmi_string(h, data[0x05]), + sizeof(dmi->base_board.product_name)); + strlcpy(dmi->base_board.version, dmi_string(h, data[0x06]), + sizeof(dmi->base_board.version)); + strlcpy(dmi->base_board.serial, dmi_string(h, data[0x07]), + sizeof(dmi->base_board.serial)); + if (h->length < 0x0F) + break; + strlcpy(dmi->base_board.asset_tag, dmi_string(h, data[0x08]), + sizeof(dmi->base_board.asset_tag)); + dmi_base_board_features(data[0x09], dmi); + strlcpy(dmi->base_board.location, dmi_string(h, data[0x0A]), + sizeof(dmi->base_board.location)); + strlcpy(dmi->base_board.type, dmi_string(h, data[0x0D]), + sizeof(dmi->base_board.type)); + if (h->length < 0x0F + data[0x0E] * sizeof(uint16_t)) + break; + break; + case 3: /* 3.3.4 Chassis Information */ + if (h->length < 0x09) + break; + dmi->chassis.filled = true; + strlcpy(dmi->chassis.manufacturer, dmi_string(h, data[0x04]), + sizeof(dmi->chassis.manufacturer)); + strlcpy(dmi->chassis.type, dmi_chassis_type(data[0x05] & 0x7F), + sizeof(dmi->chassis.type)); + strlcpy(dmi->chassis.lock, dmi_chassis_lock(data[0x05] >> 7), + sizeof(dmi->chassis.lock)); + strlcpy(dmi->chassis.version, dmi_string(h, data[0x06]), + sizeof(dmi->chassis.version)); + strlcpy(dmi->chassis.serial, dmi_string(h, data[0x07]), + sizeof(dmi->chassis.serial)); + strlcpy(dmi->chassis.asset_tag, dmi_string(h, data[0x08]), + sizeof(dmi->chassis.asset_tag)); + if (h->length < 0x0D) + break; + strlcpy(dmi->chassis.boot_up_state, dmi_chassis_state(data[0x09]), + sizeof(dmi->chassis.boot_up_state)); + strlcpy(dmi->chassis.power_supply_state, + dmi_chassis_state(data[0x0A]), + sizeof(dmi->chassis.power_supply_state)); + strlcpy(dmi->chassis.thermal_state, + dmi_chassis_state(data[0x0B]), + sizeof(dmi->chassis.thermal_state)); + strlcpy(dmi->chassis.security_status, + dmi_chassis_security_status(data[0x0C]), + sizeof(dmi->chassis.security_status)); + if (h->length < 0x11) + break; + snprintf(dmi->chassis.oem_information, + sizeof(dmi->chassis.oem_information), "0x%08X", + DWORD(data + 0x0D)); + if (h->length < 0x15) + break; + dmi->chassis.height = data[0x11]; + dmi->chassis.nb_power_cords = data[0x12]; + break; + case 4: /* 3.3.5 Processor Information */ + if (h->length < 0x1A) + break; + dmi->processor.filled = true; + strlcpy(dmi->processor.socket_designation, + dmi_string(h, data[0x04]), + sizeof(dmi->processor.socket_designation)); + strlcpy(dmi->processor.type, + dmi_processor_type(data[0x05]), sizeof(dmi->processor.type)); + strlcpy(dmi->processor.manufacturer, + dmi_string(h, data[0x07]), sizeof(dmi->processor.manufacturer)); + strlcpy(dmi->processor.family, + dmi_processor_family(data[0x06], + dmi->processor.manufacturer), + sizeof(dmi->processor.family)); + dmi_processor_id(data[0x06], data + 8, dmi_string(h, data[0x10]), dmi); + strlcpy(dmi->processor.version, + dmi_string(h, data[0x10]), sizeof(dmi->processor.version)); + dmi_processor_voltage(data[0x11], dmi); + dmi->processor.external_clock = WORD(data + 0x12); + dmi->processor.max_speed = WORD(data + 0x14); + dmi->processor.current_speed = WORD(data + 0x16); + if (data[0x18] & (1 << 6)) + strlcpy(dmi->processor.status, + dmi_processor_status(data[0x18] & 0x07), + sizeof(dmi->processor.status)); + else + sprintf(dmi->processor.status, "Unpopulated"); + strlcpy(dmi->processor.upgrade, + dmi_processor_upgrade(data[0x19]), + sizeof(dmi->processor.upgrade)); + if (h->length < 0x20) + break; + dmi_processor_cache(WORD(data + 0x1A), "L1", ver, + dmi->processor.cache1); + dmi_processor_cache(WORD(data + 0x1C), "L2", ver, + dmi->processor.cache2); + dmi_processor_cache(WORD(data + 0x1E), "L3", ver, + dmi->processor.cache3); + if (h->length < 0x23) + break; + strlcpy(dmi->processor.serial, dmi_string(h, data[0x20]), + sizeof(dmi->processor.serial)); + strlcpy(dmi->processor.asset_tag, dmi_string(h, data[0x21]), + sizeof(dmi->processor.asset_tag)); + strlcpy(dmi->processor.part_number, dmi_string(h, data[0x22]), + sizeof(dmi->processor.part_number)); + break; + case 6: /* 3.3.7 Memory Module Information */ + if (h->length < 0x0C) + break; + dmi->memory_module_count++; + s_memory_module *module = + &dmi->memory_module[dmi->memory_module_count - 1]; + dmi->memory_module[dmi->memory_module_count - 1].filled = true; + strlcpy(module->socket_designation, dmi_string(h, data[0x04]), + sizeof(module->socket_designation)); + dmi_memory_module_connections(data[0x05], module->bank_connections, sizeof(module->bank_connections)); + dmi_memory_module_speed(data[0x06], module->speed); + dmi_memory_module_types(WORD(data + 0x07), " ", module->type, sizeof(module->type)); + dmi_memory_module_size(data[0x09], module->installed_size, sizeof(module->installed_size)); + dmi_memory_module_size(data[0x0A], module->enabled_size, sizeof(module->enabled_size)); + dmi_memory_module_error(data[0x0B], "\t\t", module->error_status); + break; + case 7: /* 3.3.8 Cache Information */ + if (h->length < 0x0F) + break; + dmi->cache_count++; + if (dmi->cache_count > MAX_DMI_CACHE_ITEMS) + break; + strlcpy(dmi->cache[dmi->cache_count - 1].socket_designation, + dmi_string(h, data[0x04]), + sizeof(dmi->cache[dmi->cache_count - 1].socket_designation)); + snprintf(dmi->cache[dmi->cache_count - 1].configuration, + sizeof(dmi->cache[dmi->cache_count - 1].configuration), + "%s, %s, %u", + WORD(data + 0x05) & 0x0080 ? "Enabled" : "Disabled", + WORD(data + + 0x05) & 0x0008 ? "Socketed" : "Not Socketed", + (WORD(data + 0x05) & 0x0007) + 1); + strlcpy(dmi->cache[dmi->cache_count - 1].mode, + dmi_cache_mode((WORD(data + 0x05) >> 8) & 0x0003), + sizeof(dmi->cache[dmi->cache_count - 1].mode)); + strlcpy(dmi->cache[dmi->cache_count - 1].location, + dmi_cache_location((WORD(data + 0x05) >> 5) & 0x0003), + sizeof(dmi->cache[dmi->cache_count - 1].location)); + dmi->cache[dmi->cache_count - 1].installed_size = + dmi_cache_size(WORD(data + 0x09)); + dmi->cache[dmi->cache_count - 1].max_size = + dmi_cache_size(WORD(data + 0x07)); + dmi_cache_types(WORD(data + 0x0B), " ", + dmi->cache[dmi->cache_count - 1].supported_sram_types); + dmi_cache_types(WORD(data + 0x0D), " ", + dmi->cache[dmi->cache_count - 1].installed_sram_types); + if (h->length < 0x13) + break; + dmi->cache[dmi->cache_count - 1].speed = data[0x0F]; /* ns */ + strlcpy(dmi->cache[dmi->cache_count - 1].error_correction_type, + dmi_cache_ec_type(data[0x10]), + sizeof(dmi->cache[dmi->cache_count - 1].error_correction_type)); + strlcpy(dmi->cache[dmi->cache_count - 1].system_type, + dmi_cache_type(data[0x11]), + sizeof(dmi->cache[dmi->cache_count - 1].system_type)); + strlcpy(dmi->cache[dmi->cache_count - 1].associativity, + dmi_cache_associativity(data[0x12]), + sizeof(dmi->cache[dmi->cache_count - 1].associativity)); + break; + case 10: /* 3.3.11 On Board Devices Information */ + dmi_on_board_devices(h, dmi); + break; + case 11: /* 3.3.12 OEM Strings */ + if (h->length < 0x05) + break; + dmi_oem_strings(h, "\t", dmi); + break; + case 12: /* 3.3.13 System Configuration Options */ + if (h->length < 0x05) + break; + dmi_system_configuration_options(h, "\t", dmi); + break; + case 17: /* 3.3.18 Memory Device */ + if (h->length < 0x15) + break; + dmi->memory_count++; + if (dmi->memory_count > MAX_DMI_MEMORY_ITEMS) + break; + s_memory *mem = &dmi->memory[dmi->memory_count - 1]; + dmi->memory[dmi->memory_count - 1].filled = true; + dmi_memory_array_error_handle(WORD(data + 0x06), mem->error); + dmi_memory_device_width(WORD(data + 0x08), mem->total_width); + dmi_memory_device_width(WORD(data + 0x0A), mem->data_width); + dmi_memory_device_size(WORD(data + 0x0C), mem->size); + strlcpy(mem->form_factor, + dmi_memory_device_form_factor(data[0x0E]), + sizeof(mem->form_factor)); + dmi_memory_device_set(data[0x0F], mem->device_set); + strlcpy(mem->device_locator, dmi_string(h, data[0x10]), + sizeof(mem->device_locator)); + strlcpy(mem->bank_locator, dmi_string(h, data[0x11]), + sizeof(mem->bank_locator)); + strlcpy(mem->type, dmi_memory_device_type(data[0x12]), + sizeof(mem->type)); + dmi_memory_device_type_detail(WORD(data + 0x13), mem->type_detail, sizeof(mem->type_detail)); + if (h->length < 0x17) + break; + dmi_memory_device_speed(WORD(data + 0x15), mem->speed); + if (h->length < 0x1B) + break; + strlcpy(mem->manufacturer, dmi_string(h, data[0x17]), + sizeof(mem->manufacturer)); + strlcpy(mem->serial, dmi_string(h, data[0x18]), sizeof(mem->serial)); + strlcpy(mem->asset_tag, dmi_string(h, data[0x19]), + sizeof(mem->asset_tag)); + strlcpy(mem->part_number, dmi_string(h, data[0x1A]), + sizeof(mem->part_number)); + break; + case 22: /* 3.3.23 Portable Battery */ + if (h->length < 0x10) + break; + dmi->battery.filled = true; + strlcpy(dmi->battery.location, dmi_string(h, data[0x04]), + sizeof(dmi->battery.location)); + strlcpy(dmi->battery.manufacturer, dmi_string(h, data[0x05]), + sizeof(dmi->battery.manufacturer)); + if (data[0x06] || h->length < 0x1A) + strlcpy(dmi->battery.manufacture_date, + dmi_string(h, data[0x06]), + sizeof(dmi->battery.manufacture_date)); + if (data[0x07] || h->length < 0x1A) + strlcpy(dmi->battery.serial, dmi_string(h, data[0x07]), + sizeof(dmi->battery.serial)); + strlcpy(dmi->battery.name, dmi_string(h, data[0x08]), + sizeof(dmi->battery.name)); + if (data[0x09] != 0x02 || h->length < 0x1A) + strlcpy(dmi->battery.chemistry, + dmi_battery_chemistry(data[0x09]), + sizeof(dmi->battery.chemistry)); + if (h->length < 0x1A) + dmi_battery_capacity(WORD(data + 0x0A), 1, + dmi->battery.design_capacity); + else + dmi_battery_capacity(WORD(data + 0x0A), data[0x15], + dmi->battery.design_capacity); + dmi_battery_voltage(WORD(data + 0x0C), dmi->battery.design_voltage); + strlcpy(dmi->battery.sbds, dmi_string(h, data[0x0E]), + sizeof(dmi->battery.sbds)); + dmi_battery_maximum_error(data[0x0F], dmi->battery.maximum_error); + if (h->length < 0x1A) + break; + if (data[0x07] == 0) + sprintf(dmi->battery.sbds_serial, "%04X", WORD(data + 0x10)); + if (data[0x06] == 0) + sprintf(dmi->battery.sbds_manufacture_date, "%u-%02u-%02u", + 1980 + (WORD(data + 0x12) >> 9), + (WORD(data + 0x12) >> 5) & 0x0F, WORD(data + 0x12) & 0x1F); + if (data[0x09] == 0x02) + strlcpy(dmi->battery.sbds_chemistry, dmi_string(h, data[0x14]), + sizeof(dmi->battery.sbds_chemistry)); + // sprintf(dmi->battery.oem_info,"0x%08X",DWORD(h, data+0x16)); + break; + case 23: /* 3.3.24 System Reset */ + if (h->length < 0x0D) + break; + dmi->system.system_reset.filled = true; + dmi->system.system_reset.status = data[0x04] & (1 << 0); + dmi->system.system_reset.watchdog = data[0x04] & (1 << 5); + if (!(data[0x04] & (1 << 5))) + break; + strlcpy(dmi->system.system_reset.boot_option, + dmi_system_reset_boot_option((data[0x04] >> 1) & 0x3), + sizeof dmi->system.system_reset.boot_option); + strlcpy(dmi->system.system_reset.boot_option_on_limit, + dmi_system_reset_boot_option((data[0x04] >> 3) & 0x3), + sizeof dmi->system.system_reset.boot_option_on_limit); + dmi_system_reset_count(WORD(data + 0x05), + dmi->system.system_reset.reset_count); + dmi_system_reset_count(WORD(data + 0x07), + dmi->system.system_reset.reset_limit); + dmi_system_reset_timer(WORD(data + 0x09), + dmi->system.system_reset.timer_interval); + dmi_system_reset_timer(WORD(data + 0x0B), + dmi->system.system_reset.timeout); + break; + case 24: /* 3.3.25 Hardware Security */ + if (h->length < 0x05) + break; + dmi->hardware_security.filled = true; + strlcpy(dmi->hardware_security.power_on_passwd_status, + dmi_hardware_security_status(data[0x04] >> 6), + sizeof dmi->hardware_security.power_on_passwd_status); + strlcpy(dmi->hardware_security.keyboard_passwd_status, + dmi_hardware_security_status((data[0x04] >> 4) & 0x3), + sizeof dmi->hardware_security.keyboard_passwd_status); + strlcpy(dmi->hardware_security.administrator_passwd_status, + dmi_hardware_security_status((data[0x04] >> 2) & 0x3), + sizeof dmi->hardware_security.administrator_passwd_status); + strlcpy(dmi->hardware_security.front_panel_reset_status, + dmi_hardware_security_status(data[0x04] & 0x3), + sizeof dmi->hardware_security.front_panel_reset_status); + break; + case 32: /* 3.3.33 System Boot Information */ + if (h->length < 0x0B) + break; + dmi_system_boot_status(data[0x0A], dmi->system.system_boot_status); + case 38: /* 3.3.39 IPMI Device Information */ + if (h->length < 0x10) + break; + dmi->ipmi.filled = true; + snprintf(dmi->ipmi.interface_type, + sizeof(dmi->ipmi.interface_type), "%s", + dmi_ipmi_interface_type(data[0x04])); + dmi->ipmi.major_specification_version = data[0x05] >> 4; + dmi->ipmi.minor_specification_version = data[0x05] & 0x0F; + dmi->ipmi.I2C_slave_address = data[0x06] >> 1; + if (data[0x07] != 0xFF) + dmi->ipmi.nv_address = data[0x07]; + else + dmi->ipmi.nv_address = 0; /* Not Present */ + dmi_ipmi_base_address(data[0x04], data + 0x08, &dmi->ipmi); + if (h->length < 0x12) + break; + if (data[0x11] != 0x00) { + dmi->ipmi.irq = data[0x11]; + } + break; + } +} + +void parse_dmitable(s_dmi * dmi) +{ + int i = 0; + uint8_t *data = NULL; + uint8_t buf[dmi->dmitable.len]; + memcpy(buf, (int *)dmi->dmitable.base, sizeof(uint8_t) * dmi->dmitable.len); + data = buf; + dmi->memory_count = 0; + while (i < dmi->dmitable.num && data + 4 <= buf + dmi->dmitable.len) { /* 4 is the length of an SMBIOS structure header */ + uint8_t *next; + struct dmi_header h; + to_dmi_header(&h, data); + /* + * If a short entry is found (less than 4 bytes), not only it + * is invalid, but we cannot reliably locate the next entry. + * Better stop at this point, and let the user know his/her + * table is broken. + */ + if (h.length < 4) { + printf + ("Invalid entry length (%u). DMI table is broken! Stop.\n\n", + (unsigned int)h.length); + break; + } + + /* loo for the next handle */ + next = data + h.length; + while (next - buf + 1 < dmi->dmitable.len + && (next[0] != 0 || next[1] != 0)) + next++; + next += 2; + if (next - buf <= dmi->dmitable.len) { + dmi_decode(&h, dmi->dmitable.ver, dmi); + } + data = next; + i++; + } +} |