?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Adding upstream version 6.03~pre2+dfsg.
[syslinux-debian/hramrach.git] / com32 / gpllib / dmi / dmi.c
blobef84e1e896bdb6b7da06752ca1927e1a746ceef3
1 /* ----------------------------------------------------------------------- *
2 *
3 * Copyright 2006 Erwan Velu - All Rights Reserved
4 *
5 * Permission is hereby granted, free of charge, to any person
6 * obtaining a copy of this software and associated documentation
7 * files (the "Software"), to deal in the Software without
8 * restriction, including without limitation the rights to use,
9 * copy, modify, merge, publish, distribute, sublicense, and/or
10 * sell copies of the Software, and to permit persons to whom
11 * the Software is furnished to do so, subject to the following
12 * conditions:
13 *
14 * The above copyright notice and this permission notice shall
15 * be included in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
19 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
21 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24 * OTHER DEALINGS IN THE SOFTWARE.
25 *
26 * -----------------------------------------------------------------------
27 */
28
29 #include <stdio.h>
30 #include <string.h>
31 #include "dmi/dmi.h"
32
33 const char *out_of_spec = "<OUT OF SPEC>";
34 const char *bad_index = "<BAD INDEX>";
35
36 /*
37 * Misc. util stuff
38 */
39
40 /*
41 * 3.3.11 On Board Devices Information (Type 10)
42 */
43
44 static const char *dmi_on_board_devices_type(uint8_t code)
45 {
46 /* 3.3.11.1 */
47 static const char *type[] = {
48 "Other", /* 0x01 */
49 "Unknown",
50 "Video",
51 "SCSI Controller",
52 "Ethernet",
53 "Token Ring",
54 "Sound",
55 "PATA Controller",
56 "SATA Controller",
57 "SAS Controller" /* 0x0A */
58 };
59
60 if (code >= 0x01 && code <= 0x0A)
61 return type[code - 0x01];
62 return out_of_spec;
63 }
64
65 static void dmi_on_board_devices(struct dmi_header *h, s_dmi * dmi)
66 {
67 uint8_t *p = h->data + 4;
68 uint8_t count = (h->length - 0x04) / 2;
69 unsigned int i;
70
71 for (i = 0;
72 i < count
73 && i <
74 sizeof dmi->base_board.devices_information /
75 sizeof *dmi->base_board.devices_information; i++) {
76 strlcpy(dmi->base_board.devices_information[i].type,
77 dmi_on_board_devices_type(p[2 * i] & 0x7F),
78 sizeof dmi->base_board.devices_information[i].type);
79 dmi->base_board.devices_information[i].status = p[2 * i] & 0x80;
80 strlcpy(dmi->base_board.devices_information[i].description,
81 dmi_string(h, p[2 * i + 1]),
82 sizeof dmi->base_board.devices_information[i].description);
83 }
84 }
85
86 /*
87 * 3.3.24 System Reset (Type 23)
88 */
89
90 static const char *dmi_system_reset_boot_option(uint8_t code)
91 {
92 static const char *option[] = {
93 "Operating System", /* 0x1 */
94 "System Utilities",
95 "Do Not Reboot" /* 0x3 */
96 };
97
98 if (code >= 0x1)
99 return option[code - 0x1];
100 return out_of_spec;
101 }
102
103 static void dmi_system_reset_count(uint16_t code, char *array)
104 {
105 if (code == 0xFFFF)
106 strlcpy(array, "Unknown", sizeof array);
107 else
108 snprintf(array, sizeof array, "%u", code);
109 }
110
111 static void dmi_system_reset_timer(uint16_t code, char *array)
112 {
113 if (code == 0xFFFF)
114 strlcpy(array, "Unknown", sizeof array);
115 else
116 snprintf(array, sizeof array, "%u min", code);
117 }
118
119 /*
120 * 3.3.25 Hardware Security (Type 24)
121 */
122
123 static const char *dmi_hardware_security_status(uint8_t code)
124 {
125 static const char *status[] = {
126 "Disabled", /* 0x00 */
127 "Enabled",
128 "Not Implemented",
129 "Unknown" /* 0x03 */
130 };
131
132 return status[code];
133 }
134
135 /*
136 * 3.3.12 OEM Strings (Type 11)
137 */
138
139 static void dmi_oem_strings(struct dmi_header *h, const char *prefix,
140 s_dmi * dmi)
141 {
142 uint8_t *p = h->data + 4;
143 uint8_t count = p[0x00];
144 int i;
145
146 for (i = 1; i <= count; i++)
147 snprintf(dmi->oem_strings, OEM_STRINGS_SIZE, "%s %s %s\n",
148 dmi->oem_strings, prefix, dmi_string(h, i));
149 }
150
151 /*
152 * 3.3.13 System Configuration Options (Type 12)
153 */
154 static void dmi_system_configuration_options(struct dmi_header *h,
155 const char *prefix, s_dmi * dmi)
156 {
157 uint8_t *p = h->data + 4;
158 uint8_t count = p[0x00];
159 int i;
160
161 for (i = 1; i <= count; i++)
162 snprintf(dmi->system.configuration_options,
163 SYSTEM_CONFIGURATION_OPTIONS_SIZE, "%s %s %s\n",
164 dmi->system.configuration_options, prefix, dmi_string(h, i));
165 }
166
167 static void dmi_system_boot_status(uint8_t code, char *array)
168 {
169 static const char *status[] = {
170 "No errors detected", /* 0 */
171 "No bootable media",
172 "Operating system failed to load",
173 "Firmware-detected hardware failure",
174 "Operating system-detected hardware failure",
175 "User-requested boot",
176 "System security violation",
177 "Previously-requested image",
178 "System watchdog timer expired" /* 8 */
179 };
180
181 if (code <= 8)
182 strlcpy(array, status[code], SYSTEM_BOOT_STATUS_SIZE);
183 if (code >= 128 && code <= 191)
184 strlcpy(array, "OEM-specific", SYSTEM_BOOT_STATUS_SIZE);
185 if (code >= 192)
186 strlcpy(array, "Product-specific", SYSTEM_BOOT_STATUS_SIZE);
187 }
188
189 void dmi_bios_runtime_size(uint32_t code, s_dmi * dmi)
190 {
191 if (code & 0x000003FF) {
192 dmi->bios.runtime_size = code;
193 strlcpy(dmi->bios.runtime_size_unit, "bytes",
194 sizeof(dmi->bios.runtime_size_unit));
195 } else {
196 dmi->bios.runtime_size = code >> 10;
197 strlcpy(dmi->bios.runtime_size_unit, "KB",
198 sizeof(dmi->bios.runtime_size_unit));
199
200 }
201 }
202
203 void dmi_bios_characteristics(uint64_t code, s_dmi * dmi)
204 {
205 int i;
206 /*
207 * This isn't very clear what this bit is supposed to mean
208 */
209 //if(code.l&(1<<3))
210 if (code && (1 << 3)) {
211 ((bool *) (&dmi->bios.characteristics))[0] = true;
212 return;
213 }
214
215 for (i = 4; i <= 31; i++)
216 //if(code.l&(1<<i))
217 if (code & (1 << i))
218 ((bool *) (&dmi->bios.characteristics))[i - 3] = true;
219 }
220
221 void dmi_bios_characteristics_x1(uint8_t code, s_dmi * dmi)
222 {
223 int i;
224
225 for (i = 0; i <= 7; i++)
226 if (code & (1 << i))
227 ((bool *) (&dmi->bios.characteristics_x1))[i] = true;
228 }
229
230 void dmi_bios_characteristics_x2(uint8_t code, s_dmi * dmi)
231 {
232 int i;
233
234 for (i = 0; i <= 2; i++)
235 if (code & (1 << i))
236 ((bool *) (&dmi->bios.characteristics_x2))[i] = true;
237 }
238
239 void dmi_system_uuid(uint8_t * p, s_dmi * dmi)
240 {
241 int only0xFF = 1, only0x00 = 1;
242 int i;
243
244 for (i = 0; i < 16 && (only0x00 || only0xFF); i++) {
245 if (p[i] != 0x00)
246 only0x00 = 0;
247 if (p[i] != 0xFF)
248 only0xFF = 0;
249 }
250
251 if (only0xFF) {
252 sprintf(dmi->system.uuid, "Not Present");
253 return;
254 }
255 if (only0x00) {
256 sprintf(dmi->system.uuid, "Not Settable");
257 return;
258 }
259
260 sprintf(dmi->system.uuid,
261 "%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
262 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10],
263 p[11], p[12], p[13], p[14], p[15]);
264 }
265
266 void dmi_system_wake_up_type(uint8_t code, s_dmi * dmi)
267 {
268 /* 3.3.2.1 */
269 static const char *type[] = {
270 "Reserved", /* 0x00 */
271 "Other",
272 "Unknown",
273 "APM Timer",
274 "Modem Ring",
275 "LAN Remote",
276 "Power Switch",
277 "PCI PME#",
278 "AC Power Restored" /* 0x08 */
279 };
280
281 if (code <= 0x08) {
282 strlcpy(dmi->system.wakeup_type, type[code],
283 sizeof(dmi->system.wakeup_type));
284 } else {
285 strlcpy(dmi->system.wakeup_type, out_of_spec,
286 sizeof(dmi->system.wakeup_type));
287 }
288 return;
289 }
290
291 static void dmi_base_board_features(uint8_t code, s_dmi * dmi)
292 {
293 if ((code & 0x1F) != 0) {
294 int i;
295
296 for (i = 0; i <= 4; i++)
297 if (code & (1 << i))
298 ((bool *) (&dmi->base_board.features))[i] = true;
299 }
300 }
301
302 static void dmi_base_board_type(uint8_t code, s_dmi * dmi)
303 {
304 /* 3.3.3.2 */
305 static const char *type[] = {
306 "Unknown", /* 0x01 */
307 "Other",
308 "Server Blade",
309 "Connectivity Switch",
310 "System Management Module",
311 "Processor Module",
312 "I/O Module",
313 "Memory Module",
314 "Daughter Board",
315 "Motherboard",
316 "Processor+Memory Module",
317 "Processor+I/O Module",
318 "Interconnect Board" /* 0x0D */
319 };
320
321 if (code >= 0x01 && code <= 0x0D) {
322 strlcpy(dmi->base_board.type, type[code],
323 sizeof(dmi->base_board.type));
324 } else {
325 strlcpy(dmi->base_board.type, out_of_spec,
326 sizeof(dmi->base_board.type));
327 }
328 return;
329 }
330
331 static void dmi_processor_voltage(uint8_t code, s_dmi * dmi)
332 {
333 /* 3.3.5.4 */
334 static const uint16_t voltage[] = {
335 5000,
336 3300,
337 2900
338 };
339 int i;
340
341 if (code & 0x80)
342 dmi->processor.voltage_mv = (code & 0x7f) * 100;
343 else {
344 for (i = 0; i <= 2; i++)
345 if (code & (1 << i))
346 dmi->processor.voltage_mv = voltage[i];
347 }
348 }
349
350 static void dmi_processor_id(uint8_t type, uint8_t * p, const char *version,
351 s_dmi * dmi)
352 {
353 /*
354 * Extra flags are now returned in the ECX register when one calls
355 * the CPUID instruction. Their meaning is explained in table 6, but
356 * DMI doesn't support this yet.
357 */
358 uint32_t eax, edx;
359 int sig = 0;
360
361 /*
362 * This might help learn about new processors supporting the
363 * CPUID instruction or another form of identification.
364 */
365 sprintf(dmi->processor.id, "ID: %02X %02X %02X %02X %02X %02X %02X %02X\n",
366 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
367
368 if (type == 0x05) { /* 80386 */
369 uint16_t dx = WORD(p);
370 /*
371 * 80386 have a different signature.
372 */
373 dmi->processor.signature.type = (dx >> 12);
374 dmi->processor.signature.family = ((dx >> 8) & 0xF);
375 dmi->processor.signature.stepping = (dx >> 4) & 0xF;
376 dmi->processor.signature.minor_stepping = (dx & 0xF);
377 return;
378 }
379 if (type == 0x06) { /* 80486 */
380 uint16_t dx = WORD(p);
381 /*
382 * Not all 80486 CPU support the CPUID instruction, we have to find
383 * wether the one we have here does or not. Note that this trick
384 * works only because we know that 80486 must be little-endian.
385 */
386 if ((dx & 0x0F00) == 0x0400
387 && ((dx & 0x00F0) == 0x0040 || (dx & 0x00F0) >= 0x0070)
388 && ((dx & 0x000F) >= 0x0003))
389 sig = 1;
390 else {
391 dmi->processor.signature.type = ((dx >> 12) & 0x3);
392 dmi->processor.signature.family = ((dx >> 8) & 0xF);
393 dmi->processor.signature.model = ((dx >> 4) & 0xF);
394 dmi->processor.signature.stepping = (dx & 0xF);
395 return;
396 }
397 } else if ((type >= 0x0B && type <= 0x13) /* Intel, Cyrix */
398 ||(type >= 0xB0 && type <= 0xB3) /* Intel */
399 ||type == 0xB5 /* Intel */
400 || type == 0xB9) /* Intel */
401 sig = 1;
402 else if ((type >= 0x18 && type <= 0x1D) /* AMD */
403 ||type == 0x1F /* AMD */
404 || (type >= 0xB6 && type <= 0xB7) /* AMD */
405 ||(type >= 0x83 && type <= 0x85)) /* AMD */
406 sig = 2;
407 else if (type == 0x01 || type == 0x02) {
408 /*
409 * Some X86-class CPU have family "Other" or "Unknown". In this case,
410 * we use the version string to determine if they are known to
411 * support the CPUID instruction.
412 */
413 if (strncmp(version, "Pentium III MMX", 15) == 0)
414 sig = 1;
415 else if (strncmp(version, "AMD Athlon(TM)", 14) == 0
416 || strncmp(version, "AMD Opteron(tm)", 15) == 0)
417 sig = 2;
418 else
419 return;
420 } else /* not X86-class */
421 return;
422
423 eax = DWORD(p);
424 edx = DWORD(p + 4);
425 switch (sig) {
426 case 1: /* Intel */
427 dmi->processor.signature.type = ((eax >> 12) & 0x3);
428 dmi->processor.signature.family =
429 (((eax >> 16) & 0xFF0) + ((eax >> 8) & 0x00F));
430 dmi->processor.signature.model =
431 (((eax >> 12) & 0xF0) + ((eax >> 4) & 0x0F));
432 dmi->processor.signature.stepping = (eax & 0xF);
433 break;
434 case 2: /* AMD */
435 dmi->processor.signature.family =
436 (((eax >> 8) & 0xF) == 0xF ? (eax >> 20) & 0xFF : (eax >> 8) & 0xF);
437 dmi->processor.signature.model =
438 (((eax >> 4) & 0xF) == 0xF ? (eax >> 16) & 0xF : (eax >> 4) & 0xF);
439 dmi->processor.signature.stepping = (eax & 0xF);
440 break;
441 }
442
443 edx = DWORD(p + 4);
444 if ((edx & 0x3FF7FDFF) != 0) {
445 int i;
446 for (i = 0; i <= 31; i++)
447 if (cpu_flags_strings[i] != NULL && edx & (1 << i))
448 ((bool *) (&dmi->processor.cpu_flags))[i] = true;
449 }
450 }
451
452 void to_dmi_header(struct dmi_header *h, uint8_t * data)
453 {
454 h->type = data[0];
455 h->length = data[1];
456 h->handle = WORD(data + 2);
457 h->data = data;
458 }
459
460 const char *dmi_string(struct dmi_header *dm, uint8_t s)
461 {
462 char *bp = (char *)dm->data;
463 size_t i, len;
464
465 if (s == 0)
466 return "Not Specified";
467
468 bp += dm->length;
469 while (s > 1 && *bp) {
470 bp += strlen(bp);
471 bp++;
472 s--;
473 }
474
475 if (!*bp)
476 return bad_index;
477
478 /* ASCII filtering */
479 len = strlen(bp);
480 for (i = 0; i < len; i++)
481 if (bp[i] < 32 || bp[i] == 127)
482 bp[i] = '.';
483
484 return bp;
485 }
486
487 int checksum(uint8_t * buf, int len)
488 {
489 uint8_t sum = 0;
490 int a;
491
492 for (a = 0; a < len; a++)
493 sum += buf[a];
494 return (sum == 0);
495 }
496
497 static int smbios_decode(s_dmi * dmi, uint8_t * buf)
498 {
499
500 dmi->dmitable.ver = (buf[0x06] << 8) + buf[0x07];
501 /* Some BIOS report weird SMBIOS version, fix that up */
502 switch (dmi->dmitable.ver) {
503 case 0x021F:
504 dmi->dmitable.ver = 0x0203;
505 break;
506 case 0x0233:
507 dmi->dmitable.ver = 0x0206;
508 break;
509 }
510 dmi->dmitable.major_version = dmi->dmitable.ver >> 8;
511 dmi->dmitable.minor_version = dmi->dmitable.ver & 0xFF;
512
513 return DMI_TABLE_PRESENT;
514 }
515
516 static int legacy_decode(s_dmi * dmi, uint8_t * buf)
517 {
518 dmi->dmitable.num = buf[13] << 8 | buf[12];
519 dmi->dmitable.len = buf[7] << 8 | buf[6];
520 dmi->dmitable.base = buf[11] << 24 | buf[10] << 16 | buf[9] << 8 | buf[8];
521
522 /* Version already found? */
523 if (dmi->dmitable.ver > 0)
524 return DMI_TABLE_PRESENT;
525
526 dmi->dmitable.ver = (buf[0x06] << 8) + buf[0x07];
527
528 /*
529 * DMI version 0.0 means that the real version is taken from
530 * the SMBIOS version, which we don't know at this point.
531 */
532 if (buf[14] != 0) {
533 dmi->dmitable.major_version = buf[14] >> 4;
534 dmi->dmitable.minor_version = buf[14] & 0x0F;
535 } else {
536 dmi->dmitable.major_version = 0;
537 dmi->dmitable.minor_version = 0;
538 }
539 return DMI_TABLE_PRESENT;
540 }
541
542 int dmi_iterate(s_dmi * dmi)
543 {
544 uint8_t *p, *q;
545 int found = 0;
546
547 /* Cleaning structures */
548 memset(dmi, 0, sizeof(s_dmi));
549
550 memset(&dmi->base_board, 0, sizeof(s_base_board));
551 memset(&dmi->battery, 0, sizeof(s_battery));
552 memset(&dmi->bios, 0, sizeof(s_bios));
553 memset(&dmi->chassis, 0, sizeof(s_chassis));
554 for (int i = 0; i < MAX_DMI_MEMORY_ITEMS; i++)
555 memset(&dmi->memory[i], 0, sizeof(s_memory));
556 memset(&dmi->processor, 0, sizeof(s_processor));
557 memset(&dmi->system, 0, sizeof(s_system));
558
559 /* Until we found this elements in the dmitable, we consider them as not filled */
560 dmi->base_board.filled = false;
561 dmi->battery.filled = false;
562 dmi->bios.filled = false;
563 dmi->chassis.filled = false;
564 for (int i = 0; i < MAX_DMI_MEMORY_ITEMS; i++)
565 dmi->memory[i].filled = false;
566 dmi->processor.filled = false;
567 dmi->system.filled = false;
568
569 p = (uint8_t *) 0xF0000; /* The start address to look at the dmi table */
570 /* The anchor-string is 16-bytes aligned */
571 for (q = p; q < p + 0x10000; q += 16) {
572 /* To validate the presence of SMBIOS:
573 * + the overall checksum must be correct
574 * + the intermediate anchor-string must be _DMI_
575 * + the intermediate checksum must be correct
576 */
577 if (memcmp(q, "_SM_", 4) == 0 &&
578 checksum(q, q[0x05]) &&
579 memcmp(q + 0x10, "_DMI_", 5) == 0 && checksum(q + 0x10, 0x0F)) {
580 /* Do not return, legacy_decode will need to be called
581 * on the intermediate structure to get the table length
582 * and address
583 */
584 smbios_decode(dmi, q);
585 } else if (memcmp(q, "_DMI_", 5) == 0 && checksum(q, 0x0F)) {
586 found = 1;
587 legacy_decode(dmi, q);
588 }
589 }
590
591 if (found)
592 return DMI_TABLE_PRESENT;
593
594 dmi->dmitable.base = 0;
595 dmi->dmitable.num = 0;
596 dmi->dmitable.ver = 0;
597 dmi->dmitable.len = 0;
598 return -ENODMITABLE;
599 }
600
601 void dmi_decode(struct dmi_header *h, uint16_t ver, s_dmi * dmi)
602 {
603 uint8_t *data = h->data;
604
605 /*
606 * Note: DMI types 37, 38 and 39 are untested
607 */
608 switch (h->type) {
609 case 0: /* 3.3.1 BIOS Information */
610 if (h->length < 0x12)
611 break;
612 dmi->bios.filled = true;
613 strlcpy(dmi->bios.vendor, dmi_string(h, data[0x04]),
614 sizeof(dmi->bios.vendor));
615 strlcpy(dmi->bios.version, dmi_string(h, data[0x05]),
616 sizeof(dmi->bios.version));
617 strlcpy(dmi->bios.release_date, dmi_string(h, data[0x08]),
618 sizeof(dmi->bios.release_date));
619 dmi->bios.address = WORD(data + 0x06);
620 dmi_bios_runtime_size((0x10000 - WORD(data + 0x06)) << 4, dmi);
621 dmi->bios.rom_size = (data[0x09] + 1) << 6;
622 strlcpy(dmi->bios.rom_size_unit, "kB", sizeof(dmi->bios.rom_size_unit));
623 dmi_bios_characteristics(QWORD(data + 0x0A), dmi);
624
625 if (h->length < 0x13)
626 break;
627 dmi_bios_characteristics_x1(data[0x12], dmi);
628 if (h->length < 0x14)
629 break;
630 dmi_bios_characteristics_x2(data[0x13], dmi);
631 if (h->length < 0x18)
632 break;
633 if (data[0x14] != 0xFF && data[0x15] != 0xFF)
634 snprintf(dmi->bios.bios_revision, sizeof(dmi->bios.bios_revision),
635 "%u.%u", data[0x14], data[0x15]);
636 if (data[0x16] != 0xFF && data[0x17] != 0xFF)
637 snprintf(dmi->bios.firmware_revision,
638 sizeof(dmi->bios.firmware_revision), "%u.%u", data[0x16],
639 data[0x17]);
640 break;
641 case 1: /* 3.3.2 System Information */
642 if (h->length < 0x08)
643 break;
644 dmi->system.filled = true;
645 strlcpy(dmi->system.manufacturer, dmi_string(h, data[0x04]),
646 sizeof(dmi->system.manufacturer));
647 strlcpy(dmi->system.product_name, dmi_string(h, data[0x05]),
648 sizeof(dmi->system.product_name));
649 strlcpy(dmi->system.version, dmi_string(h, data[0x06]),
650 sizeof(dmi->system.version));
651 strlcpy(dmi->system.serial, dmi_string(h, data[0x07]),
652 sizeof(dmi->system.serial));
653 if (h->length < 0x19)
654 break;
655 dmi_system_uuid(data + 0x08, dmi);
656 dmi_system_wake_up_type(data[0x18], dmi);
657 if (h->length < 0x1B)
658 break;
659 strlcpy(dmi->system.sku_number, dmi_string(h, data[0x19]),
660 sizeof(dmi->system.sku_number));
661 strlcpy(dmi->system.family, dmi_string(h, data[0x1A]),
662 sizeof(dmi->system.family));
663 break;
664
665 case 2: /* 3.3.3 Base Board Information */
666 if (h->length < 0x08)
667 break;
668 dmi->base_board.filled = true;
669 strlcpy(dmi->base_board.manufacturer, dmi_string(h, data[0x04]),
670 sizeof(dmi->base_board.manufacturer));
671 strlcpy(dmi->base_board.product_name, dmi_string(h, data[0x05]),
672 sizeof(dmi->base_board.product_name));
673 strlcpy(dmi->base_board.version, dmi_string(h, data[0x06]),
674 sizeof(dmi->base_board.version));
675 strlcpy(dmi->base_board.serial, dmi_string(h, data[0x07]),
676 sizeof(dmi->base_board.serial));
677 if (h->length < 0x0F)
678 break;
679 strlcpy(dmi->base_board.asset_tag, dmi_string(h, data[0x08]),
680 sizeof(dmi->base_board.asset_tag));
681 dmi_base_board_features(data[0x09], dmi);
682 strlcpy(dmi->base_board.location, dmi_string(h, data[0x0A]),
683 sizeof(dmi->base_board.location));
684 dmi_base_board_type(data[0x0D], dmi);
685 if (h->length < 0x0F + data[0x0E] * sizeof(uint16_t))
686 break;
687 break;
688 case 3: /* 3.3.4 Chassis Information */
689 if (h->length < 0x09)
690 break;
691 dmi->chassis.filled = true;
692 strlcpy(dmi->chassis.manufacturer, dmi_string(h, data[0x04]),
693 sizeof(dmi->chassis.manufacturer));
694 strlcpy(dmi->chassis.type, dmi_chassis_type(data[0x05] & 0x7F),
695 sizeof(dmi->chassis.type));
696 strlcpy(dmi->chassis.lock, dmi_chassis_lock(data[0x05] >> 7),
697 sizeof(dmi->chassis.lock));
698 strlcpy(dmi->chassis.version, dmi_string(h, data[0x06]),
699 sizeof(dmi->chassis.version));
700 strlcpy(dmi->chassis.serial, dmi_string(h, data[0x07]),
701 sizeof(dmi->chassis.serial));
702 strlcpy(dmi->chassis.asset_tag, dmi_string(h, data[0x08]),
703 sizeof(dmi->chassis.asset_tag));
704 if (h->length < 0x0D)
705 break;
706 strlcpy(dmi->chassis.boot_up_state, dmi_chassis_state(data[0x09]),
707 sizeof(dmi->chassis.boot_up_state));
708 strlcpy(dmi->chassis.power_supply_state,
709 dmi_chassis_state(data[0x0A]),
710 sizeof(dmi->chassis.power_supply_state));
711 strlcpy(dmi->chassis.thermal_state,
712 dmi_chassis_state(data[0x0B]),
713 sizeof(dmi->chassis.thermal_state));
714 strlcpy(dmi->chassis.security_status,
715 dmi_chassis_security_status(data[0x0C]),
716 sizeof(dmi->chassis.security_status));
717 if (h->length < 0x11)
718 break;
719 snprintf(dmi->chassis.oem_information,
720 sizeof(dmi->chassis.oem_information), "0x%08X",
721 DWORD(data + 0x0D));
722 if (h->length < 0x15)
723 break;
724 dmi->chassis.height = data[0x11];
725 dmi->chassis.nb_power_cords = data[0x12];
726 break;
727 case 4: /* 3.3.5 Processor Information */
728 if (h->length < 0x1A)
729 break;
730 dmi->processor.filled = true;
731 strlcpy(dmi->processor.socket_designation,
732 dmi_string(h, data[0x04]),
733 sizeof(dmi->processor.socket_designation));
734 strlcpy(dmi->processor.type,
735 dmi_processor_type(data[0x05]), sizeof(dmi->processor.type));
736 strlcpy(dmi->processor.manufacturer,
737 dmi_string(h, data[0x07]), sizeof(dmi->processor.manufacturer));
738 strlcpy(dmi->processor.family,
739 dmi_processor_family(data[0x06],
740 dmi->processor.manufacturer),
741 sizeof(dmi->processor.family));
742 dmi_processor_id(data[0x06], data + 8, dmi_string(h, data[0x10]), dmi);
743 strlcpy(dmi->processor.version,
744 dmi_string(h, data[0x10]), sizeof(dmi->processor.version));
745 dmi_processor_voltage(data[0x11], dmi);
746 dmi->processor.external_clock = WORD(data + 0x12);
747 dmi->processor.max_speed = WORD(data + 0x14);
748 dmi->processor.current_speed = WORD(data + 0x16);
749 if (data[0x18] & (1 << 6))
750 strlcpy(dmi->processor.status,
751 dmi_processor_status(data[0x18] & 0x07),
752 sizeof(dmi->processor.status));
753 else
754 sprintf(dmi->processor.status, "Unpopulated");
755 strlcpy(dmi->processor.upgrade,
756 dmi_processor_upgrade(data[0x19]),
757 sizeof(dmi->processor.upgrade));
758 if (h->length < 0x20)
759 break;
760 dmi_processor_cache(WORD(data + 0x1A), "L1", ver,
761 dmi->processor.cache1);
762 dmi_processor_cache(WORD(data + 0x1C), "L2", ver,
763 dmi->processor.cache2);
764 dmi_processor_cache(WORD(data + 0x1E), "L3", ver,
765 dmi->processor.cache3);
766 if (h->length < 0x23)
767 break;
768 strlcpy(dmi->processor.serial, dmi_string(h, data[0x20]),
769 sizeof(dmi->processor.serial));
770 strlcpy(dmi->processor.asset_tag, dmi_string(h, data[0x21]),
771 sizeof(dmi->processor.asset_tag));
772 strlcpy(dmi->processor.part_number, dmi_string(h, data[0x22]),
773 sizeof(dmi->processor.part_number));
774 dmi->processor.core_count = 0;
775 dmi->processor.core_enabled = 0;
776 dmi->processor.thread_count = 0;
777 if (h->length < 0x28)
778 break;
779 dmi->processor.core_count = data[0x23];
780 dmi->processor.core_enabled = data[0x24];
781 dmi->processor.thread_count = data[0x25];
782 break;
783 case 6: /* 3.3.7 Memory Module Information */
784 if (h->length < 0x0C)
785 break;
786 dmi->memory_module_count++;
787 s_memory_module *module =
788 &dmi->memory_module[dmi->memory_module_count - 1];
789 dmi->memory_module[dmi->memory_module_count - 1].filled = true;
790 strlcpy(module->socket_designation, dmi_string(h, data[0x04]),
791 sizeof(module->socket_designation));
792 dmi_memory_module_connections(data[0x05], module->bank_connections, sizeof(module->bank_connections));
793 dmi_memory_module_speed(data[0x06], module->speed);
794 dmi_memory_module_types(WORD(data + 0x07), " ", module->type, sizeof(module->type));
795 dmi_memory_module_size(data[0x09], module->installed_size, sizeof(module->installed_size));
796 dmi_memory_module_size(data[0x0A], module->enabled_size, sizeof(module->enabled_size));
797 dmi_memory_module_error(data[0x0B], "\t\t", module->error_status);
798 break;
799 case 7: /* 3.3.8 Cache Information */
800 if (h->length < 0x0F)
801 break;
802 dmi->cache_count++;
803 if (dmi->cache_count > MAX_DMI_CACHE_ITEMS)
804 break;
805 strlcpy(dmi->cache[dmi->cache_count - 1].socket_designation,
806 dmi_string(h, data[0x04]),
807 sizeof(dmi->cache[dmi->cache_count - 1].socket_designation));
808 snprintf(dmi->cache[dmi->cache_count - 1].configuration,
809 sizeof(dmi->cache[dmi->cache_count - 1].configuration),
810 "%s, %s, %u",
811 WORD(data + 0x05) & 0x0080 ? "Enabled" : "Disabled",
812 WORD(data +
813 0x05) & 0x0008 ? "Socketed" : "Not Socketed",
814 (WORD(data + 0x05) & 0x0007) + 1);
815 strlcpy(dmi->cache[dmi->cache_count - 1].mode,
816 dmi_cache_mode((WORD(data + 0x05) >> 8) & 0x0003),
817 sizeof(dmi->cache[dmi->cache_count - 1].mode));
818 strlcpy(dmi->cache[dmi->cache_count - 1].location,
819 dmi_cache_location((WORD(data + 0x05) >> 5) & 0x0003),
820 sizeof(dmi->cache[dmi->cache_count - 1].location));
821 dmi->cache[dmi->cache_count - 1].installed_size =
822 dmi_cache_size(WORD(data + 0x09));
823 dmi->cache[dmi->cache_count - 1].max_size =
824 dmi_cache_size(WORD(data + 0x07));
825 dmi_cache_types(WORD(data + 0x0B), " ",
826 dmi->cache[dmi->cache_count - 1].supported_sram_types);
827 dmi_cache_types(WORD(data + 0x0D), " ",
828 dmi->cache[dmi->cache_count - 1].installed_sram_types);
829 if (h->length < 0x13)
830 break;
831 dmi->cache[dmi->cache_count - 1].speed = data[0x0F]; /* ns */
832 strlcpy(dmi->cache[dmi->cache_count - 1].error_correction_type,
833 dmi_cache_ec_type(data[0x10]),
834 sizeof(dmi->cache[dmi->cache_count - 1].error_correction_type));
835 strlcpy(dmi->cache[dmi->cache_count - 1].system_type,
836 dmi_cache_type(data[0x11]),
837 sizeof(dmi->cache[dmi->cache_count - 1].system_type));
838 strlcpy(dmi->cache[dmi->cache_count - 1].associativity,
839 dmi_cache_associativity(data[0x12]),
840 sizeof(dmi->cache[dmi->cache_count - 1].associativity));
841 break;
842 case 10: /* 3.3.11 On Board Devices Information */
843 dmi_on_board_devices(h, dmi);
844 break;
845 case 11: /* 3.3.12 OEM Strings */
846 if (h->length < 0x05)
847 break;
848 dmi_oem_strings(h, "\t", dmi);
849 break;
850 case 12: /* 3.3.13 System Configuration Options */
851 if (h->length < 0x05)
852 break;
853 dmi_system_configuration_options(h, "\t", dmi);
854 break;
855 case 17: /* 3.3.18 Memory Device */
856 if (h->length < 0x15)
857 break;
858 dmi->memory_count++;
859 if (dmi->memory_count > MAX_DMI_MEMORY_ITEMS)
860 break;
861 s_memory *mem = &dmi->memory[dmi->memory_count - 1];
862 dmi->memory[dmi->memory_count - 1].filled = true;
863 dmi_memory_array_error_handle(WORD(data + 0x06), mem->error);
864 dmi_memory_device_width(WORD(data + 0x08), mem->total_width);
865 dmi_memory_device_width(WORD(data + 0x0A), mem->data_width);
866 dmi_memory_device_size(WORD(data + 0x0C), mem->size);
867 strlcpy(mem->form_factor,
868 dmi_memory_device_form_factor(data[0x0E]),
869 sizeof(mem->form_factor));
870 dmi_memory_device_set(data[0x0F], mem->device_set);
871 strlcpy(mem->device_locator, dmi_string(h, data[0x10]),
872 sizeof(mem->device_locator));
873 strlcpy(mem->bank_locator, dmi_string(h, data[0x11]),
874 sizeof(mem->bank_locator));
875 strlcpy(mem->type, dmi_memory_device_type(data[0x12]),
876 sizeof(mem->type));
877 dmi_memory_device_type_detail(WORD(data + 0x13), mem->type_detail, sizeof(mem->type_detail));
878 if (h->length < 0x17)
879 break;
880 dmi_memory_device_speed(WORD(data + 0x15), mem->speed);
881 if (h->length < 0x1B)
882 break;
883 strlcpy(mem->manufacturer, dmi_string(h, data[0x17]),
884 sizeof(mem->manufacturer));
885 strlcpy(mem->serial, dmi_string(h, data[0x18]), sizeof(mem->serial));
886 strlcpy(mem->asset_tag, dmi_string(h, data[0x19]),
887 sizeof(mem->asset_tag));
888 strlcpy(mem->part_number, dmi_string(h, data[0x1A]),
889 sizeof(mem->part_number));
890 break;
891 case 22: /* 3.3.23 Portable Battery */
892 if (h->length < 0x10)
893 break;
894 dmi->battery.filled = true;
895 strlcpy(dmi->battery.location, dmi_string(h, data[0x04]),
896 sizeof(dmi->battery.location));
897 strlcpy(dmi->battery.manufacturer, dmi_string(h, data[0x05]),
898 sizeof(dmi->battery.manufacturer));
899 if (data[0x06] || h->length < 0x1A)
900 strlcpy(dmi->battery.manufacture_date,
901 dmi_string(h, data[0x06]),
902 sizeof(dmi->battery.manufacture_date));
903 if (data[0x07] || h->length < 0x1A)
904 strlcpy(dmi->battery.serial, dmi_string(h, data[0x07]),
905 sizeof(dmi->battery.serial));
906 strlcpy(dmi->battery.name, dmi_string(h, data[0x08]),
907 sizeof(dmi->battery.name));
908 if (data[0x09] != 0x02 || h->length < 0x1A)
909 strlcpy(dmi->battery.chemistry,
910 dmi_battery_chemistry(data[0x09]),
911 sizeof(dmi->battery.chemistry));
912 if (h->length < 0x1A)
913 dmi_battery_capacity(WORD(data + 0x0A), 1,
914 dmi->battery.design_capacity);
915 else
916 dmi_battery_capacity(WORD(data + 0x0A), data[0x15],
917 dmi->battery.design_capacity);
918 dmi_battery_voltage(WORD(data + 0x0C), dmi->battery.design_voltage);
919 strlcpy(dmi->battery.sbds, dmi_string(h, data[0x0E]),
920 sizeof(dmi->battery.sbds));
921 dmi_battery_maximum_error(data[0x0F], dmi->battery.maximum_error);
922 if (h->length < 0x1A)
923 break;
924 if (data[0x07] == 0)
925 sprintf(dmi->battery.sbds_serial, "%04X", WORD(data + 0x10));
926 if (data[0x06] == 0)
927 sprintf(dmi->battery.sbds_manufacture_date, "%u-%02u-%02u",
928 1980 + (WORD(data + 0x12) >> 9),
929 (WORD(data + 0x12) >> 5) & 0x0F, WORD(data + 0x12) & 0x1F);
930 if (data[0x09] == 0x02)
931 strlcpy(dmi->battery.sbds_chemistry, dmi_string(h, data[0x14]),
932 sizeof(dmi->battery.sbds_chemistry));
933 // sprintf(dmi->battery.oem_info,"0x%08X",DWORD(h, data+0x16));
934 break;
935 case 23: /* 3.3.24 System Reset */
936 if (h->length < 0x0D)
937 break;
938 dmi->system.system_reset.filled = true;
939 dmi->system.system_reset.status = data[0x04] & (1 << 0);
940 dmi->system.system_reset.watchdog = data[0x04] & (1 << 5);
941 if (!(data[0x04] & (1 << 5)))
942 break;
943 strlcpy(dmi->system.system_reset.boot_option,
944 dmi_system_reset_boot_option((data[0x04] >> 1) & 0x3),
945 sizeof dmi->system.system_reset.boot_option);
946 strlcpy(dmi->system.system_reset.boot_option_on_limit,
947 dmi_system_reset_boot_option((data[0x04] >> 3) & 0x3),
948 sizeof dmi->system.system_reset.boot_option_on_limit);
949 dmi_system_reset_count(WORD(data + 0x05),
950 dmi->system.system_reset.reset_count);
951 dmi_system_reset_count(WORD(data + 0x07),
952 dmi->system.system_reset.reset_limit);
953 dmi_system_reset_timer(WORD(data + 0x09),
954 dmi->system.system_reset.timer_interval);
955 dmi_system_reset_timer(WORD(data + 0x0B),
956 dmi->system.system_reset.timeout);
957 break;
958 case 24: /* 3.3.25 Hardware Security */
959 if (h->length < 0x05)
960 break;
961 dmi->hardware_security.filled = true;
962 strlcpy(dmi->hardware_security.power_on_passwd_status,
963 dmi_hardware_security_status(data[0x04] >> 6),
964 sizeof dmi->hardware_security.power_on_passwd_status);
965 strlcpy(dmi->hardware_security.keyboard_passwd_status,
966 dmi_hardware_security_status((data[0x04] >> 4) & 0x3),
967 sizeof dmi->hardware_security.keyboard_passwd_status);
968 strlcpy(dmi->hardware_security.administrator_passwd_status,
969 dmi_hardware_security_status((data[0x04] >> 2) & 0x3),
970 sizeof dmi->hardware_security.administrator_passwd_status);
971 strlcpy(dmi->hardware_security.front_panel_reset_status,
972 dmi_hardware_security_status(data[0x04] & 0x3),
973 sizeof dmi->hardware_security.front_panel_reset_status);
974 break;
975 case 32: /* 3.3.33 System Boot Information */
976 if (h->length < 0x0B)
977 break;
978 dmi_system_boot_status(data[0x0A], dmi->system.system_boot_status);
979 case 38: /* 3.3.39 IPMI Device Information */
980 if (h->length < 0x10)
981 break;
982 dmi->ipmi.filled = true;
983 snprintf(dmi->ipmi.interface_type,
984 sizeof(dmi->ipmi.interface_type), "%s",
985 dmi_ipmi_interface_type(data[0x04]));
986 dmi->ipmi.major_specification_version = data[0x05] >> 4;
987 dmi->ipmi.minor_specification_version = data[0x05] & 0x0F;
988 dmi->ipmi.I2C_slave_address = data[0x06] >> 1;
989 if (data[0x07] != 0xFF)
990 dmi->ipmi.nv_address = data[0x07];
991 else
992 dmi->ipmi.nv_address = 0; /* Not Present */
993 dmi_ipmi_base_address(data[0x04], data + 0x08, &dmi->ipmi);
994 if (h->length < 0x12)
995 break;
996 if (data[0x11] != 0x00) {
997 dmi->ipmi.irq = data[0x11];
998 }
999 break;
1000 }
1001 }
1002
1003 void parse_dmitable(s_dmi * dmi)
1004 {
1005 int i = 0;
1006 uint8_t *data = NULL;
1007 uint8_t buf[dmi->dmitable.len];
1008 memcpy(buf, (int *)dmi->dmitable.base, sizeof(uint8_t) * dmi->dmitable.len);
1009 data = buf;
1010 dmi->memory_count = 0;
1011 while (i < dmi->dmitable.num && data + 4 <= buf + dmi->dmitable.len) { /* 4 is the length of an SMBIOS structure header */
1012 uint8_t *next;
1013 struct dmi_header h;
1014 to_dmi_header(&h, data);
1015 /*
1016 * If a short entry is found (less than 4 bytes), not only it
1017 * is invalid, but we cannot reliably locate the next entry.
1018 * Better stop at this point, and let the user know his/her
1019 * table is broken.
1020 */
1021 if (h.length < 4) {
1022 printf
1023 ("Invalid entry length (%u). DMI table is broken! Stop.\n\n",
1024 (unsigned int)h.length);
1025 break;
1026 }
1027
1028 /* loo for the next handle */
1029 next = data + h.length;
1030 while (next - buf + 1 < dmi->dmitable.len
1031 && (next[0] != 0 || next[1] != 0))
1032 next++;
1033 next += 2;
1034 if (next - buf <= dmi->dmitable.len) {
1035 dmi_decode(&h, dmi->dmitable.ver, dmi);
1036 }
1037 data = next;
1038 i++;
1039 }
1040 }