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