blob: 17afc51f3054402c22a2a8d2fd50c1c809edd160 [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
Paul Jacksoncb5dd7c2008-05-14 08:15:16 -070013/*
14 * DMI stands for "Desktop Management Interface". It is part
15 * of and an antecedent to, SMBIOS, which stands for System
16 * Management BIOS. See further: http://www.dmtf.org/standards
17 */
Jean Delvareffbbb962013-09-11 14:24:09 -070018static const char dmi_empty_string[] = " ";
Parag Warudkar79da4722008-01-30 13:31:59 +010019
Zhenzhong Duanf1d8e612012-12-20 15:05:13 -080020static u16 __initdata dmi_ver;
Ingo Molnar9a22b6e2008-09-18 12:50:18 +020021/*
22 * Catch too early calls to dmi_check_system():
23 */
24static int dmi_initialized;
25
Tejun Heoc90fe6b2013-04-30 15:27:14 -070026/* DMI system identification string used during boot */
27static char dmi_ids_string[128] __initdata;
28
Chen, Gongdd6dad42013-10-18 14:29:25 -070029static struct dmi_memdev_info {
30 const char *device;
31 const char *bank;
32 u16 handle;
33} *dmi_memdev;
34static int dmi_memdev_nr;
35
Jean Delvaref3069ae2008-02-23 15:23:46 -080036static const char * __init dmi_string_nosave(const struct dmi_header *dm, u8 s)
Linus Torvalds1da177e2005-04-16 15:20:36 -070037{
Jeff Garzik18552562007-10-03 15:15:40 -040038 const u8 *bp = ((u8 *) dm) + dm->length;
Andrey Panin1249c512005-06-25 14:54:47 -070039
Andrey Paninc3c71202005-09-06 15:18:28 -070040 if (s) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 s--;
Andrey Paninc3c71202005-09-06 15:18:28 -070042 while (s > 0 && *bp) {
43 bp += strlen(bp) + 1;
44 s--;
45 }
46
47 if (*bp != 0) {
Parag Warudkar79da4722008-01-30 13:31:59 +010048 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;
Jean Delvaref3069ae2008-02-23 15:23:46 -080053 return bp;
Andrey Paninc3c71202005-09-06 15:18:28 -070054 }
Bjorn Helgaas4f705ae2006-04-03 17:09:22 -070055 }
Andrey Paninc3c71202005-09-06 15:18:28 -070056
Jean Delvaref3069ae2008-02-23 15:23:46 -080057 return "";
58}
59
Jean Delvareffbbb962013-09-11 14:24:09 -070060static const char * __init dmi_string(const struct dmi_header *dm, u8 s)
Jean Delvaref3069ae2008-02-23 15:23:46 -080061{
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);
Jean Delvaref3069ae2008-02-23 15:23:46 -080073
Andrey Paninc3c71202005-09-06 15:18:28 -070074 return str;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075}
76
77/*
78 * We have to be cautious here. We have seen BIOSes with DMI pointers
79 * pointing to completely the wrong place for example
80 */
Jean Delvare7fce0842007-11-03 17:29:20 +010081static void dmi_table(u8 *buf, int len, int num,
Jean Delvaree7a19c562009-03-30 21:46:44 +020082 void (*decode)(const struct dmi_header *, void *),
83 void *private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -070084{
Jean Delvare7fce0842007-11-03 17:29:20 +010085 u8 *data = buf;
Andrey Panin1249c512005-06-25 14:54:47 -070086 int i = 0;
Bjorn Helgaas4f705ae2006-04-03 17:09:22 -070087
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 /*
Bjorn Helgaas4f705ae2006-04-03 17:09:22 -070089 * Stop when we see all the items the table claimed to have
90 * OR we run off the end of the table (also happens)
91 */
Andrey Panin1249c512005-06-25 14:54:47 -070092 while ((i < num) && (data - buf + sizeof(struct dmi_header)) <= len) {
Jeff Garzik18552562007-10-03 15:15:40 -040093 const struct dmi_header *dm = (const struct dmi_header *)data;
94
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 /*
Alan Cox86385452008-11-07 16:03:46 +000096 * We want to know the total length (formatted area and
97 * strings) before decoding to make sure we won't run off the
98 * table in dmi_decode or dmi_string
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 */
Andrey Panin1249c512005-06-25 14:54:47 -0700100 data += dm->length;
101 while ((data - buf < len - 1) && (data[0] || data[1]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 data++;
Andrey Panin1249c512005-06-25 14:54:47 -0700103 if (data - buf < len - 1)
Jean Delvaree7a19c562009-03-30 21:46:44 +0200104 decode(dm, private_data);
Andrey Panin1249c512005-06-25 14:54:47 -0700105 data += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 i++;
107 }
Jean Delvare7fce0842007-11-03 17:29:20 +0100108}
109
110static u32 dmi_base;
111static u16 dmi_len;
112static u16 dmi_num;
113
Jean Delvaree7a19c562009-03-30 21:46:44 +0200114static int __init dmi_walk_early(void (*decode)(const struct dmi_header *,
115 void *))
Jean Delvare7fce0842007-11-03 17:29:20 +0100116{
117 u8 *buf;
118
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800119 buf = dmi_early_remap(dmi_base, dmi_len);
Jean Delvare7fce0842007-11-03 17:29:20 +0100120 if (buf == NULL)
121 return -1;
122
Jean Delvaree7a19c562009-03-30 21:46:44 +0200123 dmi_table(buf, dmi_len, dmi_num, decode, NULL);
Jean Delvare7fce0842007-11-03 17:29:20 +0100124
Tony Luckd114a332012-07-20 13:15:20 -0700125 add_device_randomness(buf, dmi_len);
126
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800127 dmi_early_unmap(buf, dmi_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 return 0;
129}
130
Zhenzhong Duan9f9c9cbb2012-12-20 15:05:14 -0800131static int __init dmi_checksum(const u8 *buf, u8 len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132{
Andrey Panin1249c512005-06-25 14:54:47 -0700133 u8 sum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 int a;
Bjorn Helgaas4f705ae2006-04-03 17:09:22 -0700135
Zhenzhong Duan9f9c9cbb2012-12-20 15:05:14 -0800136 for (a = 0; a < len; a++)
Andrey Panin1249c512005-06-25 14:54:47 -0700137 sum += buf[a];
138
139 return sum == 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140}
141
Jean Delvareffbbb962013-09-11 14:24:09 -0700142static const char *dmi_ident[DMI_STRING_MAX];
Andrey Paninebad6a42005-09-06 15:18:29 -0700143static LIST_HEAD(dmi_devices);
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200144int dmi_available;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
146/*
147 * Save a DMI string
148 */
Jean Delvare02d9c472013-09-11 14:24:08 -0700149static void __init dmi_save_ident(const struct dmi_header *dm, int slot,
150 int string)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
Jean Delvare02d9c472013-09-11 14:24:08 -0700152 const char *d = (const char *) dm;
Jean Delvareffbbb962013-09-11 14:24:09 -0700153 const char *p;
Andrey Panin1249c512005-06-25 14:54:47 -0700154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 if (dmi_ident[slot])
156 return;
Andrey Panin1249c512005-06-25 14:54:47 -0700157
Andrey Paninc3c71202005-09-06 15:18:28 -0700158 p = dmi_string(dm, d[string]);
159 if (p == NULL)
160 return;
161
162 dmi_ident[slot] = p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163}
164
Jean Delvare02d9c472013-09-11 14:24:08 -0700165static void __init dmi_save_uuid(const struct dmi_header *dm, int slot,
166 int index)
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200167{
Jean Delvare02d9c472013-09-11 14:24:08 -0700168 const u8 *d = (u8 *) dm + index;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200169 char *s;
170 int is_ff = 1, is_00 = 1, i;
171
172 if (dmi_ident[slot])
173 return;
174
175 for (i = 0; i < 16 && (is_ff || is_00); i++) {
Zhenzhong Duanf1d8e612012-12-20 15:05:13 -0800176 if (d[i] != 0x00)
177 is_00 = 0;
178 if (d[i] != 0xFF)
179 is_ff = 0;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200180 }
181
182 if (is_ff || is_00)
183 return;
184
185 s = dmi_alloc(16*2+4+1);
186 if (!s)
187 return;
188
Zhenzhong Duanf1d8e612012-12-20 15:05:13 -0800189 /*
190 * As of version 2.6 of the SMBIOS specification, the first 3 fields of
191 * the UUID are supposed to be little-endian encoded. The specification
192 * says that this is the defacto standard.
193 */
194 if (dmi_ver >= 0x0206)
195 sprintf(s, "%pUL", d);
196 else
197 sprintf(s, "%pUB", d);
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200198
Jean Delvare02d9c472013-09-11 14:24:08 -0700199 dmi_ident[slot] = s;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200200}
201
Jean Delvare02d9c472013-09-11 14:24:08 -0700202static void __init dmi_save_type(const struct dmi_header *dm, int slot,
203 int index)
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200204{
Jean Delvare02d9c472013-09-11 14:24:08 -0700205 const u8 *d = (u8 *) dm + index;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200206 char *s;
207
208 if (dmi_ident[slot])
209 return;
210
211 s = dmi_alloc(4);
212 if (!s)
213 return;
214
215 sprintf(s, "%u", *d & 0x7F);
216 dmi_ident[slot] = s;
217}
218
Jean Delvaref3069ae2008-02-23 15:23:46 -0800219static void __init dmi_save_one_device(int type, const char *name)
220{
221 struct dmi_device *dev;
222
223 /* No duplicate device */
224 if (dmi_find_device(type, name, NULL))
225 return;
226
227 dev = dmi_alloc(sizeof(*dev) + strlen(name) + 1);
Jean Delvareae797442013-09-11 14:24:10 -0700228 if (!dev)
Jean Delvaref3069ae2008-02-23 15:23:46 -0800229 return;
Jean Delvaref3069ae2008-02-23 15:23:46 -0800230
231 dev->type = type;
232 strcpy((char *)(dev + 1), name);
233 dev->name = (char *)(dev + 1);
234 dev->device_data = NULL;
235 list_add(&dev->list, &dmi_devices);
236}
237
Jeff Garzik18552562007-10-03 15:15:40 -0400238static void __init dmi_save_devices(const struct dmi_header *dm)
Andrey Paninebad6a42005-09-06 15:18:29 -0700239{
240 int i, count = (dm->length - sizeof(struct dmi_header)) / 2;
Andrey Paninebad6a42005-09-06 15:18:29 -0700241
242 for (i = 0; i < count; i++) {
Jeff Garzik18552562007-10-03 15:15:40 -0400243 const char *d = (char *)(dm + 1) + (i * 2);
Andrey Paninebad6a42005-09-06 15:18:29 -0700244
245 /* Skip disabled device */
246 if ((*d & 0x80) == 0)
247 continue;
248
Jean Delvaref3069ae2008-02-23 15:23:46 -0800249 dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d + 1)));
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700250 }
251}
252
Jeff Garzik18552562007-10-03 15:15:40 -0400253static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm)
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700254{
255 int i, count = *(u8 *)(dm + 1);
256 struct dmi_device *dev;
257
258 for (i = 1; i <= count; i++) {
Jean Delvareffbbb962013-09-11 14:24:09 -0700259 const char *devname = dmi_string(dm, i);
Parag Warudkar79da4722008-01-30 13:31:59 +0100260
Jean Delvare43fe1052008-02-23 15:23:55 -0800261 if (devname == dmi_empty_string)
Parag Warudkar79da4722008-01-30 13:31:59 +0100262 continue;
Parag Warudkar79da4722008-01-30 13:31:59 +0100263
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700264 dev = dmi_alloc(sizeof(*dev));
Jean Delvareae797442013-09-11 14:24:10 -0700265 if (!dev)
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700266 break;
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700267
268 dev->type = DMI_DEV_TYPE_OEM_STRING;
Parag Warudkar79da4722008-01-30 13:31:59 +0100269 dev->name = devname;
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700270 dev->device_data = NULL;
Andrey Paninebad6a42005-09-06 15:18:29 -0700271
272 list_add(&dev->list, &dmi_devices);
273 }
274}
275
Jeff Garzik18552562007-10-03 15:15:40 -0400276static void __init dmi_save_ipmi_device(const struct dmi_header *dm)
Andrey Paninebad6a42005-09-06 15:18:29 -0700277{
278 struct dmi_device *dev;
Jean Delvare02d9c472013-09-11 14:24:08 -0700279 void *data;
Andrey Paninebad6a42005-09-06 15:18:29 -0700280
Andi Kleene9928672006-01-11 22:43:33 +0100281 data = dmi_alloc(dm->length);
Jean Delvareae797442013-09-11 14:24:10 -0700282 if (data == NULL)
Andrey Paninebad6a42005-09-06 15:18:29 -0700283 return;
Andrey Paninebad6a42005-09-06 15:18:29 -0700284
285 memcpy(data, dm, dm->length);
286
Andi Kleene9928672006-01-11 22:43:33 +0100287 dev = dmi_alloc(sizeof(*dev));
Jean Delvareae797442013-09-11 14:24:10 -0700288 if (!dev)
Andrey Paninebad6a42005-09-06 15:18:29 -0700289 return;
Andrey Paninebad6a42005-09-06 15:18:29 -0700290
291 dev->type = DMI_DEV_TYPE_IPMI;
292 dev->name = "IPMI controller";
293 dev->device_data = data;
294
Carol Hebertabd24df2008-04-04 14:30:03 -0700295 list_add_tail(&dev->list, &dmi_devices);
Andrey Paninebad6a42005-09-06 15:18:29 -0700296}
297
Narendra K911e1c92010-07-26 05:56:50 -0500298static void __init dmi_save_dev_onboard(int instance, int segment, int bus,
299 int devfn, const char *name)
300{
301 struct dmi_dev_onboard *onboard_dev;
302
303 onboard_dev = dmi_alloc(sizeof(*onboard_dev) + strlen(name) + 1);
Jean Delvareae797442013-09-11 14:24:10 -0700304 if (!onboard_dev)
Narendra K911e1c92010-07-26 05:56:50 -0500305 return;
Jean Delvareae797442013-09-11 14:24:10 -0700306
Narendra K911e1c92010-07-26 05:56:50 -0500307 onboard_dev->instance = instance;
308 onboard_dev->segment = segment;
309 onboard_dev->bus = bus;
310 onboard_dev->devfn = devfn;
311
312 strcpy((char *)&onboard_dev[1], name);
313 onboard_dev->dev.type = DMI_DEV_TYPE_DEV_ONBOARD;
314 onboard_dev->dev.name = (char *)&onboard_dev[1];
315 onboard_dev->dev.device_data = onboard_dev;
316
317 list_add(&onboard_dev->dev.list, &dmi_devices);
318}
319
Wim Van Sebroeckb4bd7d52008-02-08 04:20:58 -0800320static void __init dmi_save_extended_devices(const struct dmi_header *dm)
321{
Jean Delvare02d9c472013-09-11 14:24:08 -0700322 const u8 *d = (u8 *) dm + 5;
Wim Van Sebroeckb4bd7d52008-02-08 04:20:58 -0800323
324 /* Skip disabled device */
325 if ((*d & 0x80) == 0)
326 return;
327
Narendra K911e1c92010-07-26 05:56:50 -0500328 dmi_save_dev_onboard(*(d+1), *(u16 *)(d+2), *(d+4), *(d+5),
329 dmi_string_nosave(dm, *(d-1)));
Jean Delvaref3069ae2008-02-23 15:23:46 -0800330 dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d - 1)));
Wim Van Sebroeckb4bd7d52008-02-08 04:20:58 -0800331}
332
Chen, Gongdd6dad42013-10-18 14:29:25 -0700333static void __init count_mem_devices(const struct dmi_header *dm, void *v)
334{
335 if (dm->type != DMI_ENTRY_MEM_DEVICE)
336 return;
337 dmi_memdev_nr++;
338}
339
340static void __init save_mem_devices(const struct dmi_header *dm, void *v)
341{
342 const char *d = (const char *)dm;
343 static int nr;
344
345 if (dm->type != DMI_ENTRY_MEM_DEVICE)
346 return;
347 if (nr >= dmi_memdev_nr) {
348 pr_warn(FW_BUG "Too many DIMM entries in SMBIOS table\n");
349 return;
350 }
Luck, Tony0841c042013-11-01 13:59:52 -0700351 dmi_memdev[nr].handle = get_unaligned(&dm->handle);
Chen, Gongdd6dad42013-10-18 14:29:25 -0700352 dmi_memdev[nr].device = dmi_string(dm, d[0x10]);
353 dmi_memdev[nr].bank = dmi_string(dm, d[0x11]);
354 nr++;
355}
356
357void __init dmi_memdev_walk(void)
358{
359 if (!dmi_available)
360 return;
361
362 if (dmi_walk_early(count_mem_devices) == 0 && dmi_memdev_nr) {
363 dmi_memdev = dmi_alloc(sizeof(*dmi_memdev) * dmi_memdev_nr);
364 if (dmi_memdev)
365 dmi_walk_early(save_mem_devices);
366 }
367}
368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 * Process a DMI table entry. Right now all we care about are the BIOS
371 * and machine entries. For 2.5 we should pull the smbus controller info
372 * out of here.
373 */
Jean Delvaree7a19c562009-03-30 21:46:44 +0200374static void __init dmi_decode(const struct dmi_header *dm, void *dummy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375{
Jean Delvare02d9c472013-09-11 14:24:08 -0700376 switch (dm->type) {
Andrey Paninebad6a42005-09-06 15:18:29 -0700377 case 0: /* BIOS Information */
Andrey Panin1249c512005-06-25 14:54:47 -0700378 dmi_save_ident(dm, DMI_BIOS_VENDOR, 4);
Andrey Panin1249c512005-06-25 14:54:47 -0700379 dmi_save_ident(dm, DMI_BIOS_VERSION, 5);
Andrey Panin1249c512005-06-25 14:54:47 -0700380 dmi_save_ident(dm, DMI_BIOS_DATE, 8);
381 break;
Andrey Paninebad6a42005-09-06 15:18:29 -0700382 case 1: /* System Information */
Andrey Panin1249c512005-06-25 14:54:47 -0700383 dmi_save_ident(dm, DMI_SYS_VENDOR, 4);
Andrey Panin1249c512005-06-25 14:54:47 -0700384 dmi_save_ident(dm, DMI_PRODUCT_NAME, 5);
Andrey Panin1249c512005-06-25 14:54:47 -0700385 dmi_save_ident(dm, DMI_PRODUCT_VERSION, 6);
Andrey Panin1249c512005-06-25 14:54:47 -0700386 dmi_save_ident(dm, DMI_PRODUCT_SERIAL, 7);
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200387 dmi_save_uuid(dm, DMI_PRODUCT_UUID, 8);
Andrey Panin1249c512005-06-25 14:54:47 -0700388 break;
Andrey Paninebad6a42005-09-06 15:18:29 -0700389 case 2: /* Base Board Information */
Andrey Panin1249c512005-06-25 14:54:47 -0700390 dmi_save_ident(dm, DMI_BOARD_VENDOR, 4);
Andrey Panin1249c512005-06-25 14:54:47 -0700391 dmi_save_ident(dm, DMI_BOARD_NAME, 5);
Andrey Panin1249c512005-06-25 14:54:47 -0700392 dmi_save_ident(dm, DMI_BOARD_VERSION, 6);
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200393 dmi_save_ident(dm, DMI_BOARD_SERIAL, 7);
394 dmi_save_ident(dm, DMI_BOARD_ASSET_TAG, 8);
395 break;
396 case 3: /* Chassis Information */
397 dmi_save_ident(dm, DMI_CHASSIS_VENDOR, 4);
398 dmi_save_type(dm, DMI_CHASSIS_TYPE, 5);
399 dmi_save_ident(dm, DMI_CHASSIS_VERSION, 6);
400 dmi_save_ident(dm, DMI_CHASSIS_SERIAL, 7);
401 dmi_save_ident(dm, DMI_CHASSIS_ASSET_TAG, 8);
Andrey Panin1249c512005-06-25 14:54:47 -0700402 break;
Andrey Paninebad6a42005-09-06 15:18:29 -0700403 case 10: /* Onboard Devices Information */
404 dmi_save_devices(dm);
405 break;
Shem Multinymous2e0c1f62006-09-29 01:59:37 -0700406 case 11: /* OEM Strings */
407 dmi_save_oem_strings_devices(dm);
408 break;
Andrey Paninebad6a42005-09-06 15:18:29 -0700409 case 38: /* IPMI Device Information */
410 dmi_save_ipmi_device(dm);
Wim Van Sebroeckb4bd7d52008-02-08 04:20:58 -0800411 break;
412 case 41: /* Onboard Devices Extended Information */
413 dmi_save_extended_devices(dm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 }
415}
416
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700417static int __init print_filtered(char *buf, size_t len, const char *info)
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700418{
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700419 int c = 0;
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700420 const char *p;
421
422 if (!info)
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700423 return c;
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700424
425 for (p = info; *p; p++)
426 if (isprint(*p))
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700427 c += scnprintf(buf + c, len - c, "%c", *p);
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700428 else
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700429 c += scnprintf(buf + c, len - c, "\\x%02x", *p & 0xff);
430 return c;
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700431}
432
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700433static void __init dmi_format_ids(char *buf, size_t len)
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700434{
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700435 int c = 0;
Naga Chumbalkar84e383b2011-02-14 22:47:17 +0000436 const char *board; /* Board Name is optional */
437
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700438 c += print_filtered(buf + c, len - c,
439 dmi_get_system_info(DMI_SYS_VENDOR));
440 c += scnprintf(buf + c, len - c, " ");
441 c += print_filtered(buf + c, len - c,
442 dmi_get_system_info(DMI_PRODUCT_NAME));
443
Naga Chumbalkar84e383b2011-02-14 22:47:17 +0000444 board = dmi_get_system_info(DMI_BOARD_NAME);
445 if (board) {
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700446 c += scnprintf(buf + c, len - c, "/");
447 c += print_filtered(buf + c, len - c, board);
Naga Chumbalkar84e383b2011-02-14 22:47:17 +0000448 }
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700449 c += scnprintf(buf + c, len - c, ", BIOS ");
450 c += print_filtered(buf + c, len - c,
451 dmi_get_system_info(DMI_BIOS_VERSION));
452 c += scnprintf(buf + c, len - c, " ");
453 c += print_filtered(buf + c, len - c,
454 dmi_get_system_info(DMI_BIOS_DATE));
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700455}
456
Ben Hutchingsd39de282013-07-31 13:53:30 -0700457/*
458 * Check for DMI/SMBIOS headers in the system firmware image. Any
459 * SMBIOS header must start 16 bytes before the DMI header, so take a
460 * 32 byte buffer and check for DMI at offset 16 and SMBIOS at offset
461 * 0. If the DMI header is present, set dmi_ver accordingly (SMBIOS
462 * takes precedence) and return 0. Otherwise return 1.
463 */
Ben Hutchings79bae422013-04-30 15:27:46 -0700464static int __init dmi_present(const u8 *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465{
Ben Hutchings79bae422013-04-30 15:27:46 -0700466 int smbios_ver;
Jeff Garzik18552562007-10-03 15:15:40 -0400467
Ben Hutchings79bae422013-04-30 15:27:46 -0700468 if (memcmp(buf, "_SM_", 4) == 0 &&
469 buf[5] < 32 && dmi_checksum(buf, buf[5])) {
470 smbios_ver = (buf[6] << 8) + buf[7];
471
472 /* Some BIOS report weird SMBIOS version, fix that up */
473 switch (smbios_ver) {
474 case 0x021F:
475 case 0x0221:
476 pr_debug("SMBIOS version fixup(2.%d->2.%d)\n",
477 smbios_ver & 0xFF, 3);
478 smbios_ver = 0x0203;
479 break;
480 case 0x0233:
481 pr_debug("SMBIOS version fixup(2.%d->2.%d)\n", 51, 6);
482 smbios_ver = 0x0206;
483 break;
484 }
485 } else {
486 smbios_ver = 0;
487 }
488
489 buf += 16;
490
491 if (memcmp(buf, "_DMI_", 5) == 0 && dmi_checksum(buf, 15)) {
Jean Delvare7fce0842007-11-03 17:29:20 +0100492 dmi_num = (buf[13] << 8) | buf[12];
493 dmi_len = (buf[7] << 8) | buf[6];
494 dmi_base = (buf[11] << 24) | (buf[10] << 16) |
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800495 (buf[9] << 8) | buf[8];
496
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700497 if (dmi_walk_early(dmi_decode) == 0) {
Ben Hutchings79bae422013-04-30 15:27:46 -0700498 if (smbios_ver) {
499 dmi_ver = smbios_ver;
Zhenzhong Duan9f9c9cbb2012-12-20 15:05:14 -0800500 pr_info("SMBIOS %d.%d present.\n",
501 dmi_ver >> 8, dmi_ver & 0xFF);
Ben Hutchings79bae422013-04-30 15:27:46 -0700502 } else {
Zhenzhong Duan9f9c9cbb2012-12-20 15:05:14 -0800503 dmi_ver = (buf[14] & 0xF0) << 4 |
504 (buf[14] & 0x0F);
505 pr_info("Legacy DMI %d.%d present.\n",
506 dmi_ver >> 8, dmi_ver & 0xFF);
507 }
Tejun Heoc90fe6b2013-04-30 15:27:14 -0700508 dmi_format_ids(dmi_ids_string, sizeof(dmi_ids_string));
509 printk(KERN_DEBUG "DMI: %s\n", dmi_ids_string);
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800510 return 0;
Bjorn Helgaas8881cdc2010-10-27 15:32:59 -0700511 }
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800512 }
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800513
Ben Hutchingsa40e7cf2013-03-08 12:43:32 -0800514 return 1;
Zhenzhong Duan9f9c9cbb2012-12-20 15:05:14 -0800515}
516
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800517void __init dmi_scan_machine(void)
518{
Andrey Panin61e032fa2005-09-06 15:18:26 -0700519 char __iomem *p, *q;
Ben Hutchings79bae422013-04-30 15:27:46 -0700520 char buf[32];
Andrey Panin61e032fa2005-09-06 15:18:26 -0700521
Matt Fleming83e68182012-11-14 09:42:35 +0000522 if (efi_enabled(EFI_CONFIG_TABLES)) {
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800523 if (efi.smbios == EFI_INVALID_TABLE_ADDR)
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200524 goto error;
Andrey Panin61e032fa2005-09-06 15:18:26 -0700525
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200526 /* This is called as a core_initcall() because it isn't
527 * needed during early boot. This also means we can
528 * iounmap the space when we're done with it.
529 */
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800530 p = dmi_early_remap(efi.smbios, 32);
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800531 if (p == NULL)
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200532 goto error;
Ben Hutchings79bae422013-04-30 15:27:46 -0700533 memcpy_fromio(buf, p, 32);
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800534 dmi_early_unmap(p, 32);
Ben Hutchings79bae422013-04-30 15:27:46 -0700535
536 if (!dmi_present(buf)) {
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200537 dmi_available = 1;
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200538 goto out;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200539 }
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800540 } else if (IS_ENABLED(CONFIG_DMI_SCAN_MACHINE_NON_EFI_FALLBACK)) {
541 p = dmi_early_remap(0xF0000, 0x10000);
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800542 if (p == NULL)
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200543 goto error;
Andrey Panin61e032fa2005-09-06 15:18:26 -0700544
Ben Hutchingsd39de282013-07-31 13:53:30 -0700545 /*
546 * Iterate over all possible DMI header addresses q.
547 * Maintain the 32 bytes around q in buf. On the
548 * first iteration, substitute zero for the
549 * out-of-range bytes so there is no chance of falsely
550 * detecting an SMBIOS header.
551 */
Ben Hutchings79bae422013-04-30 15:27:46 -0700552 memset(buf, 0, 16);
Matt Domsch3ed3bce2006-03-26 01:37:03 -0800553 for (q = p; q < p + 0x10000; q += 16) {
Ben Hutchings79bae422013-04-30 15:27:46 -0700554 memcpy_fromio(buf + 16, q, 16);
555 if (!dmi_present(buf)) {
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200556 dmi_available = 1;
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800557 dmi_early_unmap(p, 0x10000);
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200558 goto out;
Lennart Poettering4f5c7912007-05-08 22:07:02 +0200559 }
Ben Hutchings79bae422013-04-30 15:27:46 -0700560 memcpy(buf, buf + 16, 16);
Andrey Panin61e032fa2005-09-06 15:18:26 -0700561 }
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800562 dmi_early_unmap(p, 0x10000);
Andrey Panin61e032fa2005-09-06 15:18:26 -0700563 }
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200564 error:
Jean Delvare02d9c472013-09-11 14:24:08 -0700565 pr_info("DMI not present or invalid.\n");
Ingo Molnar9a22b6e2008-09-18 12:50:18 +0200566 out:
567 dmi_initialized = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568}
569
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570/**
Tejun Heo98e5e1b2013-04-30 15:27:15 -0700571 * dmi_set_dump_stack_arch_desc - set arch description for dump_stack()
572 *
573 * Invoke dump_stack_set_arch_desc() with DMI system information so that
574 * DMI identifiers are printed out on task dumps. Arch boot code should
575 * call this function after dmi_scan_machine() if it wants to print out DMI
576 * identifiers on task dumps.
577 */
578void __init dmi_set_dump_stack_arch_desc(void)
579{
580 dump_stack_set_arch_desc("%s", dmi_ids_string);
581}
582
583/**
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100584 * dmi_matches - check if dmi_system_id structure matches system DMI data
585 * @dmi: pointer to the dmi_system_id structure to check
586 */
587static bool dmi_matches(const struct dmi_system_id *dmi)
588{
589 int i;
590
591 WARN(!dmi_initialized, KERN_ERR "dmi check: not initialized yet.\n");
592
593 for (i = 0; i < ARRAY_SIZE(dmi->matches); i++) {
594 int s = dmi->matches[i].slot;
595 if (s == DMI_NONE)
Dmitry Torokhov75757502009-12-04 10:24:19 -0800596 break;
Jani Nikula5017b282013-07-03 15:05:02 -0700597 if (dmi_ident[s]) {
598 if (!dmi->matches[i].exact_match &&
599 strstr(dmi_ident[s], dmi->matches[i].substr))
600 continue;
601 else if (dmi->matches[i].exact_match &&
602 !strcmp(dmi_ident[s], dmi->matches[i].substr))
603 continue;
604 }
605
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100606 /* No match */
607 return false;
608 }
609 return true;
610}
611
612/**
Dmitry Torokhov75757502009-12-04 10:24:19 -0800613 * dmi_is_end_of_table - check for end-of-table marker
614 * @dmi: pointer to the dmi_system_id structure to check
615 */
616static bool dmi_is_end_of_table(const struct dmi_system_id *dmi)
617{
618 return dmi->matches[0].slot == DMI_NONE;
619}
620
621/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 * dmi_check_system - check system DMI data
623 * @list: array of dmi_system_id structures to match against
Randy Dunlapb0ef3712006-06-25 05:49:18 -0700624 * All non-null elements of the list must match
625 * their slot's (field index's) data (i.e., each
626 * list string must be a substring of the specified
627 * DMI slot's string data) to be considered a
628 * successful match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 *
630 * Walk the blacklist table running matching functions until someone
631 * returns non zero or we hit the end. Callback function is called for
Randy Dunlapb0ef3712006-06-25 05:49:18 -0700632 * each successful match. Returns the number of matches.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 */
Jeff Garzik18552562007-10-03 15:15:40 -0400634int dmi_check_system(const struct dmi_system_id *list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635{
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100636 int count = 0;
637 const struct dmi_system_id *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
Dmitry Torokhov75757502009-12-04 10:24:19 -0800639 for (d = list; !dmi_is_end_of_table(d); d++)
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100640 if (dmi_matches(d)) {
641 count++;
642 if (d->callback && d->callback(d))
643 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646 return count;
647}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648EXPORT_SYMBOL(dmi_check_system);
649
650/**
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100651 * dmi_first_match - find dmi_system_id structure matching system DMI data
652 * @list: array of dmi_system_id structures to match against
653 * All non-null elements of the list must match
654 * their slot's (field index's) data (i.e., each
655 * list string must be a substring of the specified
656 * DMI slot's string data) to be considered a
657 * successful match.
658 *
659 * Walk the blacklist table until the first match is found. Return the
660 * pointer to the matching entry or NULL if there's no match.
661 */
662const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list)
663{
664 const struct dmi_system_id *d;
665
Dmitry Torokhov75757502009-12-04 10:24:19 -0800666 for (d = list; !dmi_is_end_of_table(d); d++)
Rafael J. Wysockid7b19562009-01-19 20:55:50 +0100667 if (dmi_matches(d))
668 return d;
669
670 return NULL;
671}
672EXPORT_SYMBOL(dmi_first_match);
673
674/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 * dmi_get_system_info - return DMI data value
Randy Dunlapb0ef3712006-06-25 05:49:18 -0700676 * @field: data index (see enum dmi_field)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 *
678 * Returns one DMI data value, can be used to perform
679 * complex DMI data checks.
680 */
Jeff Garzik18552562007-10-03 15:15:40 -0400681const char *dmi_get_system_info(int field)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682{
683 return dmi_ident[field];
684}
Dmitry Torokhove70c9d52005-06-25 14:54:25 -0700685EXPORT_SYMBOL(dmi_get_system_info);
Andrey Paninebad6a42005-09-06 15:18:29 -0700686
Alok Katariafd8cd7e2008-11-03 15:50:38 -0800687/**
Randy Dunlapc2bacfc2009-01-06 14:41:40 -0800688 * dmi_name_in_serial - Check if string is in the DMI product serial information
689 * @str: string to check for
Alok Katariafd8cd7e2008-11-03 15:50:38 -0800690 */
691int dmi_name_in_serial(const char *str)
692{
693 int f = DMI_PRODUCT_SERIAL;
694 if (dmi_ident[f] && strstr(dmi_ident[f], str))
695 return 1;
696 return 0;
697}
Andi Kleena1bae672006-10-21 18:37:02 +0200698
699/**
Jean Delvare66e13e62011-11-15 14:36:09 -0800700 * dmi_name_in_vendors - Check if string is in the DMI system or board vendor name
Jean Delvare02d9c472013-09-11 14:24:08 -0700701 * @str: Case sensitive Name
Andi Kleena1bae672006-10-21 18:37:02 +0200702 */
Jeff Garzik18552562007-10-03 15:15:40 -0400703int dmi_name_in_vendors(const char *str)
Andi Kleena1bae672006-10-21 18:37:02 +0200704{
Jean Delvare66e13e62011-11-15 14:36:09 -0800705 static int fields[] = { DMI_SYS_VENDOR, DMI_BOARD_VENDOR, DMI_NONE };
Andi Kleena1bae672006-10-21 18:37:02 +0200706 int i;
707 for (i = 0; fields[i] != DMI_NONE; i++) {
708 int f = fields[i];
709 if (dmi_ident[f] && strstr(dmi_ident[f], str))
710 return 1;
711 }
712 return 0;
713}
714EXPORT_SYMBOL(dmi_name_in_vendors);
715
Andrey Paninebad6a42005-09-06 15:18:29 -0700716/**
717 * dmi_find_device - find onboard device by type/name
718 * @type: device type or %DMI_DEV_TYPE_ANY to match all device types
Randy Dunlapb0ef3712006-06-25 05:49:18 -0700719 * @name: device name string or %NULL to match all
Andrey Paninebad6a42005-09-06 15:18:29 -0700720 * @from: previous device found in search, or %NULL for new search.
721 *
722 * Iterates through the list of known onboard devices. If a device is
723 * found with a matching @vendor and @device, a pointer to its device
724 * structure is returned. Otherwise, %NULL is returned.
Randy Dunlapb0ef3712006-06-25 05:49:18 -0700725 * A new search is initiated by passing %NULL as the @from argument.
Andrey Paninebad6a42005-09-06 15:18:29 -0700726 * If @from is not %NULL, searches continue from next device.
727 */
Jean Delvare02d9c472013-09-11 14:24:08 -0700728const struct dmi_device *dmi_find_device(int type, const char *name,
Jeff Garzik18552562007-10-03 15:15:40 -0400729 const struct dmi_device *from)
Andrey Paninebad6a42005-09-06 15:18:29 -0700730{
Jeff Garzik18552562007-10-03 15:15:40 -0400731 const struct list_head *head = from ? &from->list : &dmi_devices;
732 struct list_head *d;
Andrey Paninebad6a42005-09-06 15:18:29 -0700733
Jean Delvare02d9c472013-09-11 14:24:08 -0700734 for (d = head->next; d != &dmi_devices; d = d->next) {
Jeff Garzik18552562007-10-03 15:15:40 -0400735 const struct dmi_device *dev =
736 list_entry(d, struct dmi_device, list);
Andrey Paninebad6a42005-09-06 15:18:29 -0700737
738 if (((type == DMI_DEV_TYPE_ANY) || (dev->type == type)) &&
739 ((name == NULL) || (strcmp(dev->name, name) == 0)))
740 return dev;
741 }
742
743 return NULL;
744}
745EXPORT_SYMBOL(dmi_find_device);
Andi Kleenf083a322006-03-25 16:30:19 +0100746
747/**
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900748 * dmi_get_date - parse a DMI date
749 * @field: data index (see enum dmi_field)
750 * @yearp: optional out parameter for the year
751 * @monthp: optional out parameter for the month
752 * @dayp: optional out parameter for the day
Andi Kleenf083a322006-03-25 16:30:19 +0100753 *
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900754 * The date field is assumed to be in the form resembling
755 * [mm[/dd]]/yy[yy] and the result is stored in the out
756 * parameters any or all of which can be omitted.
757 *
758 * If the field doesn't exist, all out parameters are set to zero
759 * and false is returned. Otherwise, true is returned with any
760 * invalid part of date set to zero.
761 *
762 * On return, year, month and day are guaranteed to be in the
763 * range of [0,9999], [0,12] and [0,31] respectively.
Andi Kleenf083a322006-03-25 16:30:19 +0100764 */
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900765bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp)
Andi Kleenf083a322006-03-25 16:30:19 +0100766{
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900767 int year = 0, month = 0, day = 0;
768 bool exists;
769 const char *s, *y;
Tejun Heo02c24fa2009-08-16 21:01:22 +0900770 char *e;
Andi Kleenf083a322006-03-25 16:30:19 +0100771
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900772 s = dmi_get_system_info(field);
773 exists = s;
774 if (!exists)
775 goto out;
Andi Kleenf083a322006-03-25 16:30:19 +0100776
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900777 /*
778 * Determine year first. We assume the date string resembles
779 * mm/dd/yy[yy] but the original code extracted only the year
780 * from the end. Keep the behavior in the spirit of no
781 * surprises.
782 */
783 y = strrchr(s, '/');
784 if (!y)
785 goto out;
786
787 y++;
788 year = simple_strtoul(y, &e, 10);
789 if (y != e && year < 100) { /* 2-digit year */
Andi Kleenf083a322006-03-25 16:30:19 +0100790 year += 1900;
791 if (year < 1996) /* no dates < spec 1.0 */
792 year += 100;
793 }
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900794 if (year > 9999) /* year should fit in %04d */
795 year = 0;
Andi Kleenf083a322006-03-25 16:30:19 +0100796
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900797 /* parse the mm and dd */
798 month = simple_strtoul(s, &e, 10);
799 if (s == e || *e != '/' || !month || month > 12) {
800 month = 0;
801 goto out;
802 }
803
804 s = e + 1;
805 day = simple_strtoul(s, &e, 10);
806 if (s == y || s == e || *e != '/' || day > 31)
807 day = 0;
808out:
809 if (yearp)
810 *yearp = year;
811 if (monthp)
812 *monthp = month;
813 if (dayp)
814 *dayp = day;
815 return exists;
Andi Kleenf083a322006-03-25 16:30:19 +0100816}
Tejun Heo3e5cd1f2009-08-16 21:02:36 +0900817EXPORT_SYMBOL(dmi_get_date);
Jean Delvare7fce0842007-11-03 17:29:20 +0100818
819/**
820 * dmi_walk - Walk the DMI table and get called back for every record
821 * @decode: Callback function
Jean Delvaree7a19c562009-03-30 21:46:44 +0200822 * @private_data: Private data to be passed to the callback function
Jean Delvare7fce0842007-11-03 17:29:20 +0100823 *
824 * Returns -1 when the DMI table can't be reached, 0 on success.
825 */
Jean Delvaree7a19c562009-03-30 21:46:44 +0200826int dmi_walk(void (*decode)(const struct dmi_header *, void *),
827 void *private_data)
Jean Delvare7fce0842007-11-03 17:29:20 +0100828{
829 u8 *buf;
830
831 if (!dmi_available)
832 return -1;
833
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800834 buf = dmi_remap(dmi_base, dmi_len);
Jean Delvare7fce0842007-11-03 17:29:20 +0100835 if (buf == NULL)
836 return -1;
837
Jean Delvaree7a19c562009-03-30 21:46:44 +0200838 dmi_table(buf, dmi_len, dmi_num, decode, private_data);
Jean Delvare7fce0842007-11-03 17:29:20 +0100839
Ard Biesheuvelcf074402014-01-23 15:54:39 -0800840 dmi_unmap(buf);
Jean Delvare7fce0842007-11-03 17:29:20 +0100841 return 0;
842}
843EXPORT_SYMBOL_GPL(dmi_walk);
Jiri Slabyd61c72e2008-12-10 14:07:21 +0100844
845/**
846 * dmi_match - compare a string to the dmi field (if exists)
Randy Dunlapc2bacfc2009-01-06 14:41:40 -0800847 * @f: DMI field identifier
848 * @str: string to compare the DMI field to
Jiri Slabyd61c72e2008-12-10 14:07:21 +0100849 *
850 * Returns true if the requested field equals to the str (including NULL).
851 */
852bool dmi_match(enum dmi_field f, const char *str)
853{
854 const char *info = dmi_get_system_info(f);
855
856 if (info == NULL || str == NULL)
857 return info == str;
858
859 return !strcmp(info, str);
860}
861EXPORT_SYMBOL_GPL(dmi_match);
Chen, Gongdd6dad42013-10-18 14:29:25 -0700862
863void dmi_memdev_name(u16 handle, const char **bank, const char **device)
864{
865 int n;
866
867 if (dmi_memdev == NULL)
868 return;
869
870 for (n = 0; n < dmi_memdev_nr; n++) {
871 if (handle == dmi_memdev[n].handle) {
872 *bank = dmi_memdev[n].bank;
873 *device = dmi_memdev[n].device;
874 break;
875 }
876 }
877}
878EXPORT_SYMBOL_GPL(dmi_memdev_name);