blob: 88bebe1968b717b4060a449ff49278cee2a84315 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07002#include <linux/string.h>
3#include <linux/init.h>
4#include <linux/module.h>
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -07005#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006#include <linux/dmi.h>
Matt Domsch3ed3bce2006-03-26 01:37:03 -08007#include <linux/efi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/bootmem.h>
Tony Luckd114a332012-07-20 13:15:20 -07009#include <linux/random.h>
Andi Kleenf2d3efe2006-03-25 16:30:22 +010010#include <asm/dmi.h>
Luck, Tony0841c042013-11-01 13:59:52 -070011#include <asm/unaligned.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012
Ivan Khoronzhukd7f96f972015-06-25 09:06:56 +020013struct kobject *dmi_kobj;
14EXPORT_SYMBOL_GPL(dmi_kobj);
15
Paul Jacksoncb5dd7c2008-05-14 08:15:16 -070016/*
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 */
Jean Delvareffbbb962013-09-11 14:24:09 -070021static const char dmi_empty_string[] = " ";
Parag Warudkar79da4722008-01-30 13:31:59 +010022
Ivan Khoronzhuk95be58d2015-02-18 13:33:20 +020023static u32 dmi_ver __initdata;
Ivan Khoronzhuk552e19d82015-02-18 13:33:21 +020024static u32 dmi_len;
25static u16 dmi_num;
Ivan Khoronzhukd7f96f972015-06-25 09:06:56 +020026static u8 smbios_entry_point[32];
27static int smbios_entry_point_size;
28
Ingo Molnar9a22b6e2008-09-18 12:50:18 +020029/*
30 * Catch too early calls to dmi_check_system():
31 */
32static int dmi_initialized;
33
Tejun Heoc90fe6b2013-04-30 15:27:14 -070034/* DMI system identification string used during boot */
35static char dmi_ids_string[128] __initdata;
36
Chen, Gongdd6dad42013-10-18 14:29:25 -070037static struct dmi_memdev_info {
38 const char *device;
39 const char *bank;
40 u16 handle;
41} *dmi_memdev;
42static int dmi_memdev_nr;
43
Jean Delvaref3069ae2008-02-23 15:23:46 -080044static const char * __init dmi_string_nosave(const struct dmi_header *dm, u8 s)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045{
Jeff Garzik18552562007-10-03 15:15:40 -040046 const u8 *bp = ((u8 *) dm) + dm->length;
Andrey Panin1249c512005-06-25 14:54:47 -070047
Andrey Paninc3c71202005-09-06 15:18:28 -070048 if (s) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 s--;
Andrey Paninc3c71202005-09-06 15:18:28 -070050 while (s > 0 && *bp) {
51 bp += strlen(bp) + 1;
52 s--;
53 }
54
55 if (*bp != 0) {
Parag Warudkar79da4722008-01-30 13:31:59 +010056 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;
Jean Delvaref3069ae2008-02-23 15:23:46 -080061 return bp;
Andrey Paninc3c71202005-09-06 15:18:28 -070062 }
Bjorn Helgaas4f705ae2006-04-03 17:09:22 -070063 }
Andrey Paninc3c71202005-09-06 15:18:28 -070064
Jean Delvaref3069ae2008-02-23 15:23:46 -080065 return "";
66}
67
Jean Delvareffbbb962013-09-11 14:24:09 -070068static const char * __init dmi_string(const struct dmi_header *dm, u8 s)
Jean Delvaref3069ae2008-02-23 15:23:46 -080069{
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);
Jean Delvaref3069ae2008-02-23 15:23:46 -080081
Andrey Paninc3c71202005-09-06 15:18:28 -070082 return str;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083}
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 */
Ivan Khoronzhukeb4c5ea2015-06-25 09:06:56 +020089static void dmi_decode_table(u8 *buf,
90 void (*decode)(const struct dmi_header *, void *),
91 void *private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092{
Jean Delvare7fce0842007-11-03 17:29:20 +010093 u8 *data = buf;
Andrey Panin1249c512005-06-25 14:54:47 -070094 int i = 0;
Bjorn Helgaas4f705ae2006-04-03 17:09:22 -070095
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 /*
Jean Delvarebfbaafa2015-03-20 09:59:47 +010097 * Stop when we have seen all the items the table claimed to have
Jean Delvare17cd5bd2015-06-25 09:06:55 +020098 * (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.)
Bjorn Helgaas4f705ae2006-04-03 17:09:22 -0700101 */
Linus Torvalds9c65e122015-04-13 10:22:30 -0700102 while ((!dmi_num || i < dmi_num) &&
103 (data - buf + sizeof(struct dmi_header)) <= dmi_len) {
Jeff Garzik18552562007-10-03 15:15:40 -0400104 const struct dmi_header *dm = (const struct dmi_header *)data;
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 /*
Alan Cox86385452008-11-07 16:03:46 +0000107 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 */
Andrey Panin1249c512005-06-25 14:54:47 -0700111 data += dm->length;
Ivan Khoronzhuk552e19d82015-02-18 13:33:21 +0200112 while ((data - buf < dmi_len - 1) && (data[0] || data[1]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 data++;
Ivan Khoronzhuk552e19d82015-02-18 13:33:21 +0200114 if (data - buf < dmi_len - 1)
Jean Delvaree7a19c562009-03-30 21:46:44 +0200115 decode(dm, private_data);
Ivan Khoronzhukce204e92015-02-18 15:51:41 +0200116
Jean Delvare6e0ad592015-06-25 09:06:56 +0200117 data += 2;
118 i++;
119
Ivan Khoronzhukce204e92015-02-18 15:51:41 +0200120 /*
121 * 7.45 End-of-Table (Type 127) [SMBIOS reference spec v3.0.0]
Jean Delvare17cd5bd2015-06-25 09:06:55 +0200122 * 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.
Ivan Khoronzhukce204e92015-02-18 15:51:41 +0200127 */
Jean Delvare17cd5bd2015-06-25 09:06:55 +0200128 if (!dmi_num && dm->type == DMI_ENTRY_END_OF_TABLE)
Ivan Khoronzhukce204e92015-02-18 15:51:41 +0200129 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 }
Jean Delvare6e0ad592015-06-25 09:06:56 +0200131
132 /* Trim DMI table length if needed */
133 if (dmi_len > data - buf)
134 dmi_len = data - buf;
Jean Delvare7fce0842007-11-03 17:29:20 +0100135}
136
Ard Biesheuvelfc430262014-10-14 16:41:27 +0200137static phys_addr_t dmi_base;
Jean Delvare7fce0842007-11-03 17:29:20 +0100138
Jean Delvaree7a19c562009-03-30 21:46:44 +0200139static int __init dmi_walk_early(void (*decode)(const struct dmi_header *,
140 void *))
Jean Delvare7fce0842007-11-03 17:29:20 +0100141{
142 u8 *buf;
Jean Delvare6e0ad592015-06-25 09:06:56 +0200143 u32 orig_dmi_len = dmi_len;
Jean Delvare7fce0842007-11-03 17:29:20 +0100144
Jean Delvare6e0ad592015-06-25 09:06:56 +0200145 buf = dmi_early_remap(dmi_base, orig_dmi_len);
Jean Delvare7fce0842007-11-03 17:29:20 +0100146 if (buf == NULL)
147 return -1;
148
Ivan Khoronzhukeb4c5ea2015-06-25 09:06:56 +0200149 dmi_decode_table(buf, decode, NULL);
Jean Delvare7fce0842007-11-03 17:29:20 +0100150
Tony Luckd114a332012-07-20 13:15:20 -0700151 add_device_randomness(buf, dmi_len);
152
Jean Delvare6e0ad592015-06-25 09:06:56 +0200153 dmi_early_unmap(buf, orig_dmi_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 return 0;
155}
156
Zhenzhong Duan9f9c9cbb2012-12-20 15:05:14 -0800157static int __init dmi_checksum(const u8 *buf, u8 len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158{
Andrey Panin1249c512005-06-25 14:54:47 -0700159 u8 sum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 int a;
Bjorn Helgaas4f705ae2006-04-03 17:09:22 -0700161
Zhenzhong Duan9f9c9cbb2012-12-20 15:05:14 -0800162 for (a = 0; a < len; a++)
Andrey Panin1249c512005-06-25 14:54:47 -0700163 sum += buf[a];
164
165 return sum == 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166}
167
Jean Delvareffbbb962013-09-11 14:24:09 -0700168static const char *dmi_ident[DMI_STRING_MAX];
Andrey Paninebad6a42005-09-06 15:18:29 -0700169static LIST_HEAD(dmi_devices);
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200170int dmi_available;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171
172/*
173 * Save a DMI string
174 */
Jean Delvare02d9c472013-09-11 14:24:08 -0700175static void __init dmi_save_ident(const struct dmi_header *dm, int slot,
176 int string)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177{
Jean Delvare02d9c472013-09-11 14:24:08 -0700178 const char *d = (const char *) dm;
Jean Delvareffbbb962013-09-11 14:24:09 -0700179 const char *p;
Andrey Panin1249c512005-06-25 14:54:47 -0700180
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 if (dmi_ident[slot])
182 return;
Andrey Panin1249c512005-06-25 14:54:47 -0700183
Andrey Paninc3c71202005-09-06 15:18:28 -0700184 p = dmi_string(dm, d[string]);
185 if (p == NULL)
186 return;
187
188 dmi_ident[slot] = p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189}
190
Jean Delvare02d9c472013-09-11 14:24:08 -0700191static void __init dmi_save_uuid(const struct dmi_header *dm, int slot,
192 int index)
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200193{
Jean Delvare02d9c472013-09-11 14:24:08 -0700194 const u8 *d = (u8 *) dm + index;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200195 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++) {
Zhenzhong Duanf1d8e612012-12-20 15:05:13 -0800202 if (d[i] != 0x00)
203 is_00 = 0;
204 if (d[i] != 0xFF)
205 is_ff = 0;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200206 }
207
208 if (is_ff || is_00)
209 return;
210
211 s = dmi_alloc(16*2+4+1);
212 if (!s)
213 return;
214
Zhenzhong Duanf1d8e612012-12-20 15:05:13 -0800215 /*
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 */
Ivan Khoronzhuk95be58d2015-02-18 13:33:20 +0200220 if (dmi_ver >= 0x020600)
Zhenzhong Duanf1d8e612012-12-20 15:05:13 -0800221 sprintf(s, "%pUL", d);
222 else
223 sprintf(s, "%pUB", d);
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200224
Jean Delvare02d9c472013-09-11 14:24:08 -0700225 dmi_ident[slot] = s;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200226}
227
Jean Delvare02d9c472013-09-11 14:24:08 -0700228static void __init dmi_save_type(const struct dmi_header *dm, int slot,
229 int index)
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200230{
Jean Delvare02d9c472013-09-11 14:24:08 -0700231 const u8 *d = (u8 *) dm + index;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200232 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
Jean Delvaref3069ae2008-02-23 15:23:46 -0800245static 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);
Jean Delvareae797442013-09-11 14:24:10 -0700254 if (!dev)
Jean Delvaref3069ae2008-02-23 15:23:46 -0800255 return;
Jean Delvaref3069ae2008-02-23 15:23:46 -0800256
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
Jeff Garzik18552562007-10-03 15:15:40 -0400264static void __init dmi_save_devices(const struct dmi_header *dm)
Andrey Paninebad6a42005-09-06 15:18:29 -0700265{
266 int i, count = (dm->length - sizeof(struct dmi_header)) / 2;
Andrey Paninebad6a42005-09-06 15:18:29 -0700267
268 for (i = 0; i < count; i++) {
Jeff Garzik18552562007-10-03 15:15:40 -0400269 const char *d = (char *)(dm + 1) + (i * 2);
Andrey Paninebad6a42005-09-06 15:18:29 -0700270
271 /* Skip disabled device */
272 if ((*d & 0x80) == 0)
273 continue;
274
Jean Delvaref3069ae2008-02-23 15:23:46 -0800275 dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d + 1)));
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700276 }
277}
278
Jeff Garzik18552562007-10-03 15:15:40 -0400279static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm)
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700280{
281 int i, count = *(u8 *)(dm + 1);
282 struct dmi_device *dev;
283
284 for (i = 1; i <= count; i++) {
Jean Delvareffbbb962013-09-11 14:24:09 -0700285 const char *devname = dmi_string(dm, i);
Parag Warudkar79da4722008-01-30 13:31:59 +0100286
Jean Delvare43fe1052008-02-23 15:23:55 -0800287 if (devname == dmi_empty_string)
Parag Warudkar79da4722008-01-30 13:31:59 +0100288 continue;
Parag Warudkar79da4722008-01-30 13:31:59 +0100289
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700290 dev = dmi_alloc(sizeof(*dev));
Jean Delvareae797442013-09-11 14:24:10 -0700291 if (!dev)
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700292 break;
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700293
294 dev->type = DMI_DEV_TYPE_OEM_STRING;
Parag Warudkar79da4722008-01-30 13:31:59 +0100295 dev->name = devname;
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700296 dev->device_data = NULL;
Andrey Paninebad6a42005-09-06 15:18:29 -0700297
298 list_add(&dev->list, &dmi_devices);
299 }
300}
301
Jeff Garzik18552562007-10-03 15:15:40 -0400302static void __init dmi_save_ipmi_device(const struct dmi_header *dm)
Andrey Paninebad6a42005-09-06 15:18:29 -0700303{
304 struct dmi_device *dev;
Jean Delvare02d9c472013-09-11 14:24:08 -0700305 void *data;
Andrey Paninebad6a42005-09-06 15:18:29 -0700306
Andi Kleene9928672006-01-11 22:43:33 +0100307 data = dmi_alloc(dm->length);
Jean Delvareae797442013-09-11 14:24:10 -0700308 if (data == NULL)
Andrey Paninebad6a42005-09-06 15:18:29 -0700309 return;
Andrey Paninebad6a42005-09-06 15:18:29 -0700310
311 memcpy(data, dm, dm->length);
312
Andi Kleene9928672006-01-11 22:43:33 +0100313 dev = dmi_alloc(sizeof(*dev));
Jean Delvareae797442013-09-11 14:24:10 -0700314 if (!dev)
Andrey Paninebad6a42005-09-06 15:18:29 -0700315 return;
Andrey Paninebad6a42005-09-06 15:18:29 -0700316
317 dev->type = DMI_DEV_TYPE_IPMI;
318 dev->name = "IPMI controller";
319 dev->device_data = data;
320
Carol Hebertabd24df2008-04-04 14:30:03 -0700321 list_add_tail(&dev->list, &dmi_devices);
Andrey Paninebad6a42005-09-06 15:18:29 -0700322}
323
Jordan Hargravee5b6c152016-01-15 22:08:45 +0100324static void __init dmi_save_dev_pciaddr(int instance, int segment, int bus,
325 int devfn, const char *name, int type)
Narendra K911e1c92010-07-26 05:56:50 -0500326{
Jordan Hargravee5b6c152016-01-15 22:08:45 +0100327 struct dmi_dev_onboard *dev;
Narendra K911e1c92010-07-26 05:56:50 -0500328
Jordan Hargravee5b6c152016-01-15 22:08:45 +0100329 /* Ignore invalid values */
330 if (type == DMI_DEV_TYPE_DEV_SLOT &&
331 segment == 0xFFFF && bus == 0xFF && devfn == 0xFF)
Narendra K911e1c92010-07-26 05:56:50 -0500332 return;
Jean Delvareae797442013-09-11 14:24:10 -0700333
Jordan Hargravee5b6c152016-01-15 22:08:45 +0100334 dev = dmi_alloc(sizeof(*dev) + strlen(name) + 1);
335 if (!dev)
336 return;
Narendra K911e1c92010-07-26 05:56:50 -0500337
Jordan Hargravee5b6c152016-01-15 22:08:45 +0100338 dev->instance = instance;
339 dev->segment = segment;
340 dev->bus = bus;
341 dev->devfn = devfn;
Narendra K911e1c92010-07-26 05:56:50 -0500342
Jordan Hargravee5b6c152016-01-15 22:08:45 +0100343 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);
Narendra K911e1c92010-07-26 05:56:50 -0500349}
350
Wim Van Sebroeckb4bd7d52008-02-08 04:20:58 -0800351static void __init dmi_save_extended_devices(const struct dmi_header *dm)
352{
Jean Delvare96e23942016-01-15 22:08:44 +0100353 const char *name;
Jean Delvare45b98252016-01-15 22:08:44 +0100354 const u8 *d = (u8 *)dm;
Wim Van Sebroeckb4bd7d52008-02-08 04:20:58 -0800355
356 /* Skip disabled device */
Jean Delvare45b98252016-01-15 22:08:44 +0100357 if ((d[0x5] & 0x80) == 0)
Wim Van Sebroeckb4bd7d52008-02-08 04:20:58 -0800358 return;
359
Jean Delvare45b98252016-01-15 22:08:44 +0100360 name = dmi_string_nosave(dm, d[0x4]);
Jordan Hargravee5b6c152016-01-15 22:08:45 +0100361 dmi_save_dev_pciaddr(d[0x6], *(u16 *)(d + 0x7), d[0x9], d[0xA], name,
362 DMI_DEV_TYPE_DEV_ONBOARD);
Jean Delvare45b98252016-01-15 22:08:44 +0100363 dmi_save_one_device(d[0x5] & 0x7f, name);
Wim Van Sebroeckb4bd7d52008-02-08 04:20:58 -0800364}
365
Jordan Hargravee5b6c152016-01-15 22:08:45 +0100366static 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
Chen, Gongdd6dad42013-10-18 14:29:25 -0700378static 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 }
Luck, Tony0841c042013-11-01 13:59:52 -0700396 dmi_memdev[nr].handle = get_unaligned(&dm->handle);
Chen, Gongdd6dad42013-10-18 14:29:25 -0700397 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 * 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 */
Jean Delvaree7a19c562009-03-30 21:46:44 +0200419static void __init dmi_decode(const struct dmi_header *dm, void *dummy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420{
Jean Delvare02d9c472013-09-11 14:24:08 -0700421 switch (dm->type) {
Andrey Paninebad6a42005-09-06 15:18:29 -0700422 case 0: /* BIOS Information */
Andrey Panin1249c512005-06-25 14:54:47 -0700423 dmi_save_ident(dm, DMI_BIOS_VENDOR, 4);
Andrey Panin1249c512005-06-25 14:54:47 -0700424 dmi_save_ident(dm, DMI_BIOS_VERSION, 5);
Andrey Panin1249c512005-06-25 14:54:47 -0700425 dmi_save_ident(dm, DMI_BIOS_DATE, 8);
426 break;
Andrey Paninebad6a42005-09-06 15:18:29 -0700427 case 1: /* System Information */
Andrey Panin1249c512005-06-25 14:54:47 -0700428 dmi_save_ident(dm, DMI_SYS_VENDOR, 4);
Andrey Panin1249c512005-06-25 14:54:47 -0700429 dmi_save_ident(dm, DMI_PRODUCT_NAME, 5);
Andrey Panin1249c512005-06-25 14:54:47 -0700430 dmi_save_ident(dm, DMI_PRODUCT_VERSION, 6);
Andrey Panin1249c512005-06-25 14:54:47 -0700431 dmi_save_ident(dm, DMI_PRODUCT_SERIAL, 7);
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200432 dmi_save_uuid(dm, DMI_PRODUCT_UUID, 8);
Andrey Panin1249c512005-06-25 14:54:47 -0700433 break;
Andrey Paninebad6a42005-09-06 15:18:29 -0700434 case 2: /* Base Board Information */
Andrey Panin1249c512005-06-25 14:54:47 -0700435 dmi_save_ident(dm, DMI_BOARD_VENDOR, 4);
Andrey Panin1249c512005-06-25 14:54:47 -0700436 dmi_save_ident(dm, DMI_BOARD_NAME, 5);
Andrey Panin1249c512005-06-25 14:54:47 -0700437 dmi_save_ident(dm, DMI_BOARD_VERSION, 6);
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200438 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);
Andrey Panin1249c512005-06-25 14:54:47 -0700447 break;
Jordan Hargravee5b6c152016-01-15 22:08:45 +0100448 case 9: /* System Slots */
449 dmi_save_system_slot(dm);
450 break;
Andrey Paninebad6a42005-09-06 15:18:29 -0700451 case 10: /* Onboard Devices Information */
452 dmi_save_devices(dm);
453 break;
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700454 case 11: /* OEM Strings */
455 dmi_save_oem_strings_devices(dm);
456 break;
Andrey Paninebad6a42005-09-06 15:18:29 -0700457 case 38: /* IPMI Device Information */
458 dmi_save_ipmi_device(dm);
Wim Van Sebroeckb4bd7d52008-02-08 04:20:58 -0800459 break;
460 case 41: /* Onboard Devices Extended Information */
461 dmi_save_extended_devices(dm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 }
463}
464
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700465static int __init print_filtered(char *buf, size_t len, const char *info)
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700466{
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700467 int c = 0;
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700468 const char *p;
469
470 if (!info)
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700471 return c;
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700472
473 for (p = info; *p; p++)
474 if (isprint(*p))
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700475 c += scnprintf(buf + c, len - c, "%c", *p);
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700476 else
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700477 c += scnprintf(buf + c, len - c, "\\x%02x", *p & 0xff);
478 return c;
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700479}
480
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700481static void __init dmi_format_ids(char *buf, size_t len)
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700482{
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700483 int c = 0;
Naga Chumbalkar84e383b2011-02-14 22:47:17 +0000484 const char *board; /* Board Name is optional */
485
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700486 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
Naga Chumbalkar84e383b2011-02-14 22:47:17 +0000492 board = dmi_get_system_info(DMI_BOARD_NAME);
493 if (board) {
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700494 c += scnprintf(buf + c, len - c, "/");
495 c += print_filtered(buf + c, len - c, board);
Naga Chumbalkar84e383b2011-02-14 22:47:17 +0000496 }
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700497 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));
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700503}
504
Ben Hutchingsd39de282013-07-31 13:53:30 -0700505/*
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 */
Ben Hutchings79bae422013-04-30 15:27:46 -0700512static int __init dmi_present(const u8 *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513{
Ivan Khoronzhuk95be58d2015-02-18 13:33:20 +0200514 u32 smbios_ver;
Jeff Garzik18552562007-10-03 15:15:40 -0400515
Ben Hutchings79bae422013-04-30 15:27:46 -0700516 if (memcmp(buf, "_SM_", 4) == 0 &&
517 buf[5] < 32 && dmi_checksum(buf, buf[5])) {
Ard Biesheuvelfc430262014-10-14 16:41:27 +0200518 smbios_ver = get_unaligned_be16(buf + 6);
Ivan Khoronzhukd7f96f972015-06-25 09:06:56 +0200519 smbios_entry_point_size = buf[5];
520 memcpy(smbios_entry_point, buf, smbios_entry_point_size);
Ben Hutchings79bae422013-04-30 15:27:46 -0700521
522 /* Some BIOS report weird SMBIOS version, fix that up */
523 switch (smbios_ver) {
524 case 0x021F:
525 case 0x0221:
Jean Delvared1d87042015-06-25 09:06:57 +0200526 pr_debug("SMBIOS version fixup (2.%d->2.%d)\n",
Ben Hutchings79bae422013-04-30 15:27:46 -0700527 smbios_ver & 0xFF, 3);
528 smbios_ver = 0x0203;
529 break;
530 case 0x0233:
Jean Delvared1d87042015-06-25 09:06:57 +0200531 pr_debug("SMBIOS version fixup (2.%d->2.%d)\n", 51, 6);
Ben Hutchings79bae422013-04-30 15:27:46 -0700532 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)) {
Jean Delvare5c1ac562015-05-14 14:40:50 +0200542 if (smbios_ver)
543 dmi_ver = smbios_ver;
544 else
545 dmi_ver = (buf[14] & 0xF0) << 4 | (buf[14] & 0x0F);
Andrea Arcangeliff4319d2016-01-08 09:00:54 +0100546 dmi_ver <<= 8;
Ard Biesheuvelfc430262014-10-14 16:41:27 +0200547 dmi_num = get_unaligned_le16(buf + 12);
548 dmi_len = get_unaligned_le16(buf + 6);
549 dmi_base = get_unaligned_le32(buf + 8);
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800550
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700551 if (dmi_walk_early(dmi_decode) == 0) {
Ben Hutchings79bae422013-04-30 15:27:46 -0700552 if (smbios_ver) {
Jean Delvarec2493042015-05-14 14:40:50 +0200553 pr_info("SMBIOS %d.%d present.\n",
Andrea Arcangeliff4319d2016-01-08 09:00:54 +0100554 dmi_ver >> 16, (dmi_ver >> 8) & 0xFF);
Ben Hutchings79bae422013-04-30 15:27:46 -0700555 } else {
Ivan Khoronzhukd7f96f972015-06-25 09:06:56 +0200556 smbios_entry_point_size = 15;
557 memcpy(smbios_entry_point, buf,
558 smbios_entry_point_size);
Zhenzhong Duan9f9c9cbb2012-12-20 15:05:14 -0800559 pr_info("Legacy DMI %d.%d present.\n",
Andrea Arcangeliff4319d2016-01-08 09:00:54 +0100560 dmi_ver >> 16, (dmi_ver >> 8) & 0xFF);
Zhenzhong Duan9f9c9cbb2012-12-20 15:05:14 -0800561 }
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700562 dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string));
563 printk(KERN_DEBUG "DMI: %s\n", dmi_ids_string);
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800564 return 0;
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700565 }
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800566 }
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800567
Ben Hutchingsa40e7cf2013-03-08 12:43:32 -0800568 return 1;
Zhenzhong Duan9f9c9cbb2012-12-20 15:05:14 -0800569}
570
Ard Biesheuvelfc430262014-10-14 16:41:27 +0200571/*
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 */
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])) {
Jean Delvared1d87042015-06-25 09:06:57 +0200579 dmi_ver = get_unaligned_be32(buf + 6) & 0xFFFFFF;
Jean Delvarebfbaafa2015-03-20 09:59:47 +0100580 dmi_num = 0; /* No longer specified */
Ard Biesheuvelfc430262014-10-14 16:41:27 +0200581 dmi_len = get_unaligned_le32(buf + 12);
582 dmi_base = get_unaligned_le64(buf + 16);
Ivan Khoronzhukd7f96f972015-06-25 09:06:56 +0200583 smbios_entry_point_size = buf[6];
584 memcpy(smbios_entry_point, buf, smbios_entry_point_size);
Ard Biesheuvelfc430262014-10-14 16:41:27 +0200585
Ard Biesheuvelfc430262014-10-14 16:41:27 +0200586 if (dmi_walk_early(dmi_decode) == 0) {
Ivan Khoronzhuk95be58d2015-02-18 13:33:20 +0200587 pr_info("SMBIOS %d.%d.%d present.\n",
588 dmi_ver >> 16, (dmi_ver >> 8) & 0xFF,
589 dmi_ver & 0xFF);
Ard Biesheuvelfc430262014-10-14 16:41:27 +0200590 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
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800598void __init dmi_scan_machine(void)
599{
Andrey Panin61e032f2005-09-06 15:18:26 -0700600 char __iomem *p, *q;
Ben Hutchings79bae422013-04-30 15:27:46 -0700601 char buf[32];
Andrey Panin61e032f2005-09-06 15:18:26 -0700602
Matt Fleming83e68182012-11-14 09:42:35 +0000603 if (efi_enabled(EFI_CONFIG_TABLES)) {
Ard Biesheuvelfc430262014-10-14 16:41:27 +0200604 /*
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 }
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800629 if (efi.smbios == EFI_INVALID_TABLE_ADDR)
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200630 goto error;
Andrey Panin61e032f2005-09-06 15:18:26 -0700631
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200632 /* 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 */
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800636 p = dmi_early_remap(efi.smbios, 32);
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800637 if (p == NULL)
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200638 goto error;
Ben Hutchings79bae422013-04-30 15:27:46 -0700639 memcpy_fromio(buf, p, 32);
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800640 dmi_early_unmap(p, 32);
Ben Hutchings79bae422013-04-30 15:27:46 -0700641
642 if (!dmi_present(buf)) {
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200643 dmi_available = 1;
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200644 goto out;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200645 }
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800646 } else if (IS_ENABLED(CONFIG_DMI_SCAN_MACHINE_NON_EFI_FALLBACK)) {
647 p = dmi_early_remap(0xF0000, 0x10000);
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800648 if (p == NULL)
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200649 goto error;
Andrey Panin61e032f2005-09-06 15:18:26 -0700650
Ben Hutchingsd39de282013-07-31 13:53:30 -0700651 /*
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 */
Ben Hutchings79bae422013-04-30 15:27:46 -0700658 memset(buf, 0, 16);
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800659 for (q = p; q < p + 0x10000; q += 16) {
Ben Hutchings79bae422013-04-30 15:27:46 -0700660 memcpy_fromio(buf + 16, q, 16);
Ard Biesheuvelfc430262014-10-14 16:41:27 +0200661 if (!dmi_smbios3_present(buf) || !dmi_present(buf)) {
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200662 dmi_available = 1;
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800663 dmi_early_unmap(p, 0x10000);
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200664 goto out;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200665 }
Ben Hutchings79bae422013-04-30 15:27:46 -0700666 memcpy(buf, buf + 16, 16);
Andrey Panin61e032f2005-09-06 15:18:26 -0700667 }
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800668 dmi_early_unmap(p, 0x10000);
Andrey Panin61e032f2005-09-06 15:18:26 -0700669 }
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200670 error:
Jean Delvare02d9c472013-09-11 14:24:08 -0700671 pr_info("DMI not present or invalid.\n");
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200672 out:
673 dmi_initialized = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674}
675
Ivan Khoronzhukd7f96f972015-06-25 09:06:56 +0200676static 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 * 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}
739subsys_initcall(dmi_init);
740
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741/**
Tejun Heo98e5e1b2013-04-30 15:27:15 -0700742 * 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 */
749void __init dmi_set_dump_stack_arch_desc(void)
750{
751 dump_stack_set_arch_desc("%s", dmi_ids_string);
752}
753
754/**
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100755 * dmi_matches - check if dmi_system_id structure matches system DMI data
756 * @dmi: pointer to the dmi_system_id structure to check
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)
Dmitry Torokhov75757502009-12-04 10:24:19 -0800767 break;
Jani Nikula5017b282013-07-03 15:05:02 -0700768 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
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100777 /* No match */
778 return false;
779 }
780 return true;
781}
782
783/**
Dmitry Torokhov75757502009-12-04 10:24:19 -0800784 * dmi_is_end_of_table - check for end-of-table marker
785 * @dmi: pointer to the dmi_system_id structure to check
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/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 * dmi_check_system - check system DMI data
794 * @list: array of dmi_system_id structures to match against
Randy Dunlapb0ef3712006-06-25 05:49:18 -0700795 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 *
801 * Walk the blacklist table running matching functions until someone
802 * returns non zero or we hit the end. Callback function is called for
Randy Dunlapb0ef3712006-06-25 05:49:18 -0700803 * each successful match. Returns the number of matches.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 */
Jeff Garzik18552562007-10-03 15:15:40 -0400805int dmi_check_system(const struct dmi_system_id *list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806{
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100807 int count = 0;
808 const struct dmi_system_id *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
Dmitry Torokhov75757502009-12-04 10:24:19 -0800810 for (d = list; !dmi_is_end_of_table(d); d++)
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100811 if (dmi_matches(d)) {
812 count++;
813 if (d->callback && d->callback(d))
814 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
817 return count;
818}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819EXPORT_SYMBOL(dmi_check_system);
820
821/**
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100822 * 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 */
833const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list)
834{
835 const struct dmi_system_id *d;
836
Dmitry Torokhov75757502009-12-04 10:24:19 -0800837 for (d = list; !dmi_is_end_of_table(d); d++)
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100838 if (dmi_matches(d))
839 return d;
840
841 return NULL;
842}
843EXPORT_SYMBOL(dmi_first_match);
844
845/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 * dmi_get_system_info - return DMI data value
Randy Dunlapb0ef3712006-06-25 05:49:18 -0700847 * @field: data index (see enum dmi_field)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 *
849 * Returns one DMI data value, can be used to perform
850 * complex DMI data checks.
851 */
Jeff Garzik18552562007-10-03 15:15:40 -0400852const char *dmi_get_system_info(int field)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853{
854 return dmi_ident[field];
855}
Dmitry Torokhove70c9d52005-06-25 14:54:25 -0700856EXPORT_SYMBOL(dmi_get_system_info);
Andrey Paninebad6a42005-09-06 15:18:29 -0700857
Alok Katariafd8cd7e2008-11-03 15:50:38 -0800858/**
Randy Dunlapc2bacfc2009-01-06 14:41:40 -0800859 * dmi_name_in_serial - Check if string is in the DMI product serial information
860 * @str: string to check for
Alok Katariafd8cd7e2008-11-03 15:50:38 -0800861 */
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}
Andi Kleena1bae672006-10-21 18:37:02 +0200869
870/**
Jean Delvare66e13e62011-11-15 14:36:09 -0800871 * dmi_name_in_vendors - Check if string is in the DMI system or board vendor name
Jean Delvare02d9c472013-09-11 14:24:08 -0700872 * @str: Case sensitive Name
Andi Kleena1bae672006-10-21 18:37:02 +0200873 */
Jeff Garzik18552562007-10-03 15:15:40 -0400874int dmi_name_in_vendors(const char *str)
Andi Kleena1bae672006-10-21 18:37:02 +0200875{
Jean Delvare66e13e62011-11-15 14:36:09 -0800876 static int fields[] = { DMI_SYS_VENDOR, DMI_BOARD_VENDOR, DMI_NONE };
Andi Kleena1bae672006-10-21 18:37:02 +0200877 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
Andrey Paninebad6a42005-09-06 15:18:29 -0700887/**
888 * dmi_find_device - find onboard device by type/name
889 * @type: device type or %DMI_DEV_TYPE_ANY to match all device types
Randy Dunlapb0ef3712006-06-25 05:49:18 -0700890 * @name: device name string or %NULL to match all
Andrey Paninebad6a42005-09-06 15:18:29 -0700891 * @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
Jean Delvarebfab8b482016-01-15 22:08:44 +0100894 * found with a matching @type and @name, a pointer to its device
Andrey Paninebad6a42005-09-06 15:18:29 -0700895 * structure is returned. Otherwise, %NULL is returned.
Randy Dunlapb0ef3712006-06-25 05:49:18 -0700896 * A new search is initiated by passing %NULL as the @from argument.
Andrey Paninebad6a42005-09-06 15:18:29 -0700897 * If @from is not %NULL, searches continue from next device.
898 */
Jean Delvare02d9c472013-09-11 14:24:08 -0700899const struct dmi_device *dmi_find_device(int type, const char *name,
Jeff Garzik18552562007-10-03 15:15:40 -0400900 const struct dmi_device *from)
Andrey Paninebad6a42005-09-06 15:18:29 -0700901{
Jeff Garzik18552562007-10-03 15:15:40 -0400902 const struct list_head *head = from ? &from->list : &dmi_devices;
903 struct list_head *d;
Andrey Paninebad6a42005-09-06 15:18:29 -0700904
Jean Delvare02d9c472013-09-11 14:24:08 -0700905 for (d = head->next; d != &dmi_devices; d = d->next) {
Jeff Garzik18552562007-10-03 15:15:40 -0400906 const struct dmi_device *dev =
907 list_entry(d, struct dmi_device, list);
Andrey Paninebad6a42005-09-06 15:18:29 -0700908
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);
Andi Kleenf083a322006-03-25 16:30:19 +0100917
918/**
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900919 * 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
Andi Kleenf083a322006-03-25 16:30:19 +0100924 *
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900925 * 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.
Andi Kleenf083a322006-03-25 16:30:19 +0100935 */
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900936bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp)
Andi Kleenf083a322006-03-25 16:30:19 +0100937{
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900938 int year = 0, month = 0, day = 0;
939 bool exists;
940 const char *s, *y;
Tejun Heo02c24fa2009-08-16 21:01:22 +0900941 char *e;
Andi Kleenf083a322006-03-25 16:30:19 +0100942
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900943 s = dmi_get_system_info(field);
944 exists = s;
945 if (!exists)
946 goto out;
Andi Kleenf083a322006-03-25 16:30:19 +0100947
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900948 /*
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 */
Andi Kleenf083a322006-03-25 16:30:19 +0100961 year += 1900;
962 if (year < 1996) /* no dates < spec 1.0 */
963 year += 100;
964 }
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900965 if (year > 9999) /* year should fit in %04d */
966 year = 0;
Andi Kleenf083a322006-03-25 16:30:19 +0100967
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900968 /* 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;
979out:
980 if (yearp)
981 *yearp = year;
982 if (monthp)
983 *monthp = month;
984 if (dayp)
985 *dayp = day;
986 return exists;
Andi Kleenf083a322006-03-25 16:30:19 +0100987}
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900988EXPORT_SYMBOL(dmi_get_date);
Jean Delvare7fce0842007-11-03 17:29:20 +0100989
990/**
991 * dmi_walk - Walk the DMI table and get called back for every record
992 * @decode: Callback function
Jean Delvaree7a19c562009-03-30 21:46:44 +0200993 * @private_data: Private data to be passed to the callback function
Jean Delvare7fce0842007-11-03 17:29:20 +0100994 *
995 * Returns -1 when the DMI table can't be reached, 0 on success.
996 */
Jean Delvaree7a19c562009-03-30 21:46:44 +0200997int dmi_walk(void (*decode)(const struct dmi_header *, void *),
998 void *private_data)
Jean Delvare7fce0842007-11-03 17:29:20 +0100999{
1000 u8 *buf;
1001
1002 if (!dmi_available)
1003 return -1;
1004
Ard Biesheuvelcf074402014-01-23 15:54:39 -08001005 buf = dmi_remap(dmi_base, dmi_len);
Jean Delvare7fce0842007-11-03 17:29:20 +01001006 if (buf == NULL)
1007 return -1;
1008
Ivan Khoronzhukeb4c5ea2015-06-25 09:06:56 +02001009 dmi_decode_table(buf, decode, private_data);
Jean Delvare7fce0842007-11-03 17:29:20 +01001010
Ard Biesheuvelcf074402014-01-23 15:54:39 -08001011 dmi_unmap(buf);
Jean Delvare7fce0842007-11-03 17:29:20 +01001012 return 0;
1013}
1014EXPORT_SYMBOL_GPL(dmi_walk);
Jiri Slabyd61c72e2008-12-10 14:07:21 +01001015
1016/**
1017 * dmi_match - compare a string to the dmi field (if exists)
Randy Dunlapc2bacfc2009-01-06 14:41:40 -08001018 * @f: DMI field identifier
1019 * @str: string to compare the DMI field to
Jiri Slabyd61c72e2008-12-10 14:07:21 +01001020 *
1021 * Returns true if the requested field equals to the str (including NULL).
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);
Chen, Gongdd6dad42013-10-18 14:29:25 -07001033
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);