1#include <linux/types.h>
2#include <linux/string.h>
3#include <linux/init.h>
4#include <linux/module.h>
5#include <linux/ctype.h>
6#include <linux/dmi.h>
7#include <linux/efi.h>
8#include <linux/bootmem.h>
9#include <linux/random.h>
10#include <asm/dmi.h>
11#include <asm/unaligned.h>
12
13/*
14 * DMI stands for "Desktop Management Interface".  It is part
15 * of and an antecedent to, SMBIOS, which stands for System
16 * Management BIOS.  See further: http://www.dmtf.org/standards
17 */
18static const char dmi_empty_string[] = "        ";
19
20static u16 __initdata dmi_ver;
21/*
22 * Catch too early calls to dmi_check_system():
23 */
24static int dmi_initialized;
25
26/* DMI system identification string used during boot */
27static char dmi_ids_string[128] __initdata;
28
29static struct dmi_memdev_info {
30	const char *device;
31	const char *bank;
32	u16 handle;
33} *dmi_memdev;
34static int dmi_memdev_nr;
35
36static const char * __init dmi_string_nosave(const struct dmi_header *dm, u8 s)
37{
38	const u8 *bp = ((u8 *) dm) + dm->length;
39
40	if (s) {
41		s--;
42		while (s > 0 && *bp) {
43			bp += strlen(bp) + 1;
44			s--;
45		}
46
47		if (*bp != 0) {
48			size_t len = strlen(bp)+1;
49			size_t cmp_len = len > 8 ? 8 : len;
50
51			if (!memcmp(bp, dmi_empty_string, cmp_len))
52				return dmi_empty_string;
53			return bp;
54		}
55	}
56
57	return "";
58}
59
60static const char * __init dmi_string(const struct dmi_header *dm, u8 s)
61{
62	const char *bp = dmi_string_nosave(dm, s);
63	char *str;
64	size_t len;
65
66	if (bp == dmi_empty_string)
67		return dmi_empty_string;
68
69	len = strlen(bp) + 1;
70	str = dmi_alloc(len);
71	if (str != NULL)
72		strcpy(str, bp);
73
74	return str;
75}
76
77/*
78 *	We have to be cautious here. We have seen BIOSes with DMI pointers
79 *	pointing to completely the wrong place for example
80 */
81static void dmi_table(u8 *buf, int len, int num,
82		      void (*decode)(const struct dmi_header *, void *),
83		      void *private_data)
84{
85	u8 *data = buf;
86	int i = 0;
87
88	/*
89	 *	Stop when we see all the items the table claimed to have
90	 *	OR we run off the end of the table (also happens)
91	 */
92	while ((i < num) && (data - buf + sizeof(struct dmi_header)) <= len) {
93		const struct dmi_header *dm = (const struct dmi_header *)data;
94
95		/*
96		 * 7.45 End-of-Table (Type 127) [SMBIOS reference spec v3.0.0]
97		 */
98		if (dm->type == DMI_ENTRY_END_OF_TABLE)
99			break;
100
101		/*
102		 *  We want to know the total length (formatted area and
103		 *  strings) before decoding to make sure we won't run off the
104		 *  table in dmi_decode or dmi_string
105		 */
106		data += dm->length;
107		while ((data - buf < len - 1) && (data[0] || data[1]))
108			data++;
109		if (data - buf < len - 1)
110			decode(dm, private_data);
111		data += 2;
112		i++;
113	}
114}
115
116static phys_addr_t dmi_base;
117static u16 dmi_len;
118static u16 dmi_num;
119
120static int __init dmi_walk_early(void (*decode)(const struct dmi_header *,
121		void *))
122{
123	u8 *buf;
124
125	buf = dmi_early_remap(dmi_base, dmi_len);
126	if (buf == NULL)
127		return -1;
128
129	dmi_table(buf, dmi_len, dmi_num, decode, NULL);
130
131	add_device_randomness(buf, dmi_len);
132
133	dmi_early_unmap(buf, dmi_len);
134	return 0;
135}
136
137static int __init dmi_checksum(const u8 *buf, u8 len)
138{
139	u8 sum = 0;
140	int a;
141
142	for (a = 0; a < len; a++)
143		sum += buf[a];
144
145	return sum == 0;
146}
147
148static const char *dmi_ident[DMI_STRING_MAX];
149static LIST_HEAD(dmi_devices);
150int dmi_available;
151
152/*
153 *	Save a DMI string
154 */
155static void __init dmi_save_ident(const struct dmi_header *dm, int slot,
156		int string)
157{
158	const char *d = (const char *) dm;
159	const char *p;
160
161	if (dmi_ident[slot])
162		return;
163
164	p = dmi_string(dm, d[string]);
165	if (p == NULL)
166		return;
167
168	dmi_ident[slot] = p;
169}
170
171static void __init dmi_save_uuid(const struct dmi_header *dm, int slot,
172		int index)
173{
174	const u8 *d = (u8 *) dm + index;
175	char *s;
176	int is_ff = 1, is_00 = 1, i;
177
178	if (dmi_ident[slot])
179		return;
180
181	for (i = 0; i < 16 && (is_ff || is_00); i++) {
182		if (d[i] != 0x00)
183			is_00 = 0;
184		if (d[i] != 0xFF)
185			is_ff = 0;
186	}
187
188	if (is_ff || is_00)
189		return;
190
191	s = dmi_alloc(16*2+4+1);
192	if (!s)
193		return;
194
195	/*
196	 * As of version 2.6 of the SMBIOS specification, the first 3 fields of
197	 * the UUID are supposed to be little-endian encoded.  The specification
198	 * says that this is the defacto standard.
199	 */
200	if (dmi_ver >= 0x0206)
201		sprintf(s, "%pUL", d);
202	else
203		sprintf(s, "%pUB", d);
204
205	dmi_ident[slot] = s;
206}
207
208static void __init dmi_save_type(const struct dmi_header *dm, int slot,
209		int index)
210{
211	const u8 *d = (u8 *) dm + index;
212	char *s;
213
214	if (dmi_ident[slot])
215		return;
216
217	s = dmi_alloc(4);
218	if (!s)
219		return;
220
221	sprintf(s, "%u", *d & 0x7F);
222	dmi_ident[slot] = s;
223}
224
225static void __init dmi_save_one_device(int type, const char *name)
226{
227	struct dmi_device *dev;
228
229	/* No duplicate device */
230	if (dmi_find_device(type, name, NULL))
231		return;
232
233	dev = dmi_alloc(sizeof(*dev) + strlen(name) + 1);
234	if (!dev)
235		return;
236
237	dev->type = type;
238	strcpy((char *)(dev + 1), name);
239	dev->name = (char *)(dev + 1);
240	dev->device_data = NULL;
241	list_add(&dev->list, &dmi_devices);
242}
243
244static void __init dmi_save_devices(const struct dmi_header *dm)
245{
246	int i, count = (dm->length - sizeof(struct dmi_header)) / 2;
247
248	for (i = 0; i < count; i++) {
249		const char *d = (char *)(dm + 1) + (i * 2);
250
251		/* Skip disabled device */
252		if ((*d & 0x80) == 0)
253			continue;
254
255		dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d + 1)));
256	}
257}
258
259static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm)
260{
261	int i, count = *(u8 *)(dm + 1);
262	struct dmi_device *dev;
263
264	for (i = 1; i <= count; i++) {
265		const char *devname = dmi_string(dm, i);
266
267		if (devname == dmi_empty_string)
268			continue;
269
270		dev = dmi_alloc(sizeof(*dev));
271		if (!dev)
272			break;
273
274		dev->type = DMI_DEV_TYPE_OEM_STRING;
275		dev->name = devname;
276		dev->device_data = NULL;
277
278		list_add(&dev->list, &dmi_devices);
279	}
280}
281
282static void __init dmi_save_ipmi_device(const struct dmi_header *dm)
283{
284	struct dmi_device *dev;
285	void *data;
286
287	data = dmi_alloc(dm->length);
288	if (data == NULL)
289		return;
290
291	memcpy(data, dm, dm->length);
292
293	dev = dmi_alloc(sizeof(*dev));
294	if (!dev)
295		return;
296
297	dev->type = DMI_DEV_TYPE_IPMI;
298	dev->name = "IPMI controller";
299	dev->device_data = data;
300
301	list_add_tail(&dev->list, &dmi_devices);
302}
303
304static void __init dmi_save_dev_onboard(int instance, int segment, int bus,
305					int devfn, const char *name)
306{
307	struct dmi_dev_onboard *onboard_dev;
308
309	onboard_dev = dmi_alloc(sizeof(*onboard_dev) + strlen(name) + 1);
310	if (!onboard_dev)
311		return;
312
313	onboard_dev->instance = instance;
314	onboard_dev->segment = segment;
315	onboard_dev->bus = bus;
316	onboard_dev->devfn = devfn;
317
318	strcpy((char *)&onboard_dev[1], name);
319	onboard_dev->dev.type = DMI_DEV_TYPE_DEV_ONBOARD;
320	onboard_dev->dev.name = (char *)&onboard_dev[1];
321	onboard_dev->dev.device_data = onboard_dev;
322
323	list_add(&onboard_dev->dev.list, &dmi_devices);
324}
325
326static void __init dmi_save_extended_devices(const struct dmi_header *dm)
327{
328	const u8 *d = (u8 *) dm + 5;
329
330	/* Skip disabled device */
331	if ((*d & 0x80) == 0)
332		return;
333
334	dmi_save_dev_onboard(*(d+1), *(u16 *)(d+2), *(d+4), *(d+5),
335			     dmi_string_nosave(dm, *(d-1)));
336	dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d - 1)));
337}
338
339static void __init count_mem_devices(const struct dmi_header *dm, void *v)
340{
341	if (dm->type != DMI_ENTRY_MEM_DEVICE)
342		return;
343	dmi_memdev_nr++;
344}
345
346static void __init save_mem_devices(const struct dmi_header *dm, void *v)
347{
348	const char *d = (const char *)dm;
349	static int nr;
350
351	if (dm->type != DMI_ENTRY_MEM_DEVICE)
352		return;
353	if (nr >= dmi_memdev_nr) {
354		pr_warn(FW_BUG "Too many DIMM entries in SMBIOS table\n");
355		return;
356	}
357	dmi_memdev[nr].handle = get_unaligned(&dm->handle);
358	dmi_memdev[nr].device = dmi_string(dm, d[0x10]);
359	dmi_memdev[nr].bank = dmi_string(dm, d[0x11]);
360	nr++;
361}
362
363void __init dmi_memdev_walk(void)
364{
365	if (!dmi_available)
366		return;
367
368	if (dmi_walk_early(count_mem_devices) == 0 && dmi_memdev_nr) {
369		dmi_memdev = dmi_alloc(sizeof(*dmi_memdev) * dmi_memdev_nr);
370		if (dmi_memdev)
371			dmi_walk_early(save_mem_devices);
372	}
373}
374
375/*
376 *	Process a DMI table entry. Right now all we care about are the BIOS
377 *	and machine entries. For 2.5 we should pull the smbus controller info
378 *	out of here.
379 */
380static void __init dmi_decode(const struct dmi_header *dm, void *dummy)
381{
382	switch (dm->type) {
383	case 0:		/* BIOS Information */
384		dmi_save_ident(dm, DMI_BIOS_VENDOR, 4);
385		dmi_save_ident(dm, DMI_BIOS_VERSION, 5);
386		dmi_save_ident(dm, DMI_BIOS_DATE, 8);
387		break;
388	case 1:		/* System Information */
389		dmi_save_ident(dm, DMI_SYS_VENDOR, 4);
390		dmi_save_ident(dm, DMI_PRODUCT_NAME, 5);
391		dmi_save_ident(dm, DMI_PRODUCT_VERSION, 6);
392		dmi_save_ident(dm, DMI_PRODUCT_SERIAL, 7);
393		dmi_save_uuid(dm, DMI_PRODUCT_UUID, 8);
394		break;
395	case 2:		/* Base Board Information */
396		dmi_save_ident(dm, DMI_BOARD_VENDOR, 4);
397		dmi_save_ident(dm, DMI_BOARD_NAME, 5);
398		dmi_save_ident(dm, DMI_BOARD_VERSION, 6);
399		dmi_save_ident(dm, DMI_BOARD_SERIAL, 7);
400		dmi_save_ident(dm, DMI_BOARD_ASSET_TAG, 8);
401		break;
402	case 3:		/* Chassis Information */
403		dmi_save_ident(dm, DMI_CHASSIS_VENDOR, 4);
404		dmi_save_type(dm, DMI_CHASSIS_TYPE, 5);
405		dmi_save_ident(dm, DMI_CHASSIS_VERSION, 6);
406		dmi_save_ident(dm, DMI_CHASSIS_SERIAL, 7);
407		dmi_save_ident(dm, DMI_CHASSIS_ASSET_TAG, 8);
408		break;
409	case 10:	/* Onboard Devices Information */
410		dmi_save_devices(dm);
411		break;
412	case 11:	/* OEM Strings */
413		dmi_save_oem_strings_devices(dm);
414		break;
415	case 38:	/* IPMI Device Information */
416		dmi_save_ipmi_device(dm);
417		break;
418	case 41:	/* Onboard Devices Extended Information */
419		dmi_save_extended_devices(dm);
420	}
421}
422
423static int __init print_filtered(char *buf, size_t len, const char *info)
424{
425	int c = 0;
426	const char *p;
427
428	if (!info)
429		return c;
430
431	for (p = info; *p; p++)
432		if (isprint(*p))
433			c += scnprintf(buf + c, len - c, "%c", *p);
434		else
435			c += scnprintf(buf + c, len - c, "\\x%02x", *p & 0xff);
436	return c;
437}
438
439static void __init dmi_format_ids(char *buf, size_t len)
440{
441	int c = 0;
442	const char *board;	/* Board Name is optional */
443
444	c += print_filtered(buf + c, len - c,
445			    dmi_get_system_info(DMI_SYS_VENDOR));
446	c += scnprintf(buf + c, len - c, " ");
447	c += print_filtered(buf + c, len - c,
448			    dmi_get_system_info(DMI_PRODUCT_NAME));
449
450	board = dmi_get_system_info(DMI_BOARD_NAME);
451	if (board) {
452		c += scnprintf(buf + c, len - c, "/");
453		c += print_filtered(buf + c, len - c, board);
454	}
455	c += scnprintf(buf + c, len - c, ", BIOS ");
456	c += print_filtered(buf + c, len - c,
457			    dmi_get_system_info(DMI_BIOS_VERSION));
458	c += scnprintf(buf + c, len - c, " ");
459	c += print_filtered(buf + c, len - c,
460			    dmi_get_system_info(DMI_BIOS_DATE));
461}
462
463/*
464 * Check for DMI/SMBIOS headers in the system firmware image.  Any
465 * SMBIOS header must start 16 bytes before the DMI header, so take a
466 * 32 byte buffer and check for DMI at offset 16 and SMBIOS at offset
467 * 0.  If the DMI header is present, set dmi_ver accordingly (SMBIOS
468 * takes precedence) and return 0.  Otherwise return 1.
469 */
470static int __init dmi_present(const u8 *buf)
471{
472	int smbios_ver;
473
474	if (memcmp(buf, "_SM_", 4) == 0 &&
475	    buf[5] < 32 && dmi_checksum(buf, buf[5])) {
476		smbios_ver = get_unaligned_be16(buf + 6);
477
478		/* Some BIOS report weird SMBIOS version, fix that up */
479		switch (smbios_ver) {
480		case 0x021F:
481		case 0x0221:
482			pr_debug("SMBIOS version fixup(2.%d->2.%d)\n",
483				 smbios_ver & 0xFF, 3);
484			smbios_ver = 0x0203;
485			break;
486		case 0x0233:
487			pr_debug("SMBIOS version fixup(2.%d->2.%d)\n", 51, 6);
488			smbios_ver = 0x0206;
489			break;
490		}
491	} else {
492		smbios_ver = 0;
493	}
494
495	buf += 16;
496
497	if (memcmp(buf, "_DMI_", 5) == 0 && dmi_checksum(buf, 15)) {
498		dmi_num = get_unaligned_le16(buf + 12);
499		dmi_len = get_unaligned_le16(buf + 6);
500		dmi_base = get_unaligned_le32(buf + 8);
501
502		if (dmi_walk_early(dmi_decode) == 0) {
503			if (smbios_ver) {
504				dmi_ver = smbios_ver;
505				pr_info("SMBIOS %d.%d present.\n",
506				       dmi_ver >> 8, dmi_ver & 0xFF);
507			} else {
508				dmi_ver = (buf[14] & 0xF0) << 4 |
509					   (buf[14] & 0x0F);
510				pr_info("Legacy DMI %d.%d present.\n",
511				       dmi_ver >> 8, dmi_ver & 0xFF);
512			}
513			dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string));
514			printk(KERN_DEBUG "DMI: %s\n", dmi_ids_string);
515			return 0;
516		}
517	}
518
519	return 1;
520}
521
522/*
523 * Check for the SMBIOS 3.0 64-bit entry point signature. Unlike the legacy
524 * 32-bit entry point, there is no embedded DMI header (_DMI_) in here.
525 */
526static int __init dmi_smbios3_present(const u8 *buf)
527{
528	if (memcmp(buf, "_SM3_", 5) == 0 &&
529	    buf[6] < 32 && dmi_checksum(buf, buf[6])) {
530		dmi_ver = get_unaligned_be16(buf + 7);
531		dmi_len = get_unaligned_le32(buf + 12);
532		dmi_base = get_unaligned_le64(buf + 16);
533
534		/*
535		 * The 64-bit SMBIOS 3.0 entry point no longer has a field
536		 * containing the number of structures present in the table.
537		 * Instead, it defines the table size as a maximum size, and
538		 * relies on the end-of-table structure type (#127) to be used
539		 * to signal the end of the table.
540		 * So let's define dmi_num as an upper bound as well: each
541		 * structure has a 4 byte header, so dmi_len / 4 is an upper
542		 * bound for the number of structures in the table.
543		 */
544		dmi_num = dmi_len / 4;
545
546		if (dmi_walk_early(dmi_decode) == 0) {
547			pr_info("SMBIOS %d.%d present.\n",
548				dmi_ver >> 8, dmi_ver & 0xFF);
549			dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string));
550			pr_debug("DMI: %s\n", dmi_ids_string);
551			return 0;
552		}
553	}
554	return 1;
555}
556
557void __init dmi_scan_machine(void)
558{
559	char __iomem *p, *q;
560	char buf[32];
561
562	if (efi_enabled(EFI_CONFIG_TABLES)) {
563		/*
564		 * According to the DMTF SMBIOS reference spec v3.0.0, it is
565		 * allowed to define both the 64-bit entry point (smbios3) and
566		 * the 32-bit entry point (smbios), in which case they should
567		 * either both point to the same SMBIOS structure table, or the
568		 * table pointed to by the 64-bit entry point should contain a
569		 * superset of the table contents pointed to by the 32-bit entry
570		 * point (section 5.2)
571		 * This implies that the 64-bit entry point should have
572		 * precedence if it is defined and supported by the OS. If we
573		 * have the 64-bit entry point, but fail to decode it, fall
574		 * back to the legacy one (if available)
575		 */
576		if (efi.smbios3 != EFI_INVALID_TABLE_ADDR) {
577			p = dmi_early_remap(efi.smbios3, 32);
578			if (p == NULL)
579				goto error;
580			memcpy_fromio(buf, p, 32);
581			dmi_early_unmap(p, 32);
582
583			if (!dmi_smbios3_present(buf)) {
584				dmi_available = 1;
585				goto out;
586			}
587		}
588		if (efi.smbios == EFI_INVALID_TABLE_ADDR)
589			goto error;
590
591		/* This is called as a core_initcall() because it isn't
592		 * needed during early boot.  This also means we can
593		 * iounmap the space when we're done with it.
594		 */
595		p = dmi_early_remap(efi.smbios, 32);
596		if (p == NULL)
597			goto error;
598		memcpy_fromio(buf, p, 32);
599		dmi_early_unmap(p, 32);
600
601		if (!dmi_present(buf)) {
602			dmi_available = 1;
603			goto out;
604		}
605	} else if (IS_ENABLED(CONFIG_DMI_SCAN_MACHINE_NON_EFI_FALLBACK)) {
606		p = dmi_early_remap(0xF0000, 0x10000);
607		if (p == NULL)
608			goto error;
609
610		/*
611		 * Iterate over all possible DMI header addresses q.
612		 * Maintain the 32 bytes around q in buf.  On the
613		 * first iteration, substitute zero for the
614		 * out-of-range bytes so there is no chance of falsely
615		 * detecting an SMBIOS header.
616		 */
617		memset(buf, 0, 16);
618		for (q = p; q < p + 0x10000; q += 16) {
619			memcpy_fromio(buf + 16, q, 16);
620			if (!dmi_smbios3_present(buf) || !dmi_present(buf)) {
621				dmi_available = 1;
622				dmi_early_unmap(p, 0x10000);
623				goto out;
624			}
625			memcpy(buf, buf + 16, 16);
626		}
627		dmi_early_unmap(p, 0x10000);
628	}
629 error:
630	pr_info("DMI not present or invalid.\n");
631 out:
632	dmi_initialized = 1;
633}
634
635/**
636 * dmi_set_dump_stack_arch_desc - set arch description for dump_stack()
637 *
638 * Invoke dump_stack_set_arch_desc() with DMI system information so that
639 * DMI identifiers are printed out on task dumps.  Arch boot code should
640 * call this function after dmi_scan_machine() if it wants to print out DMI
641 * identifiers on task dumps.
642 */
643void __init dmi_set_dump_stack_arch_desc(void)
644{
645	dump_stack_set_arch_desc("%s", dmi_ids_string);
646}
647
648/**
649 *	dmi_matches - check if dmi_system_id structure matches system DMI data
650 *	@dmi: pointer to the dmi_system_id structure to check
651 */
652static bool dmi_matches(const struct dmi_system_id *dmi)
653{
654	int i;
655
656	WARN(!dmi_initialized, KERN_ERR "dmi check: not initialized yet.\n");
657
658	for (i = 0; i < ARRAY_SIZE(dmi->matches); i++) {
659		int s = dmi->matches[i].slot;
660		if (s == DMI_NONE)
661			break;
662		if (dmi_ident[s]) {
663			if (!dmi->matches[i].exact_match &&
664			    strstr(dmi_ident[s], dmi->matches[i].substr))
665				continue;
666			else if (dmi->matches[i].exact_match &&
667				 !strcmp(dmi_ident[s], dmi->matches[i].substr))
668				continue;
669		}
670
671		/* No match */
672		return false;
673	}
674	return true;
675}
676
677/**
678 *	dmi_is_end_of_table - check for end-of-table marker
679 *	@dmi: pointer to the dmi_system_id structure to check
680 */
681static bool dmi_is_end_of_table(const struct dmi_system_id *dmi)
682{
683	return dmi->matches[0].slot == DMI_NONE;
684}
685
686/**
687 *	dmi_check_system - check system DMI data
688 *	@list: array of dmi_system_id structures to match against
689 *		All non-null elements of the list must match
690 *		their slot's (field index's) data (i.e., each
691 *		list string must be a substring of the specified
692 *		DMI slot's string data) to be considered a
693 *		successful match.
694 *
695 *	Walk the blacklist table running matching functions until someone
696 *	returns non zero or we hit the end. Callback function is called for
697 *	each successful match. Returns the number of matches.
698 */
699int dmi_check_system(const struct dmi_system_id *list)
700{
701	int count = 0;
702	const struct dmi_system_id *d;
703
704	for (d = list; !dmi_is_end_of_table(d); d++)
705		if (dmi_matches(d)) {
706			count++;
707			if (d->callback && d->callback(d))
708				break;
709		}
710
711	return count;
712}
713EXPORT_SYMBOL(dmi_check_system);
714
715/**
716 *	dmi_first_match - find dmi_system_id structure matching system DMI data
717 *	@list: array of dmi_system_id structures to match against
718 *		All non-null elements of the list must match
719 *		their slot's (field index's) data (i.e., each
720 *		list string must be a substring of the specified
721 *		DMI slot's string data) to be considered a
722 *		successful match.
723 *
724 *	Walk the blacklist table until the first match is found.  Return the
725 *	pointer to the matching entry or NULL if there's no match.
726 */
727const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list)
728{
729	const struct dmi_system_id *d;
730
731	for (d = list; !dmi_is_end_of_table(d); d++)
732		if (dmi_matches(d))
733			return d;
734
735	return NULL;
736}
737EXPORT_SYMBOL(dmi_first_match);
738
739/**
740 *	dmi_get_system_info - return DMI data value
741 *	@field: data index (see enum dmi_field)
742 *
743 *	Returns one DMI data value, can be used to perform
744 *	complex DMI data checks.
745 */
746const char *dmi_get_system_info(int field)
747{
748	return dmi_ident[field];
749}
750EXPORT_SYMBOL(dmi_get_system_info);
751
752/**
753 * dmi_name_in_serial - Check if string is in the DMI product serial information
754 * @str: string to check for
755 */
756int dmi_name_in_serial(const char *str)
757{
758	int f = DMI_PRODUCT_SERIAL;
759	if (dmi_ident[f] && strstr(dmi_ident[f], str))
760		return 1;
761	return 0;
762}
763
764/**
765 *	dmi_name_in_vendors - Check if string is in the DMI system or board vendor name
766 *	@str: Case sensitive Name
767 */
768int dmi_name_in_vendors(const char *str)
769{
770	static int fields[] = { DMI_SYS_VENDOR, DMI_BOARD_VENDOR, DMI_NONE };
771	int i;
772	for (i = 0; fields[i] != DMI_NONE; i++) {
773		int f = fields[i];
774		if (dmi_ident[f] && strstr(dmi_ident[f], str))
775			return 1;
776	}
777	return 0;
778}
779EXPORT_SYMBOL(dmi_name_in_vendors);
780
781/**
782 *	dmi_find_device - find onboard device by type/name
783 *	@type: device type or %DMI_DEV_TYPE_ANY to match all device types
784 *	@name: device name string or %NULL to match all
785 *	@from: previous device found in search, or %NULL for new search.
786 *
787 *	Iterates through the list of known onboard devices. If a device is
788 *	found with a matching @vendor and @device, a pointer to its device
789 *	structure is returned.  Otherwise, %NULL is returned.
790 *	A new search is initiated by passing %NULL as the @from argument.
791 *	If @from is not %NULL, searches continue from next device.
792 */
793const struct dmi_device *dmi_find_device(int type, const char *name,
794				    const struct dmi_device *from)
795{
796	const struct list_head *head = from ? &from->list : &dmi_devices;
797	struct list_head *d;
798
799	for (d = head->next; d != &dmi_devices; d = d->next) {
800		const struct dmi_device *dev =
801			list_entry(d, struct dmi_device, list);
802
803		if (((type == DMI_DEV_TYPE_ANY) || (dev->type == type)) &&
804		    ((name == NULL) || (strcmp(dev->name, name) == 0)))
805			return dev;
806	}
807
808	return NULL;
809}
810EXPORT_SYMBOL(dmi_find_device);
811
812/**
813 *	dmi_get_date - parse a DMI date
814 *	@field:	data index (see enum dmi_field)
815 *	@yearp: optional out parameter for the year
816 *	@monthp: optional out parameter for the month
817 *	@dayp: optional out parameter for the day
818 *
819 *	The date field is assumed to be in the form resembling
820 *	[mm[/dd]]/yy[yy] and the result is stored in the out
821 *	parameters any or all of which can be omitted.
822 *
823 *	If the field doesn't exist, all out parameters are set to zero
824 *	and false is returned.  Otherwise, true is returned with any
825 *	invalid part of date set to zero.
826 *
827 *	On return, year, month and day are guaranteed to be in the
828 *	range of [0,9999], [0,12] and [0,31] respectively.
829 */
830bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp)
831{
832	int year = 0, month = 0, day = 0;
833	bool exists;
834	const char *s, *y;
835	char *e;
836
837	s = dmi_get_system_info(field);
838	exists = s;
839	if (!exists)
840		goto out;
841
842	/*
843	 * Determine year first.  We assume the date string resembles
844	 * mm/dd/yy[yy] but the original code extracted only the year
845	 * from the end.  Keep the behavior in the spirit of no
846	 * surprises.
847	 */
848	y = strrchr(s, '/');
849	if (!y)
850		goto out;
851
852	y++;
853	year = simple_strtoul(y, &e, 10);
854	if (y != e && year < 100) {	/* 2-digit year */
855		year += 1900;
856		if (year < 1996)	/* no dates < spec 1.0 */
857			year += 100;
858	}
859	if (year > 9999)		/* year should fit in %04d */
860		year = 0;
861
862	/* parse the mm and dd */
863	month = simple_strtoul(s, &e, 10);
864	if (s == e || *e != '/' || !month || month > 12) {
865		month = 0;
866		goto out;
867	}
868
869	s = e + 1;
870	day = simple_strtoul(s, &e, 10);
871	if (s == y || s == e || *e != '/' || day > 31)
872		day = 0;
873out:
874	if (yearp)
875		*yearp = year;
876	if (monthp)
877		*monthp = month;
878	if (dayp)
879		*dayp = day;
880	return exists;
881}
882EXPORT_SYMBOL(dmi_get_date);
883
884/**
885 *	dmi_walk - Walk the DMI table and get called back for every record
886 *	@decode: Callback function
887 *	@private_data: Private data to be passed to the callback function
888 *
889 *	Returns -1 when the DMI table can't be reached, 0 on success.
890 */
891int dmi_walk(void (*decode)(const struct dmi_header *, void *),
892	     void *private_data)
893{
894	u8 *buf;
895
896	if (!dmi_available)
897		return -1;
898
899	buf = dmi_remap(dmi_base, dmi_len);
900	if (buf == NULL)
901		return -1;
902
903	dmi_table(buf, dmi_len, dmi_num, decode, private_data);
904
905	dmi_unmap(buf);
906	return 0;
907}
908EXPORT_SYMBOL_GPL(dmi_walk);
909
910/**
911 * dmi_match - compare a string to the dmi field (if exists)
912 * @f: DMI field identifier
913 * @str: string to compare the DMI field to
914 *
915 * Returns true if the requested field equals to the str (including NULL).
916 */
917bool dmi_match(enum dmi_field f, const char *str)
918{
919	const char *info = dmi_get_system_info(f);
920
921	if (info == NULL || str == NULL)
922		return info == str;
923
924	return !strcmp(info, str);
925}
926EXPORT_SYMBOL_GPL(dmi_match);
927
928void dmi_memdev_name(u16 handle, const char **bank, const char **device)
929{
930	int n;
931
932	if (dmi_memdev == NULL)
933		return;
934
935	for (n = 0; n < dmi_memdev_nr; n++) {
936		if (handle == dmi_memdev[n].handle) {
937			*bank = dmi_memdev[n].bank;
938			*device = dmi_memdev[n].device;
939			break;
940		}
941	}
942}
943EXPORT_SYMBOL_GPL(dmi_memdev_name);
944