Chameleon

Chameleon Svn Source Tree

Root/trunk/i386/libsaio/smbios_decode.c

1/*
2 * A very simple SMBIOS Table decoder, part of the Chameleon Boot Loader Project
3 *
4 * Copyright 2010 by Islam M. Ahmed Zaid. All rights reserved.
5 *
6 */
7
8#include "libsaio.h"
9#include "smbios.h"
10// Bungo:
11#include "boot.h"
12#include "bootstruct.h"
13
14#ifndef DEBUG_SMBIOS
15#define DEBUG_SMBIOS 0
16#endif
17
18#if DEBUG_SMBIOS
19#define DBG(x...)printf(x)
20#else
21#define DBG(x...)msglog(x)
22#endif
23
24extern char *getSMBStringForField(SMBStructHeader *structHeader, uint8_t field);
25// Bungo:
26#define NotSpecifiedStr "Not Specified" // no string
27#define OutOfSpecStr "<OUT OF SPEC>" // value out of smbios spec. range
28#define PrivateStr "** PRIVATE **" // masking private data
29#define neverMask false
30
31static bool privateData = true;
32static SMBByte minorVersion; // SMBIOS rev. minor
33static SMBByte majorVersion; // SMBIOS rev. major
34static SMBByte bcdRevisionLo; // DMI rev. minor
35static SMBByte bcdRevisionHi; // DMI rev. major
36
37/*====
38 7.2.2
39 ===*/
40static const char *SMBWakeUpTypes[] = // Bungo: strings for wake-up type (Table Type 1 - System Information)
41{
42"Reserved", /* 00h */
43"Other", /* 01h */
44"Unknown", /* 02h */
45"APM Timer", /* 03h */
46"Modem Ring", /* 04h */
47"LAN Remote", /* 05h */
48"Power Switch", /* 06h */
49"PCI PME#", /* 07h */
50"AC Power Restored" /* 08h */
51};
52
53/*====
54 7.3.2
55 ===*/
56static const char *SMBBaseBoardTypes[] = // Bungo: strings for base board type (Table Type 2 - Base Board Information)
57{
58"Unknown", /* 01h */
59"Other", /* 02h */
60"Server Blade", /* 03h */
61"Connectivity Switch", /* 04h */
62"System Management Module", /* 05h */
63"Processor Module", /* 06h */
64"I/O Module", /* 07h */
65"Memory Module", /* 08h */
66"Daughter Board", /* 09h */
67"Motherboard", /* 0Ah */
68"Processor+Memory Module", /* 0Bh */
69"Processor+I/O Module", /* 0Ch */
70"Interconnect Board" /* 0Dh */
71};
72
73 /*===
74 7.4.1
75 ===*/
76static const char *SMBChassisTypes[] = // Bungo: strings for chassis type (Table Type 3 - Chassis Information)
77{
78"Other", /* 01h */
79"Unknown", /* 02h */
80"Desktop", /* 03h */
81"Low Profile Desktop", /* 04h */
82"Pizza Box", /* 05h */
83"Mini Tower", /* 06h */
84"Tower", /* 07h */
85"Portable", /* 08h */
86"Laptop", /* 09h */
87"Notebook", /* 0Ah */
88"Hand Held", /* 0Bh */
89"Docking Station", /* 0Ch */
90"All in One", /* 0Dh */
91"Sub Notebook", /* 0Eh */
92"Space-saving", /* 0Fh */
93"Lunch Box",/* 10h */
94"Main Server Chassis",/* 11h */
95"Expansion Chassis",/* 12h */
96"SubChassis",/* 13h */
97"Bus Expansion Chassis",/* 14h */
98"Peripheral Chassis",/* 15h */
99"RAID Chassis",/* 16h */
100"Rack Mount Chassis", /* 17h */
101"Sealed-case PC",/* 18h */
102"Multi-system Chassis", /* 19h */
103"Compact PCI",/* 1Ah */
104"Advanced TCA",/* 1Bh */
105"Blade",/* 1Ch */ // An SMBIOS implementation for a Blade would contain a Type 3 Chassis structure
106"Blade Enclosing"/* 1Dh */ // A Blade Enclosure is a specialized chassis that contains a set of Blades.
107};
108
109/*====
110 7.5.1
111 ===*/
112static const char *SMBProcessorTypes[] = // Bungo: strings for processor type (Table Type 4 - Processor Information)
113{
114"Other", /* 01h */
115"Unknown", /* 02h */
116"Central Processor", /* 03h */
117"Math Processor", /* 04h */
118"DSP Processor", /* 05h */
119"Video Processor" /* 06h */
120};
121
122/*====
123 7.5.5
124 ===*/
125static const char *SMBProcessorUpgrades[] = // ErmaC: strings for processor upgrade (Table Type 4 - Processor Information)
126{
127"Other", /* 01h */
128"Unknown", /* 02h */
129"Daughter Board",
130"ZIF Socket",
131"Replaceable Piggy Back",
132"None",
133"LIF Socket",
134"Slot 1",
135"Slot 2",
136"370-pin Socket",
137"Slot A",
138"Slot M",
139"Socket 423",
140"Socket A (Socket 462)",
141"Socket 478",
142"Socket 754",
143"Socket 940",
144"Socket 939",
145"Socket mPGA604",
146"Socket LGA771",
147"Socket LGA775",
148"Socket S1",
149"Socket AM2",
150"Socket F (1207)",
151"Socket LGA1366",
152"Socket G34",
153"Socket AM3",
154"Socket C32",
155"Socket LGA1156",
156"Socket LGA1567",
157"Socket PGA988A",
158"Socket BGA1288",
159"Socket rPGA988B",
160"Socket BGA1023",
161"Socket BGA1224",
162"Socket BGA1155",
163"Socket LGA1356",
164"Socket LGA2011",
165"Socket FS1",
166"Socket FS2",
167"Socket FM1",
168"Socket FM2",
169"Socket LGA2011-3",
170"Socket LGA1356-3" /* 2Ch */
171};
172
173static const char *SMBMemoryDeviceFormFactors[] = // Bungo: strings for form factor (Table Type 17 - Memory Device)
174{
175"Other", /* 01h */
176"Unknown", /* 02h */
177"SIMM", /* 03h */
178"SIP", /* 04h */
179"Chip", /* 05h */
180"DIP", /* 06h */
181"ZIP", /* 07h */
182"Proprietary Card", /* 08h */
183"DIMM", /* 09h */
184"TSOP", /* 0Ah */
185"Row of chips", /* 0Bh */
186"RIMM", /* 0Ch */
187"SODIMM", /* 0Dh */
188"SRIMM", /* 0Eh */
189"FB-DIMM" /* 0Fh */
190};
191
192/*=====
193 7.18.2
194 ====*/
195static const char *
196SMBMemoryDeviceTypes[] =
197{
198"RAM", /* 00h Undefined */
199"RAM", /* 01h Other */
200"RAM", /* 02h Unknown */
201"DRAM", /* 03h DRAM */
202"EDRAM", /* 04h EDRAM */
203"VRAM", /* 05h VRAM */
204"SRAM", /* 06h SRAM */
205"RAM", /* 07h RAM */
206"ROM", /* 08h ROM */
207"FLASH", /* 09h FLASH */
208"EEPROM", /* 0Ah EEPROM */
209"FEPROM", /* 0Bh FEPROM */
210"EPROM", /* 0Ch EPROM */
211"CDRAM", /* 0Dh CDRAM */
212"3DRAM", /* 0Eh 3DRAM */
213"SDRAM", /* 0Fh SDRAM */
214"SGRAM", /* 10h SGRAM */
215"RDRAM", /* 11h RDRAM */
216"DDR SDRAM", /* 12h DDR */
217"DDR2 SDRAM", /* 13h DDR2 */
218"DDR2 FB-DIMM", /* 14h DDR2 FB-DIMM */
219"RAM",/* 15h unused */
220"RAM",/* 16h unused */
221"RAM",/* 17h unused */
222"DDR3",/* 18h DDR3, chosen in [5776134] */
223"FBD2"/* 19h FBD2 */
224};
225
226static const int kSMBMemoryDeviceTypeCount = sizeof(SMBMemoryDeviceTypes) /
227 sizeof(SMBMemoryDeviceTypes[0]);
228
229// Bungo: fixes random string readout if null in smbios to "Not Specified" as dmidecode displays
230char *SMBStringForField(SMBStructHeader *structHeader, uint8_t field, const bool mask)
231{
232char *str = NULL;
233str = getSMBStringForField(structHeader, field);
234if (!field) {
235str = NotSpecifiedStr;
236}
237else if (mask) {
238str = PrivateStr;
239}
240
241return str;
242};
243
244void printHeader(SMBStructHeader *structHeader)
245{
246DBG("Handle: 0x%04x, DMI type %d, %d bytes\n", structHeader->handle, structHeader->type, structHeader->length);
247}
248
249//-------------------------------------------------------------------------------------------------------------------------
250// BIOS Information (Type 0)
251//-------------------------------------------------------------------------------------------------------------------------
252void decodeBIOSInformation(SMBStructHeader *structHeader)
253{
254printHeader(structHeader);
255DBG("BIOS Information\n");
256DBG("\tVendor: %s\n", SMBStringForField(structHeader, ((SMBBIOSInformation *)structHeader)->vendor, neverMask));
257DBG("\tVersion: %s\n", SMBStringForField(structHeader, ((SMBBIOSInformation *)structHeader)->version, neverMask));
258DBG("\tRelease Date: %s\n", SMBStringForField(structHeader, ((SMBBIOSInformation *)structHeader)->releaseDate, neverMask));
259// Address:
260// Runtime Size:
261// ROM Size:
262// DBG("\tSupported BIOS functions: (0x%llX) %s\n", ((SMBBIOSInformation *)structHeader)->characteristics, SMBBIOSInfoChar0[((SMBBIOSInformation *)structHeader)->characteristics]);
263DBG("\tBIOS Revision: %d.%d\n", ((SMBBIOSInformation *)structHeader)->releaseMajor, ((SMBBIOSInformation *)structHeader)->releaseMinor);
264// Firmware Major Release
265// Firmware Minor Release
266// SMBByte characteristicsExt1;
267// SMBByte characteristicsExt2;
268DBG("\n");
269}
270
271//-------------------------------------------------------------------------------------------------------------------------
272// System Information (Type 1)
273//-------------------------------------------------------------------------------------------------------------------------
274void decodeSystemInformation(SMBStructHeader *structHeader)
275{
276printHeader(structHeader);
277DBG("System Information\n");
278DBG("\tManufacturer: %s\n", SMBStringForField(structHeader, ((SMBSystemInformation *)structHeader)->manufacturer, neverMask));
279DBG("\tProduct Name: %s\n", SMBStringForField(structHeader, ((SMBSystemInformation *)structHeader)->productName, neverMask));
280DBG("\tVersion: %s\n", SMBStringForField(structHeader, ((SMBSystemInformation *)structHeader)->version, neverMask));
281DBG("\tSerial Number: %s\n", SMBStringForField(structHeader, ((SMBSystemInformation *)structHeader)->serialNumber, privateData));
282uint8_t *uuid = ((SMBSystemInformation *)structHeader)->uuid;
283if (privateData) {
284DBG("\tUUID: %s\n", PrivateStr);
285} else {
286DBG("\tUUID: %02X%02X%02X%02X-%02X%02X-%02X%02X-%02x%02X-%02X%02X%02X%02X%02X%02X\n",
287uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5], uuid[6], uuid[7],
288uuid[8], uuid[9], uuid[10], uuid[11], uuid[12], uuid[13], uuid[14], uuid[15]);
289}
290if (((SMBSystemInformation *)structHeader)->wakeupReason > 8) {
291DBG("\tWake-up Type: %s\n", OutOfSpecStr);
292} else {
293DBG("\tWake-up Type: %s\n", SMBWakeUpTypes[((SMBSystemInformation *)structHeader)->wakeupReason]);
294}
295DBG("\tSKU Number: %s\n", SMBStringForField(structHeader, ((SMBSystemInformation *)structHeader)->skuNumber, neverMask)); // System SKU#
296DBG("\tFamily: %s\n", SMBStringForField(structHeader, ((SMBSystemInformation *)structHeader)->family, neverMask));
297DBG("\n");
298}
299
300//-------------------------------------------------------------------------------------------------------------------------
301// Base Board (or Module) Information (Type 2)
302//-------------------------------------------------------------------------------------------------------------------------
303void decodeBaseBoard(SMBStructHeader *structHeader)
304{
305printHeader(structHeader);
306DBG("Base Board Information\n");
307DBG("\tManufacturer: %s\n", SMBStringForField(structHeader, ((SMBBaseBoard *)structHeader)->manufacturer, neverMask));
308DBG("\tProduct Name: %s\n", SMBStringForField(structHeader, ((SMBBaseBoard *)structHeader)->product, neverMask));
309DBG("\tVersion: %s\n", SMBStringForField(structHeader, ((SMBBaseBoard *)structHeader)->version, neverMask));
310DBG("\tSerial Number: %s\n", SMBStringForField(structHeader, ((SMBBaseBoard *)structHeader)->serialNumber, privateData));
311DBG("\tAsset Tag: %s\n", SMBStringForField(structHeader, ((SMBBaseBoard *)structHeader)->assetTag, neverMask));
312// Feature Flags (BYTE)
313DBG("\tLocation In Chassis: %s\n", SMBStringForField(structHeader, ((SMBBaseBoard *)structHeader)->locationInChassis, neverMask)); // Part Component
314// Chassis Handle (WORD)
315if ((((SMBBaseBoard *)structHeader)->boardType < kSMBBaseBoardUnknown) || (((SMBBaseBoard *)structHeader)->boardType > kSMBBaseBoardInterconnect)) {
316DBG("\tType: %s\n", OutOfSpecStr);
317} else {
318DBG("\tType: %s\n", SMBBaseBoardTypes[(((SMBBaseBoard *)structHeader)->boardType - 1)]);
319}
320// Number of Contained Object Handles (n) (BYTE)
321// Contained Object Handles n(WORDs)
322DBG("\n");
323}
324
325//-------------------------------------------------------------------------------------------------------------------------
326// System Enclosure or Chassis (Type 3)
327//-------------------------------------------------------------------------------------------------------------------------
328void decodeSystemEnclosure(SMBStructHeader *structHeader)
329{
330printHeader(structHeader);
331DBG("Chassis Information\n");
332DBG("\tManufacturer: %s\n", SMBStringForField(structHeader, ((SMBSystemEnclosure *)structHeader)->manufacturer, neverMask));
333if ((((SMBSystemEnclosure *)structHeader)->chassisType < kSMBchassisOther) || (((SMBSystemEnclosure *)structHeader)->chassisType > kSMBchassisBladeEnclosing)) {
334DBG("\tType: %s\n", OutOfSpecStr);
335} else {
336DBG("\tType: %s\n", SMBChassisTypes[(((SMBSystemEnclosure *)structHeader)->chassisType - 1)]);
337}
338// Lock:
339DBG("\tVersion: %s\n", SMBStringForField(structHeader, ((SMBSystemEnclosure *)structHeader)->version, neverMask));
340DBG("\tSerial Number: %s\n", SMBStringForField(structHeader, ((SMBSystemEnclosure *)structHeader)->serialNumber, privateData));
341DBG("\tAsset Tag: %s\n", SMBStringForField(structHeader, ((SMBSystemEnclosure *)structHeader)->assetTag, neverMask));
342// Boot-up State:
343// Power Supply State
344// Thermal State
345// Security Status:
346// OEM Information:
347// Height;
348// Number Of Power Cords: Cords;
349// Contained Elements: ElementsCount;
350// SKU Number:
351// ElementLen;
352// Elements[1]; // open array of ElementsCount*ElementLen BYTEs
353DBG("\n");
354}
355
356//-------------------------------------------------------------------------------------------------------------------------
357// Processor Information (Type 4)
358//-------------------------------------------------------------------------------------------------------------------------
359void decodeProcessorInformation(SMBStructHeader *structHeader)
360{
361printHeader(structHeader);
362DBG("Processor Information\n");
363DBG("\tSocket Designation: %s\n", SMBStringForField(structHeader, ((SMBProcessorInformation *)structHeader)->socketDesignation, neverMask));
364if ((((SMBProcessorInformation *)structHeader)->processorType < kSMBprocessorTypeOther) || (((SMBProcessorInformation *)structHeader)->processorType > kSMBprocessorTypeGPU)) {
365DBG("\tType: %s\n", OutOfSpecStr);
366} else {
367DBG("\tType: %s\n", SMBProcessorTypes[((SMBProcessorInformation *)structHeader)->processorType - 1]);
368}
369DBG("\tFamily: 0x%X\n", ((SMBProcessorInformation *)structHeader)->processorFamily);
370DBG("\tManufacturer: %s\n", SMBStringForField(structHeader, ((SMBProcessorInformation *)structHeader)->manufacturer, neverMask));
371DBG("\tID: 0x%llX\n", ((SMBProcessorInformation *)structHeader)->processorID);
372//DBG("\tSignature: Type %u, Family %u, Model %u, Stepping %u\n", (eax >> 12) & 0x3, ((eax >> 20) & 0xFF) + ((eax >> 8) & 0x0F), ((eax >> 12) & 0xF0) + ((eax >> 4) & 0x0F), eax & 0xF);
373// Flags:
374DBG("\tVersion: %s\n", SMBStringForField(structHeader, ((SMBProcessorInformation *)structHeader)->processorVersion, neverMask));
375//DBG("\tVoltage: 0.%xV\n", ((SMBProcessorInformation *)structHeader)->voltage);
376DBG("\tExternal Clock: %d MHz\n", ((SMBProcessorInformation *)structHeader)->externalClock);
377DBG("\tMax Speed: %d MHz\n", ((SMBProcessorInformation *)structHeader)->maximumClock);
378DBG("\tCurrent Speed: %d MHz\n", ((SMBProcessorInformation *)structHeader)->currentClock);
379// Status: Populated/Unpopulated
380if ((((SMBProcessorInformation *)structHeader)->processorUpgrade < 1) || (((SMBProcessorInformation *)structHeader)->processorUpgrade > 0x2C)) {
381DBG("\tUpgrade: %s\n", OutOfSpecStr);
382} else {
383DBG("\tUpgrade: %s\n", SMBProcessorUpgrades[((SMBProcessorInformation *)structHeader)->processorUpgrade - 1]);
384}
385// L1 Cache Handle:
386// L2 Cache Handle:
387// L3 Cache Handle:
388DBG("\tSerial Number: %s\n", SMBStringForField(structHeader, ((SMBProcessorInformation *)structHeader)->serialNumber, privateData));
389DBG("\tAsset Tag: %s\n", SMBStringForField(structHeader, ((SMBProcessorInformation *)structHeader)->assetTag, neverMask));
390DBG("\tPart Number: %s\n", SMBStringForField(structHeader, ((SMBProcessorInformation *)structHeader)->partNumber, neverMask));
391if(((SMBProcessorInformation *)structHeader)->coreCount != 0) {
392DBG("\tCore Count: %d\n", ((SMBProcessorInformation *)structHeader)->coreCount);}
393if(((SMBProcessorInformation *)structHeader)->coreEnabled != 0) {
394DBG("\tCore Enabled: %d\n", ((SMBProcessorInformation *)structHeader)->coreEnabled);}
395if(((SMBProcessorInformation *)structHeader)->threadCount != 0) {
396DBG("\tThread Count: %d\n", ((SMBProcessorInformation *)structHeader)->threadCount);
397}
398// Characteristics:
399//DBG("\tProcessor Family 2: %d\n", ((SMBProcessorInformation *)structHeader)->processorFamily2);
400DBG("\n");
401}
402
403//-------------------------------------------------------------------------------------------------------------------------
404// Memory Controller Information (Type 5)
405//-------------------------------------------------------------------------------------------------------------------------
406
407//-------------------------------------------------------------------------------------------------------------------------
408// Memory Module Information (Type 6)
409//-------------------------------------------------------------------------------------------------------------------------
410//void decodeMemoryModule(SMBStructHeader *structHeader)
411//{
412//DBG("Memory Module Information\n");
413//DBG("\tSocket Designation: %s\n", getSMBStringForField((SMBStructHeader *)structHeader, structHeader->socketDesignation));
414//DBG("\tBank Connections: Type: %d\n", structHeader->bankConnections);
415//DBG("\tCurrent Speed: %X\n", structHeader->currentSpeed);
416//DBG("\tType: %llX\n", structHeader->currentMemoryType);
417//DBG("\tInstalled Size: %d\n", structHeader->installedSize);
418//DBG("\tEnabled Size: %d\n", structHeader->enabledSize);
419//DBG("\tError Status: %x\n", structHeader->errorStatus);
420//DBG("\n");
421//}
422
423//-------------------------------------------------------------------------------------------------------------------------
424// Cache Information (Type 7)
425//-------------------------------------------------------------------------------------------------------------------------
426
427//-------------------------------------------------------------------------------------------------------------------------
428// Port Connector Information (Type 8)
429//-------------------------------------------------------------------------------------------------------------------------
430
431//-------------------------------------------------------------------------------------------------------------------------
432// System Slot Information (Type 9)
433//-------------------------------------------------------------------------------------------------------------------------
434
435//-------------------------------------------------------------------------------------------------------------------------
436// On Board Device Information (Type 10)
437//-------------------------------------------------------------------------------------------------------------------------
438
439//-------------------------------------------------------------------------------------------------------------------------
440// OEM Strings (Type 11)
441//-------------------------------------------------------------------------------------------------------------------------
442void decodeSMBOEMStrings(SMBStructHeader *structHeader)
443{
444char *stringPtr = (char *)structHeader + structHeader->length;
445printHeader(structHeader);
446DBG("OEM Strings\n");
447SMBByte i;
448for (i = 1; i <= ((SMBOEMStrings *)structHeader)->count; i++) {
449DBG("\tString %d: %s\n", i, stringPtr);
450stringPtr = stringPtr + strlen(stringPtr) + 1;
451}
452DBG("\n");
453}
454//-------------------------------------------------------------------------------------------------------------------------
455// System Configuration Options (Type 12)
456//-------------------------------------------------------------------------------------------------------------------------
457
458//-------------------------------------------------------------------------------------------------------------------------
459// BIOS Language Information (Type 13)
460//-------------------------------------------------------------------------------------------------------------------------
461
462//-------------------------------------------------------------------------------------------------------------------------
463// Physical Memory Array (Type 16)
464//-------------------------------------------------------------------------------------------------------------------------
465
466//-------------------------------------------------------------------------------------------------------------------------
467// MemoryDevice (Type 17)
468//-------------------------------------------------------------------------------------------------------------------------
469void decodeMemoryDevice(SMBStructHeader *structHeader)
470{
471printHeader(structHeader);
472DBG("Memory Device\n");
473// Aray Handle
474if (((SMBMemoryDevice *)structHeader)->errorHandle == 0xFFFF)
475{
476DBG("\tError Information Handle: No Error\n");
477}
478else
479{
480DBG("\tError Information Handle: 0x%x\n", ((SMBMemoryDevice *)structHeader)->errorHandle);
481}
482// Total Width:
483// Data Width:
484switch (((SMBMemoryDevice *)structHeader)->memorySize)
485{
486case 0:
487DBG("\tSize: No Module Installed\n");
488break;
489case 0x7FFF:
490DBG("\tSize: 32GB or more\n");
491break;
492case 0xFFFF:
493DBG("\tSize: Unknown\n");
494break;
495default:
496DBG("\tSize: %d %s\n", ((SMBMemoryDevice *)structHeader)->memorySize & 0x7FFF, ((((SMBMemoryDevice *)structHeader)->memorySize & 0x8000) == 0x8000) ? "kB" : "MB");
497break;
498}
499if ((((SMBMemoryDevice *)structHeader)->formFactor < 0x01) || (((SMBMemoryDevice *)structHeader)->formFactor > 0x0F))
500{
501 DBG("\tForm Factor: %s\n", OutOfSpecStr);
502 }
503else
504{
505DBG("\tForm Factor: %s\n", SMBMemoryDeviceFormFactors[((SMBMemoryDevice *)structHeader)->formFactor - 1]);
506}
507// Set:
508DBG("\tLocator: %s\n", SMBStringForField(structHeader, ((SMBMemoryDevice *)structHeader)->deviceLocator, neverMask));
509DBG("\tBank Locator: %s\n", SMBStringForField(structHeader, ((SMBMemoryDevice *)structHeader)->bankLocator, neverMask));
510if (((SMBMemoryDevice *)structHeader)->memoryType > kSMBMemoryDeviceTypeCount)
511{
512DBG("\tMemory Type: %s\n", OutOfSpecStr);
513}
514else
515{
516DBG("\tMemory Type: %s\n", SMBMemoryDeviceTypes[((SMBMemoryDevice *)structHeader)->memoryType]);
517}
518// Type Detail:
519DBG("\tSpeed: %d MHz\n", ((SMBMemoryDevice *)structHeader)->memorySpeed);
520DBG("\tManufacturer: %s\n", SMBStringForField(structHeader, ((SMBMemoryDevice *)structHeader)->manufacturer, neverMask));
521DBG("\tSerial Number: %s\n", SMBStringForField(structHeader, ((SMBMemoryDevice *)structHeader)->serialNumber, privateData));
522DBG("\tAsset Tag: %s\n", SMBStringForField(structHeader, ((SMBMemoryDevice *)structHeader)->assetTag, neverMask));
523DBG("\tPart Number: %s\n", SMBStringForField(structHeader, ((SMBMemoryDevice *)structHeader)->partNumber, neverMask));
524// Rank:
525// Configured Clock Speed:
526DBG("\n");
527}
528
529//-------------------------------------------------------------------------------------------------------------------------
530// Apple Specific (Type 131)
531//-------------------------------------------------------------------------------------------------------------------------
532void decodeOemProcessorType(SMBStructHeader *structHeader)
533{
534printHeader(structHeader);
535DBG("Apple specific Processor Type\n");
536DBG("\tCpu-type: 0x%x\n", ((SMBOemProcessorType *)structHeader)->ProcessorType);
537DBG("\n");
538}
539
540//-------------------------------------------------------------------------------------------------------------------------
541// Apple Specific (Type 132)
542//-------------------------------------------------------------------------------------------------------------------------
543void decodeOemProcessorBusSpeed(SMBStructHeader *structHeader)
544{
545printHeader(structHeader);
546DBG("Apple specific Processor Interconnect Speed\n");
547DBG("\tQPI = %d MT/s\n", ((SMBOemProcessorBusSpeed *)structHeader)->ProcessorBusSpeed);
548DBG("\n");
549}
550
551// Info for the Table Above: dmi 2.7+ https://wiki.debian.org/InstallingDebianOn/Thinkpad/T42/lenny?action=AttachFile&do=get&target=dmidecode.Lenny_Thinkpad_T42_2373.txt
552//-------------------------------------------------------------------------------------------------------------------------
553// Apple Specific (Type 133)
554//-------------------------------------------------------------------------------------------------------------------------
555//void decodeOemPlatformFeature(SMBStructHeader *structHeader)
556//{
557//printHeader(structHeader);
558//DBG("Apple specific Platform Feature\n");
559//DBG("\t%s\n", ((SMBOemPlatformFeature *)structHeader)->PlatformFeature);
560//DBG("\n");
561//}
562
563//-------------------------------------------------------------------------------------------------------------------------
564// Specific (Type 134)
565//-------------------------------------------------------------------------------------------------------------------------
566//void decodeOem(SMBStructHeader *structHeader)
567//{
568//printHeader(structHeader);
569//DBG("Apple specific Feature\n");
570//DBG("\t%s\n", ((SMBOemPlatformFeature *)structHeader)->Feature);
571//DBG("\n");
572//}
573
574//-------------------------------------------------------------------------------------------------------------------------
575
576
577void decodeSMBIOSTable(SMBEntryPoint *eps)
578{
579uint8_t *ptr = (uint8_t *)eps->dmi.tableAddress;
580SMBStructHeader *structHeader = (SMBStructHeader *)ptr;
581
582minorVersion = eps->minorVersion;
583majorVersion = eps->majorVersion;
584bcdRevisionHi = eps->dmi.bcdRevision >> 4;
585bcdRevisionLo = eps->dmi.bcdRevision & 0x0F;
586
587getBoolForKey(kPrivateData, &privateData, &bootInfo->chameleonConfig); // Bungo: chek if mask some data
588
589DBG("\n");
590DBG("SMBIOS rev.: %d.%d, DMI rev.: %d.%d\n", majorVersion, minorVersion, bcdRevisionHi, bcdRevisionLo);
591DBG("\n");
592for (;((eps->dmi.tableAddress + eps->dmi.tableLength) > ((uint32_t)(uint8_t *)structHeader + sizeof(SMBStructHeader)));)
593{
594switch (structHeader->type)
595{
596case kSMBTypeBIOSInformation: // Type 0
597decodeBIOSInformation(structHeader);
598break;
599
600case kSMBTypeSystemInformation: // Type 1
601decodeSystemInformation(structHeader);
602break;
603
604case kSMBTypeBaseBoard: // Type 2
605decodeBaseBoard(structHeader);
606break;
607
608case kSMBTypeSystemEnclosure: // Type 3
609decodeSystemEnclosure(structHeader);
610break;
611
612case kSMBTypeProcessorInformation: // Type 4
613decodeProcessorInformation(structHeader);
614break;
615
616//case kSMBTypeMemoryModule: // Type 6
617//decodeMemoryModule(structHeader);
618//break;
619
620//case kSMBTypeSystemSlot: // Type 9
621//decodeSMBTypeSystemSlot(structHeader);
622//break;
623
624case kSMBOEMStrings: // Type 11
625decodeSMBOEMStrings(structHeader);
626break;
627
628case kSMBTypeMemoryDevice: // Type 17
629decodeMemoryDevice(structHeader);
630break;
631
632//kSMBTypeMemoryArrayMappedAddress: // Type 19
633//break;
634
635/* Skip all Apple Specific Structures */
636// case kSMBTypeFirmwareVolume: // Type 128
637// case kSMBTypeMemorySPD: // Type 130
638//break;
639
640case kSMBTypeOemProcessorType: // Type 131
641decodeOemProcessorType(structHeader);
642break;
643
644case kSMBTypeOemProcessorBusSpeed: // Type 132
645decodeOemProcessorBusSpeed(structHeader);
646break;
647
648//kSMBTypeOemPlatformFeature: // Type 133
649//decodeOemPlatformFeature(structHeader);
650//break;
651
652case kSMBTypeEndOfTable: // Type 127
653DBG("Handle 0x%04x, DMI type %d, %d bytes\n", structHeader->handle, structHeader->type, structHeader->length);
654DBG("End of Table\n");
655break;
656
657default:
658break;
659}
660
661ptr = (uint8_t *)((uint32_t)structHeader + structHeader->length);
662for (; ((uint16_t *)ptr)[0] != 0; ptr++);
663
664if (((uint16_t *)ptr)[0] == 0)
665{
666ptr += 2;
667}
668
669structHeader = (SMBStructHeader *)ptr;
670}
671DBG("\n");
672}
673
674

Archive Download this file

Revision: 2476