1 #include <linux/types.h> 2 #include <linux/string.h> 3 #include <linux/init.h> 4 #include <linux/module.h> 5 #include <linux/ctype.h> 6 #include <linux/dmi.h> 7 #include <linux/efi.h> 8 #include <linux/bootmem.h> 9 #include <linux/random.h> 10 #include <asm/dmi.h> 11 12 /* 13 * DMI stands for "Desktop Management Interface". It is part 14 * of and an antecedent to, SMBIOS, which stands for System 15 * Management BIOS. See further: http://www.dmtf.org/standards 16 */ 17 static char dmi_empty_string[] = " "; 18 19 static u16 __initdata dmi_ver; 20 /* 21 * Catch too early calls to dmi_check_system(): 22 */ 23 static int dmi_initialized; 24 25 static const char * __init dmi_string_nosave(const struct dmi_header *dm, u8 s) 26 { 27 const u8 *bp = ((u8 *) dm) + dm->length; 28 29 if (s) { 30 s--; 31 while (s > 0 && *bp) { 32 bp += strlen(bp) + 1; 33 s--; 34 } 35 36 if (*bp != 0) { 37 size_t len = strlen(bp)+1; 38 size_t cmp_len = len > 8 ? 8 : len; 39 40 if (!memcmp(bp, dmi_empty_string, cmp_len)) 41 return dmi_empty_string; 42 return bp; 43 } 44 } 45 46 return ""; 47 } 48 49 static char * __init dmi_string(const struct dmi_header *dm, u8 s) 50 { 51 const char *bp = dmi_string_nosave(dm, s); 52 char *str; 53 size_t len; 54 55 if (bp == dmi_empty_string) 56 return dmi_empty_string; 57 58 len = strlen(bp) + 1; 59 str = dmi_alloc(len); 60 if (str != NULL) 61 strcpy(str, bp); 62 else 63 printk(KERN_ERR "dmi_string: cannot allocate %Zu bytes.\n", len); 64 65 return str; 66 } 67 68 /* 69 * We have to be cautious here. We have seen BIOSes with DMI pointers 70 * pointing to completely the wrong place for example 71 */ 72 static void dmi_table(u8 *buf, int len, int num, 73 void (*decode)(const struct dmi_header *, void *), 74 void *private_data) 75 { 76 u8 *data = buf; 77 int i = 0; 78 79 /* 80 * Stop when we see all the items the table claimed to have 81 * OR we run off the end of the table (also happens) 82 */ 83 while ((i < num) && (data - buf + sizeof(struct dmi_header)) <= len) { 84 const struct dmi_header *dm = (const struct dmi_header *)data; 85 86 /* 87 * We want to know the total length (formatted area and 88 * strings) before decoding to make sure we won't run off the 89 * table in dmi_decode or dmi_string 90 */ 91 data += dm->length; 92 while ((data - buf < len - 1) && (data[0] || data[1])) 93 data++; 94 if (data - buf < len - 1) 95 decode(dm, private_data); 96 data += 2; 97 i++; 98 } 99 } 100 101 static u32 dmi_base; 102 static u16 dmi_len; 103 static u16 dmi_num; 104 105 static int __init dmi_walk_early(void (*decode)(const struct dmi_header *, 106 void *)) 107 { 108 u8 *buf; 109 110 buf = dmi_ioremap(dmi_base, dmi_len); 111 if (buf == NULL) 112 return -1; 113 114 dmi_table(buf, dmi_len, dmi_num, decode, NULL); 115 116 add_device_randomness(buf, dmi_len); 117 118 dmi_iounmap(buf, dmi_len); 119 return 0; 120 } 121 122 static int __init dmi_checksum(const u8 *buf, u8 len) 123 { 124 u8 sum = 0; 125 int a; 126 127 for (a = 0; a < len; a++) 128 sum += buf[a]; 129 130 return sum == 0; 131 } 132 133 static char *dmi_ident[DMI_STRING_MAX]; 134 static LIST_HEAD(dmi_devices); 135 int dmi_available; 136 137 /* 138 * Save a DMI string 139 */ 140 static void __init dmi_save_ident(const struct dmi_header *dm, int slot, int string) 141 { 142 const char *d = (const char*) dm; 143 char *p; 144 145 if (dmi_ident[slot]) 146 return; 147 148 p = dmi_string(dm, d[string]); 149 if (p == NULL) 150 return; 151 152 dmi_ident[slot] = p; 153 } 154 155 static void __init dmi_save_uuid(const struct dmi_header *dm, int slot, int index) 156 { 157 const u8 *d = (u8*) dm + index; 158 char *s; 159 int is_ff = 1, is_00 = 1, i; 160 161 if (dmi_ident[slot]) 162 return; 163 164 for (i = 0; i < 16 && (is_ff || is_00); i++) { 165 if (d[i] != 0x00) 166 is_00 = 0; 167 if (d[i] != 0xFF) 168 is_ff = 0; 169 } 170 171 if (is_ff || is_00) 172 return; 173 174 s = dmi_alloc(16*2+4+1); 175 if (!s) 176 return; 177 178 /* 179 * As of version 2.6 of the SMBIOS specification, the first 3 fields of 180 * the UUID are supposed to be little-endian encoded. The specification 181 * says that this is the defacto standard. 182 */ 183 if (dmi_ver >= 0x0206) 184 sprintf(s, "%pUL", d); 185 else 186 sprintf(s, "%pUB", d); 187 188 dmi_ident[slot] = s; 189 } 190 191 static void __init dmi_save_type(const struct dmi_header *dm, int slot, int index) 192 { 193 const u8 *d = (u8*) dm + index; 194 char *s; 195 196 if (dmi_ident[slot]) 197 return; 198 199 s = dmi_alloc(4); 200 if (!s) 201 return; 202 203 sprintf(s, "%u", *d & 0x7F); 204 dmi_ident[slot] = s; 205 } 206 207 static void __init dmi_save_one_device(int type, const char *name) 208 { 209 struct dmi_device *dev; 210 211 /* No duplicate device */ 212 if (dmi_find_device(type, name, NULL)) 213 return; 214 215 dev = dmi_alloc(sizeof(*dev) + strlen(name) + 1); 216 if (!dev) { 217 printk(KERN_ERR "dmi_save_one_device: out of memory.\n"); 218 return; 219 } 220 221 dev->type = type; 222 strcpy((char *)(dev + 1), name); 223 dev->name = (char *)(dev + 1); 224 dev->device_data = NULL; 225 list_add(&dev->list, &dmi_devices); 226 } 227 228 static void __init dmi_save_devices(const struct dmi_header *dm) 229 { 230 int i, count = (dm->length - sizeof(struct dmi_header)) / 2; 231 232 for (i = 0; i < count; i++) { 233 const char *d = (char *)(dm + 1) + (i * 2); 234 235 /* Skip disabled device */ 236 if ((*d & 0x80) == 0) 237 continue; 238 239 dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d + 1))); 240 } 241 } 242 243 static void __init dmi_save_oem_strings_devices(const struct dmi_header *dm) 244 { 245 int i, count = *(u8 *)(dm + 1); 246 struct dmi_device *dev; 247 248 for (i = 1; i <= count; i++) { 249 char *devname = dmi_string(dm, i); 250 251 if (devname == dmi_empty_string) 252 continue; 253 254 dev = dmi_alloc(sizeof(*dev)); 255 if (!dev) { 256 printk(KERN_ERR 257 "dmi_save_oem_strings_devices: out of memory.\n"); 258 break; 259 } 260 261 dev->type = DMI_DEV_TYPE_OEM_STRING; 262 dev->name = devname; 263 dev->device_data = NULL; 264 265 list_add(&dev->list, &dmi_devices); 266 } 267 } 268 269 static void __init dmi_save_ipmi_device(const struct dmi_header *dm) 270 { 271 struct dmi_device *dev; 272 void * data; 273 274 data = dmi_alloc(dm->length); 275 if (data == NULL) { 276 printk(KERN_ERR "dmi_save_ipmi_device: out of memory.\n"); 277 return; 278 } 279 280 memcpy(data, dm, dm->length); 281 282 dev = dmi_alloc(sizeof(*dev)); 283 if (!dev) { 284 printk(KERN_ERR "dmi_save_ipmi_device: out of memory.\n"); 285 return; 286 } 287 288 dev->type = DMI_DEV_TYPE_IPMI; 289 dev->name = "IPMI controller"; 290 dev->device_data = data; 291 292 list_add_tail(&dev->list, &dmi_devices); 293 } 294 295 static void __init dmi_save_dev_onboard(int instance, int segment, int bus, 296 int devfn, const char *name) 297 { 298 struct dmi_dev_onboard *onboard_dev; 299 300 onboard_dev = dmi_alloc(sizeof(*onboard_dev) + strlen(name) + 1); 301 if (!onboard_dev) { 302 printk(KERN_ERR "dmi_save_dev_onboard: out of memory.\n"); 303 return; 304 } 305 onboard_dev->instance = instance; 306 onboard_dev->segment = segment; 307 onboard_dev->bus = bus; 308 onboard_dev->devfn = devfn; 309 310 strcpy((char *)&onboard_dev[1], name); 311 onboard_dev->dev.type = DMI_DEV_TYPE_DEV_ONBOARD; 312 onboard_dev->dev.name = (char *)&onboard_dev[1]; 313 onboard_dev->dev.device_data = onboard_dev; 314 315 list_add(&onboard_dev->dev.list, &dmi_devices); 316 } 317 318 static void __init dmi_save_extended_devices(const struct dmi_header *dm) 319 { 320 const u8 *d = (u8*) dm + 5; 321 322 /* Skip disabled device */ 323 if ((*d & 0x80) == 0) 324 return; 325 326 dmi_save_dev_onboard(*(d+1), *(u16 *)(d+2), *(d+4), *(d+5), 327 dmi_string_nosave(dm, *(d-1))); 328 dmi_save_one_device(*d & 0x7f, dmi_string_nosave(dm, *(d - 1))); 329 } 330 331 /* 332 * Process a DMI table entry. Right now all we care about are the BIOS 333 * and machine entries. For 2.5 we should pull the smbus controller info 334 * out of here. 335 */ 336 static void __init dmi_decode(const struct dmi_header *dm, void *dummy) 337 { 338 switch(dm->type) { 339 case 0: /* BIOS Information */ 340 dmi_save_ident(dm, DMI_BIOS_VENDOR, 4); 341 dmi_save_ident(dm, DMI_BIOS_VERSION, 5); 342 dmi_save_ident(dm, DMI_BIOS_DATE, 8); 343 break; 344 case 1: /* System Information */ 345 dmi_save_ident(dm, DMI_SYS_VENDOR, 4); 346 dmi_save_ident(dm, DMI_PRODUCT_NAME, 5); 347 dmi_save_ident(dm, DMI_PRODUCT_VERSION, 6); 348 dmi_save_ident(dm, DMI_PRODUCT_SERIAL, 7); 349 dmi_save_uuid(dm, DMI_PRODUCT_UUID, 8); 350 break; 351 case 2: /* Base Board Information */ 352 dmi_save_ident(dm, DMI_BOARD_VENDOR, 4); 353 dmi_save_ident(dm, DMI_BOARD_NAME, 5); 354 dmi_save_ident(dm, DMI_BOARD_VERSION, 6); 355 dmi_save_ident(dm, DMI_BOARD_SERIAL, 7); 356 dmi_save_ident(dm, DMI_BOARD_ASSET_TAG, 8); 357 break; 358 case 3: /* Chassis Information */ 359 dmi_save_ident(dm, DMI_CHASSIS_VENDOR, 4); 360 dmi_save_type(dm, DMI_CHASSIS_TYPE, 5); 361 dmi_save_ident(dm, DMI_CHASSIS_VERSION, 6); 362 dmi_save_ident(dm, DMI_CHASSIS_SERIAL, 7); 363 dmi_save_ident(dm, DMI_CHASSIS_ASSET_TAG, 8); 364 break; 365 case 10: /* Onboard Devices Information */ 366 dmi_save_devices(dm); 367 break; 368 case 11: /* OEM Strings */ 369 dmi_save_oem_strings_devices(dm); 370 break; 371 case 38: /* IPMI Device Information */ 372 dmi_save_ipmi_device(dm); 373 break; 374 case 41: /* Onboard Devices Extended Information */ 375 dmi_save_extended_devices(dm); 376 } 377 } 378 379 static void __init print_filtered(const char *info) 380 { 381 const char *p; 382 383 if (!info) 384 return; 385 386 for (p = info; *p; p++) 387 if (isprint(*p)) 388 printk(KERN_CONT "%c", *p); 389 else 390 printk(KERN_CONT "\\x%02x", *p & 0xff); 391 } 392 393 static void __init dmi_dump_ids(void) 394 { 395 const char *board; /* Board Name is optional */ 396 397 printk(KERN_DEBUG "DMI: "); 398 print_filtered(dmi_get_system_info(DMI_SYS_VENDOR)); 399 printk(KERN_CONT " "); 400 print_filtered(dmi_get_system_info(DMI_PRODUCT_NAME)); 401 board = dmi_get_system_info(DMI_BOARD_NAME); 402 if (board) { 403 printk(KERN_CONT "/"); 404 print_filtered(board); 405 } 406 printk(KERN_CONT ", BIOS "); 407 print_filtered(dmi_get_system_info(DMI_BIOS_VERSION)); 408 printk(KERN_CONT " "); 409 print_filtered(dmi_get_system_info(DMI_BIOS_DATE)); 410 printk(KERN_CONT "\n"); 411 } 412 413 static int __init dmi_present(const char __iomem *p) 414 { 415 u8 buf[15]; 416 417 memcpy_fromio(buf, p, 15); 418 if (dmi_checksum(buf, 15)) { 419 dmi_num = (buf[13] << 8) | buf[12]; 420 dmi_len = (buf[7] << 8) | buf[6]; 421 dmi_base = (buf[11] << 24) | (buf[10] << 16) | 422 (buf[9] << 8) | buf[8]; 423 424 if (dmi_walk_early(dmi_decode) == 0) { 425 if (dmi_ver) 426 pr_info("SMBIOS %d.%d present.\n", 427 dmi_ver >> 8, dmi_ver & 0xFF); 428 else { 429 dmi_ver = (buf[14] & 0xF0) << 4 | 430 (buf[14] & 0x0F); 431 pr_info("Legacy DMI %d.%d present.\n", 432 dmi_ver >> 8, dmi_ver & 0xFF); 433 } 434 dmi_dump_ids(); 435 return 0; 436 } 437 } 438 dmi_ver = 0; 439 return 1; 440 } 441 442 static int __init smbios_present(const char __iomem *p) 443 { 444 u8 buf[32]; 445 446 memcpy_fromio(buf, p, 32); 447 if ((buf[5] < 32) && dmi_checksum(buf, buf[5])) { 448 dmi_ver = (buf[6] << 8) + buf[7]; 449 450 /* Some BIOS report weird SMBIOS version, fix that up */ 451 switch (dmi_ver) { 452 case 0x021F: 453 case 0x0221: 454 pr_debug("SMBIOS version fixup(2.%d->2.%d)\n", 455 dmi_ver & 0xFF, 3); 456 dmi_ver = 0x0203; 457 break; 458 case 0x0233: 459 pr_debug("SMBIOS version fixup(2.%d->2.%d)\n", 51, 6); 460 dmi_ver = 0x0206; 461 break; 462 } 463 return memcmp(p + 16, "_DMI_", 5) || dmi_present(p + 16); 464 } 465 return 1; 466 } 467 468 void __init dmi_scan_machine(void) 469 { 470 char __iomem *p, *q; 471 int rc; 472 473 if (efi_enabled(EFI_CONFIG_TABLES)) { 474 if (efi.smbios == EFI_INVALID_TABLE_ADDR) 475 goto error; 476 477 /* This is called as a core_initcall() because it isn't 478 * needed during early boot. This also means we can 479 * iounmap the space when we're done with it. 480 */ 481 p = dmi_ioremap(efi.smbios, 32); 482 if (p == NULL) 483 goto error; 484 485 rc = smbios_present(p); 486 dmi_iounmap(p, 32); 487 if (!rc) { 488 dmi_available = 1; 489 goto out; 490 } 491 } 492 else { 493 /* 494 * no iounmap() for that ioremap(); it would be a no-op, but 495 * it's so early in setup that sucker gets confused into doing 496 * what it shouldn't if we actually call it. 497 */ 498 p = dmi_ioremap(0xF0000, 0x10000); 499 if (p == NULL) 500 goto error; 501 502 for (q = p; q < p + 0x10000; q += 16) { 503 if (memcmp(q, "_SM_", 4) == 0 && q - p <= 0xFFE0) 504 rc = smbios_present(q); 505 else if (memcmp(q, "_DMI_", 5) == 0) 506 rc = dmi_present(q); 507 else 508 continue; 509 if (!rc) { 510 dmi_available = 1; 511 dmi_iounmap(p, 0x10000); 512 goto out; 513 } 514 } 515 dmi_iounmap(p, 0x10000); 516 } 517 error: 518 printk(KERN_INFO "DMI not present or invalid.\n"); 519 out: 520 dmi_initialized = 1; 521 } 522 523 /** 524 * dmi_matches - check if dmi_system_id structure matches system DMI data 525 * @dmi: pointer to the dmi_system_id structure to check 526 */ 527 static bool dmi_matches(const struct dmi_system_id *dmi) 528 { 529 int i; 530 531 WARN(!dmi_initialized, KERN_ERR "dmi check: not initialized yet.\n"); 532 533 for (i = 0; i < ARRAY_SIZE(dmi->matches); i++) { 534 int s = dmi->matches[i].slot; 535 if (s == DMI_NONE) 536 break; 537 if (dmi_ident[s] 538 && strstr(dmi_ident[s], dmi->matches[i].substr)) 539 continue; 540 /* No match */ 541 return false; 542 } 543 return true; 544 } 545 546 /** 547 * dmi_is_end_of_table - check for end-of-table marker 548 * @dmi: pointer to the dmi_system_id structure to check 549 */ 550 static bool dmi_is_end_of_table(const struct dmi_system_id *dmi) 551 { 552 return dmi->matches[0].slot == DMI_NONE; 553 } 554 555 /** 556 * dmi_check_system - check system DMI data 557 * @list: array of dmi_system_id structures to match against 558 * All non-null elements of the list must match 559 * their slot's (field index's) data (i.e., each 560 * list string must be a substring of the specified 561 * DMI slot's string data) to be considered a 562 * successful match. 563 * 564 * Walk the blacklist table running matching functions until someone 565 * returns non zero or we hit the end. Callback function is called for 566 * each successful match. Returns the number of matches. 567 */ 568 int dmi_check_system(const struct dmi_system_id *list) 569 { 570 int count = 0; 571 const struct dmi_system_id *d; 572 573 for (d = list; !dmi_is_end_of_table(d); d++) 574 if (dmi_matches(d)) { 575 count++; 576 if (d->callback && d->callback(d)) 577 break; 578 } 579 580 return count; 581 } 582 EXPORT_SYMBOL(dmi_check_system); 583 584 /** 585 * dmi_first_match - find dmi_system_id structure matching system DMI data 586 * @list: array of dmi_system_id structures to match against 587 * All non-null elements of the list must match 588 * their slot's (field index's) data (i.e., each 589 * list string must be a substring of the specified 590 * DMI slot's string data) to be considered a 591 * successful match. 592 * 593 * Walk the blacklist table until the first match is found. Return the 594 * pointer to the matching entry or NULL if there's no match. 595 */ 596 const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list) 597 { 598 const struct dmi_system_id *d; 599 600 for (d = list; !dmi_is_end_of_table(d); d++) 601 if (dmi_matches(d)) 602 return d; 603 604 return NULL; 605 } 606 EXPORT_SYMBOL(dmi_first_match); 607 608 /** 609 * dmi_get_system_info - return DMI data value 610 * @field: data index (see enum dmi_field) 611 * 612 * Returns one DMI data value, can be used to perform 613 * complex DMI data checks. 614 */ 615 const char *dmi_get_system_info(int field) 616 { 617 return dmi_ident[field]; 618 } 619 EXPORT_SYMBOL(dmi_get_system_info); 620 621 /** 622 * dmi_name_in_serial - Check if string is in the DMI product serial information 623 * @str: string to check for 624 */ 625 int dmi_name_in_serial(const char *str) 626 { 627 int f = DMI_PRODUCT_SERIAL; 628 if (dmi_ident[f] && strstr(dmi_ident[f], str)) 629 return 1; 630 return 0; 631 } 632 633 /** 634 * dmi_name_in_vendors - Check if string is in the DMI system or board vendor name 635 * @str: Case sensitive Name 636 */ 637 int dmi_name_in_vendors(const char *str) 638 { 639 static int fields[] = { DMI_SYS_VENDOR, DMI_BOARD_VENDOR, DMI_NONE }; 640 int i; 641 for (i = 0; fields[i] != DMI_NONE; i++) { 642 int f = fields[i]; 643 if (dmi_ident[f] && strstr(dmi_ident[f], str)) 644 return 1; 645 } 646 return 0; 647 } 648 EXPORT_SYMBOL(dmi_name_in_vendors); 649 650 /** 651 * dmi_find_device - find onboard device by type/name 652 * @type: device type or %DMI_DEV_TYPE_ANY to match all device types 653 * @name: device name string or %NULL to match all 654 * @from: previous device found in search, or %NULL for new search. 655 * 656 * Iterates through the list of known onboard devices. If a device is 657 * found with a matching @vendor and @device, a pointer to its device 658 * structure is returned. Otherwise, %NULL is returned. 659 * A new search is initiated by passing %NULL as the @from argument. 660 * If @from is not %NULL, searches continue from next device. 661 */ 662 const struct dmi_device * dmi_find_device(int type, const char *name, 663 const struct dmi_device *from) 664 { 665 const struct list_head *head = from ? &from->list : &dmi_devices; 666 struct list_head *d; 667 668 for(d = head->next; d != &dmi_devices; d = d->next) { 669 const struct dmi_device *dev = 670 list_entry(d, struct dmi_device, list); 671 672 if (((type == DMI_DEV_TYPE_ANY) || (dev->type == type)) && 673 ((name == NULL) || (strcmp(dev->name, name) == 0))) 674 return dev; 675 } 676 677 return NULL; 678 } 679 EXPORT_SYMBOL(dmi_find_device); 680 681 /** 682 * dmi_get_date - parse a DMI date 683 * @field: data index (see enum dmi_field) 684 * @yearp: optional out parameter for the year 685 * @monthp: optional out parameter for the month 686 * @dayp: optional out parameter for the day 687 * 688 * The date field is assumed to be in the form resembling 689 * [mm[/dd]]/yy[yy] and the result is stored in the out 690 * parameters any or all of which can be omitted. 691 * 692 * If the field doesn't exist, all out parameters are set to zero 693 * and false is returned. Otherwise, true is returned with any 694 * invalid part of date set to zero. 695 * 696 * On return, year, month and day are guaranteed to be in the 697 * range of [0,9999], [0,12] and [0,31] respectively. 698 */ 699 bool dmi_get_date(int field, int *yearp, int *monthp, int *dayp) 700 { 701 int year = 0, month = 0, day = 0; 702 bool exists; 703 const char *s, *y; 704 char *e; 705 706 s = dmi_get_system_info(field); 707 exists = s; 708 if (!exists) 709 goto out; 710 711 /* 712 * Determine year first. We assume the date string resembles 713 * mm/dd/yy[yy] but the original code extracted only the year 714 * from the end. Keep the behavior in the spirit of no 715 * surprises. 716 */ 717 y = strrchr(s, '/'); 718 if (!y) 719 goto out; 720 721 y++; 722 year = simple_strtoul(y, &e, 10); 723 if (y != e && year < 100) { /* 2-digit year */ 724 year += 1900; 725 if (year < 1996) /* no dates < spec 1.0 */ 726 year += 100; 727 } 728 if (year > 9999) /* year should fit in %04d */ 729 year = 0; 730 731 /* parse the mm and dd */ 732 month = simple_strtoul(s, &e, 10); 733 if (s == e || *e != '/' || !month || month > 12) { 734 month = 0; 735 goto out; 736 } 737 738 s = e + 1; 739 day = simple_strtoul(s, &e, 10); 740 if (s == y || s == e || *e != '/' || day > 31) 741 day = 0; 742 out: 743 if (yearp) 744 *yearp = year; 745 if (monthp) 746 *monthp = month; 747 if (dayp) 748 *dayp = day; 749 return exists; 750 } 751 EXPORT_SYMBOL(dmi_get_date); 752 753 /** 754 * dmi_walk - Walk the DMI table and get called back for every record 755 * @decode: Callback function 756 * @private_data: Private data to be passed to the callback function 757 * 758 * Returns -1 when the DMI table can't be reached, 0 on success. 759 */ 760 int dmi_walk(void (*decode)(const struct dmi_header *, void *), 761 void *private_data) 762 { 763 u8 *buf; 764 765 if (!dmi_available) 766 return -1; 767 768 buf = ioremap(dmi_base, dmi_len); 769 if (buf == NULL) 770 return -1; 771 772 dmi_table(buf, dmi_len, dmi_num, decode, private_data); 773 774 iounmap(buf); 775 return 0; 776 } 777 EXPORT_SYMBOL_GPL(dmi_walk); 778 779 /** 780 * dmi_match - compare a string to the dmi field (if exists) 781 * @f: DMI field identifier 782 * @str: string to compare the DMI field to 783 * 784 * Returns true if the requested field equals to the str (including NULL). 785 */ 786 bool dmi_match(enum dmi_field f, const char *str) 787 { 788 const char *info = dmi_get_system_info(f); 789 790 if (info == NULL || str == NULL) 791 return info == str; 792 793 return !strcmp(info, str); 794 } 795 EXPORT_SYMBOL_GPL(dmi_match); 796