source: bootcd/isolinux/syslinux-6.03/com32/gpllib/dmi/dmi_memory.c

/* ----------------------------------------------------------------------- *
 *
 *   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 */
        NULL,
        NULL,
        NULL,
        "DDR3",                 /* 0x18 */
        "FBD2"                  /* 0x19 */
    };

    if (code >= 0x01 && code <= 0x19)
        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);
    }
}