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
13struct kobject *dmi_kobj;
14EXPORT_SYMBOL_GPL(dmi_kobj);
15
16
17
18
19
20
21static const char dmi_empty_string[] = " ";
22
23static u32 dmi_ver __initdata;
24static u32 dmi_len;
25static u16 dmi_num;
26static u8 smbios_entry_point[32];
27static int smbios_entry_point_size;
28
29
30
31
32static int dmi_initialized;
33
34
35static char dmi_ids_string[128] __initdata;
36
37static struct dmi_memdev_info {
38 const char *device;
39 const char *bank;
40 u16 handle;
41} *dmi_memdev;
42static int dmi_memdev_nr;
43
44static const char * __init dmi_string_nosave(const struct dmi_header *dm, u8 s)
45{
46 const u8 *bp = ((u8 *) dm) + dm->length;
47
48 if (s) {
49 s--;
50 while (s > 0 && *bp) {
51 bp += strlen(bp) + 1;
52 s--;
53 }
54
55 if (*bp != 0) {
56 size_t len = strlen(bp)+1;
57 size_t cmp_len = len > 8 ? 8 : len;
58
59 if (!memcmp(bp, dmi_empty_string, cmp_len))
60 return dmi_empty_string;
61 return bp;
62 }
63 }
64
65 return "";
66}
67
68static const char * __init dmi_string(const struct dmi_header *dm, u8 s)
69{
70 const char *bp = dmi_string_nosave(dm, s);
71 char *str;
72 size_t len;
73
74 if (bp == dmi_empty_string)
75 return dmi_empty_string;
76
77 len = strlen(bp) + 1;
78 str = dmi_alloc(len);
79 if (str != NULL)
80 strcpy(str, bp);
81
82 return str;
83}
84
85
86
87
88
89static void dmi_decode_table(u8 *buf,
90 void (*decode)(const struct dmi_header *, void *),
91 void *private_data)
92{
93 u8 *data = buf;
94 int i = 0;
95
96
97
98
99
100
101
102 while ((!dmi_num || i < dmi_num) &&
103 (data - buf + sizeof(struct dmi_header)) <= dmi_len) {
104 const struct dmi_header *dm = (const struct dmi_header *)data;
105
106
107
108
109
110
111 data += dm->length;
112 while ((data - buf < dmi_len - 1) && (data[0] || data[1]))
113 data++;
114 if (data - buf < dmi_len - 1)
115 decode(dm, private_data);
116
117 data += 2;
118 i++;
119
120
121
122
123
124
125
126
127
128 if (!dmi_num && dm->type == DMI_ENTRY_END_OF_TABLE)
129 break;
130 }
131
132
133 if (dmi_len > data - buf)
134 dmi_len = data - buf;
135}
136
137static phys_addr_t dmi_base;
138
139static int __init dmi_walk_early(void (*decode)(const struct dmi_header *,
140 void *))
141{
142 u8 *buf;
143 u32 orig_dmi_len = dmi_len;
144
145 buf = dmi_early_remap(dmi_base, orig_dmi_len);
146 if (buf == NULL)
147 return -1;
148
149 dmi_decode_table(buf, decode, NULL);
150
151 add_device_randomness(buf, dmi_len);
152
153 dmi_early_unmap(buf, orig_dmi_len);
154 return 0;
155}
156
157static int __init dmi_checksum(const u8 *buf, u8 len)
158{
159 u8 sum = 0;
160 int a;
161
162 for (a = 0; a < len; a++)
163 sum += buf[a];
164
165 return sum == 0;
166}
167
168static const char *dmi_ident[DMI_STRING_MAX];
169static LIST_HEAD(dmi_devices);
170int dmi_available;
171
172
173
174
175static void __init dmi_save_ident(const struct dmi_header *dm, int slot,
176 int string)
177{
178 const char *d = (const char *) dm;
179 const char *p;
180
181 if (dmi_ident[slot])
182 return;
183
184 p = dmi_string(dm, d[string]);
185 if (p == NULL)
186 return;
187
188 dmi_ident[slot] = p;
189}
190
191static void __init dmi_save_uuid(const struct dmi_header *dm, int slot,
192 int index)
193{
194 const u8 *d = (u8 *) dm + index;
195 char *s;
196 int is_ff = 1, is_00 = 1, i;
197
198 if (dmi_ident[slot])
199 return;
200
201 for (i = 0; i < 16 && (is_ff || is_00); i++) {
202 if (d[i] != 0x00)
203 is_00 = 0;
204 if (d[i] != 0xFF)
205 is_ff = 0;
206 }
207
208 if (is_ff || is_00)
209 return;
210
211 s = dmi_alloc(16*2+4+1);
212 if (!s)
213 return;
214
215
216
217
218
219
220 if (dmi_ver >= 0x020600)
221 sprintf(s, "%pUL", d);
222 else
223 sprintf(s, "%pUB", d);
224
225 dmi_ident[slot] = s;
226}
227
228static void __init dmi_save_type(const struct dmi_header *dm, int slot,
229 int index)
230{
231 const u8 *d = (u8 *) dm + index;
232 char *s;
233
234 if (dmi_ident[slot])
235 return;
236
237 s = dmi_alloc(4);
238 if (!s)
239 return;
240
241 sprintf(s, "%u", *d & 0x7F);
242 dmi_ident[slot] = s;
243}
244
245static void __init dmi_save_one_device(int type, const char *name)
246{
247 struct dmi_device *dev;
248
249
250 if (dmi_find_device(type, name, NULL))
251 return;
252
253 dev = dmi_alloc(sizeof(*dev) + strlen(name) + 1);
254 if (!dev)
255 return;
256
257 dev->type = type;
258 strcpy((char *)(dev + 1), name);
259 dev->name = (char *)(dev + 1);
260 dev->device_data = NULL;
261 list_add(&dev->list, &dmi_devices);
262}
263
264static void __init dmi_save_devices(const struct dmi_header *dm)
265{
266 int i, count = (dm->length - sizeof(struct dmi_header)) / 2;
267
268 for (i = 0; i < count; i++) {
269 const char *d = (char *)(dm + 1) + (i * 2);
270
271
272 if ((*d & 0x80) == 0)
273 continue;
274
275 dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d + 1)));
276 }
277}
278
279static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm)
280{
281 int i, count = *(u8 *)(dm + 1);
282 struct dmi_device *dev;
283
284 for (i = 1; i <= count; i++) {
285 const char *devname = dmi_string(dm, i);
286
287 if (devname == dmi_empty_string)
288 continue;
289
290 dev = dmi_alloc(sizeof(*dev));
291 if (!dev)
292 break;
293
294 dev->type = DMI_DEV_TYPE_OEM_STRING;
295 dev->name = devname;
296 dev->device_data = NULL;
297
298 list_add(&dev->list, &dmi_devices);
299 }
300}
301
302static void __init dmi_save_ipmi_device(const struct dmi_header *dm)
303{
304 struct dmi_device *dev;
305 void *data;
306
307 data = dmi_alloc(dm->length);
308 if (data == NULL)
309 return;
310
311 memcpy(data, dm, dm->length);
312
313 dev = dmi_alloc(sizeof(*dev));
314 if (!dev)
315 return;
316
317 dev->type = DMI_DEV_TYPE_IPMI;
318 dev->name = "IPMI controller";
319 dev->device_data = data;
320
321 list_add_tail(&dev->list, &dmi_devices);
322}
323
324static void __init dmi_save_dev_pciaddr(int instance, int segment, int bus,
325 int devfn, const char *name, int type)
326{
327 struct dmi_dev_onboard *dev;
328
329
330 if (type == DMI_DEV_TYPE_DEV_SLOT &&
331 segment == 0xFFFF && bus == 0xFF && devfn == 0xFF)
332 return;
333
334 dev = dmi_alloc(sizeof(*dev) + strlen(name) + 1);
335 if (!dev)
336 return;
337
338 dev->instance = instance;
339 dev->segment = segment;
340 dev->bus = bus;
341 dev->devfn = devfn;
342
343 strcpy((char *)&dev[1], name);
344 dev->dev.type = type;
345 dev->dev.name = (char *)&dev[1];
346 dev->dev.device_data = dev;
347
348 list_add(&dev->dev.list, &dmi_devices);
349}
350
351static void __init dmi_save_extended_devices(const struct dmi_header *dm)
352{
353 const char *name;
354 const u8 *d = (u8 *)dm;
355
356
357 if ((d[0x5] & 0x80) == 0)
358 return;
359
360 name = dmi_string_nosave(dm, d[0x4]);
361 dmi_save_dev_pciaddr(d[0x6], *(u16 *)(d + 0x7), d[0x9], d[0xA], name,
362 DMI_DEV_TYPE_DEV_ONBOARD);
363 dmi_save_one_device(d[0x5] & 0x7f, name);
364}
365
366static void __init dmi_save_system_slot(const struct dmi_header *dm)
367{
368 const u8 *d = (u8 *)dm;
369
370
371 if (dm->length < 0x11)
372 return;
373 dmi_save_dev_pciaddr(*(u16 *)(d + 0x9), *(u16 *)(d + 0xD), d[0xF],
374 d[0x10], dmi_string_nosave(dm, d[0x4]),
375 DMI_DEV_TYPE_DEV_SLOT);
376}
377
378static void __init count_mem_devices(const struct dmi_header *dm, void *v)
379{
380 if (dm->type != DMI_ENTRY_MEM_DEVICE)
381 return;
382 dmi_memdev_nr++;
383}
384
385static void __init save_mem_devices(const struct dmi_header *dm, void *v)
386{
387 const char *d = (const char *)dm;
388 static int nr;
389
390 if (dm->type != DMI_ENTRY_MEM_DEVICE)
391 return;
392 if (nr >= dmi_memdev_nr) {
393 pr_warn(FW_BUG "Too many DIMM entries in SMBIOS table\n");
394 return;
395 }
396 dmi_memdev[nr].handle = get_unaligned(&dm->handle);
397 dmi_memdev[nr].device = dmi_string(dm, d[0x10]);
398 dmi_memdev[nr].bank = dmi_string(dm, d[0x11]);
399 nr++;
400}
401
402void __init dmi_memdev_walk(void)
403{
404 if (!dmi_available)
405 return;
406
407 if (dmi_walk_early(count_mem_devices) == 0 && dmi_memdev_nr) {
408 dmi_memdev = dmi_alloc(sizeof(*dmi_memdev) * dmi_memdev_nr);
409 if (dmi_memdev)
410 dmi_walk_early(save_mem_devices);
411 }
412}
413
414
415
416
417
418
419static void __init dmi_decode(const struct dmi_header *dm, void *dummy)
420{
421 switch (dm->type) {
422 case 0:
423 dmi_save_ident(dm, DMI_BIOS_VENDOR, 4);
424 dmi_save_ident(dm, DMI_BIOS_VERSION, 5);
425 dmi_save_ident(dm, DMI_BIOS_DATE, 8);
426 break;
427 case 1:
428 dmi_save_ident(dm, DMI_SYS_VENDOR, 4);
429 dmi_save_ident(dm, DMI_PRODUCT_NAME, 5);
430 dmi_save_ident(dm, DMI_PRODUCT_VERSION, 6);
431 dmi_save_ident(dm, DMI_PRODUCT_SERIAL, 7);
432 dmi_save_uuid(dm, DMI_PRODUCT_UUID, 8);
433 break;
434 case 2:
435 dmi_save_ident(dm, DMI_BOARD_VENDOR, 4);
436 dmi_save_ident(dm, DMI_BOARD_NAME, 5);
437 dmi_save_ident(dm, DMI_BOARD_VERSION, 6);
438 dmi_save_ident(dm, DMI_BOARD_SERIAL, 7);
439 dmi_save_ident(dm, DMI_BOARD_ASSET_TAG, 8);
440 break;
441 case 3:
442 dmi_save_ident(dm, DMI_CHASSIS_VENDOR, 4);
443 dmi_save_type(dm, DMI_CHASSIS_TYPE, 5);
444 dmi_save_ident(dm, DMI_CHASSIS_VERSION, 6);
445 dmi_save_ident(dm, DMI_CHASSIS_SERIAL, 7);
446 dmi_save_ident(dm, DMI_CHASSIS_ASSET_TAG, 8);
447 break;
448 case 9:
449 dmi_save_system_slot(dm);
450 break;
451 case 10:
452 dmi_save_devices(dm);
453 break;
454 case 11:
455 dmi_save_oem_strings_devices(dm);
456 break;
457 case 38:
458 dmi_save_ipmi_device(dm);
459 break;
460 case 41:
461 dmi_save_extended_devices(dm);
462 }
463}
464
465static int __init print_filtered(char *buf, size_t len, const char *info)
466{
467 int c = 0;
468 const char *p;
469
470 if (!info)
471 return c;
472
473 for (p = info; *p; p++)
474 if (isprint(*p))
475 c += scnprintf(buf + c, len - c, "%c", *p);
476 else
477 c += scnprintf(buf + c, len - c, "\\x%02x", *p & 0xff);
478 return c;
479}
480
481static void __init dmi_format_ids(char *buf, size_t len)
482{
483 int c = 0;
484 const char *board;
485
486 c += print_filtered(buf + c, len - c,
487 dmi_get_system_info(DMI_SYS_VENDOR));
488 c += scnprintf(buf + c, len - c, " ");
489 c += print_filtered(buf + c, len - c,
490 dmi_get_system_info(DMI_PRODUCT_NAME));
491
492 board = dmi_get_system_info(DMI_BOARD_NAME);
493 if (board) {
494 c += scnprintf(buf + c, len - c, "/");
495 c += print_filtered(buf + c, len - c, board);
496 }
497 c += scnprintf(buf + c, len - c, ", BIOS ");
498 c += print_filtered(buf + c, len - c,
499 dmi_get_system_info(DMI_BIOS_VERSION));
500 c += scnprintf(buf + c, len - c, " ");
501 c += print_filtered(buf + c, len - c,
502 dmi_get_system_info(DMI_BIOS_DATE));
503}
504
505
506
507
508
509
510
511
512static int __init dmi_present(const u8 *buf)
513{
514 u32 smbios_ver;
515
516 if (memcmp(buf, "_SM_", 4) == 0 &&
517 buf[5] < 32 && dmi_checksum(buf, buf[5])) {
518 smbios_ver = get_unaligned_be16(buf + 6);
519 smbios_entry_point_size = buf[5];
520 memcpy(smbios_entry_point, buf, smbios_entry_point_size);
521
522
523 switch (smbios_ver) {
524 case 0x021F:
525 case 0x0221:
526 pr_debug("SMBIOS version fixup (2.%d->2.%d)\n",
527 smbios_ver & 0xFF, 3);
528 smbios_ver = 0x0203;
529 break;
530 case 0x0233:
531 pr_debug("SMBIOS version fixup (2.%d->2.%d)\n", 51, 6);
532 smbios_ver = 0x0206;
533 break;
534 }
535 } else {
536 smbios_ver = 0;
537 }
538
539 buf += 16;
540
541 if (memcmp(buf, "_DMI_", 5) == 0 && dmi_checksum(buf, 15)) {
542 if (smbios_ver)
543 dmi_ver = smbios_ver;
544 else
545 dmi_ver = (buf[14] & 0xF0) << 4 | (buf[14] & 0x0F);
546 dmi_ver <<= 8;
547 dmi_num = get_unaligned_le16(buf + 12);
548 dmi_len = get_unaligned_le16(buf + 6);
549 dmi_base = get_unaligned_le32(buf + 8);
550
551 if (dmi_walk_early(dmi_decode) == 0) {
552 if (smbios_ver) {
553 pr_info("SMBIOS %d.%d present.\n",
554 dmi_ver >> 16, (dmi_ver >> 8) & 0xFF);
555 } else {
556 smbios_entry_point_size = 15;
557 memcpy(smbios_entry_point, buf,
558 smbios_entry_point_size);
559 pr_info("Legacy DMI %d.%d present.\n",
560 dmi_ver >> 16, (dmi_ver >> 8) & 0xFF);
561 }
562 dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string));
563 pr_info("DMI: %s\n", dmi_ids_string);
564 return 0;
565 }
566 }
567
568 return 1;
569}
570
571
572
573
574
575static int __init dmi_smbios3_present(const u8 *buf)
576{
577 if (memcmp(buf, "_SM3_", 5) == 0 &&
578 buf[6] < 32 && dmi_checksum(buf, buf[6])) {
579 dmi_ver = get_unaligned_be32(buf + 6) & 0xFFFFFF;
580 dmi_num = 0;
581 dmi_len = get_unaligned_le32(buf + 12);
582 dmi_base = get_unaligned_le64(buf + 16);
583 smbios_entry_point_size = buf[6];
584 memcpy(smbios_entry_point, buf, smbios_entry_point_size);
585
586 if (dmi_walk_early(dmi_decode) == 0) {
587 pr_info("SMBIOS %d.%d.%d present.\n",
588 dmi_ver >> 16, (dmi_ver >> 8) & 0xFF,
589 dmi_ver & 0xFF);
590 dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string));
591 pr_info("DMI: %s\n", dmi_ids_string);
592 return 0;
593 }
594 }
595 return 1;
596}
597
598void __init dmi_scan_machine(void)
599{
600 char __iomem *p, *q;
601 char buf[32];
602
603 if (efi_enabled(EFI_CONFIG_TABLES)) {
604
605
606
607
608
609
610
611
612
613
614
615
616
617 if (efi.smbios3 != EFI_INVALID_TABLE_ADDR) {
618 p = dmi_early_remap(efi.smbios3, 32);
619 if (p == NULL)
620 goto error;
621 memcpy_fromio(buf, p, 32);
622 dmi_early_unmap(p, 32);
623
624 if (!dmi_smbios3_present(buf)) {
625 dmi_available = 1;
626 goto out;
627 }
628 }
629 if (efi.smbios == EFI_INVALID_TABLE_ADDR)
630 goto error;
631
632
633
634
635
636 p = dmi_early_remap(efi.smbios, 32);
637 if (p == NULL)
638 goto error;
639 memcpy_fromio(buf, p, 32);
640 dmi_early_unmap(p, 32);
641
642 if (!dmi_present(buf)) {
643 dmi_available = 1;
644 goto out;
645 }
646 } else if (IS_ENABLED(CONFIG_DMI_SCAN_MACHINE_NON_EFI_FALLBACK)) {
647 p = dmi_early_remap(0xF0000, 0x10000);
648 if (p == NULL)
649 goto error;
650
651
652
653
654
655
656
657
658 memset(buf, 0, 16);
659 for (q = p; q < p + 0x10000; q += 16) {
660 memcpy_fromio(buf + 16, q, 16);
661 if (!dmi_smbios3_present(buf) || !dmi_present(buf)) {
662 dmi_available = 1;
663 dmi_early_unmap(p, 0x10000);
664 goto out;
665 }
666 memcpy(buf, buf + 16, 16);
667 }
668 dmi_early_unmap(p, 0x10000);
669 }
670 error:
671 pr_info("DMI not present or invalid.\n");
672 out:
673 dmi_initialized = 1;
674}
675
676static ssize_t raw_table_read(struct file *file, struct kobject *kobj,
677 struct bin_attribute *attr, char *buf,
678 loff_t pos, size_t count)
679{
680 memcpy(buf, attr->private + pos, count);
681 return count;
682}
683
684static BIN_ATTR(smbios_entry_point, S_IRUSR, raw_table_read, NULL, 0);
685static BIN_ATTR(DMI, S_IRUSR, raw_table_read, NULL, 0);
686
687static int __init dmi_init(void)
688{
689 struct kobject *tables_kobj;
690 u8 *dmi_table;
691 int ret = -ENOMEM;
692
693 if (!dmi_available) {
694 ret = -ENODATA;
695 goto err;
696 }
697
698
699
700
701
702
703 dmi_kobj = kobject_create_and_add("dmi", firmware_kobj);
704 if (!dmi_kobj)
705 goto err;
706
707 tables_kobj = kobject_create_and_add("tables", dmi_kobj);
708 if (!tables_kobj)
709 goto err;
710
711 dmi_table = dmi_remap(dmi_base, dmi_len);
712 if (!dmi_table)
713 goto err_tables;
714
715 bin_attr_smbios_entry_point.size = smbios_entry_point_size;
716 bin_attr_smbios_entry_point.private = smbios_entry_point;
717 ret = sysfs_create_bin_file(tables_kobj, &bin_attr_smbios_entry_point);
718 if (ret)
719 goto err_unmap;
720
721 bin_attr_DMI.size = dmi_len;
722 bin_attr_DMI.private = dmi_table;
723 ret = sysfs_create_bin_file(tables_kobj, &bin_attr_DMI);
724 if (!ret)
725 return 0;
726
727 sysfs_remove_bin_file(tables_kobj,
728 &bin_attr_smbios_entry_point);
729 err_unmap:
730 dmi_unmap(dmi_table);
731 err_tables:
732 kobject_del(tables_kobj);
733 kobject_put(tables_kobj);
734 err:
735 pr_err("dmi: Firmware registration failed.\n");
736
737 return ret;
738}
739subsys_initcall(dmi_init);
740
741
742
743
744
745
746
747
748
749void __init dmi_set_dump_stack_arch_desc(void)
750{
751 dump_stack_set_arch_desc("%s", dmi_ids_string);
752}
753
754
755
756
757
758static bool dmi_matches(const struct dmi_system_id *dmi)
759{
760 int i;
761
762 WARN(!dmi_initialized, KERN_ERR "dmi check: not initialized yet.\n");
763
764 for (i = 0; i < ARRAY_SIZE(dmi->matches); i++) {
765 int s = dmi->matches[i].slot;
766 if (s == DMI_NONE)
767 break;
768 if (dmi_ident[s]) {
769 if (!dmi->matches[i].exact_match &&
770 strstr(dmi_ident[s], dmi->matches[i].substr))
771 continue;
772 else if (dmi->matches[i].exact_match &&
773 !strcmp(dmi_ident[s], dmi->matches[i].substr))
774 continue;
775 }
776
777
778 return false;
779 }
780 return true;
781}
782
783
784
785
786
787static bool dmi_is_end_of_table(const struct dmi_system_id *dmi)
788{
789 return dmi->matches[0].slot == DMI_NONE;
790}
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805int dmi_check_system(const struct dmi_system_id *list)
806{
807 int count = 0;
808 const struct dmi_system_id *d;
809
810 for (d = list; !dmi_is_end_of_table(d); d++)
811 if (dmi_matches(d)) {
812 count++;
813 if (d->callback && d->callback(d))
814 break;
815 }
816
817 return count;
818}
819EXPORT_SYMBOL(dmi_check_system);
820
821
822
823
824
825
826
827
828
829
830
831
832
833const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list)
834{
835 const struct dmi_system_id *d;
836
837 for (d = list; !dmi_is_end_of_table(d); d++)
838 if (dmi_matches(d))
839 return d;
840
841 return NULL;
842}
843EXPORT_SYMBOL(dmi_first_match);
844
845
846
847
848
849
850
851
852const char *dmi_get_system_info(int field)
853{
854 return dmi_ident[field];
855}
856EXPORT_SYMBOL(dmi_get_system_info);
857
858
859
860
861
862int dmi_name_in_serial(const char *str)
863{
864 int f = DMI_PRODUCT_SERIAL;
865 if (dmi_ident[f] && strstr(dmi_ident[f], str))
866 return 1;
867 return 0;
868}
869
870
871
872
873
874int dmi_name_in_vendors(const char *str)
875{
876 static int fields[] = { DMI_SYS_VENDOR, DMI_BOARD_VENDOR, DMI_NONE };
877 int i;
878 for (i = 0; fields[i] != DMI_NONE; i++) {
879 int f = fields[i];
880 if (dmi_ident[f] && strstr(dmi_ident[f], str))
881 return 1;
882 }
883 return 0;
884}
885EXPORT_SYMBOL(dmi_name_in_vendors);
886
887
888
889
890
891
892
893
894
895
896
897
898
899const struct dmi_device *dmi_find_device(int type, const char *name,
900 const struct dmi_device *from)
901{
902 const struct list_head *head = from ? &from->list : &dmi_devices;
903 struct list_head *d;
904
905 for (d = head->next; d != &dmi_devices; d = d->next) {
906 const struct dmi_device *dev =
907 list_entry(d, struct dmi_device, list);
908
909 if (((type == DMI_DEV_TYPE_ANY) || (dev->type == type)) &&
910 ((name == NULL) || (strcmp(dev->name, name) == 0)))
911 return dev;
912 }
913
914 return NULL;
915}
916EXPORT_SYMBOL(dmi_find_device);
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp)
937{
938 int year = 0, month = 0, day = 0;
939 bool exists;
940 const char *s, *y;
941 char *e;
942
943 s = dmi_get_system_info(field);
944 exists = s;
945 if (!exists)
946 goto out;
947
948
949
950
951
952
953
954 y = strrchr(s, '/');
955 if (!y)
956 goto out;
957
958 y++;
959 year = simple_strtoul(y, &e, 10);
960 if (y != e && year < 100) {
961 year += 1900;
962 if (year < 1996)
963 year += 100;
964 }
965 if (year > 9999)
966 year = 0;
967
968
969 month = simple_strtoul(s, &e, 10);
970 if (s == e || *e != '/' || !month || month > 12) {
971 month = 0;
972 goto out;
973 }
974
975 s = e + 1;
976 day = simple_strtoul(s, &e, 10);
977 if (s == y || s == e || *e != '/' || day > 31)
978 day = 0;
979out:
980 if (yearp)
981 *yearp = year;
982 if (monthp)
983 *monthp = month;
984 if (dayp)
985 *dayp = day;
986 return exists;
987}
988EXPORT_SYMBOL(dmi_get_date);
989
990
991
992
993
994
995
996
997int dmi_walk(void (*decode)(const struct dmi_header *, void *),
998 void *private_data)
999{
1000 u8 *buf;
1001
1002 if (!dmi_available)
1003 return -1;
1004
1005 buf = dmi_remap(dmi_base, dmi_len);
1006 if (buf == NULL)
1007 return -1;
1008
1009 dmi_decode_table(buf, decode, private_data);
1010
1011 dmi_unmap(buf);
1012 return 0;
1013}
1014EXPORT_SYMBOL_GPL(dmi_walk);
1015
1016
1017
1018
1019
1020
1021
1022
1023bool dmi_match(enum dmi_field f, const char *str)
1024{
1025 const char *info = dmi_get_system_info(f);
1026
1027 if (info == NULL || str == NULL)
1028 return info == str;
1029
1030 return !strcmp(info, str);
1031}
1032EXPORT_SYMBOL_GPL(dmi_match);
1033
1034void dmi_memdev_name(u16 handle, const char **bank, const char **device)
1035{
1036 int n;
1037
1038 if (dmi_memdev == NULL)
1039 return;
1040
1041 for (n = 0; n < dmi_memdev_nr; n++) {
1042 if (handle == dmi_memdev[n].handle) {
1043 *bank = dmi_memdev[n].bank;
1044 *device = dmi_memdev[n].device;
1045 break;
1046 }
1047 }
1048}
1049EXPORT_SYMBOL_GPL(dmi_memdev_name);
1050