/* ----------------------------------------------------------------------- *
 *
 *   Copyright 2011 Intel Corporation; author: H. Peter Anvin
 *
 *   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.
 *
 * ----------------------------------------------------------------------- */

/*
 * Search DMI information for specific data or strings
 */

#include <string.h>
#include <stdio.h>
#include <sys/bitops.h>
#include <x86/cpu.h>
#include <syslinux/sysappend.h>
#include "core.h"

struct dmi_table {
    uint8_t type;
    uint8_t length;
    uint16_t handle;
};

struct dmi_header {
    char signature[5];
    uint8_t csum;
    uint16_t tbllen;
    uint32_t tbladdr;
    uint16_t nstruc;
    uint8_t revision;
    uint8_t reserved;
};

struct smbios_header {
    char signature[4];
    uint8_t csum;
    uint8_t len;
    uint8_t major;
    uint8_t minor;
    uint16_t maxsize;
    uint8_t revision;
    uint8_t fmt[5];

    struct dmi_header dmi;
};

static const struct dmi_header *dmi;

static uint8_t checksum(const void *buf, size_t len)
{
    const uint8_t *p = buf;
    uint8_t csum = 0;

    while (len--)
	csum += *p++;

    return csum;
}

static bool is_old_dmi(size_t dptr)
{
    const struct dmi_header *dmi = (void *)dptr;

    return !memcmp(dmi->signature, "_DMI_", 5) &&
	!checksum(dmi, 0x0f);
    return false;
}

static bool is_smbios(size_t dptr)
{
    const struct smbios_header *smb = (void *)dptr;

    return !memcmp(smb->signature, "_SM_", 4) &&
	!checksum(smb, smb->len) &&
	is_old_dmi(dptr+16);
}

/*
 * Find the root structure
 */
static void dmi_find_header(void)
{
    size_t dptr;

    /* Search for _SM_ or _DMI_ structure */
    for (dptr = 0xf0000 ; dptr < 0x100000 ; dptr += 16) {
	if (is_smbios(dptr)) {
	    dmi = (const struct dmi_header *)(dptr + 16);
	    break;
	} else if (is_old_dmi(dptr)) {
	    dmi = (const struct dmi_header *)dptr;
	    break;
	}
    }
}

/*
 * Return a specific data element in a specific table, and verify
 * that it is within the bounds of the table.
 */
static const void *dmi_find_data(uint8_t type, uint8_t base, uint8_t length)
{
    const struct dmi_table *table;
    size_t offset, end;
    unsigned int tblcount;

    if (!dmi)
	return NULL;

    if (base < 2)
	return NULL;

    end = base+length;

    offset = 0;
    tblcount = dmi->nstruc;

    while (offset+6 <= dmi->tbllen && tblcount--) {
	table = (const struct dmi_table *)(dmi->tbladdr + offset);

	if (table->type == 127)	/* End of table */
	    break;
	
	if (table->length < sizeof *table)
	    break;		/* Invalid length */

	offset += table->length;

	if (table->type == type && end <= table->length)
	    return (const char *)table + base;

	/* Search for a double NUL terminating the string table */
	while (offset+2 <= dmi->tbllen &&
	       *(const uint16_t *)(dmi->tbladdr + offset) != 0)
	    offset++;

	offset += 2;
    }

    return NULL;
}

/*
 * Return a specific string in a specific table.
 */
static const char *dmi_find_string(uint8_t type, uint8_t base)
{
    const struct dmi_table *table;
    size_t offset;
    unsigned int tblcount;

    if (!dmi)
	return NULL;

    if (base < 2)
	return NULL;

    offset = 0;
    tblcount = dmi->nstruc;

    while (offset+6 <= dmi->tbllen && tblcount--) {
	table = (const struct dmi_table *)(dmi->tbladdr + offset);

	if (table->type == 127)	/* End of table */
	    break;
	
	if (table->length < sizeof *table)
	    break;		/* Invalid length */

	offset += table->length;

	if (table->type == type && base < table->length) {
	    uint8_t index = ((const uint8_t *)table)[base];
	    const char *p = (const char *)table + table->length;
	    const char *str;
	    char c;

	    if (!index)
		return NULL;	/* String not present */

	    while (--index) {
		if (!*p)
		    return NULL;

		do {
		    if (offset++ >= dmi->tbllen)
			return NULL;
		    c = *p++;
		} while (c);
	    }

	    /* Make sure the string is null-terminated */
	    str = p;
	    do {
		if (offset++ >= dmi->tbllen)
		    return NULL;
		c = *p++;
	    } while (c);
	    return str;
	}

	/* Search for a double NUL terminating the string table */
	while (offset+2 <= dmi->tbllen &&
	       *(const uint16_t *)(dmi->tbladdr + offset) != 0)
	    offset++;

	offset += 2;
    }

    return NULL;
}

struct sysappend_dmi_strings {
    const char *prefix;
    enum syslinux_sysappend sa;
    uint8_t index;
    uint8_t offset;
};

static const struct sysappend_dmi_strings dmi_strings[] = {
    { "SYSVENDOR=",   SYSAPPEND_SYSVENDOR,   1, 0x04 },
    { "SYSPRODUCT=",  SYSAPPEND_SYSPRODUCT,  1, 0x05 },
    { "SYSVERSION=",  SYSAPPEND_SYSVERSION,  1, 0x06 },
    { "SYSSERIAL=",   SYSAPPEND_SYSSERIAL,   1, 0x07 },
    { "SYSSKU=",      SYSAPPEND_SYSSKU,      1, 0x19 },
    { "SYSFAMILY=",   SYSAPPEND_SYSFAMILY,   1, 0x1a },
    { "MBVENDOR=",    SYSAPPEND_MBVENDOR,    2, 0x04 },
    { "MBPRODUCT=",   SYSAPPEND_MBPRODUCT,   2, 0x05 },
    { "MBVERSION=",   SYSAPPEND_MBVERSION,   2, 0x06 },
    { "MBSERIAL=",    SYSAPPEND_MBSERIAL,    2, 0x07 },
    { "MBASSET=",     SYSAPPEND_MBASSET,     2, 0x08 },
    { "BIOSVENDOR=",  SYSAPPEND_BIOSVENDOR,  0, 0x04 },
    { "BIOSVERSION=", SYSAPPEND_BIOSVERSION, 0, 0x05 },
    { NULL, 0, 0, 0 }
};

/*
 * Install the string in the string table, if nonempty, after
 * removing leading and trailing whitespace.
 */
static bool is_ctl_or_whitespace(char c)
{
    return (c <= ' ' || c == '\x7f');
}

static const char *dmi_install_string(const char *pfx, const char *str)
{
    const char *p, *ep;
    size_t pfxlen;
    char *nstr, *q;

    if (!str)
	return NULL;

    while (*str && is_ctl_or_whitespace(*str))
	str++;

    if (!*str)
	return NULL;

    ep = p = str;
    while (*p) {
	if (!is_ctl_or_whitespace(*p))
	    ep = p+1;
	p++;
    }

    pfxlen = strlen(pfx);
    q = nstr = malloc(pfxlen + (ep-str) + 1);
    if (!nstr)
	return NULL;
    memcpy(q, pfx, pfxlen);
    q += pfxlen;
    memcpy(q, str, ep-str);
    q += (ep-str);
    *q = '\0';

    return nstr;
}

static void sysappend_set_sysff(const uint8_t *type)
{
    static char sysff_str[] = "SYSFF=000";

    if (!type || !*type)
	return;
    
    sprintf(sysff_str+6, "%u", *type & 0x7f);
    sysappend_strings[SYSAPPEND_SYSFF] = sysff_str;
}

struct cpuflag {
    uint8_t bit;
    char flag;
};

static void sysappend_set_cpu(void)
{
    static char cpu_str[6+6] = "CPU=";
    char *p = cpu_str + 4;
    static const struct cpuflag cpuflags[] = {
	{ 0*32+ 6, 'P' }, /* PAE */
	{ 1*32+ 5, 'V' }, /* VMX */
	{ 1*32+ 6, 'T' }, /* SMX (TXT) */
	{ 2*32+20, 'X' }, /* XD/NX */
	{ 2*32+29, 'L' }, /* Long mode (x86-64) */
	{ 3*32+ 2, 'S' }, /* SVM */
	{ 0, 0 }
    };
    const struct cpuflag *cf;

    /* Not technically from DMI, but it fit here... */

    if (!cpu_has_eflag(EFLAGS_ID)) {
	/* No CPUID */
	*p++ = cpu_has_eflag(EFLAGS_AC) ? '4' : '3';
    } else {
	uint32_t flags[4], eax, ebx, family;
	uint32_t ext_level;

	cpuid(1, &eax, &ebx, &flags[1], &flags[0]);
	family = (eax & 0x0ff00f00) >> 8;
	*p++ = family >= 6 ? '6' : family + '0';
	
	ext_level = cpuid_eax(0x80000000);
	if (ext_level >= 0x80000001 && ext_level <= 0x8000ffff) {
	    cpuid(0x80000001, &eax, &ebx, &flags[3], &flags[2]);
	} else {
	    flags[2] = flags[3] = 0;
	}

	for (cf = cpuflags; cf->flag; cf++) {
	    if (test_bit(cf->bit, flags))
		*p++ = cf->flag;
	}
    }

    *p = '\0';

    sysappend_strings[SYSAPPEND_CPU] = cpu_str;
}

void dmi_init(void)
{
    const struct sysappend_dmi_strings *ds;

    sysappend_set_cpu();

    dmi_find_header();
    if (!dmi)
	return;

    sysappend_set_uuid(dmi_find_data(1, 0x08, 16));
    sysappend_set_sysff(dmi_find_data(3, 0x05, 1));

    for (ds = dmi_strings; ds->prefix; ds++) {
	if (!sysappend_strings[ds->sa]) {
	    const char *str = dmi_find_string(ds->index, ds->offset);
	    sysappend_strings[ds->sa] = dmi_install_string(ds->prefix, str);
	}
    }
}
