home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
ftp.barnyard.co.uk
/
2015.02.ftp.barnyard.co.uk.tar
/
ftp.barnyard.co.uk
/
cpm
/
walnut-creek-CDROM
/
SIMTEL
/
CPMUG
/
CPMUG042.ARK
/
MNEMONIC.ASM
< prev
next >
Wrap
Assembly Source File
|
1984-04-29
|
27KB
|
1,059 lines
TITLE '*** MNEMONIC V. 2.0 - 3/14/79 ***'
PAGE 57
;*******************************************************************
;
; MNEMONIC - A MULTI-PASS MEMORY TESTER FOR CP/M
;
; COPYRIGHT 1978, BY
; WILLIAM T. PRECHT & ASSOCIATES
; 1102 S. EDSON
; LOMBARD, IL 60148
;
;********************************************************************
;
ORG 100H ; ORG FOR CP/M TPA
;
STAK EQU 1000H ; STACK ADDR - PRESERVE THIS
STAKH EQU 10H ; STACK H/O ADDR - USED TO COMPARE TO PARMS
EXITA EQU 0F000H ; COLD BOOT ADDR
CONSD EQU 00 ; CONSOLE DATA PORT
CONST EQU 02 ; CONSOLE STATUS PORT
CONSI EQU 04H ; READY BIT FOR KYBD (ACTIVE HIGH)
CONSO EQU 08H ; READY BIT FOR CONSOLE OUTPUT (ACTIVE HIGH)
SSWD EQU 20H ; SENSE SW 5 = DETAIL ERROR LIST
SSWS EQU 10H ; S.S. 4 = DO SLOW TEST
;
;*******************************************************************
;
JMP START ; BYPASS JUMP TABLE
;
EXIT JMP EXITA ; EXIT JUMP - GO TO COLD BOOT ADDR
KEYIN JMP ZKEYIN ; CUSTOM CONSOLE INPUT
KSTAT JMP ZKSTAT ; " " READY TEST
TYPE JMP ZTYPE ; " " OUTPUT
;
;********************************************************************
;
; CONSOLE KEYBOARD INPUT ROUTINE
;
;********************************************************************
;
ZKEYIN EQU $
CALL KSTAT ; TEST CHAR READY
JNC KEYIN ; NOT READY, LOOP
IN CONSD ; READ CONSOLE DATA
ANI 7FH ; STRIP PARITY
CALL TYPE ; ECHO IT TO TERMINAL
RET
;
ZKSTAT EQU $
IN CONST ; READ CONSOLE STATUS PORT
ANI CONSI ; TEST INPUT READY BIT
RZ ; NOPE, RET
STC ; YUP, SET CARRY
RET
;
;********************************************************************
;
; CONSOLE OUTPUT ROUTINE
;
;********************************************************************
;
ZTYPE EQU $
CALL TYPEC ; TYPE CHAR
CPI 0DH ; Q. CARR RTN?
RNZ ; NO, RETURN
MVI A,0AH ; GET LINE FEED
CALL TYPEC ; SEND IT
RET
;
TYPEC EQU $
PUSH PSW ; SAVE CHAR 2B TYPED
TYPEL IN CONST ; READ CONSOLE STATUS
ANI CONSO ; TEST OUTPUT READY BIT
JZ TYPEL ; NOPE, LOOP
POP PSW ; ELSE, GET CHAR
OUT CONSD ; TYPE IT
RET
;
PAGE
;
;*******************************************************************
;
; START - PROGRAM BEGINS; DO INIT
;
;*******************************************************************
;
START EQU $
LXI SP,STAK ; GET STACK ADDR
CALL PMSG1 ; TYPE VERSION MSG
JMP SPARM ; BYPASS CONTINUOUS TEST 1ST TIME
;
;*******************************************************************
;
; MAIN PROGRAM LOOP
;
;********************************************************************
;
LOOP EQU $
CALL KSTAT ; TEST CONSOLE READY
JNC CONTIN ; NO, LOOP TILL INTERRUPTED
IN CONSD ; CLEAR INTERRUPTING DATA
SPARM EQU $
CALL GPARM ; GET ADDRS TO TEST
JC SPARM ; LET'S TRY GETTING THOSE PARMS AGAIN
CALL QUICK ; DO QUICK TEST FOR MEM PRESENT
CONTIN EQU $
CALL RANDS ; SAVE RANDOM SEED
CALL GPATT ; GEN RANDOM PATTERNS IN EACH LOC
CALL KSTAT ; TEST KYBD READY
JC LOOPP ; YES, PRINT MATRIX AND EXIT
CALL RANDR ; RESET RAND TO SEED
CALL TPATT ; TEST PATTERNS
CALL KSTAT ; TEST KYBD READY
JC LOOPP ; YES, PRINT MATRIX AND EXIT
CALL SLOW ; DO SUPER-SLOW MEM TEST
CALL KSTAT ; TEST KYBD READY
JC LOOPP ; YES, PRINT MATRIX AND EXIT
LHLD PASSC ; GET 16-BIT PASS COUNTER
INX H ; PLUS 1
SHLD PASSC ; AND STORE IT BACK
CALL PRTPASS ; PRINT PASS COUNT
JMP LOOPX ; ELSE, GO TO LOOP EXIT
;
LOOPP EQU $
CALL PRMAT ; PRINT ERROR MATRIX
;
LOOPX EQU $
JMP LOOP ; LOOP TILL INTERRUPTED
;
PAGE
;
;********************************************************************
;
; GPARM - GET ADDRESS PARAMETERS
;
;********************************************************************
;
GPARM EQU $
CALL INIT ; INIT ERROR MATRIX
CALL GTSTA ; GET START ADDR
RC ; CARRY=ERROR, SO RETURN
CALL GTEND ; GET END ADDR
RC ; CARRY, PROBLEM
RET
;
;********************************************************************
;
; GPATT - GET RANDOM PATTERN TO ADDRESS SPACE
;
;********************************************************************
;
GPATT EQU $
LHLD AEND ; GET END ADDR TO H-L
XCHG ; SWAP IT TO D-E
LHLD ASTRT ; GET STARTING ADDR TO H-L
GPAT2 EQU $
CALL KSTAT ; TEST KYBD READY
RC ; YUP, EXIT
CALL RANDB ; GET RANDOM BYTE
CALL STNDX ; STORE CHAR, BUMP INDEX
JC GPAT2 ; LT MAX, LOOP
RET
;
;********************************************************************
;
; TPATT - TEST RANDOM PATTERN PREVIOUSLY GENERATED
;
;********************************************************************
;
TPATT EQU $
LHLD AEND ; GET END ADDR TO H-L
XCHG ; SWAP IT TO D-E
LHLD ASTRT ; GET STARTING ADDR
TPAT2 EQU $
CALL RANDB ; GET RANDOM BYTE
MOV B,M ; GET CHAR FROM MEM TO B
CMP B ; TEST EXPECTED TO ACTUAL
JZ TPAT3 ; EQ, ON
CALL TYPEA ; RECORD ADDR AND FAILURE
CALL STMAT ; AND STORE IN ERROR MATRIX
;
TPAT3 EQU $
CALL KSTAT ; TEST KYBD STATUS
RC ; YES, EARLY EXIT
CALL INDEX ; BUMP MEM PTR
JC TPAT2 ; LT MAX, LOOP
RET
;
;********************************************************************
;
; STNDX - STORE BYTE IN MEMORY, BUMP INDEX
;
;********************************************************************
;
STNDX EQU $
MOV M,A ; STORE CHAR IN MEM
JMP INDEX ; BUMP MEM PTR AND EXIT
;
;********************************************************************
;
; INDEX - BUMP H-L, COMPARE TO D-E (ENDING ADDR)
;
;********************************************************************
;
INDEX EQU $
MOV A,H ; GET H/O OF CURR ADDR
CMP D ; TEST TO H/O OF END
JC INXIT ; LT, ONWARD
JNZ INXIT ; NOT ZERO, END
MOV A,L ; TEST L/O
CMP E ; TO L/O OF END
JC INXIT ; LT, ON
;
; H-L = D-E
; RESET ZERO AND CARRY FLAGS
;
MVI A,0 ; GET ZERO
DCR A ; RESET ZERO FLAG
ORA A ; AND CARRY
RET
;
INXIT EQU $
INX H ; BUMP MEM PTR
RET
;
;********************************************************************
;
; STMAT - STORE BIT DIFFERENCES IN ERROR MATRIX
;
;********************************************************************
;
STMAT EQU $
PUSH PSW ; SAVE CHAR
PUSH H ; SAVE H-L
PUSH D ; AND
PUSH B ; REST
MOV B,A ; MOVE BYTE READ TO B
MOV C,M ; MOVE BYTE WRITTEN TO C
MOV A,H ; GET H/O ERROR ADDR
PUSH PSW ; SAVE H/O
LHLD ASTRT ; STARTING TEST ADDR
MOV A,H ; GET H/O TO ACC
ANI 0FCH ; STRIP L/O 2 BITS
MOV H,A ; REPLACE H/O
POP PSW ; RESTORE H/O ERR ADDR
SUB H ; 256-BYTE DIFF
ANI 0FCH ; CLEAR L/O 2 BITS
MVI H,0 ; SETUP H-L
MOV L,A ; TO FORM
DAD H ; K INDEX TO MATRIX
DAD H ; AGAIN
LXI D,MATRX ; MATRIX START
DAD D ; FORM K INDEX
SHLD MINDX ; STORE MATRIX INDEX
LHLD ERRCT ; GET ERROR COUNT
INX H ; PLUS 1
SHLD ERRCT ; AND STORE IT BACK
LXI D,8 ; BIT COUNT TO D
STMA2 EQU $
MOV A,B ; GET BYTE READ
RRC ; SHIFT L/O INTO CARRY
MOV B,A ; RETURN BYTE READ
MOV A,C ; GET BYTE WRITTEN
JC STMC1 ; BIT WAS SET IN READ - SEE IF WRITTEN
RRC ; SHIFT BYTE WRITTEN L/O BIT INTO CARRY
MOV C,A ; RETURN BYTE WRITTEN
JNC STMCO ; NOT CARRY, BIT MATCHES
JMP STMBT ; CARRY, FLAG ERR
STMC1 EQU $
RRC ; SHIFT WRITTEN BIT INTO CARRY
MOV C,A ; RETURN BYTE WRITTEN
JC STMCO ; CARRY, BIT MATCHES
STMBT EQU $
PUSH D ; SAVE ERR CTR
MVI H,0 ; SETUP
MOV L,E ; H-L
DCR L ; TAKE BIT COUNT - 1
DAD H ; * 2
XCHG ; SWAP TO D-E
LHLD MINDX ; MATRIX K INDEX
DAD D ; DISPLACE BIT LOC
MOV E,M ; GET L/O OF ERROR CTR
INX H ; BUMP PTR
MOV D,M ; GET H/O
INX D ; INCR DBL CTR
MOV M,D ; REPLACE H/O
DCX H ; DECR MEM PTR
MOV M,E ; REPLACE L/O
POP D ; RESTORE D-E
;
STMCO EQU $
DCR E ; MINUS BIT COUNTER
JNZ STMA2 ; LOOP TILL ALL BITS TESTED
POP B ; RESTORE
POP D ; ALL
POP H ; REGS
POP PSW ; AND CHAR
RET
;
;********************************************************************
;
; PMSG1 - TYPE VERSION MESSAGE AND INSTRUCTIONS
;
;********************************************************************
;
PMSG1 EQU $
LXI H,MSG1 ; GET VERSION MESSAGE
CALL LINE ; TYPE LINE
RET
;
MSG1 DB 0DH
DB 'WTP&A MNEMONIC - VERSION 2.0',0DH
DB 0DH
DB 'ANY MEMORY FROM 1000H TO FFFFH CAN BE TESTED.',0DH
DB 'TEST WILL RUN CONTINUOUSLY '
DB 'UNTIL A KEY IS STRUCK.',0DH
DB 'TURN ON S.S. 5 TO GET DETAILED ERROR LIST;',0DH
DB ' S.S. 4 TO DO SUPER-SLOW TEST.',0DH
DB 0DH
DB 'WHEN A KEY IS STRUCK, ALL CUMULATIVE ERRORS',0DH
DB ' WILL BE SUMMARIZED BY BIT POSITION',0DH
DB ' WITHIN 1K BOUNDARIES.',0DH
DB 0DH
DB '(ALL INPUTS AND OUTPUTS ARE IN HEX.)',0DH
DB 0DH
DB 00
;
;********************************************************************
;
; PMSGS - PRINT STARTING ADDR REQ MSG
;
;********************************************************************
;
PMSGS EQU $
LXI H,MSGS ; GET START ADDR REQ MSG
CALL LINE ; TYPE LINE
RET
;
MSGS DB 'START ADDR (HEX) ?',0DH,00
;
;********************************************************************
;
; PMSGE - TYPE ENDING ADDR REQ MSG
;
;********************************************************************
;
PMSGE EQU $
LXI H,MSGE ; GET ENDING ADDR REQ MSG
CALL LINE ; TYPE LINE
RET
;
MSGE DB 'END ADDR (HEX) ?',0DH,00
;
;********************************************************************
;
; LINE - TYPE A LINE TERMINATED BY X'00'
;
;********************************************************************
;
LINE EQU $
MOV A,M ; GET CHAR FROM MSG
CPI 00 ; Q. MSG END?
JZ LINEX ; YUP, WRAP UP
CALL TYPE ; ELSE, TYPE CHAR
INX H ; BUMP PTR
JMP LINE ; LOOP TILL MSG END
;
LINEX EQU $
RET
;
;********************************************************************
;
; GTSTA - GET MEMORY STARTING ADDRESS
;
;********************************************************************
;
GTSTA EQU $
CALL PMSGS ; SEND STARTING REQ MSG
CALL RDADR ; READ ADDR FROM CONSOLE
JC GTSTA ; CARRY=ERROR, SO REPROMPT
CALL PACKA ; PACK ADDR INTO ADDRH
LHLD ADDRH ; GET PACKED ADDR
SHLD ASTRT ; SAVE IT IN STARTING ADDR
MOV A,H ; GET H/O OF START ADDR
CPI STAKH ; TEST TO STACK ADDR
RET
;
;********************************************************************
;
; GTEND - GET ENDING ADDRESS
;
;********************************************************************
;
GTEND EQU $
CALL PMSGE ; SEND ENDING REQ MSG
CALL RDADR ; READ ADDR FROM CONSOLE
JC GTEND ; CARRY=ERROR, SO REPROMPT
CALL PACKA ; PACK ADDR INTO ADDRH
LHLD ADDRH ; GET PACKED ADDR
SHLD AEND ; SAVE IT IN ENDING ADDR
XCHG ; SWAP TO D-E
LHLD ASTRT ; GET STARTING ADDR TO H-L
MOV A,D ; GET H/O OF ENDING ADDR
CMP H ; TEST TO H/O OF START
RC ; LT, ERROR
RNZ ; NOT ZERO, GO ON
MOV A,E ; GET L/O OF END
CMP L ; TEST TO L/O OF START
RC ; LT, ERROR
ORA A ; CLEAR CARRY
RET
;
;********************************************************************
;
; RDADR - READ 4-BYTE ADDRESS FROM CONSOLE,
; CONVERT IT TO HEX AND STORE IT.
;
;********************************************************************
;
RDADR EQU $
LXI H,NRAND ; RANDOMLY CREATE NRAND
LXI D,ADDRA ; ADDR TO FILL
MVI B,4 ; CHAR COUNT
;
RDSTA EQU $
CALL KSTAT ; TEST KYBD STATUS
JC RDBYT ; CARRY= CHAR READY
INR M ; ELSE, ADD TO NRAND DIGIT
JMP RDSTA ; LOOP TILL CHAR
;
RDBYT EQU $
CALL KEYIN ; READ CHAR
CALL TESTK ; TEST VALIDITY
JC RDERR ; NG, RESTART
STAX D ; OK, STORE CHAR
INX D ; BUMP ADDRA PTR
INX H ; AND NRAND PTR
DCR B ; MINUS LTH COUNTER
JNZ RDSTA ; LOOP TILL DONE
MVI A,0DH ; CARR RTN
CALL TYPE ; TYPE IT
RET
;
RDERR EQU $
PUSH H ; SAVE H-L (NRAND DIGIT)
LXI H,MSGKE ; GET ERR MSG ADDR
CALL LINE ; TYPE LINE
POP H ; RESTORE H-L
STC ; SHOW ERROR
RET
;
MSGKE DB 0DH,'YOU WANTA TRY THAT AGAIN?',0DH,00
;
;********************************************************************
;
; TESTK - TEST KEYIN CHARACTER.
; IF CTL-C, DO COLD BOOT
;
;********************************************************************
;
TESTK EQU $
CPI 03H ; CTL-C?
JZ EXIT ; YUP, GET OUT
CPI '0' ; NUMERIC
JC TSKNG ; NOPE, ERR
CPI '9'+1 ; REALLY NUMERIC?
JNC TSKAF ; NO, TEST A-F
SUI 30H ; ADJUST TO BINARY
ORA A ; RESET CARRY
RET
;
TSKAF EQU $
CPI 'A' ; TEST "A"
JC TSKNG ; LT, ERR
CPI 'F'+1 ; TEST "F"
JNC TSKNG ; GT F, ERR
SUI 37H ; SUBTRACT 55
ORA A ; RESET CARRY
RET
;
TSKNG EQU $
STC
RET
;
;********************************************************************
;
; PACKA - PACK ADDRESS KEYED-IN
;
;********************************************************************
;
PACKA EQU $
LXI H,ADDRA ; GET PARTIALLY-CONVERTED ADDR
CALL PACKB ; PACK A BYTE
MOV D,A ; PUT IT OVER THERE FOR THE NONCE
CALL PACKB ; PACK 2ND BYTE
MOV E,A ; COMBINE
XCHG ; THEM INTO H-L
SHLD ADDRH ; SAVE THEM IN ADDRH
RET
;
PACKB EQU $
MOV A,M ; GET CHAR FROM INPUT
RLC ; ROTATE
RLC ; IT
RLC ; TO
RLC ; H/O
ANI 0F0H ; CLEAR L/O
MOV B,A ; SAVE IT IN B
INX H ; BUMP MEM PTR
MOV A,M ; GET NEXT CHAR
ORA B ; OR ON H/O FROM B
INX H ; BUMP MEM PTR AGAIN
RET
;
;********************************************************************
;
; RANDS - SAVE RANDOM NUMBER FOR LATER RESTORATION
;
;********************************************************************
;
RANDS EQU $
LXI H,NRAND+3 ; PT TO L/O OF 4-BYTE RANDOM NUMBER
MVI A,01 ; ENSURE
ORA M ; THAT L/O OF NRAND
MOV M,A ; ENDS IN 1
LXI D,NRNDS+3 ; POINT D TO RAND SAVE
JMP RNDS2 ; GO TO COMMON MOVE RTN
;
RANDR EQU $
LXI H,NRNDS+3 ; FROM ADDR = RAND SAVE
LXI D,NRAND+3 ; TO ADDR = RANDOM NUMBER
;
RNDS2 EQU $
MVI B,4 ; COUNT = 4
;
RNDSL EQU $
MOV A,M ; GET CHAR FROM SOURCE
STAX D ; COPY IT TO DEST
DCX D ; DECR
DCX H ; BOTH PTRS
DCR B ; MINUS COUNT
JNZ RNDSL ; LOOP TILL DONE
RET
;
PAGE
;
;********************************************************************
;
; DATA AREAS
;
;********************************************************************
;
NRAND DS 4 ; PSEUDO-RANDOM NUMBER
NRNDS DS 4 ; RAND SAVE AREA
;
MLTPR DW 0A5A5H ; RANDOM MULTIPLIER
;
PRDAD DW 0 ; PARTIAL PRODUCT A*D
PRDBD DW 0 ; " " B*D
PRDBC DW 0 ; " " B*C
;
ADDRA DS 4 ; ADDR INPUT
ADDRH DS 2 ; HEX EQUIV. OF ADDRA
;
ASTRT DS 2 ; HEX STARTING ADDR
AEND DS 2 ; HEX ENDING ADDR
ATEST DS 2 ; HEX TEST ADDR FOR "SLOW"
;
MINDX DW 0 ; K INDEX TO ERROR MATRIX
;
PASSC DW 0 ; PASS COUNTER
ERRCT DW 0 ; ERROR COUNTER
;
DS 2
MATRX DS 1024 ; ERROR MATRIX (64K * 16)
DS 2
;
PAGE
;
;********************************************************************
;
; GENERATE RANDOM BYTE
;
;********************************************************************
;
RANDB EQU $
PUSH D ; SAVE
PUSH H ; REGS
LDA MLTPR+1 ; GET MULTIPLIER L/O
MOV C,A ; SAVE IN C
LDA NRAND+3 ; GET NRAND L/O
MOV B,A ; SAVE IN B
CALL MULT ; GET 16-BIT PRODUCT IN H-L
SHLD PRDBD ; STORE 1ST PARTIAL PRODUCT
LDA MLTPR+1 ; GET MULTIPLIER H/O
MOV C,A ; SAVE IN C
LDA NRAND+2 ; GET NRAND DIG
MOV B,A ; SAVE IN B
CALL MULT ; DO MULTIPLICATION
SHLD PRDBC ; SAVE PARTIAL PRODUCT
LDA MLTPR ; GET MULTIPLIER L/O
MOV C,A ; SAVE IN C
LDA NRAND+3 ; GET NRAND L/O
MOV B,A ; SAVE IN B
CALL MULT ; DO MULTIPLICATION
SHLD PRDAD ; SAVE 3RD PARTIAL PROD
LDA PRDBD ; GET NEW L/O DIGIT
STA NRAND+3 ; UPDATE NRAND L/O
LXI H,0 ; GET CLEAR SUM
MVI B,0 ; CLEAR H/O OF ADDEND
LDA PRDBD+1 ; GET H/O OF PROD BD
MOV C,A ; TO L/O OF ADDEND
DAD B ; ADD INTO SUM
LDA PRDBC ; GET L/O OF PROD BC
MOV C,A ; TO L/O OF ADDEND
DAD B ; ADD INTO SUM
LDA PRDAD ; GET L/O OF PROD AD
MOV C,A ; TO L/O OF ADDEND
DAD B ; ADD INTO SUM
MOV A,L ; GET L/O OF SUM
STA NRAND+2 ; UPDATE NRAND TO NEW VALUE
POP H ; RESTORE
POP D ; REGS
RET
;
;********************************************************************
;
; MULT B * C = PROD IN H-L
;
;********************************************************************
;
MULT EQU $
PUSH D ; SAVE D-E
MOV A,B ; COPY MULTIPLICAND TO A
MVI B,0 ; CLEAR UPPER ADDEND
LXI H,0 ; INIT PRODUCT TO ZERO
MVI D,8 ; MULTIPLIER BIT COUNT
MULT2 EQU $
DAD H ; SHIFT PRODUCT LEFT
RLC ; MULTIPLIER BIT TO CARRY
JNC MULTC ; SKIP IF BIT ZERO
DAD B ; ELSE, ADD MPCND TO PARTIAL PRODUCT
MULTC EQU $
DCR D ; DECR BIT COUNT
JNZ MULT2 ; LOOP TILL DONE
POP D ; RESTORE D-E
RET
;
;********************************************************************
;
; PRMAT - PRINT ERROR BIT MATRIX
;
;********************************************************************
;
PRMAT EQU $
CALL PRTPASS ; PRINT PASS COUNT
LHLD ERRCT ; GET ERROR COUNT
MOV A,H ; GET H/O
ORA A ; Q. 0?
JNZ PRMAH ; NO, GO THRU MATRIX
MOV A,L ; GET L/O
ORA A ; Q. ZERO?
JZ PRMAX ; YES, BYPASS MATRIX SEARCH
PRMAH EQU $
LXI H,MSGBH ; GET BIT ERR MSG HEADER
CALL LINE ; TYPE IT
LHLD ASTRT ; GET STARTING ADDR
MOV A,H ; GET H/O
ANI 0FCH ; MASK OFF L/O 2 BITS
MOV H,A ; AND MOVE IT BACK
XCHG ; MOVE TO D-E
LXI H,MATRX ; POINT TO ERROR MATRIX
MVI B,64 ; COUNT OF K'S TO SEARCH
PRMA3 EQU $
MVI C,8 ; # OF BIT COUNTERS PER K
PUSH H ; SAVE CURRENT K INDEX TO MATRIX
PRMA4 EQU $
MOV A,M ; GET BIT COUNTER
ORA A ; Q. ZERO?
JNZ PRMA5 ; NO, MUST PRINT THIS K
INX H ; ELSE, BUMP TO NEXT BIT CTR
MOV A,M ; GET H/O OF BIT CTR
ORA A ; TEST ZERO
JNZ PRMA5 ; NO, PRINT K
INX H ; YES, BUMP MEM PTR
DCR C ; MINUS BIT COUNTER
JNZ PRMA4 ; NOT DONE TESTING THIS K, LOOP
JMP PRMA7 ; ELSE, TRY NEXT K
PRMA5 EQU $
POP H ; RESTORE STARTING K INDEX
MVI C,8 ; RESTART BIT COUNTER
XCHG ; GET CURR K ADDR
PUSH H ; SAVE IT
MVI L,0 ; PRINT K ADDR ON EVEN BOUNDARY
MVI A,' ' ; BLANK FOR SPACING
CALL TYPE ; TYPE IT
CALL TYPEB ; TYPE IT
LXI H,MSG2B ; 2 BLANKS
CALL LINE ; TYPE THEM
POP H ; RESTORE K ADDR
XCHG ; THEN SWAP BACK
PRMA6 EQU $
PUSH D ; SAVE TARGET ADDR
MOV E,M ; GET 1ST BYTE TO E
INX H ; BUMP MEM PTR
MOV D,M ; GET 2ND BYTE
XCHG ; SWAP TO H-L
CALL TYPEB ; TYPE CTR AS THO ADDR
XCHG ; SWAP BACK
POP D ; RESTORE D-E
INX H ; BUMP MEM PTR
DCR C ; MINUS COUNT
JNZ PRMA6 ; LOOP TILL DONE
MVI A,0DH ; CARR RTN
CALL TYPE ; TYPE IT
JMP PRMA8 ; AND GO TEST NEXT MATRIX LVL
;
PRMA7 EQU $
POP H ; RESTORE H-L
PUSH B ; SAVE COUNTERS
LXI B,16 ; GET OFFSET TO NEXT K
DAD B ; BUMP H-L
POP B ; RESTORE COUNTERS
PRMA8 EQU $
DCR B ; MINUS K COUNTER
JZ PRMAX ; ZERO, DONE
XCHG ; GET START ADDR
PUSH B ; SAVE BIT COUNTERS
LXI B,400H ; GET K BOUNDARY
DAD B ; ADJUST START ADDR
XCHG ; SWAP BACK
POP B ; RESTORE BIT COUNTERS
JMP PRMA3 ; LOOP TILL DONE
;
PRMAX EQU $
RET
;
MSGBH DB 'K ADDR B7 B6 B5 B4'
DB ' B3 B2 B1 B0'
DB 0DH,00
;
;********************************************************************
;
; PRTPASS - PRINT PASS COUNTER AND TOTAL ERRORS
;
;********************************************************************
;
PRTPASS EQU $
LXI H,MSGPC ; GET PASS COUNT MSG ADDR
CALL LINE ; TYPE IT
LHLD PASSC ; GET PASS COUNTER
CALL TYPEB ; TYPE IT
LXI H,MSGER ; ERROR COUNT MESSAGE
CALL LINE ; TYPE LINE
LHLD ERRCT ; GET ERROR COUNTER
CALL TYPEB ; TYPE COUNT OF ERRORS
MVI A,0DH ; CARR RTN
CALL TYPE ; END LINE
RET
;
MSGPC DB 'PASSES COMPLETED = ',00
MSGER DB '; COUNT OF ERROR BYTES = ',00
DB 00
;
;********************************************************************
;
; TYPEH - TYPE A BYTE IN 2-DIGIT HEX
;
;********************************************************************
;
TYPEH EQU $
PUSH B ; SAVE COUNT
MOV B,A ; SAVE CHAR IN B
ANI 0F0H ; STRIP L/O
RRC ; SHIFT
RRC ; TO
RRC ; L/O
RRC ; 4 BITS
CALL TYPHH ; TYPE HEX
MOV A,B ; GET CHAR BACK
ANI 0FH ; NOW STRIP H/O
CALL TYPHH ; TYPE HEX
POP B ; RESTORE COUNT
RET
;
TYPHH EQU $
ADI 90H ; DO
DAA ; HEX TO ASCII
ACI 40H ; ADJUSTMENT
DAA ; TRICK
CALL TYPE ; TYPE ADJUSTED HEX CHAR
RET
;
;********************************************************************
;
; QUICK - DO QUICK TEST OF MEMORY RANGE
; USING X'FF' AND X'00'
;
;********************************************************************
;
QUICK EQU $
MVI C,0FFH ; USE FOXES FIRST
CALL QTEST ; DO QUICK TEST
CALL KSTAT ; TEST KYBD READY
RC ; YES, EXIT
MVI C,00H ; NOW USE ZEROS
CALL QTEST ; DO QUICK TEST AGAIN
RET
;
QTEST EQU $
LHLD AEND ; GET END ADDR TO H-L
XCHG ; SWAP IT TO D-E
LHLD ASTRT ; GET STARTING ADDR
QTES2 EQU $
CALL KSTAT ; TEST KYBD READY
RC ; YES, EXIT
MOV A,C ; GET STORING VALUE
CALL STNDX ; STORE CHAR IN MEM, BUMP INDEX
JC QTES2 ; LT, MORE
LHLD ASTRT ; GET START ADDR AGAIN
QTES3 EQU $
CALL KSTAT ; TEST KYBD READY
RC ; YES, EXIT
MOV A,C ; GET STORED VALUE
MOV B,M ; GET CHAR FROM MEM
CMP B ; TEST EACH DIGIT AGAINST EXPECTED
JZ QTES4 ; EQ, ON
CALL TYPEA ; ELSE, TYPE ERR VALS
CALL STMAT ; STORE BIT ERRORS IN MATRIX
QTES4 EQU $
CALL INDEX ; BUMP INDEX
JC QTES3 ; LT, AGAIN
RET
;
;********************************************************************
;
; SLOW - DO SUPER-SLOW MEM TEST.
; FIRST, MARCH A 1 BIT THRU A FLD OF ZEROS,
; TESTING EACH OTHER BYTE IN THE RANGE FOR
; A CHANGE.
; THEN, MARCH A ZERO BIT THRU A FLD OF ONES,
; TESTING AS ABOVE.
;
;********************************************************************
;
SLOW EQU $
IN 255 ; READ SENSE SWS
ANI SSWS ; TEST SLOW SELECTED
RZ ; NO, EXIT
MVI B,00 ; ZEROS TO MEM FOR 1ST PHASE
CALL SETMEM ; CLEAR ADDR SPACE
MVI C,01 ; BIT REG
SLOW2 EQU $
CALL SLOWT ; DO SLOW TEST
CALL KSTAT ; TEST FOR INTERRUPTION
RC ; YES, GO
MOV A,C ; GET BIT REG
RLC ; SHIFT BIT
JC SLOW3 ; WHEN BIT REACHES CARRY, DONE
MOV C,A ; REPLACE BIT
JMP SLOW2 ; NOT DONE, CONTINUE
SLOW3 EQU $
MVI B,0FFH ; ALL ONES
CALL SETMEM ; TO ADDR SPACE
MVI C,0FEH ; BIT REG TO A L/O ZERO
SLOW4 EQU $
CALL SLOWT ; DO SLOW TEST
CALL KSTAT ; TEST FOR INTERRUPTION
RC ; YES, GO
MOV A,C ; GET BIT REG
RLC ; SHIFT 0 BIT LEFTWARDS
JNC SLOW5 ; WHEN ZERO REACHES CARRY, DONE
MOV C,A ; REPLACE BIT REG
JMP SLOW4 ; NOT DONE, CONTINUE
;
SLOW5 EQU $
MVI B,08 ; COUNT OF BELLS
SLOWB EQU $
MVI A,07H ; BELL CHAR
CALL TYPE ; SOUND IT
CALL KSTAT ; TEST KYBD READY
JC SLOWX ; YES, CLEANUP
LXI H,0 ; LONG WAIT
SLOW6 EQU $
DCR L ;
JNZ SLOW6 ;
DCR H ;
JNZ SLOW6 ;
DCR B ; MINUS BELL COUNT
JNZ SLOWB ; NOT DONE, RING AGAIN
SLOWX EQU $
MVI A,0DH ; CR
CALL TYPE ; TYPE IT
RET
;
SLOWT EQU $
LHLD ASTRT ; GET STARTING ADDR FOR TEST
SHLD ATEST ; STORE IT AT TEST ADDR
SLOWT2 EQU $
LHLD ATEST ; GET TEST ADDR
MOV M,C ; STORE BIT REG AT TEST BYTE
LHLD AEND ; ENDING ADDR TO H-L
XCHG ; SWAP IT TO D-E
LHLD ASTRT ; GET STARTING ADDR
SLOWS2 EQU $
MOV A,M ; GET BYTE FROM MEM
CMP B ; TEST TO EXPECTED
JZ SLOWS5 ; EQ, ON
PUSH B ; SAVE B-C
MOV C,A ; SAVE CHAR READ (ERROR)
XCHG ; CURRENT ADDR TO D-E
LHLD ATEST ; GET TEST ADDR TO H-L
MOV A,H ; GET H/O ADDR OF TEST BYTE
CMP D ; TEST TO D
JNZ SLOWS3 ; NOT EQ, ON
MOV A,L ; GET L/O
CMP E ; TEST L/O OF TEST ADDR
JNZ SLOWS3 ; NOT EQUAL, PRT ERROR
JMP SLOWS4 ; AND BYPASS ERROR PRT
SLOWS3 EQU $
MOV A,B ; SWAP EXPECTED TO ACC
MOV B,C ; INSERT VALUE READ IN ERROR
CALL TYPEA ; TYPE ADDR
CALL STMAT ; STORE IN ERR MATRIX
SLOWS4 EQU $
POP B ; RESTORE B-C
LHLD AEND ; GET ENDING ADDR
XCHG ; CURRENT ADDR BACK TO H-L
SLOWS5 EQU $
INX H ; BUMP MEM PTR
MOV A,H ; GET H/O OF CURR ADDR
CMP D ; TEST TO H/O OF END ADDR
JC SLOWS2 ; LT, CONTINUE
MOV A,L ; GET L/O OF CURR ADDR
CMP E ; TEST TO L/O OF END ADDR
JC SLOWS2 ; LT, ON
SLOWSX EQU $
CALL KSTAT ; TEST FOR INTERRUPTION
RC ; YES, GO
LHLD ATEST ; GET TEST ADDR
MOV M,B ; REPLACE TEST BYTE
INX H ; BUMP TEST ADDR
SHLD ATEST ; AND RESAVE IT
XCHG ; SWAP TEST ADDR TO D-E
LHLD AEND ; GET END ADDR TO H-L
MOV A,D ; GET H/O OF TEST ADDR
CMP H ; TEST TO H/O OF END ADDR
JC SLOWT2 ; LT, ON
JNZ SLOWTX ; NOT EQ, DONE
MOV A,E ; GET L/O OF TEST ADDR
CMP L ; TEST TO L/O OF END ADDR
JC SLOWT2 ; LT, ON
JZ SLOWT2 ; EQ, 1 MORE TIME
SLOWTX EQU $
RET
;
;********************************************************************
;
; SETMEM - SET ADDR SPACE TO VALUE IN B
;
;********************************************************************
;
SETMEM EQU $
LHLD AEND ; GET ENDING ADDR
XCHG ; TO D-E
LHLD ASTRT ; GET STARTING ADDR
SETM2 EQU $
MOV M,B ; FILL MEM BYTE
CALL INDEX ; BUMP PTR
JC SETM2 ; LT, LOOP
RET
;
;********************************************************************
;
; INIT - SETUP MATRIX
;
;********************************************************************
;
INIT EQU $
LXI H,MATRX ; GET ERROR MATRIX ADDR
LXI B,1024 ; GET MATRIX LENGTH
XRA A ; GET ZERO
INIT2 EQU $
MOV M,A ; STORE ZERO IN ERROR MATRIX BYTE
INX H ; BUMP MEM PTR
DCR C ; MINUS L/O OF COUNT
JNZ INIT2 ; INNER LOOP
DCR B ; MINUS COUNT
JNZ INIT2 ; LOOP TILL DONE
LXI H,0 ; ZEROS TO
SHLD PASSC ; PASS COUNTER
SHLD ERRCT ; AND ERROR COUNTER
RET
;
;********************************************************************
;
; TYPEA - TYPE ERROR ADDR, WROTE, READ
;
;********************************************************************
;
TYPEA EQU $
PUSH PSW ; SAVE CHAR 2B TYPED
IN 255 ; READ SENSE SWS
ANI SSWD ; TEST DETAIL LIST SENSE SW
JZ TYPAX ; YES, DON'T DETAIL ERRS
PUSH H ; SAVE ADDR OF ERROR
LHLD ERRCT ; GET ERROR COUNTER
MOV A,H ; GET H/O
ORA A ; Q. ZERO?
JNZ TYPA2 ; NO, ALREADY PRINTED HEADER
MOV A,L ; GET L/O
ORA A ; Q. ZERO?
JNZ TYPA2 ; NO, BYPASS
LXI H,MSGEH ; GET ERROR HEADER MSG
CALL LINE ; TYPE IT
TYPA2 EQU $
POP H ; RESTORE ERROR ADDR
CALL TYPEB ; CONVERT AND TYPE H-L
PUSH H ; SAVE H-L AGAIN
LXI H,MSG2B ; 2 BLANKS
CALL LINE ; TYPE IT
POP H ; RESTORE H-L
POP PSW ; GET CHAR
PUSH PSW ; RESAVE IT
CALL TYPEH ; TYPE IT
PUSH H ; SAVE H-L AGAIN
LXI H,MSG3B ; 3 BLANKS
CALL LINE ; TYPE IT
POP H ; RESTORE H-L
MOV A,B ; GET CHAR READ
CALL TYPEH ; TYPE IT
MVI A,0DH ; CARR RTN
CALL TYPE ; SEND IT
TYPAX EQU $
POP PSW ; RESTORE CHAR
RET
;
MSGEH DB 'ADDR WROTE READ',0DH
DB 00
MSG3B DB ' '
MSG2B DB ' ',00
;
;********************************************************************
;
; TYPEB - TYPE 2-BYTE ADDRESS IN H-L
;
;********************************************************************
;
TYPEB EQU $
MOV A,H ; GET H/O OF ADDR
CALL TYPEH ; TYPE IT
MOV A,L ; GET L/O
CALL TYPEH ; TYPE IT
MVI A,' ' ; BLANK
CALL TYPE ; FOR SEPARATION
RET
;
END