]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/firmware/dmi_scan.c
Merge branch 'linus' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[karo-tx-linux.git] / drivers / firmware / dmi_scan.c
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 struct kobject *dmi_kobj;
14 EXPORT_SYMBOL_GPL(dmi_kobj);
15
16 /*
17  * DMI stands for "Desktop Management Interface".  It is part
18  * of and an antecedent to, SMBIOS, which stands for System
19  * Management BIOS.  See further: http://www.dmtf.org/standards
20  */
21 static const char dmi_empty_string[] = "        ";
22
23 static u32 dmi_ver __initdata;
24 static u32 dmi_len;
25 static u16 dmi_num;
26 static u8 smbios_entry_point[32];
27 static int smbios_entry_point_size;
28
29 /*
30  * Catch too early calls to dmi_check_system():
31  */
32 static int dmi_initialized;
33
34 /* DMI system identification string used during boot */
35 static char dmi_ids_string[128] __initdata;
36
37 static struct dmi_memdev_info {
38         const char *device;
39         const char *bank;
40         u16 handle;
41 } *dmi_memdev;
42 static int dmi_memdev_nr;
43
44 static 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
68 static 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  *      We have to be cautious here. We have seen BIOSes with DMI pointers
87  *      pointing to completely the wrong place for example
88  */
89 static 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          * Stop when we have seen all the items the table claimed to have
98          * (SMBIOS < 3.0 only) OR we reach an end-of-table marker (SMBIOS
99          * >= 3.0 only) OR we run off the end of the table (should never
100          * happen but sometimes does on bogus implementations.)
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                  *  We want to know the total length (formatted area and
108                  *  strings) before decoding to make sure we won't run off the
109                  *  table in dmi_decode or dmi_string
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                  * 7.45 End-of-Table (Type 127) [SMBIOS reference spec v3.0.0]
122                  * For tables behind a 64-bit entry point, we have no item
123                  * count and no exact table length, so stop on end-of-table
124                  * marker. For tables behind a 32-bit entry point, we have
125                  * seen OEM structures behind the end-of-table marker on
126                  * some systems, so don't trust it.
127                  */
128                 if (!dmi_num && dm->type == DMI_ENTRY_END_OF_TABLE)
129                         break;
130         }
131
132         /* Trim DMI table length if needed */
133         if (dmi_len > data - buf)
134                 dmi_len = data - buf;
135 }
136
137 static phys_addr_t dmi_base;
138
139 static 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
157 static 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
168 static const char *dmi_ident[DMI_STRING_MAX];
169 static LIST_HEAD(dmi_devices);
170 int dmi_available;
171
172 /*
173  *      Save a DMI string
174  */
175 static 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
191 static 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          * As of version 2.6 of the SMBIOS specification, the first 3 fields of
217          * the UUID are supposed to be little-endian encoded.  The specification
218          * says that this is the defacto standard.
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
228 static 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
245 static void __init dmi_save_one_device(int type, const char *name)
246 {
247         struct dmi_device *dev;
248
249         /* No duplicate device */
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
264 static 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                 /* Skip disabled device */
272                 if ((*d & 0x80) == 0)
273                         continue;
274
275                 dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d + 1)));
276         }
277 }
278
279 static 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
302 static 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
324 static 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         /* Ignore invalid values */
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
351 static void __init dmi_save_extended_devices(const struct dmi_header *dm)
352 {
353         const char *name;
354         const u8 *d = (u8 *)dm;
355
356         /* Skip disabled device */
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
366 static void __init dmi_save_system_slot(const struct dmi_header *dm)
367 {
368         const u8 *d = (u8 *)dm;
369
370         /* Need SMBIOS 2.6+ structure */
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
378 static 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
385 static 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
402 void __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  *      Process a DMI table entry. Right now all we care about are the BIOS
416  *      and machine entries. For 2.5 we should pull the smbus controller info
417  *      out of here.
418  */
419 static void __init dmi_decode(const struct dmi_header *dm, void *dummy)
420 {
421         switch (dm->type) {
422         case 0:         /* BIOS Information */
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:         /* System Information */
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:         /* Base Board Information */
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:         /* Chassis Information */
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:         /* System Slots */
449                 dmi_save_system_slot(dm);
450                 break;
451         case 10:        /* Onboard Devices Information */
452                 dmi_save_devices(dm);
453                 break;
454         case 11:        /* OEM Strings */
455                 dmi_save_oem_strings_devices(dm);
456                 break;
457         case 38:        /* IPMI Device Information */
458                 dmi_save_ipmi_device(dm);
459                 break;
460         case 41:        /* Onboard Devices Extended Information */
461                 dmi_save_extended_devices(dm);
462         }
463 }
464
465 static 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
481 static void __init dmi_format_ids(char *buf, size_t len)
482 {
483         int c = 0;
484         const char *board;      /* Board Name is optional */
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  * Check for DMI/SMBIOS headers in the system firmware image.  Any
507  * SMBIOS header must start 16 bytes before the DMI header, so take a
508  * 32 byte buffer and check for DMI at offset 16 and SMBIOS at offset
509  * 0.  If the DMI header is present, set dmi_ver accordingly (SMBIOS
510  * takes precedence) and return 0.  Otherwise return 1.
511  */
512 static 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                 /* Some BIOS report weird SMBIOS version, fix that up */
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                         printk(KERN_DEBUG "DMI: %s\n", dmi_ids_string);
564                         return 0;
565                 }
566         }
567
568         return 1;
569 }
570
571 /*
572  * Check for the SMBIOS 3.0 64-bit entry point signature. Unlike the legacy
573  * 32-bit entry point, there is no embedded DMI header (_DMI_) in here.
574  */
575 static 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;                    /* No longer specified */
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_debug("DMI: %s\n", dmi_ids_string);
592                         return 0;
593                 }
594         }
595         return 1;
596 }
597
598 void __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                  * According to the DMTF SMBIOS reference spec v3.0.0, it is
606                  * allowed to define both the 64-bit entry point (smbios3) and
607                  * the 32-bit entry point (smbios), in which case they should
608                  * either both point to the same SMBIOS structure table, or the
609                  * table pointed to by the 64-bit entry point should contain a
610                  * superset of the table contents pointed to by the 32-bit entry
611                  * point (section 5.2)
612                  * This implies that the 64-bit entry point should have
613                  * precedence if it is defined and supported by the OS. If we
614                  * have the 64-bit entry point, but fail to decode it, fall
615                  * back to the legacy one (if available)
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                 /* This is called as a core_initcall() because it isn't
633                  * needed during early boot.  This also means we can
634                  * iounmap the space when we're done with it.
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                  * Iterate over all possible DMI header addresses q.
653                  * Maintain the 32 bytes around q in buf.  On the
654                  * first iteration, substitute zero for the
655                  * out-of-range bytes so there is no chance of falsely
656                  * detecting an SMBIOS header.
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
676 static 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
684 static BIN_ATTR(smbios_entry_point, S_IRUSR, raw_table_read, NULL, 0);
685 static BIN_ATTR(DMI, S_IRUSR, raw_table_read, NULL, 0);
686
687 static 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          * Set up dmi directory at /sys/firmware/dmi. This entry should stay
700          * even after farther error, as it can be used by other modules like
701          * dmi-sysfs.
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 }
739 subsys_initcall(dmi_init);
740
741 /**
742  * dmi_set_dump_stack_arch_desc - set arch description for dump_stack()
743  *
744  * Invoke dump_stack_set_arch_desc() with DMI system information so that
745  * DMI identifiers are printed out on task dumps.  Arch boot code should
746  * call this function after dmi_scan_machine() if it wants to print out DMI
747  * identifiers on task dumps.
748  */
749 void __init dmi_set_dump_stack_arch_desc(void)
750 {
751         dump_stack_set_arch_desc("%s", dmi_ids_string);
752 }
753
754 /**
755  *      dmi_matches - check if dmi_system_id structure matches system DMI data
756  *      @dmi: pointer to the dmi_system_id structure to check
757  */
758 static 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                 /* No match */
778                 return false;
779         }
780         return true;
781 }
782
783 /**
784  *      dmi_is_end_of_table - check for end-of-table marker
785  *      @dmi: pointer to the dmi_system_id structure to check
786  */
787 static 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  *      dmi_check_system - check system DMI data
794  *      @list: array of dmi_system_id structures to match against
795  *              All non-null elements of the list must match
796  *              their slot's (field index's) data (i.e., each
797  *              list string must be a substring of the specified
798  *              DMI slot's string data) to be considered a
799  *              successful match.
800  *
801  *      Walk the blacklist table running matching functions until someone
802  *      returns non zero or we hit the end. Callback function is called for
803  *      each successful match. Returns the number of matches.
804  */
805 int 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 }
819 EXPORT_SYMBOL(dmi_check_system);
820
821 /**
822  *      dmi_first_match - find dmi_system_id structure matching system DMI data
823  *      @list: array of dmi_system_id structures to match against
824  *              All non-null elements of the list must match
825  *              their slot's (field index's) data (i.e., each
826  *              list string must be a substring of the specified
827  *              DMI slot's string data) to be considered a
828  *              successful match.
829  *
830  *      Walk the blacklist table until the first match is found.  Return the
831  *      pointer to the matching entry or NULL if there's no match.
832  */
833 const 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 }
843 EXPORT_SYMBOL(dmi_first_match);
844
845 /**
846  *      dmi_get_system_info - return DMI data value
847  *      @field: data index (see enum dmi_field)
848  *
849  *      Returns one DMI data value, can be used to perform
850  *      complex DMI data checks.
851  */
852 const char *dmi_get_system_info(int field)
853 {
854         return dmi_ident[field];
855 }
856 EXPORT_SYMBOL(dmi_get_system_info);
857
858 /**
859  * dmi_name_in_serial - Check if string is in the DMI product serial information
860  * @str: string to check for
861  */
862 int 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  *      dmi_name_in_vendors - Check if string is in the DMI system or board vendor name
872  *      @str: Case sensitive Name
873  */
874 int 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 }
885 EXPORT_SYMBOL(dmi_name_in_vendors);
886
887 /**
888  *      dmi_find_device - find onboard device by type/name
889  *      @type: device type or %DMI_DEV_TYPE_ANY to match all device types
890  *      @name: device name string or %NULL to match all
891  *      @from: previous device found in search, or %NULL for new search.
892  *
893  *      Iterates through the list of known onboard devices. If a device is
894  *      found with a matching @type and @name, a pointer to its device
895  *      structure is returned.  Otherwise, %NULL is returned.
896  *      A new search is initiated by passing %NULL as the @from argument.
897  *      If @from is not %NULL, searches continue from next device.
898  */
899 const 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 }
916 EXPORT_SYMBOL(dmi_find_device);
917
918 /**
919  *      dmi_get_date - parse a DMI date
920  *      @field: data index (see enum dmi_field)
921  *      @yearp: optional out parameter for the year
922  *      @monthp: optional out parameter for the month
923  *      @dayp: optional out parameter for the day
924  *
925  *      The date field is assumed to be in the form resembling
926  *      [mm[/dd]]/yy[yy] and the result is stored in the out
927  *      parameters any or all of which can be omitted.
928  *
929  *      If the field doesn't exist, all out parameters are set to zero
930  *      and false is returned.  Otherwise, true is returned with any
931  *      invalid part of date set to zero.
932  *
933  *      On return, year, month and day are guaranteed to be in the
934  *      range of [0,9999], [0,12] and [0,31] respectively.
935  */
936 bool 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          * Determine year first.  We assume the date string resembles
950          * mm/dd/yy[yy] but the original code extracted only the year
951          * from the end.  Keep the behavior in the spirit of no
952          * surprises.
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) {     /* 2-digit year */
961                 year += 1900;
962                 if (year < 1996)        /* no dates < spec 1.0 */
963                         year += 100;
964         }
965         if (year > 9999)                /* year should fit in %04d */
966                 year = 0;
967
968         /* parse the mm and dd */
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;
979 out:
980         if (yearp)
981                 *yearp = year;
982         if (monthp)
983                 *monthp = month;
984         if (dayp)
985                 *dayp = day;
986         return exists;
987 }
988 EXPORT_SYMBOL(dmi_get_date);
989
990 /**
991  *      dmi_walk - Walk the DMI table and get called back for every record
992  *      @decode: Callback function
993  *      @private_data: Private data to be passed to the callback function
994  *
995  *      Returns -1 when the DMI table can't be reached, 0 on success.
996  */
997 int 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 }
1014 EXPORT_SYMBOL_GPL(dmi_walk);
1015
1016 /**
1017  * dmi_match - compare a string to the dmi field (if exists)
1018  * @f: DMI field identifier
1019  * @str: string to compare the DMI field to
1020  *
1021  * Returns true if the requested field equals to the str (including NULL).
1022  */
1023 bool 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 }
1032 EXPORT_SYMBOL_GPL(dmi_match);
1033
1034 void 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 }
1049 EXPORT_SYMBOL_GPL(dmi_memdev_name);