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
15
16
17
18static const char dmi_empty_string[] = " ";
19
20static u16 __initdata dmi_ver;
21
22
23
24static int dmi_initialized;
25
26
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
79
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
90
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
97
98 if (dm->type == DMI_ENTRY_END_OF_TABLE)
99 break;
100
101
102
103
104
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
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
197
198
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
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
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
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
377
378
379
380static void __init dmi_decode(const struct dmi_header *dm, void *dummy)
381{
382 switch (dm->type) {
383 case 0:
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:
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:
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:
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:
410 dmi_save_devices(dm);
411 break;
412 case 11:
413 dmi_save_oem_strings_devices(dm);
414 break;
415 case 38:
416 dmi_save_ipmi_device(dm);
417 break;
418 case 41:
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;
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
465
466
467
468
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
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
524
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
536
537
538
539
540
541
542
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
565
566
567
568
569
570
571
572
573
574
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
592
593
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
612
613
614
615
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
637
638
639
640
641
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
650
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
672 return false;
673 }
674 return true;
675}
676
677
678
679
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
688
689
690
691
692
693
694
695
696
697
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
717
718
719
720
721
722
723
724
725
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
741
742
743
744
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
754
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
766
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
783
784
785
786
787
788
789
790
791
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
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
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
844
845
846
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) {
855 year += 1900;
856 if (year < 1996)
857 year += 100;
858 }
859 if (year > 9999)
860 year = 0;
861
862
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
886
887
888
889
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
912
913
914
915
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