2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#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 17:37:03 +08:00
|
|
|
#include <linux/efi.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/bootmem.h>
|
2006-01-12 05:43:33 +08:00
|
|
|
#include <linux/slab.h>
|
2006-03-25 23:30:22 +08:00
|
|
|
#include <asm/dmi.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-30 20:31:59 +08:00
|
|
|
static char dmi_empty_string[] = " ";
|
|
|
|
|
2007-10-04 03:15:40 +08:00
|
|
|
static char * __init dmi_string(const struct dmi_header *dm, u8 s)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-10-04 03:15:40 +08:00
|
|
|
const u8 *bp = ((u8 *) dm) + dm->length;
|
2005-09-07 06:18:28 +08:00
|
|
|
char *str = "";
|
2005-06-26 05:54:47 +08:00
|
|
|
|
2005-09-07 06:18:28 +08:00
|
|
|
if (s) {
|
2005-04-17 06:20:36 +08:00
|
|
|
s--;
|
2005-09-07 06:18:28 +08:00
|
|
|
while (s > 0 && *bp) {
|
|
|
|
bp += strlen(bp) + 1;
|
|
|
|
s--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*bp != 0) {
|
2008-01-30 20:31:59 +08: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;
|
|
|
|
str = dmi_alloc(len);
|
2005-09-07 06:18:28 +08:00
|
|
|
if (str != NULL)
|
|
|
|
strcpy(str, bp);
|
|
|
|
else
|
2008-01-30 20:31:59 +08:00
|
|
|
printk(KERN_ERR "dmi_string: cannot allocate %Zu bytes.\n", len);
|
2005-09-07 06:18:28 +08:00
|
|
|
}
|
2006-04-04 08:09:22 +08:00
|
|
|
}
|
2005-09-07 06:18:28 +08:00
|
|
|
|
|
|
|
return str;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have to be cautious here. We have seen BIOSes with DMI pointers
|
|
|
|
* pointing to completely the wrong place for example
|
|
|
|
*/
|
2007-11-04 00:29:20 +08:00
|
|
|
static void dmi_table(u8 *buf, int len, int num,
|
|
|
|
void (*decode)(const struct dmi_header *))
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-11-04 00:29:20 +08:00
|
|
|
u8 *data = buf;
|
2005-06-26 05:54:47 +08:00
|
|
|
int i = 0;
|
2006-04-04 08:09:22 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2006-04-04 08:09:22 +08:00
|
|
|
* Stop when we see all the items the table claimed to have
|
|
|
|
* OR we run off the end of the table (also happens)
|
|
|
|
*/
|
2005-06-26 05:54:47 +08:00
|
|
|
while ((i < num) && (data - buf + sizeof(struct dmi_header)) <= len) {
|
2007-10-04 03:15:40 +08:00
|
|
|
const struct dmi_header *dm = (const struct dmi_header *)data;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* We want to know the total length (formated area and strings)
|
|
|
|
* before decoding to make sure we won't run off the table in
|
|
|
|
* dmi_decode or dmi_string
|
|
|
|
*/
|
2005-06-26 05:54:47 +08:00
|
|
|
data += dm->length;
|
|
|
|
while ((data - buf < len - 1) && (data[0] || data[1]))
|
2005-04-17 06:20:36 +08:00
|
|
|
data++;
|
2005-06-26 05:54:47 +08:00
|
|
|
if (data - buf < len - 1)
|
2005-04-17 06:20:36 +08:00
|
|
|
decode(dm);
|
2005-06-26 05:54:47 +08:00
|
|
|
data += 2;
|
2005-04-17 06:20:36 +08:00
|
|
|
i++;
|
|
|
|
}
|
2007-11-04 00:29:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static u32 dmi_base;
|
|
|
|
static u16 dmi_len;
|
|
|
|
static u16 dmi_num;
|
|
|
|
|
|
|
|
static int __init dmi_walk_early(void (*decode)(const struct dmi_header *))
|
|
|
|
{
|
|
|
|
u8 *buf;
|
|
|
|
|
|
|
|
buf = dmi_ioremap(dmi_base, dmi_len);
|
|
|
|
if (buf == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
dmi_table(buf, dmi_len, dmi_num, decode);
|
|
|
|
|
|
|
|
dmi_iounmap(buf, dmi_len);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-04 03:15:40 +08:00
|
|
|
static int __init dmi_checksum(const u8 *buf)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-06-26 05:54:47 +08:00
|
|
|
u8 sum = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
int a;
|
2006-04-04 08:09:22 +08:00
|
|
|
|
2005-06-26 05:54:47 +08:00
|
|
|
for (a = 0; a < 15; a++)
|
|
|
|
sum += buf[a];
|
|
|
|
|
|
|
|
return sum == 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static char *dmi_ident[DMI_STRING_MAX];
|
2005-09-07 06:18:29 +08:00
|
|
|
static LIST_HEAD(dmi_devices);
|
2007-05-09 04:07:02 +08:00
|
|
|
int dmi_available;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Save a DMI string
|
|
|
|
*/
|
2007-10-04 03:15:40 +08:00
|
|
|
static void __init dmi_save_ident(const struct dmi_header *dm, int slot, int string)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-10-04 03:15:40 +08:00
|
|
|
const char *d = (const char*) dm;
|
|
|
|
char *p;
|
2005-06-26 05:54:47 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (dmi_ident[slot])
|
|
|
|
return;
|
2005-06-26 05:54:47 +08:00
|
|
|
|
2005-09-07 06:18:28 +08:00
|
|
|
p = dmi_string(dm, d[string]);
|
|
|
|
if (p == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dmi_ident[slot] = p;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-10-04 03:15:40 +08:00
|
|
|
static void __init dmi_save_uuid(const struct dmi_header *dm, int slot, int index)
|
2007-05-09 04:07:02 +08:00
|
|
|
{
|
2007-10-04 03:15:40 +08:00
|
|
|
const u8 *d = (u8*) dm + index;
|
2007-05-09 04:07:02 +08: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++) {
|
|
|
|
if(d[i] != 0x00) is_ff = 0;
|
|
|
|
if(d[i] != 0xFF) is_00 = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_ff || is_00)
|
|
|
|
return;
|
|
|
|
|
|
|
|
s = dmi_alloc(16*2+4+1);
|
|
|
|
if (!s)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sprintf(s,
|
|
|
|
"%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
|
|
|
|
d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],
|
|
|
|
d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]);
|
|
|
|
|
|
|
|
dmi_ident[slot] = s;
|
|
|
|
}
|
|
|
|
|
2007-10-04 03:15:40 +08:00
|
|
|
static void __init dmi_save_type(const struct dmi_header *dm, int slot, int index)
|
2007-05-09 04:07:02 +08:00
|
|
|
{
|
2007-10-04 03:15:40 +08:00
|
|
|
const u8 *d = (u8*) dm + index;
|
2007-05-09 04:07:02 +08:00
|
|
|
char *s;
|
|
|
|
|
|
|
|
if (dmi_ident[slot])
|
|
|
|
return;
|
|
|
|
|
|
|
|
s = dmi_alloc(4);
|
|
|
|
if (!s)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sprintf(s, "%u", *d & 0x7F);
|
|
|
|
dmi_ident[slot] = s;
|
|
|
|
}
|
|
|
|
|
2007-10-04 03:15:40 +08:00
|
|
|
static void __init dmi_save_devices(const struct dmi_header *dm)
|
2005-09-07 06:18:29 +08:00
|
|
|
{
|
|
|
|
int i, count = (dm->length - sizeof(struct dmi_header)) / 2;
|
|
|
|
struct dmi_device *dev;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
2007-10-04 03:15:40 +08:00
|
|
|
const char *d = (char *)(dm + 1) + (i * 2);
|
2005-09-07 06:18:29 +08:00
|
|
|
|
|
|
|
/* Skip disabled device */
|
|
|
|
if ((*d & 0x80) == 0)
|
|
|
|
continue;
|
|
|
|
|
2006-01-12 05:43:33 +08:00
|
|
|
dev = dmi_alloc(sizeof(*dev));
|
2005-09-07 06:18:29 +08:00
|
|
|
if (!dev) {
|
|
|
|
printk(KERN_ERR "dmi_save_devices: out of memory.\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->type = *d++ & 0x7f;
|
|
|
|
dev->name = dmi_string(dm, *d);
|
|
|
|
dev->device_data = NULL;
|
2006-09-29 16:59:37 +08:00
|
|
|
list_add(&dev->list, &dmi_devices);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-30 20:31:59 +08:00
|
|
|
static struct dmi_device empty_oem_string_dev = {
|
|
|
|
.name = dmi_empty_string,
|
|
|
|
};
|
|
|
|
|
2007-10-04 03:15:40 +08:00
|
|
|
static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm)
|
2006-09-29 16:59:37 +08:00
|
|
|
{
|
|
|
|
int i, count = *(u8 *)(dm + 1);
|
|
|
|
struct dmi_device *dev;
|
|
|
|
|
|
|
|
for (i = 1; i <= count; i++) {
|
2008-01-30 20:31:59 +08:00
|
|
|
char *devname = dmi_string(dm, i);
|
|
|
|
|
|
|
|
if (!strcmp(devname, dmi_empty_string)) {
|
|
|
|
list_add(&empty_oem_string_dev.list, &dmi_devices);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-09-29 16:59:37 +08:00
|
|
|
dev = dmi_alloc(sizeof(*dev));
|
|
|
|
if (!dev) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"dmi_save_oem_strings_devices: out of memory.\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->type = DMI_DEV_TYPE_OEM_STRING;
|
2008-01-30 20:31:59 +08:00
|
|
|
dev->name = devname;
|
2006-09-29 16:59:37 +08:00
|
|
|
dev->device_data = NULL;
|
2005-09-07 06:18:29 +08:00
|
|
|
|
|
|
|
list_add(&dev->list, &dmi_devices);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-04 03:15:40 +08:00
|
|
|
static void __init dmi_save_ipmi_device(const struct dmi_header *dm)
|
2005-09-07 06:18:29 +08:00
|
|
|
{
|
|
|
|
struct dmi_device *dev;
|
|
|
|
void * data;
|
|
|
|
|
2006-01-12 05:43:33 +08:00
|
|
|
data = dmi_alloc(dm->length);
|
2005-09-07 06:18:29 +08:00
|
|
|
if (data == NULL) {
|
|
|
|
printk(KERN_ERR "dmi_save_ipmi_device: out of memory.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(data, dm, dm->length);
|
|
|
|
|
2006-01-12 05:43:33 +08:00
|
|
|
dev = dmi_alloc(sizeof(*dev));
|
2005-09-07 06:18:29 +08:00
|
|
|
if (!dev) {
|
|
|
|
printk(KERN_ERR "dmi_save_ipmi_device: out of memory.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->type = DMI_DEV_TYPE_IPMI;
|
|
|
|
dev->name = "IPMI controller";
|
|
|
|
dev->device_data = data;
|
|
|
|
|
|
|
|
list_add(&dev->list, &dmi_devices);
|
|
|
|
}
|
|
|
|
|
2008-02-08 20:20:58 +08:00
|
|
|
static void __init dmi_save_extended_devices(const struct dmi_header *dm)
|
|
|
|
{
|
|
|
|
const u8 *d = (u8*) dm + 5;
|
|
|
|
struct dmi_device *dev;
|
|
|
|
|
|
|
|
/* Skip disabled device */
|
|
|
|
if ((*d & 0x80) == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dev = dmi_alloc(sizeof(*dev));
|
|
|
|
if (!dev) {
|
|
|
|
printk(KERN_ERR "dmi_save_extended_devices: out of memory.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->type = *d-- & 0x7f;
|
|
|
|
dev->name = dmi_string(dm, *d);
|
|
|
|
dev->device_data = NULL;
|
|
|
|
|
|
|
|
list_add(&dev->list, &dmi_devices);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08: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.
|
|
|
|
*/
|
2007-10-04 03:15:40 +08:00
|
|
|
static void __init dmi_decode(const struct dmi_header *dm)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-06-26 05:54:47 +08:00
|
|
|
switch(dm->type) {
|
2005-09-07 06:18:29 +08:00
|
|
|
case 0: /* BIOS Information */
|
2005-06-26 05:54:47 +08: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-07 06:18:29 +08:00
|
|
|
case 1: /* System Information */
|
2005-06-26 05:54:47 +08: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-09 04:07:02 +08:00
|
|
|
dmi_save_uuid(dm, DMI_PRODUCT_UUID, 8);
|
2005-06-26 05:54:47 +08:00
|
|
|
break;
|
2005-09-07 06:18:29 +08:00
|
|
|
case 2: /* Base Board Information */
|
2005-06-26 05:54:47 +08: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-09 04:07:02 +08: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-26 05:54:47 +08:00
|
|
|
break;
|
2005-09-07 06:18:29 +08:00
|
|
|
case 10: /* Onboard Devices Information */
|
|
|
|
dmi_save_devices(dm);
|
|
|
|
break;
|
2006-09-29 16:59:37 +08:00
|
|
|
case 11: /* OEM Strings */
|
|
|
|
dmi_save_oem_strings_devices(dm);
|
|
|
|
break;
|
2005-09-07 06:18:29 +08:00
|
|
|
case 38: /* IPMI Device Information */
|
|
|
|
dmi_save_ipmi_device(dm);
|
2008-02-08 20:20:58 +08:00
|
|
|
break;
|
|
|
|
case 41: /* Onboard Devices Extended Information */
|
|
|
|
dmi_save_extended_devices(dm);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-04 03:15:40 +08:00
|
|
|
static int __init dmi_present(const char __iomem *p)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-09-07 06:18:26 +08:00
|
|
|
u8 buf[15];
|
2007-10-04 03:15:40 +08: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 17:37:03 +08:00
|
|
|
memcpy_fromio(buf, p, 15);
|
|
|
|
if ((memcmp(buf, "_DMI_", 5) == 0) && dmi_checksum(buf)) {
|
2007-11-04 00:29:20 +08:00
|
|
|
dmi_num = (buf[13] << 8) | buf[12];
|
|
|
|
dmi_len = (buf[7] << 8) | buf[6];
|
|
|
|
dmi_base = (buf[11] << 24) | (buf[10] << 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 17:37:03 +08:00
|
|
|
(buf[9] << 8) | buf[8];
|
2005-09-07 06:18:26 +08: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 17:37:03 +08:00
|
|
|
/*
|
|
|
|
* DMI version 0.0 means that the real version is taken from
|
|
|
|
* the SMBIOS version, which we don't know at this point.
|
|
|
|
*/
|
|
|
|
if (buf[14] != 0)
|
|
|
|
printk(KERN_INFO "DMI %d.%d present.\n",
|
|
|
|
buf[14] >> 4, buf[14] & 0xF);
|
|
|
|
else
|
|
|
|
printk(KERN_INFO "DMI present.\n");
|
2007-11-04 00:29:20 +08:00
|
|
|
if (dmi_walk_early(dmi_decode) == 0)
|
[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 17:37:03 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
2005-09-07 06:18:26 +08: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 17:37:03 +08:00
|
|
|
void __init dmi_scan_machine(void)
|
|
|
|
{
|
|
|
|
char __iomem *p, *q;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (efi_enabled) {
|
2006-03-26 17:37:08 +08:00
|
|
|
if (efi.smbios == EFI_INVALID_TABLE_ADDR)
|
[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 17:37:03 +08:00
|
|
|
goto out;
|
|
|
|
|
2007-05-09 04:07:02 +08: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.
|
|
|
|
*/
|
2006-03-26 17:37:08 +08:00
|
|
|
p = dmi_ioremap(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 17:37:03 +08:00
|
|
|
if (p == NULL)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
rc = dmi_present(p + 0x10); /* offset of _DMI_ string */
|
2006-03-26 17:37:09 +08:00
|
|
|
dmi_iounmap(p, 32);
|
2007-05-09 04:07:02 +08:00
|
|
|
if (!rc) {
|
|
|
|
dmi_available = 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 17:37:03 +08:00
|
|
|
return;
|
2007-05-09 04:07:02 +08: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 17:37:03 +08:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* no iounmap() for that ioremap(); it would be a no-op, but
|
|
|
|
* it's so early in setup that sucker gets confused into doing
|
|
|
|
* what it shouldn't if we actually call it.
|
|
|
|
*/
|
|
|
|
p = dmi_ioremap(0xF0000, 0x10000);
|
|
|
|
if (p == NULL)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
for (q = p; q < p + 0x10000; q += 16) {
|
|
|
|
rc = dmi_present(q);
|
2007-05-09 04:07:02 +08:00
|
|
|
if (!rc) {
|
|
|
|
dmi_available = 1;
|
2008-01-30 20:33:09 +08:00
|
|
|
dmi_iounmap(p, 0x10000);
|
2005-09-07 06:18:26 +08:00
|
|
|
return;
|
2007-05-09 04:07:02 +08:00
|
|
|
}
|
2005-09-07 06:18:26 +08:00
|
|
|
}
|
2008-01-30 20:33:32 +08:00
|
|
|
dmi_iounmap(p, 0x10000);
|
2005-09-07 06:18:26 +08: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 17:37:03 +08:00
|
|
|
out: printk(KERN_INFO "DMI not present or invalid.\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dmi_check_system - check system DMI data
|
|
|
|
* @list: array of dmi_system_id structures to match against
|
2006-06-25 20:49:18 +08: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-17 06:20:36 +08: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 20:49:18 +08:00
|
|
|
* each successful match. Returns the number of matches.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2007-10-04 03:15:40 +08:00
|
|
|
int dmi_check_system(const struct dmi_system_id *list)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i, count = 0;
|
2007-10-04 03:15:40 +08:00
|
|
|
const struct dmi_system_id *d = list;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
while (d->ident) {
|
|
|
|
for (i = 0; i < ARRAY_SIZE(d->matches); i++) {
|
|
|
|
int s = d->matches[i].slot;
|
|
|
|
if (s == DMI_NONE)
|
|
|
|
continue;
|
|
|
|
if (dmi_ident[s] && strstr(dmi_ident[s], d->matches[i].substr))
|
|
|
|
continue;
|
|
|
|
/* No match */
|
|
|
|
goto fail;
|
|
|
|
}
|
2005-09-07 06:18:30 +08:00
|
|
|
count++;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (d->callback && d->callback(d))
|
|
|
|
break;
|
|
|
|
fail: d++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dmi_check_system);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dmi_get_system_info - return DMI data value
|
2006-06-25 20:49:18 +08:00
|
|
|
* @field: data index (see enum dmi_field)
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* Returns one DMI data value, can be used to perform
|
|
|
|
* complex DMI data checks.
|
|
|
|
*/
|
2007-10-04 03:15:40 +08:00
|
|
|
const char *dmi_get_system_info(int field)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
return dmi_ident[field];
|
|
|
|
}
|
2005-06-26 05:54:25 +08:00
|
|
|
EXPORT_SYMBOL(dmi_get_system_info);
|
2005-09-07 06:18:29 +08:00
|
|
|
|
2006-10-22 00:37:02 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* dmi_name_in_vendors - Check if string is anywhere in the DMI vendor information.
|
|
|
|
* @str: Case sensitive Name
|
|
|
|
*/
|
2007-10-04 03:15:40 +08:00
|
|
|
int dmi_name_in_vendors(const char *str)
|
2006-10-22 00:37:02 +08:00
|
|
|
{
|
|
|
|
static int fields[] = { DMI_BIOS_VENDOR, DMI_BIOS_VERSION, DMI_SYS_VENDOR,
|
|
|
|
DMI_PRODUCT_NAME, DMI_PRODUCT_VERSION, DMI_BOARD_VENDOR,
|
|
|
|
DMI_BOARD_NAME, DMI_BOARD_VERSION, DMI_NONE };
|
|
|
|
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-07 06:18:29 +08: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 20:49:18 +08:00
|
|
|
* @name: device name string or %NULL to match all
|
2005-09-07 06:18:29 +08: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 20:49:18 +08:00
|
|
|
* A new search is initiated by passing %NULL as the @from argument.
|
2005-09-07 06:18:29 +08:00
|
|
|
* If @from is not %NULL, searches continue from next device.
|
|
|
|
*/
|
2007-10-04 03:15:40 +08:00
|
|
|
const struct dmi_device * dmi_find_device(int type, const char *name,
|
|
|
|
const struct dmi_device *from)
|
2005-09-07 06:18:29 +08:00
|
|
|
{
|
2007-10-04 03:15:40 +08:00
|
|
|
const struct list_head *head = from ? &from->list : &dmi_devices;
|
|
|
|
struct list_head *d;
|
2005-09-07 06:18:29 +08:00
|
|
|
|
|
|
|
for(d = head->next; d != &dmi_devices; d = d->next) {
|
2007-10-04 03:15:40 +08:00
|
|
|
const struct dmi_device *dev =
|
|
|
|
list_entry(d, struct dmi_device, list);
|
2005-09-07 06:18:29 +08: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 23:30:19 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* dmi_get_year - Return year of a DMI date
|
|
|
|
* @field: data index (like dmi_get_system_info)
|
|
|
|
*
|
|
|
|
* Returns -1 when the field doesn't exist. 0 when it is broken.
|
|
|
|
*/
|
|
|
|
int dmi_get_year(int field)
|
|
|
|
{
|
|
|
|
int year;
|
2007-10-04 03:15:40 +08:00
|
|
|
const char *s = dmi_get_system_info(field);
|
2006-03-25 23:30:19 +08:00
|
|
|
|
|
|
|
if (!s)
|
|
|
|
return -1;
|
|
|
|
if (*s == '\0')
|
|
|
|
return 0;
|
|
|
|
s = strrchr(s, '/');
|
|
|
|
if (!s)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
s += 1;
|
|
|
|
year = simple_strtoul(s, NULL, 0);
|
|
|
|
if (year && year < 100) { /* 2-digit year */
|
|
|
|
year += 1900;
|
|
|
|
if (year < 1996) /* no dates < spec 1.0 */
|
|
|
|
year += 100;
|
|
|
|
}
|
|
|
|
|
|
|
|
return year;
|
|
|
|
}
|
2007-11-04 00:29:20 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* dmi_walk - Walk the DMI table and get called back for every record
|
|
|
|
* @decode: Callback function
|
|
|
|
*
|
|
|
|
* Returns -1 when the DMI table can't be reached, 0 on success.
|
|
|
|
*/
|
|
|
|
int dmi_walk(void (*decode)(const struct dmi_header *))
|
|
|
|
{
|
|
|
|
u8 *buf;
|
|
|
|
|
|
|
|
if (!dmi_available)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
buf = ioremap(dmi_base, dmi_len);
|
|
|
|
if (buf == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
dmi_table(buf, dmi_len, dmi_num, decode);
|
|
|
|
|
|
|
|
iounmap(buf);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dmi_walk);
|