/* ----------------------------------------------------------------------- *
*
* Pportions of this file taken from the dmidecode project
*
* Copyright (C) 2000-2002 Alan Cox <alan@redhat.com>
* Copyright (C) 2002-2008 Jean Delvare <khali@linux-fr.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* For the avoidance of doubt the "preferred form" of this code is one which
* is in an open unpatent encumbered format. Where cryptographic key signing
* forms part of the process of creating an executable the information
* including keys needed to generate an equivalently functional executable
* are deemed to be part of the source code.
*/
#include <dmi/dmi.h>
#include <stdio.h>
void dmi_memory_array_error_handle(uint16_t code, char *array)
{
if (code == 0xFFFE)
sprintf(array, "%s", "Not Provided");
else if (code == 0xFFFF)
sprintf(array, "%s", "No Error");
else
sprintf(array, "0x%04X", code);
}
void dmi_memory_device_width(uint16_t code, char *width)
{
/*
* 3.3.18 Memory Device (Type 17)
* If no memory module is present, width may be 0
*/
if (code == 0xFFFF || code == 0)
sprintf(width, "%s", "Unknown");
else
sprintf(width, "%u bits", code);
}
void dmi_memory_device_size(uint16_t code, char *size)
{
if (code == 0)
sprintf(size, "%s", "Free");
else if (code == 0xFFFF)
sprintf(size, "%s", "Unknown");
else {
if (code & 0x8000)
sprintf(size, "%u kB", code & 0x7FFF);
else
sprintf(size, "%u MB", code);
}
}
const char *dmi_memory_device_form_factor(uint8_t code)
{
/* 3.3.18.1 */
static const char *form_factor[] = {
"Other", /* 0x01 */
"Unknown",
"SIMM",
"SIP",
"Chip",
"DIP",
"ZIP",
"Proprietary Card",
"DIMM",
"TSOP",
"Row Of Chips",
"RIMM",
"SODIMM",
"SRIMM",
"FB-DIMM" /* 0x0F */
};
if (code >= 0x01 && code <= 0x0F)
return form_factor[code - 0x01];
return out_of_spec;
}
void dmi_memory_device_set(uint8_t code, char *set)
{
if (code == 0)
sprintf(set, "%s", "None");
else if (code == 0xFF)
sprintf(set, "%s", "Unknown");
else
sprintf(set, "%u", code);
}
const char *dmi_memory_device_type(uint8_t code)
{
/* 3.3.18.2 */
static const char *type[] = {
"Other", /* 0x01 */
"Unknown",
"DRAM",
"EDRAM",
"VRAM",
"SRAM",
"RAM",
"ROM",
"Flash",
"EEPROM",
"FEPROM",
"EPROM",
"CDRAM",
"3DRAM",
"SDRAM",
"SGRAM",
"RDRAM",
"DDR",
"DDR2",
"DDR2 FB-DIMM" /* 0x14 */
};
if (code >= 0x01 && code <= 0x14)
return type[code - 0x01];
return out_of_spec;
}
void dmi_memory_device_type_detail(uint16_t code, char *type_detail, int sizeof_type_detail)
{
/* 3.3.18.3 */
static const char *detail[] = {
"Other", /* 1 */
"Unknown",
"Fast-paged",
"Static Column",
"Pseudo-static",
"RAMBus",
"Synchronous",
"CMOS",
"EDO",
"Window DRAM",
"Cache DRAM",
"Non-Volatile" /* 12 */
};
if ((code & 0x1FFE) == 0)
sprintf(type_detail, "%s", "None");
else {
int i;
for (i = 1; i <= 12; i++)
if (code & (1 << i))
snprintf(type_detail, sizeof_type_detail, "%s", detail[i - 1]);
}
}
void dmi_memory_device_speed(uint16_t code, char *speed)
{
if (code == 0)
sprintf(speed, "%s", "Unknown");
else
sprintf(speed, "%u MHz", code);
}
/*
* 3.3.7 Memory Module Information (Type 6)
*/
void dmi_memory_module_types(uint16_t code, const char *sep, char *type, int sizeof_type)
{
/* 3.3.7.1 */
static const char *types[] = {
"Other", /* 0 */
"Unknown",
"Standard",
"FPM",
"EDO",
"Parity",
"ECC",
"SIMM",
"DIMM",
"Burst EDO",
"SDRAM" /* 10 */
};
if ((code & 0x07FF) == 0)
sprintf(type, "%s", "None");
else {
int i;
for (i = 0; i <= 10; i++)
if (code & (1 << i))
snprintf(type, sizeof_type, "%s%s%s", type, sep, types[i]);
}
}
void dmi_memory_module_connections(uint8_t code, char *connection, int sizeof_connection)
{
if (code == 0xFF)
sprintf(connection, "%s", "None");
else {
if ((code & 0xF0) != 0xF0)
sprintf(connection, "%u ", code >> 4);
if ((code & 0x0F) != 0x0F)
snprintf(connection, sizeof_connection, "%s%u", connection, code & 0x0F);
}
}
void dmi_memory_module_speed(uint8_t code, char *speed)
{
if (code == 0)
sprintf(speed, "%s", "Unknown");
else
sprintf(speed, "%u ns", code);
}
void dmi_memory_module_size(uint8_t code, char *size, int sizeof_size)
{
/* 3.3.7.2 */
switch (code & 0x7F) {
case 0x7D:
sprintf(size, "%s", "Not Determinable");
break;
case 0x7E:
sprintf(size, "%s", "Disabled");
break;
case 0x7F:
sprintf(size, "%s", "Not Installed");
return;
default:
sprintf(size, "%u MB", 1 << (code & 0x7F));
}
if (code & 0x80)
snprintf(size, sizeof_size, "%s %s", size, "(Double-bank Connection)");
else
snprintf(size, sizeof_size, "%s %s", size, "(Single-bank Connection)");
}
void dmi_memory_module_error(uint8_t code, const char *prefix, char *error)
{
if (code & (1 << 2))
sprintf(error, "%s", "See Event Log\n");
else {
if ((code & 0x03) == 0)
sprintf(error, "%s", "OK\n");
if (code & (1 << 0))
sprintf(error, "%sUncorrectable Errors\n", prefix);
if (code & (1 << 1))
sprintf(error, "%sCorrectable Errors\n", prefix);
}
}
