]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/firmware/dmi_scan.c
parport: fix ieee1284_epp_read_addr
[mirror_ubuntu-artful-kernel.git] / drivers / firmware / dmi_scan.c
CommitLineData
1da177e4 1#include <linux/types.h>
1da177e4
LT
2#include <linux/string.h>
3#include <linux/init.h>
4#include <linux/module.h>
1da177e4 5#include <linux/dmi.h>
3ed3bce8 6#include <linux/efi.h>
1da177e4 7#include <linux/bootmem.h>
e9928674 8#include <linux/slab.h>
f2d3efed 9#include <asm/dmi.h>
1da177e4 10
79da4721
PW
11static char dmi_empty_string[] = " ";
12
1855256c 13static char * __init dmi_string(const struct dmi_header *dm, u8 s)
1da177e4 14{
1855256c 15 const u8 *bp = ((u8 *) dm) + dm->length;
c3c7120d 16 char *str = "";
1249c513 17
c3c7120d 18 if (s) {
1da177e4 19 s--;
c3c7120d
AP
20 while (s > 0 && *bp) {
21 bp += strlen(bp) + 1;
22 s--;
23 }
24
25 if (*bp != 0) {
79da4721
PW
26 size_t len = strlen(bp)+1;
27 size_t cmp_len = len > 8 ? 8 : len;
28
29 if (!memcmp(bp, dmi_empty_string, cmp_len))
30 return dmi_empty_string;
31 str = dmi_alloc(len);
c3c7120d
AP
32 if (str != NULL)
33 strcpy(str, bp);
34 else
79da4721 35 printk(KERN_ERR "dmi_string: cannot allocate %Zu bytes.\n", len);
c3c7120d 36 }
4f705ae3 37 }
c3c7120d
AP
38
39 return str;
1da177e4
LT
40}
41
42/*
43 * We have to be cautious here. We have seen BIOSes with DMI pointers
44 * pointing to completely the wrong place for example
45 */
7fce084a
JD
46static void dmi_table(u8 *buf, int len, int num,
47 void (*decode)(const struct dmi_header *))
1da177e4 48{
7fce084a 49 u8 *data = buf;
1249c513 50 int i = 0;
4f705ae3 51
1da177e4 52 /*
4f705ae3
BH
53 * Stop when we see all the items the table claimed to have
54 * OR we run off the end of the table (also happens)
55 */
1249c513 56 while ((i < num) && (data - buf + sizeof(struct dmi_header)) <= len) {
1855256c
JG
57 const struct dmi_header *dm = (const struct dmi_header *)data;
58
1da177e4
LT
59 /*
60 * We want to know the total length (formated area and strings)
61 * before decoding to make sure we won't run off the table in
62 * dmi_decode or dmi_string
63 */
1249c513
AP
64 data += dm->length;
65 while ((data - buf < len - 1) && (data[0] || data[1]))
1da177e4 66 data++;
1249c513 67 if (data - buf < len - 1)
1da177e4 68 decode(dm);
1249c513 69 data += 2;
1da177e4
LT
70 i++;
71 }
7fce084a
JD
72}
73
74static u32 dmi_base;
75static u16 dmi_len;
76static u16 dmi_num;
77
78static int __init dmi_walk_early(void (*decode)(const struct dmi_header *))
79{
80 u8 *buf;
81
82 buf = dmi_ioremap(dmi_base, dmi_len);
83 if (buf == NULL)
84 return -1;
85
86 dmi_table(buf, dmi_len, dmi_num, decode);
87
88 dmi_iounmap(buf, dmi_len);
1da177e4
LT
89 return 0;
90}
91
1855256c 92static int __init dmi_checksum(const u8 *buf)
1da177e4 93{
1249c513 94 u8 sum = 0;
1da177e4 95 int a;
4f705ae3 96
1249c513
AP
97 for (a = 0; a < 15; a++)
98 sum += buf[a];
99
100 return sum == 0;
1da177e4
LT
101}
102
1da177e4 103static char *dmi_ident[DMI_STRING_MAX];
ebad6a42 104static LIST_HEAD(dmi_devices);
4f5c791a 105int dmi_available;
1da177e4
LT
106
107/*
108 * Save a DMI string
109 */
1855256c 110static void __init dmi_save_ident(const struct dmi_header *dm, int slot, int string)
1da177e4 111{
1855256c
JG
112 const char *d = (const char*) dm;
113 char *p;
1249c513 114
1da177e4
LT
115 if (dmi_ident[slot])
116 return;
1249c513 117
c3c7120d
AP
118 p = dmi_string(dm, d[string]);
119 if (p == NULL)
120 return;
121
122 dmi_ident[slot] = p;
1da177e4
LT
123}
124
1855256c 125static void __init dmi_save_uuid(const struct dmi_header *dm, int slot, int index)
4f5c791a 126{
1855256c 127 const u8 *d = (u8*) dm + index;
4f5c791a
LP
128 char *s;
129 int is_ff = 1, is_00 = 1, i;
130
131 if (dmi_ident[slot])
132 return;
133
134 for (i = 0; i < 16 && (is_ff || is_00); i++) {
135 if(d[i] != 0x00) is_ff = 0;
136 if(d[i] != 0xFF) is_00 = 0;
137 }
138
139 if (is_ff || is_00)
140 return;
141
142 s = dmi_alloc(16*2+4+1);
143 if (!s)
144 return;
145
146 sprintf(s,
147 "%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
148 d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],
149 d[8], d[9], d[10], d[11], d[12], d[13], d[14], d[15]);
150
151 dmi_ident[slot] = s;
152}
153
1855256c 154static void __init dmi_save_type(const struct dmi_header *dm, int slot, int index)
4f5c791a 155{
1855256c 156 const u8 *d = (u8*) dm + index;
4f5c791a
LP
157 char *s;
158
159 if (dmi_ident[slot])
160 return;
161
162 s = dmi_alloc(4);
163 if (!s)
164 return;
165
166 sprintf(s, "%u", *d & 0x7F);
167 dmi_ident[slot] = s;
168}
169
1855256c 170static void __init dmi_save_devices(const struct dmi_header *dm)
ebad6a42
AP
171{
172 int i, count = (dm->length - sizeof(struct dmi_header)) / 2;
173 struct dmi_device *dev;
174
175 for (i = 0; i < count; i++) {
1855256c 176 const char *d = (char *)(dm + 1) + (i * 2);
ebad6a42
AP
177
178 /* Skip disabled device */
179 if ((*d & 0x80) == 0)
180 continue;
181
e9928674 182 dev = dmi_alloc(sizeof(*dev));
ebad6a42
AP
183 if (!dev) {
184 printk(KERN_ERR "dmi_save_devices: out of memory.\n");
185 break;
186 }
187
188 dev->type = *d++ & 0x7f;
189 dev->name = dmi_string(dm, *d);
190 dev->device_data = NULL;
2e0c1f6c
SM
191 list_add(&dev->list, &dmi_devices);
192 }
193}
194
79da4721
PW
195static struct dmi_device empty_oem_string_dev = {
196 .name = dmi_empty_string,
197};
198
1855256c 199static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm)
2e0c1f6c
SM
200{
201 int i, count = *(u8 *)(dm + 1);
202 struct dmi_device *dev;
203
204 for (i = 1; i <= count; i++) {
79da4721
PW
205 char *devname = dmi_string(dm, i);
206
207 if (!strcmp(devname, dmi_empty_string)) {
208 list_add(&empty_oem_string_dev.list, &dmi_devices);
209 continue;
210 }
211
2e0c1f6c
SM
212 dev = dmi_alloc(sizeof(*dev));
213 if (!dev) {
214 printk(KERN_ERR
215 "dmi_save_oem_strings_devices: out of memory.\n");
216 break;
217 }
218
219 dev->type = DMI_DEV_TYPE_OEM_STRING;
79da4721 220 dev->name = devname;
2e0c1f6c 221 dev->device_data = NULL;
ebad6a42
AP
222
223 list_add(&dev->list, &dmi_devices);
224 }
225}
226
1855256c 227static void __init dmi_save_ipmi_device(const struct dmi_header *dm)
ebad6a42
AP
228{
229 struct dmi_device *dev;
230 void * data;
231
e9928674 232 data = dmi_alloc(dm->length);
ebad6a42
AP
233 if (data == NULL) {
234 printk(KERN_ERR "dmi_save_ipmi_device: out of memory.\n");
235 return;
236 }
237
238 memcpy(data, dm, dm->length);
239
e9928674 240 dev = dmi_alloc(sizeof(*dev));
ebad6a42
AP
241 if (!dev) {
242 printk(KERN_ERR "dmi_save_ipmi_device: out of memory.\n");
243 return;
244 }
245
246 dev->type = DMI_DEV_TYPE_IPMI;
247 dev->name = "IPMI controller";
248 dev->device_data = data;
249
250 list_add(&dev->list, &dmi_devices);
251}
252
1da177e4
LT
253/*
254 * Process a DMI table entry. Right now all we care about are the BIOS
255 * and machine entries. For 2.5 we should pull the smbus controller info
256 * out of here.
257 */
1855256c 258static void __init dmi_decode(const struct dmi_header *dm)
1da177e4 259{
1249c513 260 switch(dm->type) {
ebad6a42 261 case 0: /* BIOS Information */
1249c513 262 dmi_save_ident(dm, DMI_BIOS_VENDOR, 4);
1249c513 263 dmi_save_ident(dm, DMI_BIOS_VERSION, 5);
1249c513
AP
264 dmi_save_ident(dm, DMI_BIOS_DATE, 8);
265 break;
ebad6a42 266 case 1: /* System Information */
1249c513 267 dmi_save_ident(dm, DMI_SYS_VENDOR, 4);
1249c513 268 dmi_save_ident(dm, DMI_PRODUCT_NAME, 5);
1249c513 269 dmi_save_ident(dm, DMI_PRODUCT_VERSION, 6);
1249c513 270 dmi_save_ident(dm, DMI_PRODUCT_SERIAL, 7);
4f5c791a 271 dmi_save_uuid(dm, DMI_PRODUCT_UUID, 8);
1249c513 272 break;
ebad6a42 273 case 2: /* Base Board Information */
1249c513 274 dmi_save_ident(dm, DMI_BOARD_VENDOR, 4);
1249c513 275 dmi_save_ident(dm, DMI_BOARD_NAME, 5);
1249c513 276 dmi_save_ident(dm, DMI_BOARD_VERSION, 6);
4f5c791a
LP
277 dmi_save_ident(dm, DMI_BOARD_SERIAL, 7);
278 dmi_save_ident(dm, DMI_BOARD_ASSET_TAG, 8);
279 break;
280 case 3: /* Chassis Information */
281 dmi_save_ident(dm, DMI_CHASSIS_VENDOR, 4);
282 dmi_save_type(dm, DMI_CHASSIS_TYPE, 5);
283 dmi_save_ident(dm, DMI_CHASSIS_VERSION, 6);
284 dmi_save_ident(dm, DMI_CHASSIS_SERIAL, 7);
285 dmi_save_ident(dm, DMI_CHASSIS_ASSET_TAG, 8);
1249c513 286 break;
ebad6a42
AP
287 case 10: /* Onboard Devices Information */
288 dmi_save_devices(dm);
289 break;
2e0c1f6c
SM
290 case 11: /* OEM Strings */
291 dmi_save_oem_strings_devices(dm);
292 break;
ebad6a42
AP
293 case 38: /* IPMI Device Information */
294 dmi_save_ipmi_device(dm);
1da177e4
LT
295 }
296}
297
1855256c 298static int __init dmi_present(const char __iomem *p)
1da177e4 299{
61e032fa 300 u8 buf[15];
1855256c 301
3ed3bce8
MD
302 memcpy_fromio(buf, p, 15);
303 if ((memcmp(buf, "_DMI_", 5) == 0) && dmi_checksum(buf)) {
7fce084a
JD
304 dmi_num = (buf[13] << 8) | buf[12];
305 dmi_len = (buf[7] << 8) | buf[6];
306 dmi_base = (buf[11] << 24) | (buf[10] << 16) |
3ed3bce8 307 (buf[9] << 8) | buf[8];
61e032fa 308
3ed3bce8
MD
309 /*
310 * DMI version 0.0 means that the real version is taken from
311 * the SMBIOS version, which we don't know at this point.
312 */
313 if (buf[14] != 0)
314 printk(KERN_INFO "DMI %d.%d present.\n",
315 buf[14] >> 4, buf[14] & 0xF);
316 else
317 printk(KERN_INFO "DMI present.\n");
7fce084a 318 if (dmi_walk_early(dmi_decode) == 0)
3ed3bce8
MD
319 return 0;
320 }
321 return 1;
322}
61e032fa 323
3ed3bce8
MD
324void __init dmi_scan_machine(void)
325{
326 char __iomem *p, *q;
327 int rc;
328
329 if (efi_enabled) {
b2c99e3c 330 if (efi.smbios == EFI_INVALID_TABLE_ADDR)
3ed3bce8
MD
331 goto out;
332
4f5c791a
LP
333 /* This is called as a core_initcall() because it isn't
334 * needed during early boot. This also means we can
335 * iounmap the space when we're done with it.
336 */
b2c99e3c 337 p = dmi_ioremap(efi.smbios, 32);
3ed3bce8
MD
338 if (p == NULL)
339 goto out;
340
341 rc = dmi_present(p + 0x10); /* offset of _DMI_ string */
23dd842c 342 dmi_iounmap(p, 32);
4f5c791a
LP
343 if (!rc) {
344 dmi_available = 1;
3ed3bce8 345 return;
4f5c791a 346 }
3ed3bce8
MD
347 }
348 else {
349 /*
350 * no iounmap() for that ioremap(); it would be a no-op, but
351 * it's so early in setup that sucker gets confused into doing
352 * what it shouldn't if we actually call it.
353 */
354 p = dmi_ioremap(0xF0000, 0x10000);
355 if (p == NULL)
356 goto out;
357
358 for (q = p; q < p + 0x10000; q += 16) {
359 rc = dmi_present(q);
4f5c791a
LP
360 if (!rc) {
361 dmi_available = 1;
0d64484f 362 dmi_iounmap(p, 0x10000);
61e032fa 363 return;
4f5c791a 364 }
61e032fa 365 }
3212bff3 366 dmi_iounmap(p, 0x10000);
61e032fa 367 }
3ed3bce8 368 out: printk(KERN_INFO "DMI not present or invalid.\n");
1da177e4
LT
369}
370
1da177e4
LT
371/**
372 * dmi_check_system - check system DMI data
373 * @list: array of dmi_system_id structures to match against
b0ef371e
RD
374 * All non-null elements of the list must match
375 * their slot's (field index's) data (i.e., each
376 * list string must be a substring of the specified
377 * DMI slot's string data) to be considered a
378 * successful match.
1da177e4
LT
379 *
380 * Walk the blacklist table running matching functions until someone
381 * returns non zero or we hit the end. Callback function is called for
b0ef371e 382 * each successful match. Returns the number of matches.
1da177e4 383 */
1855256c 384int dmi_check_system(const struct dmi_system_id *list)
1da177e4
LT
385{
386 int i, count = 0;
1855256c 387 const struct dmi_system_id *d = list;
1da177e4
LT
388
389 while (d->ident) {
390 for (i = 0; i < ARRAY_SIZE(d->matches); i++) {
391 int s = d->matches[i].slot;
392 if (s == DMI_NONE)
393 continue;
394 if (dmi_ident[s] && strstr(dmi_ident[s], d->matches[i].substr))
395 continue;
396 /* No match */
397 goto fail;
398 }
640e8033 399 count++;
1da177e4
LT
400 if (d->callback && d->callback(d))
401 break;
1da177e4
LT
402fail: d++;
403 }
404
405 return count;
406}
1da177e4
LT
407EXPORT_SYMBOL(dmi_check_system);
408
409/**
410 * dmi_get_system_info - return DMI data value
b0ef371e 411 * @field: data index (see enum dmi_field)
1da177e4
LT
412 *
413 * Returns one DMI data value, can be used to perform
414 * complex DMI data checks.
415 */
1855256c 416const char *dmi_get_system_info(int field)
1da177e4
LT
417{
418 return dmi_ident[field];
419}
e70c9d5e 420EXPORT_SYMBOL(dmi_get_system_info);
ebad6a42 421
a1bae672
AK
422
423/**
424 * dmi_name_in_vendors - Check if string is anywhere in the DMI vendor information.
425 * @str: Case sensitive Name
426 */
1855256c 427int dmi_name_in_vendors(const char *str)
a1bae672
AK
428{
429 static int fields[] = { DMI_BIOS_VENDOR, DMI_BIOS_VERSION, DMI_SYS_VENDOR,
430 DMI_PRODUCT_NAME, DMI_PRODUCT_VERSION, DMI_BOARD_VENDOR,
431 DMI_BOARD_NAME, DMI_BOARD_VERSION, DMI_NONE };
432 int i;
433 for (i = 0; fields[i] != DMI_NONE; i++) {
434 int f = fields[i];
435 if (dmi_ident[f] && strstr(dmi_ident[f], str))
436 return 1;
437 }
438 return 0;
439}
440EXPORT_SYMBOL(dmi_name_in_vendors);
441
ebad6a42
AP
442/**
443 * dmi_find_device - find onboard device by type/name
444 * @type: device type or %DMI_DEV_TYPE_ANY to match all device types
b0ef371e 445 * @name: device name string or %NULL to match all
ebad6a42
AP
446 * @from: previous device found in search, or %NULL for new search.
447 *
448 * Iterates through the list of known onboard devices. If a device is
449 * found with a matching @vendor and @device, a pointer to its device
450 * structure is returned. Otherwise, %NULL is returned.
b0ef371e 451 * A new search is initiated by passing %NULL as the @from argument.
ebad6a42
AP
452 * If @from is not %NULL, searches continue from next device.
453 */
1855256c
JG
454const struct dmi_device * dmi_find_device(int type, const char *name,
455 const struct dmi_device *from)
ebad6a42 456{
1855256c
JG
457 const struct list_head *head = from ? &from->list : &dmi_devices;
458 struct list_head *d;
ebad6a42
AP
459
460 for(d = head->next; d != &dmi_devices; d = d->next) {
1855256c
JG
461 const struct dmi_device *dev =
462 list_entry(d, struct dmi_device, list);
ebad6a42
AP
463
464 if (((type == DMI_DEV_TYPE_ANY) || (dev->type == type)) &&
465 ((name == NULL) || (strcmp(dev->name, name) == 0)))
466 return dev;
467 }
468
469 return NULL;
470}
471EXPORT_SYMBOL(dmi_find_device);
f083a329
AK
472
473/**
474 * dmi_get_year - Return year of a DMI date
475 * @field: data index (like dmi_get_system_info)
476 *
477 * Returns -1 when the field doesn't exist. 0 when it is broken.
478 */
479int dmi_get_year(int field)
480{
481 int year;
1855256c 482 const char *s = dmi_get_system_info(field);
f083a329
AK
483
484 if (!s)
485 return -1;
486 if (*s == '\0')
487 return 0;
488 s = strrchr(s, '/');
489 if (!s)
490 return 0;
491
492 s += 1;
493 year = simple_strtoul(s, NULL, 0);
494 if (year && year < 100) { /* 2-digit year */
495 year += 1900;
496 if (year < 1996) /* no dates < spec 1.0 */
497 year += 100;
498 }
499
500 return year;
501}
7fce084a
JD
502
503/**
504 * dmi_walk - Walk the DMI table and get called back for every record
505 * @decode: Callback function
506 *
507 * Returns -1 when the DMI table can't be reached, 0 on success.
508 */
509int dmi_walk(void (*decode)(const struct dmi_header *))
510{
511 u8 *buf;
512
513 if (!dmi_available)
514 return -1;
515
516 buf = ioremap(dmi_base, dmi_len);
517 if (buf == NULL)
518 return -1;
519
520 dmi_table(buf, dmi_len, dmi_num, decode);
521
522 iounmap(buf);
523 return 0;
524}
525EXPORT_SYMBOL_GPL(dmi_walk);