github.com/wfjm.w11
1
0
Fork 0
mirror of https://github.com/wfjm/w11.git synced 2026-04-25 11:51:51 +00:00
Code Issues Releases Wiki Activity

- added RH70/RP/RM big disk support

Browse Source 
- many cleanups
This commit is contained in:
Walter F.J. Mueller
2015-05-14 17:00:36 +00:00
parent e91847f8db
commit 4a032e9436
247 changed files with 11301 additions and 3449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
tools/tbench/rhrp_all.dat Normal file
View File

@@ -0,0 +1,8 @@
# $Id: rhrp_all.dat 668 2015-04-25 14:31:19Z mueller $
#
## steering file for all rhrp tests
#
test_rhrp_basics.tcl
test_rhrp_regs.tcl
test_rhrp_func_reg.tcl
test_rhrp_int.tcl

119
tools/tbench/test_cp_cpubasics.tcl
View File

@@ -1,21 +1,24 @@
# $Id: test_cp_cpubasics.tcl 552 2014-03-02 23:02:00Z mueller $
# $Id: test_cp_cpubasics.tcl 676 2015-05-09 16:31:54Z mueller $
#
# Copyright 2013- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
# Copyright 2013-2015 by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
# License disclaimer see LICENSE_gpl_v2.txt in $RETROBASE directory
#
# Revision History:
# Date Rev Version Comment
# 2015-05-09 676 1.1 w11a start/stop/suspend overhaul
# 2013-03-31 502 1.0 Initial version
#
# Test very basic cpu interface gymnastics
# 1. load code via ldasm
# 2. execute code via -start, -stapc, -continue
# 2. execute code via -start, -stapc
# 3. single step code via -step
# 4. verify -suspend, -resume
#
# ----------------------------------------------------------------------------
rlc log "test_cp_cpubasics: Test very basic cpu interface gymnastics"
rlc log " load code via lsasm"
rlc log "test_cp_cpubasics: Test very basic cpu interface gymnastics ---------"
rlc log " A1: start/stop/step basics --------------------------------"
rlc log " load simple linear code via lsasm"
#
$cpu ldasm -lst lst -sym sym {
@@ -27,11 +30,11 @@ start: inc r2
stop:
}
rlc log " read back and check"
rlc log " read back and check"
$cpu cp -wal $sym(start) \
-brm 4 -edata {0005202 0005202 0005202 0000000}
rlc log " execute via -start"
rlc log " execute via -start"
$cpu cp -wr2 00000 \
-wpc $sym(start) \
-start
@@ -39,29 +42,93 @@ $cpu wtcpu -reset 1.0
$cpu cp -rr2 -edata 00003 \
-rpc -edata $sym(stop)
rlc log " execute via -stapc"
rlc log " execute via -stapc"
$cpu cp -wr2 00100 \
-stapc $sym(start)
$cpu wtcpu -reset 1.0
$cpu cp -rr2 -edata 00103 \
-rpc -edata $sym(stop)
rlc log " execute via -continue"
$cpu cp -wr2 00200 \
-wpc $sym(start) \
-continue
$cpu wtcpu -reset 1.0
$cpu cp -rr2 -edata 00203 \
-rpc -edata $sym(stop)
rlc log " execute via -step"
$cpu cp -wr2 00300 \
rlc log " execute via -step"
$cpu cp -wr2 00300 \
-wpc $sym(start)
$cpu cp -step -rpc -edata [expr {$sym(start)+002}] \
-rr2 -edata 00301 -rstat -edata 000100
$cpu cp -step -rpc -edata [expr {$sym(start)+004}] \
-rr2 -edata 00302 -rstat -edata 000100
$cpu cp -step -rpc -edata [expr {$sym(start)+006}] \
-rr2 -edata 00303 -rstat -edata 000100
$cpu cp -step -rpc -edata [expr {$sym(start)+010}] \
-rr2 -edata 00303 -rstat -edata 000030
$cpu cp -step \
-rpc -edata [expr {$sym(start)+002}] \
-rr2 -edata 00301 \
-rstat -edata 000100
$cpu cp -step \
-rpc -edata [expr {$sym(start)+004}] \
-rr2 -edata 00302 \
-rstat -edata 000100
$cpu cp -step \
-rpc -edata [expr {$sym(start)+006}] \
-rr2 -edata 00303 \
-rstat -edata 000100
$cpu cp -step \
-rpc -edata [expr {$sym(start)+010}] \
-rr2 -edata 00303 \
-rstat -edata 000020
rlc log " A2: suspend/resume basics; cpugo,cpususp flags ------------"
# define tmpproc for r2 increment checks
proc tmpproc_checkr2inc {val} {
set emsg ""
if {$val == 0} {
set emsg "FAIL: r2 change zero"
rlc errcnt -inc
}
rlc log -bare ".. r2 increment $val $emsg"
}
#
rlc log " load simple loop code via lsasm"
$cpu ldasm -lst lst -sym sym {
. = 1000
start: inc r2
br start
stop:
}
set statgo [regbld rw11::STAT cpugo]
set statgosu [regbld rw11::STAT cpususp cpugo]
rlc log " execute via -stapc, check cpugo and that r2 increments"
$cpu cp -wr2 00000 \
-stapc $sym(start) \
-rr2 rr2_1 -estat $statgo \
-rr2 rr2_2 -estat $statgo
tmpproc_checkr2inc $rr2_1
tmpproc_checkr2inc [expr {$rr2_2 - $rr2_1}]
rlc log " suspend, check cpususp=1 and that r2 doesn't increment"
$cpu cp -suspend \
-wr2 00000 \
-rr2 -edata 0 -estat $statgosu \
-rr2 -edata 0 -estat $statgosu
rlc log " resume, check cpususp=0 and that r2 increments again"
$cpu cp -resume \
-rr2 rr2_1 -estat $statgo \
-rr2 rr2_2 -estat $statgo
tmpproc_checkr2inc $rr2_1
tmpproc_checkr2inc [expr {$rr2_2 - $rr2_1}]
rlc log " suspend than step, two steps should inc r2 once"
$cpu cp -suspend \
-wr2 00000 \
-step \
-step \
-rr2 -edata 1 \
-step \
-step \
-rr2 -edata 2
rlc log " stop while suspended, check cpugo=0,cpususp=1,attn=1; harvest attn"
$cpu cp -stop -estat [regbld rw11::STAT cpususp attn]
$cpu wtcpu -reset 1.0
rlc log " creset, check cpususp=0"
# Note: creset still has cpususp stat flag set because it clears with one
# cycle delay. So do -estat after next command
$cpu cp -creset \
-rr2 -estat 0

4
tools/tbench/test_cp_gpr.tcl
View File

@@ -1,4 +1,4 @@
# $Id: test_cp_gpr.tcl 552 2014-03-02 23:02:00Z mueller $
# $Id: test_cp_gpr.tcl 676 2015-05-09 16:31:54Z mueller $
#
# Copyright 2013- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
# License disclaimer see LICENSE_gpl_v2.txt in $RETROBASE directory
@@ -14,7 +14,7 @@
#
# ----------------------------------------------------------------------------
rlc log "test_cp_gpr: test cp access to general purpose registers"
rlc log "test_cp_gpr: test cp access to general purpose registers ------------"
rlc log " write set 0"
$cpu cp -wps 0000000
$cpu cp -wr0 0000001 \

4
tools/tbench/test_cp_ibrbasics.tcl
View File

@@ -1,4 +1,4 @@
# $Id: test_cp_ibrbasics.tcl 621 2014-12-26 21:20:05Z mueller $
# $Id: test_cp_ibrbasics.tcl 676 2015-05-09 16:31:54Z mueller $
#
# Copyright 2014- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
# License disclaimer see LICENSE_gpl_v2.txt in $RETROBASE directory
@@ -13,7 +13,7 @@
#
# ----------------------------------------------------------------------------
rlc log "test_cp_ibrbasics: Test very basic ibus interface gymnastics"
rlc log "test_cp_ibrbasics: Test very basic ibus interface gymnastics --------"
rlc log " write/read ibus space (MMU SAR SM I regs) via bwm/brm"
$cpu cp -wal 0172240 \

4
tools/tbench/test_cp_membasics.tcl
View File

@@ -1,4 +1,4 @@
# $Id: test_cp_membasics.tcl 621 2014-12-26 21:20:05Z mueller $
# $Id: test_cp_membasics.tcl 676 2015-05-09 16:31:54Z mueller $
#
# Copyright 2014- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
# License disclaimer see LICENSE_gpl_v2.txt in $RETROBASE directory
@@ -14,7 +14,7 @@
#
# ----------------------------------------------------------------------------
rlc log "test_cp_membasics: Test very basic memory interface gymnastics"
rlc log "test_cp_membasics: Test very basic memory interface gymnastics ------"
# --------------------------------------------------------------------
rlc log " write/read address register"

4
tools/tbench/test_cp_psw.tcl
View File

@@ -1,4 +1,4 @@
# $Id: test_cp_psw.tcl 621 2014-12-26 21:20:05Z mueller $
# $Id: test_cp_psw.tcl 676 2015-05-09 16:31:54Z mueller $
#
# Copyright 2013-2014 by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
# License disclaimer see LICENSE_gpl_v2.txt in $RETROBASE directory
@@ -18,7 +18,7 @@
#
# ----------------------------------------------------------------------------
rlc log "test_cp_psw: test psw access via all methods"
rlc log "test_cp_psw: test psw access via all methods ------------------------"
rlc log " write/read via cp"
foreach w { 000000 000017 } {
$cpu cp -wps $w \

200
tools/tbench/test_rhrp_basics.tcl Normal file
View File

@@ -0,0 +1,200 @@
# $Id: test_rhrp_basics.tcl 667 2015-04-18 20:16:05Z mueller $
#
# Copyright 2015- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
# License disclaimer see LICENSE_gpl_v2.txt in $RETROBASE directory
#
# Revision History:
# Date Rev Version Comment
# 2015-03-29 660 1.0 Initial version
#
# Test basic access
# 1. ibus/rbus ack (for cs1:cs3) and no ack (cs3+2)
# 2. unit enable/disable and cs2.ned response
# 3. drive type logic
# 4. readability of all regs (enabled and diabled unit, check cs2.ned)
# ----------------------------------------------------------------------------
rlc log "test_rhrp_basics: basic access tests --------------------------------"
rlc log " setup context"
package require ibd_rhrp
ibd_rhrp::setup
rlc set statmask $rw11::STAT_DEFMASK
rlc set statvalue 0
rlc log " A1: test that cs1,cs3 give ack, cs3+2 gives no ack --------"
set iaddrfail [expr {[cpu0 imap rpa.cs3] + 2}]
rlc log " A1.1: rem read cs1,cs3,cs3+1 -----------------------"
$cpu cp -ribr rpa.cs1 \
-ribr rpa.cs3 \
-ribr $iaddrfail -estaterr
rlc log " A1.2: loc read cs1,cs3,cs3+1 -----------------------"
$cpu cp -rma rpa.cs1 \
-rma rpa.cs3 \
-rma $iaddrfail -estaterr
rlc log " A2: test unit enable, dt and cs2.ned ----------------------"
rlc log " A2.1: disable unit 0 -------------------------------"
#
# select rem and loc unit 0; disable unit
$cpu cp -wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 0] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 0}] \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}]
rlc log " A2.2: check dt read and cs2.ned --------------------"
set cs2ned [regbld ibd_rhrp::CS2 ned]
$cpu cp -wma rpa.cs1 [regbld ibd_rhrp::CS1 tre] \
-rma rpa.dt \
-rma rpa.cs2 -edata $cs2ned $cs2ned
rlc log " A2.3: enable unit 0 as RP06; check cs2.ned, dt -----"
# check for cs2.ned=0 response on dt read (after cs1.tre=1)
# unit 0 selected rem and loc from previous section
$cpu cp -wibr rpa.ds [regbld ibd_rhrp::DS {dpr 1}] \
-wibr rpa.dt $ibd_rhrp::DTE_RP06 \
-wma rpa.cs1 [regbld ibd_rhrp::CS1 tre] \
-rma rpa.dt -edata $ibd_rhrp::DT_RP06 \
-rma rpa.cs2 -edata 0 $cs2ned
rlc log " A3: set drive types, check proper dt response -------------"
# dte dt
set tbl [list $ibd_rhrp::DTE_RP04 $ibd_rhrp::DT_RP04 \
$ibd_rhrp::DTE_RP06 $ibd_rhrp::DT_RP06 \
$ibd_rhrp::DTE_RM04 $ibd_rhrp::DT_RM04 \
$ibd_rhrp::DTE_RM80 $ibd_rhrp::DT_RM80 \
$ibd_rhrp::DTE_RM05 $ibd_rhrp::DT_RM05 \
$ibd_rhrp::DTE_RP07 $ibd_rhrp::DT_RP07 ]
# unit 0 enabled and selected rem and loc from previous section
foreach {dte dt} $tbl {
$cpu cp -wibr rpa.dt $dte \
-ribr rpa.dt -edata $dte \
-rma rpa.dt -edata $dt
}
rlc log " A4: check unit selection and that units are distinct ------"
rlc log " A4.1: setup units: 0: RP04 1:off 2:RP06 3:off ------"
# unit dpr dte dt
set tbl [list 0 1 $ibd_rhrp::DTE_RP04 $ibd_rhrp::DT_RP04 \
1 0 0 0 \
2 1 $ibd_rhrp::DTE_RP06 $ibd_rhrp::DT_RP06 \
3 0 0 0]
foreach {unit dpr dte dt} $tbl {
$cpu cp -wibr rpa.cs1 [ibd_rhrp::rcs1_wunit $unit] \
-wibr rpa.ds [regbld ibd_rhrp::DS [list dpr $dpr]] \
-wibr rpa.dt $dte
}
rlc log " A4.2: readback dt rem and loc; check cs2.ned -------"
set dsmsk [regbld ibd_rhrp::DS dpr]
set cs2msk [regbld ibd_rhrp::CS2 ned {unit 3}]
foreach {unit dpr dte dt} $tbl {
set dsval [regbld ibd_rhrp::DS [list dpr $dpr]]
set cs2val [regbld ibd_rhrp::CS2 [list ned [expr {1-$dpr}]] [list unit $unit]]
$cpu cp -wibr rpa.cs1 [ibd_rhrp::rcs1_wunit $unit] \
-ribr rpa.ds -edata $dsval $dsmsk \
-ribr rpa.dt -edata $dte \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 [list unit $unit]] \
-wma rpa.cs1 [regbld ibd_rhrp::CS1 tre] \
-rma rpa.dt -edata $dt \
-rma rpa.cs2 -edata $cs2val $cs2msk
}
rlc log " A5: check cs2.ned for all regs on disabled unit -----------"
# use setting from last section: drive 0 on, drive 1 off
# addr mb
set tbl [list rpa.cs1 1 \
rpa.wc 0 \
rpa.ba 0 \
rpa.da 1 \
rpa.cs2 0 \
rpa.ds 1 \
rpa.er1 1 \
rpa.as 1 \
rpa.la 1 \
rpa.db 0 \
rpa.mr1 1 \
rpa.dt 1 \
rpa.sn 1 \
rpa.of 1 \
rpa.dc 1 \
rpa.m13 1 \
rpa.m14 1 \
rpa.m15 1 \
rpa.ec1 1 \
rpa.ec2 1 \
rpa.bae 0 \
rpa.cs3 0 \
]
# Note: First unit 1 (enabled) selected, and cs1.tre=1 done
# Than unit 1 (disabled) selected, and registered read
# This ensures that cs2.ned is really cleared, because a cs1.tre=1
# write while a disabled drive is selected will clear and set ned !!
set cs2msk [regbld ibd_rhrp::CS2 ned {unit -1}]
foreach {addr mb} $tbl {
set cs2val [regbld ibd_rhrp::CS2 [list ned $mb] {unit 1}]
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-wma rpa.cs1 [regbld ibd_rhrp::CS1 tre] \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-rma $addr \
-rma rpa.cs2 -edata $cs2val $cs2msk
}
rlc log " A6: check cs2.ned for all regs on enable unit -------------"
# select drive 0 (on); cs1.tre=1; read all regs; check cs2 at end once (sticky)
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 [list unit 0]] \
-wma rpa.cs1 [regbld ibd_rhrp::CS1 tre] \
-rma rpa.cs1 \
-rma rpa.wc \
-rma rpa.ba \
-rma rpa.da
$cpu cp -rma rpa.cs2 \
-rma rpa.ds \
-rma rpa.er1 \
-rma rpa.as \
-rma rpa.la \
-rma rpa.db \
-rma rpa.mr1
$cpu cp -rma rpa.dt \
-rma rpa.sn \
-rma rpa.of \
-rma rpa.dc \
-rma rpa.m13 \
-rma rpa.m14 \
-rma rpa.m15
$cpu cp -rma rpa.ec1 \
-rma rpa.ec2 \
-rma rpa.bae \
-rma rpa.cs3 \
-rma rpa.cs2 -edata 0 [regbld ibd_rhrp::CS2 ned]
rlc log " A7: check that unit 3-7 are loc selectable, but off -------"
rlc log " A7.1: loc read dt for unit 3-7 ; check cs2.unit+ned"
set cs2msk [regbld ibd_rhrp::CS2 ned {unit -1}]
foreach {unit} {4 5 6 7} {
set cs2val [regbld ibd_rhrp::CS2 ned [list unit $unit]]
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 [list unit $unit]] \
-wma rpa.cs1 [regbld ibd_rhrp::CS1 tre] \
-rma rpa.dt -edata 0 \
-rma rpa.cs2 -edata $cs2val $cs2msk
}

149
tools/tbench/test_rhrp_func_reg.tcl Normal file
View File

@@ -0,0 +1,149 @@
# $Id: test_rhrp_func_reg.tcl 668 2015-04-25 14:31:19Z mueller $
#
# Copyright 2015- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
# License disclaimer see LICENSE_gpl_v2.txt in $RETROBASE directory
#
# Revision History:
# Date Rev Version Comment
# 2015-03-29 660 1.0 Initial version
#
# Test functions - register level
# A:
# ----------------------------------------------------------------------------
rlc log "test_rhrp_func_reg: test functions - register level -----------------"
rlc log " setup: unit 0:RP06(mol), 1:RM05(mol,wrl), 2: RP07(mol=0), 3: off"
package require ibd_rhrp
ibd_rhrp::setup
rlc set statmask $rw11::STAT_DEFMASK
rlc set statvalue 0
# configure drives
$cpu cp -wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 0] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 1} mol] \
-wibr rpa.dt $ibd_rhrp::DTE_RP06 \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 1] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 1} mol wrl] \
-wibr rpa.dt $ibd_rhrp::DTE_RM05 \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 2] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 1}] \
-wibr rpa.dt $ibd_rhrp::DTE_RP07 \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 3] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 0}]
# setup system: select unit 0; clr errors (cs1.tre and func=dclr); clear ATs
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-wma rpa.cs1 [regbld ibd_rhrp::CS1 tre] \
-wma rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::FUNC_DCLR] \
-wma rpa.as [regbld ibd_rhrp::AS u3 u2 u1 u0] \
-rma rpa.ds -edata [regbld ibd_rhrp::DS dpr mol dry]
# -- Section A -- function basics --------------------------------------------
rlc log " A -- function basics ----------------------------------------------"
rlc log " A1: test cs1 func basics ----------------------------------"
rlc log " A1.1a: func noop; check no as ----------------------"
set dsmsk [regbld ibd_rhrp::DS ata dpr]
$cpu cp -wma rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::FUNC_NOOP] \
-rma rpa.as -edata 0x0 \
-rma rpa.ds -edata [regbld ibd_rhrp::DS dpr] $dsmsk
rlc log " A2.1a: test invalid function (037) -----------------"
$cpu cp -wma rpa.cs1 [ibd_rhrp::cs1_func 037]
rlc log " A2.1b: check as,er1.ilf,ds.ata; clear as; recheck --"
$cpu cp -rma rpa.as -edata [regbld ibd_rhrp::AS u0] \
-rma rpa.er1 -edata [regbld ibd_rhrp::ER1 ilf] \
-rma rpa.ds -edata [regbld ibd_rhrp::DS ata dpr] $dsmsk \
-wma rpa.as [regbld ibd_rhrp::AS u0] \
-rma rpa.as -edata 0x0 \
-rma rpa.ds -edata [regbld ibd_rhrp::DS dpr] $dsmsk
rlc log " A2.2a: func dclr; check no as and er1 clear --------"
$cpu cp -wma rpa.as [regbld ibd_rhrp::AS u3 u2 u1 u0] \
-wma rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::FUNC_DCLR] \
-rma rpa.as -edata 0x0 \
-rma rpa.er1 -edata 0x0
# -- Section B -- state functions --------------------------------------------
rlc log " B -- state functions ----------------------------------------------"
# -- Section C -- seek functions ---------------------------------------------
rlc log " C -- seek functions -----------------------------------------------"
# -- Section D -- transfer functions -----------------------------------------
rlc log " D -- transfer functions -------------------------------------------"
rlc log " D1: test func read sequence -------------------------------"
rlc log " D1.1: issue func with ie=0 ---------------------------"
# discard pending attn to be on save side
rlc wtlam 0.
rlc exec -attn
set attnmsk [expr {1<<$ibd_rhrp::ANUM}]
set ba 0x1000
set wc [expr {0xffff & (-256)}]
set da [regbld ibd_rhrp::DA {ta 2} {sa 1}]
set dc 0x0003
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-wma rpa.cs1 [regbld ibd_rhrp::CS1 tre] \
-wma rpa.ba $ba \
-wma rpa.bae 0x0 \
-wma rpa.wc $wc \
-wma rpa.da $da \
-wma rpa.dc $dc \
-wma rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::FUNC_READ]
rlc log " D1.2: loc status check: cs1.rdy=0, ds.dry=0 ----------"
$cpu cp -rma rpa.cs1 -edata 0 [regbld ibd_rhrp::CS1 rdy] \
-rma rpa.ds -edata 0 [regbld ibd_rhrp::DS dry]
rlc log " D1.3: rem status check: attn + state -----------------"
rlc exec -attn -edata $attnmsk
# check rdy=0 ie=0 func=read
set cs1val [regbld ibd_rhrp::CS1 [list func $ibd_rhrp::FUNC_READ]]
set cs1msk [regbld ibd_rhrp::CS1 rdy ie {func -1}]
# expect ds mol=1 dpr=1 dry=0
set dsval [regbld ibd_rhrp::DS mol dpr]
$cpu cp -wibr rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::RFUNC_CUNIT] \
-ribr rpa.cs1 -edata $cs1val $cs1msk \
-ribr rpa.ba -edata $ba \
-ribr rpa.bae -edata 0x0 \
-ribr rpa.wc -edata $wc \
-ribr rpa.da -edata $da \
-ribr rpa.dc -edata $dc \
-ribr rpa.ds -edata $dsval
rlc log " D1.4: rem send response ------------------------------"
set ba [expr {0xffff & (-$wc)}]
set da [regbld ibd_rhrp::DA {ta 2} {sa 2}]
$cpu cp -wibr rpa.ba $ba \
-wibr rpa.wc 0x0 \
-wibr rpa.da $da \
-wibr rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::RFUNC_DONE]
rlc log " D1.5: loc check: cs1.rdy=1, ds.dry=1 -----------------"
# expect cs1 sc=0 tre=0 dva=1 rdy=1 ie=0 func=read go=0
set cs1val [regbld ibd_rhrp::CS1 dva rdy [list func $ibd_rhrp::FUNC_READ]]
# expect ds ata=0 mol=1 dpr=1 dry=1
set dsval [regbld ibd_rhrp::DS mol dpr dry]
$cpu cp -rma rpa.cs1 -edata $cs1val \
-rma rpa.ba -edata $ba \
-rma rpa.wc -edata 0x0 \
-rma rpa.da -edata $da \
-rma rpa.ds -edata $dsval

490
tools/tbench/test_rhrp_int.tcl Normal file
View File

@@ -0,0 +1,490 @@
# $Id: test_rhrp_int.tcl 678 2015-05-10 16:23:02Z mueller $
#
# Copyright 2015- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
# License disclaimer see LICENSE_gpl_v2.txt in $RETROBASE directory
#
# Revision History:
# Date Rev Version Comment
# 2015-05-04 674 1.1 w11a start/stop/suspend overhaul
# 2015-03-29 667 1.0 Initial version
#
# Test interrupt response
# A:
# ----------------------------------------------------------------------------
rlc log "test_rhrp_int: test interrupt response ------------------------------"
rlc log " setup: unit 0:RP06(mol), 1:RM05(mol,wrl), 2: RP07(mol=0), 3: off"
package require ibd_rhrp
ibd_rhrp::setup
rlc set statmask $rw11::STAT_DEFMASK
rlc set statvalue 0
# configure drives
$cpu cp -wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 0] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 1} mol] \
-wibr rpa.dt $ibd_rhrp::DTE_RP06 \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 1] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 1} mol wrl] \
-wibr rpa.dt $ibd_rhrp::DTE_RM05 \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 2] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 1}] \
-wibr rpa.dt $ibd_rhrp::DTE_RP07 \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 3] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 0}]
# clear errors: cs1.tre=1 via unit 0
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-wma rpa.cs1 [regbld ibd_rhrp::CS1 tre] \
-wma rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::FUNC_DCLR] \
-wma rpa.as [regbld ibd_rhrp::AS u3 u2 u1 u0] \
-rma rpa.ds -edata [regbld ibd_rhrp::DS dpr mol dry]
# load test code
$cpu ldasm -lst lst -sym sym {
.include |lib/defs_cpu.mac|
.include |lib/defs_rp.mac|
;
.include |lib/vec_cpucatch.mac|
;
. = 000254 ; setup RHRP interrupt vector
v..rp: .word vh.rp
.word cp.pr7
;
. = 1000 ; data area
stack:
ibuf: .blkw 4. ; input buffer
rint: .word 0 ; reinterrupt
;
icnt: .word 0 ; interrupt count
pcnt: .word 0 ; poll count
obuf: .blkw 6. ; output buffer
fbuf: .blkw 5. ; final buffer
;
. = 2000 ; code area
start: spl 7 ; lock out interrupts
clr icnt ; clear counters
clr pcnt
;
mov #obuf,r0 ; clear obuf
clr (r0)+
clr (r0)+
clr (r0)+
clr (r0)+
clr (r0)+
clr (r0)+
clr r5 ; r5 used to time int delay
;
mov #ibuf,r0 ; setup regs from ibuf
mov (r0)+,@#rp.cs2 ; cs2
mov (r0)+,@#rp.da ; da
mov (r0)+,@#rp.dc ; dc
mov (r0)+,@#rp.cs1 ; cs1
spl 0 ; allow interrupts
;
inc r5 ; time int delay, up to 10 instructions
inc r5
inc r5
inc r5
inc r5
inc r5
inc r5
inc r5
inc r5
inc r5
;
poll: inc pcnt ; count polls
tstb @#rp.cs1 ; check cs1 rdy
bpl poll ; if rdy=0 keep polling
tst icnt ; did we have an interrupt ?
bne 1$ ;
;
mov #obuf,r0 ; store regs in obuf
mov @#rp.cs1,(r0)+ ; cs1
mov @#rp.cs2,(r0)+ ; cs2
mov @#rp.er1,(r0)+ ; er1
mov @#rp.ds,(r0)+ ; ds
mov @#rp.as,(r0)+ ; as
;
1$: tst rint ; re-interrupt wanted ?
bne 2$ ;
mov #377,@#rp.as ; if not, cancel all attentions
clr rint
;
2$: bit #rp.erp,@#rp.ds ; ds.erp = 1 ? any controller errors ?
beq 3$
mov #<rp.fcl+rp.go>,@#rp.cs1 ; than do drive clear
;
3$: bit #rp.tre,@#rp.cs1 ; cs1.tre = 1 ? any transfer errors ?
beq 4$
mov #rp.tre,@#rp.cs1 ; if yes, clear them with tre=1 write
;
4$: mov #fbuf,r0 ; store final regs in fbuf
mov @#rp.cs1,(r0)+ ; cs1
mov @#rp.cs2,(r0)+ ; cs2
mov @#rp.er1,(r0)+ ; er1
mov @#rp.ds,(r0)+ ; ds
mov @#rp.as,(r0)+ ; as
halt ; halt if done
stop:
;
clr pcnt ; clear pcnt again
mov #obuf,r0 ; clear obuf again
clr (r0)+
clr (r0)+
clr (r0)+
clr (r0)+
clr (r0)+
clr (r0)+
;
mov #rp.ie,@#rp.cs1 ; re-enable interrupt
br poll
; RHRP interrupt handler
vh.rp: mov #obuf,r0 ; store regs in obuf
mov @#rp.cs1,(r0)+ ; cs1
mov @#rp.cs2,(r0)+ ; cs2
mov @#rp.er1,(r0)+ ; er1
mov @#rp.ds,(r0)+ ; ds
mov @#rp.as,r1 ;
mov r1,(r0)+ ; as
mov r5,(r0)+ ; int delay
;
1$: tst icnt ; test first interrupt
beq 2$ ; if yes quit
mov r1,@#rp.as ; if not, clear as
2$: inc icnt ; count interrupts
rti ; and return
}
##puts $lst
# define tmpproc for readback checks
proc tmpproc_dotest {cpu symName opts} {
upvar 1 $symName sym
set tout 10.; # FIXME_code: parameter ??
# setup defs hash, first defaults, than write over concrete run values
array set defs { i.cs2 0 \
i.da 0 \
i.dc 0 \
i.cs1 0 \
i.idly 0 \
o.cs1 0 \
o.cs2 0 \
o.er1 0 \
o.ds 0 \
o.as 0 \
o.itim 10 \
o.icnt 0 \
o.pcnt 1 \
or.cs1 0 \
or.cs2 0 \
or.er1 0 \
or.ds 0 \
or.as 0 \
or.icnt 0 \
or.pcnt 1 \
do.rint 0 \
do.lam 0
}
array set defs $opts
# build ibuf
set ibuf [list $defs(i.cs2) $defs(i.da) $defs(i.dc) $defs(i.cs1) \
$defs(do.rint)]
# setup idly, write ibuf, setup stack, and start cpu at start:
$cpu cp -wibr rpa.cs1 [regbld ibd_rhrp::RCS1 \
[list val $defs(i.idly)] \
[list func $ibd_rhrp::RFUNC_WIDLY] ] \
-wal $sym(ibuf) \
-bwm $ibuf \
-wsp $sym(stack) \
-stapc $sym(start)
# here do minimal lam handling (harvest + send DONE)
if {$defs(do.lam)} {
rlc wtlam $tout apat
$cpu cp -attn \
-wibr rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::RFUNC_DONE]
}
$cpu wtcpu -reset $tout
# determine regs after cleanup
set cs1msk [rutil::com16 [regbld ibd_rhrp::CS1 {func -1}]]
set fcs2 [expr {$defs(o.cs2) & 0x00ff}]; # cs1.tre clears upper byte !
set fer1 0
if {!$defs(do.rint)} { # no reinterrupt, ata clear by cpu
set fcs1 [expr {$defs(o.cs1) & ~[regbld ibd_rhrp::CS1 sc tre {func -1}] }]
set fds [expr {$defs(o.ds) & ~[regbld ibd_rhrp::DS ata erp] }]
set fas 0
} else { # reinterrupt, ata still pending
set fcs1 [expr {$defs(o.cs1) & ~[regbld ibd_rhrp::CS1 tre {func -1}] }]
set fds [expr {$defs(o.ds) & ~[regbld ibd_rhrp::DS erp] }]
set fas $defs(o.as)
}
$cpu cp -rpc -edata $sym(stop) \
-rsp -edata $sym(stack) \
-wal $sym(icnt) \
-rmi -edata $defs(o.icnt) \
-rmi \
-rmi -edata $defs(o.cs1) \
-rmi -edata $defs(o.cs2) \
-rmi -edata $defs(o.er1) \
-rmi -edata $defs(o.ds) \
-rmi -edata $defs(o.as) \
-rmi -edata $defs(o.itim) \
-rmi -edata $fcs1 $cs1msk \
-rmi -edata $fcs2 \
-rmi -edata $fer1 \
-rmi -edata $fds \
-rmi -edata $fas
if {!$defs(do.rint)} return "";
$cpu cp -start
$cpu wtcpu -reset $tout
# determine regs after cleanup
set fcs1 [expr {$defs(or.cs1) & ~[regbld ibd_rhrp::CS1 sc] }]
set fcs2 $defs(or.cs2)
set fer1 0
set fds [expr {$defs(or.ds) & ~[regbld ibd_rhrp::DS ata] }]
set fas 0
$cpu cp -rpc -edata $sym(stop) \
-rsp -edata $sym(stack) \
-wal $sym(icnt) \
-rmi -edata $defs(or.icnt) \
-rmi \
-rmi -edata $defs(or.cs1) \
-rmi -edata $defs(or.cs2) \
-rmi -edata $defs(or.er1) \
-rmi -edata $defs(or.ds) \
-rmi -edata $defs(or.as) \
-rmi \
-rmi -edata $fcs1 \
-rmi -edata $fcs2 \
-rmi -edata $fer1 \
-rmi -edata $fds \
-rmi -edata $fas
return ""
}
# discard pending attn to be on save side
rlc wtlam 0.
rlc exec -attn
# -- Section A ---------------------------------------------------------------
rlc log " A -- function basics ----------------------------------------------"
rlc log " A1: test rdy and ie logic ---------------------------------"
rlc log " A1.1 set cs1.ie=1 alone -> no interrupt ------------"
# Note: no interrupt, so ie stays on !
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 ie] \
o.icnt 0 \
o.cs1 [regbld ibd_rhrp::CS1 dva rdy ie] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.er1 0 \
o.ds [regbld ibd_rhrp::DS mol dpr dry] \
o.as 0 \
o.itim 0
]
tmpproc_dotest $cpu sym $opts
rlc log " A1.2 set cs1.ie=1 with rdy=1 -> software interrupt -"
# Note: interrupt, so ie switched off again !
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 rdy ie] \
o.icnt 1 \
o.cs1 [regbld ibd_rhrp::CS1 dva rdy] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.er1 0 \
o.ds [regbld ibd_rhrp::DS mol dpr dry] \
o.as 0 \
o.itim 1
]
tmpproc_dotest $cpu sym $opts
rlc log " A2: test state functions: iff no, as yes ------------------"
rlc log " A2.1 noop function ---------------------------------"
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 ie go] \
o.cs1 [regbld ibd_rhrp::CS1 ie dva rdy] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.er1 0 \
o.ds [regbld ibd_rhrp::DS mol dpr dry] \
o.as 0 \
o.itim 0
]
tmpproc_dotest $cpu sym $opts
rlc log " A2.2 pack acknowledge function (sets ds.vv=1) ------"
set rbcs1func [list func $ibd_rhrp::FUNC_PACK]
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 $rbcs1func ie go] \
o.cs1 [regbld ibd_rhrp::CS1 dva rdy ie $rbcs1func] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.er1 0 \
o.ds [regbld ibd_rhrp::DS mol dpr dry vv] \
o.as 0 \
o.itim 0
]
tmpproc_dotest $cpu sym $opts
rlc log " A3: test seek type functions: iff no, as yes --------------"
rlc log " A3.1 seek function, ie=0, valid da,dc---------------"
# check that cs1.sc=1, ds.ata=1, and as.u0=1
set rbcs1func [list func $ibd_rhrp::FUNC_SEEK]
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 $rbcs1func go] \
o.cs1 [regbld ibd_rhrp::CS1 sc dva rdy $rbcs1func] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.er1 0 \
o.ds [regbld ibd_rhrp::DS ata mol dpr dry vv] \
o.as [regbld ibd_rhrp::AS u0] \
o.itim 0
]
tmpproc_dotest $cpu sym $opts
rlc log " A3.2 seek function, valid da,dc, idly=0 ------------"
# check re-interrupt too
set rbcs1func [list func $ibd_rhrp::FUNC_SEEK]
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 ie $rbcs1func go] \
i.dc 814 \
i.idly 0 \
o.icnt 1 \
o.cs1 [regbld ibd_rhrp::CS1 sc dva rdy $rbcs1func] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.er1 0 \
o.ds [regbld ibd_rhrp::DS ata mol dpr dry vv] \
o.as [regbld ibd_rhrp::AS u0] \
o.itim 1 \
do.rint 1 \
or.icnt 2 \
or.cs1 [regbld ibd_rhrp::CS1 sc dva rdy] \
or.cs2 [regbld ibd_rhrp::CS2 or ir] \
or.er1 0 \
or.ds [regbld ibd_rhrp::DS ata mol dpr dry vv] \
or.as [regbld ibd_rhrp::AS u0]
]
tmpproc_dotest $cpu sym $opts
rlc log " A3.3 seek function, invalid dc ---------------------"
set rbcs1func [list func $ibd_rhrp::FUNC_SEEK]
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 ie $rbcs1func go] \
i.dc 815 \
o.icnt 1 \
o.cs1 [regbld ibd_rhrp::CS1 sc dva rdy $rbcs1func] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.er1 [regbld ibd_rhrp::ER1 iae] \
o.ds [regbld ibd_rhrp::DS ata erp mol dpr dry vv] \
o.as [regbld ibd_rhrp::AS u0] \
o.itim 1
]
tmpproc_dotest $cpu sym $opts
rlc log " A3.4 search function, valid da,dc, idly=0 ----------"
set rbcs1func [list func $ibd_rhrp::FUNC_SEAR]
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 ie $rbcs1func go] \
i.dc 0 \
i.da [regbld ibd_rhrp::DA {ta 0} {sa 21}] \
i.idly 0 \
o.icnt 1 \
o.cs1 [regbld ibd_rhrp::CS1 sc dva rdy $rbcs1func] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.er1 0 \
o.ds [regbld ibd_rhrp::DS ata mol dpr dry vv] \
o.as [regbld ibd_rhrp::AS u0] \
o.itim 1
]
tmpproc_dotest $cpu sym $opts
rlc log " A3.5 search function, valid da,dc, idly=2 ----------"
set rbcs1func [list func $ibd_rhrp::FUNC_SEAR]
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 ie $rbcs1func go] \
i.dc 0 \
i.da [regbld ibd_rhrp::DA {ta 0} {sa 21}] \
i.idly 2 \
o.icnt 1 \
o.cs1 [regbld ibd_rhrp::CS1 sc dva rdy $rbcs1func] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.er1 0 \
o.ds [regbld ibd_rhrp::DS ata mol dpr dry vv] \
o.as [regbld ibd_rhrp::AS u0] \
o.itim 3
]
tmpproc_dotest $cpu sym $opts
rlc log " A3.5 search function, valid da,dc, idly=8 ----------"
set rbcs1func [list func $ibd_rhrp::FUNC_SEAR]
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 ie $rbcs1func go] \
i.dc 0 \
i.da [regbld ibd_rhrp::DA {ta 0} {sa 21}] \
i.idly 8 \
o.icnt 1 \
o.cs1 [regbld ibd_rhrp::CS1 sc dva rdy $rbcs1func] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.er1 0 \
o.ds [regbld ibd_rhrp::DS ata mol dpr dry vv] \
o.as [regbld ibd_rhrp::AS u0] \
o.itim 9
]
tmpproc_dotest $cpu sym $opts
rlc log " A3.5 search function, invalid sa, idly=8 -----------"
# Note: idly is 8, but error ata's come immediately !!
set rbcs1func [list func $ibd_rhrp::FUNC_SEAR]
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 ie $rbcs1func go] \
i.dc 0 \
i.da [regbld ibd_rhrp::DA {ta 0} {sa 22}] \
i.idly 8 \
o.icnt 1 \
o.cs1 [regbld ibd_rhrp::CS1 sc dva rdy $rbcs1func] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.er1 [regbld ibd_rhrp::ER1 iae] \
o.ds [regbld ibd_rhrp::DS ata erp mol dpr dry vv] \
o.as [regbld ibd_rhrp::AS u0] \
o.itim 1
]
tmpproc_dotest $cpu sym $opts
rlc log " A4: test transfer functions: iff yes, as no ---------------"
rlc log " A4.1 read function, valid da,dc --------------------"
set rbcs1func [list func $ibd_rhrp::FUNC_READ]
set opts [list \
i.cs1 [regbld ibd_rhrp::CS1 ie $rbcs1func go] \
o.icnt 1 \
o.cs1 [regbld ibd_rhrp::CS1 dva rdy $rbcs1func] \
o.cs2 [regbld ibd_rhrp::CS2 or ir] \
o.ds [regbld ibd_rhrp::DS mol dpr dry vv] \
do.lam 1
]
tmpproc_dotest $cpu sym $opts

426
tools/tbench/test_rhrp_regs.tcl Normal file
View File

@@ -0,0 +1,426 @@
# $Id: test_rhrp_regs.tcl 678 2015-05-10 16:23:02Z mueller $
#
# Copyright 2015- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
# License disclaimer see LICENSE_gpl_v2.txt in $RETROBASE directory
#
# Revision History:
# Date Rev Version Comment
# 2015-03-29 660 1.0 Initial version
#
# Test register response
# A: test ba, bae, cs1.bae, wc and db (cntl regs)
# B: test da, dc (and cc for RP typ)
# C: test of,mr1,mr2(for RM typ); test NI regs: er2,er3,ec1,ec2
# D: test hr (for RM typ); ensure unit distinct
# E: test cs2.clr
# F: test er1
# ----------------------------------------------------------------------------
rlc log "test_rhrp_regs: test register response ------------------------------"
rlc log " setup context; unit 0:RP06, 1:RM05, 2: RP07, 3: off"
package require ibd_rhrp
ibd_rhrp::setup
rlc set statmask $rw11::STAT_DEFMASK
rlc set statvalue 0
# configure drives
$cpu cp -wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 0] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 1}] \
-wibr rpa.dt $ibd_rhrp::DTE_RP06 \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 1] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 1}] \
-wibr rpa.dt $ibd_rhrp::DTE_RM05 \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 2] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 1}] \
-wibr rpa.dt $ibd_rhrp::DTE_RP07 \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 3] \
-wibr rpa.ds [regbld ibd_rhrp::DS {dpr 0}]
# clear errors: cs1.tre=1 via unit 0
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-wma rpa.cs1 [regbld ibd_rhrp::CS1 tre]
# -- Section A ---------------------------------------------------------------
rlc log " A1: test ba,bae and cs1.bae -------------------------------"
rlc log " A1.1: loc write ba, read loc and rem ---------------"
$cpu cp -wma rpa.ba 0xffff \
-rma rpa.ba -edata 0xfffe \
-ribr rpa.ba -edata 0xfffe \
-wma rpa.ba 0x0 \
-rma rpa.ba -edata 0x0 \
-ribr rpa.ba -edata 0x0
rlc log " A1.2: rem write ba, read loc and rem ---------------"
$cpu cp -wibr rpa.ba 0x12ef \
-ribr rpa.ba -edata 0x12ee \
-rma rpa.ba -edata 0x12ee \
-wibr rpa.ba 0x0 \
-ribr rpa.ba -edata 0x0 \
-rma rpa.ba -edata 0x0
rlc log " A1.3: loc write bae, read l+r bae+cs1.bae ----------"
set cs1msk [regbld ibd_rhrp::CS1 {bae -1}]
foreach bae {077 071 000} {
set cs1val [regbld ibd_rhrp::CS1 [list bae [expr {$bae & 03}]]]
$cpu cp -wma rpa.bae $bae \
-rma rpa.bae -edata $bae \
-rma rpa.cs1 -edata $cs1val $cs1msk \
-ribr rpa.bae -edata $bae \
-ribr rpa.cs1 -edata $cs1val $cs1msk
}
rlc log " A1.4: rem write bae, read l+r bae+cs1.bae ----------"
foreach bae {077 071 000} {
set cs1val [regbld ibd_rhrp::CS1 [list bae [expr {$bae & 03}]]]
$cpu cp -wibr rpa.bae $bae \
-ribr rpa.bae -edata $bae \
-ribr rpa.cs1 -edata $cs1val $cs1msk \
-rma rpa.bae -edata $bae \
-rma rpa.cs1 -edata $cs1val $cs1msk
}
rlc log " A1.5: loc write cs1.bae, read l+r bae+cs1.bae ------"
$cpu cp -wibr rpa.bae 070; # set 3 lbs of bae
foreach cs1bae {03 01 00} {
set cs1val [regbld ibd_rhrp::CS1 [list bae $cs1bae]]
set bae [expr {070 | $cs1bae}]
$cpu cp -wma rpa.cs1 $cs1val \
-rma rpa.bae -edata $bae \
-rma rpa.cs1 -edata $cs1val $cs1msk \
-ribr rpa.bae -edata $bae \
-ribr rpa.cs1 -edata $cs1val $cs1msk
}
# Note: cs1.bae can only be loc written !
# No need to do this via rem, use bae !!
# therefore no 'rem write cs1.bae' test
rlc log " A1.6: loc write cs1.func, read loc, ensure distinct "
set funcu0 [regbld ibd_rhrp::CS1 {func 001}]
set funcu1 [regbld ibd_rhrp::CS1 {func 025}]
set funcu2 [regbld ibd_rhrp::CS1 {func 037}]
set funcmsk [regbld ibd_rhrp::CS1 {func -1}]
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-wma rpa.cs1 $funcu0 \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-wma rpa.cs1 $funcu1 \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-wma rpa.cs1 $funcu2
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-rma rpa.cs1 -edata $funcu0 $funcmsk \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-rma rpa.cs1 -edata $funcu1 $funcmsk \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-rma rpa.cs1 -edata $funcu2 $funcmsk
# Note: rem read of cs1.func always gives func frozen a go for xfer function !
# therefore no rem read cs1.func test here
rlc log " A2: test wc; ensure wc,ba distinct ------------------------"
rlc log " A2.1: loc write wc,ba, read loc and rem ------------"
foreach {wc ba} {0xdead 0x1234 0xbeaf 0x5678} {
$cpu cp -wma rpa.wc $wc \
-wma rpa.ba $ba \
-rma rpa.wc -edata $wc \
-rma rpa.ba -edata $ba \
-ribr rpa.wc -edata $wc \
-ribr rpa.ba -edata $ba
}
rlc log " A2.2: rem write wc,ba, read loc and rem ------------"
foreach {wc ba} {0x4321 0x3456 0x5432 0x1234} {
$cpu cp -wibr rpa.wc $wc \
-wibr rpa.ba $ba \
-ribr rpa.wc -edata $wc \
-ribr rpa.ba -edata $ba \
-rma rpa.wc -edata $wc \
-rma rpa.ba -edata $ba
}
rlc log " A3: test db; check cs2.or,ir; ensure ba,dt distinct --"
set cs2msk [regbld ibd_rhrp::CS2 or ir {unit -1}]
set cs2val [regbld ibd_rhrp::CS2 or ir {unit 0}]
# clear cs2 -> set unit 0; later check that or,ir set, and unit 0
# only loc tested; rem side irrelevant
foreach {db ba} {0xdead 0x1234 0xbeaf 0x5678} {
$cpu cp -wma rpa.cs2 0 \
-wma rpa.db $db \
-wma rpa.ba $ba \
-rma rpa.cs2 -edata $cs2val $cs2msk \
-rma rpa.db -edata $db \
-rma rpa.ba -edata $ba
}
# -- Section B ---------------------------------------------------------------
rlc log " B1: test da,dc; ensure unit distinct; check cc ------------"
# define tmpproc for readback checks
proc tmpproc_checkdadc {cpu tbl} {
foreach {unit ta sa dc} $tbl {
set da [regbld ibd_rhrp::DA [list ta $ta] [list sa $sa]]
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 [list unit $unit]] \
-rma rpa.da -edata $da \
-rma rpa.dc -edata $dc \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit $unit] \
-ribr rpa.da -edata $da \
-ribr rpa.dc -edata $dc
}
}
rlc log " B1.1: loc setup ------------------------------------"
# unit ta sa dc
# 5b 6b 10b
set tbl { 0 007 006 00123 \
1 013 031 00345 \
2 037 077 01777
}
foreach {unit ta sa dc} $tbl {
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 [list unit $unit]] \
-wma rpa.da [regbld ibd_rhrp::DA [list ta $ta] [list sa $sa]] \
-wma rpa.dc $dc
}
rlc log " B1.2: loc+rem readback -----------------------------"
tmpproc_checkdadc $cpu $tbl
rlc log " B1.3: check cc for unit 0 (RP06) -------------------"
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-rma rpa.m13 -edata 00123
rlc log " B1.4: rem setup ------------------------------------"
# unit ta sa dc
# 5b 6b 10b
set tbl { 0 005 004 00234 \
1 020 077 00456 \
2 032 023 01070
}
foreach {unit ta sa dc} $tbl {
$cpu cp -wibr rpa.cs1 [ibd_rhrp::rcs1_wunit $unit] \
-wibr rpa.da [regbld ibd_rhrp::DA [list ta $ta] [list sa $sa]] \
-wibr rpa.dc $dc
}
rlc log " B1.5: loc+rem readback -----------------------------"
tmpproc_checkdadc $cpu $tbl
rlc log " B1.6: check cc for unit 0 (RP06) -------------------"
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-rma rpa.m13 -edata 00234
# -- Section C ---------------------------------------------------------------
rlc log " C1: test of,mr1,mr2(for RM typ); test NI regs: er2,er3,ec1,ec2"
# test fmt,eci,hci flags (NI, but stored), also off for RP
set of_0 [regbld ibd_rhrp::OF fmt {odi 1} {off -1}]
set of_1 [regbld ibd_rhrp::OF eci {odi 0}]
set of_2 [regbld ibd_rhrp::OF hci {odi 0}]
set mr1_0 0x7700
set mr1_1 0x7701
set mr1_2 0x7702
set mr2_1 0x6601
set mr2_2 0x6602
set da_0 [regbld ibd_rhrp::DA {ta 010} {sa 022}]
set da_1 [regbld ibd_rhrp::DA {ta 011} {sa 021}]
set da_2 [regbld ibd_rhrp::DA {ta 012} {sa 020}]
set dc_0 0x40
set dc_1 0x41
set dc_2 0x42
rlc log " C1.1: loc write da,mr1,of,dc (mr2 for RM) ----------"
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-wma rpa.da $da_0 \
-wma rpa.mr1 $mr1_0 \
-wma rpa.of $of_0 \
-wma rpa.dc $dc_0
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-wma rpa.da $da_1 \
-wma rpa.mr1 $mr1_1 \
-wma rpa.of $of_1 \
-wma rpa.dc $dc_1 \
-wma rpa.m14 $mr2_1
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-wma rpa.da $da_2 \
-wma rpa.mr1 $mr1_2 \
-wma rpa.of $of_2 \
-wma rpa.dc $dc_2 \
-wma rpa.m14 $mr2_2
rlc log " C1.2: loc read da,mr1,of,dc (mr2 for RM) -----------"
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-rma rpa.da -edata $da_0 \
-rma rpa.mr1 -edata $mr1_0 \
-rma rpa.of -edata $of_0 \
-rma rpa.dc -edata $dc_0
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-rma rpa.da -edata $da_1 \
-rma rpa.mr1 -edata $mr1_1 \
-rma rpa.of -edata $of_1 \
-rma rpa.dc -edata $dc_1 \
-rma rpa.m14 -edata $mr2_1
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-rma rpa.da -edata $da_2 \
-rma rpa.mr1 -edata $mr1_2 \
-rma rpa.of -edata $of_2 \
-rma rpa.dc -edata $dc_2 \
-rma rpa.m14 -edata $mr2_2
rlc log " C2.1: loc write er2,er3,ec1,ec2 --------------------"
# unit 0: RP typ -> m14 is er2; m15 is er3
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-wma rpa.m14 0xaa00 \
-wma rpa.m15 0xaa10 \
-wma rpa.ec1 0xaa20 \
-wma rpa.ec1 0xaa30
# unit 1+2: RM typ -> m15 is er2
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-wma rpa.m15 0xaa11 \
-wma rpa.ec1 0xaa21 \
-wma rpa.ec1 0xaa31
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-wma rpa.m15 0xaa12 \
-wma rpa.ec1 0xaa22 \
-wma rpa.ec1 0xaa32
rlc log " C2.1: loc read er2,er3,ec1,ec2 (NI -> =0!) ---------"
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-rma rpa.m14 -edata 0x0 \
-rma rpa.m15 -edata 0x0 \
-rma rpa.ec1 -edata 0x0 \
-rma rpa.ec1 -edata 0x0
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-rma rpa.m15 -edata 0x0 \
-rma rpa.ec1 -edata 0x0 \
-rma rpa.ec1 -edata 0x0
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-rma rpa.m15 -edata 0x0 \
-rma rpa.ec1 -edata 0x0 \
-rma rpa.ec1 -edata 0x0
# -- Section D ---------------------------------------------------------------
rlc log " D1: test hr (for RM typ); ensure unit distinct ------------"
# test unit 1+2, they are RM typ (RM05 and RP07)
set da [regbld ibd_rhrp::DA {ta 005} {sa 023}]; # some da
set dc 00456; # some dc
rlc log " D1.1: write da(1) and dc(2) ------------------------"
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-wma rpa.da $da \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-wma rpa.da $dc
rlc log " D1.2: check hr(1) and hr(2) ------------------------"
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-rma rpa.m13 -edata [rutil::com16 $da] \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-rma rpa.m13 -edata [rutil::com16 $dc]
rlc log " D1.3: write da(2) and dc(1) ------------------------"
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-wma rpa.da $da \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-wma rpa.da $dc
rlc log " D1.4: check hr(1) and hr(2) ------------------------"
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-rma rpa.m13 -edata [rutil::com16 $dc] \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-rma rpa.m13 -edata [rutil::com16 $da]
# FIXME: add code to check hr response for all mb reg writes
# -- Section E ---------------------------------------------------------------
rlc log " E1: test rem er1 write; clear via func=dclr ---------------"
rlc log " E1.1: rem er1 set uns,iae,aoe,ilf; loc readback ----"
set er1msk [regbld ibd_rhrp::ER1 uns iae aoe ilf]
# use unit 1
$cpu cp -wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 1] \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}]
$cpu cp -rma rpa.er1 -edata 0x0 \
-wibr rpa.er1 [regbld ibd_rhrp::ER1 uns] \
-rma rpa.er1 -edata [regbld ibd_rhrp::ER1 uns] $er1msk \
-wibr rpa.er1 [regbld ibd_rhrp::ER1 iae] \
-rma rpa.er1 -edata [regbld ibd_rhrp::ER1 uns iae] $er1msk \
-wibr rpa.er1 [regbld ibd_rhrp::ER1 aoe] \
-rma rpa.er1 -edata [regbld ibd_rhrp::ER1 uns iae aoe] $er1msk \
-wibr rpa.er1 [regbld ibd_rhrp::ER1 ilf] \
-rma rpa.er1 -edata [regbld ibd_rhrp::ER1 uns iae aoe ilf] $er1msk
rlc log " E1.2: clear er1 via func=dclr ----------------------"
$cpu cp -wma rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::FUNC_DCLR] \
-rma rpa.er1 -edata 0x0
rlc log " E1.3: rem er1 set in different units ---------------"
$cpu cp -wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 0] \
-wibr rpa.er1 [regbld ibd_rhrp::ER1 iae] \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 1] \
-wibr rpa.er1 [regbld ibd_rhrp::ER1 aoe] \
-wibr rpa.cs1 [ibd_rhrp::rcs1_wunit 2] \
-wibr rpa.er1 [regbld ibd_rhrp::ER1 ilf]
rlc log " E1.4: loc readback, show er1 is distinct -----------"
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-rma rpa.er1 -edata [regbld ibd_rhrp::ER1 iae] $er1msk \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-rma rpa.er1 -edata [regbld ibd_rhrp::ER1 aoe] $er1msk \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-rma rpa.er1 -edata [regbld ibd_rhrp::ER1 ilf] $er1msk
rlc log " E1.5: show func=dclr distinct ----------------------"
# clear unit 1, that that 1 clr and 0+2 untouched
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-wma rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::FUNC_DCLR] \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-rma rpa.er1 -edata [regbld ibd_rhrp::ER1 iae] $er1msk \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 1}] \
-rma rpa.er1 -edata 0x0 \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-rma rpa.er1 -edata [regbld ibd_rhrp::ER1 ilf] $er1msk
rlc log " E1.6: clear er1 in remaining units -----------------"
# unit 0+2 still have er1 bits set from previous test
$cpu cp -wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 0}] \
-wma rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::FUNC_DCLR] \
-rma rpa.er1 -edata 0x0 \
-wma rpa.cs2 [regbld ibd_rhrp::CS2 {unit 2}] \
-wma rpa.cs1 [ibd_rhrp::cs1_func $ibd_rhrp::FUNC_DCLR] \
-rma rpa.er1 -edata 0x0