#!/usr/local/bin/perl
#
# @(#) memconf - Identify sizes of SIMM/DIMM memory modules installed on a
# @(#)           Sun workstation or server.
# @(#) Micron Technology, Inc. - Tom Schmidt 13-Apr-1999 V1.15.1
#
# Maintained by Tom Schmidt (tschmidt@micron.com)
#
#   If memconf does not recognize a system, then please send the output of
#   '/usr/sbin/prtconf -pv' (or '/usr/etc/devinfo -pv' on Solaris 1.X) and
#   '/usr/platform/`uname -i`/sbin/prtdiag -v' if available to
#   tschmidt@micron.com so that memconf can be enhanced to recognize it.
#   Check my website at http://netnow.micron.net/~tschmidt/unix.html to get
#   the latest version.
#
# Usage: memconf [ -v | -h ]
#                  -v    verbose mode
#                  -h    print help
#
# memconf reports the size of each SIMM/DIMM memory module installed in a
# system. It also reports the system type and any empty memory sockets.
# In verbose mode, it also reports:
#  - banner name, model, and CPU/system frequencies
#  - address range and bank numbers for each module
#
# Based on SunManagers SUMMARY by Howard Modell (h.modell@ieee.org)
# on 29-Jan-1997.
#
# Tested to work on:
# - sun4c Sun SS2, IPX
# - sun4m Sun 4/6x0, SS4, SS5, SS10, SS10SX, SS20, LX/ZX, Classic, Voyager
# - sun4d Sun SPARCserver-1000, SPARCserver-1000E, SPARCcenter-2000
# - sun4u Sun Ultra 1, 2, 5, 10, 30, 60, 250, 450, UltraStation 10
# - sun4u Sun Enterprise 3000, 3500, 4000/5000, 4500/5500, 6000, 6500
# - sun4u AXUS Ultra 250 and 450 (no verbose output)
#
# Untested systems that might work:
# - sun4c SLC, ELC (does it have 'memory' lines in devinfo/prtconf output?)
# - sun4u1 Sun Enterprise 10000 (no verbose output)
# - sun4d Sun SPARCcenter & sun4u Enterprise systems running Solaris 7 or
#   Solaris 8 beta; does prtdiag output format change?
# - May not work properly on Sun clones
#
# Won't work on:
# - Systems without /dev/openprom
# - sun4c SS1, SS1+, IPC (no 'memory' lines in devinfo/prtconf output)
# - sun4 kernel architecture, and sun3 and older systems
# - Perl 5.001 is known to have problems with hex number conversions
# - Does not detect unused VSIMMs (another FB installed) or second VSIMM
#
# To Do:
# - Test on untested systems above, adding verbose to those that lack it
# - Add newer systems as they come out
# - Recognize VME bus memory cards in 4/6x0
# - Add Sun clones
#
# Revision History:
# - 29-Jan-1997 - V1.0 - From SunManagers SUMMARY by Howard Modell
#                         (h.modell@ieee.org)
# - 05-Feb-1997 - V1.1 - Ported to SunOS, added slot information, etc.
# - 17-Aug-1998 - V1.2 - Added Ultra-30, Ultra Enterprise 4000/5000.
# - 18-Aug-1998 - V1.2.1 - Added Ultra-5.
# - 20-Aug-1998 - V1.3 - Fixed SS10SX. Added Ultra Enterprise 3000.
# - 02-Sep-1998 - V1.3.1 - Cleanup Ultra 450 recognition.
# - 15-Sep-1998 - V1.4 - Added verbose output for Sun 4/30 LX/ZX and Classic.
# - 17-Sep-1998 - V1.5 - Added verbose output for SPARCserver 1000 & SPARCcenter
#                         2000. Added untested Ultra-60 verbose output.
# - 17-Sep-1998 - V1.5.1 - Fixed Ultra 450.
# - 18-Sep-1998 - V1.6 - Fixed Ultra-60 and Enterprise 3000/4000/5000.
# - 25-Sep-1998 - V1.7 - Use prtdiag on Enterprise systems to handle multiple
#                         system boards.
# - 28-Sep-1998 - V1.8 - Fixed Enterprise systems running Solaris 2.6. Fixed
#                         Ultra 5/10. Changed calculation of top address range.
# - 29-Sep-1998 - V1.9 - Added SS2000.
# - 19-Oct-1998 - V1.9.1 - Fixed stacked module detection.
# - 30-Oct-1998 - V1.9.2 - Sort modules by address range (fixes some stacked
#                         module detection).
# - 04-Nov-1998 - V1.10 - Cleanup for perl4 backward compatibility. Enhanced
#                         Ultra 450 to handle interleaving. Added Ultra 250.
# - 19-Nov-1998 - V1.11 - Added -h for help.
# - 08-Dec-1998 - V1.11.1 - Tested OK on SPARCclassic and SS4.
# - 14-Dec-1998 - V1.12 - Improved Ultra 5/10 memory detection.
# - 29-Dec-1998 - V1.12.1 - Test OK on Enterprise 6000. Cleanup of output on
#                         Enterprise systems.
# - 31-Dec-1998 - V1.12.2 - Test OK on Enterprise 4500/5500.
# - 04-Jan-1999 - V1.12.3 - Cleanup of some minor perl warnings.
# - 11-Jan-1999 - V1.12.4 - Solaris 7 tested OK on some systems, but not tested
#                        on Ultra 250, 450, Enterprise, nor SPARCcenter.
# - 27-Jan-1999 - V1.12.5 - Added verbose output for untested Voyager S240.
# - 28-Jan-1999 - V1.12.6 - Added UltraStation 10.
# - 04-Feb-1999 - V1.13 - Added AXUS 250/450. Fixed Voyager S240.
# - 11-Feb-1999 - V1.13.1 - Detect perl 5.001 bugs. Added exit status. Check
#                        for illegal memory stuffing in SS5 and Ultra 5/10.
# - 15-Feb-1999 - V1.13.2 - Added verbose output for IPX. ELC and SLC untested.
# - 22-Feb-1999 - V1.13.3 - Enhanced VSIMM detection.
# - 12-Mar-1999 - V1.14 - Enhanced Ultra 250, AXUS 250/450. Report empty sockets
#                        in verbose mode for most systems. Solaris 7 tested OK
#                        on Ultra 250, 450.
# - 15-Mar-1999 - V1.15 - Corrected and enhanced Ultra 5/10. Report CPU and
#                        system frequencies in verbose mode.
# - 13-Apr-1999 - V1.15.1 - Always report empty sockets. Tested OK so far on
#                        Solaris 8 beta releases.

# Uncomment for debugging (perl 5 only)
#use diagnostics;

$version = "V1.15.1 13-Apr-1999";
$URL = "http://netnow.micron.net/~tschmidt/unix.html";

if (-f '/vmunix') {
        $BSD = 1;
        if (! -f '/usr/etc/devinfo') {
                print "ERROR: no 'devinfo' command. Aborting.\n";
                exit 1;
        }
        $config_cmd = "/usr/etc/devinfo -pv";
} else {
        $BSD = 0;
        if (! -f '/usr/sbin/prtconf') {
                print "ERROR: no 'prtconf' command. Aborting.\n";
                exit 1;
        }
        $config_cmd = "/usr/sbin/prtconf -pv";
}
$hostname = `/usr/bin/uname -n`;
chop $hostname;
$machine = `/usr/bin/uname -m`;
chop $machine;
$sunos = `/usr/bin/uname -r`;
chop $sunos;
if (-d '/usr/platform') {
        $platform = `/usr/bin/uname -i`;
        chop $platform;
        $prtdiag_cmd = "/usr/platform/$platform/sbin/prtdiag";
} elsif (-f '/usr/kvm/prtdiag') {
        $platform = $machine;
        $prtdiag_cmd = '/usr/kvm/prtdiag';
} else {
        $platform = $machine;
        $prtdiag_cmd = "";
}
$filename = "";
$memory_size = "";
$installed_memory = 0;
$ultra = 0;
$simmbanks = 0;
$simmspergroup = 1;
$bankcnt = 0;
$slot0 = 0;
$smallestsimm = 4096;
$largestsimm = 0;
$found32mb = 0;
$sxmem = 0;
$memtype = "SIMM";
$sockettype = "socket";
$verbose = 0;
$recognized = 1;
$untested = 1;
$perlhexbug = 0;
$exitstatus = 0;
$meg = 1048576;
@socketstr = ("");
@orderstr = ("");
@groupstr = ("");
@bankstr = ("");
@bytestr = ("");
$socket = "";
$order = "";
$group = "";
$bank = "";
$byte = "";
$gotmemory = "";
@boards = "";
$boardfound = 0;
$flag = 0;
$format = 0;
$sockets_used = "";
$sockets_empty = "";
$sortslots = 1;
$devtype = "";
$freq = 0;
$sysfreq = 0;
$cpufreq = 0;
$ncpu = 0;
#
# Parse options
#
if ($#ARGV >= 0) {
        foreach $name (@ARGV) {
                if ("$name" eq "-v") {
                        # verbose mode
                        $verbose = 1;
                } elsif ("$name" eq "-d") {
                        # more verbose debug mode
                        $verbose = 2;
                } elsif (-f "$name") {
                        open(FILE, "<$name");
                        # Test file with prtconf/devinfo output
                        @config = <FILE>;
                        # Test file with prtdiag output
                        @prtdiag = @config;
                        $hostname = "";
                        $filename = "$name";
                } else {
                        &show_help;
                }
        }
}
if ("$filename" eq "") {
        @config = `$config_cmd`;
}

sub show_help {
        print "Usage: memconf [ -v | -h ]\n";
        print "                 -v    verbose mode\n";
        print "                 -h    print help\n";
        print "\nThis is memconf, $version\n\n";
        print "Please send bug reports and enhancement requests along with the output of\n";
        print "\"$config_cmd\" ";
        print "and \"$prtdiag_cmd -v\" " if ($prtdiag_cmd);
        print "\nto tschmidt\@micron.com as E-mail attachments so that ";
        print "memconf can be enhanced.\nCheck my website at ";
        print "$URL to get\n";
        print "the latest version.\n";
        exit;
}

sub show_header {
        print "memconf:  $version $URL\n" if ($verbose);
        print "hostname: $hostname\n" if ($hostname);
        print "filename: $filename\n" if ($filename);
        if ($verbose eq 0) {
                if ($banner) {
                        print "$banner\n";
                } elsif ($model) {
                        print "$model\n";
                }
        } else {
                print "banner:   $banner\n" if ($banner);
                print "model:    $model\n" if ($model);
                print "$ncpu cpu" if ($ncpu > 0 & $cpufreq > 0);
                print "s" if ($ncpu > 1);
                print ", cpu freq: ${cpufreq}MHz, " if ($cpufreq);
                print "system freq: ${sysfreq}MHz\n" if ($sysfreq);
        }
        if ($verbose > 1) {
                print "ultra = $ultra\n" if ($ultra);
                print "memory line: $gotmemory\n" if ($gotmemory);
#                print "module info: $gotmodule\n" if ($gotmodule);
        }
}

sub show_unrecognized {
        print "       This is most likely because memconf does not ";
        print "completely recognize this\n";
        print "       system.\n";
        &show_request;
}

sub show_untested {
        if ($untested == 2) {
                print "WARNING: This is an untested SunOS $sunos operating";
        } else {
                print "ERROR: This is an untested";
        }
        print " system by memconf.\n";
        print "       Please let the author know how it works.\n";
        $exitstatus = 1;
        &show_request;
}

sub show_request {
        print "       Please send the output of \"$config_cmd\" ";
        print "and\n       \"$prtdiag_cmd -v\" " if ($prtdiag_cmd);
        print "to Tom Schmidt\n       (tschmidt\@micron.com) as E-mail ";
        print "attachments so that memconf can be\n";
        print "       enhanced to properly recognize this system. ";
        print "Please include the\n";
        print "       Sun Model and Operating System version. ";
        print "Check my website at\n";
        print "       $URL to get the latest version.\n";
}

$i = 0;
$banner = "";
$model = "";
foreach $line (@config) {
        if ($line =~ /banner-name:/) {
                $banner = $line;
                $banner =~ s/\s+banner-name:\s+//;
                $banner =~ s/'//g;
                chop $banner;
                if ($banner =~ /Enterprise/) { $ultra = "e"; }
                if ($banner =~ /Ultra 1\b/) { $ultra = 1; }
                if ($banner =~ /Ultra 2\b/) { $ultra = 2; }
                if ($banner =~ /Ultra 5\b/) { $ultra = 5; }
                if ($banner =~ /Ultra 10\b/) { $ultra = 10; }
                if ($banner =~ /UltraStation 10\b/) { $ultra = 10; }
                if ($banner =~ /Ultra 30\b/) { $ultra = 30; }
                if ($banner =~ /Ultra 60\b/) { $ultra = 60; }
                if ($banner =~ /\b250\b/) { $ultra = 250; }
                if ($banner =~ /\b450\b/) { $ultra = 450; }
                if ($banner =~ /\bMP-250\b/) { $ultra = "axus250"; }
                if ($banner =~ /UltraAX-MP\b/) { $ultra = "axus450"; }
        }
        if ($line =~ /SUNW,Ultra-/ | $line =~ /SUNW,SPARC/ | $line =~ /Sun 4/ |
            $line =~ /SUNW,S240/ | $line =~ /SUNW,UltraSPARC-IIi-Engine/ |
            $line =~ /SUNW,UltraAX-MP/ ) {
                $model = $line;
                $model =~ s/\s+name:\s+//;
                $model =~ s/'//g;
                $model =~ s/SUNW,//g;
                chop $model;
                if ($model =~ /Ultra-1\b/) { $ultra = 1; }
                if ($model =~ /Ultra-2\b/) { $ultra = 2; }
                if ($model =~ /Ultra-5\b/) { $ultra = 5; }
                if ($model =~ /Ultra-5_10\b/) { $ultra = 5; }
                if ($model =~ /Ultra-30\b/) { $ultra = 30; }
                if ($model =~ /Ultra-60\b/) { $ultra = 60; }
                if ($model =~ /Ultra-250\b/) { $ultra = 250; }
                if ($model =~ /Ultra-4\b/) { $ultra = 450; }
                if ($model =~ /Ultra-Enterprise/) { $ultra = "e"; }
                if ($model =~ /UltraSPARC-IIi-Engine\b/) { $ultra = 10; }
        }
        if ($line =~ /\sname:\s+'memory'/) {
                $j = $i - 2;
                if ($config[$j] =~ /\sreg:\s/) {
                        $gotmemory = $config[$j];
                        chop $gotmemory;
                } elsif ($config[$j - 1] =~ /\sreg:\s/) {
                        $gotmemory = $config[$j - 1];
                        chop $gotmemory;
                }
        }
        if ($line =~ /\sdevice_type:\s+'memory-bank'/) {
                $j = $i - 3;
                if ($config[$j] =~ /\sreg:\s/ & $config[$j] !~ /.00000000$/) {
                        $config[$j] =~ s/\s+reg:\s+//;
                        if ($gotmemory) {
                                $gotmemory .= ".$config[$j]";
                        } else {
                                $gotmemory = $config[$j];
                        }
                        chop $gotmemory;
                }
        }
        # The following is not used yet
        #if ($line =~ /\sdevice_type:\s+'memory-module'/) {
        #        if ($config[$i - 2] =~ /\sreg:\s/) {
        #                $config[$i - 3] =~ s/\s+socket-name:\s+//;
        #                if ($gotmodule) {
        #                        $gotmodule .= ".$config[$i - 3]";
        #                } else {
        #                        $gotmodule = $config[$i - 3];
        #                }
        #                chop $gotmodule;
        #                $config[$i - 2] =~ s/\s+reg:\s+//;
        #                @module = split(/\./, $config[$i - 2]);
        #                $gotmodule .= ".$module[3]";
        #                chop $gotmodule;
        #                $config[$i + 1] =~ s/\s+name:\s+//;
        #                $config[$i + 1] =~ y/[a-z]/[A-Z]/;
        #                $gotmodule .= ".$config[$i + 1]";
        #                chop $gotmodule;
        #                $gotmodule =~ s/'//g;
        #        }
        #}
        if ($line =~ /\sname:\s+'cgfourteen'/) {
                # Determine size of VSIMM
                # Currently assumes only one VSIMM is installed
                if ($config[$i - 2] =~ /\sreg:\s/) {
                        $sx_line = $config[$i - 2];
                        chop $sx_line;
                } elsif ($config[$i - 3] =~ /\sreg:\s/) {
                        $sx_line = $config[$i - 3];
                        chop $sx_line;
                }
                @sxline = split(/\./, $sx_line);
                $sxmem = hex("0x$sxline[5]") / $meg;
        }
        if ($line =~ /Memory size:\s/ & $installed_memory == 0) {
                $memory_size = $line;
                chop $memory_size;
                @memory = split(/\s/, $memory_size);
                $installed_memory = $memory[2];
                $BSD = 0;        # prtconf only has this output
                $config_cmd = "/usr/sbin/prtconf -pv";
        }
        if ($sysfreq == 0 & $freq > 0) {
                $sysfreq = $freq;
                $freq = 0;
        }
        if ("$devtype" eq "cpu" & $freq > 0) {
                $cpufreq = $freq;
                $freq = 0;
                $devtype = "";
                $ncpu++;
        }
        if ($line =~ /device_type:/) {
                @dev_line = split(/\'/, $line);
                $devtype = $dev_line[1];
        }
        if ($line =~ /clock-frequency:/) {
                @freq_line = split(' ', $line);
                $freq = int(hex("0x$freq_line[1]") / 1000000 + 0.5);
        }
        $i++;
}
$sysfreq = $freq if ($sysfreq == 0 & $freq > 0);
if ("$devtype" eq "cpu" & $freq > 0) {
        $cpufreq = $freq;
        $ncpu++;
}
$cpufreq = $sysfreq if ($sysfreq > $cpufreq & $ncpu > 0);
if ("$model" eq "Ultra-5_10" | $ultra eq 5 | $ultra eq 10) {
        $ultra = ($sysfreq > 91) ? 10 : 5;
}

if ("$gotmemory" eq "") {
        &show_header;
        print "total memory = ${installed_memory}MB\n" if ($installed_memory);
        print "ERROR: no 'memory' line in \"$config_cmd\" output.\n";
        &show_unrecognized if (! $BSD);
        exit 1;
}

$gotmemory =~ s/\s+reg:\s+//;
$gotmemory =~ s/'//g;
@slots = split(/\./, $gotmemory);
$slot = 1;
$totmem = 0;
$startx = 0;
&show_header;
# DIMMs are installed in pairs on Ultra 1, 5, and 10; quads on
# Ultra 2, 60, 450; 8's in Enterprise
if ($ultra) {
        $val0 = 3;        # simmsize is in 4th field
        $valaddr = 2;        # address is 2 fields before simmsize
        $valinc = 4;        # fields per simm
        $memtype = "DIMM";
} else {
        $val0 = 2;        # simmsize is in 3rd field
        $valaddr = 1;        # address is 1 field before simmsize
        $valinc = 3;        # fields per simm        # fields per simm
}

#
# define SIMM layout for specific systems
#
if ("$model" eq "Sun 4/20") {
        # SLC accepts 4MB SIMMs on motherboard
        $untested = 1;
        $simmrangex = "01000000";
        $simmbanks = 4;
        $simmsperbank = 1;
        @socketstr = ("U0502","U0501","U0602","U0601");
}
if ("$model" eq "Sun 4/25") {
        # ELC accepts 4MB or 16MB SIMMs on motherboard
        $untested = 1;
        $simmrangex = "01000000";
        $simmbanks = 4;
        $simmsperbank = 1;
        @socketstr = ("U0407","U0408","U0409","U0410");
        @bankstr = ("MEM1","MEM2","MEM3","MEM4");
}
if ("$model" eq "Sun 4/50") {
        # IPX accepts 4MB or 16MB SIMMs on motherboard
        $untested = 0;
        $simmrangex = "01000000";
        $simmbanks = 4;
        $simmsperbank = 1;
        @socketstr = ("U0310","U0309","U0308","U0307");
        @bankstr = (0,1,2,3);
}
if ("$model" eq "Sun 4/75") {
        # SS2 accepts 4MB SIMMs on motherboard and 32MB or 64MB SBus expansion
        # card
        $untested = 0;
        $simmrangex = "01000000";
        $simmbanks = 4;
        $simmsperbank = 4;
        @socketstr = ("U0311","U0309","U0307","U0322","U0312","U0310","U0308","U0321","U0313","U0314","U0315","U0320","U0319","U0318","U0317","U0316");
        @bankstr = (0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3);
        @bytestr = (0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3);
}
if ("$model" =~ /SPARCstation-LX/ | "$model" =~ /SPARCclassic/) {
        # LX (4/30) and Classic (4/15) accept 4MB and 16MB SIMMs on motherboard
        # Classic-X (4/10) accepts 1MB, 2MB and 4MB SIMMs on motherboard
        $untested = 0;
        $simmrangex = "02000000";
        $simmbanks = 3;
        $simmsperbank = 2;
        @socketstr = ("U0304","U0303","U0301","U0302","U0402","U0401");
        @bankstr = (1,1,2,2,3,3);
}
if ("$model" eq "S240") {
        # Voyager has 16MB on motherboard, plus accepts one or two 16MB or 32MB
        # Memory cards
        # Motherboard, address 0x00000000 - 0x007fffff, 0x01000000 - 0x017fffff
        # Lower slot = Mem 1, address 0x02000000 - 0x07ffffff
        # Upper slot = Mem 2, address 0x0a000000 - 0x0fffffff
        $untested = 0;
        $memtype = "memory card";
        $sockettype = "slot";
        $simmrangex = "02000000";
        $simmbanks = 8;        # Count the skipped address range
        $simmsperbank = 1;
        @socketstr = ("Motherboard","Mem 1","Mem 1","Mem 1","?","Mem 2","Mem 2","Mem 2");
        @orderstr = ("Motherboard","Lower slot","Lower slot","Lower slot","?","Upper slot","Upper slot","Upper slot");
}
if ("$model" eq "SPARCstation-4") {
        # Accepts 8MB and 32MB SIMMs on motherboard
        $untested = 0;
        $simmrangex = "02000000";
        $simmbanks = 5;
        $simmsperbank = 1;
        @socketstr = ("J0301","J0302","J0303","J0304","J0305");
        @bankstr = (0,1,2,3,4);
}
if ("$model" eq "SPARCstation-5") {
        # Accepts 8MB and 32MB SIMMs on motherboard
        $untested = 0;
        $simmrangex = "02000000";
        $simmbanks = 8;
        $simmsperbank = 1;
        @socketstr = ("J0300","J0301","J0302","J0303","J0400","J0401","J0402","J0403");
        @bankstr = (0,1,2,3,4,5,6,7);
}
if ("$model" =~ /SPARCstation-10/) {
        # Accepts 16MB and 64MB SIMMs on motherboard
        $untested = 0;
        $simmrangex = "04000000";
        $simmbanks = 8;
        $simmsperbank = 1;
        @socketstr = ("J0201","J0203","J0302","J0304","J0202","J0301","J0303","J0305");
        @orderstr = ("1st","3rd","4th","2nd","8th","6th","5th","7th");
        @bankstr = (0,1,2,3,4,5,6,7);
}
if ("$model" eq "SPARCstation-20") {
        # Accepts 16MB, 32MB and 64MB SIMMs on motherboard
        $untested = 0;
        $simmrangex = "04000000";
        $simmbanks = 8;
        $simmsperbank = 1;
        @socketstr = ("J0201","J0303","J0202","J0301","J0305","J0203","J0302","J0304");
        @orderstr = ("1st","2nd","3rd","4th","5th","6th","7th","8th");
        @bankstr = (0,1,2,3,4,5,6,7);
}
if ("$model" eq "SPARCsystem-600") {
        # Accepts 4MB or 16MB SIMMs on motherboard, 1MB or 4MB SIMMs on VME
        # expansion card
        $untested = 0;
        $simmrangex = "10000000";
        $simmbanks = 2;
        $simmsperbank = 16;
        @socketstr = ("U1107","U1307","U1105","U1305","U1103","U1303","U1101","U1301","U1207","U1407","U1205","U1405","U1203","U1403","U1201","U1401","U1108","U1308","U1106","U1306","U1104","U1304","U1102","U1302","U1208","U1408","U1206","U1406","U1204","U1404
","U1202","U1402");
        @bankstr = (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1);
        @bytestr = ("0L0","0L1","1L0","1L1","2L0","2L1","3L0","3L1","4L0","4L1","5L0","5L1","6L0","6L1","7L0","7L1","0H0","0H1","1H0","1H1","2H0","2H1","3H0","3H1","4H0","4H1","5H0","5H1","6H0","6H1","7H0","7H1");
}
if ("$model" eq "SPARCserver-1000" | "$model" eq "SPARCcenter-2000") {
        # Accepts 8MB and 32MB SIMMs on motherboard
        $untested = 0;
        $untested = 2 if ($sunos =~ /5.[7-9]/);
        @prtdiag = `$prtdiag_cmd` if ("$filename" eq "");
        foreach $line (@prtdiag) {
                if ($line =~ /Memory Units:/ | $line =~ /===== Memory =====/) {
                        # Start of memory section
                        $flag = 1;
                }
                if ($line =~ /IO Cards/ | $line =~ /SBus Cards/) {
                        # End of memory section
                        $flag = 0;
                }
                if ($flag == 1) {
                        @boards = "@boards$line";
                        $boardfound = 1;
                }
        }
        if ($boardfound) {
                print "@boards";
                print "Each memory unit group is comprised of 4 SIMMs\n";
        } else {
                $recognized = 0;
        }
        $totmem = $installed_memory;
        goto finish;
}
if ($ultra =~ /axus/) {
        # AXUS clones, no verbose output
        $untested = 0;
        $totmem = $installed_memory;
        goto finish;
}
if ("$model" eq "Ultra-1" | $ultra eq 1) {
        # Accepts 16MB, 32MB, 64MB or 128MB DIMMs on motherboard
        $untested = 0;
        $memtype = "DIMM";
        $simmrangex = "10000000";
        $simmbanks = 4;
        $simmsperbank = 2;
        @socketstr = ("U0701","U0601","U0702","U0602","U0703","U0603","U0704","U0604");
        @bankstr = ("0L","0H","1L","1H","2L","2H","3L","3H");
        @bytestr = ("00-15","16-31","00-15","16-31","00-15","16-31","00-15","16-31");
}
if ("$model" eq "Ultra-2" | $ultra eq 2) {
        # Accepts 16MB, 32MB, 64MB or 128MB DIMMs on motherboard
        $untested = 0;
        $memtype = "DIMM";
        $simmrangex = "20000000";
        $simmbanks = 4;
        $simmsperbank = 4;
        @socketstr = ("U0501","U0401","U0701","U0601","U0502","U0402","U0702","U0602","U0503","U0403","U0703","U0603","U0504","U0404","U0704","U0604");
        @groupstr = (0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3);
        @bankstr = ("0L","0H","1L","1H","0L","0H","1L","1H","0L","0H","1L","1H","0L","0H","1L","1H");
        @bytestr = ("00-15","16-31","32-47","48-63","00-15","16-31","32-47","48-63","00-15","16-31","32-47","48-63","00-15","16-31","32-47","48-63");
}
if ("$model" eq "Ultra-30" | $ultra eq 30) {
        # Accepts 16MB, 32MB, 64MB or 128MB DIMMs on motherboard
        $untested = 0;
        $memtype = "DIMM";
        $simmrangex = "20000000";
        $simmbanks = 4;
        $simmsperbank = 4;
        @socketstr = ("U0701","U0801","U0901","U1001","U0702","U0802","U0902","U1002","U0703","U0803","U0903","U1003","U0704","U0804","U0904","U1004");
        @bankstr = ("0L","0L","0H","0H","1L","1L","1H","1H","2L","2L","2H","2H","3L","3L","3H","3H");
}
if ("$model" eq "Ultra-5_10" | $ultra eq 5 | $ultra eq 10) {
        # Accepts 16MB, 32MB, 64MB, 128MB, or 256MB DIMMs on motherboard
        # 16MB DIMM uses 10-bit column addressing
        # 32, 64, 128, and 256MB DIMMs use 11-bit column addressing
        # Do not mix 16MB DIMMs with other sizes
        # 256MB DIMM not supported in Ultra 5
        # Bank 0 DIMM1/DIMM2 0x00000000 - 0x0fffffff, 0x20000000 - 0x2fffffff
        # Bank 1 DIMM3/DIMM4 0x10000000 - 0x1fffffff, 0x30000000 - 0x3fffffff
        $untested = 0;
        $memtype = "DIMM";
        $simmrangex = "10000000";
        $simmbanks = 2;
        $simmsperbank = 2;
        @socketstr = ("DIMM1","DIMM2","DIMM3","DIMM4");
        @bankstr = ("0L","0H","1L","1H");
        $sortslots = 0;
}
if ("$model" eq "Ultra-60" | $ultra eq 60) {
        # Accepts 16MB, 32MB, 64MB or 128MB DIMMs on motherboard
        # U1001-U1004 bank 3 address 0xa0000000 - 0xbfffffff
        # U0901-U0904 bank 2 address 0x80000000 - 0x9fffffff
        # U0801-U0804 bank 1 address 0x20000000 - 0x3fffffff
        # U0701-U0704 bank 0 address 0x00000000 - 0x1fffffff
        $untested = 0;
        $memtype = "DIMM";
        $simmrangex = "20000000";
        $simmbanks = 6;        # Count the skipped address range
        $simmsperbank = 4;
        @socketstr = ("U0701","U0702","U0703","U0704","U0801","U0802","U0803","U0804","?","?","?","?","?","?","?","?","U0901","U0902","U0903","U0904","U1001","U1002","U1003","U1004");
        @bankstr = ("0","0","0","0","1","1","1","1","?","?","?","?","?","?","?","?","2","2","2","2","3","3","3","3");
}
if ("$model" eq "Ultra-4" | "$model" eq "Ultra-250" | $ultra eq 250 | $ultra eq 450) {
        # Accepts 16MB, 32MB, 64MB, 128MB or 256MB DIMMs on motherboard
        $untested = 0;
        $untested = 2 if ($sunos =~ /5.[8-9]/);
        @prtdiag = `$prtdiag_cmd` if ("$filename" eq "");
        foreach $line (@prtdiag) {
                if ($line =~ /IO Cards/) {
                        # End of memory section
                        $flag = 0;
                }
                if ($flag >= 1) {
                        if ($line ne "\n") {
                                @boards = "@boards$line" if ($line ne "\n");
                                $boardfound = 1;
                                @linearr = split(' ', $line);
                                if ("$linearr[2]" =~ /\bU\d\d\d\d\b/) {
                                        $sockets_used = "$sockets_used $linearr[2]";
                                } elsif ("$linearr[2]" =~ /\b\d\d\d\d\b/) {
                                        $sockets_used = "$sockets_used U$linearr[2]";
                                }
                        }
                }
                if ($line =~ /Memory Units:/) {
                        # Start of memory section, Solaris 2.5.1 format
                        $flag = 1;
                        $format = 1;
                }
                if ($line =~ /===== Memory =====/) {
                        # Start of memory section, Solaris 2.6 and 2.7 format
                        $flag = 1;
                        $format = 2;
                }
                if ($flag == 1 & $line =~ /------/) {
                        # Next lines are the memory on each system board
                        $flag = 2;
                }
        }
        if ("$model" eq "Ultra-4" | $ultra eq 450) {
                $memtype = "DIMM";
                $simmrangex = "40000000";
                $simmbanks = 4;
                $simmsperbank = 4;
                @socketstr = ("U1901","U1902","U1903","U1904","U1801","U1802","U1803","U1804","U1701","U1702","U1703","U1704","U1601","U1602","U1603","U1604");
                @groupstr = ("A","A","A","A","B","B","B","B","C","C","C","C","D","D","D","D");
                @bankstr = (2,2,2,2,3,3,3,3,0,0,0,0,1,1,1,1);
        } elsif ("$model" eq "Ultra-250" | $ultra eq 250) {
                $memtype = "DIMM";
                $simmrangex = "40000000";
                $simmbanks = 4;
                $simmsperbank = 4;
                @socketstr = ("U0701","U0801","U0901","U1001","U0702","U0802","U0902","U1002","U0703","U0803","U0903","U1003","U0704","U0804","U0904","U1004");
                @bankstr = ("A","A","A","A","B","B","B","B","C","C","C","C","D","D","D","D");
        }
        if ($boardfound) {
                print "@boards";
                $totmem = $installed_memory;
                goto finish;
        }
}
if ("$model" eq "Ultra-Enterprise" | $ultra eq "e") {
        # E3x00/E4x00/E5x00/E6x00 accepts 8MB, 32MB or 128MB DIMMs on
        # motherboard, 2 banks of 8 DIMMs per board.
        $untested = 1;
        $untested = 0 if ($banner =~ /\bE?[3-6][05]00\b/);
        $untested = 2 if ($sunos =~ /5.[7-9]/);
        @prtdiag = `$prtdiag_cmd` if ("$filename" eq "");
        foreach $line (@prtdiag) {
                if ($line =~ /Memory Units:/) {
                        # Start of memory section, Solaris 2.5.1 format
                        $flag = 1;
                        $format = 1;
                }
                if ($line =~ /===== Memory =====/) {
                        # Start of memory section, Solaris 2.6 format
                        $flag = 1;
                        $format = 2;
                }
                if ($line =~ /IO Cards/) {
                        # End of memory section
                        $flag = 0;
                }
                if ($flag == 2 & $line ne "\n") {
                        if ($format == 1) {
                                # Memory on each system board
                                $mem0 = substr($line,10,4);
                                $mem0 = 0 if ("$mem0" !~ /\d+/);
                                $dimm0 = $mem0 / 8;
                                if ($dimm0 > 0) {
                                        $dimms0 = sprintf("8x%3d", $dimm0);
                                } else {
                                        $dimms0 = "     ";
                                }
                                $mem1 = substr($line,34,4);
                                $mem1 = 0 if ("$mem1" !~ /\d+/);
                                $dimm1 = $mem1 / 8;
                                if ($dimm1 > 0) {
                                        $dimms1 = sprintf("8x%3d", $dimm1);
                                } else {
                                        $dimms1 = "     ";
                                }
                                if ($dimm0 == 0 & $dimm1 == 0) {
                                        $newline = "";
                                } else {
                                        $newline = substr($line,0,16) . $dimms0;
                                        $newline .= substr($line,16,24);
                                        if ($dimm1 > 0) {
                                                $newline .= $dimms1;
                                                $newline .= substr($line,39,16);
                                        }
                                }
                                @boards = "@boards$newline";
                                $boardfound = 1;
                        }
                        if ($format == 2) {
                                # Memory on each system board
                                $mem = substr($line,12,4);
                                $mem = 0 if ("$mem" !~ /\d+/);
                                $dimm = $mem / 8;
                                if ($dimm > 0) {
                                        $dimms = sprintf("8x%3d", $dimm);
                                        $newline = substr($line,0,18) . $dimms;
                                        $newline .= substr($line,16,47);
                                        @boards = "@boards$newline";
                                        $boardfound = 1;
                                } else {
                                        $flag = 0;
                                }
                        }
                }
                if ($flag == 1 & $line =~ /------/) {
                        # Next lines are the memory on each system board
                        $flag = 2;
                }
        }
        if ($boardfound) {
                if ($format == 1) {
                        print "                   Bank 0                       Bank 1\n";
                        print "          J3100-J3800   Interleave     J3101-J3801   Interleave\n";
                        print "           MB   DIMMs  Factor  With     MB   DIMMs  Factor  With\n";
                        print "          ----  -----  ------  ----    ----  -----  ------  ----\n";
                        print "@boards";
                }
                if ($format == 2) {
                        print "                                                     Intrlv.  Intrlv.\n";
                        print "Brd   Bank   MB   DIMMs   Status   Condition  Speed   Factor   With\n";
                        print "---  -----  ----  -----  -------  ----------  -----  -------  -------\n";
                        print "@boards";
                        print "Bank 0 uses sockets J3100-J3800, Bank 1 uses sockets J3101-J3801\n";
                }
        } else {
                $recognized = 0;
        }
        $totmem = $installed_memory;
        goto finish;
}

if ($sortslots) {
        for($val=$val0; $val < scalar(@slots); $val += $valinc) {
                $mods{$slots[$val - $valaddr]} = $slots[$val];
        }
        for(sort keys %mods) {
                push(@newslots, "$_");
                push(@newslots, "$mods{$_}");
        }
} else {
        for($val=$val0; $val < scalar(@slots); $val += $valinc) {
                push(@newslots, "$slots[$val - $valaddr]");
                push(@newslots, "$slots[$val]");
        }
}

for($val=0; $val < scalar(@newslots); $val += 2) {
        $simmaddr = $newslots[$val];
        $simmsz = $newslots[$val + 1];
        $simmsize = hex("0x$simmsz") / $meg;
        $perlhexbug = 1 if ($simmsize < 0);
        $totmem += $simmsize;

        if ("$model" eq "Sun 4/75" & $simmbanks < $bankcnt + 2) {
                # SS2 SBus memory card
                if ("$simmaddr" eq "08000000") {
                        print "SBus primary contains ";
                } else {
                        print "SBus secondary contains ";
                }
                $simmstart = hex("0x$simmaddr");
                $perlhexbug = 1 if ($simmstart < 0);
                $simmrange = hex("0x$simmrangex");
                $perlhexbug = 1 if ($simmrange < 0);
                $simmstop = sprintf("%08lx", $simmstart + (2 * $simmrange) - 1);
                $totmem += $simmsize;
                $simmsize *= 2;
                $val += 2;
                print "${simmsize}MB";
                print " (address 0x$simmaddr - 0x$simmstop)" if ($verbose);
                print "\n";
        } elsif ($simmbanks > 0) {
                $simmstart = hex("0x$simmaddr");
                $perlhexbug = 1 if ($simmstart < 0);
                $simmrange = hex("0x$simmrangex");
                $perlhexbug = 1 if ($simmrange < 0);
                $simmstop = sprintf("%08lx", $simmstart + ($simmsize * $meg / $simmsperbank) - 1);
                $cnt = 0;
                $maxcnt = $simmbanks * $simmsperbank / $simmspergroup;
                while ($cnt < $maxcnt) {
                        if ($simmstart >= ($simmrange * $cnt) & $simmstart < ($simmrange * ($cnt + 1))) {
                                $bankcnt = $cnt;
                                $cnt3 = ($bankcnt * $simmsperbank / $simmspergroup);
                                $socket = $socketstr[$cnt3] if ($#socketstr);
                                $order = $orderstr[$cnt3] if ($#orderstr);
                                $group = $groupstr[$cnt3] if ($#groupstr);
                                $bank = $bankstr[$cnt3] if ($#bankstr);
                                $byte = $bytestr[$cnt3] if ($#bytestr);
                        }
                        $cnt++;
                }
                #
                # Check for stacked DIMMs. A 128MB DIMM is sometimes seen as 2
                # 64MB DIMMs with a hole in the address range. This may report
                # more slots than are really in a system. (i.e. a SS20 with
                # 8 32MB SIMMs reports 16 slots of 16MB each).
                #
                $stacked = 0;
                if ($val < $#newslots - 2) {
                        if ("$model" eq "Ultra-5_10" | $ultra eq 5 | $ultra eq 10) {
                                $start = $simmstart + ($simmrange * 2);
                                $startx = sprintf("%08lx", $start);
                                $stacked = 1 if ($newslots[$val + 2] eq $startx & $newslots[$val + 3] eq $simmsz);
                        } else {
                                $start = $simmstart + ($simmrange / 2);
                                $startx = sprintf("%08lx", $start);
                                $stacked = 1 if ($newslots[$val + 2] eq $startx & $newslots[$val + 3] eq $simmsz & ($simmsize ne 64));
                        }
                        if ($stacked) {
                                $totmem += $simmsize;
                                $simm2stop = sprintf("%08lx", $start + ($simmsize * $meg / $simmsperbank) - 1);
                                $simmstop .= ", 0x$startx - 0x$simm2stop";
                                $simmsize *= 2;
                                $val += 2;
                                $found32mb = 1 if ($simmsize == 32);
                        }
                }
                #
                # Check for Voyager memory cards. A 32MB memory card is seen
                # as 4 8MB memory blocks with holes in the address range.
                #
                if ("$model" eq "S240" & $simmstart > 0 & $simmsize == 16 & $val < $#newslots - 4) {
                        $start = hex("0x$newslots[$val + 4]") - hex("0x$newslots[$val]");
                        $perlhexbug = 1 if ($start < 0);
                        $startx = sprintf("%08lx", $start);
                        if ($newslots[$val + 1] eq "00800000" & $newslots[$val + 3] eq "00800000" & $startx eq "04000000") {
                                $totmem += $simmsize;
                                $startx = $newslots[$val + 2];
                                $start = hex("0x$startx");
                                $perlhexbug = 1 if ($start < 0);
                                $simm2stop = sprintf("%08lx", $start + ($simmsize * $meg / $simmsperbank) - 1);
                                $simmstop .= ", 0x$startx - 0x$simm2stop";
                                $startx = $newslots[$val + 4];
                                $start = hex("0x$startx");
                                $perlhexbug = 1 if ($start < 0);
                                $simm2stop = sprintf("%08lx", $start + ($simmsize * $meg / $simmsperbank) - 1);
                                $simmstop .= ", 0x$startx - 0x$simm2stop";
                                $simmsize *= 2;
                                $val += 4;
                        }
                }
                $slot0 = $simmsize if ($simmstart == 0);
                $smallestsimm = $simmsize if ($simmsize < $smallestsimm);
                $largestsimm = $simmsize if ($simmsize > $largestsimm);

                $cnt2 = 0;
                $maxcnt2 = $simmsperbank / $simmspergroup;
                while ($cnt2 < $maxcnt2) {
                        $socket = '?' if ("$socket" eq "");
                        $recognized = 0 if ("$socket" eq "?");
                        $sockets_used = "$sockets_used $socket";
                        if ($simmspergroup > 1) {
                                print "${sockettype}s $socket have $simmsperbank ";
                                print $simmsize/$simmsperbank . "MB ${memtype}s";
                        } else {
                                if ($socket eq "Motherboard") {
                                        print "$socket has ";
                                        print $simmsize/$simmsperbank . "MB";
                                } else {
                                        print "${sockettype} $socket has a ";
                                        print $simmsize/$simmsperbank . "MB $memtype";
                                }
                        }
                        if ($verbose) {
                                print " (";
                                if ("$order" ne "") {
                                        if ("$memtype" eq "memory card") {
                                                print "$order, ";
                                        } else {
                                                print "$order $memtype, ";
                                        }
                                }
                                print "group $group, " if ("$group" ne "");
                                print "bank $bank, " if ("$bank" ne "");
                                print "byte $byte, " if ("$byte" ne "");
                                print "address 0x$simmaddr - 0x$simmstop)";
                        }
                        print "\n";
                        $cnt2++;
                        $cnt3 = ($bankcnt * $simmsperbank / $simmspergroup) + $cnt2;
                        $socket = $socketstr[$cnt3] if ($#socketstr);
                        $order = $orderstr[$cnt3] if ($#orderstr);
                        $group = $groupstr[$cnt3] if ($#groupstr);
                        $bank = $bankstr[$cnt3] if ($#bankstr);
                        $byte = $bytestr[$cnt3] if ($#bytestr);
                }
        } elsif ($ultra eq 1 | $ultra eq 5 | $ultra eq 10 | $ultra eq 30) {
                print "bank $slot has a pair of " . $simmsize/2 . "MB DIMMs\n";
        } elsif ($ultra eq 2 | $ultra eq 250 | $ultra eq 450) {
                print "group $slot has four " . $simmsize/4 . "MB DIMMs\n";
        } elsif ($ultra eq 60) {
                print "group $slot has four " . $simmsize/2 . "MB DIMMs\n";
        } elsif ($ultra eq "e") {
                print "group $slot has eight " . $simmsize/8 . "MB DIMMs\n";
        } elsif ($socket eq "Motherboard") {
                print "$slot has ${simmsize}MB\n";
        } else {
                print "slot $slot has a ${simmsize}MB $memtype\n";
        }
        $slot++;
}
if ($sxmem) {
        # Currently assumes only one VSIMM is installed.
        # Auxiliary Video Board 501-2020 (SS10SX) or 501-2488 (SS20) required
        # if two VSIMMs are installed.
        if ("$model" eq "SPARCstation-20") {
                # SS20 first VSIMM in J0304/J0407, second in J0305/J0406
                print "sockets J0304/J0407";
                $sockets_used = "$sockets_used J0304";
        } else {
                # SS10SX first VSIMM in J0301/J1203, second in J0202/J1201
                print "sockets J0301/J1203";
                $sockets_used = "$sockets_used J0301";
        }
        print " have a ${sxmem}MB VSIMM installed for SX (CG14) graphics\n";
}

finish:
#
# Check for empty sockets
#
if ($#socketstr > 0) {
        print "empty ${sockettype}s:";
        foreach $socket (@socketstr) {
                if ("$socket" ne "?") {
                        if ("$sockets_used" !~ /\b$socket\b/ & 
                            "$sockets_empty" !~ /\b$socket\b/) {
                                $sockets_empty = "$sockets_empty $socket";
                        }
                }
        }
        if ("$sockets_empty" ne "") {
                print "$sockets_empty\n";
        } else {
                print " None\n";
        }
}

#
# Print total memory
#
print "total memory = ${totmem}MB\n";

#
# Check for illegal SIMM stuffings
#
if ("$model" eq "Sun 4/50" | "$model" eq "Sun 4/25") {        # IPX, ELC
        if ($slot0 != 16 & $largestsimm == 16 & $sunos =~ /4.1.1/) {
                print "ERROR: Install the highest capacity 16MB SIMM in ";
                print "socket $socketstr[0] under SunOS 4.1.1.\n";
                $exitstatus = 1;
        }
}
if ("$model" =~ /SPARCstation-10/) {
        if ($slot0 < $largestsimm & $BSD) {
                print "ERROR: Install the highest capacity SIMM in socket ";
                print "$socketstr[0] under Solaris 1.X.\n";
                $exitstatus = 1;
        }
        if ($found32mb) {
                print "ERROR: The 32MB SIMM is not supported in the SS10 ";
                print "or SS10SX.\n";
                $exitstatus = 1;
        }
}
if ("$model" eq "SPARCstation-5") {
        if ($slot0 < $largestsimm & $BSD) {
                print "ERROR: Install the highest capacity SIMM in socket ";
                print "$socketstr[0] under Solaris 1.X.\n";
                $exitstatus = 1;
        }
}
if ("$model" eq "Ultra-5_10" | $ultra eq 5 | $ultra eq 10) {
        # Look for 16MB DIMMs (32MB pairs)
        if ($smallestsimm == 32 & $largestsimm > 32) {
                print "ERROR: 16MB DIMMs cannot be mixed with larger DIMMs ";
                print "on Ultra 5/10 systems.\n";
                $exitstatus = 1;
        }
}
if ($ultra eq 5) {
        # Look for 256MB DIMMs (512MB pairs)
        if ($largestsimm == 512) {
                print "ERROR: 256MB DIMMs cannot be used on Ultra 5 systems.\n";
                $exitstatus = 1;
        }
}

#
# Check for buggy perl version
#
if ($perlhexbug) {
        $_ = $];
        ($VERS) = /(\d\.\d{3}).*/;
        print "ERROR: Perl V5.001 is known to be buggy.\n" if ($VERS == 5.001);
        print "ERROR: Perl V5.002 or later is recommended for best results.\n" if ($VERS < 5.002);
        exit 1;
}

#
# Check for possible memory detection errors by this program
#
if ($recognized == 0) {
        print "ERROR: Layout of memory ${sockettype}s not completely ";
        print "recognized on this system.\n";
        $exitstatus = 1;
}
if ($installed_memory > 0) {
        if ($installed_memory != $totmem) {
                print "ERROR: Total memory installed (${installed_memory}MB) ";
                print "does not match total memory found.\n";
                $recognized = 0;
                $exitstatus = 1;
        }
}
&show_unrecognized if ($recognized == 0);
$untested = 2 if ($sunos =~ /5.[8-9]/);                # Future/Beta SunOS releases
&show_untested if ($untested);
exit $exitstatus;