summaryrefslogtreecommitdiff
path: root/core/dmi.c
diff options
context:
space:
mode:
Diffstat (limited to 'core/dmi.c')
-rw-r--r--core/dmi.c383
1 files changed, 383 insertions, 0 deletions
diff --git a/core/dmi.c b/core/dmi.c
new file mode 100644
index 00000000..9cbe2832
--- /dev/null
+++ b/core/dmi.c
@@ -0,0 +1,383 @@
+/* ----------------------------------------------------------------------- *
+ *
+ * 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 <sys/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);
+ }
+ }
+}
View Lorry Controller Status