The source code.dmidecode-1-8

1 files changed, 1725 insertions, 0 deletions

diff --git a/dmidecode.c b/dmidecode.c
new file mode 100644
index 0000000..ff4440d
--- /dev/null
+++ b/dmidecode.c
@@ -0,0 +1,1725 @@
+/*
+ * DMI decode rev 1.8
+ *
+ *	(C) 2000-2002 Alan Cox <alan@redhat.com>
+ *
+ *      2-July-2001 Matt Domsch <Matt_Domsch@dell.com>
+ *      Additional structures displayed per SMBIOS 2.3.1 spec
+ *
+ *      13-December-2001 Arjan van de Ven <arjanv@redhat.com>
+ *      Fix memory bank type (DMI case 6)
+ *
+ *      3-August-2002 Mark D. Studebaker <mds@paradyne.com>
+ *      Better indent in dump_raw_data
+ *      Fix return value in dmi_bus_name
+ *      Additional sensor fields decoded
+ *      Fix compilation warnings
+ *
+ *      6-August-2002 Jean Delvare <khali@linux-fr.org>
+ *      Reposition file pointer after DMI table display
+ *      Disable first RSD PTR checksum (was not correct anyway)
+ *      Show actual DMI struct count and occupied size
+ *      Check for NULL after malloc
+ *      Use SEEK_* constants instead of numeric values
+ *      Code optimization (and warning fix) in DMI cases 10 and 14
+ *      Add else's to avoid unneeded cascaded if's in main loop
+ *      Code optimization in DMI information display
+ *      Fix all compilation warnings
+ *
+ *      9-August-2002 Jean Delvare <khali@linux-fr.org>
+ *      Better DMI struct count/size error display
+ *      More careful memory access in dmi_table
+ *      DMI case 13 (Language) decoded
+ *      C++ style comments removed
+ *      Commented out code removed
+ *      DMI 0.0 case handled
+ *      Fix return value of dmi_port_type and dmi_port_connector_type
+ *
+ *      23-August-2002 Alan Cox <alan@redhat.com>
+ *      Make the code pass -Wall -pedantic by fixing a few harmless sign of
+ *        pointer mismatches
+ *      Correct main prototype
+ *      Check for compilers with wrong type sizes
+ *
+ *      17-Sep-2002 Larry Lile <llile@dreamworks.com>
+ *      Type 16 & 17 structures displayed per SMBIOS 2.3.1 spec
+ *
+ *      20-September-2002 Dave Johnson <ddj@cascv.brown.edu>
+ *      Fix comparisons in dmi_bus_name
+ *      Fix comparison in dmi_processor_type
+ *      Fix bitmasking in dmi_onboard_type
+ *      Fix return value of dmi_temp_loc
+ *
+ *      28-September-2002 Jean Delvare <khali@linux-fr.org>
+ *      Fix missing coma in dmi_bus_name
+ *      Remove unwanted bitmaskings in dmi_mgmt_dev_type, dmi_mgmt_addr_type,
+ *        dmi_fan_type, dmi_volt_loc, dmi_temp_loc and dmi_status
+ *      Fix DMI table read bug ("dmi: read: Success")
+ *      Make the code pass -W again
+ *      Fix return value of dmi_card_size
+ *
+ *      05-October-2002 Jean Delvare <khali@linux-fr.org>
+ *      More ACPI decoded
+ *      More PNP decoded
+ *      More SYSID decoded
+ *      PCI Interrupt Routing decoded
+ *      BIOS32 Service Directory decoded
+ *      Sony system detection (unconfirmed)
+ *      Checksums verified whenever possible
+ *      Better checks on file read and close
+ *      Define VERSION and display version at beginning
+ *      More secure decoding (won't run off the table in any case)
+ *      Do not try to decode more structures than announced
+ *      Fix an off-by-one error that caused the last address being
+ *        scanned to be 0x100000, not 0xFFFF0 as it should
+ *
+ *      10-October-2002 Jean Delvare <khali@linux-fr.org>
+ *      Remove extra semicolon at the end of dmi_memory_array_use
+ *      Fix compilation warnings
+ *      Add missing backslash in DMI case 37
+ *      Fix BIOS ROM size (DMI case 0)
+ *
+ *      12-October-2002 Jean Delvare <khali@linux-fr.org>
+ *      Fix maximum cache size and installed size being inverted
+ *      Fix typos in port types
+ *
+ *      14-October-2002 Jean Delvare <khali@linux-fr.org>
+ *      Fix typo in dmi_memory_array_location
+ *      Replace Kbyte by kB in DMI case 16
+ *      Add DDR entry in dmi_memory_device_type
+ *      Fix extra s in SYSIS
+ *
+ *      15-October-2002 Jean Delvare <khali@linux-fr.org>
+ *      Fix bad index in DMI case 27 (cooling device)
+ *
+ * Licensed under the GNU Public license. If you want to use it in with
+ * another license just ask.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ * For the avoidance of doubt the "preferred form" of this code is one which
+ * is in an open unpatent encumbered format. Where cryptographic key signing
+ * forms part of the process of creating an executable the information 
+ * including keys needed to generate an equivalently functional executable
+ * are deemed to be part of the source code.
+ *		[In the light of TCPA and Palladium the author urges
+ *		 other open source authors to add such a clarification]
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define VERSION "1.8"
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+
+static void
+dump_raw_data(void *data, unsigned int length)
+{
+	char buffer1[80], buffer2[80], *b1, *b2, c;
+	unsigned char *p = data;
+	unsigned long column=0;
+	unsigned int length_printed = 0;
+	const unsigned char maxcolumn = 16;
+	while (length_printed < length) {
+		printf("\t");
+		b1 = buffer1;
+		b2 = buffer2;
+		for (column = 0;
+		     column < maxcolumn && length_printed < length; 
+		     column ++) {
+			b1 += sprintf(b1, "%02x ",(unsigned int) *p);
+			if (*p < 32 || *p > 126) c = '.';
+			else c = *p;
+			b2 += sprintf(b2, "%c", c);
+			p++;
+			length_printed++;
+		}
+		/* pad out the line */
+		for (; column < maxcolumn; column++)
+		{
+			b1 += sprintf(b1, "   ");
+			b2 += sprintf(b2, " ");
+		}
+		
+		printf("%s\t%s\n", buffer1, buffer2);
+	}
+}
+
+
+
+struct dmi_header
+{
+	u8	type;
+	u8	length;
+	u16	handle;
+};
+
+static const char *dmi_string(struct dmi_header *dm, u8 s)
+{
+	char *bp=(char *)dm;
+	if(s==0)
+		return "";
+	
+	bp+=dm->length;
+	while(s>1 && *bp)
+	{
+		bp+=strlen(bp);
+		bp++;
+		s--;
+	}
+	if(!*bp)
+		return "<bad index>";
+	return bp;
+}
+
+static void dmi_decode_ram(u8 data)
+{
+	if(data&(1<<0))
+		printf("OTHER ");
+	if(data&(1<<1))
+		printf("UNKNOWN ");
+	if(data&(1<<2))
+		printf("STANDARD ");
+	if(data&(1<<3))
+		printf("FPM ");
+	if(data&(1<<4))
+		printf("EDO ");
+	if(data&(1<<5))
+		printf("PARITY ");
+	if(data&(1<<6))
+		printf("ECC ");
+	if(data&(1<<7))
+		printf("SIMM ");
+	if(data&(1<<8))
+		printf("DIMM ");
+	if(data&(1<<9))
+		printf("Burst EDO ");
+	if(data&(1<<10))
+		printf("SDRAM ");
+}
+
+static void dmi_cache_size(u16 n)
+{
+	if(n&(1<<15))
+		printf("%dK\n", (n&0x7FFF)*64);
+	else
+		printf("%dK\n", n&0x7FFF);
+}
+
+static void dmi_decode_cache(u16 c)
+{
+	if(c&(1<<0))
+		printf("Other ");
+	if(c&(1<<1))
+		printf("Unknown ");
+	if(c&(1<<2))
+		printf("Non-burst ");
+	if(c&(1<<3))
+		printf("Burst ");
+	if(c&(1<<4))
+		printf("Pipeline burst ");
+	if(c&(1<<5))
+		printf("Synchronous ");
+	if(c&(1<<6))
+		printf("Asynchronous ");
+}
+
+const char *dmi_bus_name(u8 num)
+{
+	static const char *bus[]={
+		"",
+		"",
+		"",
+		"ISA ",
+		"MCA ",
+		"EISA ",
+		"PCI ",
+		"PCMCIA ",
+		"VLB ",
+		"Proprietary ",
+		"CPU Slot ",
+		"Proprietary RAM ",
+		"I/O Riser ",
+		"NUBUS ",
+		"PCI-66 ",
+		"AGP ",
+		"AGP 2x ",
+		"AGP 4x "
+	};
+	static const char *jpbus[]={
+		"PC98/C20",
+		"PC98/C24",
+		"PC98/E",
+		"PC98/LocalBus",
+		"PC98/Card"
+	};
+	
+	if(num<=0x11)
+		return bus[num];
+	if(num>=0xA0 && num<=0xA4)
+		return jpbus[num - 0xA0];
+	return "";
+}
+
+const char *dmi_bus_width(u8 code)
+{
+	static const char *width[]={
+		"",
+		"",
+		"",
+		"8bit ",
+		"16bit ",
+		"32bit ",
+		"64bit ",
+		"128bit "
+	};
+	if(code>7)
+		return "";
+	return width[code];
+}
+
+const char *dmi_card_size(u8 v)
+{
+	if(v==3)
+		return("Short ");
+	if(v==4)
+		return("Long ");
+	return "";
+}
+
+static void dmi_card_props(u8 v)
+{
+	printf("\t\tSlot Features: ");
+	if(v&(1<<1))
+		printf("5v ");
+	if(v&(1<<2))
+		printf("3.3v ");
+	if(v&(1<<3))
+		printf("Shared ");
+	if(v&(1<<4))
+		printf("PCCard16 ");
+	if(v&(1<<5))
+		printf("CardBus ");
+	if(v&(1<<6))
+		printf("Zoom-Video ");
+	if(v&(1<<7))
+		printf("ModemRingResume ");
+	printf("\n");
+}		
+		
+const char *dmi_chassis_type(u8 code)
+{
+	static const char *chassis_type[]={
+		"",
+		"Other",
+		"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",
+		"Expansion Chassis",
+		"SubChassis",
+		"Bus Expansion Chassis",
+		"Peripheral Chassis",
+		"RAID Chassis",
+		"Rack Mount Chassis",
+		"Sealed-case PC",
+	};
+	code &= ~0x80;
+	
+	if(code>0x18)
+		return "";
+	return chassis_type[code];
+	
+}
+
+const char *dmi_port_connector_type(u8 code)
+{
+	static const char *connector_type[]={
+		"None",
+		"Centronics",
+		"Mini Centronics",
+		"Proprietary",
+		"DB-25 pin male",
+		"DB-25 pin female",
+		"DB-15 pin male",
+		"DB-15 pin female",
+		"DB-9 pin male",
+		"DB-9 pin female",
+		"RJ-11", 
+		"RJ-45",
+		"50 Pin MiniSCSI",
+		"Mini-DIN",
+		"Micro-DIN",
+		"PS/2",
+		"Infrared",
+		"HP-HIL",
+		"Access Bus (USB)",
+		"SSA SCSI",
+		"Circular DIN-8 male",
+		"Circular DIN-8 female",
+		"On Board IDE",
+		"On Board Floppy",
+		"9 Pin Dual Inline (pin 10 cut)",
+		"25 Pin Dual Inline (pin 26 cut)",
+		"50 Pin Dual Inline",
+		"68 Pin Dual Inline",
+		"On Board Sound Input from CD-ROM",
+		"Mini-Centronics Type-14",
+		"Mini-Centronics Type-26",
+		"Mini-jack (headphones)",
+		"BNC",
+		"1394",
+		"PC-98",
+		"PC-98Hireso",
+		"PC-H98",
+		"PC-98Note",
+		"PC98Full",
+	};
+	
+	if(code == 0xFF)
+		return "Other";
+	
+	if(code <= 0x21)
+		return connector_type[code];
+	
+	if((code >= 0xA0) && (code <= 0xA4))
+		return connector_type[code-0xA0+0x22];
+	
+	return "";
+}
+
+static const char *dmi_memory_array_location(u8 num)
+{
+	static const char *memory_array_location[]={
+		"",
+		"Other",
+		"Unknown",
+		"System board or motherboard",
+		"ISA add-on card",
+		"EISA add-on card",
+		"PCI add-on card",
+		"MCA add-on card",
+		"PCMCIA add-on card",
+		"Proprietary add-on card",
+		"NuBus",
+	};
+	static const char *jp_memory_array_location[]={
+		"PC-98/C20 add-on card",
+		"PC-98/C24 add-on card",
+		"PC-98/E add-on card",
+		"PC-98/Local bus add-on card",
+	};
+	if(num<=0x0A)
+		return memory_array_location[num];
+	if(num>=0xA0 && num<0xA3)
+		return jp_memory_array_location[num];
+	return "";
+}
+
+static const char *dmi_memory_array_use(u8 num)
+{
+	static const char *memory_array_use[]={
+		"",
+		"Other",
+		"Unknown",
+		"System memory",
+		"Video memory",
+		"Flash memory",
+		"Non-volatile RAM",
+		"Cache memory",
+	};
+	if (num > 0x07)
+		return "";
+	return memory_array_use[num];
+}
+
+static const char *dmi_memory_array_error_correction_type(u8 num)
+{
+	static const char *memory_array_error_correction_type[]={
+		"",
+		"Other",
+		"Unknown",
+		"None",
+		"Parity",
+		"Single-bit ECC",
+		"Multi-bit ECC",
+		"CRC",
+	};
+	if (num > 0x07)
+		return "";
+	return memory_array_error_correction_type[num];
+}
+
+static const char *dmi_memory_device_form_factor(u8 num)
+{
+	static const char *memory_device_form_factor[]={
+		"",
+		"Other",
+		"Unknown",
+		"SIMM",
+		"SIP",
+		"Chip",
+		"DIP",
+		"ZIP",
+		"Proprietary Card",
+		"DIMM",
+		"TSOP",
+		"Row of chips",
+		"RIMM",
+		"SODIMM",
+		"SRIMM",
+	};
+	if (num > 0x0E)
+		return "";
+	return memory_device_form_factor[num];
+}
+
+static const char *dmi_memory_device_type(u8 num)
+{
+	static const char *memory_device_type[]={
+		"",
+		"Other",
+		"Unknown",
+		"DRAM",
+		"EDRAM",
+		"VRAM",
+		"SRAM",
+		"RAM",
+		"ROM",
+		"FLASH",
+		"EEPROM",
+		"FEPROM",
+		"EPROM",
+		"CDRAM",
+		"3DRAM",
+		"SDRAM",
+		"SGRAM",
+		"RDRAM",
+		"DDR"
+	};
+	if (num > 0x12)
+		return "";
+	return memory_device_type[num];
+}
+
+static void dmi_memory_device_detail(u8 v)
+{
+	printf("\t\tType Detail: ");
+	if (v&(1<<1))
+		printf("Other ");
+	if (v&(1<<2))
+		printf("Unknown ");
+	if (v&(1<<3))
+		printf("Fast-paged ");
+	if (v&(1<<4))
+		printf("Static column ");
+	if (v&(1<<5))
+		printf("Pseudo-static ");
+	if (v&(1<<6))
+		printf("RAMBUS ");
+	if (v&(1<<7))
+		printf("Synchronous ");
+	if (v&(1<<8))
+		printf("CMOS ");
+	if (v&(1<<9))
+		printf("EDO ");
+	if (v&(1<<10))
+		printf("Window DRAM ");
+	if (v&(1<<11))
+		printf("Cache DRAM ");
+	if (v&(1<<12))
+		printf("Non-volatile ");
+	printf("\n");
+}
+
+const char *dmi_port_type(u8 code)
+{
+	static const char *port_type[]={
+		"None",
+		"Parallel Port XT/AT Compatible",
+		"Parallel Port PS/2",
+		"Parallel Port ECP",
+		"Parallel Port EPP",
+		"Parallel Port ECP/EPP",
+		"Serial Port XT/AT Compatible",
+		"Serial Port 16450 Compatible",
+		"Serial Port 16550 Compatible",
+		"Serial Port 16550A Compatible",
+		"SCSI Port",
+		"MIDI Port",
+		"Joy Stick Port",
+		"Keyboard Port",
+		"Mouse Port",
+		"SSA SCSI",
+		"USB",
+		"FireWire (IEEE P1394)",
+		"PCMCIA Type I",
+		"PCMCIA Type II",
+		"PCMCIA Type III",
+		"Cardbus",
+		"Access Bus Port",
+		"SCSI II",
+		"SCSI Wide",
+		"PC-98",
+		"PC-98-Hireso",
+		"PC-H98",
+		"Video Port",
+		"Audio Port",
+		"Modem Port",
+		"Network Port",
+		"8251 Compatible",
+		"8251 FIFO Compatible",
+	};
+	
+	if(code == 0xFF)
+		return "Other";
+	
+	if (code <= 0x1F)
+		return port_type[code];
+	
+	if ((code >= 0xA0) && (code <= 0xA1))
+		return port_type[code-0xA0+0x20];
+	
+	return "";
+}
+
+const char *dmi_processor_type(u8 code)
+{
+	static const char *processor_type[]={
+		"",
+		"Other",
+		"Unknown",
+		"Central Processor",
+		"Math Processor",
+		"DSP Processor",
+		"Video Processor"
+	};
+	
+	if(code == 0xFF)
+		return "Other";
+	
+	if (code > 6)
+		return "";
+	return processor_type[code];
+}
+
+const char *dmi_processor_family(u8 code)
+{
+	static const char *processor_family[]={
+		"",
+		"Other",
+		"Unknown",
+		"8086",
+		"80286",
+		"Intel386 processor",
+		"Intel486 processor",
+		"8087",
+		"80287",
+		"80387",
+		"80487",
+		"Pentium processor Family",
+		"Pentium Pro processor",
+		"Pentium II processor",
+		"Pentium processor with MMX technology",
+		"Celeron processor",
+		"Pentium II Xeon processor",
+		"Pentium III processor",
+		"M1 Family",
+		"M1","M1","M1","M1","M1","M1", /* 13h - 18h */
+		"K5 Family",
+		"K5","K5","K5","K5","K5","K5", /* 1Ah - 1Fh */
+		"Power PC Family",
+		"Power PC 601",
+		"Power PC 603",
+		"Power PC 603+",
+		"Power PC 604",
+	};
+	
+	if(code == 0xFF)
+		return "Other";
+	
+	if (code > 0x24)
+		return "";
+	return processor_family[code];
+}
+
+const char *dmi_onboard_type(u8 code)
+{
+	static const char *onboard_type[]={
+		"",
+		"Other",
+		"Unknown",
+		"Video",
+		"SCSI Controller",
+		"Ethernet",
+		"Token Ring",
+		"Sound",
+	};
+	code &= ~0x80;
+	if (code > 7)
+		return "";
+	return onboard_type[code];
+}
+
+const char *dmi_mgmt_dev_type(u8 code)
+{
+	static const char *type[]={
+		"",
+		"Other",
+		"Unknown",
+		"LM75",
+		"LM78",
+		"LM79",
+		"LM80",
+		"LM81",
+		"ADM9240",
+		"DS1780",
+		"MAX1617",
+		"GL518SM",
+		"W83781D",
+		"HT82H791",
+	};
+	
+	if (code > 0x0d)
+		return "";
+	return type[code];
+}
+
+const char *dmi_mgmt_addr_type(u8 code)
+{
+	static const char *type[]={
+		"",
+		"Other",
+		"Unknown",
+		"I/O",
+		"Memory",
+		"SMBus",
+	};
+	
+	if (code > 5)
+		return "";
+	return type[code];
+}
+
+const char *dmi_fan_type(u8 code)
+{
+	static const char *type[]={
+		"",
+		"Other",
+		"Unknown",
+		"Fan",
+		"Centrifugal Blower",
+		"Chip Fan",
+		"Cabinet Fan",
+		"Power Supply Fan",
+		"Heat Pipe",
+		"Integrated Refrigeration",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"Active Cooling",
+		"Passive Cooling",
+	};
+	
+	if (code > 0x11)
+		return "";
+	return type[code];
+}
+
+const char *dmi_volt_loc(u8 code)
+{
+	static const char *type[]={
+		"",
+		"Other",
+		"Unknown",
+		"Processor",
+		"Disk",
+		"Peripheral Bay",
+		"System Management Module",
+		"Motherboard",
+		"Memory Module",
+		"Processor Module",
+		"Power Unit",
+		"Add-in Card",
+	};
+	
+	if (code > 0x0b)
+		return "";
+	return type[code];
+}
+
+const char *dmi_temp_loc(u8 code)
+{
+	static const char *type[]={
+		"Front Panel Board",
+		"Back Panel Board",
+		"Power System Board",
+		"Drive Back Plane",
+	};
+	
+	if (code <= 0x0b)
+		return dmi_volt_loc(code);
+	if (code <= 0x0f)
+		return type[code - 0x0c];
+	return "";
+}
+
+const char *dmi_status(u8 code)
+{
+	static const char *type[]={
+		"",
+		"Other",
+		"Unknown",
+		"OK",
+		"Non-critical",
+		"Critical",
+		"Non-recoverable",
+	};
+	
+	if (code > 6)
+		return "";
+	return type[code];
+}
+
+/* 3 dec. places */
+const char *dmi_millivolt(u8 *data, int indx)
+{
+	static char buffer[20];
+	short int d;
+
+	if (data[indx+1] == 0x80 && data[indx] == 0)
+		return "Unknown";
+	d = data[indx+1] << 8 | data[indx];
+	sprintf(buffer, "%0.3f", d / 1000.0);
+	return buffer;
+}
+
+/* 2 dec. places */
+const char *dmi_accuracy(u8 *data, int indx)
+{
+	static char buffer[20];
+	short int d;
+
+	if (data[indx+1] == 0x80 && data[indx] == 0)
+		return "Unknown";
+	d = data[indx+1] << 8 | data[indx];
+	sprintf(buffer, "%0.2f", d / 100.0);
+	return buffer;
+}
+
+/* 1 dec. place */
+const char *dmi_temp(u8 *data, int indx)
+{
+	static char buffer[20];
+	short int d;
+
+	if (data[indx+1] == 0x80 && data[indx] == 0)
+		return "Unknown";
+	d = data[indx+1] << 8 | data[indx];
+	sprintf(buffer, "%0.1f", d / 10.0);
+	return buffer;
+}
+
+/* 0 dec. place */
+const char *dmi_speed(u8 *data, int indx)
+{
+	static char buffer[20];
+	short int d;
+
+	if (data[indx+1] == 0x80 && data[indx] == 0)
+		return "Unknown";
+	d = data[indx+1] << 8 | data[indx];
+	sprintf(buffer, "%d", d);
+	return buffer;
+}
+
+		
+static void dmi_table(int fd, u32 base, int len, int num)
+{
+	unsigned char *buf=malloc(len);
+	struct dmi_header *dm;
+	u8 *data, *next;
+	int i=0;
+	int r=0, r2=0;
+		
+	if(len==0)
+	{
+		fputs("dmi: no data\n", stderr);
+		return;
+	}
+	
+	if(buf==NULL)
+	{
+		perror("dmi: malloc");
+		return;
+	}
+	if(lseek(fd, (long)base, SEEK_SET)==-1)
+	{
+		perror("dmi: lseek");
+		return;
+	}
+	while(r2!=len && (r=read(fd, buf+r2, len-r2))!=0 && r!=-1)
+		r2+=r;
+	if(r==-1)
+	{
+		perror("dmi: read");
+		return;
+	}
+	if(r==0)
+	{
+		fputs("dmi: read: Unexpected end of file\n", stderr);
+		return;
+	}
+	data = buf;
+	while(i<num && data+sizeof(struct dmi_header)<=(u8*)buf+len)
+	{
+		u32 u, u2;
+		dm=(struct dmi_header *)data;
+		printf("Handle 0x%04X\n\tDMI type %d, %d bytes.\n",
+			dm->handle,
+			dm->type, dm->length);
+		
+		/* we won't read beyond allocated memory */
+		next=data+dm->length;
+		while(next-buf+1<len && (next[0]!=0 || next[1]!=0))
+			next++;
+		next+=2;
+		if(next-buf>len)
+		{
+			printf("\tIncomplete structure, abort decoding.\n");
+			break;
+		}
+		
+		switch(dm->type)
+		{
+			case  0:
+				printf("\tBIOS Information Block\n");
+			printf("\t\tVendor: %s\n", 
+					dmi_string(dm, data[4]));
+			printf("\t\tVersion: %s\n", 
+					dmi_string(dm, data[5]));
+			printf("\t\tRelease: %s\n",
+					dmi_string(dm, data[8]));
+			printf("\t\tBIOS base: 0x%04X0\n",
+					data[7]<<8|data[6]);
+			printf("\t\tROM size: %dK\n",
+					64*(data[9]+1));
+				printf("\t\tCapabilities:\n");
+				u=data[13]<<24|data[12]<<16|data[11]<<8|data[10];		
+				u2=data[17]<<24|data[16]<<16|data[15]<<8|data[14];
+				printf("\t\t\tFlags: 0x%08X%08X\n",
+					u2,u);
+				break;
+				
+			case 1:
+				printf("\tSystem Information Block\n");
+			printf("\t\tVendor: %s\n",
+					dmi_string(dm, data[4]));
+			printf("\t\tProduct: %s\n",
+					dmi_string(dm, data[5]));
+			printf("\t\tVersion: %s\n",
+					dmi_string(dm, data[6]));
+			printf("\t\tSerial Number: %s\n",
+					dmi_string(dm, data[7]));
+				break;
+
+			case 2:
+				printf("\tBoard Information Block\n");
+			printf("\t\tVendor: %s\n",
+					dmi_string(dm, data[4]));
+			printf("\t\tProduct: %s\n",
+					dmi_string(dm, data[5]));
+			printf("\t\tVersion: %s\n",
+					dmi_string(dm, data[6]));
+			printf("\t\tSerial Number: %s\n",
+					dmi_string(dm, data[7]));
+				break;
+
+			case 3:
+				printf("\tChassis Information Block\n");
+			printf("\t\tVendor: %s\n",
+					dmi_string(dm, data[4]));
+			printf("\t\tChassis Type: %s\n",
+			       dmi_chassis_type(data[5]));
+			if (data[5] & 0x80)
+				printf("\t\t\tLock present\n");
+			printf("\t\tVersion: %s\n",
+					dmi_string(dm, data[6]));
+			printf("\t\tSerial Number: %s\n",
+					dmi_string(dm, data[7]));
+			printf("\t\tAsset Tag: %s\n",
+					dmi_string(dm, data[8]));
+				break;
+			
+		case 4:
+			printf("\tProcessor\n");
+			printf("\t\tSocket Designation: %s\n",
+			       dmi_string(dm, data[4]));
+			printf("\t\tProcessor Type: %s\n",
+			       dmi_processor_type(data[5]));
+			printf("\t\tProcessor Family: %s\n",
+			       dmi_processor_family(data[6]));
+			printf("\t\tProcessor Manufacturer: %s\n",
+			       dmi_string(dm, data[7]));
+			printf("\t\tProcessor Version: %s\n",
+			       dmi_string(dm, data[0x10]));
+			if (dm->length <= 0x20) break;
+			printf("\t\tSerial Number: %s\n",
+			       dmi_string(dm, data[0x20]));
+			printf("\t\tAsset Tag: %s\n",
+			       dmi_string(dm, data[0x21]));
+			printf("\t\tVendor Part Number: %s\n",
+			       dmi_string(dm, data[0x22]));
+			break;
+			
+		case 5:
+			printf("\tMemory Controller\n");
+			break;
+			
+			case 6:
+				printf("\tMemory Bank\n");
+				printf("\t\tSocket: %s\n", dmi_string(dm, data[4]));
+				if(data[5]!=0xFF)
+				{
+					printf("\t\tBanks: ");
+					if((data[5]&0xF0)!=0xF0)
+						printf("%d ",
+							data[5]>>4);
+					if((data[5]&0x0F)!=0x0F)
+						printf("%d",
+							data[5]&0x0F);
+					printf("\n");
+				}
+				if(data[6])
+					printf("\t\tSpeed: %dnS\n", data[6]);
+				printf("\t\tType: ");
+				dmi_decode_ram(data[8]<<8|data[7]);
+				printf("\n");
+				printf("\t\tInstalled Size: ");
+				switch(data[9]&0x7F)
+				{
+					case 0x7D:
+						printf("Unknown");break;
+					case 0x7E:
+						printf("Disabled");break;
+					case 0x7F:
+						printf("Not Installed");break;
+					default:
+						printf("%dMbyte",
+							(1<<(data[9]&0x7F)));
+				}
+				if(data[9]&0x80)
+					printf(" (Double sided)");
+				printf("\n");
+				printf("\t\tEnabled Size: ");
+				switch(data[10]&0x7F)
+				{
+					case 0x7D:
+						printf("Unknown");break;
+					case 0x7E:
+						printf("Disabled");break;
+					case 0x7F:
+						printf("Not Installed");break;
+					default:
+						printf("%dMbyte",
+							(1<<(data[10]&0x7F)));
+				}
+				if(data[10]&0x80)
+					printf(" (Double sided)");
+				printf("\n");
+				if((data[11]&4)==0)
+				{
+					if(data[11]&(1<<0))
+						printf("\t\t*** BANK HAS UNCORRECTABLE ERRORS (BIOS DISABLED)\n");
+					if(data[11]&(1<<1))
+						printf("\t\t*** BANK LOGGED CORRECTABLE ERRORS AT BOOT\n");
+				}
+				break;
+			case 7:
+			{
+				static const char *types[4]={
+					"Internal ", "External ",
+					"", ""};
+				static const char *modes[4]={
+					"write-through",
+					"write-back",
+					"",""};
+					
+				printf("\tCache\n");
+				printf("\t\tSocket: %s\n",
+					dmi_string(dm, data[4]));
+				u=data[6]<<8|data[5];
+				printf("\t\tL%d %s%sCache: ",
+					1+(u&7), (u&(1<<3))?"socketed ":"",
+					types[(u>>5)&3]);
+				if(u&(1<<7))
+					printf("%s\n",
+						modes[(u>>8)&3]);
+				else
+					printf("disabled\n");
+				printf("\t\tL%d Cache Size: ", 1+(u&7));
+				dmi_cache_size(data[9]|data[10]<<8);
+				printf("\t\tL%d Cache Maximum: ", 1+(u&7));
+				dmi_cache_size(data[7]|data[8]<<8);
+				printf("\t\tL%d Cache Type: ", 1+(u&7));
+				dmi_decode_cache(data[13]);
+				printf("\n");
+			}
+			break;
+
+		case 8:
+			printf("\tPort Connector\n");
+			printf("\t\tInternal Designator: %s\n",
+			       dmi_string(dm, data[4]));
+			printf("\t\tInternal Connector Type: %s\n",
+			       dmi_port_connector_type(data[5]));
+			printf("\t\tExternal Designator: %s\n",
+			       dmi_string(dm, data[6]));
+			printf("\t\tExternal Connector Type: %s\n",
+			       dmi_port_connector_type(data[7]));
+			printf("\t\tPort Type: %s\n",
+			       dmi_port_type(data[8]));
+			break;
+			
+			
+			
+		case 9:
+			printf("\tCard Slot\n");
+			printf("\t\tSlot: %s\n", 
+				dmi_string(dm, data[4]));
+			printf("\t\tType: %s%s%s\n",
+				dmi_bus_width(data[6]),
+				dmi_card_size(data[8]),
+				dmi_bus_name(data[5]));
+			if(data[7]==3)
+				printf("\t\tStatus: Available.\n");
+			if(data[7]==4)
+				printf("\t\tStatus: In use.\n");
+			if(data[11]&0xFE)
+				dmi_card_props(data[11]);
+			break;
+							
+		case 10:
+			printf("\tOn Board Devices Information\n");
+			for (u=2; u*2+1<dm->length; u++) {
+				printf("\t\tDescription: %s : %s\n",
+				       dmi_string(dm, data[1+2*u]),
+				       (data[2*u]) & 0x80 ?
+				       "Enabled" : "Disabled");
+				printf("\t\tType: %s\n",
+				       dmi_onboard_type(data[2*u]));
+
+			}
+
+			break;
+			
+			
+			case 11:
+				printf("\tOEM Data\n");
+			for(u=1;u<=data[4];u++)
+					printf("\t\t%s\n", dmi_string(dm,u));
+				break;
+			case 12:
+				printf("\tConfiguration Information\n");
+			for(u=1;u<=data[4];u++)
+					printf("\t\t%s\n", dmi_string(dm,u));
+				break;
+				
+		case 13:
+			printf("\tBIOS Language Information\n");
+			printf("\t\tInstallable Languages: %u\n", data[4]);
+			for (u=1; u<=data[4]; u++) {
+				printf("\t\t\t%s\n", dmi_string(dm,u));
+			}
+			printf("\t\tCurrently Installed Language: %s\n", dmi_string(dm, data[21]));
+			break;
+			
+		case 14:
+			printf("\tGroup Associations\n");
+			for (u=0; 3*u+7<dm->length; u++) {
+				printf("\t\tGroup Name: %s\n",
+				       dmi_string(dm,data[4]));
+				printf("\t\t\tType: 0x%02x\n", *(data+5+(u*3)));
+				printf("\t\t\tHandle: 0x%04x\n",
+				       *(u16*)(data+6+(u*3)));
+			}
+			break;
+			
+			
+			case 15:
+				printf("\tEvent Log\n");
+				printf("\t\tLog Area: %d bytes.\n",
+					data[5]<<8|data[4]);
+				printf("\t\tLog Header At: %d.\n",
+					data[7]<<8|data[6]);
+				printf("\t\tLog Data At: %d.\n",
+					data[9]<<8|data[8]);
+				printf("\t\tLog Type: %d.\n",
+					data[10]);
+				if(data[11]&(1<<0))
+					printf("\t\tLog Valid: Yes.\n");
+				if(data[11]&(1<<1))
+					printf("\t\t**Log Is Full**.\n");
+				break;
+			
+		case 16:
+			printf("\tPhysical Memory Array\n");
+			printf("\t\tLocation: %s\n",
+				dmi_memory_array_location(data[4]));
+			printf("\t\tUse: %s\n",
+				dmi_memory_array_use(data[5]));
+			printf("\t\tError Correction Type: %s\n",
+				dmi_memory_array_error_correction_type(data[6]));
+			u2 = data[10]<<24|data[9]<<16|data[8]<<8|data[7];
+			printf("\t\tMaximum Capacity: ");
+			if (u2 == 0x80000000)
+				printf("Unknown\n");
+			else
+				printf("%u kB\n", u2);
+			printf("\t\tError Information Handle: ");
+			u = data[12]<<8|data[11];
+			if (u == 0xffff) {
+				printf("None\n");
+			} else if (u == 0xfffe) {
+				printf("Not Provided\n");
+			} else {
+				printf("0x%04X\n", u);
+			}
+			printf("\t\tNumber of Devices: %u\n", data[14]<<8|data[13]);
+			break;
+		case 17:
+			printf("\tMemory Device\n");
+			printf("\t\tArray Handle: 0x%04X\n", data[5]<<8|data[4]);
+			printf("\t\tError Information Handle: ");
+			u = data[7]<<8|data[6];
+			if (u == 0xffff) {
+				printf("None\n");
+			} else if (u == 0xfffe) {
+				printf("Not Provided\n");
+			} else {
+				printf("0x%04X\n", u);
+			}
+			u = data[9]<<8|data[8];
+			printf("\t\tTotal Width: ");
+			if (u == 0xffff)
+				printf("Unknown\n");
+			else
+				printf("%u bits\n", u);
+			u = data[11]<<8|data[10];
+			printf("\t\tData Width: ");
+			if (u == 0xffff)
+				printf("Unknown\n");
+			else
+				printf("%u bits\n", u);
+			u = data[13]<<8|data[12];
+			printf("\t\tSize: ");
+			if (u == 0xffff)
+				printf("Unknown\n");
+			else
+				printf("%u %sbyte\n", (u&0x7fff), (u&0x8000) ? "K" : "M");
+			printf("\t\tForm Factor: %s\n",
+				dmi_memory_device_form_factor(data[14]));
+			if (data[15] != 0) {
+				printf("\t\tSet: ");
+				if (data[15] == 0xff)
+					printf("Unknown\n");
+				else
+					printf("0x%02X\n", data[15]);
+			}
+			printf("\t\tLocator: %s\n",
+				dmi_string(dm, data[16]));
+			printf("\t\tBank Locator: %s\n",
+				dmi_string(dm, data[17]));
+			printf("\t\tType: %s\n",
+				dmi_memory_device_type(data[18]));
+			u = data[20]<<8|data[19];
+			if (u&0x1ffe)
+				dmi_memory_device_detail(u);
+			if (dm->length > 21) {
+				u = data[22]<<8|data[21];
+				printf("\t\tSpeed: ");
+				if (u == 0)
+					printf("Unknown\n");
+				else
+					printf("%u MHz (%.1f ns)\n", u, (1000.0/u));
+			}
+			if (dm->length > 23)
+				printf("\t\tManufacturer: %s\n",
+					dmi_string(dm, data[23]));
+			if (dm->length > 24)
+				printf("\t\tSerial Number: %s\n",
+					dmi_string(dm, data[24]));
+			if (dm->length > 25)
+				printf("\t\tAsset Tag: %s\n",
+					dmi_string(dm, data[25]));
+			if (dm->length > 26)
+				printf("\t\tPart Number: %s\n",
+					dmi_string(dm, data[26]));
+			break;
+		case 18:
+			printf("\t32-bit Memory Error Information\n");
+			break;
+		case 19:
+			printf("\tMemory Array Mapped Address\n");
+			break;
+		case 20:
+			printf("\tMemory Device Mapped Address\n");
+			break;
+		case 21:
+			printf("\tBuilt-In Pointing Device\n");
+			break;
+		case 22:
+			printf("\tPortable Battery\n");
+			printf("\t\tLocation: %s\n",
+					dmi_string(dm, data[4]));
+			printf("\t\tManufacturer: %s\n",
+					dmi_string(dm, data[5]));
+			printf("\t\tManufacture Date: %s\n",
+					dmi_string(dm, data[6]));
+			printf("\t\tSerial Number: %s\n",
+					dmi_string(dm, data[7]));
+			printf("\t\tName: %s\n",
+					dmi_string(dm, data[8]));
+				break;
+
+		case 23:
+			printf("\tSystem Reset\n");
+			break;
+		case 24:
+			printf("\tHardware Security\n");
+			break;
+		case 25:
+			printf("\tSystem Power Controls\n");
+			break;
+		case 26:
+			printf("\tVoltage Sensor\n");
+			printf("\t\tDescription: %s\n",
+					dmi_string(dm, data[4]));
+			printf("\t\tDevice Location: %s\n",
+			       dmi_volt_loc(data[5] & 0x1f));
+			printf("\t\tDevice Status: %s\n",
+			       dmi_status(data[5] >> 5));
+			printf("\t\tMaximum Value: %s\n",
+			        dmi_millivolt(data, 6));
+			printf("\t\tMinimum Value: %s\n",
+			        dmi_millivolt(data, 8));
+			printf("\t\tResolution:    %s\n",
+			        dmi_millivolt(data, 10));
+			printf("\t\tTolerance:     %s\n",
+			        dmi_millivolt(data, 12));
+			printf("\t\tAccuracy:      %s\n",
+			        dmi_accuracy(data, 14));
+			if(dm->length > 0x14)
+				printf("\t\tNominal Value: %s\n",
+				        dmi_millivolt(data, 0x14));
+			break;
+		case 27:
+			printf("\tCooling Device\n");
+			printf("\t\tDevice Type: %s\n",
+			       dmi_fan_type(data[6] & 0x1f));
+			printf("\t\tDevice Status: %s\n",
+			       dmi_status(data[6] >> 5));
+			if(dm->length > 0x0c)
+				printf("\t\tNominal Speed: %s\n",
+				        dmi_speed(data, 0x0c));
+			break;
+		case 28:
+			printf("\tTemperature Sensor\n");
+			printf("\t\tDescription: %s\n",
+					dmi_string(dm, data[4]));
+			printf("\t\tDevice Location: %s\n",
+			       dmi_temp_loc(data[5] & 0x1f));
+			printf("\t\tDevice Status: %s\n",
+			       dmi_status(data[5] >> 5));
+			printf("\t\tMaximum Value: %s\n",
+			        dmi_temp(data, 6));
+			printf("\t\tMinimum Value: %s\n",
+			        dmi_temp(data, 8));
+			printf("\t\tResolution:    %s\n",
+			        dmi_temp(data, 10));
+			printf("\t\tTolerance:     %s\n",
+			        dmi_temp(data, 12));
+			printf("\t\tAccuracy:      %s\n",
+			        dmi_accuracy(data, 14));
+			if(dm->length > 0x14)
+				printf("\t\tNominal Value: %s\n",
+				        dmi_temp(data, 0x14));
+			break;
+		case 29:
+			printf("\tCurrent Sensor\n");
+			printf("\t\tDescription: %s\n",
+					dmi_string(dm, data[4]));
+			printf("\t\tDevice Location: %s\n",
+			       dmi_volt_loc(data[5] & 0x1f));
+			printf("\t\tDevice Status: %s\n",
+			       dmi_status(data[5] >> 5));
+			printf("\t\tMaximum Value: %s\n",
+			        dmi_millivolt(data, 6));
+			printf("\t\tMinimum Value: %s\n",
+			        dmi_millivolt(data, 8));
+			printf("\t\tResolution:    %s\n",
+			        dmi_millivolt(data, 10));
+			printf("\t\tTolerance:     %s\n",
+			        dmi_millivolt(data, 12));
+			printf("\t\tAccuracy:      %s\n",
+			        dmi_accuracy(data, 14));
+			if(dm->length > 0x14)
+				printf("\t\tNominal Value: %s\n",
+				        dmi_millivolt(data, 0x14));
+			break;
+		case 30:
+			printf("\tOut-of-Band Remote Access\n");
+			break;
+		case 31:
+			printf("\tBoot Integrity Services Entry Point\n");
+			break;
+		case 32:
+			printf("\tSystem Boot Information\n");
+			break;
+		case 33:
+			printf("\t64-bit Memory Error Information\n");
+			break;
+		case 34:
+			printf("\tManagement Device\n");
+			printf("\t\tDescription: %s\n",
+					dmi_string(dm, data[4]));
+			printf("\t\tDevice Type: %s\n",
+			       dmi_mgmt_dev_type(data[5]));
+			printf("\t\tAddress Type: %s\n",
+			       dmi_mgmt_addr_type(data[6]));
+			break;
+		case 35:
+			printf("\tManagement Device Component\n");
+			printf("\t\tDescription: %s\n",
+					dmi_string(dm, data[4]));
+			printf("\t\tDevice Handle   : 0x%02x%02x\n",
+			       data[6], data[5]);
+			printf("\t\tComponent Handle: 0x%02x%02x\n",
+			       data[8], data[7]);
+			printf("\t\tThreshold Handle: 0x%02x%02x\n",
+			       data[10], data[9]);
+			break;
+		case 36:
+			printf("\tManagement Device Threshold Data\n");
+			if (dm->length > 4) 
+				dump_raw_data(data+4, dm->length-4);
+			break;
+		case 37:
+			printf("\tMemory Channel\n");
+			break;
+		case 38:
+			printf("\tIPMI Device\n");
+			if (dm->length > 4) 
+				dump_raw_data(data+4, dm->length-4);
+			break;
+		case 39:
+			printf("\tPower Supply\n");
+			if (dm->length > 4) 
+				dump_raw_data(data+4, dm->length-4);
+			break;
+		case 126:
+			printf("\tInactive\n");
+			break;
+			
+		case 127:
+			printf("\tEnd-of-Table\n");
+			break;
+			
+		default:
+			if (dm->length > 4) 
+				dump_raw_data(data+4, dm->length-4);
+			break;
+			
+			
+			
+		}
+		data=next;
+		i++;
+	}
+	if(i!=num)
+	{
+		printf("Wrong DMI structures count: %d announced, only %d decoded.\n",
+			num, i);
+	}
+	if(data-(u8*)buf!=len)
+	{
+		printf("Wrong DMI structures length: %d bytes announced, %d bytes decoded.\n",
+			len, data-(u8*)buf);
+	}
+	free(buf);
+}
+
+
+static const char *acpi_version(u8 code)
+{
+	static const char *version[]={
+		" 1.0",
+		"",
+		" 2.0"
+	};
+	
+	if(code<=2)
+		return version[code];
+	return "";
+}
+
+
+static const char *pnp_event_notification(u8 code)
+{
+	static const char *notification[]={
+		"Not Supported",
+		"Polling",
+		"Asynchronous"
+	};
+	
+	if(code<=2)
+		return notification[code];
+	return "";
+}
+
+
+static void pir_exclusive_irqs(u16 code)
+{
+	if(code==0)
+		printf(" None");
+	else
+	{
+		u8 a;
+		for(a=0; a<16; a++)
+			if(code&(1<<a))
+				printf(" %u", a);
+	}
+}
+
+
+static __inline__ int checksum(u8 *buf, int len)
+{
+	u8 sum=0;
+	int a;
+	
+	for(a=0; a<len; a++)
+		sum+=buf[a];
+	return (sum==0);
+}
+
+int main(__attribute__ ((unused)) int argc, const char *argv[])
+{
+	u8 buf[48];
+	int fd=open("/dev/mem", O_RDONLY);
+	long fp=0xE0000L;
+	u8 smmajver=0, smminver=0;
+	
+	if(sizeof(u8)!=1 || sizeof(u16)!=2 || sizeof(u32)!=4 || '\0'!=0)
+	{
+		fprintf(stderr,"%s: compiler incompatibility.\n", argv[0]);
+		exit(255);
+	}
+	printf("# dmidecode %s\n", VERSION);
+	if(fd==-1)
+	{
+		perror("/dev/mem");
+		exit(1);
+	}
+	if(lseek(fd, fp, SEEK_SET)==-1)
+	{
+		perror("lseek");
+		exit(1);
+	}
+		
+	while( fp < 0xFFFFF)
+	{
+		ssize_t r=0, r2=0;
+		
+		while(r2!=16 && (r=read(fd, buf+r2, 16-r2))!=0 && r!=-1)
+			r2+=r;
+		if(r==-1)
+		{
+			perror("read");
+			exit(1);
+		}
+		if(r==0)
+		{
+			fputs("read: Unexpected end of file\n", stderr);
+			exit(1);
+		}
+		
+		if(memcmp(buf, "_SM_", 4)==0)
+			printf("SMBIOS %d.%d present.\n", smmajver=buf[6], smminver=buf[7]);
+		else if(memcmp(buf, "_SYSID_", 7)==0)
+		{
+			/* complete buffer, compute checksum */
+			read(fd, buf+16, 16); /* arbitrary, at least 1 */
+			if(*(u16 *)(buf+8)<=32 && checksum(buf, *(u16 *)(buf+8)))
+			{
+				fp+=16;
+				printf("SYSID present.\n");
+				printf("\tRevision: %u\n",
+					buf[16]);
+				printf("%d structure%s.\n",
+					*(u16 *)(buf+14), *(u16 *)(buf+14)>1?"s":"");
+				printf("SYSID table at 0x%08X.\n",
+					*(u32 *)(buf+10));
+			}
+			else
+				lseek(fd, -16, SEEK_CUR);
+		}
+		else if(memcmp(buf, "_DMI_", 5)==0 && checksum(buf, 15))
+		{
+			u16 num=buf[13]<<8|buf[12];
+			u16 len=buf[7]<<8|buf[6];
+			u32 base=buf[11]<<24|buf[10]<<16|buf[9]<<8|buf[8];
+
+			/* if version is 0.0, the real version is taken from _SM_ above */
+			printf("DMI %d.%d present.\n",
+				buf[14]?buf[14]>>4:smmajver, buf[14]?buf[14]&0x0F:smminver);
+			printf("%d structures occupying %d bytes.\n",
+				num, len);
+			printf("DMI table at 0x%08X.\n",
+				base);
+			dmi_table(fd, base, len, num);
+
+			/* dmi_table moved us far away */
+			lseek(fd, fp+16, SEEK_SET);
+		}
+		else if(memcmp(buf, "$PnP", 4)==0)
+		{
+			/* complete buffer, compute checksum */
+			read(fd, buf+16, 32); /* arbitrary, at least 1 */
+			if(buf[5]<=48 && checksum(buf, buf[5]))
+			{
+				fp+=32;
+				printf("PNP %u.%u present.\n",
+					buf[4]>>4, buf[4]&0x0F);
+				printf("\tEvent Notification: %s\n",
+					pnp_event_notification((*(u16 *)(buf+6))&0x03));
+				if(((*(u16 *)(buf+6))&0x03)==1)
+					printf("\tEvent Notification Flag Address: 0x%08X\n",
+						*(u32 *)(buf+9));
+				printf("\tReal Mode Code Address: %04X:%04X\n",
+					*(u16 *)(buf+0x0F), *(u16 *)(buf+0x0D));
+				printf("\tReal Mode Data Address: %04X:0000\n",
+					*(u16 *)(buf+0x1B));
+				printf("\tProtected Mode Code Address: 0x%08X\n",
+					*(u32 *)(buf+0x13)+*(u16 *)(buf+0x11));
+				printf("\tProtected Mode Data Address: 0x%08X\n",
+					*(u32 *)(buf+0x1D));
+				if(*(u32 *)(buf+0x17)!=0)
+					printf("\tOEM Device Identifier: 0x%08X\n",
+						*(u32 *)(buf+0x17));
+			}
+			else
+				lseek(fd, -32, SEEK_CUR);
+		}
+		else if(memcmp(buf, "RSD PTR ", 8)==0)
+		{
+			/* complete buffer, compute checksum */
+			read(fd, buf+16, 4);
+			if(checksum(buf, 20))
+			{
+				lseek(fd, 12, SEEK_CUR);
+				fp+=16;
+				printf("ACPI%s present.\n",
+					acpi_version(buf[15]));
+				printf("\tOEM ID: ");
+				fwrite(buf+9, 6, 1, stdout);
+				printf("\n");
+				printf("RSD table at 0x%08X.\n",
+					*(u32 *)(buf+16));
+			}
+			else
+				lseek(fd, -4, SEEK_CUR);
+		}
+		else if(memcmp(buf, "$SNY", 4)==0)
+		{
+			/* complete buffer, compute checksum */
+			read(fd, buf+16, 16);
+			if(buf[5]<=32 && checksum(buf, buf[5]))
+			{
+				fp+=16;
+				printf("Sony system detected (?).\n");
+			}
+			else
+				lseek(fd, -16, SEEK_CUR);
+		}
+		else if(memcmp(buf, "_32_", 4)==0)
+		{
+			/* complete buffer, reposition file, compute checksum */
+			read(fd, buf+16, 32);
+			lseek(fd, -32, SEEK_CUR);
+			if(buf[9]>=1 && buf[9]<=3 && checksum(buf, buf[9]<<4))
+			{
+				printf("BIOS32 Service Directory present.\n");
+				printf("\tCalling Interface Address: 0x%08X\n",
+					*(u32 *)(buf+4));
+				lseek(fd, (buf[9]-1)<<4, SEEK_CUR);
+				fp+=(buf[9]-1)<<4;
+			}
+		}
+		else if(memcmp(buf, "$PIR", 4)==0)
+		{
+			/* complete buffer, reposition file */
+			read(fd, buf+16, 16);
+			lseek(fd, -16, SEEK_CUR);
+			if(buf[5]!=0 && buf[30]==0)
+			{
+				printf("PCI Interrupt Routing %u.%u present.\n",
+					buf[5], buf[4]);
+				printf("\tTable Size: %u bytes\n",
+					*(u16 *)(buf+6));
+				printf("\tRouter ID: %02x:%02x.%1x\n",
+					buf[8], buf[9]>>3, buf[9]&0x07);
+				printf("\tExclusive IRQs:");
+				pir_exclusive_irqs(*(u16 *)(buf+10));
+				printf("\n");
+				if(*(u32 *)(buf+12)!=0)
+					printf("\tCompatible Router: %04x:%04x\n",
+						*(u16 *)(buf+12), *(u16 *)(buf+14));
+				if(*(u32 *)(buf+16)!=0)
+					printf("\tMiniport Data: 0x%08X\n",
+						*(u32 *)(buf+16));
+			}
+		}
+		fp+=16;
+	}
+
+	if(close(fd)==-1)
+	{
+		perror("/dev/mem");
+		exit(1);
+	}
+
+	return 0;
+}