#include <assert.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <unistd.h>

#include <libxml/tree.h>

#include "version.h"

#include "config.h"

#include "types.h"

#include "util.h"

#include "dmixml.h"

#include "dmidecode.h"

#include "dmioem.h"

#include "efi.h"

#include "dmidump.h"

#include "dmihelper.h"

const char *dmi_string(const struct dmi_header *dm, u8 s)

{

char *bp = (char *)dm->data;

size_t i, len;

if(s == 0)

return "Not Specified";

bp += dm->length;

while(s > 1 && *bp) {

bp += strlen(bp);

bp++;

s--;

}

if(!*bp)

return NULL;

/* ASCII filtering */

len = strlen(bp);

for(i = 0; i < len; i++)

if(bp[i] < 32 || bp[i] == 127)

bp[i] = '.';

return bp;

}

xmlNode *dmi_smbios_structure_type(xmlNode *node, u8 code)

{

static struct {

const char *descr;

const char *tagname;

const char *attrname;

const char *attrvalue;

} types[] = {

/* *INDENT-OFF* */

{"BIOS", "BIOS", NULL, NULL}, /* 0 */

{"System", "System", NULL, NULL},

{"Base Board", "BaseBoard", NULL, NULL},

{"Chassis", "Chassis", NULL, NULL},

{"Processor", "Processor", NULL, NULL},

{"Memory Controller", "Memory", "type", "controller"},

{"Memory Module", "Memory", "type", "module"},

{"Cache", "Cache", NULL, NULL},

{"Port Connector", "PortConnectors", NULL, NULL},

{"System Slots", "Slots", NULL, NULL},

{"On Board Devices", "OnBoardDevices", NULL, NULL},

{"OEM Strings", "OEMstrings", NULL, NULL},

{"System Configuration Options", "SysConfigOpts", NULL, NULL},

{"BIOS Language", "BIOS", "type", "language"},

{"Group Associations", "GroupAssociations", NULL, NULL},

{"System Event Log", "EventLog", NULL, NULL},

{"Physical Memory Array", "PhysicalMemoryArray", NULL, NULL},

{"Memory Device", "Memory", "type", "device"},

{"32-bit Memory Error", "MemoryError", "bit", "32"},

{"Memory Array Mapped Address", "MemoryAddressMap", "type", "MemoryArray"},

{"Memory Device Mapped Address", "MemoryAddressMap", "type", "Device"},

{"Built-in Pointing Device", "BuiltinPointingDevice",NULL, NULL},

{"Portable Battery", "PortableBattery", NULL, NULL},

{"System Reset", "SystemReset", NULL, NULL},

{"Hardware Security", "HWsecurity", NULL, NULL},

{"System Power Controls", "SysPowerCtrl", NULL, NULL},

{"Voltage Probe", "Probe", "type", "Voltage"},

{"Cooling Device", "CoolingDevice", NULL, NULL},

{"Temperature Probe", "Probe", "type", "Temperature"},

{"Electrical Current Probe", "Probe", "type", "ElectricalCurrent"},

{"Out-of-band Remote Access", "RemoteAccess", NULL, NULL},

{"Boot Integrity Services", "BootIntegritySrv", NULL, NULL},

{"System Boot", "SystemBoot", NULL, NULL},

{"64-bit Memory Error", "MemoryError", "bit", "64"},

{"Management Device", "ManagementDevice", NULL, NULL},

{"Management Device Component", "ManagementDevice", "type", "component"},

{"Management Device Threshold Data","ManagementDevice", "type", "Threshold Data"},

{"Memory Channel", "MemoryChannel", NULL, NULL},

{"IPMI Device", "IPMIdevice", NULL, NULL},

{"Power Supply", "PowerSupply", NULL, NULL} /* 39 */

/* *INDENT-ON* */

};

xmlNode *type_n = NULL;

if(code <= 39) {

type_n = xmlNewChild(node, NULL, (xmlChar *)types[code].tagname, NULL);

assert( type_n != NULL );

dmixml_AddAttribute(type_n, "flags", "0x%04x", code);

dmixml_AddTextChild(type_n, "Description", "%s", types[code].descr);

if( (types[code].attrname != NULL) && (types[code].attrvalue != NULL) ) {

dmixml_AddAttribute(type_n, types[code].attrname, "%s", types[code].attrvalue);

}

} else {

type_n = xmlNewChild(node, NULL, (xmlChar *) "UnknownSMBiosType", NULL);

dmixml_AddAttribute(type_n, "flags", "0x%04x", code);

}

return type_n;

}

static int dmi_bcd_range(u8 value, u8 low, u8 high)

{

if(value > 0x99 || (value & 0x0F) > 0x09)

return 0;

if(value < low || value > high)

return 0;

return 1;

}

void dmi_dump(xmlNode *node, struct dmi_header * h)

{

int row, i;

const char *s;

xmlNode *dump_n = NULL, *row_n = NULL;

char *tmp_s = NULL;

dump_n = xmlNewChild(node, NULL, (xmlChar *) "HeaderAndData", NULL);

assert( dump_n != NULL );

tmp_s = (char *) malloc((h->length * 2) + 2);

for(row = 0; row < ((h->length - 1) >> 4) + 1; row++) {

memset(tmp_s, 0, (h->length * 2) + 2);

for(i = 0; i < (16 && i < h->length - (row << 4)); i++) {

snprintf(tmp_s + strlen(tmp_s), (h->length * 2)-strlen(tmp_s),

"0x%02x", (h->data)[(row << 4) + i]);

}

row_n = dmixml_AddTextChild(dump_n, "Row", "%s", tmp_s);

dmixml_AddAttribute(row_n, "index", "%i", row);

row_n = NULL;

}

free(tmp_s); tmp_s = NULL;

dump_n = NULL;

dump_n = xmlNewChild(node, NULL, (xmlChar *) "Strings", NULL);

assert( dump_n != NULL );

if((h->data)[h->length] || (h->data)[h->length + 1]) {

i = 1;

while((s = dmi_string(h, i++)) != NULL) {

//. FIXME: DUMP

/*

row_n = dmixml_AddTextChild(dump_n, "String", "%s", s);

dmixml_AddAttribute(row_n, "index", "%i", i);

row_n = NULL;

}

}

dump_n = NULL;

}

void dmi_bios_runtime_size(xmlNode *node, u32 code)

{

xmlNode *data_n = xmlNewChild(node, NULL, (xmlChar *) "RuntimeSize", NULL);

assert( data_n != NULL );

dmixml_AddAttribute(data_n, "flags", "0x%04x", code);

if(code & 0x000003FF) {

dmixml_AddAttribute(data_n, "unit", "bytes");

dmixml_AddTextContent(data_n, "%i", code);

} else {

dmixml_AddAttribute(data_n, "unit", "KB");

dmixml_AddTextContent(data_n, "%i", code >> 10);

}

}

void dmi_bios_characteristics(xmlNode *node, u64 code)

{

static const char *characteristics[] = {

"BIOS characteristics not supported", /* 3 */

"ISA is supported",

"MCA is supported",

"EISA is supported",

"PCI is supported",

"PC Card (PCMCIA) is supported",

"PNP is supported",

"APM is supported",

"BIOS is upgradeable",

"BIOS shadowing is allowed",

"VLB is supported",

"ESCD support is available",

"Boot from CD is supported",

"Selectable boot is supported",

"BIOS ROM is socketed",

"Boot from PC Card (PCMCIA) is supported",

"EDD is supported",

"Japanese floppy for NEC 9800 1.2 MB is supported (int 13h)",

"Japanese floppy for Toshiba 1.2 MB is supported (int 13h)",

"5.25\"/360 KB floppy services are supported (int 13h)",

"5.25\"/1.2 MB floppy services are supported (int 13h)",

"3.5\"/720 KB floppy services are supported (int 13h)",

"3.5\"/2.88 MB floppy services are supported (int 13h)",

"Print screen service is supported (int 5h)",

"8042 keyboard services are supported (int 9h)",

"Serial services are supported (int 14h)",

"Printer services are supported (int 17h)",

"CGA/mono video services are supported (int 10h)",

"NEC PC-98" /* 31 */

};

dmixml_AddAttribute(node, "dmispec", "3.3.1.1");

dmixml_AddAttribute(node, "flags", "0x%04x", code);

if(code.l&(1<<3)) {

dmixml_AddAttribute(node, "unavailable", "1");

dmixml_AddTextContent(node, characteristics[0]);

} else {

int i = 0;

xmlNode *flags_n = xmlNewChild(node, NULL, (xmlChar *) "flags", NULL);

assert( flags_n != NULL );

for(i = 4; i <= 31; i++) {

xmlNode *flg_n = dmixml_AddTextChild(flags_n, "flag", characteristics[i - 3]);

dmixml_AddAttribute(flg_n, "enabled", "%i", (code.l & (1 << i) ? 1 : 0 ));

}

}

}

void dmi_bios_characteristics_x1(xmlNode *node, u8 code)

{

int i = 0;

static const char *characteristics[] = {

"ACPI", /* 0 */

"USB legacy",

"AGP",

"I2O boot",

"LS-120 boot",

"ATAPI Zip drive boot",

"IEEE 1394 boot",

"Smart battery" /* 7 */

};

dmixml_AddAttribute(node, "dmispec", "3.3.1.2.1");

dmixml_AddAttribute(node, "flags", "0x%04x", code);

for(i = 0; i <= 7; i++) {

xmlNode *chr_n = dmixml_AddTextChild(node, "characteristic", characteristics[i]);

dmixml_AddAttribute(chr_n, "enabled", "%i", (code & (1 << i) ? 1: 0));

}

}

void dmi_bios_characteristics_x2(xmlNode *node, u8 code)

{

int i = 0;

static const char *characteristics[] = {

"BIOS boot specification", /* 0 */

"Function key-initiated network boot",

"Targeted content distribution" /* 2 */

};

dmixml_AddAttribute(node, "dmispec", "3.3.1.2.2");

dmixml_AddAttribute(node, "flags", "0x%04x", code);

for(i = 0; i <= 2; i++) {

xmlNode *chr_n = dmixml_AddTextChild(node, "characteristic", characteristics[i]);

dmixml_AddAttribute(chr_n, "enabled", "%i", (code & (1 << i) ? 1: 0));

}

}

void dmi_system_uuid(xmlNode *node, const u8 * p, u16 ver)

{

int only0xFF = 1, only0x00 = 1;

int i;

xmlNode *uuid_n = NULL;

for(i = 0; i < 16 && (only0x00 || only0xFF); i++) {

if(p[i] != 0x00)

only0x00 = 0;

if(p[i] != 0xFF)

only0xFF = 0;

}

uuid_n = xmlNewChild(node, NULL, (xmlChar *) "SystemUUID", NULL);

dmixml_AddAttribute(uuid_n, "dmispec", "3.3.2");

if(only0xFF ) {

dmixml_AddAttribute(uuid_n, "unavailable", "1");

dmixml_AddTextContent(uuid_n, "Not Present");

return;

}

if(only0x00){

dmixml_AddAttribute(uuid_n, "unavailable", "1");

dmixml_AddTextContent(uuid_n,"Not Settable");

return;

}

/*

if(ver >= 0x0206) {

dmixml_AddTextContent(uuid_n,

"%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",

p[3], p[2], p[1], p[0], p[5], p[4], p[7], p[6], p[8], p[9], p[10],

p[11], p[12], p[13], p[14], p[15]);

} else {

dmixml_AddTextContent(uuid_n,

"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",

p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10],

p[11], p[12], p[13], p[14], p[15]);

}

}

void dmi_system_wake_up_type(xmlNode *node, u8 code)

{

static const char *type[] = {

"Reserved", /* 0x00 */

"Other",

"Unknown",

"APM Timer",

"Modem Ring",

"LAN Remote",

"Power Switch",

"PCI PME#",

"AC Power Restored" /* 0x08 */

};

xmlNode *swut_n = xmlNewChild(node, NULL, (xmlChar *) "SystemWakeUpType", NULL);

assert( swut_n != NULL );

dmixml_AddAttribute(swut_n, "dmispec", "3.3.2.1");

dmixml_AddAttribute(swut_n, "flags", "0x%04x", code);

if(code <= 0x08) {

dmixml_AddTextContent(swut_n, type[code]);

} else {

dmixml_AddAttribute(swut_n, "outofspec", "1");

}

}

void dmi_base_board_features(xmlNode *node, u8 code)

{

static const char *features[] = {

"Board is a hosting board", /* 0 */

"Board requires at least one daughter board",

"Board is removable",

"Board is replaceable",

"Board is hot swappable" /* 4 */

};

xmlNode *feat_n = xmlNewChild(node, NULL, (xmlChar *) "Features", NULL);

assert( feat_n != NULL );

dmixml_AddAttribute(feat_n, "dmispec", "3.3.3.1");

dmixml_AddAttribute(feat_n, "flags", "0x%04x", code);

if((code & 0x1F) != 0) {

int i;

for(i = 0; i <= 4; i++) {

if(code & (1 << i)) {

dmixml_AddTextChild(feat_n, "feature", features[i]);

}

}

} else {

dmixml_AddAttribute(feat_n, "unavailable", "1");

}

}

void dmi_base_board_type(xmlNode *node, const char *tagname, u8 code)

{

/* 3.3.3.2 */

static const char *type[] = {

"Unknown", /* 0x01 */

"Other",

"Server Blade",

"Connectivity Switch",

"System Management Module",

"Processor Module",

"I/O Module",

"Memory Module",

"Daughter Board",

"Motherboard",

"Processor+Memory Module",

"Processor+I/O Module",

"Interconnect Board" /* 0x0D */

};

xmlNode *type_n = xmlNewChild(node, NULL, (xmlChar *) tagname, NULL);

assert( type_n != NULL );

dmixml_AddAttribute(type_n, "dmispec", "3.3.3.2");

dmixml_AddAttribute(type_n, "flags", "0x%04x", code);

if(code >= 0x01 && code <= 0x0D) {

dmixml_AddTextContent(type_n, "%s", type[code - 0x01]);

} else {

dmixml_AddAttribute(type_n, "unavailable", "1");

}

}

void dmi_base_board_handles(xmlNode *node, u8 count, const u8 * p)

{

int i;

xmlNode *dict_n = NULL;

dict_n = xmlNewChild(node, NULL, (xmlChar *) "ContainedObjectHandles", NULL);

assert( dict_n != NULL );

dmixml_AddAttribute(dict_n, "count", "%i", count);

for(i = 0; i < count; i++) {

xmlNode *elmt_n = xmlNewChild(dict_n, NULL, (xmlChar *) "Handle", NULL);

assert( elmt_n != NULL );

dmixml_AddTextContent(elmt_n, "0x%04x", WORD(p + sizeof(u16) * i));

}

}

void dmi_chassis_type(xmlNode *node, u8 code)

{

static const char *type[] = {

"Other", /* 0x01 */

"Unknown",

"Desktop",

"Low Profile Desktop",

"Pizza Box",

"Mini Tower",

"Tower",

"Portable",

"Laptop",

"Notebook",

"Hand Held",

"Docking Station",

"All In One",

"Sub Notebook",

"Space-saving",

"Lunch Box",

"Main Server Chassis", /* CIM_Chassis.ChassisPackageType says "Main System Chassis" */

"Expansion Chassis",

"Sub Chassis",

"Bus Expansion Chassis",

"Peripheral Chassis",

"RAID Chassis",

"Rack Mount Chassis",

"Sealed-case PC",

"Multi-system",

"CompactPCI",

"AdvancedTCA", /* 0x1B */

"Blade",

"Blade Enclosing" /* 0x1D */

};

xmlNode *type_n = xmlNewChild(node, NULL, (xmlChar *)"ChassisType", NULL);

assert( type_n != NULL );

dmixml_AddAttribute(type_n, "dmispec", "3.3.4.1");

dmixml_AddAttribute(type_n, "flags", "0x%04x", code);

if(code >= 0x01 && code <= 0x1B) {

dmixml_AddAttribute(type_n, "available", "1");

dmixml_AddTextContent(type_n, "%s", type[code - 0x01]);

} else {

dmixml_AddAttribute(type_n, "available", "0");

}

}

void dmi_chassis_lock(xmlNode *node, u8 code)

{

static const char *lock[] = {

"Not Present", /* 0x00 */

"Present" /* 0x01 */

};

xmlNode *lock_n = xmlNewChild(node, NULL, (xmlChar *) "ChassisLock", NULL);

assert( lock_n != NULL );

dmixml_AddAttribute(lock_n, "dmispec", "3.3.4");

dmixml_AddAttribute(lock_n, "flags", "0x%04x", code);

dmixml_AddTextContent(lock_n, "%s", lock[code]);

}

void dmi_chassis_state(xmlNode *node, const char *tagname, u8 code)

{

static const char *state[] = {

"Other", /* 0x01 */

"Unknown",

"Safe", /* master.mif says OK */

"Warning",

"Critical",

"Non-recoverable" /* 0x06 */

};

xmlNode *state_n = xmlNewChild(node, NULL, (xmlChar *) tagname, NULL);

assert( state_n != NULL );

dmixml_AddAttribute(state_n, "dmispec", "3.3.4.2");

dmixml_AddAttribute(state_n, "flags", "0x%04x", code);

if(code >= 0x01 && code <= 0x06) {

dmixml_AddTextContent(state_n, "%s", state[code - 0x01]);

} else {

dmixml_AddAttribute(state_n, "unavailable", "1");

}

}

void dmi_chassis_security_status(xmlNode *node, u8 code)

{

static const char *status[] = {

"Other", /* 0x01 */

"Unknown",

"None",

"External Interface Locked Out",

"External Interface Enabled" /* 0x05 */

};

xmlNode *secstat_n = xmlNewChild(node, NULL, (xmlChar *) "SecurityStatus", NULL);

assert( secstat_n != NULL );

dmixml_AddAttribute(secstat_n, "dmispec", "3.3.4.3");

dmixml_AddAttribute(secstat_n, "flags", "0x%04x", code);

if(code >= 0x01 && code <= 0x05) {

dmixml_AddTextContent(secstat_n, "%s", status[code - 0x01]);

} else {

dmixml_AddAttribute(secstat_n, "unavailable", "1");

}

}

void dmi_chassis_height(xmlNode *node, u8 code)

{

xmlNode *hght_n = xmlNewChild(node, NULL, (xmlChar *) "ChassisHeight", NULL);

assert( hght_n != NULL );

if(code == 0x00) {

dmixml_AddAttribute(hght_n, "unspecified", "1");

} else {

dmixml_AddAttribute(hght_n, "unit", "U");

dmixml_AddTextContent(hght_n, "%i", code);

}

}

void dmi_chassis_power_cords(xmlNode *node, u8 code)

{

xmlNode *pwrc_n = xmlNewChild(node, NULL, (xmlChar *) "PowerCords", NULL);

assert( pwrc_n != NULL );

if(code == 0x00) {

dmixml_AddAttribute(pwrc_n, "unspecified", "1");

} else {

dmixml_AddTextContent(pwrc_n, "%i", code);

}

}

void dmi_chassis_elements(xmlNode *node, u8 count, u8 len, const u8 * p)

{

int i;

xmlNode *data_n = xmlNewChild(node, NULL, (xmlChar *) "ChassisElements", NULL);

assert( data_n != NULL );

dmixml_AddAttribute(data_n, "count", "%i", count);

for(i = 0; i < count; i++) {

if(len >= 0x03) {

xmlNode *key_n = NULL;

if( p[i * len] & 0x80 ) {

key_n = dmi_smbios_structure_type(data_n, p[i * len] & 0x7F);

} else {

key_n = xmlNewChild(data_n, NULL, (xmlChar *) "BaseboardElement", NULL);

dmi_base_board_type(key_n, "Description", p[i * len] & 0x7F);

}

assert( key_n != NULL );

if(p[1 + i * len] == p[2 + i * len]) {

dmixml_AddTextChild(key_n, "Value", "%i", p[1 + i * len]);

} else {

dmixml_AddTextChild(key_n, "Value", "%i-%i", p[1 + i * len], p[2 + i * len]);

}

}

}

}

void dmi_processor_type(xmlNode *node, u8 code)

{

/* 3.3.5.1 */

static const char *type[] = {

"Other", /* 0x01 */

"Unknown",

"Central Processor",

"Math Processor",

"DSP Processor",

"Video Processor" /* 0x06 */

};

xmlNode *proct_n = xmlNewChild(node, NULL, (xmlChar *) "Type", NULL);

assert( proct_n != NULL );

dmixml_AddAttribute(proct_n, "flags", "0x%04x", code);

if(code >= 0x01 && code <= 0x06) {

dmixml_AddTextContent(proct_n, type[code - 0x01]);

} else {

dmixml_AddAttribute(proct_n, "outofspec", "1");

}

}

void dmi_processor_family(xmlNode *node, const struct dmi_header *h)

{

const u8 *data = h->data;

unsigned int i, low, high;

u16 code;

/* 3.3.5.2 */

static struct {

int value;

const char *name;

} family2[] = {

/* *INDENT-OFF* */

{ 0x01, "Other" },

{ 0x02, "Unknown" },

{ 0x03, "8086" },

{ 0x04, "80286" },

{ 0x05, "80386" },

{ 0x06, "80486" },

{ 0x07, "8087" },

{ 0x08, "80287" },

{ 0x09, "80387" },

{ 0x0A, "80487" },

{ 0x0B, "Pentium" },

{ 0x0C, "Pentium Pro" },

{ 0x0D, "Pentium II" },

{ 0x0E, "Pentium MMX" },

{ 0x0F, "Celeron" },

{ 0x10, "Pentium II Xeon" },

{ 0x11, "Pentium III" },

{ 0x12, "M1" },

{ 0x13, "M2" },

{ 0x14, "Celeron M" }, /* From CIM_Processor.Family */

{ 0x15, "Pentium 4 HT" }, /* From CIM_Processor.Family */

{ 0x18, "Duron" },

{ 0x19, "K5" },

{ 0x1A, "K6" },

{ 0x1B, "K6-2" },

{ 0x1C, "K6-3" },

{ 0x1D, "Athlon" },

{ 0x1E, "AMD29000" },

{ 0x1F, "K6-2+" },

{ 0x20, "Power PC" },

{ 0x21, "Power PC 601" },

{ 0x22, "Power PC 603" },

{ 0x23, "Power PC 603+" },

{ 0x24, "Power PC 604" },

{ 0x25, "Power PC 620" },

{ 0x26, "Power PC x704" },

{ 0x27, "Power PC 750" },

{ 0x28, "Core Duo" }, /* From CIM_Processor.Family */

{ 0x29, "Core Duo Mobile" }, /* From CIM_Processor.Family */

{ 0x2A, "Core Solo Mobile" }, /* From CIM_Processor.Family */

{ 0x2B, "Atom" }, /* From CIM_Processor.Family */

{ 0x30, "Alpha" },

{ 0x31, "Alpha 21064" },

{ 0x32, "Alpha 21066" },

{ 0x33, "Alpha 21164" },

{ 0x34, "Alpha 21164PC" },

{ 0x35, "Alpha 21164a" },

{ 0x36, "Alpha 21264" },

{ 0x37, "Alpha 21364" },

{ 0x40, "MIPS" },

{ 0x41, "MIPS R4000" },

{ 0x42, "MIPS R4200" },

{ 0x43, "MIPS R4400" },

{ 0x44, "MIPS R4600" },

{ 0x45, "MIPS R10000" },

{ 0x50, "SPARC" },

{ 0x51, "SuperSPARC" },

{ 0x52, "MicroSPARC II" },

{ 0x53, "MicroSPARC IIep" },

{ 0x54, "UltraSPARC" },

{ 0x55, "UltraSPARC II" },

{ 0x56, "UltraSPARC IIi" },

{ 0x57, "UltraSPARC III" },

{ 0x58, "UltraSPARC IIIi" },

{ 0x60, "68040" },

{ 0x61, "68xxx" },

{ 0x62, "68000" },

{ 0x63, "68010" },

{ 0x64, "68020" },

{ 0x65, "68030" },

{ 0x70, "Hobbit" },

{ 0x78, "Crusoe TM5000" },

{ 0x79, "Crusoe TM3000" },

{ 0x7A, "Efficeon TM8000" },

{ 0x80, "Weitek" },

{ 0x82, "Itanium" },

{ 0x83, "Athlon 64" },

{ 0x84, "Opteron" },

{ 0x85, "Sempron" },

{ 0x86, "Turion 64" },

{ 0x87, "Dual-Core Opteron" },

{ 0x88, "Athlon 64 X2" },

{ 0x89, "Turion 64 X2" },

{ 0x8A, "Quad-Core Opteron" }, /* From CIM_Processor.Family */

{ 0x8B, "Third-Generation Opteron" }, /* From CIM_Processor.Family */

{ 0x8C, "Phenom FX" }, /* From CIM_Processor.Family */

{ 0x8D, "Phenom X4" }, /* From CIM_Processor.Family */

{ 0x8E, "Phenom X2" }, /* From CIM_Processor.Family */

{ 0x8F, "Athlon X2" }, /* From CIM_Processor.Family */

{ 0x90, "PA-RISC" },

{ 0x91, "PA-RISC 8500" },

{ 0x92, "PA-RISC 8000" },

{ 0x93, "PA-RISC 7300LC" },

{ 0x94, "PA-RISC 7200" },

{ 0x95, "PA-RISC 7100LC" },

{ 0x96, "PA-RISC 7100" },

{ 0xA0, "V30" },

{ 0xA1, "Quad-Core Xeon 3200" }, /* From CIM_Processor.Family */

{ 0xA2, "Dual-Core Xeon 3000" }, /* From CIM_Processor.Family */

{ 0xA3, "Quad-Core Xeon 5300" }, /* From CIM_Processor.Family */

{ 0xA4, "Dual-Core Xeon 5100" }, /* From CIM_Processor.Family */

{ 0xA5, "Dual-Core Xeon 5000" }, /* From CIM_Processor.Family */

{ 0xA6, "Dual-Core Xeon LV" }, /* From CIM_Processor.Family */

{ 0xA7, "Dual-Core Xeon ULV" }, /* From CIM_Processor.Family */

{ 0xA8, "Dual-Core Xeon 7100" }, /* From CIM_Processor.Family */

{ 0xA9, "Quad-Core Xeon 5400" }, /* From CIM_Processor.Family */

{ 0xAA, "Quad-Core Xeon" }, /* From CIM_Processor.Family */

{ 0xB0, "Pentium III Xeon" },

{ 0xB1, "Pentium III Speedstep" },

{ 0xB2, "Pentium 4" },

{ 0xB3, "Xeon" },

{ 0xB4, "AS400" },

{ 0xB5, "Xeon MP" },

{ 0xB6, "Athlon XP" },

{ 0xB7, "Athlon MP" },

{ 0xB8, "Itanium 2" },

{ 0xB9, "Pentium M" },

{ 0xBA, "Celeron D" },

{ 0xBB, "Pentium D" },

{ 0xBC, "Pentium EE" },

{ 0xBD, "Core Solo" },

/* 0xBE handled as a special case */

{ 0xBF, "Core 2 Duo" },

{ 0xC0, "Core 2 Solo" }, /* From CIM_Processor.Family */

{ 0xC1, "Core 2 Extreme" }, /* From CIM_Processor.Family */

{ 0xC2, "Core 2 Quad" }, /* From CIM_Processor.Family */

{ 0xC3, "Core 2 Extreme Mobile" }, /* From CIM_Processor.Family */

{ 0xC4, "Core 2 Duo Mobile" }, /* From CIM_Processor.Family */

{ 0xC5, "Core 2 Solo Mobile" }, /* From CIM_Processor.Family */

{ 0xC8, "IBM390" },

{ 0xC9, "G4" },

{ 0xCA, "G5" },

{ 0xCB, "ESA/390 G6" },

{ 0xCC, "z/Architectur" },

{ 0xD2, "C7-M" },

{ 0xD3, "C7-D" },

{ 0xD4, "C7" },

{ 0xD5, "Eden" },

{ 0xFA, "i860" },

{ 0xFB, "i960" },

{ 0x104, "SH-3" },

{ 0x105, "SH-4" },

{ 0x118, "ARM" },

{ 0x119, "StrongARM" },

{ 0x12C, "6x86" },

{ 0x12D, "MediaGX" },

{ 0x12E, "MII" },

{ 0x140, "WinChip" },

{ 0x15E, "DSP" },

{ 0x1F4, "Video Processor" },

/* *INDENT-ON* */

};

/* Linear Search - Slow

xmlNode *family_n = xmlNewChild(node, NULL, (xmlChar *) "Family", NULL);

assert( family_n != NULL );

dmixml_AddAttribute(family_n, "dmispec", "3.3.3.5");

code = (data[0x06] == 0xFE && h->length >= 0x2A) ? WORD(data + 0x28) : data[0x06];

dmixml_AddAttribute(family_n, "flags", "0x%04x", code);

/* Special case for ambiguous value 0xBE */

if(code == 0xBE) {

const char *manufacturer = dmi_string(h, data[0x07]);

/* Best bet based on manufacturer string */

if(strstr(manufacturer, "Intel") != NULL ||

strncasecmp(manufacturer, "Intel", 5) == 0) {

dmixml_AddTextContent(family_n, "Core 2");

return;

}

if(strstr(manufacturer, "AMD") != NULL

|| strncasecmp(manufacturer, "AMD", 3) == 0) {

dmixml_AddTextContent(family_n, "K7");

return;

}

dmixml_AddTextContent(family_n, "Core 2 or K7");

return;

}

/* Perform a binary search */

low = 0;

high = ARRAY_SIZE(family2) - 1;

while(1) {

i = (low + high) / 2;

if(family2[i].value == code) {

dmixml_AddTextContent(family_n, family2[i].name);

return;

}

if(low == high) { /* Not found */

dmixml_AddAttribute(family_n, "outofspec", "1");

return;

}

if(code < family2[i].value)

high = i;

else

low = i + 1;

}

dmixml_AddAttribute(family_n, "outofspec", "1");

}

xmlNode *dmi_processor_id(xmlNode *node, u8 type, const u8 * p, const char *version)

{

/* Intel AP-485 revision 31, table 3-4 */

static struct _cpuflags {

const char *flag;

const char *descr;

} flags[] = {

/* *INDENT-OFF* */

{"FPU", "FPU (Floating-point unit on-chip)"}, /* 0 */

{"VME", "VME (Virtual mode extension)"},

{"DE", "DE (Debugging extension)"},

{"PSE", "PSE (Page size extension)"},

{"TSC", "TSC (Time stamp counter)"},

{"MSR", "MSR (Model specific registers)"},

{"PAE", "PAE (Physical address extension)"},

{"MCE", "MCE (Machine check exception)"},

{"CX8", "CX8 (CMPXCHG8 instruction supported)"},

{"APIC", "APIC (On-chip APIC hardware supported)"},

{NULL, NULL}, /* 10 */

{"SEP", "SEP (Fast system call)"},

{"MTRR", "MTRR (Memory type range registers)"},

{"PGE", "PGE (Page global enable)"},

{"MCA", "MCA (Machine check architecture)"},

{"CMOV", "CMOV (Conditional move instruction supported)"},

{"PAT", "PAT (Page attribute table)"},

{"PSE-36", "PSE-36 (36-bit page size extension)"},

{"PSN", "PSN (Processor serial number present and enabled)"},

{"CLFSH", "CLFLUSH (CLFLUSH instruction supported)"},

{NULL, NULL }, /* 20 */

{"DS", "DS (Debug store)"},

{"ACPI", "ACPI (ACPI supported)"},

{"MMX", "MMX (MMX technology supported)"},

{"FXSR", "FXSR (Fast floating-point save and restore)"},

{"SSE", "SSE (Streaming SIMD extensions)"},

{"SSE2", "SSE2 (Streaming SIMD extensions 2)"},

{"SS", "SS (Self-snoop)"},

{"HTT", "HTT (Hyper-threading technology)"},

{"TM", "TM (Thermal monitor supported)"},

{"IA64", "IA64 (IA64 capabilities)"},