Subversion Repositories w11

#!/usr/bin/perl -w

# $Id: pi_rri 314 2010-07-09 17:38:41Z mueller $

#

# Copyright 2007-2010 by Walter F.J. Mueller 

#

# This program is free software; you may redistribute and/or modify it under

# the terms of the GNU General Public License as published by the Free

# Software Foundation, either version 2, 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 complete details.

#

#  Revision History:

# Date         Rev Version  Comment

# 2010-06-27   310   1.6.2  fix autoflush for fh_log; duplicate exec err to log

# 2010-06-18   306   1.6.1  PDPCP_ADDR_IBRB now 020, PDPCP_ADDR_IBR now 0200;

#                           ibrbase now just drops the 6 lsb's; pdpcp mode:

#                           rename librb -> wibrb; finished cp/rri overhaul

# 2010-06-13   305   1.6    change PDPCP_ADDR_ assignments, add PDPCP_FUNC_

#                           constants; adapt pdpcp mode to changed rri addr and

#                           stim file format; emulate old 'sta' behaviour with

#                           new 'stapc' command; rename lal,lah -> wal,wah and

#                           implement locally; adapt serv11 mode to new rri

# 2010-06-11   303   1.5.1  add cmd_inter; flush{"line"} after interactive cmd

#                           added readline support.

# 2010-06-07   302   1.5    use sop/eop framing instead of soc+chaining

# 2010-06-06   301   1.4.18 rename .rpmon->.rbmon; NCOMM=4 (new eop,nak commas)

# 2010-06-03   299   1.4.17 adapt .reset to new rbus init decode

# 2010-05-05   288   1.4.16 first preliminary implementation of eval based

#                           perl macro's via @@pmac; add ^C signal handler;

#                           added optional min/max check for cget_gdat() and

#                           cget_tagval_gdat().

# 2010-05-02   287   1.4.15 enable hardware flow control in termios

# 2010-05-01   286   1.4.14 add .sinit command for rri and pdpcp modes;

#                           add 500k,1M,2M,3M baudrates, check value now

# 2010-04-26   284   1.4.13 add error check for GetOptions

# 2010-04-25   283   1.4.12 raw_rcv9_to: handle undef as return value correctly

# 2009-10-11   244   1.4.11 support > 115kbaud speed; new stat output in log;

#                           use nxbuf_max=8 as default;

# 2009-09-27   242   1.4.10 add "ERR  --" messages in log file; fix usage of

#                           uninitialized vars in serv11_exec_probe();

# 2009-09-25   241   1.4.9  BUGFIX: serv11_server_attn_get() now or's attn bits

# 2009-09-20   240   1.4.8  serv11_rri_uset cache under $ctl, not in unittbl

# 2009-09-13   238   1.4.7  add ctlname for DL11 log entries; only TTA output

#                           written to stdout when no terminal attached.

# 2009-07-26   236   1.4.6  fix cpraw mode and .mode error handling;

# 2009-07-12   233   1.4.5  add attach/detach support for term; telnet support;

# 2009-07-05   232   1.4.4  add cchk_number(), cget_regrange(); rename _atdt_ to

#                           _attdet_; serv11: add exa/dep command; removed

#                           rr[0-7], wr[0-7], rmem, and wmem commands; new probe

#                           handling, use {probe_[ir]val} and {probemask};

#                           serv11: command parser supports abbeviations;

#                           serv11: add set/sho command, reorganize ls* cmds;

#                           serv11: add {trace} parameter; rri_sideband() flush;

# 2009-07-04   231   1.4.3  first reglist definitions; add CPU in _ctltbl;

#                           add serv11_probe_cpu();

# 2009-06-28   230   1.4.2  use serv11_atdt_pc11(), remove atdt via ucb hack;

#                           add serv11_rri_uset(); pc11 now fully supported;

#                           attn log message now gives device; use -e as file

#                           test; add ptape boot mode support; lsconf output

#                           sorted by ibus address;

# 2009-06-21   228   1.4.1  BUGFIX: correct typo in RK6 ucb; reorganize init

#                           handling, introduce usethdl; reorganize attach;

#                           add atdthdl at ctl or ucb level; add det command;

# 2009-06-20   227   1.4    nxbuf_min,max,inc now a ctl property;

# 2009-06-14   226   1.3.31 add very preliminary lp11 device handling

# 2009-06-11   225   1.3.30 quick hack to add dl11 log files.

# 2009-05-30   220   1.3.29 add papertape boot code;

# 2009-05-24   219   1.3.28 add papertape hook as dev "PC" units "PTR" and "PTP"

# 2009-05-21   217   1.3.27 rk11: now error message when init not done

# 2009-05-17   216   1.3.26 BUGFIX:rk11: fix read/write logic for short sectors;

#                           BUGFIX:rk11: re-work the seek complete handling

#                           add read/write check support; add PGE error support;

# 2009-05-13   215   1.3.25 dl11: drop parity bit in transmit path;

#                           rk11: add read/write format; set SOK at init time;

# 2009-05-10   214   1.3.24 BUGFIX: in serv11_attn_rk11() RKER was written

#                           instead of RKMR for RKCS_DRESET, _WLOCK, _SEEK

# 2009-04-11   206   1.3.23 add --int to force interactive mode

#                           fix handling of odd length records in lsabs

# 2008-12-14   177   1.3.22 correct DL11_BASE_B to 176500 (was RL address)

# 2008-11-28   173   1.3.21 serv11_rri_lalh(): allow now mode =0,1,2 and 3;

#                           serv11_rdma_rk11(): use mode=3 in rri_lalh, thus

#                           enable 22bit and ubmap simultaneously.

#                           add proper MEX update for RKCS in rdma_rk11.

#                           add proper DRSEL propagation for RKDA in rdma_rk11.

# 2008-05-30   151   1.3.20 BUGFIX: corrected @que_rcv logic in serv11 input

#                           loop, TT0 output will not longer hang sometimes;

#                           disable the attn+ioto(16 or 63 ms) hack;

# 2008-05-23   150   1.3.19 tio[89b] messages: to $fh_log now, add delta-time;

#                           fixes in disk extend logic and messages; add the

#                           (^c form of ( command; add adaptive read vector

#                           in serv11_attn_dl11;

# 2008-05-22   149   1.3.18 add term_tios_print, fixes for --term under cygwin;

# 2008-05-22   148   1.3.17 add (,< short-cut commands

# 2008-05-18   147   1.3.16 ATTN comma drop now warning, -W (was -I);

# 2008-05-12   145   1.3.15 rename ldpta -> ldabs

# 2008-05-09   144   1.3.14 disable call in attn_dispatch(1) (needs busy logic)

# 2008-05-01   142   1.3.13 serv11: add stop,cont,reset; add $force for attn

#                           handlers; use attn+ioto(16ms) to avoid TTO hangs

# 2008-05-01   141   1.3.12 write TTO char-by-char now to STDOUT

# 2008-04-25   138   1.3.11 show ccc/scc for code 000257/000277 in disassembler

# 2008-04-19   137   1.3.10 minor fix disassembler: use f reg prefix for f4,f5

# 2008-04-18   136   1.3.9  hack in a poor man's output to console...

# 2008-04-13   135   1.3.8  substitute environment variables in cmd file names

# 2008-04-11   134   1.3.7  allow line comments starting with ";" (for simh)

# 2008-04-06   133   1.3.6  fix file check in serv11_cexec_ldpta; fix wrong

#                           opcode for mfps; fixed bug in disassembling mode=77

#                           add -a for lsmem;

# 2008-04-04   132   1.3.5  add in disassembler non-11/70 and fpp codes;

#                           add (>|>>)file option for lsmem (redirect to file)

# 2008-03-39   131   1.3.4  lsmem -m: use now wide (3 word) symbolic dump format

#                           add ldpta command (load paper tape abs format)

#                           add start and step command

# 2008-03-24   129   1.3.3  allow comments when in serv11 server mode.

#                           check attach file size; zero-fill after partial

#                           block write; reorganize dsk file and rdma handling

#                           leading blanks now ignored in commands

# 2008-03-22   128   1.3.2  fully functional server mode (todo: TT <-> telnet)

# 2008-03-19   127   1.3.1  very preliminary server mode now working

# 2008-03-09   124   1.3    add serv11 mode; add PDP11 disamssebler

# 2008-03-02   121   1.2.5  the default .sdef now checks for hard errors.

#                           the _open handlers for rri and pdpcp setup default

#                           Add .cerr, .merr as ignored directives for pdpcp

# 2008-02-24   119   1.2.4  added lah,rps,wps command in .pdpcp mode

# 2008-02-16   116   1.2.3  add librb,[rw]ibr,and wtlam to pdpcp command set

# 2007-12-25   105   1.2.2  for rri mode add .dbas[io] (set base for data vals)

#                           add ${par}, ${par:=val}, ${par:-val} substitution

#                           allow parameter definition via par=val lines

#                           add $[..perl code..] escape to embed perl code

#                           allow @file(arg1,arg2,arg3,...); print .wtlam wait

# 2007-11-24    98   1.2.1  adapt to new rri internal init handling

# 2007-11-18    96   1.2    add 'read before write' logic to avoid deadlocks

#                           under cygwin broken fifo (size=1 !) implementation

# 2007-10-12    88   1.1.4  fix some -w issues

# 2007-09-23    84   1.1.3  .reset command in pdpcp mode; keep-alive in --fifo

# 2007-09-16    83   1.1.2  add --cmax; full --term implemented

# 2007-09-09    80   1.1.1  add --run; modularize I/O handling; initial --term

#                           proper return code / retry loop for sysread/write

# 2007-09-09    80   1.1    new non-blocking/blocking handling; ignore IDLE's

#                           and unexpected ATTN commas; add _flush; add

#                           data check handling, command chaining, 'pdpcp' mode.

# 2007-09-02    79   1.0.1  implement 'rri' mode

# 2007-09-01    78   1.0    Initial version

use 5.005;                                  # require Perl 5.005 or higher

use strict;                                 # require strict checking

use FileHandle;

use POSIX qw(mkfifo isatty :termios_h);

use Fcntl qw(O_WRONLY O_RDONLY O_NOCTTY);

use Errno qw(EINTR);

use Time::HiRes qw(gettimeofday);

use Socket;

use Term::ReadLine;

use constant CPREF  => 0x80;

use constant NCOMM  => 4;

use constant CESC   => CPREF|0x0f ;

use constant CEN1   => (~CPREF)&0xf0;

use constant D9IDLE => 0x100;

use constant D9SOP  => 0x101;

use constant D9EOP  => 0x102;

use constant D9NAK  => 0x103;

use constant D9ATTN => 0x104;

use constant PDPCP_ADDR_CONF =>  000;

use constant PDPCP_ADDR_CNTL =>  001;

use constant PDPCP_ADDR_STAT =>  002;

use constant PDPCP_ADDR_PSW  =>  003;

use constant PDPCP_ADDR_AL   =>  004;

use constant PDPCP_ADDR_AH   =>  005;

use constant PDPCP_ADDR_MEM  =>  006;

use constant PDPCP_ADDR_MEMI =>  007;

use constant PDPCP_ADDR_R0   =>  010;

use constant PDPCP_ADDR_PC   =>  017;

use constant PDPCP_ADDR_IBRB =>  020;

use constant PDPCP_ADDR_IBR  => 0200;

use constant PDPCP_FUNC_NOOP => 000;

use constant PDPCP_FUNC_STA  => 001;

use constant PDPCP_FUNC_STO  => 002;

use constant PDPCP_FUNC_CONT => 003;

use constant PDPCP_FUNC_STEP => 004;

use constant PDPCP_FUNC_RST  => 017;

use constant LINUX_B57600    => 0010001;   # B57600  not part of POSIX package !

use constant LINUX_B115200   => 0010002;   #   in linux these values are in

use constant LINUX_B230400   => 0010003;   #   termios.h, specifically in

use constant LINUX_B460800   => 0010004;   #     /usr/include/bits/termios.h

use constant LINUX_B500000   => 0010005;

use constant LINUX_B576000   => 0010006;

use constant LINUX_B921600   => 0010007;

use constant LINUX_B1000000  => 0010010;

use constant LINUX_B2000000  => 0010013;

use constant LINUX_B3000000  => 0010015;

use constant LINUX_CRTSCTS   => 020000000000; # ! Not part of POSIX !!

use Getopt::Long;

my %opts = ();

GetOptions(\%opts, "help", "int", "trace",

                   "tio8", "tio9", "tiob",

                   "dserv", "tserv", "log:s",

                   "fifo:s", "term:s",

                   "timeout=f", "cmax=i",

                   "run=s",

                   )

  or die "bad options";

sub init_regtbl;                            # initialize regtbl from reglist

sub get_command;

sub do_command;

sub read_command;

sub setpar_command;

sub nomode_open;

sub nomode_flush;

sub nomode_close;

sub nomode_cexec;

sub cpraw_open;

sub cpraw_flush;

sub cpraw_close;

sub cpraw_cexec;

sub do_cprx;

sub do_cptx;

sub cpraw_tx_match_now;

sub cpraw_tx_match;

sub rri_open;

sub rri_flush;

sub rri_close;

sub rri_cexec;

sub rri_cget_stat;

sub rri_cget_addr;

sub rri_cget_nblk;

sub rri_sideband;

sub rri_cmdlist_do;

sub rri_cmdlist_dump;

sub rri_cmdlist_exec;

sub rri_cmdlist_check_stat;

sub rri_cmdlist_get_rval;

sub rri_cmdlist_conv_rval;

sub rri_ref_check;                          # check reference data (1=err)

sub pdpcp_open;

sub pdpcp_flush;

sub pdpcp_close;

sub pdpcp_cexec;

sub pdpcp_cmd_rreg;

sub pdpcp_cmd_wreg;

sub serv11_open;

sub serv11_flush;

sub serv11_close;

sub serv11_cexec;

sub serv11_cexec_shoreg;

sub serv11_cexec_shommu_ssrx;

sub serv11_cexec_shommu_sadr;

sub serv11_cexec_ldabs;

sub serv11_cexec_shoconf;

sub serv11_cexec_shoatt;

sub serv11_cexec_attdet;

sub serv11_cexec_boot;

sub serv11_cexec_exa;

sub serv11_cexec_dep;

sub serv11_config;

sub serv11_init_dispatch;

sub serv11_server;

sub serv11_server_attn_get;

sub serv11_server_attn_dispatch;

sub serv11_probe_gen;                       # generic probe handler

sub serv11_init_gen;                        # generic controller init handler

sub serv11_detach_gen;                      # generic detach handler

sub serv11_attdet_disk;                     # generic disk att/det handler

sub serv11_attdet_ronly;                    # generic in  only att/det handler

sub serv11_attdet_wonly;                    # generic out only att/det handler

sub serv11_attdet_term;                     # generic term att/det handler

sub serv11_probe_cpu;                       # cpu: probe handler

sub serv11_attn_cpu;                        # cpu: attention handler

sub serv11_exadep_cpu;                      # cpu: exa/dep handler

sub serv11_ichr_dl11;

sub serv11_attn_dl11;

sub serv11_uset_lp11;

sub serv11_attn_lp11;

sub serv11_uset_pc11;

sub serv11_attdet_pc11;

sub serv11_attn_pc11;

sub serv11_uset_rk11;

sub serv11_attn_rk11;

sub serv11_attn_rk11_logerr;

sub serv11_rdma_rk11;

sub serv11_icb_disk_read;                   # read  one dsk file block

sub serv11_icb_disk_write;                  # write one dsk file block

sub serv11_rri_init;                        # issue rri init command

sub serv11_rri_attn;                        # issue rri attn command

sub serv11_rri_stat;                        # issue rri stat command

sub serv11_rri_rreg;                        # issue rri rreg command

sub serv11_rri_wreg;                        # issue rri wreg command

sub serv11_rri_rblk;                        # issue rri rblk command

sub serv11_rri_wblk;                        # issue rri wblk command

sub serv11_rri_lalh;                        # issue pdpcp lal and lah commands

sub serv11_rri_ibrb;                        # issue rbus set base address

sub serv11_rri_ribr;                        # issue rbus read

sub serv11_rri_wibr;                        # issue rbus write

sub serv11_rri_clear;

sub serv11_rri_exec;

sub serv11_rri_uset;                        # issue rbus uset writes

sub serv11_exec_rblk;

sub serv11_exec_wblk;

sub serv11_exec_probe;

sub next_nxbuf;                             # calculate next nxbuf value

sub telnet_readhdl;                         # telnet: socket read handler

sub telnet_writehdl;                        # telnet: write handler

sub pdp11_disassemble;                      # simple PDP11 disassembler

sub pdp11_disassemble_regmod;               #   helper

sub file_seek;                              # fseek wrapper

sub file_read;                              # fread wrapper

sub file_seek_read;                         # fseek+fread wrapper

sub file_write;                             # fwrite wrapper

sub file_seek_write;                        # fseek+fwrite wrapper

sub raw_get9_crc_16bit;                     # read 16 bit value

sub raw_get9_crc_8bit;                      # read 8bit value

sub raw_get9_crc_check;                     # get 9bit, block, crc, ref value

sub raw_get9_check;                         # get 9bit, block, expect ref value

sub raw_get9_checksop;                      # get 9bit, block, expect 'sop'

sub raw_get9_checkeop;                      # get 9bit, block, expect 'eop'

sub raw_get9_crc;                           # get 9bit, block, update crc

sub raw_get9;                               # get 9bit, block

sub raw_snd9_crc;                           # put 9bit to RX, update crc

sub raw_snd9;                               # put 9bit to RX

sub raw_snd8;                               # put 8bit to RX

sub raw_rcv9;                               # get 9bit from TX, non-blocking

sub raw_rcv8;                               # get 8bit from TX, non-blocking

sub raw_rcv9_to;                            # get 9bit from TX, expl. time-out

sub raw_rcv8_to;                            # get 8bit from TX, expl. time-out

sub wait_sel_filercv;                       # poll/wait for RCV to be ready

sub fifo_open;                              # chan fifo: open handler

sub fifo_close;                             # chan fifo: close handler

sub term_open;                              # chan term: open handler

sub term_close;                             # chan term: close handler

sub term_tios_print;                        # chan term: print termios state

sub genio_read;                             # generic io: read handler

sub genio_write;                            # generic io: write handler

sub cget_chkblank;                          # check for unused chars in cmd line

sub cget_tagval2_gdat;                      # get tag=v1[,v2], generic base

sub cget_tagval_gdat;                       # get tag=val, generic base

sub cget_gdat;                              # get generic base value

sub cget_name;                              # get name \w+

sub cget_bool;                              # get boolean [01]

sub cget_file;                              # get filename [\w\/.]+

sub cget_ucb;                               # get ucb (read name, return ucb)

sub cget_opt;                               # get option

sub cget_optset;                            # get option set

sub cget_regrange;                          # get register/memory range

sub cchk_number;                            # check for number. any gdat value

sub sget_bdat;                              # convert 01 string -> binary value

sub conv_etime;                             # generate timestamp string

sub conv_dat9;

sub conv_dat8;

sub conv_str2bytes;                         # string to bytelist; handle \n

sub conv_buf2wlist;                         # string buffer -> word list

sub conv_wlist2buf;                         # word list -> string buffer

sub conv_byte2ascii2;                       # byte -> 2 charcter ASCII display

sub gconv_dat16;

sub hdl_sigint;                             # SIGINT handler

sub get_time;

sub get_timestamp;

sub filename_expand;                        # expand $nnn in name

sub print_fatal;

sub print_help;

my %stat_tab = ( obyte => 0.,

               oesc  => 0.,

               osop  => 0.,

               ibyte => 0.,

               iesc  => 0.,

               att   => 0.,

               xreg  => 0.,

               xblk  => 0.,

               rdisk => 0.,

               wdisk => 0.);

my %stat_tab_last = %stat_tab;

my %mode_tab = (nomode => {open  => \&nomode_open,

                           flush => \&nomode_flush,

                           close => \&nomode_close,

                           cmd   => \&nomode_cexec},

                cpraw  => {open  => \&cpraw_open,

                           flush => \&cpraw_flush,

                           close => \&cpraw_close,

                           cmd   => \&cpraw_cexec},

                rri    => {open  => \&rri_open,

                           flush => \&rri_flush,

                           close => \&rri_close,

                           cmd   => \&rri_cexec},

                pdpcp  => {open  => \&pdpcp_open,

                           flush => \&pdpcp_flush,

                           close => \&pdpcp_close,

                           cmd   => \&pdpcp_cexec},

                serv11 => {open  => \&serv11_open,

                           flush => \&serv11_flush,

                           close => \&serv11_close,

                           cmd   => \&serv11_cexec}

                );

my %chan_tab = (fifo => {open  => \&fifo_open,

                         close => \&fifo_close,

                         read  => \&genio_read,

                         write => \&genio_write},

                term => {open  => \&term_open,

                         close => \&term_close,

                         read  => \&genio_read,

                         write => \&genio_write}

                );

my $curmode = "nomode";

my $curcmd = \&nomode_cexec;

my $curchan = undef;

my @cmdfh;

my @cmdfn;

my @cmdargs;

my $time0 = -1;

my $tlast_tio8 = 0;

my $tlast_tio9 = 0;

my $tlast_tiob = 0;

my @que_rcv;

my @que_snd;

my @cpraw_tx_read;

my @cpraw_tx_expt;

my $fh_log = *STDOUT;

my $fh_snd;

my $fh_rcv;

my $fdset_filercv;

my $fifo_keep;

my $term_oldtios;

my $raw_rcv_esc = 0;

my $raw_timeout = 1.;

my $cmax = 16;

my $cmd_line;

my $cmd_rest;

my $cmd_bad;

my $cmd_inter;                              # interactive cmd flag

my $term;

if (-t STDIN) {

  $term = new Term::ReadLine 'pi_rri';

}

my %par;                                # params for command line substitution

my $sigint_count = 0;                       # SIGINT counter

use constant TELNET_CODE_NULL =>   0;

use constant TELNET_CODE_LF   =>  10;

use constant TELNET_CODE_CR   =>  13;

use constant TELNET_CODE_ESC  =>  27;

use constant TELNET_CODE_SE   => 240;

use constant TELNET_CODE_NOP  => 241;

use constant TELNET_CODE_IP   => 244;

use constant TELNET_CODE_GA   => 249;

use constant TELNET_CODE_SB   => 250;

use constant TELNET_CODE_WILL => 251;

use constant TELNET_CODE_WONT => 252;

use constant TELNET_CODE_DO   => 253;

use constant TELNET_CODE_DONT => 254;

use constant TELNET_CODE_IAC  => 255;

use constant TELNET_OPT_BIN   =>  0;

use constant TELNET_OPT_ECHO  =>  1;

use constant TELNET_OPT_SGA   =>  3;

use constant TELNET_OPT_TTYP  => 24;

use constant TELNET_OPT_LINE  => 34;

use constant TELNET_STATE_LISTEN => -1;

use constant TELNET_STATE_STREAM =>  0;

use constant TELNET_STATE_IAC    =>  1;

use constant TELNET_STATE_CMD    =>  2;

use constant TELNET_STATE_SUBNEG =>  3;

use constant TELNET_STATE_SUBIAC =>  4;

#

# %telnettbl->{snum} --> telnet session table, hash of hashes, key'ed by port

#   -> {port}        port number (int)

#   -> {state}       state: (_LISTEN|_STREAM|_IAC|_CMD|_SUBNEG|_SUBIAC)

#   -> {fh_port}     file handle of port socket (for listen)

#   -> {fh_data}     file handle of data socket

#   -> {ucb}         ucb the port is attached to

#

my %telnettbl;

my $rri_ref_sdef = 0x00;         # by default check for 'hard' errors

my $rri_msk_sdef = 0xf0;         # ignore the status bits + attn flag

my %rri_amtbl;

my @rri_cmdlist;

my $rri_rvalcnt = 0;

my $rri_ncmdmax = undef;

my $rri_dbasi   = 2;             # default input base

my $rri_dbaso   = 8;             # default output base

my $rri_nodfill = " " x 5;       # filler string for "d=-" stanzas

my %rri_cname2cmd = (rreg => 0,  # c_rri_cmd_rreg : slv3 := "000";

                     rblk => 1,  # c_rri_cmd_rblk : slv3 := "001";

                     wreg => 2,  # c_rri_cmd_wreg : slv3 := "010";

                     wblk => 3,  # c_rri_cmd_wblk : slv3 := "011";

                     stat => 4,  # c_rri_cmd_stat : slv3 := "100";

                     attn => 5,  # c_rri_cmd_attn : slv3 := "101";

                     init => 6); # c_rri_cmd_init : slv3 := "110";

my @crc8_tbl = (   0,  29,  58,  39, 116, 105,  78,  83, # from gen_crc8_tbl

                 232, 245, 210, 207, 156, 129, 166, 187,

                 205, 208, 247, 234, 185, 164, 131, 158,

                  37,  56,  31,   2,  81,  76, 107, 118,

                 135, 154, 189, 160, 243, 238, 201, 212,

                 111, 114,  85,  72,  27,   6,  33,  60,

                  74,  87, 112, 109,  62,  35,   4,  25,

                 162, 191, 152, 133, 214, 203, 236, 241,

                  19,  14,  41,  52, 103, 122,  93,  64,

                 251, 230, 193, 220, 143, 146, 181, 168,

                 222, 195, 228, 249, 170, 183, 144, 141,

                  54,  43,  12,  17,  66,  95, 120, 101,

                 148, 137, 174, 179, 224, 253, 218, 199,

                 124,  97,  70,  91,   8,  21,  50,  47,

                  89,  68,  99, 126,  45,  48,  23,  10,

                 177, 172, 139, 150, 197, 216, 255, 226,

                  38,  59,  28,   1,  82,  79, 104, 117,

                 206, 211, 244, 233, 186, 167, 128, 157,

                 235, 246, 209, 204, 159, 130, 165, 184,

                   3,  30,  57,  36, 119, 106,  77,  80,

                 161, 188, 155, 134, 213, 200, 239, 242,

                  73,  84, 115, 110,  61,  32,   7,  26,

                 108, 113,  86,  75,  24,   5,  34,  63,

                 132, 153, 190, 163, 240, 237, 202, 215,

                  53,  40,  15,  18,  65,  92, 123, 102,

                 221, 192, 231, 250, 169, 180, 147, 142,

                 248, 229, 194, 223, 140, 145, 182, 171,

                  16,  13,  42,  55, 100, 121,  94,  67,

                 178, 175, 136, 149, 198, 219, 252, 225,

                  90,  71,  96, 125,  46,  51,  20,   9,

                 127,  98,  69,  88,  11,  22,  49,  44,

                 151, 138, 173, 176, 227, 254, 217, 196);

my $ocrc = 0;

my $icrc = 0;

my $kpid = -1;

my @pdp11_opcode_tbl = (

    {code=>0000000, mask=>0000000, name=>"halt", type=>"0arg"},

    {code=>0000001, mask=>0000000, name=>"wait", type=>"0arg"},

    {code=>0000002, mask=>0000000, name=>"rti ", type=>"0arg"},

    {code=>0000003, mask=>0000000, name=>"bpt ", type=>"0arg"},

    {code=>0000004, mask=>0000000, name=>"iot ", type=>"0arg"},

    {code=>0000005, mask=>0000000, name=>"reset",type=>"0arg"},

    {code=>0000006, mask=>0000000, name=>"rtt ", type=>"0arg"},

    {code=>0000007, mask=>0000000, name=>"!!mfpt", type=>"0arg"},

    {code=>0000100, mask=>0000077, name=>"jmp ", type=>"1arg"},

    {code=>0000200, mask=>0000007, name=>"rts ", type=>"1reg"},

    {code=>0000230, mask=>0000007, name=>"spl ", type=>"spl"},

    {code=>0000240, mask=>0000017, name=>"cl",   type=>"ccop"},

    {code=>0000260, mask=>0000017, name=>"se",   type=>"ccop"},

    {code=>0000300, mask=>0000077, name=>"swap", type=>"1arg"},

    {code=>0000400, mask=>0000377, name=>"br  ", type=>"br"},

    {code=>0001000, mask=>0000377, name=>"bne ", type=>"br"},

    {code=>0001400, mask=>0000377, name=>"beq ", type=>"br"},

    {code=>0002000, mask=>0000377, name=>"bge ", type=>"br"},

    {code=>0002400, mask=>0000377, name=>"blt ", type=>"br"},

    {code=>0003000, mask=>0000377, name=>"bgt ", type=>"br"},

    {code=>0003400, mask=>0000377, name=>"ble ", type=>"br"},

    {code=>0004000, mask=>0000777, name=>"jsr ", type=>"jsr"},

    {code=>0005000, mask=>0000077, name=>"clr ", type=>"1arg"},

    {code=>0005100, mask=>0000077, name=>"com ", type=>"1arg"},

    {code=>0005200, mask=>0000077, name=>"inc ", type=>"1arg"},

    {code=>0005300, mask=>0000077, name=>"dec ", type=>"1arg"},

    {code=>0005400, mask=>0000077, name=>"neg ", type=>"1arg"},

    {code=>0005500, mask=>0000077, name=>"adc ", type=>"1arg"},

    {code=>0005600, mask=>0000077, name=>"sbc ", type=>"1arg"},

    {code=>0005700, mask=>0000077, name=>"tst ", type=>"1arg"},

    {code=>0006000, mask=>0000077, name=>"ror ", type=>"1arg"},

    {code=>0006100, mask=>0000077, name=>"rol ", type=>"1arg"},

    {code=>0006200, mask=>0000077, name=>"asr ", type=>"1arg"},

    {code=>0006300, mask=>0000077, name=>"asl ", type=>"1arg"},

    {code=>0006400, mask=>0000077, name=>"mark", type=>"mark"},

    {code=>0006500, mask=>0000077, name=>"mfpi", type=>"1arg"},

    {code=>0006600, mask=>0000077, name=>"mtpi", type=>"1arg"},

    {code=>0006700, mask=>0000077, name=>"sxt ", type=>"1arg"},

    {code=>0007000, mask=>0000077, name=>"!!csm",  type=>"1arg"},

    {code=>0007200, mask=>0000077, name=>"!!tstset",type=>"1arg"},

    {code=>0007300, mask=>0000077, name=>"!!wrtlck",type=>"1arg"},

    {code=>0010000, mask=>0007777, name=>"mov ", type=>"2arg"},

    {code=>0020000, mask=>0007777, name=>"cmp ", type=>"2arg"},

    {code=>0030000, mask=>0007777, name=>"bit ", type=>"2arg"},

    {code=>0040000, mask=>0007777, name=>"bic ", type=>"2arg"},

    {code=>0050000, mask=>0007777, name=>"bis ", type=>"2arg"},

    {code=>0060000, mask=>0007777, name=>"add ", type=>"2arg"},

    {code=>0070000, mask=>0000777, name=>"mul ", type=>"rdst"},

    {code=>0071000, mask=>0000777, name=>"div ", type=>"rdst"},

    {code=>0072000, mask=>0000777, name=>"ash ", type=>"rdst"},

    {code=>0073000, mask=>0000777, name=>"ashc", type=>"rdst"},

    {code=>0074000, mask=>0000777, name=>"xor ", type=>"rdst"},

    {code=>0077000, mask=>0000777, name=>"sob ", type=>"sob"},

    {code=>0100000, mask=>0000377, name=>"bpl ", type=>"br"},

    {code=>0100400, mask=>0000377, name=>"bmi ", type=>"br"},

    {code=>0101000, mask=>0000377, name=>"bhi ", type=>"br"},

    {code=>0101400, mask=>0000377, name=>"blos", type=>"br"},

    {code=>0102000, mask=>0000377, name=>"bvc ", type=>"br"},

    {code=>0102400, mask=>0000377, name=>"bvs ", type=>"br"},

    {code=>0103000, mask=>0000377, name=>"bcc ", type=>"br"},

    {code=>0103400, mask=>0000377, name=>"bcs ", type=>"br"},

    {code=>0104000, mask=>0000377, name=>"emt ", type=>"trap"},

    {code=>0104400, mask=>0000377, name=>"trap", type=>"trap"},

    {code=>0105000, mask=>0000077, name=>"clrb", type=>"1arg"},

    {code=>0105100, mask=>0000077, name=>"comb", type=>"1arg"},

    {code=>0105200, mask=>0000077, name=>"incb", type=>"1arg"},

    {code=>0105300, mask=>0000077, name=>"decb", type=>"1arg"},

    {code=>0105400, mask=>0000077, name=>"negb", type=>"1arg"},

    {code=>0105500, mask=>0000077, name=>"adcb", type=>"1arg"},

    {code=>0105600, mask=>0000077, name=>"sbcb", type=>"1arg"},

    {code=>0105700, mask=>0000077, name=>"tstb", type=>"1arg"},

    {code=>0106000, mask=>0000077, name=>"rorb", type=>"1arg"},

    {code=>0106100, mask=>0000077, name=>"rolb", type=>"1arg"},

    {code=>0106200, mask=>0000077, name=>"asrb", type=>"1arg"},

    {code=>0106300, mask=>0000077, name=>"aslb", type=>"1arg"},

    {code=>0106400, mask=>0000077, name=>"!!mtps", type=>"1arg"},

    {code=>0106500, mask=>0000077, name=>"mfpd", type=>"1arg"},

    {code=>0106600, mask=>0000077, name=>"mtpd", type=>"1arg"},

    {code=>0106700, mask=>0000077, name=>"!!mfps", type=>"1arg"},

    {code=>0110000, mask=>0007777, name=>"movb", type=>"2arg"},

    {code=>0120000, mask=>0007777, name=>"cmpb", type=>"2arg"},

    {code=>0130000, mask=>0007777, name=>"bitb", type=>"2arg"},

    {code=>0140000, mask=>0007777, name=>"bicb", type=>"2arg"},

    {code=>0150000, mask=>0007777, name=>"bisb", type=>"2arg"},

    {code=>0160000, mask=>0007777, name=>"sub ", type=>"2arg"},

    {code=>0170000, mask=>0000000, name=>"!!cfcc", type=>"0arg"},

    {code=>0170001, mask=>0000000, name=>"!!setf", type=>"0arg"},

    {code=>0170011, mask=>0000000, name=>"!!setd", type=>"0arg"},

    {code=>0170002, mask=>0000000, name=>"!!seti", type=>"0arg"},

    {code=>0170012, mask=>0000000, name=>"!!setl", type=>"0arg"},

    {code=>0170100, mask=>0000077, name=>"!!ldfps",type=>"1fpp"},

    {code=>0170200, mask=>0000077, name=>"!!stfps",type=>"1fpp"},

    {code=>0170300, mask=>0000077, name=>"!!stst", type=>"1fpp"},

    {code=>0170400, mask=>0000077, name=>"!!clrf", type=>"1fpp"},

    {code=>0170500, mask=>0000077, name=>"!!tstf", type=>"1fpp"},

    {code=>0170600, mask=>0000077, name=>"!!absf", type=>"1fpp"},

    {code=>0170700, mask=>0000077, name=>"!!negf", type=>"1fpp"},

    {code=>0171000, mask=>0000377, name=>"!!mulf", type=>"rfpp"},

    {code=>0171400, mask=>0000377, name=>"!!modf", type=>"rfpp"},

    {code=>0172000, mask=>0000377, name=>"!!addf", type=>"rfpp"},

    {code=>0172400, mask=>0000377, name=>"!!ldf",  type=>"rfpp"},

    {code=>0173000, mask=>0000377, name=>"!!subf", type=>"rfpp"},

    {code=>0173400, mask=>0000377, name=>"!!cmpf", type=>"rfpp"},

    {code=>0174000, mask=>0000377, name=>"!!stf",  type=>"rfpp"},

    {code=>0174400, mask=>0000377, name=>"!!divf", type=>"rfpp"},

    {code=>0175000, mask=>0000377, name=>"!!stexp",type=>"rfpp"},

    {code=>0175400, mask=>0000377, name=>"!!stcif",type=>"rfpp"},

    {code=>0176000, mask=>0000377, name=>"!!stcfd",type=>"rfpp"},

    {code=>0176400, mask=>0000377, name=>"!!ldexp",type=>"rfpp"},

    {code=>0177000, mask=>0000377, name=>"!!ldcif",type=>"rfpp"},

    {code=>0177400, mask=>0000377, name=>"!!ldcdf",type=>"rfpp"}

  );

use constant BIT00 => 0000001;

use constant BIT01 => 0000002;

use constant BIT02 => 0000004;

use constant BIT03 => 0000010;

use constant BIT04 => 0000020;

use constant BIT05 => 0000040;

use constant BIT06 => 0000100;

use constant BIT07 => 0000200;

use constant BIT08 => 0000400;

use constant BIT09 => 0001000;

use constant BIT10 => 0002000;

use constant BIT11 => 0004000;

use constant BIT12 => 0010000;

use constant BIT13 => 0020000;

use constant BIT14 => 0040000;

use constant BIT15 => 0100000;

use constant REGATTR_RBMBOX => 0000001;     # rbus is mailbox, skip on exa loop

use constant REGATTR_RBRD   => 0000002;     # by default  read on rbus

use constant REGATTR_RBWR   => 0000004;     # by default write on rbus

use constant REGATTR_IBMBOX => 0000010;     # ibus is mailbox, skip on exa loop

# some common defs

my @partbl_nxbuf = ( nxbuf_min => { type => "hval:d" },

                     nxbuf_inc => { type => "hval:d" },

                     nxbuf_max => { type => "hval:d" },

                     nxbuf     => { type => "hval:d" } );

# CPU general defs

use constant CPU_MMR3   => 0172516;

use constant CPU_SDREG  => 0177570;

use constant CPU_MMR0   => 0177572;

use constant CPU_MMR1   => 0177574;

use constant CPU_MMR2   => 0177576;

use constant CPU_LOSIZE => 0177760;

use constant CPU_HISIZE => 0177762;

use constant CPU_SYSID  => 0177764;

use constant CPU_CPUERR => 0177766;

use constant CPU_MBRK   => 0177770;

use constant CPU_PIRQ   => 0177772;

use constant CPU_STKLIM => 0177774;

use constant CPU_PSW    => 0177776;

# DL11 general defs

use constant DL11_BASE_A  => 0177560;

use constant DL11_BASE_B  => 0176500;

# DL11 address offsets

use constant DL11_RCSR  => 00;

use constant DL11_RBUF  => 02;

use constant DL11_XCSR  => 04;

use constant DL11_XBUF  => 06;

# DL11 register defs

use constant DL11_RCSR_M_RDONE  => BIT07;

use constant DL11_XCSR_M_XRDY   => BIT07;

use constant DL11_XBUF_M_RRDY   => BIT09;

use constant DL11_XBUF_M_XVAL   => BIT08;

use constant DL11_XBUF_M_XBUF   => 0377;

my @reglist_dl11 = ({name   => "rcsr",

                     offset => DL11_RCSR},

                    {name   => "rbuf",

                     offset => DL11_RBUF,

                     attr   => REGATTR_IBMBOX},

                    {name   => "xcsr",

                     offset => DL11_XCSR},

                    {name   => "xbuf",

                     offset => DL11_XBUF,

                     attr   => REGATTR_RBMBOX});

my %partbl_dl11  = ( trace => { type => "hval:b" },

                   @partbl_nxbuf );

# LP11 general defs

use constant LP11_BASE  => 0177514;

# LP11 address offsets

use constant LP11_CSR   => 00;

use constant LP11_BUF   => 02;

# LP11 register defs

use constant LP11_CSR_M_ERR  => BIT15;

use constant LP11_BUF_M_VAL  => BIT08;

use constant LP11_BUF_M_BUF  => 0177;

my @reglist_lp11 = ({name   => "csr",

                     offset => LP11_CSR},

                    {name   => "buf",

                     offset => LP11_BUF,

                     attr   => REGATTR_RBMBOX});

my %partbl_lp11  = ( trace => { type => "hval:b" },

                   @partbl_nxbuf );

# PC11 address offsets

use constant PC11_RCSR  => 00;

use constant PC11_RBUF  => 02;

use constant PC11_PCSR  => 04;

use constant PC11_PBUF  => 06;

# PC11 register defs

use constant PC11_RCSR_M_ERR    => BIT15;

use constant PC11_PCSR_M_ERR    => BIT15;

use constant PC11_PBUF_M_RBUSY  => BIT09;

use constant PC11_PBUF_M_PVAL   => BIT08;

use constant PC11_PBUF_M_PBUF   => 0377;

my @reglist_pc11 = ({name   => "rcsr",

                     offset => PC11_RCSR},

                    {name   => "rbuf",

                     offset => PC11_RBUF,

                     attr   => REGATTR_IBMBOX},

                    {name   => "pcsr",

                     offset => PC11_PCSR},

                    {name   => "pbuf",

                     offset => PC11_PBUF,

                     attr   => REGATTR_RBMBOX});

my %partbl_pc11  = ( trace => { type => "hval:b" },

                   @partbl_nxbuf );

# RK11 general defs

use constant RK11_BASE    => 0177400;

use constant RK11_NUMSE   =>  12;         # number of sectors

use constant RK11_NUMHD   =>   2;         # number of heads

use constant RK11_NUMCY   => 203;         # number of cylinders

use constant RK11_NUMDR   =>   8;         # number of drives

use constant RK11_NUMBL   => RK11_NUMSE * RK11_NUMHD * RK11_NUMCY;

use constant RK11_BLKSIZE => 512;                       # disk block size

use constant RK11_VOLSIZE => RK11_BLKSIZE * RK11_NUMBL; # disk volume size

# RK11 address offsets

use constant RK11_RKDS  => 00;

use constant RK11_RKER  => 02;

use constant RK11_RKCS  => 04;

use constant RK11_RKWC  => 06;

use constant RK11_RKBA  => 010;

use constant RK11_RKDA  => 012;

use constant RK11_RKMR  => 014;

# RK11 register defs

use constant RKDS_M_ID     => 0160000;  # ID: drive number

use constant RKDS_V_ID     => 13;

use constant RKDS_B_ID     => 0007;

use constant RKDS_M_HDEN   => BIT11;    # HDEN: high density drive (rk05)

use constant RKDS_M_DRU    => BIT10;    # DRU: drive unsafe

use constant RKDS_M_SIN    => BIT09;    # SIN: seek incomplete

use constant RKDS_M_SOK    => BIT08;    # SOK: sector counter OK

use constant RKDS_M_DRY    => BIT07;    # DRY: drive ready

use constant RKDS_M_ADRY   => BIT06;    # ADRY: access ready

use constant RKDS_M_WPS    => BIT05;    # WPS: write protect

use constant RKDS_B_SC     => 0017;     # SC: sector counter

use constant RKER_M_DRE    => BIT15;    # DRE: drive error

use constant RKER_M_OVR    => BIT14;    # OVR: overrun

use constant RKER_M_WLO    => BIT13;    # WLO: write lock violation

use constant RKER_M_PGE    => BIT11;    # PGE: programming error

use constant RKER_M_NXM    => BIT10;    # NXM: non existent memory

use constant RKER_M_NXD    => BIT07;    # NXD: non existent drive

use constant RKER_M_NXC    => BIT06;    # NXC: non existent cylinder

use constant RKER_M_NXS    => BIT05;    # NXS: non existent sector

use constant RKER_M_CSE    => BIT01;    # CSE: check sum error

use constant RKER_M_WCE    => BIT00;    # WCE: write check error

use constant RKCS_M_MAINT  => BIT12;    # MAINT: maintenance mode

use constant RKCS_M_IBA    => BIT11;    # IBA: inhibit increment RKBA

use constant RKCS_M_FMT    => BIT10;    # FMT: format

use constant RKCS_M_RWA    => BIT09;    # RWA: read-write all

use constant RKCS_M_SSE    => BIT08;    # SSE: stop on soft errors

use constant RKCS_M_MEX    => 0000060;  # MEX: memory extension

use constant RKCS_V_MEX    =>  4;

use constant RKCS_B_MEX    => 0003;

use constant RKCS_V_FUNC   =>  1;       # FUNC: function

use constant RKCS_B_FUNC   => 0007;

use constant   RKCS_CRESET =>  0;

use constant   RKCS_WRITE  =>  1;

use constant   RKCS_READ   =>  2;

use constant   RKCS_WCHK   =>  3;

use constant   RKCS_SEEK   =>  4;

use constant   RKCS_RCHK   =>  5;

use constant   RKCS_DRESET =>  6;

use constant   RKCS_WLOCK  =>  7;

use constant RKCS_M_GO     => BIT00;    # GO: go bit

use constant RKDA_M_DRSEL  => 0160000;  # DRSEL: drive number

use constant RKDA_V_DRSEL  => 13;

use constant RKDA_B_DRSEL  => 0007;

use constant RKDA_M_CYL    => 0017740;  # CYL: cyclinder address

use constant RKDA_V_CYL    =>  5;

use constant RKDA_B_CYL    => 0377;

use constant RKDA_M_SUR    => 0000020;  # SUR: surface

use constant RKDA_V_SUR    =>  4;

use constant RKDA_B_SUR    => 0001;

use constant RKDA_B_SC     => 0017;     # SC: sector address

use constant RKMR_M_RID    => 0160000;  # RID: drive id for RKDS RB read

use constant RKMR_V_RID    => 13;

use constant RKMR_V_CRDONE => 11;       # CRDONE: control reset done

use constant RKMR_V_SBCLR  => 10;       # SBCLR: clear SBUSY's with SDONE

use constant RKMR_V_CRESET =>  9;       # CRESET: initiate control reset

use constant RKMR_V_FDONE  =>  8;       # FDONE: initiate function done

my @reglist_rk11 = ({name   => "rkds",

                     offset => RK11_RKDS},

                    {name   => "rker",

                     offset => RK11_RKER},

                    {name   => "rkcs",

                     offset => RK11_RKCS},

                    {name   => "rkwc",

                     offset => RK11_RKWC},

                    {name   => "rkba",

                     offset => RK11_RKBA},

                    {name   => "rkda",

                     offset => RK11_RKDA},

                    {name   => "rkmr",

                     offset => RK11_RKMR});

my %partbl_rk11  = ( trace => { type => "hval:b" } );

# KWP general defs

my @reglist_kwp = ({name   => "csr",

                    offset => 0},

                   {name   => "csb",

                    offset => 2},

                   {name   => "ctr",

                    offset => 4});

# KWL general defs

my @reglist_kwl = ({name   => "csr",

                    offset => 0});

# IIST general defs

my @reglist_iist = ({name   => "acr",

                     offset => 0},

                    {name   => "adr",

                     offset => 2});

use constant BOOT_START  => 02000;

my $serv11_fds_update   =   1;

my $serv11_config_done  =   0;

my $serv11_init_pending =   1;

my $serv11_rdma_chunk   = 256;

my $serv11_init_anena  = 0x8000;       # enable attn

#my $serv11_init_anena   = 0xC03f;       # enable attn+ioto(63ms)

#

# %serv11_ctltbl->{dev} --> controller table; is hash of hashes

#   -> {ctlname}     controller name

#   -> {ctltype}     controller type (e.g. DL11)

#   -> {devname}     device name

#   -> {type}        device type: term, lpr, ptap, disk, tape, eth

#   -> {units}       array of unit names

#   -> {base}        controller base address

#   -> {ibrb}        controller base mapping for remote ib access

#   -> {csroff}      csr offset from base (for probing)

#   -> {lam}         lam number used by controller

#   -> {nxbuf_min}   nxbuf: minimal vector size

#   -> {nxbuf_inc}   nxbuf: vector size increment

#   -> {nxbuf_max}   nxbuf: maximal vector size

#   -> {probehdl}    address of probe handler

#   -> {probemask}   sides to be tested (set to "ir" if missing)

#   -> {ichrhdl}     address of input character handler

#   -> {inithdl}     address of controler init handler

#   -> {usethdl}     address of unit setup handler

#   -> {attdethdl}   address of attach/detach handler

#   -> {attnhdl}     address og attention handler

#   -> {reglist}     register list (array of regdsc's)

#   -> {regtbl}      register table (by name, created by ...)

#   -> {partbl}      parameter table (array of pardsc's)