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