diff options
Diffstat (limited to 'eeprom')
| -rw-r--r-- | eeprom/Module.mk | 31 | ||||
| -rw-r--r-- | eeprom/README | 22 | ||||
| -rwxr-xr-x | eeprom/ddcmon | 567 | ||||
| -rwxr-xr-x | eeprom/decode-dimms | 1417 | ||||
| -rwxr-xr-x | eeprom/decode-edid | 225 | ||||
| -rwxr-xr-x | eeprom/decode-vaio | 237 | ||||
| -rwxr-xr-x | eeprom/decode-xeon | 197 |
7 files changed, 2696 insertions, 0 deletions
diff --git a/eeprom/Module.mk b/eeprom/Module.mk new file mode 100644 index 0000000..950bee5 --- /dev/null +++ b/eeprom/Module.mk @@ -0,0 +1,31 @@ +# EEPROM decoding scripts for the Linux eeprom driver +# +# Copyright (C) 2007-2008 Jean Delvare <khali@linux-fr.org> +# +# Licensed under the GNU General Public License. + +EEPROM_DIR := eeprom + +EEPROM_TARGETS := decode-dimms decode-vaio ddcmon decode-edid + +# decode-xeon was not yet ported to the Linux 2.6 sysfs interface +ifeq (,$(findstring /2.6., /$(KERNELVERSION))) +EEPROM_TARGETS += decode-xeon +endif + +# +# Commands +# + +install-eeprom: $(addprefix $(EEPROM_DIR)/,$(EEPROM_TARGETS)) + $(INSTALL_DIR) $(DESTDIR)$(bindir) + for program in $(EEPROM_TARGETS) ; do \ + $(INSTALL_PROGRAM) $(EEPROM_DIR)/$$program $(DESTDIR)$(bindir) ; done + +uninstall-eeprom: + for program in $(EEPROM_TARGETS) ; do \ + $(RM) $(DESTDIR)$(bindir)/$$program ; done + +install: install-eeprom + +uninstall: uninstall-eeprom diff --git a/eeprom/README b/eeprom/README new file mode 100644 index 0000000..efca1d0 --- /dev/null +++ b/eeprom/README @@ -0,0 +1,22 @@ +This directory contains scripts to decode the data exposed by the eeprom +Linux kernel driver. + +* decode-dimms (perl script) + Decode the information found in memory module SPD EEPROMs. The SPD + data is read either from the running system or from dump files. + +* decode-vaio (perl script) + Decode the information found in Sony Vaio laptop identification EEPROMs. + +* ddcmon (perl script) + decode-edid (perl script) + Decode the information found in monitor EEPROMs. Both scripts require + an access to the DDC channel of the monitor. This is typically provided + by framebuffer drivers. decode-edid additionally requires parse-edid, + which is part of the read-edid package. ddcmon prints general + information, while decode-edid prints timing information for + inclusion into your X11 configuration file. + +* decode-xeon (perl script) + ID ROM data decoding for Xeon processors. Support for sysfs is still + missing, so this script doesn't work with 2.6 kernels yet. diff --git a/eeprom/ddcmon b/eeprom/ddcmon new file mode 100755 index 0000000..3c3caf0 --- /dev/null +++ b/eeprom/ddcmon @@ -0,0 +1,567 @@ +#!/usr/bin/perl -w +# +# Copyright (C) 2004-2005 Jean Delvare <khali@linux-fr.org> +# +# Parts inspired from decode-edid. +# Copyright (C) 2003-2004 Jean Delvare <khali@linux-fr.org> +# +# Parts inspired from the ddcmon driver and sensors' print_ddcmon function. +# Copyright (C) 1998-2004 Mark D. Studebaker +# +# Parts inspired from the fbmon driver (Linux 2.6.10). +# Copyright (C) 2002 James Simmons <jsimmons@users.sf.net> +# +# 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., 51 Franklin Street, Fifth Floor, Boston, +# MA 02110-1301 USA. +# +# Version 1.0 2005-01-04 Jean Delvare <khali@linux-fr.org> +# +# This script is a replacement for the now deprecated ddcmon kernel driver. +# Instead of having a dedicated driver, it is better to reuse the standard +# eeprom driver and implement the EDID-specific code in user-space. +# +# EDID (Extended Display Identification Data) is a VESA standard which +# allows storing (on manufacturer's side) and retrieving (on user's side) +# of configuration information about displays, such as manufacturer, +# serial number, physical dimensions and allowed horizontal and vertical +# refresh rates. +# +# Syntax: ddcmon [bus [address]] +# Address can be given in decimal or hexadecimal (with a 0x prefix). +# If no address is given, default is 0x50. +# Bus number must be given in decimal. If no bus number is given, +# try them all. + +use strict; +use Fcntl qw(:DEFAULT :seek); +use vars qw(@standard_scales); + +@standard_scales = ([1, 1], [3, 4], [4, 5], [16, 9]); + +# Make sure the eeprom module is loaded. +# For non-modular kernels, we can't help. +if (-r '/proc/modules') +{ + my $found = 0; + open(MODULES, '/proc/modules'); + while (!$found && defined ($_ = <MODULES>)) + { + $found++ if m/^eeprom\s+/; + } + close(MODULES); + + unless ($found) + { + print STDERR + "This script requires the eeprom module to be loaded.\n"; + exit 1; + } +} + +# Only used for sysfs +sub rawread +{ + my $filename = shift; + my $length = shift; + my $offset = shift || 0; + my $bytes = ''; + + sysopen(FH, $filename, O_RDONLY) + or die "Can't open $filename"; + if ($offset) + { + sysseek(FH, $offset, SEEK_SET) + or die "Can't seek in $filename"; + } + + $offset = 0; + while ($length) + { + my $r = sysread(FH, $bytes, $length, $offset); + die "Can't read $filename" + unless defined($r); + die "Unexpected EOF in $filename" + unless $r; + $offset += $r; + $length -= $r; + } + close(FH); + + return $bytes; +} + +sub get_edid_sysfs +{ + my ($bus, $addr) = @_; + + my @bytes = unpack("C*", rawread("/sys/bus/i2c/devices/$bus-00$addr/eeprom", 128)); + + return \@bytes; +} + +sub get_edid_procfs +{ + my ($bus, $addr) = @_; + + my @bytes; + + for (my $i = 0 ; $i < 0x80; $i += 0x10) + { + my $filename = sprintf("/proc/sys/dev/sensors/eeprom-i2c-\%s-\%s/\%02x", + $bus, $addr, $i); + open(EEDATA, $filename) + or die "Can't read $filename"; + push @bytes, split(/\s+/, <EEDATA>); + close(EEDATA); + } + + return \@bytes; +} + +sub print_line +{ + my $label = shift; + my $pattern = shift; + + printf("\%-24s$pattern\n", $label.':', @_); +} + +sub extract_byte +{ + my ($bytes, $offset) = @_; + + return $bytes->[$offset]; +} + +sub extract_word +{ + my ($bytes, $offset) = @_; + + return ($bytes->[$offset] + | ($bytes->[$offset+1] << 8)); +} + +sub extract_manufacturer +{ + my ($bytes, $offset) = @_; + my $i = ($bytes->[$offset+1] | ($bytes->[$offset] << 8)); + + return sprintf('%c%c%c', + (($i >> 10) & 0x1f) + ord('A') - 1, + (($i >> 5) & 0x1f) + ord('A') - 1, + ($i & 0x1f) + ord('A') - 1); +} + +sub extract_sesquiword +{ + my ($bytes, $offset) = @_; + + return ($bytes->[$offset] + | ($bytes->[$offset+1] << 8) + | ($bytes->[$offset+2] << 16)); +} + +sub extract_dword +{ + my ($bytes, $offset) = @_; + + return ($bytes->[$offset] + | ($bytes->[$offset+1] << 8) + | ($bytes->[$offset+2] << 16) + | ($bytes->[$offset+3] << 24)); +} + +sub extract_display_input +{ + my ($bytes, $offset) = @_; + + my @voltage = ('0.700V/0.300V', '0.714V/0.286V', + '1.000V/0.400V', '0.700V/0.000V'); + + return 'Digital' + if ($bytes->[$offset] & 0x80); + + return 'Analog ('.$voltage[($bytes->[$offset] & 0x60) >> 5].')'; +} + +sub extract_dpms +{ + my ($bytes, $offset) = @_; + + my @supported; + + push @supported, 'Active Off' if ($bytes->[$offset] & 0x20); + push @supported, 'Suspend' if ($bytes->[$offset] & 0x40); + push @supported, 'Standby' if ($bytes->[$offset] & 0x80); + + return join(', ', @supported) + if (@supported); + + return 'None supported'; +} + +sub extract_color_mode +{ + my ($bytes, $offset) = @_; + + my @mode = ('Monochrome', 'RGB Multicolor', 'Non-RGB Multicolor'); + + return $mode[($bytes->[$offset] >> 3) & 0x03]; +} + +sub good_signature +{ + my $bytes = shift; + + return $bytes->[0] == 0x00 + && $bytes->[1] == 0xff + && $bytes->[2] == 0xff + && $bytes->[3] == 0xff + && $bytes->[4] == 0xff + && $bytes->[5] == 0xff + && $bytes->[6] == 0xff + && $bytes->[7] == 0x00; +} + +sub verify_checksum +{ + my $bytes = shift; + my $cs; + + for (my $i = 0, $cs = 0; $i < 0x80; $i++) + { + $cs += $bytes->[$i]; + } + + return (($cs & 0xff) == 0 ? 'OK' : 'Not OK'); +} + +sub add_timing +{ + my ($timings, $new) = @_; + + my $mode = sprintf('%ux%u@%u%s', $new->[0], $new->[1], + $new->[2], defined ($new->[3]) && + $new->[3] eq 'interlaced' ? 'i' : ''); + + $timings->{$mode} = $new; +} + +sub add_standard_timing +{ + my ($timings, $byte0, $byte1) = @_; + + # Unused slot + return if ($byte0 == $byte1) + && ($byte0 == 0x01 || $byte0 == 0x00 || $byte0 == 0x20); + + my $width = ($byte0 + 31) * 8; + my $height = $width * $standard_scales[$byte1 >> 6]->[0] + / $standard_scales[$byte1 >> 6]->[1]; + my $refresh = 60 + ($byte1 & 0x3f); + + add_timing($timings, [$width, $height, $refresh]); +} + +sub sort_timings +{ + # First order by width + return -1 if $a->[0] < $b->[0]; + return 1 if $a->[0] > $b->[0]; + + # Second by height + return -1 if $a->[1] < $b->[1]; + return 1 if $a->[1] > $b->[1]; + + # Third by frequency + # Interlaced modes count for half their frequency + my $freq_a = $a->[2]; + my $freq_b = $b->[2]; + $freq_a /= 2 if defined $a->[3] && $a->[3] eq 'interlaced'; + $freq_b /= 2 if defined $b->[3] && $b->[3] eq 'interlaced'; + return -1 if $freq_a < $freq_b; + return 1 if $freq_a > $freq_b; + + return 0; +} + +sub print_timings +{ + my ($bytes, $timings) = @_; + + # Established Timings + my @established = + ( + [720, 400, 70], + [720, 400, 88], + [640, 480, 60], + [640, 480, 67], + [640, 480, 72], + [640, 480, 75], + [800, 600, 56], + [800, 600, 60], + [800, 600, 72], + [800, 600, 75], + [832, 624, 75], + [1024, 768, 87, 'interlaced'], + [1024, 768, 60], + [1024, 768, 70], + [1024, 768, 75], + [1280, 1024, 75], + undef, undef, undef, + [1152, 870, 75], + ); + my $temp = extract_sesquiword($bytes, 0x23); + for (my $i = 0; $i < 24; $i++) + { + next unless defined($established[$i]); + add_timing($timings, $established[$i]) + if ($temp & (1 << $i)); + } + + # Standard Timings + for (my $i = 0x26; $i < 0x36; $i += 2) + { + add_standard_timing($timings, $bytes->[$i], $bytes->[$i+1]); + } + + foreach my $v (sort sort_timings values(%{$timings})) + { + print_line("Timing", '%ux%u @ %u Hz%s', + $v->[0], $v->[1], $v->[2], + defined($v->[3]) ? ' ('.$v->[3].')' : ''); + } +} + +sub extract_string +{ + my ($bytes, $offset) = @_; + my $string = ''; + + for (my $i = 5; $i < 18; $i++) + { + last if $bytes->[$offset+$i] == 0x0a + || $bytes->[$offset+$i] == 0x00; + $string .= chr($bytes->[$offset+$i]) + if ($bytes->[$offset+$i] >= 32 + && $bytes->[$offset+$i] < 127); + } + $string =~ s/\s+$//; + + return $string; +} + +# Some blocks contain different information: +# 0x00, 0x00, 0x00, 0xfa: Additional standard timings block +# 0x00, 0x00, 0x00, 0xfc: Monitor block +# 0x00, 0x00, 0x00, 0xfd: Limits block +# 0x00, 0x00, 0x00, 0xfe: Ascii block +# 0x00, 0x00, 0x00, 0xff: Serial block +# Return a reference to a hash containing all information. +sub extract_detailed_timings +{ + my ($bytes) = @_; + + my %info = ('timings' => {}); + + for (my $offset = 0x36; $offset < 0x7e; $offset += 18) + { + if ($bytes->[$offset] == 0x00 + && $bytes->[$offset+1] == 0x00 + && $bytes->[$offset+2] == 0x00 + && $bytes->[$offset+4] == 0x00) + { + if ($bytes->[$offset+3] == 0xfa) + { + for (my $i = $offset + 5; $i < $offset + 17; $i += 2) + { + add_standard_timing($info{'timings'}, + $bytes->[$i], + $bytes->[$i+1]); + } + } + + elsif ($bytes->[$offset+3] == 0xfc) + { + $info{'monitor'} .= extract_string($bytes, $offset); + } + + elsif ($bytes->[$offset+3] == 0xfd) + { + $info{'limits'}{'vsync_min'} = $bytes->[$offset+5]; + $info{'limits'}{'vsync_max'} = $bytes->[$offset+6]; + $info{'limits'}{'hsync_min'} = $bytes->[$offset+7]; + $info{'limits'}{'hsync_max'} = $bytes->[$offset+8]; + $info{'limits'}{'clock_max'} = $bytes->[$offset+9]; + } + + elsif ($bytes->[$offset+3] == 0xfe) + { + $info{'ascii'} .= extract_string($bytes, $offset); + } + + elsif ($bytes->[$offset+3] == 0xff) + { + $info{'serial'} .= extract_string($bytes, $offset); + } + + next; + } + + # Detailed Timing + my $width = $bytes->[$offset+2] + (($bytes->[$offset+4] & 0xf0) << 4); + my $height = $bytes->[$offset+5] + (($bytes->[$offset+7] & 0xf0) << 4); + my $clock = extract_word($bytes, $offset) * 10000; + my $hblank = $bytes->[$offset+3] + (($bytes->[$offset+4] & 0x0f) << 8); + my $vblank = $bytes->[$offset+6] + (($bytes->[$offset+7] & 0x0f) << 8); + my $area = ($width + $hblank) * ($height + $vblank); + next unless $area; # Should not happen, but... + my $refresh = ($clock + $area / 2) / $area; # Proper rounding + add_timing($info{'timings'}, [$width, $height, $refresh]); + } + + return \%info; +} + +sub print_edid +{ + my ($bus, $address) = @_; + my $bytes; + + if (-r "/sys/bus/i2c/devices/$bus-00$address/eeprom") + { + $bytes = get_edid_sysfs($bus, $address); + } + elsif (-r "/proc/sys/dev/sensors/eeprom-i2c-$bus-$address/00") + { + $bytes = get_edid_procfs($bus, $address); + } + + return 1 unless defined $bytes; + return 2 unless good_signature($bytes); + + print_line('Checksum', '%s', verify_checksum($bytes)); + my $edid_version = extract_byte($bytes, 0x12); + my $edid_revision = extract_byte($bytes, 0x13); + print_line('EDID Version', '%u.%u', $edid_version, + $edid_revision); + if ($edid_version > 1 || $edid_revision > 2) + { + $standard_scales[0][0] = 16; + $standard_scales[0][1] = 10; + } + else + { + $standard_scales[0][0] = 1; + $standard_scales[0][1] = 1; + } + + my $info = extract_detailed_timings($bytes); + + print_line('Manufacturer ID', '%s', extract_manufacturer($bytes, 0x08)); + print_line('Model Number', '0x%04X', extract_word($bytes, 0x0A)); + print_line('Model Name', '%s', $info->{'monitor'}) + if defined $info->{'monitor'}; + + if ($info->{'serial'}) + { + print_line('Serial Number', '%s', $info->{'serial'}) + } + elsif ((my $temp = extract_dword($bytes, 0x0C))) + { + print_line('Serial Number', '%u', $temp) + } + + print_line('Manufacture Time', '%u-W%02u', + 1990 + extract_byte($bytes, 0x11), + extract_byte($bytes, 0x10)); + print_line('Display Input', '%s', extract_display_input($bytes, 0x14)); + print_line('Monitor Size (cm)', '%ux%u', extract_byte($bytes, 0x15), + extract_byte($bytes, 0x16)); + print_line('Gamma Factor', '%.2f', + 1 + extract_byte($bytes, 0x17) / 100.0); + print_line('DPMS Modes', '%s', extract_dpms($bytes, 0x18)); + print_line('Color Mode', '%s', extract_color_mode($bytes, 0x18)) + if (($bytes->[0x18] & 0x18) != 0x18); + print_line('Additional Info', '%s', $info->{'ascii'}) + if $info->{'ascii'}; + + if (defined($info->{'limits'})) + { + print_line('Vertical Sync (Hz)', '%u-%u', + $info->{'limits'}{'vsync_min'}, + $info->{'limits'}{'vsync_max'}); + print_line('Horizontal Sync (kHz)', '%u-%u', + $info->{'limits'}{'hsync_min'}, + $info->{'limits'}{'hsync_max'}); + print_line('Max Pixel Clock (MHz)', '%u', + $info->{'limits'}{'clock_max'} * 10) + unless $info->{'limits'}{'clock_max'} == 0xff; + } + + print_timings($bytes, $info->{'timings'}); + print("\n"); + return 0; +} + +# Get the address. Default to 0x50 if not given. +my $address; +if (defined($ARGV[1])) +{ + $address = $ARGV[1]; + # Convert to decimal, whatever the value. + $address = oct $address if $address =~ m/^0/; + # Convert to an hexadecimal string. + $address = sprintf '%02x', $address; +} +else +{ + $address = '50'; +} + +if (defined($ARGV[0])) +{ + my $error = print_edid($ARGV[0], $address); + + if ($error == 1) + { + print STDERR + "No EEPROM found at 0x$address on bus $ARGV[0].\n"; + exit 1; + } + elsif ($error == 2) + { + print STDERR + "EEPROM found at 0x$address on bus $ARGV[0], but is not an EDID EEPROM.\n"; + exit 1; + } +} +# If no bus is given, try them all. +else +{ + my $total = 0; + + for (my $i = 0; $i < 16; $i++) + { + $total++ unless print_edid($i, $address); + } + + unless ($total) + { + print STDERR + "No EDID EEPROM found.\n"; + exit 1; + } +} diff --git a/eeprom/decode-dimms b/eeprom/decode-dimms new file mode 100755 index 0000000..cf9cebf --- /dev/null +++ b/eeprom/decode-dimms @@ -0,0 +1,1417 @@ +#!/usr/bin/perl -w +# +# EEPROM data decoder for SDRAM DIMM modules +# +# Copyright 1998, 1999 Philip Edelbrock <phil@netroedge.com> +# modified by Christian Zuckschwerdt <zany@triq.net> +# modified by Burkart Lingner <burkart@bollchen.de> +# Copyright (C) 2005-2008 Jean Delvare <khali@linux-fr.org> +# +# 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., 51 Franklin Street, Fifth Floor, Boston, +# MA 02110-1301 USA. +# +# +# The eeprom driver must be loaded (unless option -x is used). For kernels +# older than 2.6.0, the eeprom driver can be found in the lm-sensors package. +# +# References: +# PC SDRAM Serial Presence +# Detect (SPD) Specification, Intel, +# 1997,1999, Rev 1.2B +# +# Jedec Standards 4.1.x & 4.5.x +# http://www.jedec.org +# + +require 5.004; + +use strict; +use POSIX qw(ceil); +use Fcntl qw(:DEFAULT :seek); +use vars qw($opt_html $opt_bodyonly $opt_igncheck $use_sysfs $use_hexdump + @vendors %decode_callback $revision @dimm_list %hexdump_cache); + +use constant LITTLEENDIAN => "little-endian"; +use constant BIGENDIAN => "big-endian"; + +$revision = '$Revision: 5388 $ ($Date: 2008-11-18 18:15:09 +0100 (mar. 18 nov. 2008) $)'; +$revision =~ s/\$\w+: (.*?) \$/$1/g; +$revision =~ s/ \([^()]*\)//; + +@vendors = ( +["AMD", "AMI", "Fairchild", "Fujitsu", + "GTE", "Harris", "Hitachi", "Inmos", + "Intel", "I.T.T.", "Intersil", "Monolithic Memories", + "Mostek", "Freescale (former Motorola)", "National", "NEC", + "RCA", "Raytheon", "Conexant (Rockwell)", "Seeq", + "NXP (former Signetics, Philips Semi.)", "Synertek", "Texas Instruments", "Toshiba", + "Xicor", "Zilog", "Eurotechnique", "Mitsubishi", + "Lucent (AT&T)", "Exel", "Atmel", "SGS/Thomson", + "Lattice Semi.", "NCR", "Wafer Scale Integration", "IBM", + "Tristar", "Visic", "Intl. CMOS Technology", "SSSI", + "MicrochipTechnology", "Ricoh Ltd.", "VLSI", "Micron Technology", + "Hyundai Electronics", "OKI Semiconductor", "ACTEL", "Sharp", + "Catalyst", "Panasonic", "IDT", "Cypress", + "DEC", "LSI Logic", "Zarlink (former Plessey)", "UTMC", + "Thinking Machine", "Thomson CSF", "Integrated CMOS (Vertex)", "Honeywell", + "Tektronix", "Sun Microsystems", "SST", "ProMos/Mosel Vitelic", + "Infineon (former Siemens)", "Macronix", "Xerox", "Plus Logic", + "SunDisk", "Elan Circuit Tech.", "European Silicon Str.", "Apple Computer", + "Xilinx", "Compaq", "Protocol Engines", "SCI", + "Seiko Instruments", "Samsung", "I3 Design System", "Klic", + "Crosspoint Solutions", "Alliance Semiconductor", "Tandem", "Hewlett-Packard", + "Intg. Silicon Solutions", "Brooktree", "New Media", "MHS Electronic", + "Performance Semi.", "Winbond Electronic", "Kawasaki Steel", "Bright Micro", + "TECMAR", "Exar", "PCMCIA", "LG Semi (former Goldstar)", + "Northern Telecom", "Sanyo", "Array Microsystems", "Crystal Semiconductor", + "Analog Devices", "PMC-Sierra", "Asparix", "Convex Computer", + "Quality Semiconductor", "Nimbus Technology", "Transwitch", "Micronas (ITT Intermetall)", + "Cannon", "Altera", "NEXCOM", "QUALCOMM", + "Sony", "Cray Research", "AMS(Austria Micro)", "Vitesse", + "Aster Electronics", "Bay Networks (Synoptic)", "Zentrum or ZMD", "TRW", + "Thesys", "Solbourne Computer", "Allied-Signal", "Dialog", + "Media Vision", "Level One Communication"], +["Cirrus Logic", "National Instruments", "ILC Data Device", "Alcatel Mietec", + "Micro Linear", "Univ. of NC", "JTAG Technologies", "BAE Systems", + "Nchip", "Galileo Tech", "Bestlink Systems", "Graychip", + "GENNUM", "VideoLogic", "Robert Bosch", "Chip Express", + "DATARAM", "United Microelec Corp.", "TCSI", "Smart Modular", + "Hughes Aircraft", "Lanstar Semiconductor", "Qlogic", "Kingston", + "Music Semi", "Ericsson Components", "SpaSE", "Eon Silicon Devices", + "Programmable Micro Corp", "DoD", "Integ. Memories Tech.", "Corollary Inc.", + "Dallas Semiconductor", "Omnivision", "EIV(Switzerland)", "Novatel Wireless", + "Zarlink (former Mitel)", "Clearpoint", "Cabletron", "STEC (former Silicon Technology)", + "Vanguard", "Hagiwara Sys-Com", "Vantis", "Celestica", + "Century", "Hal Computers", "Rohm Company Ltd.", "Juniper Networks", + "Libit Signal Processing", "Mushkin Enhanced Memory", "Tundra Semiconductor", "Adaptec Inc.", + "LightSpeed Semi.", "ZSP Corp.", "AMIC Technology", "Adobe Systems", + "Dynachip", "PNY Electronics", "Newport Digital", "MMC Networks", + "T Square", "Seiko Epson", "Broadcom", "Viking Components", + "V3 Semiconductor", "Flextronics (former Orbit)", "Suwa Electronics", "Transmeta", + "Micron CMS", "American Computer & Digital Components Inc", "Enhance 3000 Inc", "Tower Semiconductor", + "CPU Design", "Price Point", "Maxim Integrated Product", "Tellabs", + "Centaur Technology", "Unigen Corporation", "Transcend Information", "Memory Card Technology", + "CKD Corporation Ltd.", "Capital Instruments, Inc.", "Aica Kogyo, Ltd.", "Linvex Technology", + "MSC Vertriebs GmbH", "AKM Company, Ltd.", "Dynamem, Inc.", "NERA ASA", + "GSI Technology", "Dane-Elec (C Memory)", "Acorn Computers", "Lara Technology", + "Oak Technology, Inc.", "Itec Memory", "Tanisys Technology", "Truevision", + "Wintec Industries", "Super PC Memory", "MGV Memory", "Galvantech", + "Gadzoox Nteworks", "Multi Dimensional Cons.", "GateField", "Integrated Memory System", + "Triscend", "XaQti", "Goldenram", "Clear Logic", + "Cimaron Communications", "Nippon Steel Semi. Corp.", "Advantage Memory", "AMCC", + "LeCroy", "Yamaha Corporation", "Digital Microwave", "NetLogic Microsystems", + "MIMOS Semiconductor", "Advanced Fibre", "BF Goodrich Data.", "Epigram", + "Acbel Polytech Inc.", "Apacer Technology", "Admor Memory", "FOXCONN", + "Quadratics Superconductor", "3COM"], +["Camintonn Corporation", "ISOA Incorporated", "Agate Semiconductor", "ADMtek Incorporated", + "HYPERTEC", "Adhoc Technologies", "MOSAID Technologies", "Ardent Technologies", + "Switchcore", "Cisco Systems, Inc.", "Allayer Technologies", "WorkX AG", + "Oasis Semiconductor", "Novanet Semiconductor", "E-M Solutions", "Power General", + "Advanced Hardware Arch.", "Inova Semiconductors GmbH", "Telocity", "Delkin Devices", + "Symagery Microsystems", "C-Port Corporation", "SiberCore Technologies", "Southland Microsystems", + "Malleable Technologies", "Kendin Communications", "Great Technology Microcomputer", "Sanmina Corporation", + "HADCO Corporation", "Corsair", "Actrans System Inc.", "ALPHA Technologies", + "Silicon Laboratories, Inc. (Cygnal)", "Artesyn Technologies", "Align Manufacturing", "Peregrine Semiconductor", + "Chameleon Systems", "Aplus Flash Technology", "MIPS Technologies", "Chrysalis ITS", + "ADTEC Corporation", "Kentron Technologies", "Win Technologies", "Tachyon Semiconductor (former ASIC Designs Inc.)", + "Extreme Packet Devices", "RF Micro Devices", "Siemens AG", "Sarnoff Corporation", + "Itautec Philco SA", "Radiata Inc.", "Benchmark Elect. (AVEX)", "Legend", + "SpecTek Incorporated", "Hi/fn", "Enikia Incorporated", "SwitchOn Networks", + "AANetcom Incorporated", "Micro Memory Bank", "ESS Technology", "Virata Corporation", + "Excess Bandwidth", "West Bay Semiconductor", "DSP Group", "Newport Communications", + "Chip2Chip Incorporated", "Phobos Corporation", "Intellitech Corporation", "Nordic VLSI ASA", + "Ishoni Networks", "Silicon Spice", "Alchemy Semiconductor", "Agilent Technologies", + "Centillium Communications", "W.L. Gore", "HanBit Electronics", "GlobeSpan", + "Element 14", "Pycon", "Saifun Semiconductors", "Sibyte, Incorporated", + "MetaLink Technologies", "Feiya Technology", "I & C Technology", "Shikatronics", + "Elektrobit", "Megic", "Com-Tier", "Malaysia Micro Solutions", + "Hyperchip", "Gemstone Communications", "Anadigm (former Anadyne)", "3ParData", + "Mellanox Technologies", "Tenx Technologies", "Helix AG", "Domosys", + "Skyup Technology", "HiNT Corporation", "Chiaro", "MDT Technologies GmbH (former MCI Computer GMBH)", + "Exbit Technology A/S", "Integrated Technology Express", "AVED Memory", "Legerity", + "Jasmine Networks", "Caspian Networks", "nCUBE", "Silicon Access Networks", + "FDK Corporation", "High Bandwidth Access", "MultiLink Technology", "BRECIS", + "World Wide Packets", "APW", "Chicory Systems", "Xstream Logic", + "Fast-Chip", "Zucotto Wireless", "Realchip", "Galaxy Power", + "eSilicon", "Morphics Technology", "Accelerant Networks", "Silicon Wave", + "SandCraft", "Elpida"], +["Solectron", "Optosys Technologies", "Buffalo (former Melco)", "TriMedia Technologies", + "Cyan Technologies", "Global Locate", "Optillion", "Terago Communications", + "Ikanos Communications", "Princeton Technology", "Nanya Technology", "Elite Flash Storage", + "Mysticom", "LightSand Communications", "ATI Technologies", "Agere Systems", + "NeoMagic", "AuroraNetics", "Golden Empire", "Mushkin", + "Tioga Technologies", "Netlist", "TeraLogic", "Cicada Semiconductor", + "Centon Electronics", "Tyco Electronics", "Magis Works", "Zettacom", + "Cogency Semiconductor", "Chipcon AS", "Aspex Technology", "F5 Networks", + "Programmable Silicon Solutions", "ChipWrights", "Acorn Networks", "Quicklogic", + "Kingmax Semiconductor", "BOPS", "Flasys", "BitBlitz Communications", + "eMemory Technology", "Procket Networks", "Purple Ray", "Trebia Networks", + "Delta Electronics", "Onex Communications", "Ample Communications", "Memory Experts Intl", + "Astute Networks", "Azanda Network Devices", "Dibcom", "Tekmos", + "API NetWorks", "Bay Microsystems", "Firecron Ltd", "Resonext Communications", + "Tachys Technologies", "Equator Technology", "Concept Computer", "SILCOM", + "3Dlabs", "c't Magazine", "Sanera Systems", "Silicon Packets", + "Viasystems Group", "Simtek", "Semicon Devices Singapore", "Satron Handelsges", + "Improv Systems", "INDUSYS GmbH", "Corrent", "Infrant Technologies", + "Ritek Corp", "empowerTel Networks", "Hypertec", "Cavium Networks", + "PLX Technology", "Massana Design", "Intrinsity", "Valence Semiconductor", + "Terawave Communications", "IceFyre Semiconductor", "Primarion", "Picochip Designs Ltd", + "Silverback Systems", "Jade Star Technologies", "Pijnenburg Securealink", + "TakeMS International AG", "Cambridge Silicon Radio", + "Swissbit", "Nazomi Communications", "eWave System", + "Rockwell Collins", "Picocel Co., Ltd.", "Alphamosaic Ltd", "Sandburst", + "SiCon Video", "NanoAmp Solutions", "Ericsson Technology", "PrairieComm", + "Mitac International", "Layer N Networks", "MtekVision", "Allegro Networks", + "Marvell Semiconductors", "Netergy Microelectronic", "NVIDIA", "Internet Machines", + "Peak Electronics", "Litchfield Communication", "Accton Technology", "Teradiant Networks", + "Europe Technologies", "Cortina Systems", "RAM Components", "Raqia Networks", + "ClearSpeed", "Matsushita Battery", "Xelerated", "SimpleTech", + "Utron Technology", "Astec International", "AVM gmbH", "Redux Communications", + "Dot Hill Systems", "TeraChip"], +["T-RAM Incorporated", "Innovics Wireless", "Teknovus", "KeyEye Communications", + "Runcom Technologies", "RedSwitch", "Dotcast", "Silicon Mountain Memory", + "Signia Technologies", "Pixim", "Galazar Networks", "White Electronic Designs", + "Patriot Scientific", "Neoaxiom Corporation", "3Y Power Technology", "Europe Technologies", + "Potentia Power Systems", "C-guys Incorporated", "Digital Communications Technology Incorporated", "Silicon-Based Technology", + "Fulcrum Microsystems", "Positivo Informatica Ltd", "XIOtech Corporation", "PortalPlayer", + "Zhiying Software", "Direct2Data", "Phonex Broadband", "Skyworks Solutions", + "Entropic Communications", "Pacific Force Technology", "Zensys A/S", "Legend Silicon Corp.", + "sci-worx GmbH", "SMSC (former Oasis Silicon Systems)", "Renesas Technology", "Raza Microelectronics", + "Phyworks", "MediaTek", "Non-cents Productions", "US Modular", + "Wintegra Ltd", "Mathstar", "StarCore", "Oplus Technologies", + "Mindspeed", "Just Young Computer", "Radia Communications", "OCZ", + "Emuzed", "LOGIC Devices", "Inphi Corporation", "Quake Technologies", + "Vixel", "SolusTek", "Kongsberg Maritime", "Faraday Technology", + "Altium Ltd.", "Insyte", "ARM Ltd.", "DigiVision", + "Vativ Technologies", "Endicott Interconnect Technologies", "Pericom", "Bandspeed", + "LeWiz Communications", "CPU Technology", "Ramaxel Technology", "DSP Group", + "Axis Communications", "Legacy Electronics", "Chrontel", "Powerchip Semiconductor", + "MobilEye Technologies", "Excel Semiconductor", "A-DATA Technology", "VirtualDigm", + "G Skill Intl", "Quanta Computer", "Yield Microelectronics", "Afa Technologies", + "KINGBOX Technology Co. Ltd.", "Ceva", "iStor Networks", "Advance Modules", + "Microsoft", "Open-Silicon", "Goal Semiconductor", "ARC International", + "Simmtec", "Metanoia", "Key Stream", "Lowrance Electronics", + "Adimos", "SiGe Semiconductor", "Fodus Communications", "Credence Systems Corp.", + "Genesis Microchip Inc.", "Vihana, Inc.", "WIS Technologies", "GateChange Technologies", + "High Density Devices AS", "Synopsys", "Gigaram", "Enigma Semiconductor Inc.", + "Century Micro Inc.", "Icera Semiconductor", "Mediaworks Integrated Systems", "O'Neil Product Development", + "Supreme Top Technology Ltd.", "MicroDisplay Corporation", "Team Group Inc.", "Sinett Corporation", + "Toshiba Corporation", "Tensilica", "SiRF Technology", "Bacoc Inc.", + "SMaL Camera Technologies", "Thomson SC", "Airgo Networks", "Wisair Ltd.", + "SigmaTel", "Arkados", "Compete IT gmbH Co. KG", "Eudar Technology Inc.", + "Focus Enhancements", "Xyratex"], +["Specular Networks", "Patriot Memory", "U-Chip Technology Corp.", "Silicon Optix", + "Greenfield Networks", "CompuRAM GmbH", "Stargen, Inc.", "NetCell Corporation", + "Excalibrus Technologies Ltd", "SCM Microsystems", "Xsigo Systems, Inc.", "CHIPS & Systems Inc", + "Tier 1 Multichip Solutions", "CWRL Labs", "Teradici", "Gigaram, Inc.", + "g2 Microsystems", "PowerFlash Semiconductor", "P.A. Semi, Inc.", "NovaTech Solutions, S.A.", + "c2 Microsystems, Inc.", "Level5 Networks", "COS Memory AG", "Innovasic Semiconductor", + "02IC Co. Ltd", "Tabula, Inc.", "Crucial Technology", "Chelsio Communications", + "Solarflare Communications", "Xambala Inc.", "EADS Astrium", "ATO Semicon Co. Ltd.", + "Imaging Works, Inc.", "Astute Networks, Inc.", "Tzero", "Emulex", + "Power-One", "Pulse~LINK Inc.", "Hon Hai Precision Industry", "White Rock Networks Inc.", + "Telegent Systems USA, Inc.", "Atrua Technologies, Inc.", "Acbel Polytech Inc.", + "eRide Inc.","ULi Electronics Inc.", "Magnum Semiconductor Inc.", "neoOne Technology, Inc.", + "Connex Technology, Inc.", "Stream Processors, Inc.", "Focus Enhancements", "Telecis Wireless, Inc.", + "uNav Microelectronics", "Tarari, Inc.", "Ambric, Inc.", "Newport Media, Inc.", "VMTS", + "Enuclia Semiconductor, Inc.", "Virtium Technology Inc.", "Solid State System Co., Ltd.", "Kian Tech LLC", + "Artimi", "Power Quotient International", "Avago Technologies", "ADTechnology", "Sigma Designs", + "SiCortex, Inc.", "Ventura Technology Group", "eASIC", "M.H.S. SAS", "Micro Star International", + "Rapport Inc.", "Makway International", "Broad Reach Engineering Co.", + "Semiconductor Mfg Intl Corp", "SiConnect", "FCI USA Inc.", "Validity Sensors", + "Coney Technology Co. Ltd.", "Spans Logic", "Neterion Inc.", "Qimonda", + "New Japan Radio Co. Ltd.", "Velogix", "Montalvo Systems", "iVivity Inc.", "Walton Chaintech", + "AENEON", "Lorom Industrial Co. Ltd.", "Radiospire Networks", "Sensio Technologies, Inc.", + "Nethra Imaging", "Hexon Technology Pte Ltd", "CompuStocx (CSX)", "Methode Electronics, Inc.", + "Connect One Ltd.", "Opulan Technologies", "Septentrio NV", "Goldenmars Technology Inc.", + "Kreton Corporation", "Cochlear Ltd.", "Altair Semiconductor", "NetEffect, Inc.", + "Spansion, Inc.", "Taiwan Semiconductor Mfg", "Emphany Systems Inc.", + "ApaceWave Technologies", "Mobilygen Corporation", "Tego", "Cswitch Corporation", + "Haier (Beijing) IC Design Co.", "MetaRAM", "Axel Electronics Co. Ltd.", "Tilera Corporation", + "Aquantia", "Vivace Semiconductor", "Redpine Signals", "Octalica", "InterDigital Communications", + "Avant Technology", "Asrock, Inc.", "Availink", "Quartics, Inc.", "Element CXI", + "Innovaciones Microelectronicas", "VeriSilicon Microelectronics", "W5 Networks"], +["MOVEKING", "Mavrix Technology, Inc.", "CellGuide Ltd.", "Faraday Technology", + "Diablo Technologies, Inc.", "Jennic", "Octasic", "Molex Incorporated", "3Leaf Networks", + "Bright Micron Technology", "Netxen", "NextWave Broadband Inc.", "DisplayLink", "ZMOS Technology", + "Tec-Hill", "Multigig, Inc.", "Amimon", "Euphonic Technologies, Inc.", "BRN Phoenix", + "InSilica", "Ember Corporation", "Avexir Technologies Corporation", "Echelon Corporation", + "Edgewater Computer Systems", "XMOS Semiconductor Ltd.", "GENUSION, Inc.", "Memory Corp NV", + "SiliconBlue Technologies", "Rambus Inc."]); + +$use_sysfs = -d '/sys/bus'; + +# We consider that no data was written to this area of the SPD EEPROM if +# all bytes read 0x00 or all bytes read 0xff +sub spd_written(@) +{ + my $all_00 = 1; + my $all_ff = 1; + + foreach my $b (@_) { + $all_00 = 0 unless $b == 0x00; + $all_ff = 0 unless $b == 0xff; + return 1 unless $all_00 or $all_ff; + } + + return 0; +} + +sub parity($) +{ + my $n = shift; + my $parity = 0; + + while ($n) { + $parity++ if ($n & 1); + $n >>= 1; + } + + return ($parity & 1); +} + +sub manufacturer(@) +{ + my @bytes = @_; + my $ai = 0; + my $first; + + return ("Undefined", []) unless spd_written(@bytes); + + while (defined($first = shift(@bytes)) && $first == 0x7F) { + $ai++; + } + + return ("Invalid", []) unless defined $first; + return ("Invalid", [$first, @bytes]) if parity($first) != 1; + return ("Unknown", \@bytes) unless (($first & 0x7F) - 1 <= $vendors[$ai]); + + return ($vendors[$ai][($first & 0x7F) - 1], \@bytes); +} + +sub manufacturer_data(@) +{ + my $hex = ""; + my $asc = ""; + + return unless spd_written(@_); + + foreach my $byte (@_) { + $hex .= sprintf("\%02X ", $byte); + $asc .= ($byte >= 32 && $byte < 127) ? chr($byte) : '?'; + } + + return "$hex(\"$asc\")"; +} + +sub part_number(@) +{ + my $asc = ""; + my $byte; + + while (defined ($byte = shift) && $byte >= 32 && $byte < 127) { + $asc .= chr($byte); + } + + return ($asc eq "") ? "Undefined" : $asc; +} + +sub cas_latencies(@) +{ + return "None" unless @_; + return join ', ', map("${_}T", sort { $b <=> $a } @_); +} + +sub printl($$) # print a line w/ label and value +{ + my ($label, $value) = @_; + if ($opt_html) { + $label =~ s/</\</sg; + $label =~ s/>/\>/sg; + $label =~ s/\n/<br>\n/sg; + $value =~ s/</\</sg; + $value =~ s/>/\>/sg; + $value =~ s/\n/<br>\n/sg; + print "<tr><td valign=top>$label</td><td>$value</td></tr>\n"; + } else { + my @values = split /\n/, $value; + printf "%-47s %s\n", $label, shift @values; + printf "%-47s %s\n", "", $_ foreach (@values); + } +} + +sub printl2($$) # print a line w/ label and value (outside a table) +{ + my ($label, $value) = @_; + if ($opt_html) { + $label =~ s/</\</sg; + $label =~ s/>/\>/sg; + $label =~ s/\n/<br>\n/sg; + $value =~ s/</\</sg; + $value =~ s/>/\>/sg; + $value =~ s/\n/<br>\n/sg; + } + print "$label: $value\n"; +} + +sub prints($) # print seperator w/ given text +{ + my ($label) = @_; + if ($opt_html) { + $label =~ s/</\</sg; + $label =~ s/>/\>/sg; + $label =~ s/\n/<br>\n/sg; + print "<tr><td align=center colspan=2><b>$label</b></td></tr>\n"; + } else { + print "\n---=== $label ===---\n"; + } +} + +sub printh($$) # print header w/ given text +{ + my ($header, $sub) = @_; + if ($opt_html) { + $header =~ s/</\</sg; + $header =~ s/>/\>/sg; + $header =~ s/\n/<br>\n/sg; + $sub =~ s/</\</sg; + $sub =~ s/>/\>/sg; + $sub =~ s/\n/<br>\n/sg; + print "<h1>$header</h1>\n"; + print "<p>$sub</p>\n"; + } else { + print "\n$header\n$sub\n"; + } +} + +sub printc($) # print comment +{ + my ($comment) = @_; + if ($opt_html) { + $comment =~ s/</\</sg; + $comment =~ s/>/\>/sg; + $comment =~ s/\n/<br>\n/sg; + print "<!-- $comment -->\n"; + } else { + print "# $comment\n"; + } +} + +sub tns($) # print a time in ns +{ + return sprintf("%3.2f ns", $_[0]); +} + +# Parameter: bytes 0-63 +sub decode_sdr_sdram($) +{ + my $bytes = shift; + my ($l, $temp); + +# SPD revision + printl "SPD Revision", $bytes->[62]; + +#size computation + + prints "Memory Characteristics"; + + my $k = 0; + my $ii = 0; + + $ii = ($bytes->[3] & 0x0f) + ($bytes->[4] & 0x0f) - 17; + if (($bytes->[5] <= 8) && ($bytes->[17] <= 8)) { + $k = $bytes->[5] * $bytes->[17]; + } + + if ($ii > 0 && $ii <= 12 && $k > 0) { + printl "Size", ((1 << $ii) * $k) . " MB"; + } else { + printl "INVALID SIZE", $bytes->[3] . "," . $bytes->[4] . "," . + $bytes->[5] . "," . $bytes->[17]; + } + + my @cas; + for ($ii = 0; $ii < 7; $ii++) { + push(@cas, $ii + 1) if ($bytes->[18] & (1 << $ii)); + } + + my $trcd; + my $trp; + my $tras; + my $ctime = ($bytes->[9] >> 4) + ($bytes->[9] & 0xf) * 0.1; + + $trcd = $bytes->[29]; + $trp = $bytes->[27];; + $tras = $bytes->[30]; + + printl "tCL-tRCD-tRP-tRAS", + $cas[$#cas] . "-" . + ceil($trcd/$ctime) . "-" . + ceil($trp/$ctime) . "-" . + ceil($tras/$ctime); + + $l = "Number of Row Address Bits"; + if ($bytes->[3] == 0) { printl $l, "Undefined!"; } + elsif ($bytes->[3] == 1) { printl $l, "1/16"; } + elsif ($bytes->[3] == 2) { printl $l, "2/17"; } + elsif ($bytes->[3] == 3) { printl $l, "3/18"; } + else { printl $l, $bytes->[3]; } + + $l = "Number of Col Address Bits"; + if ($bytes->[4] == 0) { printl $l, "Undefined!"; } + elsif ($bytes->[4] == 1) { printl $l, "1/16"; } + elsif ($bytes->[4] == 2) { printl $l, "2/17"; } + elsif ($bytes->[4] == 3) { printl $l, "3/18"; } + else { printl $l, $bytes->[4]; } + + $l = "Number of Module Rows"; + if ($bytes->[5] == 0 ) { printl $l, "Undefined!"; } + else { printl $l, $bytes->[5]; } + + $l = "Data Width"; + if ($bytes->[7] > 1) { + printl $l, "Undefined!" + } else { + $temp = ($bytes->[7] * 256) + $bytes->[6]; + printl $l, $temp; + } + + $l = "Module Interface Signal Levels"; + if ($bytes->[8] == 0) { printl $l, "5.0 Volt/TTL"; } + elsif ($bytes->[8] == 1) { printl $l, "LVTTL"; } + elsif ($bytes->[8] == 2) { printl $l, "HSTL 1.5"; } + elsif ($bytes->[8] == 3) { printl $l, "SSTL 3.3"; } + elsif ($bytes->[8] == 4) { printl $l, "SSTL 2.5"; } + elsif ($bytes->[8] == 255) { printl $l, "New Table"; } + else { printl $l, "Undefined!"; } + + $l = "Module Configuration Type"; + if ($bytes->[11] == 0) { printl $l, "No Parity"; } + elsif ($bytes->[11] == 1) { printl $l, "Parity"; } + elsif ($bytes->[11] == 2) { printl $l, "ECC"; } + else { printl $l, "Undefined!"; } + + $l = "Refresh Type"; + if ($bytes->[12] > 126) { printl $l, "Self Refreshing"; } + else { printl $l, "Not Self Refreshing"; } + + $l = "Refresh Rate"; + $temp = $bytes->[12] & 0x7f; + if ($temp == 0) { printl $l, "Normal (15.625 us)"; } + elsif ($temp == 1) { printl $l, "Reduced (3.9 us)"; } + elsif ($temp == 2) { printl $l, "Reduced (7.8 us)"; } + elsif ($temp == 3) { printl $l, "Extended (31.3 us)"; } + elsif ($temp == 4) { printl $l, "Extended (62.5 us)"; } + elsif ($temp == 5) { printl $l, "Extended (125 us)"; } + else { printl $l, "Undefined!"; } + + $l = "Primary SDRAM Component Bank Config"; + if ($bytes->[13] > 126) { printl $l, "Bank2 = 2 x Bank1"; } + else { printl $l, "No Bank2 OR Bank2 = Bank1 width"; } + + $l = "Primary SDRAM Component Widths"; + $temp = $bytes->[13] & 0x7f; + if ($temp == 0) { printl $l, "Undefined!\n"; } + else { printl $l, $temp; } + + $l = "Error Checking SDRAM Component Bank Config"; + if ($bytes->[14] > 126) { printl $l, "Bank2 = 2 x Bank1"; } + else { printl $l, "No Bank2 OR Bank2 = Bank1 width"; } + + $l = "Error Checking SDRAM Component Widths"; + $temp = $bytes->[14] & 0x7f; + if ($temp == 0) { printl $l, "Undefined!"; } + else { printl $l, $temp; } + + $l = "Min Clock Delay for Back to Back Random Access"; + if ($bytes->[15] == 0) { printl $l, "Undefined!"; } + else { printl $l, $bytes->[15]; } + + $l = "Supported Burst Lengths"; + my @array; + for ($ii = 0; $ii < 4; $ii++) { + push(@array, 1 << $ii) if ($bytes->[16] & (1 << $ii)); + } + push(@array, "Page") if ($bytes->[16] & 128); + if (@array) { $temp = join ', ', @array; } + else { $temp = "None"; } + printl $l, $temp; + + $l = "Number of Device Banks"; + if ($bytes->[17] == 0) { printl $l, "Undefined/Reserved!"; } + else { printl $l, $bytes->[17]; } + + $l = "Supported CAS Latencies"; + printl $l, cas_latencies(@cas); + + $l = "Supported CS Latencies"; + @array = (); + for ($ii = 0; $ii < 7; $ii++) { + push(@array, $ii) if ($bytes->[19] & (1 << $ii)); + } + if (@array) { $temp = join ', ', @array; } + else { $temp = "None"; } + printl $l, $temp; + + $l = "Supported WE Latencies"; + @array = (); + for ($ii = 0; $ii < 7; $ii++) { + push(@array, $ii) if ($bytes->[20] & (1 << $ii)); + } + if (@array) { $temp = join ', ', @array; } + else { $temp = "None"; } + printl $l, $temp; + + if (@cas >= 1) { + $l = "Cycle Time at CAS ".$cas[$#cas]; + printl $l, "$ctime ns"; + + $l = "Access Time at CAS ".$cas[$#cas]; + $temp = ($bytes->[10] >> 4) + ($bytes->[10] & 0xf) * 0.1; + printl $l, "$temp ns"; + } + + if (@cas >= 2 && spd_written(@$bytes[23..24])) { + $l = "Cycle Time at CAS ".$cas[$#cas-1]; + $temp = $bytes->[23] >> 4; + if ($temp == 0) { printl $l, "Undefined!"; } + else { + if ($temp < 4 ) { $temp += 15; } + printl $l, $temp + (($bytes->[23] & 0xf) * 0.1) . " ns"; + } + + $l = "Access Time at CAS ".$cas[$#cas-1]; + $temp = $bytes->[24] >> 4; + if ($temp == 0) { printl $l, "Undefined!"; } + else { + if ($temp < 4 ) { $temp += 15; } + printl $l, $temp + (($bytes->[24] & 0xf) * 0.1) . " ns"; + } + } + + if (@cas >= 3 && spd_written(@$bytes[25..26])) { + $l = "Cycle Time at CAS ".$cas[$#cas-2]; + $temp = $bytes->[25] >> 2; + if ($temp == 0) { printl $l, "Undefined!"; } + else { printl $l, $temp + ($bytes->[25] & 0x3) * 0.25 . " ns"; } + + $l = "Access Time at CAS ".$cas[$#cas-2]; + $temp = $bytes->[26] >> 2; + if ($temp == 0) { printl $l, "Undefined!"; } + else { printl $l, $temp + ($bytes->[26] & 0x3) * 0.25 . " ns"; } + } + + $l = "SDRAM Module Attributes"; + $temp = ""; + if ($bytes->[21] & 1) { $temp .= "Buffered Address/Control Inputs\n"; } + if ($bytes->[21] & 2) { $temp .= "Registered Address/Control Inputs\n"; } + if ($bytes->[21] & 4) { $temp .= "On card PLL (clock)\n"; } + if ($bytes->[21] & 8) { $temp .= "Buffered DQMB Inputs\n"; } + if ($bytes->[21] & 16) { $temp .= "Registered DQMB Inputs\n"; } + if ($bytes->[21] & 32) { $temp .= "Differential Clock Input\n"; } + if ($bytes->[21] & 64) { $temp .= "Redundant Row Address\n"; } + if ($bytes->[21] & 128) { $temp .= "Undefined (bit 7)\n"; } + if ($bytes->[21] == 0) { $temp .= "(None Reported)\n"; } + printl $l, $temp; + + $l = "SDRAM Device Attributes (General)"; + $temp = ""; + if ($bytes->[22] & 1) { $temp .= "Supports Early RAS# Recharge\n"; } + if ($bytes->[22] & 2) { $temp .= "Supports Auto-Precharge\n"; } + if ($bytes->[22] & 4) { $temp .= "Supports Precharge All\n"; } + if ($bytes->[22] & 8) { $temp .= "Supports Write1/Read Burst\n"; } + if ($bytes->[22] & 16) { $temp .= "Lower VCC Tolerance: 5%\n"; } + else { $temp .= "Lower VCC Tolerance: 10%\n"; } + if ($bytes->[22] & 32) { $temp .= "Upper VCC Tolerance: 5%\n"; } + else { $temp .= "Upper VCC Tolerance: 10%\n"; } + if ($bytes->[22] & 64) { $temp .= "Undefined (bit 6)\n"; } + if ($bytes->[22] & 128) { $temp .= "Undefined (bit 7)\n"; } + printl $l, $temp; + + $l = "Minimum Row Precharge Time"; + if ($bytes->[27] == 0) { printl $l, "Undefined!"; } + else { printl $l, "$bytes->[27] ns"; } + + $l = "Row Active to Row Active Min"; + if ($bytes->[28] == 0) { printl $l, "Undefined!"; } + else { printl $l, "$bytes->[28] ns"; } + + $l = "RAS to CAS Delay"; + if ($bytes->[29] == 0) { printl $l, "Undefined!"; } + else { printl $l, "$bytes->[29] ns"; } + + $l = "Min RAS Pulse Width"; + if ($bytes->[30] == 0) { printl $l, "Undefined!"; } + else { printl $l, "$bytes->[30] ns"; } + + $l = "Row Densities"; + $temp = ""; + if ($bytes->[31] & 1) { $temp .= "4 MByte\n"; } + if ($bytes->[31] & 2) { $temp .= "8 MByte\n"; } + if ($bytes->[31] & 4) { $temp .= "16 MByte\n"; } + if ($bytes->[31] & 8) { $temp .= "32 MByte\n"; } + if ($bytes->[31] & 16) { $temp .= "64 MByte\n"; } + if ($bytes->[31] & 32) { $temp .= "128 MByte\n"; } + if ($bytes->[31] & 64) { $temp .= "256 MByte\n"; } + if ($bytes->[31] & 128) { $temp .= "512 MByte\n"; } + if ($bytes->[31] == 0) { $temp .= "(Undefined! -- None Reported!)\n"; } + printl $l, $temp; + + if (($bytes->[32] & 0xf) <= 9) { + $l = "Command and Address Signal Setup Time"; + $temp = (($bytes->[32] & 0x7f) >> 4) + ($bytes->[32] & 0xf) * 0.1; + printl $l, (($bytes->[32] >> 7) ? -$temp : $temp) . " ns"; + } + + if (($bytes->[33] & 0xf) <= 9) { + $l = "Command and Address Signal Hold Time"; + $temp = (($bytes->[33] & 0x7f) >> 4) + ($bytes->[33] & 0xf) * 0.1; + printl $l, (($bytes->[33] >> 7) ? -$temp : $temp) . " ns"; + } + + if (($bytes->[34] & 0xf) <= 9) { + $l = "Data Signal Setup Time"; + $temp = (($bytes->[34] & 0x7f) >> 4) + ($bytes->[34] & 0xf) * 0.1; + printl $l, (($bytes->[34] >> 7) ? -$temp : $temp) . " ns"; + } + + if (($bytes->[35] & 0xf) <= 9) { + $l = "Data Signal Hold Time"; + $temp = (($bytes->[35] & 0x7f) >> 4) + ($bytes->[35] & 0xf) * 0.1; + printl $l, (($bytes->[35] >> 7) ? -$temp : $temp) . " ns"; + } +} + +# Parameter: bytes 0-63 +sub decode_ddr_sdram($) +{ + my $bytes = shift; + my ($l, $temp); + +# SPD revision + if ($bytes->[62] != 0xff) { + printl "SPD Revision", ($bytes->[62] >> 4) . "." . + ($bytes->[62] & 0xf); + } + +# speed + prints "Memory Characteristics"; + + $l = "Maximum module speed"; + $temp = ($bytes->[9] >> 4) + ($bytes->[9] & 0xf) * 0.1; + my $ddrclk = 2 * (1000 / $temp); + my $tbits = ($bytes->[7] * 256) + $bytes->[6]; + if (($bytes->[11] == 2) || ($bytes->[11] == 1)) { $tbits = $tbits - 8; } + my $pcclk = int ($ddrclk * $tbits / 8); + $pcclk += 100 if ($pcclk % 100) >= 50; # Round properly + $pcclk = $pcclk - ($pcclk % 100); + $ddrclk = int ($ddrclk); + printl $l, "${ddrclk}MHz (PC${pcclk})"; + +#size computation + my $k = 0; + my $ii = 0; + + $ii = ($bytes->[3] & 0x0f) + ($bytes->[4] & 0x0f) - 17; + if (($bytes->[5] <= 8) && ($bytes->[17] <= 8)) { + $k = $bytes->[5] * $bytes->[17]; + } + + if ($ii > 0 && $ii <= 12 && $k > 0) { + printl "Size", ((1 << $ii) * $k) . " MB"; + } else { + printl "INVALID SIZE", $bytes->[3] . ", " . $bytes->[4] . ", " . + $bytes->[5] . ", " . $bytes->[17]; + } + + my $highestCAS = 0; + my %cas; + for ($ii = 0; $ii < 7; $ii++) { + if ($bytes->[18] & (1 << $ii)) { + $highestCAS = 1+$ii*0.5; + $cas{$highestCAS}++; + } + } + + my $trcd; + my $trp; + my $tras; + my $ctime = ($bytes->[9] >> 4) + ($bytes->[9] & 0xf) * 0.1; + + $trcd = ($bytes->[29] >> 2) + (($bytes->[29] & 3) * 0.25); + $trp = ($bytes->[27] >> 2) + (($bytes->[27] & 3) * 0.25); + $tras = $bytes->[30]; + + printl "tCL-tRCD-tRP-tRAS", + $highestCAS . "-" . + ceil($trcd/$ctime) . "-" . + ceil($trp/$ctime) . "-" . + ceil($tras/$ctime); + +# latencies + printl "Supported CAS Latencies", cas_latencies(keys %cas); + + my @array; + for ($ii = 0; $ii < 7; $ii++) { + push(@array, $ii) if ($bytes->[19] & (1 << $ii)); + } + if (@array) { $temp = join ', ', @array; } + else { $temp = "None"; } + printl "Supported CS Latencies", $temp; + + @array = (); + for ($ii = 0; $ii < 7; $ii++) { + push(@array, $ii) if ($bytes->[20] & (1 << $ii)); + } + if (@array) { $temp = join ', ', @array; } + else { $temp = "None"; } + printl "Supported WE Latencies", $temp; + +# timings + if (exists $cas{$highestCAS}) { + printl "Minimum Cycle Time at CAS $highestCAS", + "$ctime ns"; + + printl "Maximum Access Time at CAS $highestCAS", + (($bytes->[10] >> 4) * 0.1 + ($bytes->[10] & 0xf) * 0.01) . " ns"; + } + + if (exists $cas{$highestCAS-0.5} && spd_written(@$bytes[23..24])) { + printl "Minimum Cycle Time at CAS ".($highestCAS-0.5), + (($bytes->[23] >> 4) + ($bytes->[23] & 0xf) * 0.1) . " ns"; + + printl "Maximum Access Time at CAS ".($highestCAS-0.5), + (($bytes->[24] >> 4) * 0.1 + ($bytes->[24] & 0xf) * 0.01) . " ns"; + } + + if (exists $cas{$highestCAS-1} && spd_written(@$bytes[25..26])) { + printl "Minimum Cycle Time at CAS ".($highestCAS-1), + (($bytes->[25] >> 4) + ($bytes->[25] & 0xf) * 0.1) . " ns"; + + printl "Maximum Access Time at CAS ".($highestCAS-1), + (($bytes->[26] >> 4) * 0.1 + ($bytes->[26] & 0xf) * 0.01) . " ns"; + } + +# module attributes + if ($bytes->[47] & 0x03) { + if (($bytes->[47] & 0x03) == 0x01) { $temp = "1.125\" to 1.25\""; } + elsif (($bytes->[47] & 0x03) == 0x02) { $temp = "1.7\""; } + elsif (($bytes->[47] & 0x03) == 0x03) { $temp = "Other"; } + printl "Module Height", $temp; + } +} + +sub ddr2_sdram_ctime($) +{ + my $byte = shift; + my $ctime; + + $ctime = $byte >> 4; + if (($byte & 0xf) <= 9) { $ctime += ($byte & 0xf) * 0.1; } + elsif (($byte & 0xf) == 10) { $ctime += 0.25; } + elsif (($byte & 0xf) == 11) { $ctime += 0.33; } + elsif (($byte & 0xf) == 12) { $ctime += 0.66; } + elsif (($byte & 0xf) == 13) { $ctime += 0.75; } + + return $ctime; +} + +sub ddr2_sdram_atime($) +{ + my $byte = shift; + my $atime; + + $atime = ($byte >> 4) * 0.1 + ($byte & 0xf) * 0.01; + + return $atime; +} + +# Base, high-bit, 3-bit fraction code +sub ddr2_sdram_rtime($$$) +{ + my ($rtime, $msb, $ext) = @_; + my @table = (0, .25, .33, .50, .66, .75); + + return $rtime + $msb * 256 + $table[$ext]; +} + +sub ddr2_module_types($) +{ + my $byte = shift; + my @types = qw(RDIMM UDIMM SO-DIMM Micro-DIMM Mini-RDIMM Mini-UDIMM); + my @widths = (133.35, 133.25, 67.6, 45.5, 82.0, 82.0); + my @suptypes; + local $_; + + foreach (0..5) { + push @suptypes, "$types[$_] ($widths[$_] mm)" + if ($byte & (1 << $_)); + } + + return @suptypes; +} + +sub ddr2_refresh_rate($) +{ + my $byte = shift; + my @refresh = qw(Normal Reduced Reduced Extended Extended Extended); + my @refresht = (15.625, 3.9, 7.8, 31.3, 62.5, 125); + + return "$refresh[$byte & 0x7f] ($refresht[$byte & 0x7f] us)". + ($byte & 0x80 ? " - Self Refresh" : ""); +} + +# Parameter: bytes 0-63 +sub decode_ddr2_sdram($) +{ + my $bytes = shift; + my ($l, $temp); + my $ctime; + +# SPD revision + if ($bytes->[62] != 0xff) { + printl "SPD Revision", ($bytes->[62] >> 4) . "." . + ($bytes->[62] & 0xf); + } + +# speed + prints "Memory Characteristics"; + + $l = "Maximum module speed"; + $ctime = ddr2_sdram_ctime($bytes->[9]); + my $ddrclk = 2 * (1000 / $ctime); + my $tbits = ($bytes->[7] * 256) + $bytes->[6]; + if ($bytes->[11] & 0x03) { $tbits = $tbits - 8; } + my $pcclk = int ($ddrclk * $tbits / 8); + # Round down to comply with Jedec + $pcclk = $pcclk - ($pcclk % 100); + $ddrclk = int ($ddrclk); + printl $l, "${ddrclk}MHz (PC2-${pcclk})"; + +#size computation + my $k = 0; + my $ii = 0; + + $ii = ($bytes->[3] & 0x0f) + ($bytes->[4] & 0x0f) - 17; + $k = (($bytes->[5] & 0x7) + 1) * $bytes->[17]; + + if($ii > 0 && $ii <= 12 && $k > 0) { + printl "Size", ((1 << $ii) * $k) . " MB"; + } else { + printl "INVALID SIZE", $bytes->[3] . "," . $bytes->[4] . "," . + $bytes->[5] . "," . $bytes->[17]; + } + + printl "Banks x Rows x Columns x Bits", + join(' x ', $bytes->[17], $bytes->[3], $bytes->[4], $bytes->[6]); + printl "Ranks", ($bytes->[5] & 7) + 1; + + printl "SDRAM Device Width", $bytes->[13]." bits"; + + my @heights = ('< 25.4', '25.4', '25.4 - 30.0', '30.0', '30.5', '> 30.5'); + printl "Module Height", $heights[$bytes->[5] >> 5]." mm"; + + my @suptypes = ddr2_module_types($bytes->[20]); + printl "Module Type".(@suptypes > 1 ? 's' : ''), join(', ', @suptypes); + + printl "DRAM Package", $bytes->[5] & 0x10 ? "Stack" : "Planar"; + + my @volts = ("TTL (5V Tolerant)", "LVTTL", "HSTL 1.5V", + "SSTL 3.3V", "SSTL 2.5V", "SSTL 1.8V", "TBD"); + printl "Voltage Interface Level", $volts[$bytes->[8]]; + + printl "Refresh Rate", ddr2_refresh_rate($bytes->[12]); + + my @burst; + push @burst, 4 if ($bytes->[16] & 4); + push @burst, 8 if ($bytes->[16] & 8); + $burst[0] = 'None' if !@burst; + printl "Supported Burst Lengths", join(', ', @burst); + + my $highestCAS = 0; + my %cas; + for ($ii = 2; $ii < 7; $ii++) { + if ($bytes->[18] & (1 << $ii)) { + $highestCAS = $ii; + $cas{$highestCAS}++; + } + } + + my $trcd; + my $trp; + my $tras; + + $trcd = ($bytes->[29] >> 2) + (($bytes->[29] & 3) * 0.25); + $trp = ($bytes->[27] >> 2) + (($bytes->[27] & 3) * 0.25); + $tras = $bytes->[30]; + + printl "tCL-tRCD-tRP-tRAS", + $highestCAS . "-" . + ceil($trcd/$ctime) . "-" . + ceil($trp/$ctime) . "-" . + ceil($tras/$ctime); + +# latencies + printl "Supported CAS Latencies (tCL)", cas_latencies(keys %cas); + +# timings + if (exists $cas{$highestCAS}) { + printl "Minimum Cycle Time at CAS $highestCAS (tCK min)", + tns($ctime); + printl "Maximum Access Time at CAS $highestCAS (tAC)", + tns(ddr2_sdram_atime($bytes->[10])); + } + + if (exists $cas{$highestCAS-1} && spd_written(@$bytes[23..24])) { + printl "Minimum Cycle Time at CAS ".($highestCAS-1), + tns(ddr2_sdram_ctime($bytes->[23])); + printl "Maximum Access Time at CAS ".($highestCAS-1), + tns(ddr2_sdram_atime($bytes->[24])); + } + + if (exists $cas{$highestCAS-2} && spd_written(@$bytes[25..26])) { + printl "Minimum Cycle Time at CAS ".($highestCAS-2), + tns(ddr2_sdram_ctime($bytes->[25])); + printl "Maximum Access Time at CAS ".($highestCAS-2), + tns(ddr2_sdram_atime($bytes->[26])); + } + printl "Maximum Cycle Time (tCK max)", + tns(ddr2_sdram_ctime($bytes->[43])); + +# more timing information + prints("Timing Parameters"); + printl "Address/Command Setup Time Before Clock (tIS)", + tns(ddr2_sdram_atime($bytes->[32])); + printl "Address/Command Hold Time After Clock (tIH)", + tns(ddr2_sdram_atime($bytes->[33])); + printl "Data Input Setup Time Before Strobe (tDS)", + tns(ddr2_sdram_atime($bytes->[34])); + printl "Data Input Hold Time After Strobe (tDH)", + tns(ddr2_sdram_atime($bytes->[35])); + printl "Minimum Row Precharge Delay (tRP)", tns($trp); + printl "Minimum Row Active to Row Active Delay (tRRD)", + tns($bytes->[28]/4); + printl "Minimum RAS# to CAS# Delay (tRCD)", tns($trcd); + printl "Minimum RAS# Pulse Width (tRAS)", tns($tras); + printl "Write Recovery Time (tWR)", tns($bytes->[36]/4); + printl "Minimum Write to Read CMD Delay (tWTR)", tns($bytes->[37]/4); + printl "Minimum Read to Pre-charge CMD Delay (tRTP)", tns($bytes->[38]/4); + printl "Minimum Active to Auto-refresh Delay (tRC)", + tns(ddr2_sdram_rtime($bytes->[41], 0, ($bytes->[40] >> 4) & 7)); + printl "Minimum Recovery Delay (tRFC)", + tns(ddr2_sdram_rtime($bytes->[42], $bytes->[40] & 1, + ($bytes->[40] >> 1) & 7)); + printl "Maximum DQS to DQ Skew (tDQSQ)", tns($bytes->[44]/100); + printl "Maximum Read Data Hold Skew (tQHS)", tns($bytes->[45]/100); + printl "PLL Relock Time", $bytes->[46] . " us" if ($bytes->[46]); +} + +# Parameter: bytes 0-63 +sub decode_direct_rambus($) +{ + my $bytes = shift; + +#size computation + prints "Memory Characteristics"; + + my $ii; + + $ii = ($bytes->[4] & 0x0f) + ($bytes->[4] >> 4) + ($bytes->[5] & 0x07) - 13; + + if ($ii > 0 && $ii < 16) { + printl "Size", (1 << $ii) . " MB"; + } else { + printl "INVALID SIZE", sprintf("0x%02x, 0x%02x", + $bytes->[4], $bytes->[5]); + } +} + +# Parameter: bytes 0-63 +sub decode_rambus($) +{ + my $bytes = shift; + +#size computation + prints "Memory Characteristics"; + + my $ii; + + $ii = ($bytes->[3] & 0x0f) + ($bytes->[3] >> 4) + ($bytes->[5] & 0x07) - 13; + + if ($ii > 0 && $ii < 16) { + printl "Size", (1 << $ii) . " MB"; + } else { + printl "INVALID SIZE", sprintf("0x%02x, 0x%02x", + $bytes->[3], $bytes->[5]); + } +} + +%decode_callback = ( + "SDR SDRAM" => \&decode_sdr_sdram, + "DDR SDRAM" => \&decode_ddr_sdram, + "DDR2 SDRAM" => \&decode_ddr2_sdram, + "Direct Rambus" => \&decode_direct_rambus, + "Rambus" => \&decode_rambus, +); + +# Parameter: bytes 64-127 +sub decode_intel_spec_freq($) +{ + my $bytes = shift; + my ($l, $temp); + + prints "Intel Specification"; + + $l = "Frequency"; + if ($bytes->[62] == 0x66) { $temp = "66MHz\n"; } + elsif ($bytes->[62] == 100) { $temp = "100MHz or 133MHz\n"; } + elsif ($bytes->[62] == 133) { $temp = "133MHz\n"; } + else { $temp = "Undefined!\n"; } + printl $l, $temp; + + $l = "Details for 100MHz Support"; + $temp = ""; + if ($bytes->[63] & 1) { $temp .= "Intel Concurrent Auto-precharge\n"; } + if ($bytes->[63] & 2) { $temp .= "CAS Latency = 2\n"; } + if ($bytes->[63] & 4) { $temp .= "CAS Latency = 3\n"; } + if ($bytes->[63] & 8) { $temp .= "Junction Temp A (100 degrees C)\n"; } + else { $temp .= "Junction Temp B (90 degrees C)\n"; } + if ($bytes->[63] & 16) { $temp .= "CLK 3 Connected\n"; } + if ($bytes->[63] & 32) { $temp .= "CLK 2 Connected\n"; } + if ($bytes->[63] & 64) { $temp .= "CLK 1 Connected\n"; } + if ($bytes->[63] & 128) { $temp .= "CLK 0 Connected\n"; } + if (($bytes->[63] & 192) == 192) { $temp .= "Double-sided DIMM\n"; } + elsif (($bytes->[63] & 192) != 0) { $temp .= "Single-sided DIMM\n"; } + printl $l, $temp; +} + +# Read various hex dump style formats: hexdump, hexdump -C, i2cdump, eeprog +# note that normal 'hexdump' format on a little-endian system byte-swaps +# words, using hexdump -C is better. +sub read_hexdump($) +{ + my $addr = 0; + my $repstart = 0; + my @bytes; + my $header = 1; + my $word = 0; + + # Look in the cache first + return @{$hexdump_cache{$_[0]}} if exists $hexdump_cache{$_[0]}; + + open F, '<', $_[0] or die "Unable to open: $_[0]"; + while (<F>) { + chomp; + if (/^\*$/) { + $repstart = $addr; + next; + } + /^(?:0000 )?([a-f\d]{2,8}):?\s+((:?[a-f\d]{4}\s*){8}|(:?[a-f\d]{2}\s*){16})/i || + /^(?:0000 )?([a-f\d]{2,8}):?\s*$/i; + next if (!defined $1 && $header); # skip leading unparsed lines + + defined $1 or die "Unable to parse input"; + $header = 0; + + $addr = hex $1; + if ($repstart) { + @bytes[$repstart .. ($addr-1)] = + (@bytes[($repstart-16)..($repstart-1)]) x (($addr-$repstart)/16); + $repstart = 0; + } + last unless defined $2; + foreach (split(/\s+/, $2)) { + if (/^(..)(..)$/) { + $word |= 1; + if ($use_hexdump eq LITTLEENDIAN) { + $bytes[$addr++] = hex($2); + $bytes[$addr++] = hex($1); + } else { + $bytes[$addr++] = hex($1); + $bytes[$addr++] = hex($2); + } + } else { + $bytes[$addr++] = hex($_); + } + } + } + close F; + $header and die "Unable to parse any data from hexdump '$_[0]'"; + $word and printc "Using $use_hexdump 16-bit hex dump"; + + # Cache the data for later use + $hexdump_cache{$_[0]} = \@bytes; + return @bytes; +} + +sub readspd64($$) # reads 64 bytes from SPD-EEPROM +{ + my ($offset, $dimm_i) = @_; + my @bytes; + if ($use_hexdump) { + @bytes = read_hexdump($dimm_i); + return @bytes[$offset..($offset+63)]; + } elsif ($use_sysfs) { + # Kernel 2.6 with sysfs + sysopen(HANDLE, "/sys/bus/i2c/drivers/eeprom/$dimm_i/eeprom", O_RDONLY) + or die "Cannot open /sys/bus/i2c/drivers/eeprom/$dimm_i/eeprom"; + binmode HANDLE; + sysseek(HANDLE, $offset, SEEK_SET); + sysread(HANDLE, my $eeprom, 64); + close HANDLE; + @bytes = unpack("C64", $eeprom); + } else { + # Kernel 2.4 with procfs + for my $i (0 .. 3) { + my $hexoff = sprintf('%02x', $offset + $i * 16); + push @bytes, split(" ", `cat /proc/sys/dev/sensors/$dimm_i/$hexoff`); + } + } + return @bytes; +} + +# Parse command-line +foreach (@ARGV) { + if ($_ eq '-h' || $_ eq '--help') { + print "Usage: $0 [-c] [-f [-b]] [-x|-X file [files..]]\n", + " $0 -h\n\n", + " -f, --format Print nice html output\n", + " -b, --bodyonly Don't print html header\n", + " (useful for postprocessing the output)\n", + " -c, --checksum Decode completely even if checksum fails\n", + " -x, Read data from hexdump files\n", + " -X, Same as -x except treat multibyte hex\n", + " data as little endian\n", + " -h, --help Display this usage summary\n"; + print <<"EOF"; + +Hexdumps can be the output from hexdump, hexdump -C, i2cdump, eeprog and +likely many other progams producing hex dumps of one kind or another. Note +that the default output of "hexdump" will be byte-swapped on little-endian +systems and you must use -X instead of -x, otherwise the dump will not be +parsed correctly. It is better to use "hexdump -C", which is not ambiguous. +EOF + exit; + } + + if ($_ eq '-f' || $_ eq '--format') { + $opt_html = 1; + next; + } + if ($_ eq '-b' || $_ eq '--bodyonly') { + $opt_bodyonly = 1; + next; + } + if ($_ eq '-c' || $_ eq '--checksum') { + $opt_igncheck = 1; + next; + } + if ($_ eq '-x') { + $use_hexdump = BIGENDIAN; + next; + } + if ($_ eq '-X') { + $use_hexdump = LITTLEENDIAN; + next; + } + + if (m/^-/) { + print STDERR "Unrecognized option $_\n"; + exit; + } + + push @dimm_list, $_ if $use_hexdump; +} + +if ($opt_html && !$opt_bodyonly) { + print "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n", + "<html><head>\n", + "\t<meta HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=iso-8859-1\">\n", + "\t<title>PC DIMM Serial Presence Detect Tester/Decoder Output</title>\n", + "</head><body>\n"; +} + +printc "decode-dimms version $revision"; +printh 'Memory Serial Presence Detect Decoder', +'By Philip Edelbrock, Christian Zuckschwerdt, Burkart Lingner, +Jean Delvare, Trent Piepho and others'; + + +my $dimm_count = 0; +my $dir; +if (!$use_hexdump) { + if ($use_sysfs) { $dir = '/sys/bus/i2c/drivers/eeprom'; } + else { $dir = '/proc/sys/dev/sensors'; } + if (-d $dir) { + @dimm_list = split(/\s+/, `ls $dir`); + } elsif (! -d '/sys/module/eeprom') { + print "No EEPROM found, are you sure the eeprom module is loaded?\n"; + exit; + } +} + +for my $i ( 0 .. $#dimm_list ) { + $_ = $dimm_list[$i]; + if (($use_sysfs && /^\d+-\d+$/) + || (!$use_sysfs && /^eeprom-/) + || $use_hexdump) { + my @bytes = readspd64(0, $dimm_list[$i]); + my $dimm_checksum = 0; + $dimm_checksum += $bytes[$_] foreach (0 .. 62); + $dimm_checksum &= 0xff; + + next unless $bytes[63] == $dimm_checksum || $opt_igncheck; + $dimm_count++; + + print "<b><u>" if $opt_html; + printl2 "\n\nDecoding EEPROM", + $use_hexdump ? $dimm_list[$i] : ($use_sysfs ? + "/sys/bus/i2c/drivers/eeprom/$dimm_list[$i]" : + "/proc/sys/dev/sensors/$dimm_list[$i]"); + print "</u></b>" if $opt_html; + print "<table border=1>\n" if $opt_html; + if (!$use_hexdump) { + if (($use_sysfs && /^[^-]+-([^-]+)$/) + || (!$use_sysfs && /^[^-]+-[^-]+-[^-]+-([^-]+)$/)) { + my $dimm_num = $1 - 49; + printl "Guessing DIMM is in", "bank $dimm_num"; + } + } + +# Decode first 3 bytes (0-2) + prints "SPD EEPROM Information"; + + my $l = "EEPROM Checksum of bytes 0-62"; + printl $l, ($bytes[63] == $dimm_checksum ? + sprintf("OK (0x%.2X)", $bytes[63]): + sprintf("Bad\n(found 0x%.2X, calculated 0x%.2X)\n", + $bytes[63], $dimm_checksum)); + + # Simple heuristic to detect Rambus + my $is_rambus = $bytes[0] < 4; + my $temp; + if ($is_rambus) { + if ($bytes[0] == 1) { $temp = "0.7"; } + elsif ($bytes[0] == 2) { $temp = "1.0"; } + elsif ($bytes[0] == 0 || $bytes[0] == 255) { $temp = "Invalid"; } + else { $temp = "Reserved"; } + printl "SPD Revision", $temp; + } else { + printl "# of bytes written to SDRAM EEPROM", + $bytes[0]; + } + + $l = "Total number of bytes in EEPROM"; + if ($bytes[1] <= 14) { + printl $l, 2**$bytes[1]; + } elsif ($bytes[1] == 0) { + printl $l, "RFU"; + } else { printl $l, "ERROR!"; } + + $l = "Fundamental Memory type"; + my $type = "Unknown"; + if ($is_rambus) { + if ($bytes[2] == 1) { $type = "Direct Rambus"; } + elsif ($bytes[2] == 17) { $type = "Rambus"; } + } else { + if ($bytes[2] == 1) { $type = "FPM DRAM"; } + elsif ($bytes[2] == 2) { $type = "EDO"; } + elsif ($bytes[2] == 3) { $type = "Pipelined Nibble"; } + elsif ($bytes[2] == 4) { $type = "SDR SDRAM"; } + elsif ($bytes[2] == 5) { $type = "Multiplexed ROM"; } + elsif ($bytes[2] == 6) { $type = "DDR SGRAM"; } + elsif ($bytes[2] == 7) { $type = "DDR SDRAM"; } + elsif ($bytes[2] == 8) { $type = "DDR2 SDRAM"; } + } + printl $l, $type; + +# Decode next 61 bytes (3-63, depend on memory type) + $decode_callback{$type}->(\@bytes) + if exists $decode_callback{$type}; + +# Decode next 35 bytes (64-98, common to all memory types) + prints "Manufacturing Information"; + + @bytes = readspd64(64, $dimm_list[$i]); + + $l = "Manufacturer"; + # $extra is a reference to an array containing up to + # 7 extra bytes from the Manufacturer field. Sometimes + # these bytes are filled with interesting data. + ($temp, my $extra) = manufacturer(@bytes[0..7]); + printl $l, $temp; + $l = "Custom Manufacturer Data"; + $temp = manufacturer_data(@{$extra}); + printl $l, $temp if defined $temp; + + if (spd_written($bytes[8])) { + # Try the location code as ASCII first, as earlier specifications + # suggested this. As newer specifications don't mention it anymore, + # we still fall back to binary. + $l = "Manufacturing Location Code"; + $temp = (chr($bytes[8]) =~ m/^[\w\d]$/) ? chr($bytes[8]) + : sprintf("0x%.2X", $bytes[8]); + printl $l, $temp; + } + + $l = "Part Number"; + $temp = part_number(@bytes[9..26]); + printl $l, $temp; + + if (spd_written(@bytes[27..28])) { + $l = "Revision Code"; + $temp = sprintf("0x%02X%02X\n", @bytes[27..28]); + printl $l, $temp; + } + + if (spd_written(@bytes[29..30])) { + $l = "Manufacturing Date"; + # In theory the year and week are in BCD format, but + # this is not always true in practice :( + if (($bytes[29] & 0xf0) <= 0x90 + && ($bytes[29] & 0x0f) <= 0x09 + && ($bytes[30] & 0xf0) <= 0x90 + && ($bytes[30] & 0x0f) <= 0x09) { + # Note that this heuristic will break in year 2080 + $temp = sprintf("%d%02X-W%02X\n", + $bytes[29] >= 0x80 ? 19 : 20, + @bytes[29..30]); + } else { + $temp = sprintf("0x%02X%02X\n", + @bytes[29..30]); + } + printl $l, $temp; + } + + if (spd_written(@bytes[31..34])) { + $l = "Assembly Serial Number"; + $temp = sprintf("0x%02X%02X%02X%02X\n", + @bytes[31..34]); + printl $l, $temp; + } + +# Next 27 bytes (99-125) are manufacturer specific, can't decode + +# Last 2 bytes (126-127) are reserved, Intel used them as an extension + if ($type eq "SDR SDRAM") { + decode_intel_spec_freq(\@bytes); + } + + print "</table>\n" if $opt_html; + } +} +printl2 "\n\nNumber of SDRAM DIMMs detected and decoded", $dimm_count; + +print "</body></html>\n" if ($opt_html && !$opt_bodyonly); diff --git a/eeprom/decode-edid b/eeprom/decode-edid new file mode 100755 index 0000000..15ba1a4 --- /dev/null +++ b/eeprom/decode-edid @@ -0,0 +1,225 @@ +#!/usr/bin/perl -w +# +# Copyright (C) 2003-2006 Jean Delvare <khali@linux-fr.org> +# +# 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., 51 Franklin Street, Fifth Floor, Boston, +# MA 02110-1301 USA. +# +# Version 0.1 2003-07-17 Jean Delvare <khali@linux-fr.org> +# Version 0.2 2003-07-22 Jean Delvare <khali@linux-fr.org> +# Use print instead of syswrite. +# Version 0.3 2003-08-24 Jean Delvare <khali@linux-fr.org> +# Fix data block length (128 bytes instead of 256). +# Version 1.0 2004-02-08 Jean Delvare <khali@linux-fr.org> +# Added support for Linux 2.5/2.6 (i.e. sysfs). +# Version 1.1 2006-09-01 Jean Delvare <khali@linux-fr.org> +# Append /usr/sbin or /usr/local/sbin to $PATH if needed. +# +# EEPROM data decoding for EDID. EDID (Extended Display Identification +# Data) is a VESA standard which allows storing (on manufacturer's side) +# and retrieving (on user's side) of configuration information about +# displays, such as manufacturer, serial number, physical dimensions and +# allowed horizontal and vertical refresh rates. +# +# Using the eeprom kernel driver, you have two possibilities to +# make use of these data: +# 1* The ddcmon script. +# 2* This script. +# Both solutions will return a different kind of information. The first +# method will report user-interesting information, such as the model number +# or the year of manufacturing. The second method will report video-card- +# interesting information, such as video modes and refresh rates. +# +# Note that this script does almost nothing by itself. It simply converts +# what it finds in /proc to binary data to feed the parse-edid program. +# The parse-edid program was written by John Fremlin and is available at +# the following address: +# http://john.fremlin.de/programs/linux/read-edid/ + +use strict; +use Fcntl qw(:DEFAULT :seek); +use vars qw($bus $address); +use constant PROCFS => 1; +use constant SYSFS => 2; + +# parse-edid will typically be installed in /usr/sbin or /usr/local/sbin +# even though regular users can run it +$ENV{PATH} .= ':/usr/local/sbin' + if $ENV{PATH} !~ m,(^|:)/usr/local/sbin/?(:|$), + && -x '/usr/local/sbin/parse-edid'; +$ENV{PATH} .= ':/usr/sbin' + if $ENV{PATH} !~ m,(^|:)/usr/sbin/?(:|$), + && -x '/usr/sbin/parse-edid'; + +sub edid_valid_procfs +{ + my ($bus, $addr) = @_; + + open EEDATA, "/proc/sys/dev/sensors/eeprom-i2c-$bus-$addr/00"; + my $line = <EEDATA>; + close EEDATA; + return 1 + if $line =~ m/^0 255 255 255 255 255 255 0 /; + return 0; +} + +# Only used for sysfs +sub rawread +{ + my ($filename, $length, $offset) = @_; + my $bytes = ''; + + sysopen(FH, $filename, O_RDONLY) + or die "Can't open $filename"; + if ($offset) + { + sysseek(FH, $offset, SEEK_SET) + or die "Can't seek in $filename"; + } + + $offset = 0; + while ($length) + { + my $r = sysread(FH, $bytes, $length, $offset); + die "Can't read $filename" + unless defined($r); + die "Unexpected EOF in $filename" + unless $r; + $offset += $r; + $length -= $r; + } + close(FH); + + return $bytes; +} + +sub edid_valid_sysfs +{ + my ($bus, $addr) = @_; + my $bytes = rawread("/sys/bus/i2c/devices/$bus-00$addr/eeprom", 8, 0); + + return 1 + if $bytes eq "\x00\xFF\xFF\xFF\xFF\xFF\xFF\x00"; + return 0; +} + +sub bus_detect +{ + my $max = shift; + + for (my $i=0; $i<$max; $i++) + { + if (-r "/proc/sys/dev/sensors/eeprom-i2c-$i-50/00") + { + if (edid_valid_procfs($i, '50')) + { + print STDERR + "decode-edid: using bus $i (autodetected)\n"; + return $i; + } + } + elsif (-r "/sys/bus/i2c/devices/$i-0050/eeprom") + { + if (edid_valid_sysfs($i, '50')) + { + print STDERR + "decode-edid: using bus $i (autodetected)\n"; + return $i; + } + } + } + + return; # default +} + +sub edid_decode +{ + my ($bus, $addr, $mode) = @_; + + # Make sure it is an EDID EEPROM. + + unless (($mode == PROCFS && edid_valid_procfs ($bus, $addr)) + || ($mode == SYSFS && edid_valid_sysfs ($bus, $addr))) + { + print STDERR + "decode-edid: not an EDID EEPROM at $bus-$addr\n"; + return; + } + + $SIG{__WARN__} = sub { }; + open PIPE, "| parse-edid" + or die "Can't open parse-edid. Please install read-edid.\n"; + delete $SIG{__WARN__}; + binmode PIPE; + + if ($mode == PROCFS) + { + for (my $i=0; $i<=0x70; $i+=0x10) + { + my $file = sprintf '%02x', $i; + my $output = ''; + open EEDATA, "/proc/sys/dev/sensors/eeprom-i2c-$bus-$addr/$file" + or die "Can't read /proc/sys/dev/sensors/eeprom-i2c-$bus-$addr/$file"; + while(<EEDATA>) + { + foreach my $item (split) + { + $output .= pack "C", $item; + } + } + close EEDATA; + print PIPE $output; + } + } + elsif ($mode == SYSFS) + { + print PIPE rawread("/sys/bus/i2c/devices/$bus-00$address/eeprom", 128, 0); + } + + close PIPE; +} + +# Get the address. Default to 0x50 if not given. +$address = $ARGV[1] || 0x50; +# Convert to decimal, whatever the value. +$address = oct $address if $address =~ m/^0/; +# Convert to an hexadecimal string. +$address = sprintf '%02x', $address; + +# Get the bus. Try to autodetect if not given. +$bus = $ARGV[0] if defined $ARGV[0]; +$bus = bus_detect(8) unless defined $bus; + +if(defined $bus) +{ + print STDERR + "decode-edid: decode-edid version 1.1\n"; + if (-r "/proc/sys/dev/sensors/eeprom-i2c-$bus-$address") + { + edid_decode ($bus, $address, PROCFS); + exit 0; + } + elsif (-r "/sys/bus/i2c/devices/$bus-00$address") + { + edid_decode ($bus, $address, SYSFS); + exit 0; + } +} + +print STDERR + "EDID EEPROM not found. Please make sure that the eeprom module is loaded.\n"; +print STDERR + "Maybe your EDID EEPROM is on another bus. Try \"decode-edid ".($bus+1)."\".\n" + if defined $bus; diff --git a/eeprom/decode-vaio b/eeprom/decode-vaio new file mode 100755 index 0000000..2631170 --- /dev/null +++ b/eeprom/decode-vaio @@ -0,0 +1,237 @@ +#!/usr/bin/perl -w +# +# Copyright (C) 2002-2008 Jean Delvare <khali@linux-fr.org> +# +# 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., 51 Franklin Street, Fifth Floor, Boston, +# MA 02110-1301 USA. +# +# EEPROM data decoding for Sony Vaio laptops. +# +# The eeprom driver must be loaded. For kernels older than 2.6.0, the +# eeprom driver can be found in the lm-sensors package. +# +# Please note that this is a guess-only work. Sony support refused to help +# me, so if someone can provide information, please contact me. +# My knowledge is summarized on this page: +# http://khali.linux-fr.org/vaio/eeprom.html +# +# It seems that if present, the EEPROM is always at 0x57. +# +# Models tested so far: +# PCG-F403 : No EEPROM +# PCG-F707 : No EEPROM +# PCG-GR114EK : OK +# PCG-GR114SK : OK +# PCG-GR214EP : OK +# PCG-GRT955MP : OK +# PCG-GRX316G : OK +# PCG-GRX570 : OK +# PCG-GRX600K : OK +# PCG-U1 : OK +# PCG-Z600LEK : No EEPROM +# PCG-Z600NE : No EEPROM +# VGN-S260 : OK +# VGN-S4M/S : OK +# VGN-TZ11MN/N : OK +# +# Thanks to Werner Heuser, Carsten Blume, Christian Gennerat, Joe Wreschnig, +# Xavier Roche, Sebastien Lefevre, Lars Heer, Steve Dobson, Kent Hunt, +# Timo Hoenig and others for their precious help. + + +use strict; +use Fcntl qw(:DEFAULT :seek); +use vars qw($sysfs $found); + +use constant VERSION => "1.6"; +use constant ONLYROOT => "Readable only by root"; + +sub print_item +{ + my ($label,$value) = @_; + + printf("\%16s : \%s\n",$label,$value); +} + +# Abstract reads so that other functions don't have to care wether +# we need to use procfs or sysfs +sub read_eeprom_bytes +{ + my ($bus, $addr, $offset, $length) = @_; + my $filename; + + if ($sysfs) + { + $filename = "/sys/bus/i2c/devices/$bus-00$addr/eeprom"; + sysopen(FH, $filename, O_RDONLY) + or die "Can't open $filename"; + sysseek(FH, $offset, SEEK_SET) + or die "Can't seek in $filename"; + + my ($r, $bytes); + $bytes = ''; + $offset = 0; + while($length) + { + $r = sysread(FH, $bytes, $length, $offset); + die "Can't read $filename" + unless defined($r); + die "Unexpected EOF in $filename" + unless $r; + $offset += $r; + $length -= $r; + } + close(FH); + + return $bytes; + } + else + { + my $base = $offset & 0xf0; + $offset -= $base; + my $values = ''; + my $remains = $length + $offset; + + # Get all lines in a single string + while ($remains > 0) + { + $filename = "/proc/sys/dev/sensors/eeprom-i2c-$bus-$addr/" + . sprintf('%02x', $base); + open(FH, $filename) + or die "Can't open $filename"; + $values .= <FH>; + close(FH); + $remains -= 16; + $base += 16; + } + + # Store the useful part in an array + my @bytes = split(/[ \n]/, $values); + @bytes = @bytes[$offset..$offset+$length-1]; + + # Back to a binary string + return pack('C*', @bytes); + } +} + +sub decode_string +{ + my ($bus, $addr, $offset, $length) = @_; + + my $string = read_eeprom_bytes($bus, $addr, $offset, $length); + $string =~ s/\x00.*$//; + + return($string); +} + +sub decode_hexa +{ + my ($bus, $addr, $offset, $length) = @_; + + my @bytes = unpack('C*', read_eeprom_bytes($bus, $addr, $offset, $length)); + my $string=''; + + for(my $i=0;$i<$length;$i++) + { + $string.=sprintf('%02X', shift(@bytes)); + } + + return($string); +} + +sub decode_uuid +{ + my ($bus,$addr,$base) = @_; + + my @bytes = unpack('C16', read_eeprom_bytes($bus, $addr, $base, 16)); + my $string=''; + + for(my $i=0;$i<16;$i++) + { + $string.=sprintf('%02x',shift(@bytes)); + if(($i==3)||($i==5)||($i==7)||($i==9)) + { + $string.='-'; + } + } + + if ($string eq '00000000-0000-0000-0000-000000000000') + { + return(ONLYROOT); + } + else + { + return($string); + } +} + +sub vaio_decode +{ + my ($bus,$addr) = @_; + + my $name = decode_string($bus, $addr, 128, 32); + # Simple heuristic to skip false positives + return 0 unless $name =~ m/^[A-Z-]{4}/; + + print_item('Machine Name', $name); + my $serial = decode_string($bus, $addr, 192, 32); + print_item('Serial Number', $serial ? $serial : ONLYROOT); + print_item('UUID', decode_uuid($bus, $addr, 16)); + my $revision = decode_string($bus, $addr, 160, 10); + print_item(length($revision) > 2 ? 'Service Tag' : 'Revision', + $revision); + print_item('Asset Tag', decode_string($bus, $addr, 170, 4). + decode_hexa($bus, $addr, 174, 12)); + print_item('OEM Data', decode_string($bus, $addr, 32, 16)); + print_item('Timestamp', decode_string($bus, $addr, 224, 18)); + return 1; +} + +BEGIN +{ + print("# Sony Vaio EEPROM Decoder version ".VERSION." by Jean Delvare\n\n"); +} + +END +{ + print("\n"); +} + +for (my $i = 0, $found=0; $i <= 4 && !$found; $i++) +{ + if (-r "/sys/bus/i2c/devices/$i-0057/eeprom") + { + $sysfs = 1; + $found += vaio_decode($i, '57'); + } + elsif (-r "/proc/sys/dev/sensors/eeprom-i2c-$i-57") + { + if (-r "/proc/sys/dev/sensors/eeprom-i2c-$i-57/data0-15") + { + print("Deprecated old interface found. Please upgrade to lm_sensors 2.6.3 or greater."); + exit; + } + else + { + $sysfs = 0; + $found += vaio_decode($i, '57'); + } + } +} + +if (!$found) +{ + print("Vaio EEPROM not found. Please make sure that the eeprom module is loaded.\n"); +} diff --git a/eeprom/decode-xeon b/eeprom/decode-xeon new file mode 100755 index 0000000..8a400b9 --- /dev/null +++ b/eeprom/decode-xeon @@ -0,0 +1,197 @@ +#!/usr/bin/perl +# +# Copyright 1998, 1999 Philip Edelbrock <phil@netroedge.com> +# and Mark Studebaker <mdsxyz123@yahoo.com> +# +# Version 0.1 +# +# +# ID ROM data decoding for Xeon processors. +# Each Xeon processor contains two memories: +# - A scratch EEPROM at an even location 0x50, 52, 54, or 56; +# - An ID ROM at an odd location 0x51, 53, 55, or 57. +# This program decodes the ID ROM's only. +# The scratch EEPROMs have no prescribed format. +# If the output of this program makes no sense for a particular device, +# it is probably decoding a DIMM Serial Presence Detect (SPD) EEPROM. +# See decode-dimms to decode those devices. +# +# +# The eeprom driver must be loaded. For kernels older than 2.6.0, the +# eeprom driver can be found in the lm-sensors package. +# +# To do: +# Calculate and check checksums for each section +# Decode flags in byte 0x7B (cartridge feature flags) +# +# References: +# "Pentium II Xeon Processor at 400 and 450 MHz" Data Sheet +# Intel +# +# +# + +print "Xeon Processor Information ROM Decoder\n"; +print "Written by Philip Edelbrock and Mark Studebaker. Copyright 1998, 1999.\n"; +print "Version 2.6.3\n\n"; + +$dimm_count=0; +$_=`ls /proc/sys/dev/sensors/`; +@dimm_list=split(); + +for $i ( 0 .. $#dimm_list ) { + $_=$dimm_list[$i]; + if ((/^eeprom-/) && (/-51$/ || /-53$/ || /-55$/ || /-57$/)) { + $dimm_count=$dimm_count + 1; + + print "\nDecoding Xeon ROM: /proc/sys/dev/sensors/$dimm_list[$i]\n"; + if (/^[^-]+-[^-]+-[^-]+-([^-]+)$/) { + $dimm_num=($1 - 49) / 2; + print "Guessing Xeon is number $dimm_num\n"; + } +# Decode first 16 bytes + print "\t\t----=== Xeon ROM Header Data ===----\n"; + + $_=`cat /proc/sys/dev/sensors/$dimm_list[$i]/00`; + @bytes=split(" "); + + printf("\tData Format Revision: \t\t\t\t0x%.4X\n", $bytes[0]); + + print "\tTotal number of bytes in EEPROM:\t\t"; + print ($bytes[1] << 4) + $bytes[2]; + print "\n"; + + printf("\tProcessor Data Address:\t\t\t\t0x%.2X\n", $bytes[3]); + printf("\tProcessor Core Data Address:\t\t\t0x%.2X\n", $bytes[4]); + printf("\tL2 Cache Data Address:\t\t\t\t0x%.2X\n", $bytes[5]); + printf("\tSEC Cartridge Data Address:\t\t\t0x%.2X\n", $bytes[6]); + printf("\tPart Number Data Address:\t\t\t0x%.2X\n", $bytes[7]); + printf("\tThermal Reference Data Address:\t\t\t0x%.2X\n", $bytes[8]); + printf("\tFeature Data Address:\t\t\t\t0x%.2X\n", $bytes[9]); + printf("\tOther Data Address:\t\t\t\t0x%.2X\n", $bytes[10]); + + print "\t\t----=== Xeon ROM Processor Data ===----\n"; + +# Decode next 16 bytes + $_=`cat /proc/sys/dev/sensors/$dimm_list[$i]/10`; + @bbytes=split(" "); + print "\tS-spec/QDF Number:\t\t\t\t\""; + print pack("cccccc",$bytes[14],$bytes[15],$bbytes[0], + $bbytes[1],$bbytes[2],$bbytes[3]); + print "\"\n"; + $tmp = $bbytes[4] & 0xC0 >> 6; + printf("\tSample / Production:\t\t\t\t0x%.2X", $tmp); + if($tmp) { + print " (Production)\n"; + } else { + print " (Sample)\n"; + } + + print "\t\t----=== Xeon ROM Core Data ===----\n"; + + printf("\tProcessor Core Type:\t\t\t\t0x%.2X\n", + ($bbytes[6] & 0xC0) >> 6); + printf("\tProcessor Core Family:\t\t\t\t0x%.2X\n", + ($bbytes[6] & 0x3C) >> 2); + printf("\tProcessor Core Model:\t\t\t\t0x%.2X\n", + (($bbytes[6] & 0x03) << 2) + (($bbytes[7] & 0xC0) >> 6)); + printf("\tProcessor Core Stepping:\t\t\t0x%.2X\n", + ($bbytes[7] & 0x30) >> 4); + print "\tMaximum Core Frequency (Mhz):\t\t\t"; + print ($bbytes[13] << 4) + $bbytes[14]; + print "\n"; + +# Decode next 16 bytes (32-47) + $_=`cat /proc/sys/dev/sensors/$dimm_list[$i]/20`; + @bytes=split(" "); + print "\tCore Voltage ID (mV):\t\t\t\t"; + print ($bbytes[15] << 4) + $bytes[0]; + print "\n"; + print "\tCore Voltage Tolerance, High (mV):\t\t"; + print $bytes[1]; + print "\n"; + print "\tCore Voltage Tolerance, Low (mV):\t\t"; + print $bytes[2]; + print "\n"; + + print "\t\t----=== Xeon ROM L2 Cache Data ===----\n"; + + print "\tL2 Cache Size (KB):\t\t\t\t"; + print ($bytes[9] << 4) + $bytes[10]; + print "\n"; + printf("\tNumber of SRAM Components:\t\t\t%d\n", + ($bytes[11] & 0xF0) >> 4); + print "\tL2 Cache Voltage ID (mV):\t\t\t"; + print ($bytes[12] << 4) + $bytes[13]; + print "\n"; + print "\tL2 Cache Voltage Tolerance, High (mV):\t\t"; + print $bytes[14]; + print "\n"; + print "\tL2 Cache Voltage Tolerance, Low (mV):\t\t"; + print $bytes[15]; + print "\n"; + +# Decode next 16 bytes (48-63) + $_=`cat /proc/sys/dev/sensors/$dimm_list[$i]/30`; + @bytes=split(" "); + + printf("\tCache/Tag Stepping ID:\t\t\t\t0x%.2X\n", + ($bytes[0] & 0xF0) >> 4); + + print "\t\t----=== Xeon ROM Cartridge Data ===----\n"; + + print "\tCartridge Revision:\t\t\t\t\""; + print pack("cccc",$bytes[2],$bytes[3],$bytes[4],$bytes[5]); + print "\"\n"; + printf("\tSubstrate Rev. Software ID:\t\t\t0x%.2X\n", + ($bbytes[6] & 0xC0) >> 6); + + print "\t\t----=== Xeon ROM Part Number Data ===----\n"; + + print "\tProcessor Part Number:\t\t\t\t\""; + print pack("ccccccc",$bytes[8],$bytes[9],$bytes[10], + $bytes[11],$bytes[12],$bytes[13],$bytes[14]); + print "\"\n"; + $byte15=$byte[15]; + +# Decode next 16 bytes (64-79) + $_=`cat /proc/sys/dev/sensors/$dimm_list[$i]/40`; + @bytes=split(" "); + + print "\tProcessor BOM ID:\t\t\t\t\""; + print pack("cccccccccccccc",$byte15,$bytes[0],$bytes[1], + $bytes[2],$bytes[3],$bytes[4],$bytes[5],$bytes[6], + $bytes[7],$bytes[8],$bytes[9],$bytes[10],$bytes[11], + $bytes[12]); + print "\"\n"; + +# Decode next 16 bytes (80-95) + $_=`cat /proc/sys/dev/sensors/$dimm_list[$i]/50`; + @bbytes=split(" "); + printf("\tProcessor Electronic Signature: \t\t0x%.2X%.2X%.2X%.2X%.2X%.2X%.2X%.2X\n", + $bytes[13],$bytes[14],$bytes[15],$bbytes[0], + $bbytes[1],$bbytes[2],$bbytes[3],$bbytes[4]); + +# Decode next 16 bytes (96-111) +# Not used... + +# Decode next 16 bytes (112-127) + $_=`cat /proc/sys/dev/sensors/$dimm_list[$i]/70`; + @bytes=split(" "); + + print "\t\t----=== Xeon Thermal Reference Data ===----\n"; + + printf("\tThermal Reference Byte: \t\t\t0x%.2X\n", $bytes[0]); + + print "\t\t----=== Xeon ROM Feature Data ===----\n"; + + printf("\tProcessor Core Feature Flags: \t\t\t0x%.2X%.2X%.2X%.2X\n", + $bytes[4],$bytes[5],$bytes[6],$bytes[7]); + printf("\tCartridge Feature Flags: \t\t\t0x%.2X%.2X%.2X%.2X\n", + $bytes[8],$bytes[9],$bytes[10],$bytes[11]); + printf("\tNumber of Devices in TAP Chain:\t\t\t%d\n", + ($bytes[12] & 0xF0) >> 4); + + } +} +print "\n\nNumber of Xeon ROMs detected and decoded: $dimm_count\n"; |