[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / firmware / dmi_scan.c

#include <linux/types.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/dmi.h>
#include <linux/efi.h>
#include <linux/bootmem.h>
#include <linux/slab.h>
#include <asm/dmi.h>

/*
 * 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
 */
static char dmi_empty_string[] = "        ";

/*
 * Catch too early calls to dmi_check_system():
 */
static int dmi_initialized;

static const char * __init dmi_string_nosave(const struct dmi_header *dm, u8 s)
{
	const u8 *bp = ((u8 *) dm) + dm->length;

	if (s) {
		s--;
		while (s > 0 && *bp) {
			bp += strlen(bp) + 1;
			s--;
		}

		if (*bp != 0) {
			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;
			return bp;
		}
	}

	return "";
}

static char * __init dmi_string(const struct dmi_header *dm, u8 s)
{
	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);
	else
		printk(KERN_ERR "dmi_string: cannot allocate %Zu bytes.\n", len);

	return str;
}

/*
 *	We have to be cautious here. We have seen BIOSes with DMI pointers
 *	pointing to completely the wrong place for example
 */
static void dmi_table(u8 *buf, int len, int num,
		      void (*decode)(const struct dmi_header *))
{
	u8 *data = buf;
	int i = 0;

	/*
	 *	Stop when we see all the items the table claimed to have
	 *	OR we run off the end of the table (also happens)
	 */
	while ((i < num) && (data - buf + sizeof(struct dmi_header)) <= len) {
		const struct dmi_header *dm = (const struct dmi_header *)data;

		/*
		 *  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
		 */
		data += dm->length;
		while ((data - buf < len - 1) && (data[0] || data[1]))
			data++;
		if (data - buf < len - 1)
			decode(dm);
		data += 2;
		i++;
	}
}

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);
	return 0;
}

static int __init dmi_checksum(const u8 *buf)
{
	u8 sum = 0;
	int a;

	for (a = 0; a < 15; a++)
		sum += buf[a];

	return sum == 0;
}

static char *dmi_ident[DMI_STRING_MAX];
static LIST_HEAD(dmi_devices);
int dmi_available;

/*
 *	Save a DMI string
 */
static void __init dmi_save_ident(const struct dmi_header *dm, int slot, int string)
{
	const char *d = (const char*) dm;
	char *p;

	if (dmi_ident[slot])
		return;

	p = dmi_string(dm, d[string]);
	if (p == NULL)
		return;

	dmi_ident[slot] = p;
}

static void __init dmi_save_uuid(const struct dmi_header *dm, int slot, int index)
{
	const u8 *d = (u8*) dm + index;
	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;
}

static void __init dmi_save_type(const struct dmi_header *dm, int slot, int index)
{
	const u8 *d = (u8*) dm + index;
	char *s;

	if (dmi_ident[slot])
		return;

	s = dmi_alloc(4);
	if (!s)
		return;

	sprintf(s, "%u", *d & 0x7F);
	dmi_ident[slot] = s;
}

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);
	if (!dev) {
		printk(KERN_ERR "dmi_save_one_device: out of memory.\n");
		return;
	}

	dev->type = type;
	strcpy((char *)(dev + 1), name);
	dev->name = (char *)(dev + 1);
	dev->device_data = NULL;
	list_add(&dev->list, &dmi_devices);
}

static void __init dmi_save_devices(const struct dmi_header *dm)
{
	int i, count = (dm->length - sizeof(struct dmi_header)) / 2;

	for (i = 0; i < count; i++) {
		const char *d = (char *)(dm + 1) + (i * 2);

		/* Skip disabled device */
		if ((*d & 0x80) == 0)
			continue;

		dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d + 1)));
	}
}

static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm)
{
	int i, count = *(u8 *)(dm + 1);
	struct dmi_device *dev;

	for (i = 1; i <= count; i++) {
		char *devname = dmi_string(dm, i);

		if (devname == dmi_empty_string)
			continue;

		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;
		dev->name = devname;
		dev->device_data = NULL;

		list_add(&dev->list, &dmi_devices);
	}
}

static void __init dmi_save_ipmi_device(const struct dmi_header *dm)
{
	struct dmi_device *dev;
	void * data;

	data = dmi_alloc(dm->length);
	if (data == NULL) {
		printk(KERN_ERR "dmi_save_ipmi_device: out of memory.\n");
		return;
	}

	memcpy(data, dm, dm->length);

	dev = dmi_alloc(sizeof(*dev));
	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_tail(&dev->list, &dmi_devices);
}

static void __init dmi_save_extended_devices(const struct dmi_header *dm)
{
	const u8 *d = (u8*) dm + 5;

	/* Skip disabled device */
	if ((*d & 0x80) == 0)
		return;

	dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d - 1)));
}

/*
 *	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.
 */
static void __init dmi_decode(const struct dmi_header *dm)
{
	switch(dm->type) {
	case 0:		/* BIOS Information */
		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;
	case 1:		/* System Information */
		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);
		dmi_save_uuid(dm, DMI_PRODUCT_UUID, 8);
		break;
	case 2:		/* Base Board Information */
		dmi_save_ident(dm, DMI_BOARD_VENDOR, 4);
		dmi_save_ident(dm, DMI_BOARD_NAME, 5);
		dmi_save_ident(dm, DMI_BOARD_VERSION, 6);
		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);
		break;
	case 10:	/* Onboard Devices Information */
		dmi_save_devices(dm);
		break;
	case 11:	/* OEM Strings */
		dmi_save_oem_strings_devices(dm);
		break;
	case 38:	/* IPMI Device Information */
		dmi_save_ipmi_device(dm);
		break;
	case 41:	/* Onboard Devices Extended Information */
		dmi_save_extended_devices(dm);
	}
}

static int __init dmi_present(const char __iomem *p)
{
	u8 buf[15];

	memcpy_fromio(buf, p, 15);
	if ((memcmp(buf, "_DMI_", 5) == 0) && dmi_checksum(buf)) {
		dmi_num = (buf[13] << 8) | buf[12];
		dmi_len = (buf[7] << 8) | buf[6];
		dmi_base = (buf[11] << 24) | (buf[10] << 16) |
			(buf[9] << 8) | buf[8];

		/*
		 * 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");
		if (dmi_walk_early(dmi_decode) == 0)
			return 0;
	}
	return 1;
}

void __init dmi_scan_machine(void)
{
	char __iomem *p, *q;
	int rc;

	if (efi_enabled) {
		if (efi.smbios == EFI_INVALID_TABLE_ADDR)
			goto error;

		/* 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.
		 */
		p = dmi_ioremap(efi.smbios, 32);
		if (p == NULL)
			goto error;

		rc = dmi_present(p + 0x10); /* offset of _DMI_ string */
		dmi_iounmap(p, 32);
		if (!rc) {
			dmi_available = 1;
			goto out;
		}
	}
	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 error;

		for (q = p; q < p + 0x10000; q += 16) {
			rc = dmi_present(q);
			if (!rc) {
				dmi_available = 1;
				dmi_iounmap(p, 0x10000);
				goto out;
			}
		}
		dmi_iounmap(p, 0x10000);
	}
 error:
	printk(KERN_INFO "DMI not present or invalid.\n");
 out:
	dmi_initialized = 1;
}

/**
 *	dmi_check_system - check 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 running matching functions until someone
 *	returns non zero or we hit the end. Callback function is called for
 *	each successful match. Returns the number of matches.
 */
int dmi_check_system(const struct dmi_system_id *list)
{
	int i, count = 0;
	const struct dmi_system_id *d = list;

	WARN(!dmi_initialized, KERN_ERR "dmi check: not initialized yet.\n");

	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;
		}
		count++;
		if (d->callback && d->callback(d))
			break;
fail:		d++;
	}

	return count;
}
EXPORT_SYMBOL(dmi_check_system);

/**
 *	dmi_get_system_info - return DMI data value
 *	@field: data index (see enum dmi_field)
 *
 *	Returns one DMI data value, can be used to perform
 *	complex DMI data checks.
 */
const char *dmi_get_system_info(int field)
{
	return dmi_ident[field];
}
EXPORT_SYMBOL(dmi_get_system_info);


/**
 *	dmi_name_in_vendors - Check if string is anywhere in the DMI vendor information.
 *	@str: 	Case sensitive Name
 */
int dmi_name_in_vendors(const char *str)
{
	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);

/**
 *	dmi_find_device - find onboard device by type/name
 *	@type: device type or %DMI_DEV_TYPE_ANY to match all device types
 *	@name: device name string or %NULL to match all
 *	@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.
 *	A new search is initiated by passing %NULL as the @from argument.
 *	If @from is not %NULL, searches continue from next device.
 */
const struct dmi_device * dmi_find_device(int type, const char *name,
				    const struct dmi_device *from)
{
	const struct list_head *head = from ? &from->list : &dmi_devices;
	struct list_head *d;

	for(d = head->next; d != &dmi_devices; d = d->next) {
		const struct dmi_device *dev =
			list_entry(d, struct dmi_device, list);

		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);

/**
 *	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;
	const char *s = dmi_get_system_info(field);

	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;
}

/**
 *	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);
Commit	Line	Data
1da177e4	1	#include <linux/types.h>
1da177e4 LT	2	#include <linux/string.h>
	3	#include <linux/init.h>
	4	#include <linux/module.h>
1da177e4	5	#include <linux/dmi.h>
3ed3bce8	6	#include <linux/efi.h>
1da177e4	7	#include <linux/bootmem.h>
e9928674	8	#include <linux/slab.h>
f2d3efed	9	#include <asm/dmi.h>
1da177e4	10
cb5dd7c1 PJ	11	/*
	12	* DMI stands for "Desktop Management Interface". It is part
	13	* of and an antecedent to, SMBIOS, which stands for System
	14	* Management BIOS. See further: http://www.dmtf.org/standards
	15	*/
79da4721 PW	16	static char dmi_empty_string[] = " ";
79da4721 PW	17
9a22b6e7 IM	18	/*
	19	* Catch too early calls to dmi_check_system():
	20	*/
	21	static int dmi_initialized;
	22
f3069ae9	23	static const char * __init dmi_string_nosave(const struct dmi_header *dm, u8 s)
1da177e4	24	{
1855256c	25	const u8 bp = ((u8 ) dm) + dm->length;
1249c513	26
c3c7120d	27	if (s) {
1da177e4	28	s--;
c3c7120d AP	29	while (s > 0 && *bp) {
	30	bp += strlen(bp) + 1;
	31	s--;
	32	}
	33
	34	if (*bp != 0) {
79da4721 PW	35	size_t len = strlen(bp)+1;
	36	size_t cmp_len = len > 8 ? 8 : len;
	37
	38	if (!memcmp(bp, dmi_empty_string, cmp_len))
	39	return dmi_empty_string;
f3069ae9	40	return bp;
c3c7120d	41	}
4f705ae3	42	}
c3c7120d	43
f3069ae9 JD	44	return "";
	45	}
	46
	47	static char * __init dmi_string(const struct dmi_header *dm, u8 s)
	48	{
	49	const char *bp = dmi_string_nosave(dm, s);
	50	char *str;
	51	size_t len;
	52
	53	if (bp == dmi_empty_string)
	54	return dmi_empty_string;
	55
	56	len = strlen(bp) + 1;
	57	str = dmi_alloc(len);
	58	if (str != NULL)
	59	strcpy(str, bp);
	60	else
	61	printk(KERN_ERR "dmi_string: cannot allocate %Zu bytes.\n", len);
	62
c3c7120d	63	return str;
1da177e4 LT	64	}
	65
	66	/*
	67	* We have to be cautious here. We have seen BIOSes with DMI pointers
	68	* pointing to completely the wrong place for example
	69	*/
7fce084a JD	70	static void dmi_table(u8 *buf, int len, int num,
7fce084a JD	71	void (decode)(const struct dmi_header ))
1da177e4	72	{
7fce084a	73	u8 *data = buf;
1249c513	74	int i = 0;
4f705ae3	75
1da177e4	76	/*
4f705ae3 BH	77	* Stop when we see all the items the table claimed to have
	78	* OR we run off the end of the table (also happens)
	79	*/
1249c513	80	while ((i < num) && (data - buf + sizeof(struct dmi_header)) <= len) {
1855256c JG	81	const struct dmi_header dm = (const struct dmi_header )data;
1855256c JG	82
1da177e4 LT	83	/*
	84	* We want to know the total length (formated area and strings)
	85	* before decoding to make sure we won't run off the table in
	86	* dmi_decode or dmi_string
	87	*/
1249c513 AP	88	data += dm->length;
1249c513 AP	89	while ((data - buf < len - 1) && (data[0] \|\| data[1]))
1da177e4	90	data++;
1249c513	91	if (data - buf < len - 1)
1da177e4	92	decode(dm);
1249c513	93	data += 2;
1da177e4 LT	94	i++;
1da177e4 LT	95	}
7fce084a JD	96	}
	97
	98	static u32 dmi_base;
	99	static u16 dmi_len;
	100	static u16 dmi_num;
	101
	102	static int __init dmi_walk_early(void (decode)(const struct dmi_header ))
	103	{
	104	u8 *buf;
	105
	106	buf = dmi_ioremap(dmi_base, dmi_len);
	107	if (buf == NULL)
	108	return -1;
	109
	110	dmi_table(buf, dmi_len, dmi_num, decode);
	111
	112	dmi_iounmap(buf, dmi_len);
1da177e4 LT	113	return 0;
	114	}
	115
1855256c	116	static int __init dmi_checksum(const u8 *buf)
1da177e4	117	{
1249c513	118	u8 sum = 0;
1da177e4	119	int a;
4f705ae3	120
1249c513 AP	121	for (a = 0; a < 15; a++)
	122	sum += buf[a];
	123
	124	return sum == 0;
1da177e4 LT	125	}
1da177e4 LT	126
1da177e4	127	static char *dmi_ident[DMI_STRING_MAX];
ebad6a42	128	static LIST_HEAD(dmi_devices);
4f5c791a	129	int dmi_available;
1da177e4 LT	130
	131	/*
	132	* Save a DMI string
	133	*/
1855256c	134	static void __init dmi_save_ident(const struct dmi_header *dm, int slot, int string)
1da177e4	135	{
1855256c JG	136	const char d = (const char) dm;
1855256c JG	137	char *p;
1249c513	138
1da177e4 LT	139	if (dmi_ident[slot])
1da177e4 LT	140	return;
1249c513	141
c3c7120d AP	142	p = dmi_string(dm, d[string]);
	143	if (p == NULL)
	144	return;
	145
	146	dmi_ident[slot] = p;
1da177e4 LT	147	}
1da177e4 LT	148
1855256c	149	static void __init dmi_save_uuid(const struct dmi_header *dm, int slot, int index)
4f5c791a	150	{
1855256c	151	const u8 d = (u8) dm + index;
4f5c791a LP	152	char *s;
	153	int is_ff = 1, is_00 = 1, i;
	154
	155	if (dmi_ident[slot])
	156	return;
	157
	158	for (i = 0; i < 16 && (is_ff \|\| is_00); i++) {
	159	if(d[i] != 0x00) is_ff = 0;
	160	if(d[i] != 0xFF) is_00 = 0;
	161	}
	162
	163	if (is_ff \|\| is_00)
	164	return;
	165
	166	s = dmi_alloc(16*2+4+1);
	167	if (!s)
	168	return;
	169
	170	sprintf(s,
	171	"%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
	172	d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],
	173	d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]);
	174
	175	dmi_ident[slot] = s;
	176	}
	177
1855256c	178	static void __init dmi_save_type(const struct dmi_header *dm, int slot, int index)
4f5c791a	179	{
1855256c	180	const u8 d = (u8) dm + index;
4f5c791a LP	181	char *s;
	182
	183	if (dmi_ident[slot])
	184	return;
	185
	186	s = dmi_alloc(4);
	187	if (!s)
	188	return;
	189
	190	sprintf(s, "%u", *d & 0x7F);
	191	dmi_ident[slot] = s;
	192	}
	193
f3069ae9 JD	194	static void __init dmi_save_one_device(int type, const char *name)
	195	{
	196	struct dmi_device *dev;
	197
	198	/* No duplicate device */
	199	if (dmi_find_device(type, name, NULL))
	200	return;
	201
	202	dev = dmi_alloc(sizeof(*dev) + strlen(name) + 1);
	203	if (!dev) {
	204	printk(KERN_ERR "dmi_save_one_device: out of memory.\n");
	205	return;
	206	}
	207
	208	dev->type = type;
	209	strcpy((char *)(dev + 1), name);
	210	dev->name = (char *)(dev + 1);
	211	dev->device_data = NULL;
	212	list_add(&dev->list, &dmi_devices);
	213	}
	214
1855256c	215	static void __init dmi_save_devices(const struct dmi_header *dm)
ebad6a42 AP	216	{
ebad6a42 AP	217	int i, count = (dm->length - sizeof(struct dmi_header)) / 2;
ebad6a42 AP	218
ebad6a42 AP	219	for (i = 0; i < count; i++) {
1855256c	220	const char d = (char )(dm + 1) + (i * 2);
ebad6a42 AP	221
	222	/* Skip disabled device */
	223	if ((*d & 0x80) == 0)
	224	continue;
	225
f3069ae9	226	dmi_save_one_device(d & 0x7f, dmi_string_nosave(dm, (d + 1)));
2e0c1f6c SM	227	}
	228	}
	229
1855256c	230	static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm)
2e0c1f6c SM	231	{
	232	int i, count = (u8 )(dm + 1);
	233	struct dmi_device *dev;
	234
	235	for (i = 1; i <= count; i++) {
79da4721 PW	236	char *devname = dmi_string(dm, i);
79da4721 PW	237
43fe105a	238	if (devname == dmi_empty_string)
79da4721	239	continue;
79da4721	240
2e0c1f6c SM	241	dev = dmi_alloc(sizeof(*dev));
	242	if (!dev) {
	243	printk(KERN_ERR
	244	"dmi_save_oem_strings_devices: out of memory.\n");
	245	break;
	246	}
	247
	248	dev->type = DMI_DEV_TYPE_OEM_STRING;
79da4721	249	dev->name = devname;
2e0c1f6c	250	dev->device_data = NULL;
ebad6a42 AP	251
	252	list_add(&dev->list, &dmi_devices);
	253	}
	254	}
	255
1855256c	256	static void __init dmi_save_ipmi_device(const struct dmi_header *dm)
ebad6a42 AP	257	{
	258	struct dmi_device *dev;
	259	void * data;
	260
e9928674	261	data = dmi_alloc(dm->length);
ebad6a42 AP	262	if (data == NULL) {
	263	printk(KERN_ERR "dmi_save_ipmi_device: out of memory.\n");
	264	return;
	265	}
	266
	267	memcpy(data, dm, dm->length);
	268
e9928674	269	dev = dmi_alloc(sizeof(*dev));
ebad6a42 AP	270	if (!dev) {
	271	printk(KERN_ERR "dmi_save_ipmi_device: out of memory.\n");
	272	return;
	273	}
	274
	275	dev->type = DMI_DEV_TYPE_IPMI;
	276	dev->name = "IPMI controller";
	277	dev->device_data = data;
	278
abd24df8	279	list_add_tail(&dev->list, &dmi_devices);
ebad6a42 AP	280	}
ebad6a42 AP	281
b4bd7d59 WVS	282	static void __init dmi_save_extended_devices(const struct dmi_header *dm)
	283	{
	284	const u8 d = (u8) dm + 5;
b4bd7d59 WVS	285
	286	/* Skip disabled device */
	287	if ((*d & 0x80) == 0)
	288	return;
	289
f3069ae9	290	dmi_save_one_device(d & 0x7f, dmi_string_nosave(dm, (d - 1)));
b4bd7d59 WVS	291	}
b4bd7d59 WVS	292
1da177e4 LT	293	/*
	294	* Process a DMI table entry. Right now all we care about are the BIOS
	295	* and machine entries. For 2.5 we should pull the smbus controller info
	296	* out of here.
	297	*/
1855256c	298	static void __init dmi_decode(const struct dmi_header *dm)
1da177e4	299	{
1249c513	300	switch(dm->type) {
ebad6a42	301	case 0: /* BIOS Information */
1249c513	302	dmi_save_ident(dm, DMI_BIOS_VENDOR, 4);
1249c513	303	dmi_save_ident(dm, DMI_BIOS_VERSION, 5);
1249c513 AP	304	dmi_save_ident(dm, DMI_BIOS_DATE, 8);
1249c513 AP	305	break;
ebad6a42	306	case 1: /* System Information */
1249c513	307	dmi_save_ident(dm, DMI_SYS_VENDOR, 4);
1249c513	308	dmi_save_ident(dm, DMI_PRODUCT_NAME, 5);
1249c513	309	dmi_save_ident(dm, DMI_PRODUCT_VERSION, 6);
1249c513	310	dmi_save_ident(dm, DMI_PRODUCT_SERIAL, 7);
4f5c791a	311	dmi_save_uuid(dm, DMI_PRODUCT_UUID, 8);
1249c513	312	break;
ebad6a42	313	case 2: /* Base Board Information */
1249c513	314	dmi_save_ident(dm, DMI_BOARD_VENDOR, 4);
1249c513	315	dmi_save_ident(dm, DMI_BOARD_NAME, 5);
1249c513	316	dmi_save_ident(dm, DMI_BOARD_VERSION, 6);
4f5c791a LP	317	dmi_save_ident(dm, DMI_BOARD_SERIAL, 7);
	318	dmi_save_ident(dm, DMI_BOARD_ASSET_TAG, 8);
	319	break;
	320	case 3: /* Chassis Information */
	321	dmi_save_ident(dm, DMI_CHASSIS_VENDOR, 4);
	322	dmi_save_type(dm, DMI_CHASSIS_TYPE, 5);
	323	dmi_save_ident(dm, DMI_CHASSIS_VERSION, 6);
	324	dmi_save_ident(dm, DMI_CHASSIS_SERIAL, 7);
	325	dmi_save_ident(dm, DMI_CHASSIS_ASSET_TAG, 8);
1249c513	326	break;
ebad6a42 AP	327	case 10: /* Onboard Devices Information */
	328	dmi_save_devices(dm);
	329	break;
2e0c1f6c SM	330	case 11: /* OEM Strings */
	331	dmi_save_oem_strings_devices(dm);
	332	break;
ebad6a42 AP	333	case 38: /* IPMI Device Information */
ebad6a42 AP	334	dmi_save_ipmi_device(dm);
b4bd7d59 WVS	335	break;
	336	case 41: /* Onboard Devices Extended Information */
	337	dmi_save_extended_devices(dm);
1da177e4 LT	338	}
	339	}
	340
1855256c	341	static int __init dmi_present(const char __iomem *p)
1da177e4	342	{
61e032fa	343	u8 buf[15];
1855256c	344
3ed3bce8 MD	345	memcpy_fromio(buf, p, 15);
3ed3bce8 MD	346	if ((memcmp(buf, "_DMI_", 5) == 0) && dmi_checksum(buf)) {
7fce084a JD	347	dmi_num = (buf[13] << 8) \| buf[12];
	348	dmi_len = (buf[7] << 8) \| buf[6];
	349	dmi_base = (buf[11] << 24) \| (buf[10] << 16) \|
3ed3bce8	350	(buf[9] << 8) \| buf[8];
61e032fa	351
3ed3bce8 MD	352	/*
	353	* DMI version 0.0 means that the real version is taken from
	354	* the SMBIOS version, which we don't know at this point.
	355	*/
	356	if (buf[14] != 0)
	357	printk(KERN_INFO "DMI %d.%d present.\n",
	358	buf[14] >> 4, buf[14] & 0xF);
	359	else
	360	printk(KERN_INFO "DMI present.\n");
7fce084a	361	if (dmi_walk_early(dmi_decode) == 0)
3ed3bce8 MD	362	return 0;
	363	}
	364	return 1;
	365	}
61e032fa	366
3ed3bce8 MD	367	void __init dmi_scan_machine(void)
	368	{
	369	char __iomem p, q;
	370	int rc;
	371
	372	if (efi_enabled) {
b2c99e3c	373	if (efi.smbios == EFI_INVALID_TABLE_ADDR)
9a22b6e7	374	goto error;
3ed3bce8	375
4f5c791a LP	376	/* This is called as a core_initcall() because it isn't
	377	* needed during early boot. This also means we can
	378	* iounmap the space when we're done with it.
	379	*/
b2c99e3c	380	p = dmi_ioremap(efi.smbios, 32);
3ed3bce8	381	if (p == NULL)
9a22b6e7	382	goto error;
3ed3bce8 MD	383
3ed3bce8 MD	384	rc = dmi_present(p + 0x10); /* offset of _DMI_ string */
23dd842c	385	dmi_iounmap(p, 32);
4f5c791a LP	386	if (!rc) {
4f5c791a LP	387	dmi_available = 1;
9a22b6e7	388	goto out;
4f5c791a	389	}
3ed3bce8 MD	390	}
	391	else {
	392	/*
	393	* no iounmap() for that ioremap(); it would be a no-op, but
	394	* it's so early in setup that sucker gets confused into doing
	395	* what it shouldn't if we actually call it.
	396	*/
	397	p = dmi_ioremap(0xF0000, 0x10000);
	398	if (p == NULL)
9a22b6e7	399	goto error;
3ed3bce8 MD	400
	401	for (q = p; q < p + 0x10000; q += 16) {
	402	rc = dmi_present(q);
4f5c791a LP	403	if (!rc) {
4f5c791a LP	404	dmi_available = 1;
0d64484f	405	dmi_iounmap(p, 0x10000);
9a22b6e7	406	goto out;
4f5c791a	407	}
61e032fa	408	}
3212bff3	409	dmi_iounmap(p, 0x10000);
61e032fa	410	}
9a22b6e7 IM	411	error:
	412	printk(KERN_INFO "DMI not present or invalid.\n");
	413	out:
	414	dmi_initialized = 1;
1da177e4 LT	415	}
1da177e4 LT	416
1da177e4 LT	417	/**
	418	* dmi_check_system - check system DMI data
	419	* @list: array of dmi_system_id structures to match against
b0ef371e RD	420	* All non-null elements of the list must match
	421	* their slot's (field index's) data (i.e., each
	422	* list string must be a substring of the specified
	423	* DMI slot's string data) to be considered a
	424	* successful match.
1da177e4 LT	425	*
	426	* Walk the blacklist table running matching functions until someone
	427	* returns non zero or we hit the end. Callback function is called for
b0ef371e	428	* each successful match. Returns the number of matches.
1da177e4	429	*/
1855256c	430	int dmi_check_system(const struct dmi_system_id *list)
1da177e4 LT	431	{
1da177e4 LT	432	int i, count = 0;
1855256c	433	const struct dmi_system_id *d = list;
1da177e4	434
9a22b6e7 IM	435	WARN(!dmi_initialized, KERN_ERR "dmi check: not initialized yet.\n");
9a22b6e7 IM	436
1da177e4 LT	437	while (d->ident) {
	438	for (i = 0; i < ARRAY_SIZE(d->matches); i++) {
	439	int s = d->matches[i].slot;
	440	if (s == DMI_NONE)
	441	continue;
	442	if (dmi_ident[s] && strstr(dmi_ident[s], d->matches[i].substr))
	443	continue;
	444	/* No match */
	445	goto fail;
	446	}
640e8033	447	count++;
1da177e4 LT	448	if (d->callback && d->callback(d))
1da177e4 LT	449	break;
1da177e4 LT	450	fail: d++;
	451	}
	452
	453	return count;
	454	}
1da177e4 LT	455	EXPORT_SYMBOL(dmi_check_system);
	456
	457	/**
	458	* dmi_get_system_info - return DMI data value
b0ef371e	459	* @field: data index (see enum dmi_field)
1da177e4 LT	460	*
	461	* Returns one DMI data value, can be used to perform
	462	* complex DMI data checks.
	463	*/
1855256c	464	const char *dmi_get_system_info(int field)
1da177e4 LT	465	{
	466	return dmi_ident[field];
	467	}
e70c9d5e	468	EXPORT_SYMBOL(dmi_get_system_info);
ebad6a42	469
a1bae672 AK	470
	471	/**
	472	* dmi_name_in_vendors - Check if string is anywhere in the DMI vendor information.
	473	* @str: Case sensitive Name
	474	*/
1855256c	475	int dmi_name_in_vendors(const char *str)
a1bae672 AK	476	{
	477	static int fields[] = { DMI_BIOS_VENDOR, DMI_BIOS_VERSION, DMI_SYS_VENDOR,
	478	DMI_PRODUCT_NAME, DMI_PRODUCT_VERSION, DMI_BOARD_VENDOR,
	479	DMI_BOARD_NAME, DMI_BOARD_VERSION, DMI_NONE };
	480	int i;
	481	for (i = 0; fields[i] != DMI_NONE; i++) {
	482	int f = fields[i];
	483	if (dmi_ident[f] && strstr(dmi_ident[f], str))
	484	return 1;
	485	}
	486	return 0;
	487	}
	488	EXPORT_SYMBOL(dmi_name_in_vendors);
	489
ebad6a42 AP	490	/**
	491	* dmi_find_device - find onboard device by type/name
	492	* @type: device type or %DMI_DEV_TYPE_ANY to match all device types
b0ef371e	493	* @name: device name string or %NULL to match all
ebad6a42 AP	494	* @from: previous device found in search, or %NULL for new search.
	495	*
	496	* Iterates through the list of known onboard devices. If a device is
	497	* found with a matching @vendor and @device, a pointer to its device
	498	* structure is returned. Otherwise, %NULL is returned.
b0ef371e	499	* A new search is initiated by passing %NULL as the @from argument.
ebad6a42 AP	500	* If @from is not %NULL, searches continue from next device.
ebad6a42 AP	501	*/
1855256c JG	502	const struct dmi_device * dmi_find_device(int type, const char *name,
1855256c JG	503	const struct dmi_device *from)
ebad6a42	504	{
1855256c JG	505	const struct list_head *head = from ? &from->list : &dmi_devices;
1855256c JG	506	struct list_head *d;
ebad6a42 AP	507
ebad6a42 AP	508	for(d = head->next; d != &dmi_devices; d = d->next) {
1855256c JG	509	const struct dmi_device *dev =
1855256c JG	510	list_entry(d, struct dmi_device, list);
ebad6a42 AP	511
	512	if (((type == DMI_DEV_TYPE_ANY) \|\| (dev->type == type)) &&
	513	((name == NULL) \|\| (strcmp(dev->name, name) == 0)))
	514	return dev;
	515	}
	516
	517	return NULL;
	518	}
	519	EXPORT_SYMBOL(dmi_find_device);
f083a329 AK	520
	521	/**
	522	* dmi_get_year - Return year of a DMI date
	523	* @field: data index (like dmi_get_system_info)
	524	*
	525	* Returns -1 when the field doesn't exist. 0 when it is broken.
	526	*/
	527	int dmi_get_year(int field)
	528	{
	529	int year;
1855256c	530	const char *s = dmi_get_system_info(field);
f083a329 AK	531
	532	if (!s)
	533	return -1;
	534	if (*s == '\0')
	535	return 0;
	536	s = strrchr(s, '/');
	537	if (!s)
	538	return 0;
	539
	540	s += 1;
	541	year = simple_strtoul(s, NULL, 0);
	542	if (year && year < 100) { /* 2-digit year */
	543	year += 1900;
	544	if (year < 1996) /* no dates < spec 1.0 */
	545	year += 100;
	546	}
	547
	548	return year;
	549	}
7fce084a JD	550
	551	/**
	552	* dmi_walk - Walk the DMI table and get called back for every record
	553	* @decode: Callback function
	554	*
	555	* Returns -1 when the DMI table can't be reached, 0 on success.
	556	*/
	557	int dmi_walk(void (decode)(const struct dmi_header ))
	558	{
	559	u8 *buf;
	560
	561	if (!dmi_available)
	562	return -1;
	563
	564	buf = ioremap(dmi_base, dmi_len);
	565	if (buf == NULL)
	566	return -1;
	567
	568	dmi_table(buf, dmi_len, dmi_num, decode);
	569
	570	iounmap(buf);
	571	return 0;
	572	}
	573	EXPORT_SYMBOL_GPL(dmi_walk);