2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
2010-10-27 16:32:59 -06:00
|
|
|
#include <linux/ctype.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/dmi.h>
|
[PATCH] ia64: use i386 dmi_scan.c
Enable DMI table parsing on ia64.
Andi Kleen has a patch in his x86_64 tree which enables the use of i386
dmi_scan.c on x86_64. dmi_scan.c functions are being used by the
drivers/char/ipmi/ipmi_si_intf.c driver for autodetecting the ports or
memory spaces where the IPMI controllers may be found.
This patch adds equivalent changes for ia64 as to what is in the x86_64
tree. In addition, I reworked the DMI detection, such that on EFI-capable
systems, it uses the efi.smbios pointer to find the table, rather than
brute-force searching from 0xF0000. On non-EFI systems, it continues the
brute-force search.
My test system, an Intel S870BN4 'Tiger4', aka Dell PowerEdge 7250, with
latest BIOS, does not list the IPMI controller in the ACPI namespace, nor
does it have an ACPI SPMI table. Also note, currently shipping Dell x8xx
EM64T servers don't have these either, so DMI is the only method for
obtaining the address of the IPMI controller.
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Acked-by: "Luck, Tony" <tony.luck@intel.com>
Cc: Andi Kleen <ak@muc.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-26 02:37:03 -07:00
|
|
|
#include <linux/efi.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/bootmem.h>
|
2012-07-20 14:15:20 -06:00
|
|
|
#include <linux/random.h>
|
2006-03-25 08:30:22 -07:00
|
|
|
#include <asm/dmi.h>
|
2013-11-01 14:59:52 -06:00
|
|
|
#include <asm/unaligned.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-06-25 01:06:56 -06:00
|
|
|
struct kobject *dmi_kobj;
|
|
|
|
EXPORT_SYMBOL_GPL(dmi_kobj);
|
|
|
|
|
2008-05-14 09:15:16 -06:00
|
|
|
/*
|
|
|
|
* DMI stands for "Desktop Management Interface". It is part
|
|
|
|
* of and an antecedent to, SMBIOS, which stands for System
|
|
|
|
* Management BIOS. See further: http://www.dmtf.org/standards
|
|
|
|
*/
|
2013-09-11 15:24:09 -06:00
|
|
|
static const char dmi_empty_string[] = " ";
|
2008-01-30 05:31:59 -07:00
|
|
|
|
2015-02-18 04:33:20 -07:00
|
|
|
static u32 dmi_ver __initdata;
|
2015-02-18 04:33:21 -07:00
|
|
|
static u32 dmi_len;
|
|
|
|
static u16 dmi_num;
|
2015-06-25 01:06:56 -06:00
|
|
|
static u8 smbios_entry_point[32];
|
|
|
|
static int smbios_entry_point_size;
|
|
|
|
|
2008-09-18 04:50:18 -06:00
|
|
|
/*
|
|
|
|
* Catch too early calls to dmi_check_system():
|
|
|
|
*/
|
|
|
|
static int dmi_initialized;
|
|
|
|
|
2013-04-30 16:27:14 -06:00
|
|
|
/* DMI system identification string used during boot */
|
|
|
|
static char dmi_ids_string[128] __initdata;
|
|
|
|
|
2013-10-18 15:29:25 -06:00
|
|
|
static struct dmi_memdev_info {
|
|
|
|
const char *device;
|
|
|
|
const char *bank;
|
|
|
|
u16 handle;
|
|
|
|
} *dmi_memdev;
|
|
|
|
static int dmi_memdev_nr;
|
|
|
|
|
2008-02-23 16:23:46 -07:00
|
|
|
static const char * __init dmi_string_nosave(const struct dmi_header *dm, u8 s)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-10-03 13:15:40 -06:00
|
|
|
const u8 *bp = ((u8 *) dm) + dm->length;
|
2005-06-25 15:54:47 -06:00
|
|
|
|
2005-09-06 16:18:28 -06:00
|
|
|
if (s) {
|
2005-04-16 16:20:36 -06:00
|
|
|
s--;
|
2005-09-06 16:18:28 -06:00
|
|
|
while (s > 0 && *bp) {
|
|
|
|
bp += strlen(bp) + 1;
|
|
|
|
s--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*bp != 0) {
|
2008-01-30 05:31:59 -07:00
|
|
|
size_t len = strlen(bp)+1;
|
|
|
|
size_t cmp_len = len > 8 ? 8 : len;
|
|
|
|
|
|
|
|
if (!memcmp(bp, dmi_empty_string, cmp_len))
|
|
|
|
return dmi_empty_string;
|
2008-02-23 16:23:46 -07:00
|
|
|
return bp;
|
2005-09-06 16:18:28 -06:00
|
|
|
}
|
2006-04-03 18:09:22 -06:00
|
|
|
}
|
2005-09-06 16:18:28 -06:00
|
|
|
|
2008-02-23 16:23:46 -07:00
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2013-09-11 15:24:09 -06:00
|
|
|
static const char * __init dmi_string(const struct dmi_header *dm, u8 s)
|
2008-02-23 16:23:46 -07:00
|
|
|
{
|
|
|
|
const char *bp = dmi_string_nosave(dm, s);
|
|
|
|
char *str;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
if (bp == dmi_empty_string)
|
|
|
|
return dmi_empty_string;
|
|
|
|
|
|
|
|
len = strlen(bp) + 1;
|
|
|
|
str = dmi_alloc(len);
|
|
|
|
if (str != NULL)
|
|
|
|
strcpy(str, bp);
|
|
|
|
|
2005-09-06 16:18:28 -06:00
|
|
|
return str;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have to be cautious here. We have seen BIOSes with DMI pointers
|
|
|
|
* pointing to completely the wrong place for example
|
|
|
|
*/
|
2015-06-25 01:06:56 -06:00
|
|
|
static void dmi_decode_table(u8 *buf,
|
|
|
|
void (*decode)(const struct dmi_header *, void *),
|
|
|
|
void *private_data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-11-03 10:29:20 -06:00
|
|
|
u8 *data = buf;
|
2005-06-25 15:54:47 -06:00
|
|
|
int i = 0;
|
2006-04-03 18:09:22 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2015-03-20 02:59:47 -06:00
|
|
|
* Stop when we have seen all the items the table claimed to have
|
2015-06-25 01:06:55 -06:00
|
|
|
* (SMBIOS < 3.0 only) OR we reach an end-of-table marker (SMBIOS
|
|
|
|
* >= 3.0 only) OR we run off the end of the table (should never
|
|
|
|
* happen but sometimes does on bogus implementations.)
|
2006-04-03 18:09:22 -06:00
|
|
|
*/
|
2015-04-13 11:22:30 -06:00
|
|
|
while ((!dmi_num || i < dmi_num) &&
|
|
|
|
(data - buf + sizeof(struct dmi_header)) <= dmi_len) {
|
2007-10-03 13:15:40 -06:00
|
|
|
const struct dmi_header *dm = (const struct dmi_header *)data;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2008-11-07 09:03:46 -07:00
|
|
|
* We want to know the total length (formatted area and
|
|
|
|
* strings) before decoding to make sure we won't run off the
|
|
|
|
* table in dmi_decode or dmi_string
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2005-06-25 15:54:47 -06:00
|
|
|
data += dm->length;
|
2015-02-18 04:33:21 -07:00
|
|
|
while ((data - buf < dmi_len - 1) && (data[0] || data[1]))
|
2005-04-16 16:20:36 -06:00
|
|
|
data++;
|
2015-02-18 04:33:21 -07:00
|
|
|
if (data - buf < dmi_len - 1)
|
2009-03-30 13:46:44 -06:00
|
|
|
decode(dm, private_data);
|
2015-02-18 06:51:41 -07:00
|
|
|
|
2015-06-25 01:06:56 -06:00
|
|
|
data += 2;
|
|
|
|
i++;
|
|
|
|
|
2015-02-18 06:51:41 -07:00
|
|
|
/*
|
|
|
|
* 7.45 End-of-Table (Type 127) [SMBIOS reference spec v3.0.0]
|
2015-06-25 01:06:55 -06:00
|
|
|
* For tables behind a 64-bit entry point, we have no item
|
|
|
|
* count and no exact table length, so stop on end-of-table
|
|
|
|
* marker. For tables behind a 32-bit entry point, we have
|
|
|
|
* seen OEM structures behind the end-of-table marker on
|
|
|
|
* some systems, so don't trust it.
|
2015-02-18 06:51:41 -07:00
|
|
|
*/
|
2015-06-25 01:06:55 -06:00
|
|
|
if (!dmi_num && dm->type == DMI_ENTRY_END_OF_TABLE)
|
2015-02-18 06:51:41 -07:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2015-06-25 01:06:56 -06:00
|
|
|
|
|
|
|
/* Trim DMI table length if needed */
|
|
|
|
if (dmi_len > data - buf)
|
|
|
|
dmi_len = data - buf;
|
2007-11-03 10:29:20 -06:00
|
|
|
}
|
|
|
|
|
2014-10-14 08:41:27 -06:00
|
|
|
static phys_addr_t dmi_base;
|
2007-11-03 10:29:20 -06:00
|
|
|
|
2009-03-30 13:46:44 -06:00
|
|
|
static int __init dmi_walk_early(void (*decode)(const struct dmi_header *,
|
|
|
|
void *))
|
2007-11-03 10:29:20 -06:00
|
|
|
{
|
|
|
|
u8 *buf;
|
2015-06-25 01:06:56 -06:00
|
|
|
u32 orig_dmi_len = dmi_len;
|
2007-11-03 10:29:20 -06:00
|
|
|
|
2015-06-25 01:06:56 -06:00
|
|
|
buf = dmi_early_remap(dmi_base, orig_dmi_len);
|
2007-11-03 10:29:20 -06:00
|
|
|
if (buf == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2015-06-25 01:06:56 -06:00
|
|
|
dmi_decode_table(buf, decode, NULL);
|
2007-11-03 10:29:20 -06:00
|
|
|
|
2012-07-20 14:15:20 -06:00
|
|
|
add_device_randomness(buf, dmi_len);
|
|
|
|
|
2015-06-25 01:06:56 -06:00
|
|
|
dmi_early_unmap(buf, orig_dmi_len);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-12-20 16:05:14 -07:00
|
|
|
static int __init dmi_checksum(const u8 *buf, u8 len)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-06-25 15:54:47 -06:00
|
|
|
u8 sum = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
int a;
|
2006-04-03 18:09:22 -06:00
|
|
|
|
2012-12-20 16:05:14 -07:00
|
|
|
for (a = 0; a < len; a++)
|
2005-06-25 15:54:47 -06:00
|
|
|
sum += buf[a];
|
|
|
|
|
|
|
|
return sum == 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-09-11 15:24:09 -06:00
|
|
|
static const char *dmi_ident[DMI_STRING_MAX];
|
2005-09-06 16:18:29 -06:00
|
|
|
static LIST_HEAD(dmi_devices);
|
2007-05-08 14:07:02 -06:00
|
|
|
int dmi_available;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Save a DMI string
|
|
|
|
*/
|
2013-09-11 15:24:08 -06:00
|
|
|
static void __init dmi_save_ident(const struct dmi_header *dm, int slot,
|
|
|
|
int string)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-09-11 15:24:08 -06:00
|
|
|
const char *d = (const char *) dm;
|
2013-09-11 15:24:09 -06:00
|
|
|
const char *p;
|
2005-06-25 15:54:47 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (dmi_ident[slot])
|
|
|
|
return;
|
2005-06-25 15:54:47 -06:00
|
|
|
|
2005-09-06 16:18:28 -06:00
|
|
|
p = dmi_string(dm, d[string]);
|
|
|
|
if (p == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dmi_ident[slot] = p;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-09-11 15:24:08 -06:00
|
|
|
static void __init dmi_save_uuid(const struct dmi_header *dm, int slot,
|
|
|
|
int index)
|
2007-05-08 14:07:02 -06:00
|
|
|
{
|
2013-09-11 15:24:08 -06:00
|
|
|
const u8 *d = (u8 *) dm + index;
|
2007-05-08 14:07:02 -06:00
|
|
|
char *s;
|
|
|
|
int is_ff = 1, is_00 = 1, i;
|
|
|
|
|
|
|
|
if (dmi_ident[slot])
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < 16 && (is_ff || is_00); i++) {
|
2012-12-20 16:05:13 -07:00
|
|
|
if (d[i] != 0x00)
|
|
|
|
is_00 = 0;
|
|
|
|
if (d[i] != 0xFF)
|
|
|
|
is_ff = 0;
|
2007-05-08 14:07:02 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (is_ff || is_00)
|
|
|
|
return;
|
|
|
|
|
|
|
|
s = dmi_alloc(16*2+4+1);
|
|
|
|
if (!s)
|
|
|
|
return;
|
|
|
|
|
2012-12-20 16:05:13 -07:00
|
|
|
/*
|
|
|
|
* As of version 2.6 of the SMBIOS specification, the first 3 fields of
|
|
|
|
* the UUID are supposed to be little-endian encoded. The specification
|
|
|
|
* says that this is the defacto standard.
|
|
|
|
*/
|
2015-02-18 04:33:20 -07:00
|
|
|
if (dmi_ver >= 0x020600)
|
2012-12-20 16:05:13 -07:00
|
|
|
sprintf(s, "%pUL", d);
|
|
|
|
else
|
|
|
|
sprintf(s, "%pUB", d);
|
2007-05-08 14:07:02 -06:00
|
|
|
|
2013-09-11 15:24:08 -06:00
|
|
|
dmi_ident[slot] = s;
|
2007-05-08 14:07:02 -06:00
|
|
|
}
|
|
|
|
|
2013-09-11 15:24:08 -06:00
|
|
|
static void __init dmi_save_type(const struct dmi_header *dm, int slot,
|
|
|
|
int index)
|
2007-05-08 14:07:02 -06:00
|
|
|
{
|
2013-09-11 15:24:08 -06:00
|
|
|
const u8 *d = (u8 *) dm + index;
|
2007-05-08 14:07:02 -06:00
|
|
|
char *s;
|
|
|
|
|
|
|
|
if (dmi_ident[slot])
|
|
|
|
return;
|
|
|
|
|
|
|
|
s = dmi_alloc(4);
|
|
|
|
if (!s)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sprintf(s, "%u", *d & 0x7F);
|
|
|
|
dmi_ident[slot] = s;
|
|
|
|
}
|
|
|
|
|
2008-02-23 16:23:46 -07:00
|
|
|
static void __init dmi_save_one_device(int type, const char *name)
|
|
|
|
{
|
|
|
|
struct dmi_device *dev;
|
|
|
|
|
|
|
|
/* No duplicate device */
|
|
|
|
if (dmi_find_device(type, name, NULL))
|
|
|
|
return;
|
|
|
|
|
|
|
|
dev = dmi_alloc(sizeof(*dev) + strlen(name) + 1);
|
2013-09-11 15:24:10 -06:00
|
|
|
if (!dev)
|
2008-02-23 16:23:46 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
dev->type = type;
|
|
|
|
strcpy((char *)(dev + 1), name);
|
|
|
|
dev->name = (char *)(dev + 1);
|
|
|
|
dev->device_data = NULL;
|
|
|
|
list_add(&dev->list, &dmi_devices);
|
|
|
|
}
|
|
|
|
|
2007-10-03 13:15:40 -06:00
|
|
|
static void __init dmi_save_devices(const struct dmi_header *dm)
|
2005-09-06 16:18:29 -06:00
|
|
|
{
|
|
|
|
int i, count = (dm->length - sizeof(struct dmi_header)) / 2;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
2007-10-03 13:15:40 -06:00
|
|
|
const char *d = (char *)(dm + 1) + (i * 2);
|
2005-09-06 16:18:29 -06:00
|
|
|
|
|
|
|
/* Skip disabled device */
|
|
|
|
if ((*d & 0x80) == 0)
|
|
|
|
continue;
|
|
|
|
|
2008-02-23 16:23:46 -07:00
|
|
|
dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d + 1)));
|
2006-09-29 02:59:37 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-03 13:15:40 -06:00
|
|
|
static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm)
|
2006-09-29 02:59:37 -06:00
|
|
|
{
|
|
|
|
int i, count = *(u8 *)(dm + 1);
|
|
|
|
struct dmi_device *dev;
|
|
|
|
|
|
|
|
for (i = 1; i <= count; i++) {
|
2013-09-11 15:24:09 -06:00
|
|
|
const char *devname = dmi_string(dm, i);
|
2008-01-30 05:31:59 -07:00
|
|
|
|
2008-02-23 16:23:55 -07:00
|
|
|
if (devname == dmi_empty_string)
|
2008-01-30 05:31:59 -07:00
|
|
|
continue;
|
|
|
|
|
2006-09-29 02:59:37 -06:00
|
|
|
dev = dmi_alloc(sizeof(*dev));
|
2013-09-11 15:24:10 -06:00
|
|
|
if (!dev)
|
2006-09-29 02:59:37 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
dev->type = DMI_DEV_TYPE_OEM_STRING;
|
2008-01-30 05:31:59 -07:00
|
|
|
dev->name = devname;
|
2006-09-29 02:59:37 -06:00
|
|
|
dev->device_data = NULL;
|
2005-09-06 16:18:29 -06:00
|
|
|
|
|
|
|
list_add(&dev->list, &dmi_devices);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-03 13:15:40 -06:00
|
|
|
static void __init dmi_save_ipmi_device(const struct dmi_header *dm)
|
2005-09-06 16:18:29 -06:00
|
|
|
{
|
|
|
|
struct dmi_device *dev;
|
2013-09-11 15:24:08 -06:00
|
|
|
void *data;
|
2005-09-06 16:18:29 -06:00
|
|
|
|
2006-01-11 14:43:33 -07:00
|
|
|
data = dmi_alloc(dm->length);
|
2013-09-11 15:24:10 -06:00
|
|
|
if (data == NULL)
|
2005-09-06 16:18:29 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
memcpy(data, dm, dm->length);
|
|
|
|
|
2006-01-11 14:43:33 -07:00
|
|
|
dev = dmi_alloc(sizeof(*dev));
|
2013-09-11 15:24:10 -06:00
|
|
|
if (!dev)
|
2005-09-06 16:18:29 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
dev->type = DMI_DEV_TYPE_IPMI;
|
|
|
|
dev->name = "IPMI controller";
|
|
|
|
dev->device_data = data;
|
|
|
|
|
2008-04-04 15:30:03 -06:00
|
|
|
list_add_tail(&dev->list, &dmi_devices);
|
2005-09-06 16:18:29 -06:00
|
|
|
}
|
|
|
|
|
2010-07-26 04:56:50 -06:00
|
|
|
static void __init dmi_save_dev_onboard(int instance, int segment, int bus,
|
|
|
|
int devfn, const char *name)
|
|
|
|
{
|
|
|
|
struct dmi_dev_onboard *onboard_dev;
|
|
|
|
|
|
|
|
onboard_dev = dmi_alloc(sizeof(*onboard_dev) + strlen(name) + 1);
|
2013-09-11 15:24:10 -06:00
|
|
|
if (!onboard_dev)
|
2010-07-26 04:56:50 -06:00
|
|
|
return;
|
2013-09-11 15:24:10 -06:00
|
|
|
|
2010-07-26 04:56:50 -06:00
|
|
|
onboard_dev->instance = instance;
|
|
|
|
onboard_dev->segment = segment;
|
|
|
|
onboard_dev->bus = bus;
|
|
|
|
onboard_dev->devfn = devfn;
|
|
|
|
|
|
|
|
strcpy((char *)&onboard_dev[1], name);
|
|
|
|
onboard_dev->dev.type = DMI_DEV_TYPE_DEV_ONBOARD;
|
|
|
|
onboard_dev->dev.name = (char *)&onboard_dev[1];
|
|
|
|
onboard_dev->dev.device_data = onboard_dev;
|
|
|
|
|
|
|
|
list_add(&onboard_dev->dev.list, &dmi_devices);
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:58 -07:00
|
|
|
static void __init dmi_save_extended_devices(const struct dmi_header *dm)
|
|
|
|
{
|
2013-09-11 15:24:08 -06:00
|
|
|
const u8 *d = (u8 *) dm + 5;
|
2008-02-08 05:20:58 -07:00
|
|
|
|
|
|
|
/* Skip disabled device */
|
|
|
|
if ((*d & 0x80) == 0)
|
|
|
|
return;
|
|
|
|
|
2010-07-26 04:56:50 -06:00
|
|
|
dmi_save_dev_onboard(*(d+1), *(u16 *)(d+2), *(d+4), *(d+5),
|
|
|
|
dmi_string_nosave(dm, *(d-1)));
|
2008-02-23 16:23:46 -07:00
|
|
|
dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d - 1)));
|
2008-02-08 05:20:58 -07:00
|
|
|
}
|
|
|
|
|
2013-10-18 15:29:25 -06:00
|
|
|
static void __init count_mem_devices(const struct dmi_header *dm, void *v)
|
|
|
|
{
|
|
|
|
if (dm->type != DMI_ENTRY_MEM_DEVICE)
|
|
|
|
return;
|
|
|
|
dmi_memdev_nr++;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init save_mem_devices(const struct dmi_header *dm, void *v)
|
|
|
|
{
|
|
|
|
const char *d = (const char *)dm;
|
|
|
|
static int nr;
|
|
|
|
|
|
|
|
if (dm->type != DMI_ENTRY_MEM_DEVICE)
|
|
|
|
return;
|
|
|
|
if (nr >= dmi_memdev_nr) {
|
|
|
|
pr_warn(FW_BUG "Too many DIMM entries in SMBIOS table\n");
|
|
|
|
return;
|
|
|
|
}
|
2013-11-01 14:59:52 -06:00
|
|
|
dmi_memdev[nr].handle = get_unaligned(&dm->handle);
|
2013-10-18 15:29:25 -06:00
|
|
|
dmi_memdev[nr].device = dmi_string(dm, d[0x10]);
|
|
|
|
dmi_memdev[nr].bank = dmi_string(dm, d[0x11]);
|
|
|
|
nr++;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init dmi_memdev_walk(void)
|
|
|
|
{
|
|
|
|
if (!dmi_available)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (dmi_walk_early(count_mem_devices) == 0 && dmi_memdev_nr) {
|
|
|
|
dmi_memdev = dmi_alloc(sizeof(*dmi_memdev) * dmi_memdev_nr);
|
|
|
|
if (dmi_memdev)
|
|
|
|
dmi_walk_early(save_mem_devices);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Process a DMI table entry. Right now all we care about are the BIOS
|
|
|
|
* and machine entries. For 2.5 we should pull the smbus controller info
|
|
|
|
* out of here.
|
|
|
|
*/
|
2009-03-30 13:46:44 -06:00
|
|
|
static void __init dmi_decode(const struct dmi_header *dm, void *dummy)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-09-11 15:24:08 -06:00
|
|
|
switch (dm->type) {
|
2005-09-06 16:18:29 -06:00
|
|
|
case 0: /* BIOS Information */
|
2005-06-25 15:54:47 -06:00
|
|
|
dmi_save_ident(dm, DMI_BIOS_VENDOR, 4);
|
|
|
|
dmi_save_ident(dm, DMI_BIOS_VERSION, 5);
|
|
|
|
dmi_save_ident(dm, DMI_BIOS_DATE, 8);
|
|
|
|
break;
|
2005-09-06 16:18:29 -06:00
|
|
|
case 1: /* System Information */
|
2005-06-25 15:54:47 -06:00
|
|
|
dmi_save_ident(dm, DMI_SYS_VENDOR, 4);
|
|
|
|
dmi_save_ident(dm, DMI_PRODUCT_NAME, 5);
|
|
|
|
dmi_save_ident(dm, DMI_PRODUCT_VERSION, 6);
|
|
|
|
dmi_save_ident(dm, DMI_PRODUCT_SERIAL, 7);
|
2007-05-08 14:07:02 -06:00
|
|
|
dmi_save_uuid(dm, DMI_PRODUCT_UUID, 8);
|
2005-06-25 15:54:47 -06:00
|
|
|
break;
|
2005-09-06 16:18:29 -06:00
|
|
|
case 2: /* Base Board Information */
|
2005-06-25 15:54:47 -06:00
|
|
|
dmi_save_ident(dm, DMI_BOARD_VENDOR, 4);
|
|
|
|
dmi_save_ident(dm, DMI_BOARD_NAME, 5);
|
|
|
|
dmi_save_ident(dm, DMI_BOARD_VERSION, 6);
|
2007-05-08 14:07:02 -06:00
|
|
|
dmi_save_ident(dm, DMI_BOARD_SERIAL, 7);
|
|
|
|
dmi_save_ident(dm, DMI_BOARD_ASSET_TAG, 8);
|
|
|
|
break;
|
|
|
|
case 3: /* Chassis Information */
|
|
|
|
dmi_save_ident(dm, DMI_CHASSIS_VENDOR, 4);
|
|
|
|
dmi_save_type(dm, DMI_CHASSIS_TYPE, 5);
|
|
|
|
dmi_save_ident(dm, DMI_CHASSIS_VERSION, 6);
|
|
|
|
dmi_save_ident(dm, DMI_CHASSIS_SERIAL, 7);
|
|
|
|
dmi_save_ident(dm, DMI_CHASSIS_ASSET_TAG, 8);
|
2005-06-25 15:54:47 -06:00
|
|
|
break;
|
2005-09-06 16:18:29 -06:00
|
|
|
case 10: /* Onboard Devices Information */
|
|
|
|
dmi_save_devices(dm);
|
|
|
|
break;
|
2006-09-29 02:59:37 -06:00
|
|
|
case 11: /* OEM Strings */
|
|
|
|
dmi_save_oem_strings_devices(dm);
|
|
|
|
break;
|
2005-09-06 16:18:29 -06:00
|
|
|
case 38: /* IPMI Device Information */
|
|
|
|
dmi_save_ipmi_device(dm);
|
2008-02-08 05:20:58 -07:00
|
|
|
break;
|
|
|
|
case 41: /* Onboard Devices Extended Information */
|
|
|
|
dmi_save_extended_devices(dm);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-30 16:27:14 -06:00
|
|
|
static int __init print_filtered(char *buf, size_t len, const char *info)
|
2010-10-27 16:32:59 -06:00
|
|
|
{
|
2013-04-30 16:27:14 -06:00
|
|
|
int c = 0;
|
2010-10-27 16:32:59 -06:00
|
|
|
const char *p;
|
|
|
|
|
|
|
|
if (!info)
|
2013-04-30 16:27:14 -06:00
|
|
|
return c;
|
2010-10-27 16:32:59 -06:00
|
|
|
|
|
|
|
for (p = info; *p; p++)
|
|
|
|
if (isprint(*p))
|
2013-04-30 16:27:14 -06:00
|
|
|
c += scnprintf(buf + c, len - c, "%c", *p);
|
2010-10-27 16:32:59 -06:00
|
|
|
else
|
2013-04-30 16:27:14 -06:00
|
|
|
c += scnprintf(buf + c, len - c, "\\x%02x", *p & 0xff);
|
|
|
|
return c;
|
2010-10-27 16:32:59 -06:00
|
|
|
}
|
|
|
|
|
2013-04-30 16:27:14 -06:00
|
|
|
static void __init dmi_format_ids(char *buf, size_t len)
|
2010-10-27 16:32:59 -06:00
|
|
|
{
|
2013-04-30 16:27:14 -06:00
|
|
|
int c = 0;
|
2011-02-14 15:47:17 -07:00
|
|
|
const char *board; /* Board Name is optional */
|
|
|
|
|
2013-04-30 16:27:14 -06:00
|
|
|
c += print_filtered(buf + c, len - c,
|
|
|
|
dmi_get_system_info(DMI_SYS_VENDOR));
|
|
|
|
c += scnprintf(buf + c, len - c, " ");
|
|
|
|
c += print_filtered(buf + c, len - c,
|
|
|
|
dmi_get_system_info(DMI_PRODUCT_NAME));
|
|
|
|
|
2011-02-14 15:47:17 -07:00
|
|
|
board = dmi_get_system_info(DMI_BOARD_NAME);
|
|
|
|
if (board) {
|
2013-04-30 16:27:14 -06:00
|
|
|
c += scnprintf(buf + c, len - c, "/");
|
|
|
|
c += print_filtered(buf + c, len - c, board);
|
2011-02-14 15:47:17 -07:00
|
|
|
}
|
2013-04-30 16:27:14 -06:00
|
|
|
c += scnprintf(buf + c, len - c, ", BIOS ");
|
|
|
|
c += print_filtered(buf + c, len - c,
|
|
|
|
dmi_get_system_info(DMI_BIOS_VERSION));
|
|
|
|
c += scnprintf(buf + c, len - c, " ");
|
|
|
|
c += print_filtered(buf + c, len - c,
|
|
|
|
dmi_get_system_info(DMI_BIOS_DATE));
|
2010-10-27 16:32:59 -06:00
|
|
|
}
|
|
|
|
|
2013-07-31 14:53:30 -06:00
|
|
|
/*
|
|
|
|
* Check for DMI/SMBIOS headers in the system firmware image. Any
|
|
|
|
* SMBIOS header must start 16 bytes before the DMI header, so take a
|
|
|
|
* 32 byte buffer and check for DMI at offset 16 and SMBIOS at offset
|
|
|
|
* 0. If the DMI header is present, set dmi_ver accordingly (SMBIOS
|
|
|
|
* takes precedence) and return 0. Otherwise return 1.
|
|
|
|
*/
|
2013-04-30 16:27:46 -06:00
|
|
|
static int __init dmi_present(const u8 *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2015-02-18 04:33:20 -07:00
|
|
|
u32 smbios_ver;
|
2007-10-03 13:15:40 -06:00
|
|
|
|
2013-04-30 16:27:46 -06:00
|
|
|
if (memcmp(buf, "_SM_", 4) == 0 &&
|
|
|
|
buf[5] < 32 && dmi_checksum(buf, buf[5])) {
|
2014-10-14 08:41:27 -06:00
|
|
|
smbios_ver = get_unaligned_be16(buf + 6);
|
2015-06-25 01:06:56 -06:00
|
|
|
smbios_entry_point_size = buf[5];
|
|
|
|
memcpy(smbios_entry_point, buf, smbios_entry_point_size);
|
2013-04-30 16:27:46 -06:00
|
|
|
|
|
|
|
/* Some BIOS report weird SMBIOS version, fix that up */
|
|
|
|
switch (smbios_ver) {
|
|
|
|
case 0x021F:
|
|
|
|
case 0x0221:
|
2015-06-25 01:06:57 -06:00
|
|
|
pr_debug("SMBIOS version fixup (2.%d->2.%d)\n",
|
2013-04-30 16:27:46 -06:00
|
|
|
smbios_ver & 0xFF, 3);
|
|
|
|
smbios_ver = 0x0203;
|
|
|
|
break;
|
|
|
|
case 0x0233:
|
2015-06-25 01:06:57 -06:00
|
|
|
pr_debug("SMBIOS version fixup (2.%d->2.%d)\n", 51, 6);
|
2013-04-30 16:27:46 -06:00
|
|
|
smbios_ver = 0x0206;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
smbios_ver = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
buf += 16;
|
|
|
|
|
|
|
|
if (memcmp(buf, "_DMI_", 5) == 0 && dmi_checksum(buf, 15)) {
|
2015-05-14 06:40:50 -06:00
|
|
|
if (smbios_ver)
|
|
|
|
dmi_ver = smbios_ver;
|
|
|
|
else
|
|
|
|
dmi_ver = (buf[14] & 0xF0) << 4 | (buf[14] & 0x0F);
|
2014-10-14 08:41:27 -06:00
|
|
|
dmi_num = get_unaligned_le16(buf + 12);
|
|
|
|
dmi_len = get_unaligned_le16(buf + 6);
|
|
|
|
dmi_base = get_unaligned_le32(buf + 8);
|
2005-09-06 16:18:26 -06:00
|
|
|
|
2010-10-27 16:32:59 -06:00
|
|
|
if (dmi_walk_early(dmi_decode) == 0) {
|
2013-04-30 16:27:46 -06:00
|
|
|
if (smbios_ver) {
|
2015-05-14 06:40:50 -06:00
|
|
|
pr_info("SMBIOS %d.%d present.\n",
|
|
|
|
dmi_ver >> 8, dmi_ver & 0xFF);
|
2013-04-30 16:27:46 -06:00
|
|
|
} else {
|
2015-06-25 01:06:56 -06:00
|
|
|
smbios_entry_point_size = 15;
|
|
|
|
memcpy(smbios_entry_point, buf,
|
|
|
|
smbios_entry_point_size);
|
2012-12-20 16:05:14 -07:00
|
|
|
pr_info("Legacy DMI %d.%d present.\n",
|
|
|
|
dmi_ver >> 8, dmi_ver & 0xFF);
|
|
|
|
}
|
2015-02-18 04:33:20 -07:00
|
|
|
dmi_ver <<= 8;
|
2013-04-30 16:27:14 -06:00
|
|
|
dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string));
|
|
|
|
printk(KERN_DEBUG "DMI: %s\n", dmi_ids_string);
|
[PATCH] ia64: use i386 dmi_scan.c
Enable DMI table parsing on ia64.
Andi Kleen has a patch in his x86_64 tree which enables the use of i386
dmi_scan.c on x86_64. dmi_scan.c functions are being used by the
drivers/char/ipmi/ipmi_si_intf.c driver for autodetecting the ports or
memory spaces where the IPMI controllers may be found.
This patch adds equivalent changes for ia64 as to what is in the x86_64
tree. In addition, I reworked the DMI detection, such that on EFI-capable
systems, it uses the efi.smbios pointer to find the table, rather than
brute-force searching from 0xF0000. On non-EFI systems, it continues the
brute-force search.
My test system, an Intel S870BN4 'Tiger4', aka Dell PowerEdge 7250, with
latest BIOS, does not list the IPMI controller in the ACPI namespace, nor
does it have an ACPI SPMI table. Also note, currently shipping Dell x8xx
EM64T servers don't have these either, so DMI is the only method for
obtaining the address of the IPMI controller.
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Acked-by: "Luck, Tony" <tony.luck@intel.com>
Cc: Andi Kleen <ak@muc.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-26 02:37:03 -07:00
|
|
|
return 0;
|
2010-10-27 16:32:59 -06:00
|
|
|
}
|
[PATCH] ia64: use i386 dmi_scan.c
Enable DMI table parsing on ia64.
Andi Kleen has a patch in his x86_64 tree which enables the use of i386
dmi_scan.c on x86_64. dmi_scan.c functions are being used by the
drivers/char/ipmi/ipmi_si_intf.c driver for autodetecting the ports or
memory spaces where the IPMI controllers may be found.
This patch adds equivalent changes for ia64 as to what is in the x86_64
tree. In addition, I reworked the DMI detection, such that on EFI-capable
systems, it uses the efi.smbios pointer to find the table, rather than
brute-force searching from 0xF0000. On non-EFI systems, it continues the
brute-force search.
My test system, an Intel S870BN4 'Tiger4', aka Dell PowerEdge 7250, with
latest BIOS, does not list the IPMI controller in the ACPI namespace, nor
does it have an ACPI SPMI table. Also note, currently shipping Dell x8xx
EM64T servers don't have these either, so DMI is the only method for
obtaining the address of the IPMI controller.
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Acked-by: "Luck, Tony" <tony.luck@intel.com>
Cc: Andi Kleen <ak@muc.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-26 02:37:03 -07:00
|
|
|
}
|
2005-09-06 16:18:26 -06:00
|
|
|
|
2013-03-08 13:43:32 -07:00
|
|
|
return 1;
|
2012-12-20 16:05:14 -07:00
|
|
|
}
|
|
|
|
|
2014-10-14 08:41:27 -06:00
|
|
|
/*
|
|
|
|
* Check for the SMBIOS 3.0 64-bit entry point signature. Unlike the legacy
|
|
|
|
* 32-bit entry point, there is no embedded DMI header (_DMI_) in here.
|
|
|
|
*/
|
|
|
|
static int __init dmi_smbios3_present(const u8 *buf)
|
|
|
|
{
|
|
|
|
if (memcmp(buf, "_SM3_", 5) == 0 &&
|
|
|
|
buf[6] < 32 && dmi_checksum(buf, buf[6])) {
|
2015-06-25 01:06:57 -06:00
|
|
|
dmi_ver = get_unaligned_be32(buf + 6) & 0xFFFFFF;
|
2015-03-20 02:59:47 -06:00
|
|
|
dmi_num = 0; /* No longer specified */
|
2014-10-14 08:41:27 -06:00
|
|
|
dmi_len = get_unaligned_le32(buf + 12);
|
|
|
|
dmi_base = get_unaligned_le64(buf + 16);
|
2015-06-25 01:06:56 -06:00
|
|
|
smbios_entry_point_size = buf[6];
|
|
|
|
memcpy(smbios_entry_point, buf, smbios_entry_point_size);
|
2014-10-14 08:41:27 -06:00
|
|
|
|
|
|
|
if (dmi_walk_early(dmi_decode) == 0) {
|
2015-02-18 04:33:20 -07:00
|
|
|
pr_info("SMBIOS %d.%d.%d present.\n",
|
|
|
|
dmi_ver >> 16, (dmi_ver >> 8) & 0xFF,
|
|
|
|
dmi_ver & 0xFF);
|
2014-10-14 08:41:27 -06:00
|
|
|
dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string));
|
|
|
|
pr_debug("DMI: %s\n", dmi_ids_string);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
[PATCH] ia64: use i386 dmi_scan.c
Enable DMI table parsing on ia64.
Andi Kleen has a patch in his x86_64 tree which enables the use of i386
dmi_scan.c on x86_64. dmi_scan.c functions are being used by the
drivers/char/ipmi/ipmi_si_intf.c driver for autodetecting the ports or
memory spaces where the IPMI controllers may be found.
This patch adds equivalent changes for ia64 as to what is in the x86_64
tree. In addition, I reworked the DMI detection, such that on EFI-capable
systems, it uses the efi.smbios pointer to find the table, rather than
brute-force searching from 0xF0000. On non-EFI systems, it continues the
brute-force search.
My test system, an Intel S870BN4 'Tiger4', aka Dell PowerEdge 7250, with
latest BIOS, does not list the IPMI controller in the ACPI namespace, nor
does it have an ACPI SPMI table. Also note, currently shipping Dell x8xx
EM64T servers don't have these either, so DMI is the only method for
obtaining the address of the IPMI controller.
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Acked-by: "Luck, Tony" <tony.luck@intel.com>
Cc: Andi Kleen <ak@muc.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-26 02:37:03 -07:00
|
|
|
void __init dmi_scan_machine(void)
|
|
|
|
{
|
|
|
|
char __iomem *p, *q;
|
2013-04-30 16:27:46 -06:00
|
|
|
char buf[32];
|
[PATCH] ia64: use i386 dmi_scan.c
Enable DMI table parsing on ia64.
Andi Kleen has a patch in his x86_64 tree which enables the use of i386
dmi_scan.c on x86_64. dmi_scan.c functions are being used by the
drivers/char/ipmi/ipmi_si_intf.c driver for autodetecting the ports or
memory spaces where the IPMI controllers may be found.
This patch adds equivalent changes for ia64 as to what is in the x86_64
tree. In addition, I reworked the DMI detection, such that on EFI-capable
systems, it uses the efi.smbios pointer to find the table, rather than
brute-force searching from 0xF0000. On non-EFI systems, it continues the
brute-force search.
My test system, an Intel S870BN4 'Tiger4', aka Dell PowerEdge 7250, with
latest BIOS, does not list the IPMI controller in the ACPI namespace, nor
does it have an ACPI SPMI table. Also note, currently shipping Dell x8xx
EM64T servers don't have these either, so DMI is the only method for
obtaining the address of the IPMI controller.
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Acked-by: "Luck, Tony" <tony.luck@intel.com>
Cc: Andi Kleen <ak@muc.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-26 02:37:03 -07:00
|
|
|
|
2012-11-14 02:42:35 -07:00
|
|
|
if (efi_enabled(EFI_CONFIG_TABLES)) {
|
2014-10-14 08:41:27 -06:00
|
|
|
/*
|
|
|
|
* According to the DMTF SMBIOS reference spec v3.0.0, it is
|
|
|
|
* allowed to define both the 64-bit entry point (smbios3) and
|
|
|
|
* the 32-bit entry point (smbios), in which case they should
|
|
|
|
* either both point to the same SMBIOS structure table, or the
|
|
|
|
* table pointed to by the 64-bit entry point should contain a
|
|
|
|
* superset of the table contents pointed to by the 32-bit entry
|
|
|
|
* point (section 5.2)
|
|
|
|
* This implies that the 64-bit entry point should have
|
|
|
|
* precedence if it is defined and supported by the OS. If we
|
|
|
|
* have the 64-bit entry point, but fail to decode it, fall
|
|
|
|
* back to the legacy one (if available)
|
|
|
|
*/
|
|
|
|
if (efi.smbios3 != EFI_INVALID_TABLE_ADDR) {
|
|
|
|
p = dmi_early_remap(efi.smbios3, 32);
|
|
|
|
if (p == NULL)
|
|
|
|
goto error;
|
|
|
|
memcpy_fromio(buf, p, 32);
|
|
|
|
dmi_early_unmap(p, 32);
|
|
|
|
|
|
|
|
if (!dmi_smbios3_present(buf)) {
|
|
|
|
dmi_available = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2006-03-26 02:37:08 -07:00
|
|
|
if (efi.smbios == EFI_INVALID_TABLE_ADDR)
|
2008-09-18 04:50:18 -06:00
|
|
|
goto error;
|
[PATCH] ia64: use i386 dmi_scan.c
Enable DMI table parsing on ia64.
Andi Kleen has a patch in his x86_64 tree which enables the use of i386
dmi_scan.c on x86_64. dmi_scan.c functions are being used by the
drivers/char/ipmi/ipmi_si_intf.c driver for autodetecting the ports or
memory spaces where the IPMI controllers may be found.
This patch adds equivalent changes for ia64 as to what is in the x86_64
tree. In addition, I reworked the DMI detection, such that on EFI-capable
systems, it uses the efi.smbios pointer to find the table, rather than
brute-force searching from 0xF0000. On non-EFI systems, it continues the
brute-force search.
My test system, an Intel S870BN4 'Tiger4', aka Dell PowerEdge 7250, with
latest BIOS, does not list the IPMI controller in the ACPI namespace, nor
does it have an ACPI SPMI table. Also note, currently shipping Dell x8xx
EM64T servers don't have these either, so DMI is the only method for
obtaining the address of the IPMI controller.
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Acked-by: "Luck, Tony" <tony.luck@intel.com>
Cc: Andi Kleen <ak@muc.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-26 02:37:03 -07:00
|
|
|
|
2007-05-08 14:07:02 -06:00
|
|
|
/* This is called as a core_initcall() because it isn't
|
|
|
|
* needed during early boot. This also means we can
|
|
|
|
* iounmap the space when we're done with it.
|
|
|
|
*/
|
2014-01-23 16:54:39 -07:00
|
|
|
p = dmi_early_remap(efi.smbios, 32);
|
[PATCH] ia64: use i386 dmi_scan.c
Enable DMI table parsing on ia64.
Andi Kleen has a patch in his x86_64 tree which enables the use of i386
dmi_scan.c on x86_64. dmi_scan.c functions are being used by the
drivers/char/ipmi/ipmi_si_intf.c driver for autodetecting the ports or
memory spaces where the IPMI controllers may be found.
This patch adds equivalent changes for ia64 as to what is in the x86_64
tree. In addition, I reworked the DMI detection, such that on EFI-capable
systems, it uses the efi.smbios pointer to find the table, rather than
brute-force searching from 0xF0000. On non-EFI systems, it continues the
brute-force search.
My test system, an Intel S870BN4 'Tiger4', aka Dell PowerEdge 7250, with
latest BIOS, does not list the IPMI controller in the ACPI namespace, nor
does it have an ACPI SPMI table. Also note, currently shipping Dell x8xx
EM64T servers don't have these either, so DMI is the only method for
obtaining the address of the IPMI controller.
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Acked-by: "Luck, Tony" <tony.luck@intel.com>
Cc: Andi Kleen <ak@muc.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-26 02:37:03 -07:00
|
|
|
if (p == NULL)
|
2008-09-18 04:50:18 -06:00
|
|
|
goto error;
|
2013-04-30 16:27:46 -06:00
|
|
|
memcpy_fromio(buf, p, 32);
|
2014-01-23 16:54:39 -07:00
|
|
|
dmi_early_unmap(p, 32);
|
2013-04-30 16:27:46 -06:00
|
|
|
|
|
|
|
if (!dmi_present(buf)) {
|
2007-05-08 14:07:02 -06:00
|
|
|
dmi_available = 1;
|
2008-09-18 04:50:18 -06:00
|
|
|
goto out;
|
2007-05-08 14:07:02 -06:00
|
|
|
}
|
2014-01-23 16:54:39 -07:00
|
|
|
} else if (IS_ENABLED(CONFIG_DMI_SCAN_MACHINE_NON_EFI_FALLBACK)) {
|
|
|
|
p = dmi_early_remap(0xF0000, 0x10000);
|
[PATCH] ia64: use i386 dmi_scan.c
Enable DMI table parsing on ia64.
Andi Kleen has a patch in his x86_64 tree which enables the use of i386
dmi_scan.c on x86_64. dmi_scan.c functions are being used by the
drivers/char/ipmi/ipmi_si_intf.c driver for autodetecting the ports or
memory spaces where the IPMI controllers may be found.
This patch adds equivalent changes for ia64 as to what is in the x86_64
tree. In addition, I reworked the DMI detection, such that on EFI-capable
systems, it uses the efi.smbios pointer to find the table, rather than
brute-force searching from 0xF0000. On non-EFI systems, it continues the
brute-force search.
My test system, an Intel S870BN4 'Tiger4', aka Dell PowerEdge 7250, with
latest BIOS, does not list the IPMI controller in the ACPI namespace, nor
does it have an ACPI SPMI table. Also note, currently shipping Dell x8xx
EM64T servers don't have these either, so DMI is the only method for
obtaining the address of the IPMI controller.
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Acked-by: "Luck, Tony" <tony.luck@intel.com>
Cc: Andi Kleen <ak@muc.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-26 02:37:03 -07:00
|
|
|
if (p == NULL)
|
2008-09-18 04:50:18 -06:00
|
|
|
goto error;
|
[PATCH] ia64: use i386 dmi_scan.c
Enable DMI table parsing on ia64.
Andi Kleen has a patch in his x86_64 tree which enables the use of i386
dmi_scan.c on x86_64. dmi_scan.c functions are being used by the
drivers/char/ipmi/ipmi_si_intf.c driver for autodetecting the ports or
memory spaces where the IPMI controllers may be found.
This patch adds equivalent changes for ia64 as to what is in the x86_64
tree. In addition, I reworked the DMI detection, such that on EFI-capable
systems, it uses the efi.smbios pointer to find the table, rather than
brute-force searching from 0xF0000. On non-EFI systems, it continues the
brute-force search.
My test system, an Intel S870BN4 'Tiger4', aka Dell PowerEdge 7250, with
latest BIOS, does not list the IPMI controller in the ACPI namespace, nor
does it have an ACPI SPMI table. Also note, currently shipping Dell x8xx
EM64T servers don't have these either, so DMI is the only method for
obtaining the address of the IPMI controller.
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Acked-by: "Luck, Tony" <tony.luck@intel.com>
Cc: Andi Kleen <ak@muc.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-26 02:37:03 -07:00
|
|
|
|
2013-07-31 14:53:30 -06:00
|
|
|
/*
|
|
|
|
* Iterate over all possible DMI header addresses q.
|
|
|
|
* Maintain the 32 bytes around q in buf. On the
|
|
|
|
* first iteration, substitute zero for the
|
|
|
|
* out-of-range bytes so there is no chance of falsely
|
|
|
|
* detecting an SMBIOS header.
|
|
|
|
*/
|
2013-04-30 16:27:46 -06:00
|
|
|
memset(buf, 0, 16);
|
[PATCH] ia64: use i386 dmi_scan.c
Enable DMI table parsing on ia64.
Andi Kleen has a patch in his x86_64 tree which enables the use of i386
dmi_scan.c on x86_64. dmi_scan.c functions are being used by the
drivers/char/ipmi/ipmi_si_intf.c driver for autodetecting the ports or
memory spaces where the IPMI controllers may be found.
This patch adds equivalent changes for ia64 as to what is in the x86_64
tree. In addition, I reworked the DMI detection, such that on EFI-capable
systems, it uses the efi.smbios pointer to find the table, rather than
brute-force searching from 0xF0000. On non-EFI systems, it continues the
brute-force search.
My test system, an Intel S870BN4 'Tiger4', aka Dell PowerEdge 7250, with
latest BIOS, does not list the IPMI controller in the ACPI namespace, nor
does it have an ACPI SPMI table. Also note, currently shipping Dell x8xx
EM64T servers don't have these either, so DMI is the only method for
obtaining the address of the IPMI controller.
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Acked-by: "Luck, Tony" <tony.luck@intel.com>
Cc: Andi Kleen <ak@muc.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-26 02:37:03 -07:00
|
|
|
for (q = p; q < p + 0x10000; q += 16) {
|
2013-04-30 16:27:46 -06:00
|
|
|
memcpy_fromio(buf + 16, q, 16);
|
2014-10-14 08:41:27 -06:00
|
|
|
if (!dmi_smbios3_present(buf) || !dmi_present(buf)) {
|
2007-05-08 14:07:02 -06:00
|
|
|
dmi_available = 1;
|
2014-01-23 16:54:39 -07:00
|
|
|
dmi_early_unmap(p, 0x10000);
|
2008-09-18 04:50:18 -06:00
|
|
|
goto out;
|
2007-05-08 14:07:02 -06:00
|
|
|
}
|
2013-04-30 16:27:46 -06:00
|
|
|
memcpy(buf, buf + 16, 16);
|
2005-09-06 16:18:26 -06:00
|
|
|
}
|
2014-01-23 16:54:39 -07:00
|
|
|
dmi_early_unmap(p, 0x10000);
|
2005-09-06 16:18:26 -06:00
|
|
|
}
|
2008-09-18 04:50:18 -06:00
|
|
|
error:
|
2013-09-11 15:24:08 -06:00
|
|
|
pr_info("DMI not present or invalid.\n");
|
2008-09-18 04:50:18 -06:00
|
|
|
out:
|
|
|
|
dmi_initialized = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2015-06-25 01:06:56 -06:00
|
|
|
static ssize_t raw_table_read(struct file *file, struct kobject *kobj,
|
|
|
|
struct bin_attribute *attr, char *buf,
|
|
|
|
loff_t pos, size_t count)
|
|
|
|
{
|
|
|
|
memcpy(buf, attr->private + pos, count);
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static BIN_ATTR(smbios_entry_point, S_IRUSR, raw_table_read, NULL, 0);
|
|
|
|
static BIN_ATTR(DMI, S_IRUSR, raw_table_read, NULL, 0);
|
|
|
|
|
|
|
|
static int __init dmi_init(void)
|
|
|
|
{
|
|
|
|
struct kobject *tables_kobj;
|
|
|
|
u8 *dmi_table;
|
|
|
|
int ret = -ENOMEM;
|
|
|
|
|
|
|
|
if (!dmi_available) {
|
|
|
|
ret = -ENODATA;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up dmi directory at /sys/firmware/dmi. This entry should stay
|
|
|
|
* even after farther error, as it can be used by other modules like
|
|
|
|
* dmi-sysfs.
|
|
|
|
*/
|
|
|
|
dmi_kobj = kobject_create_and_add("dmi", firmware_kobj);
|
|
|
|
if (!dmi_kobj)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
tables_kobj = kobject_create_and_add("tables", dmi_kobj);
|
|
|
|
if (!tables_kobj)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
dmi_table = dmi_remap(dmi_base, dmi_len);
|
|
|
|
if (!dmi_table)
|
|
|
|
goto err_tables;
|
|
|
|
|
|
|
|
bin_attr_smbios_entry_point.size = smbios_entry_point_size;
|
|
|
|
bin_attr_smbios_entry_point.private = smbios_entry_point;
|
|
|
|
ret = sysfs_create_bin_file(tables_kobj, &bin_attr_smbios_entry_point);
|
|
|
|
if (ret)
|
|
|
|
goto err_unmap;
|
|
|
|
|
|
|
|
bin_attr_DMI.size = dmi_len;
|
|
|
|
bin_attr_DMI.private = dmi_table;
|
|
|
|
ret = sysfs_create_bin_file(tables_kobj, &bin_attr_DMI);
|
|
|
|
if (!ret)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
sysfs_remove_bin_file(tables_kobj,
|
|
|
|
&bin_attr_smbios_entry_point);
|
|
|
|
err_unmap:
|
|
|
|
dmi_unmap(dmi_table);
|
|
|
|
err_tables:
|
|
|
|
kobject_del(tables_kobj);
|
|
|
|
kobject_put(tables_kobj);
|
|
|
|
err:
|
|
|
|
pr_err("dmi: Firmware registration failed.\n");
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
subsys_initcall(dmi_init);
|
|
|
|
|
2013-04-30 16:27:15 -06:00
|
|
|
/**
|
|
|
|
* dmi_set_dump_stack_arch_desc - set arch description for dump_stack()
|
|
|
|
*
|
|
|
|
* Invoke dump_stack_set_arch_desc() with DMI system information so that
|
|
|
|
* DMI identifiers are printed out on task dumps. Arch boot code should
|
|
|
|
* call this function after dmi_scan_machine() if it wants to print out DMI
|
|
|
|
* identifiers on task dumps.
|
|
|
|
*/
|
|
|
|
void __init dmi_set_dump_stack_arch_desc(void)
|
|
|
|
{
|
|
|
|
dump_stack_set_arch_desc("%s", dmi_ids_string);
|
|
|
|
}
|
|
|
|
|
2009-01-19 12:55:50 -07:00
|
|
|
/**
|
|
|
|
* dmi_matches - check if dmi_system_id structure matches system DMI data
|
|
|
|
* @dmi: pointer to the dmi_system_id structure to check
|
|
|
|
*/
|
|
|
|
static bool dmi_matches(const struct dmi_system_id *dmi)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
WARN(!dmi_initialized, KERN_ERR "dmi check: not initialized yet.\n");
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(dmi->matches); i++) {
|
|
|
|
int s = dmi->matches[i].slot;
|
|
|
|
if (s == DMI_NONE)
|
2009-12-04 11:24:19 -07:00
|
|
|
break;
|
2013-07-03 16:05:02 -06:00
|
|
|
if (dmi_ident[s]) {
|
|
|
|
if (!dmi->matches[i].exact_match &&
|
|
|
|
strstr(dmi_ident[s], dmi->matches[i].substr))
|
|
|
|
continue;
|
|
|
|
else if (dmi->matches[i].exact_match &&
|
|
|
|
!strcmp(dmi_ident[s], dmi->matches[i].substr))
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2009-01-19 12:55:50 -07:00
|
|
|
/* No match */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-12-04 11:24:19 -07:00
|
|
|
/**
|
|
|
|
* dmi_is_end_of_table - check for end-of-table marker
|
|
|
|
* @dmi: pointer to the dmi_system_id structure to check
|
|
|
|
*/
|
|
|
|
static bool dmi_is_end_of_table(const struct dmi_system_id *dmi)
|
|
|
|
{
|
|
|
|
return dmi->matches[0].slot == DMI_NONE;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* dmi_check_system - check system DMI data
|
|
|
|
* @list: array of dmi_system_id structures to match against
|
2006-06-25 06:49:18 -06:00
|
|
|
* All non-null elements of the list must match
|
|
|
|
* their slot's (field index's) data (i.e., each
|
|
|
|
* list string must be a substring of the specified
|
|
|
|
* DMI slot's string data) to be considered a
|
|
|
|
* successful match.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Walk the blacklist table running matching functions until someone
|
|
|
|
* returns non zero or we hit the end. Callback function is called for
|
2006-06-25 06:49:18 -06:00
|
|
|
* each successful match. Returns the number of matches.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-10-03 13:15:40 -06:00
|
|
|
int dmi_check_system(const struct dmi_system_id *list)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-01-19 12:55:50 -07:00
|
|
|
int count = 0;
|
|
|
|
const struct dmi_system_id *d;
|
|
|
|
|
2009-12-04 11:24:19 -07:00
|
|
|
for (d = list; !dmi_is_end_of_table(d); d++)
|
2009-01-19 12:55:50 -07:00
|
|
|
if (dmi_matches(d)) {
|
|
|
|
count++;
|
|
|
|
if (d->callback && d->callback(d))
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dmi_check_system);
|
|
|
|
|
2009-01-19 12:55:50 -07:00
|
|
|
/**
|
|
|
|
* dmi_first_match - find dmi_system_id structure matching system DMI data
|
|
|
|
* @list: array of dmi_system_id structures to match against
|
|
|
|
* All non-null elements of the list must match
|
|
|
|
* their slot's (field index's) data (i.e., each
|
|
|
|
* list string must be a substring of the specified
|
|
|
|
* DMI slot's string data) to be considered a
|
|
|
|
* successful match.
|
|
|
|
*
|
|
|
|
* Walk the blacklist table until the first match is found. Return the
|
|
|
|
* pointer to the matching entry or NULL if there's no match.
|
|
|
|
*/
|
|
|
|
const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list)
|
|
|
|
{
|
|
|
|
const struct dmi_system_id *d;
|
|
|
|
|
2009-12-04 11:24:19 -07:00
|
|
|
for (d = list; !dmi_is_end_of_table(d); d++)
|
2009-01-19 12:55:50 -07:00
|
|
|
if (dmi_matches(d))
|
|
|
|
return d;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dmi_first_match);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* dmi_get_system_info - return DMI data value
|
2006-06-25 06:49:18 -06:00
|
|
|
* @field: data index (see enum dmi_field)
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Returns one DMI data value, can be used to perform
|
|
|
|
* complex DMI data checks.
|
|
|
|
*/
|
2007-10-03 13:15:40 -06:00
|
|
|
const char *dmi_get_system_info(int field)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return dmi_ident[field];
|
|
|
|
}
|
2005-06-25 15:54:25 -06:00
|
|
|
EXPORT_SYMBOL(dmi_get_system_info);
|
2005-09-06 16:18:29 -06:00
|
|
|
|
2008-11-03 16:50:38 -07:00
|
|
|
/**
|
2009-01-06 15:41:40 -07:00
|
|
|
* dmi_name_in_serial - Check if string is in the DMI product serial information
|
|
|
|
* @str: string to check for
|
2008-11-03 16:50:38 -07:00
|
|
|
*/
|
|
|
|
int dmi_name_in_serial(const char *str)
|
|
|
|
{
|
|
|
|
int f = DMI_PRODUCT_SERIAL;
|
|
|
|
if (dmi_ident[f] && strstr(dmi_ident[f], str))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2006-10-21 10:37:02 -06:00
|
|
|
|
|
|
|
/**
|
drivers/firmware/dmi_scan.c: make dmi_name_in_vendors more focused
The current implementation of dmi_name_in_vendors() is an invitation to
lazy coding and false positives [1]. Searching for a string in 8 know
what you're looking for, so you should know where to look. strstr isn't
fast, especially when it fails, so we should avoid calling it when it
just can't succeed.
Looking at the current users of the function, it seems clear to me that
they are looking for a system or board vendor name, so let's limit
dmi_name_in_vendors to these two DMI fields. This much better matches
the function name, BTW.
[1] We currently have code looking for short names in DMI data, such as
"IBM", "ASUS" or "Acer". I let you guess what will happen the day other
vendors ship products named, for example, "SCHREIBMEISTER", "PEGASUS" or
"Acerola".
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Cc: Andi Kleen <andi@firstfloor.org>
Cc: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-11-15 15:36:09 -07:00
|
|
|
* dmi_name_in_vendors - Check if string is in the DMI system or board vendor name
|
2013-09-11 15:24:08 -06:00
|
|
|
* @str: Case sensitive Name
|
2006-10-21 10:37:02 -06:00
|
|
|
*/
|
2007-10-03 13:15:40 -06:00
|
|
|
int dmi_name_in_vendors(const char *str)
|
2006-10-21 10:37:02 -06:00
|
|
|
{
|
drivers/firmware/dmi_scan.c: make dmi_name_in_vendors more focused
The current implementation of dmi_name_in_vendors() is an invitation to
lazy coding and false positives [1]. Searching for a string in 8 know
what you're looking for, so you should know where to look. strstr isn't
fast, especially when it fails, so we should avoid calling it when it
just can't succeed.
Looking at the current users of the function, it seems clear to me that
they are looking for a system or board vendor name, so let's limit
dmi_name_in_vendors to these two DMI fields. This much better matches
the function name, BTW.
[1] We currently have code looking for short names in DMI data, such as
"IBM", "ASUS" or "Acer". I let you guess what will happen the day other
vendors ship products named, for example, "SCHREIBMEISTER", "PEGASUS" or
"Acerola".
Signed-off-by: Jean Delvare <khali@linux-fr.org>
Cc: Andi Kleen <andi@firstfloor.org>
Cc: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-11-15 15:36:09 -07:00
|
|
|
static int fields[] = { DMI_SYS_VENDOR, DMI_BOARD_VENDOR, DMI_NONE };
|
2006-10-21 10:37:02 -06:00
|
|
|
int i;
|
|
|
|
for (i = 0; fields[i] != DMI_NONE; i++) {
|
|
|
|
int f = fields[i];
|
|
|
|
if (dmi_ident[f] && strstr(dmi_ident[f], str))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dmi_name_in_vendors);
|
|
|
|
|
2005-09-06 16:18:29 -06:00
|
|
|
/**
|
|
|
|
* dmi_find_device - find onboard device by type/name
|
|
|
|
* @type: device type or %DMI_DEV_TYPE_ANY to match all device types
|
2006-06-25 06:49:18 -06:00
|
|
|
* @name: device name string or %NULL to match all
|
2005-09-06 16:18:29 -06:00
|
|
|
* @from: previous device found in search, or %NULL for new search.
|
|
|
|
*
|
|
|
|
* Iterates through the list of known onboard devices. If a device is
|
|
|
|
* found with a matching @vendor and @device, a pointer to its device
|
|
|
|
* structure is returned. Otherwise, %NULL is returned.
|
2006-06-25 06:49:18 -06:00
|
|
|
* A new search is initiated by passing %NULL as the @from argument.
|
2005-09-06 16:18:29 -06:00
|
|
|
* If @from is not %NULL, searches continue from next device.
|
|
|
|
*/
|
2013-09-11 15:24:08 -06:00
|
|
|
const struct dmi_device *dmi_find_device(int type, const char *name,
|
2007-10-03 13:15:40 -06:00
|
|
|
const struct dmi_device *from)
|
2005-09-06 16:18:29 -06:00
|
|
|
{
|
2007-10-03 13:15:40 -06:00
|
|
|
const struct list_head *head = from ? &from->list : &dmi_devices;
|
|
|
|
struct list_head *d;
|
2005-09-06 16:18:29 -06:00
|
|
|
|
2013-09-11 15:24:08 -06:00
|
|
|
for (d = head->next; d != &dmi_devices; d = d->next) {
|
2007-10-03 13:15:40 -06:00
|
|
|
const struct dmi_device *dev =
|
|
|
|
list_entry(d, struct dmi_device, list);
|
2005-09-06 16:18:29 -06:00
|
|
|
|
|
|
|
if (((type == DMI_DEV_TYPE_ANY) || (dev->type == type)) &&
|
|
|
|
((name == NULL) || (strcmp(dev->name, name) == 0)))
|
|
|
|
return dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dmi_find_device);
|
2006-03-25 08:30:19 -07:00
|
|
|
|
|
|
|
/**
|
2009-08-16 06:02:36 -06:00
|
|
|
* dmi_get_date - parse a DMI date
|
|
|
|
* @field: data index (see enum dmi_field)
|
|
|
|
* @yearp: optional out parameter for the year
|
|
|
|
* @monthp: optional out parameter for the month
|
|
|
|
* @dayp: optional out parameter for the day
|
2006-03-25 08:30:19 -07:00
|
|
|
*
|
2009-08-16 06:02:36 -06:00
|
|
|
* The date field is assumed to be in the form resembling
|
|
|
|
* [mm[/dd]]/yy[yy] and the result is stored in the out
|
|
|
|
* parameters any or all of which can be omitted.
|
|
|
|
*
|
|
|
|
* If the field doesn't exist, all out parameters are set to zero
|
|
|
|
* and false is returned. Otherwise, true is returned with any
|
|
|
|
* invalid part of date set to zero.
|
|
|
|
*
|
|
|
|
* On return, year, month and day are guaranteed to be in the
|
|
|
|
* range of [0,9999], [0,12] and [0,31] respectively.
|
2006-03-25 08:30:19 -07:00
|
|
|
*/
|
2009-08-16 06:02:36 -06:00
|
|
|
bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp)
|
2006-03-25 08:30:19 -07:00
|
|
|
{
|
2009-08-16 06:02:36 -06:00
|
|
|
int year = 0, month = 0, day = 0;
|
|
|
|
bool exists;
|
|
|
|
const char *s, *y;
|
2009-08-16 06:01:22 -06:00
|
|
|
char *e;
|
2006-03-25 08:30:19 -07:00
|
|
|
|
2009-08-16 06:02:36 -06:00
|
|
|
s = dmi_get_system_info(field);
|
|
|
|
exists = s;
|
|
|
|
if (!exists)
|
|
|
|
goto out;
|
2006-03-25 08:30:19 -07:00
|
|
|
|
2009-08-16 06:02:36 -06:00
|
|
|
/*
|
|
|
|
* Determine year first. We assume the date string resembles
|
|
|
|
* mm/dd/yy[yy] but the original code extracted only the year
|
|
|
|
* from the end. Keep the behavior in the spirit of no
|
|
|
|
* surprises.
|
|
|
|
*/
|
|
|
|
y = strrchr(s, '/');
|
|
|
|
if (!y)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
y++;
|
|
|
|
year = simple_strtoul(y, &e, 10);
|
|
|
|
if (y != e && year < 100) { /* 2-digit year */
|
2006-03-25 08:30:19 -07:00
|
|
|
year += 1900;
|
|
|
|
if (year < 1996) /* no dates < spec 1.0 */
|
|
|
|
year += 100;
|
|
|
|
}
|
2009-08-16 06:02:36 -06:00
|
|
|
if (year > 9999) /* year should fit in %04d */
|
|
|
|
year = 0;
|
|
|
|
|
|
|
|
/* parse the mm and dd */
|
|
|
|
month = simple_strtoul(s, &e, 10);
|
|
|
|
if (s == e || *e != '/' || !month || month > 12) {
|
|
|
|
month = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
2006-03-25 08:30:19 -07:00
|
|
|
|
2009-08-16 06:02:36 -06:00
|
|
|
s = e + 1;
|
|
|
|
day = simple_strtoul(s, &e, 10);
|
|
|
|
if (s == y || s == e || *e != '/' || day > 31)
|
|
|
|
day = 0;
|
|
|
|
out:
|
|
|
|
if (yearp)
|
|
|
|
*yearp = year;
|
|
|
|
if (monthp)
|
|
|
|
*monthp = month;
|
|
|
|
if (dayp)
|
|
|
|
*dayp = day;
|
|
|
|
return exists;
|
2006-03-25 08:30:19 -07:00
|
|
|
}
|
2009-08-16 06:02:36 -06:00
|
|
|
EXPORT_SYMBOL(dmi_get_date);
|
2007-11-03 10:29:20 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* dmi_walk - Walk the DMI table and get called back for every record
|
|
|
|
* @decode: Callback function
|
2009-03-30 13:46:44 -06:00
|
|
|
* @private_data: Private data to be passed to the callback function
|
2007-11-03 10:29:20 -06:00
|
|
|
*
|
|
|
|
* Returns -1 when the DMI table can't be reached, 0 on success.
|
|
|
|
*/
|
2009-03-30 13:46:44 -06:00
|
|
|
int dmi_walk(void (*decode)(const struct dmi_header *, void *),
|
|
|
|
void *private_data)
|
2007-11-03 10:29:20 -06:00
|
|
|
{
|
|
|
|
u8 *buf;
|
|
|
|
|
|
|
|
if (!dmi_available)
|
|
|
|
return -1;
|
|
|
|
|
2014-01-23 16:54:39 -07:00
|
|
|
buf = dmi_remap(dmi_base, dmi_len);
|
2007-11-03 10:29:20 -06:00
|
|
|
if (buf == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2015-06-25 01:06:56 -06:00
|
|
|
dmi_decode_table(buf, decode, private_data);
|
2007-11-03 10:29:20 -06:00
|
|
|
|
2014-01-23 16:54:39 -07:00
|
|
|
dmi_unmap(buf);
|
2007-11-03 10:29:20 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dmi_walk);
|
2008-12-10 06:07:21 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* dmi_match - compare a string to the dmi field (if exists)
|
2009-01-06 15:41:40 -07:00
|
|
|
* @f: DMI field identifier
|
|
|
|
* @str: string to compare the DMI field to
|
2008-12-10 06:07:21 -07:00
|
|
|
*
|
|
|
|
* Returns true if the requested field equals to the str (including NULL).
|
|
|
|
*/
|
|
|
|
bool dmi_match(enum dmi_field f, const char *str)
|
|
|
|
{
|
|
|
|
const char *info = dmi_get_system_info(f);
|
|
|
|
|
|
|
|
if (info == NULL || str == NULL)
|
|
|
|
return info == str;
|
|
|
|
|
|
|
|
return !strcmp(info, str);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dmi_match);
|
2013-10-18 15:29:25 -06:00
|
|
|
|
|
|
|
void dmi_memdev_name(u16 handle, const char **bank, const char **device)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if (dmi_memdev == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (n = 0; n < dmi_memdev_nr; n++) {
|
|
|
|
if (handle == dmi_memdev[n].handle) {
|
|
|
|
*bank = dmi_memdev[n].bank;
|
|
|
|
*device = dmi_memdev[n].device;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dmi_memdev_name);
|