.TITLE	DMADG2


;	FUNCTIONALLY TESTS PI-11B DIRECT MEMORY ACCESS CARD
;	IN CONJUNCTION WITH ID-2000 SERIES IMAGE DISPLAY SYSTEM
;	WITH 1024-BYTE INTENSITY TRANSFORMATION TABLE.

;	TESTS ARE DIVIDED INTO FIVE GROUPS:

;		I. READ/WRITE REGISTER TESTS

;			A. WORD COUNT
;			B. BUS ADDRESS
;			C. COMMAND STATUS

;		II. INTERRUPT FUNCTION TEST

;		III. DMA TRANSFER TESTS (ASCENDING LENGTH BLOCKS)

;			A. ASCENDING BIT PATTERNS
;				1. WORDS
;				2. LOWER BYTES
;				3. UPPER BYTES

;			B. DESCENDING BIT PATTERNS
;				1. WORDS
;				2. LOWER BYTES
;				3. UPPER BYTES

;		IV. SHIFTER TESTS

;			A. INITIAL SHIFT
;			B. MULTIPLE TRANSFERS
;			C. MULTIPLE TRANSFERS WITH SHIFT

;			(CONTINUED ON NEXT PAGE)
	.PAGE
;		V. SPECIFIC BLOCK LENGTH DMA TRANSFER TEST

;			REQUIRES THE DESIRED BLOCK LENGTH AS KEYBOARD INPUT

;	TESTS MAY BE EXECUTED SERIALLY BY SPECIFICATION OF ZERO
;	FOR THE SELECTED TEST OR REPEATEDLY RUN INDIVIDUALLY BY SUPPLYING
;	THE DESIRED TEST NUMBER.

;	A CARRIAGE RETURN WILL TERMINATE EXECUTION OF A REPEATING TEST
;	OR SEQUENCE, THEREBY PERMITTING NEW TEST SELECTION.

;	SELECTION OF A TEST NUMBER > 16(8) CAUSES THE AVAILABLE TESTS TO BE 
;	LISTED ON THE CONSOLE TERMINAL.

;	ALL NEW CODE: 22 SEPTEMBER 77
;	MODIFICATIONS TO: 18 OCTOBER 78

;	PROGRAMMER: KEN DINWIDDIE
	.PAGE
	.SBTTL	EQUATES


;	PDP-11 REGISTER DEFINITIONS:

	R0	=%0
	R1	=%1
	R2	=%2
	R3	=%3
	R4	=%4
	R5	=%5
	R6	=%6
	R7	=%7
	SP	=%6
	PC	=%7


;	CONSOLE TERMINAL REGISTER DEFINITIONS:

	KEYCSR	=177560
	KEYDAT	=177562
	PRCSR	=177564
	PRDAT	=177566

;	ID-2000 SERIES REGISTER DEFINITIONS (DMA SYSTEMS):

	XREG	=166020
	YREG	=166022
	BPMR	=166024
	CSR	=166026
	DREG	=166030

;	DMA REGISTER DEFINITIONS:

	DAWC	=166040		; WORD COUNT
	DABA	=166042		; BUS ADDRESS
	DACS	=166044		; COMMAND/STATUS
	DASC	=166050		; SHIFTER CONTROL
	.PAGE
	.SBTTL	MACRO DEFINITIONS


	.MACRO	CRLF		; ASCII CARRIAGE RETURN / LINE FEED
	.BYTE	15,12
	.ENDM

	.MACRO	CRLFLF		; ASCII CARRIAGE RETURN / TWO LINE FEEDS
	.BYTE	15,12,12
	.ENDM
	.PAGE
	.SBTTL	INTERRUPT VECTOR INITIALIZATION


	.ASECT
	.	=234
	.WORD	VECTOR,340	; INITIALIZE INTERRUPT VECTOR LOCATIONS

	.CSECT
START:	CLR	@#KEYCSR
	CLR	@#PRCSR
	CLR	@#DACS		; SET DMA TO I/O MODE
	CLR	@#DASC		; INITIALIZE FOR NO SHIFTING
.IIF DF TTY	BR	TSTSEL	; BYPASS TEST LIST IF TELETYPE
	.PAGE
	.SBTTL	CONSOLE KEYBOARD TEST SELECTION


LSTINS:	MOV	#TSTDSC,R5
	JSR	R7,SHOTXT	; LIST INSTRUCTIONS FOR DIAGNOSTICS
TSTSEL:	MOV	#62702,NXTPAS	; CONFIRM ADD INSTRUCTION IN DAXWTS
	MOV	@#KEYDAT,R0	; RESET KEYBOARD READY
	MOV	#TSTREQ,R5
	JSR	R7,SHOTXT	; ISSUE TEST REQUEST PROMPT
	CLR	REPEAT		; RESET REPEAT FLAG
	JSR	PC,GETNUM	; GO GET A NUMBER FROM THE KEYBOARD IN R1
	TST	R1		; ZERO ?
	BEQ	WCTEST		; START THROUGHT THE WHOLE SEQUENCE IF SO
	CMP	#16,R1
	BMI	LSTINS		; LIST INSTRUCTIONS IF > 16(8)
	DEC	REPEAT		; SET REPEAT FLAG FOR INDIVIDUAL TEST
	ROL	R1		; CREATE TABLE OFFSET
	BIC	#177741,R1	; DELETE INVALID BITS
	JMP	@TSTTBL(R1)	; GO EXECUTE SELECTED TEST

REPEAT:	.BLKW	1		; FLAG TO REPEAT SPECIFIED TEST

TSTTBL:	.WORD	0,WCTEST,BATEST,CSTEST,INTEST,ASWDTS,ASLBTS,ASUBTS
	.WORD	DSWDTS,DSLBTS,DSUBTS,ISHFTS,MULTST,MSHTST,SBLDTS
	.PAGE
	.SBTTL	REGISTER READ-WRITE TESTS


WCTEST:	MOV	#WCTXT,R5
	JSR	PC,SHOTXT	; IDENTIFY WORD COUNT REGISTER TEST
	MOV	#DAWC,R0	; WORD COUNT REGISTER
	MOV	#-1,R1		; READ/WRITE MASK (ALL BITS)
	JSR	PC,REGTST	; TEST THE WORD COUNT REGISTER
	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	WCTEST		; REPEAT THE TEST IF DESIRED

BATEST:	MOV	#BATXT,R5
	JSR	PC,SHOTXT	; IDENTIFY THE BUS ADDRESS REGISTER TEST
	MOV	#DABA,R0	; BUS ADDRES REGISTER
	MOV	#-2,R1		; READ/WRITE MASK (ALL BITS EXCEPT 0)
	JSR	PC,REGTST	; TEST THE BUS ADDRESS REGISTER
	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	BATEST		; REPEAT THE TEST IF DESIRED

CSTEST:	MOV	#CSTXT,R5
	JSR	PC,SHOTXT	; IDENTIFY THE COMMAND/STATUS REGISTER TEST
	MOV	#DACS,R0	; COMMAND/STATUS REGISTER
	MOV	#566,R1		; READ/WRITE MASK
	JSR	PC,REGTST	; TEST THE COMMAND/STATUS REGISTER
	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	CSTEST		; REPEAT THE TEST IF DESIRED
	.PAGE
	.SBTTL	INTERRUPT FUNCTION TEST


INTEST:	MOV	#INTXT,R5
	JSR	PC,SHOTXT	; IDENTIFY THE INTERRUPT FUNCTION TEST
	CLR	R4		; CLEAR THE ERROR FLAG
	CLR	INTFLG		; CLEAR THE INTERRUPT FLAG
	CLR	@#XREG		; POINT TO START OF ID-2000 BUFFER MEMORY
	MOV	#1,@#DAWC	; SET WORD COUNT = 1
	MOV	#400,@#DACS	; PRIME THE BUS
	MOV	#OUTBUF,@#DABA	; SUPPLY BUFFER ADDRESS
	MOV	#503,@#DACS	; INITIATE DMA WRITE OF ONE WORD
	.REPT	20
	NOP			; ALLOW TIME FOR TRANSFER
	.ENDR
	TST	INTFLG		; INTERRUPT PROCESSED ?
	BNE	INTES2		; CARRY ON IF SO
INTES1:	MOV	#INTERR,R5
	JSR	PC,SHOTXT	; SHOW INTERRUPT ERROR
	INC	R4		; FLAG ERROR
INTES2:	CLR	@#DACS		; RESTORE I/O MODE OPERATION
	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	INTEST		; REPEAT TEST IF DESIRED
	.PAGE
	.SBTTL	DMA TRANSFER TEST - ASCENDING WORDS


ASWDTS:	MOV	#ASWDTX,R5
	JSR	PC,SHOTXT	; IDENTIFY ASCENDING WORDS TEST
	JSR	PC,BLDASW	; GO FILL THE OUTPUT BUFFER
	JSR	PC,DAXWTS	; GO TEST DMA FOR ASCENDING WORDS
	TST	R4		; ERROR ?
	BEQ	ASWDT1		; CARRY ON IF NOT
	MOV	#ASWETX,R5
	JSR	PC,SHOTXT	; IDENTIFY ASCENDING WORDS ERROR
	JSR	PC,WAIT		; GO WAIT FOR KEYSTROKE AFTER ERROR I. D.
ASWDT1:	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	ASWDTS		; REPEAT TEST IF DESIRED
	.PAGE
	.SBTTL	DMA TRANSFER TEST - ASCENDING LOWER BYTES


ASLBTS:	MOV	#ASLBTX,R5
	JSR	PC,SHOTXT	; IDENTIFY ASCENDING LOWER BYTES TEST
	JSR	PC,BLDASW	; FILL OUTPUT BUFFER
	JSR	PC,DAXLBT	; GO TEST DMA FOR ASCENDING LOWER BYTES
	TST	R4		; ERROR ?
	BEQ	ASLBT1		; CARRY ON IF NOT
	MOV	#ASLETX,R5
	JSR	PC,SHOTXT	; IDENTIFY ASCENDING LOWER BYTES ERROR
	JSR	PC,WAIT		; GO WAIT FOR KEYSTROKE AFTER ERROR
ASLBT1:	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	ASLBTS		; REPEAT TEST IF DESIRED
	.PAGE
	.SBTTL	DMA TRANSFER TEST - ASCENDING UPPER BYTES


ASUBTS:	MOV	#ASUBTX,R5
	JSR	PC,SHOTXT	; IDENTIFY ASCENDING UPPER BYTES TEST
	JSR	PC,BLDASW	; FILL OUTPUT BUFFER
	JSR	PC,SWAP		; GO SWAP BYTES THEREIN
	JSR	PC,DAXUBT	; GO TEST DMA FOR ASCENDING UPPER BYTES
	TST	R4		; ERROR ?
	BEQ	ASUBT1		; CARRY ON IF NOT
	MOV	#ASUETX,R5
	JSR	PC,SHOTXT	; IDENTIFY ASCENDING UPPER BYTES ERROR
	JSR	PC,WAIT		; GO WAIT FOR KEYSTROKE AFTER ERROR
ASUBT1:	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	ASUBTS		; REPEAT TEST IF DESIRED
	.PAGE
	.SBTTL	DMA TRANSFER TEST - DESCENDING WORDS


DSWDTS:	MOV	#DSWDTX,R5
	JSR	PC,SHOTXT	; IDENTIFY DESCENDING WORDS TEST
	JSR	PC,BLDDSW	; FILL OUTPUT BUFFER
	JSR	PC,DAXWTS	; GO TEST DMA FOR DESCENDING WORDS
	TST	R4		; ERROR ?
	BEQ	DSWDT1		; CARRY ON IF NOT
	MOV	#DSWETX,R5
	JSR	PC,SHOTXT	; IDENTIFY DESCENDING WORDS ERROR
	JSR	PC,WAIT		; GO WAIT FOR KEYSTROKE AFTER ERROR
DSWDT1:	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	DSWDTS		; REPEAT TEST IF DESIRED
	.PAGE
	.SBTTL	DMA TRANSFER TEST - DESCENDING LOWER BYTES


DSLBTS:	MOV	#DSLBTX,R5
	JSR	PC,SHOTXT	; IDENTIFY DESCENDING LOWER BYTES TEST
	JSR	PC,BLDDSW	; FILL OUTPUT BUFFER WITH DESCENDING PATTERN
	JSR	PC,DAXLBT	; GO TEST DMA LOWER BYTE TRANSFERS
	TST	R4		; ERROR ?
	BEQ	DSLBT1		; CARRY ON IF NOT
	MOV	#DSLETX,R5
	JSR	PC,SHOTXT	; IDENTIFY DESCENDING LOWER BYTES ERROR
	JSR	PC,WAIT		; GO WAIT FOR KEYSTROKE AFTER ERROR
DSLBT1:	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	DSLBTS		; REPEAT TEST IF DESIRED
	.PAGE
	.SBTTL	DMA TRANSFER TEST - DESCENDING UPPER BYTES


DSUBTS:	MOV	#DSUBTX,R5
	JSR	PC,SHOTXT	; IDENTIFY DESCENDING UPPER BYTES TEST
	JSR	PC,BLDDSW	; FILL OUTPUT BUFFER WITH DESCENDING PATTERN
	JSR	PC,SWAP		; GO INTERCHANGE LOW AND HIGH BYTES
	JSR	PC,DAXUBT	; GO TEST DMA UPPER BYTE TRANSFERS
	TST	R4		; ERROR ?
	BEQ	DSUBT1		; CARRY ON IF NOT
	MOV	#DSUETX,R5
	JSR	PC,SHOTXT	; IDENTIFY DESCENDING UPPER BYTES ERROR
	JSR	PC,WAIT		; GO WAIT FOR KEYSTROKE AFTER ERROR
DSUBT1:	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	DSUBTS		; REPEAT TEST IF DESIRED
	.PAGE
	.SBTTL	SHIFTER TEST - INITIAL SHIFT


ISHFTS:	MOV	#ISHFTX,R5
	JSR	PC,SHOTXT	; IDENTIFY INITIAL SHIFT TEST
	JSR	PC,BLDASW	; FILL OUTPUT BUFFER WITH ASCENDING WORDS
	MOV	#OUTBUF,R0
	MOV	#CMPBUF,R1
MOVDAT:	MOV	(R0)+,(R1)+	; MOVE OUTPUT BUFFER TO COMPARISON BUFFER
	CMP	#OUTBUF+1024.,R0
	BNE	MOVDAT
	MOV	#401,R3		; INITIAL SHIFT CODE (START WITH ONE)
ISHFT1:	MOV	#CMPBUF,R0	; POINT TO START OF COMPARISON BUFFER
SOFSHF:	CLC
	ROL	(R0)		; SHIFT LEFT ONE, MS BIT TO CARRY
	BCC	SOFSH1		; LEAVE BIT 0 ZERO IF OLD MS BIT ZERO
	BIS	#1,(R0)		; SET BIT 0 IF OLD MS BIT ONE
SOFSH1:	ADD	#2,R0		; ADVANCE COMPARISON BUFFER POINTER
	CMP	#CMPBUF+1024.,R0
	BNE	SOFSHF		; CONTINUE SOFTWARE SHIFT UNTIL DONE
	MOV	#512.,R2	; SET WORD COUNT
	MOV	R2,RDCNT	; AND SAVE FOR READBACK COUNT
	JSR	PC,DAXSHF	; GO TEST INITIAL SHIFTED DMA TRANSFER
	TST	R4		; ERROR ?
	BEQ	ISHFT2		; CARRY ON IF NONE
	MOV	#ISHETX,R5
	JSR	PC,SHOTXT	; IDENTIFY INITIAL SHIFT ERROR
	JSR	PC,WAIT		; GO WAIT FOR KEYSTROKE ON ERROR
ISHFT2:	INC	R3		; ADVANCE INITIAL SHIFT CODE BY ONE
	CMP	#420,R3		; LAST PASS ?
	BNE	ISHFT1		; CARRY ON IF NOT
	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	ISHFTS		; REPEAT TEST IF DESIRED
	.PAGE
	.SBTTL	SHIFTER TEST - MULTIPLE TRANSFERS


MULTST:	MOV	#MULTXT,R5
	JSR	PC,SHOTXT	; IDENTIFY MULTIPLE TRANSFER TEST
	JSR	PC,BLDASW	; BUILD ASCENDING WORDS IN OUTPUT BUFFER
	MOV	#400,R3		; START WITH ONE TRANSFER
MULCBF:	MOV	#CMPBUF,R2	; POINT TO START OF COMPARISON BUFFER
	MOV	#OUTBUF,R1	; POINT TO START OF OUTPUT BUFFER
MULCB1:	MOV	R3,R0		; INITIALIZE TRANSFER COUNT
MULCB2:	MOV	(R1),(R2)+	; BUILD COMPARISON BUFFER
	CMP	#CMPBUF+1024.,R2
	BEQ	MULTS1		; STOP IF FULL
	SUB	#400,R0		; DECREMENT MULTIPLE TRANSFER COUNT
	BNE	MULCB2		; REPEAT COMPARISON WORD IF REQUIRED
	ADD	#2,R1		; ADVANCE INPUT BUFFER POINTER IF NOT
	BR	MULCB1		; AND CONTINUE BUILDING COMPARISON BUFFER
MULTS1:	MOV	#512.,R1	; COMPARISON BUFFER SIZE
	MOV	R3,R0
	SWAB	R0		; "DIVIDE BY 256"
	MOV	#-1,R2		; INITIALIZE QUOTIENT
MULTS2:	INC	R2
	SUB	R0,R1
	BGT	MULTS2		; DIVIDE BUFFER LENGTH BY TRANSFER COUNT
	CLR	RDCNT		; INITIALIZE PRODUCT
MULTS3:	ADD	R2,RDCNT
	DEC	R0
	BNE	MULTS3		; CALCULATE NUMBER OF WORDS TO READ
	JSR	PC,DAXSHF	; GO TEST MULTIPLE TRANSFERS
	TST	R4		; ERROR ?
	BEQ	MULTS4		; CARRY ON IF NONE
	MOV	#MULETX,R5
	JSR	PC,SHOTXT	; IDENTIFY MULTIPLE TRANSFERS ERROR
	JSR	PC,WAIT		; GO WAIT FOR KEYSTROKE
MULTS4:	ADD	#400,R3		; INCREASE NUMBER OF TRANSFERS PER WORD
	CMP	#10000,R3
	BNE	MULCBF		; TRY MORE TRANSFERS PER WORD THRU 15
	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	MULTST		; GO REPEAT TEST IF DESIRED
	.PAGE
	.SBTTL	SHIFTER TEST - MULTIPLE SHIFTED TRANSFERS


MSHTST:	MOV	#MSHTXT,R5
	JSR	PC,SHOTXT	; IDENTIFY MULTIPLE SHIFTED TRANSFERS TEST
	JSR	PC,BLDASW	; BUILD ASCENDING WORDS IN OUTPUT BUFFER
	MOV	#7420,R3	; START WITH 15 TRANSFERS, 1 SHIFT
MSHCBF:	MOV	#CMPBUF,R2	; POINT TO START OF COMPARISON BUFFER
	MOV	#OUTBUF,R1	; POINT TO START OF OUTPUT BUFFER
MSHCB1:	MOV	R3,R0
	BIC	#377,R0		; STRIP TO NUMBER OF TRANSFERS*256 ONLY
	SWAB	R0		; "DIVIDE BY 256"
	MOV	R0,NXFERS	; SAVE FOR FUTURE REFERENCE
MSHCB2:	MOV	(R1)+,R4	; PICK UP WORD FROM COMPARISON BUFFER
MSHCB3:	MOV	R4,(R2)+	; BUILD COMPARISON BUFFER
	CMP	#CMPBUF+1024.,R2
	BEQ	MSHTS1		; STOP IF FULL
	MOV	#20,R5
	SUB	NXFERS,R5	; NUMBER OF SHIFTS BETWEEN WORDS
SHIFTS:	CLC
	ROL	R4		; SHIFT ONE LEFT, MS BIT TO CARRY
	BCC	SHIFT1		; LEAVE BIT 0 ZERO IF NO CARRY
	BIS	#1,R4		; SET BIT 0 IF CARRY SET
SHIFT1:	DEC	R5		; DECREMENT SHIFT COUNTER
	BNE	SHIFTS		; CONTINUE UNTIL THIS WORD PROPERLY SHIFTED
	DEC	R0		; DECREMENT TRANSFER COUNTER
	BNE	MSHCB3		; AND PROCESS THIS WORD UNTIL DONE
	MOV	NXFERS,R0	; RESTORE TRANSFER COUNT
	BR	MSHCB2		; AND GO GET THE NEXT WORD
MSHTS1:	MOV	NXFERS,R0	; RESTORE THE TRANSFER COUNT
	MOV	#512.,R1	; COMPARISON BUFFER SIZE
	MOV	#-1,R2		; INITIALIZE QUOTIENT
MSHTS2:	INC	R2
	SUB	R0,R1
	BGT	MSHTS2		; DIVIDE BUFFER LENGTH BY TRANSFER COUNT
	CLR	RDCNT		; INITIALIZE PRODUCT
MSHTS3:	ADD	R2,RDCNT
	DEC	R0
	BNE	MSHTS3		; CALCULATE NUMBER OF WORDS TO READ BACK
	JSR	PC,DAXSHF	; GO TEST MULTIPLE SHIFTED TRANSFERS
	TST	R4		; ERROR ?
	BEQ	MSHTS4		; CARRY ON IF NONE
	MOV	#MSHETX,R5
	JSR	PC,SHOTXT	; IDENTIFY MULTIPLE SHIFTED TRANSFER ERROR
	JSR	PC,WAIT		; GO AWAIT KEYSTROKE ON ERROR
MSHTS4:	ADD	#20,R3		; ADVANCE NUMBER OF SHIFTS
	SUB	#400,R3		; REDUCE NUMBER OF TRANSFERS
	CMP	#400,R3		; LAST PASS ?
	BNE	MSHCBF		; CARRY ON IF NOT
	JSR	PC,CHKEY	; GO CHECK FOR TERMINATING KEYSTROKE
	BR	MSHTST		; REPEAT TEST IF DESIRED
	JMP	WCTEST		; RECYCLE THROUGH TESTS

NXFERS:	.BLKW	1		; NUMBER OF TRANSFERS STORAGE LOCATION
	.PAGE
	.SBTTL	SPECIFIC BLOCK LENGTH DMA TRANSFER TEST


SBLDTS:	MOV	#SBLDTX,R5
	JSR	PC,SHOTXT	; IDENTIFY SPECIFIC BLOCK LENGTH TEST
	JSR	PC,GETNUM	; ACQUIRE BLOCK LENGTH FROM KEYBOARD
	TST	R1
	BEQ	SBLDTS		; FORBID BLOCK LENGTH OF ZERO
	CMP	#512.,R1
	BMI	SBLDTS		; OR ONE > 512 WORDS
	MOV	R1,BLNGTH	; SAVE DESIRED BLOCK LENGTH
SBLDT1:	MOV	BLNGTH,R2	; PREPARE FOR DESIRED BLOCK LENGTH
	MOV	#207,NXTPAS	; FORCE RETURN FROM DAXWTS
	JSR	PC,BLDASW	; BUILD ASCENDING WORDS IN OUTPUT BUFFER
	CLR	R3		; PREPARE TO CLEAR SHIFT CONTROL REGISTER
	JSR	PC,DAXWT1	; GO TEST SPECIFIED BLOCK LENGTH TRANSFER
	TST	R4		; ERROR(S) ?
	BEQ	SBLDT2		; CARRY ON IF NOT
	MOV	#ASWETX,R5
	JSR	PC,SHOTXT	; IDENTIFY ASCENDING WORDS ERROR
	JSR	PC,WAIT		; GO WAIT FOR KEYSTROKE ON ERROR
SBLDT2:	MOV	#62702,NXTPAS	; RESTORE ADD INSTRUCTION IN DAXWTS
	JSR	PC,CHKEY	; TERMINATING KEYSTROKE ?
	BR	SBLDT1		; REPEAT TEST IF INDICATED
	JMP	TSTSEL		; ALLOW TEST SELECTION IF NOT

BLNGTH:	.BLKW	1		; BLOCK LENGTH STORAGE LOCATION
	.PAGE
	.SBTTL	SUBROUTINES


BLDASW:	CLR	R0
	MOV	#OUTBUF,R1	; POINT TO START OF OUTPUT BUFFER
BLDAS1:	MOV	R0,(R1)+	; BUILD ASCENDING WORDS IN OUTPUT BUFFER
	INC	R0		; ADVANCE PATTERN
	CMP	#512.,R0
	BNE	BLDAS1		; CONTINUE UNTIL FULL
	RTS	PC

BLDDSW:	MOV	#-1,R0		; START PATTERN WITH ALL BITS SET
	MOV	#OUTBUF,R1	; POINT TO START OF OUTPUT BUFFER
BLDDS1:	MOV	R0,(R1)+	; BUILD DESCENDING WORDS IN OUTPUT BUFFER
	DEC	R0
	CMP	#-513.,R0
	BNE	BLDDS1		; CONTINUE UNTIL FULL
	RTS	PC

CHKEY:	TSTB	@#KEYCSR	; KEYSTROKE ?
	BPL	CHKEY1
	TST	(SP)+		; BUMP STACK POINTER
	JMP	TSTSEL		; ALLOW NEW TEST IF SO
CHKEY1:	TST	REPEAT		; REPEAT FLAG SET ?
	BNE	CHKEY2		; GO REPEAT TEST IF SO
	ADD	#2,(SP)		; POINT TO NEXT TEST IN SEQUENCE
CHKEY2:	RTS	PC

CMPLBS:	MOV	#OUTBUF,R0	; POINT TO START OF OUTPUT BUFFER
CMPLB0:	MOV	#INBUF,R1	; POINT TO START OF INPUT BUFFER
	CLR	R4		; RESET ERROR FLAG
CMPLB1:	CMPB	(R0),(R1)	; COMPARE BUFFERS BYTE-BY-BYTE
	BNE	LBERR		; GO IDENTIFY ERRORS IF ANY
CMPLB2:	ADD	#2,R0
	ADD	#1,R1		; ADVANCE POINTERS
	DEC	R3		; REDUCE WORD COUNT
	BNE	CMPLB1		; CARRY ON IF INDICATED
	RTS	PC
LBERR:	JSR	PC,SHOBER	; IDENTIFY ERROR
	INC	R4		; ADVANCE ERROR COUNT
	BR	CMPLB2		; AND PROCEED WITH TEST

CMPUBS:	MOV	#OUTBUF+1,R0	; POINT TO FIRST UPPER BYTE OF OUTPUT BUFFER
	BR	CMPLB0

CMPWDS:	MOV	#INBUF,R1	; POINT TO START OF INPUT BUFFER
	CLR	R4		; RESET ERROR FLAG
CMPWD1:	CMP	(R0)+,(R1)+	; COMPARE BUFFER CONTENTS
	BNE	WDERR		; GO IDENTIFY ERROR IF ANY
CMPWD2:	DEC	R3		; DECREMENT WORD COUNT
	BNE	CMPWD1		; CARRY ON UNTIL DONE
	RTS	PC
WDERR:	TST	-(R0)
	TST	-(R1)		; POINT TO ERRONEOUS WORD PAIR
	JSR	PC,SHOERR	; IDENTIFY ERROR
	TST	(R0)+
	TST	(R1)+		; RESTORE DATA POINTERS
	INC	R4		; ADVANCE ERROR COUNT
	BR	CMPWD2		; AND PROCEED WITH TEST

DAXLBT:	MOV	#1,R2		; INITIALIZE FOR ONE WORD TRANSFER
DAXLB1:	MOV	#515,R1		; SET UP TO DMA WRITE LOWER BYTES
	MOV	#OUTBUF,R0	; POINT TO OUTPUT BUFFER
	JSR	PC,DMAXFR	; PERFORM DMA LOWER BYTES WRITE
	MOV	R2,R3
	JSR	PC,GETWDS	; GO I/O READ LOWER BYTES
	MOV	R2,R3
	JSR	PC,CMPLBS	; GO COMPARE THE READ VS. WRITTEN DATA
	TST	R4		; ERROR ?
	BEQ	DAXLB2		; CARRY ON IF NONE
	MOV	#CRLLS,R5
	JSR	PC,SHOTXT	; CR, 2 LF'S & INDENT 10 SPACES
	JSR	PC,SHONUM	; GO SHOW NUMBER OF ERRORS
	MOV	#DAWLER,R5
	JSR	PC,SHOTXT	; IDENTIFY LOWER BYTE ERROR(S)
DAXLB2:	ADD	#11,R2		; ADVANCE TRANSFER COUNT BY 9
	CMP	#1002,R2
	BNE	DAXLB1		; CONTINUE UNTIL LAST PASS
	RTS	PC

DAXSHF:	MOV	R3,-(SP)	; SAVE R3 ON THE STACK
	MOV	#507,R1		; SET UP FOR SHIFTED DMA TRANSFERS
	MOV	#OUTBUF,R0	; POINT TO OUTPUT BUFFER
	JSR	PC,DMAXFR	; PERFORM SHIFTED DMA WRITE
	MOV	RDCNT,R3
	JSR	PC,GETWDS	; I/O READ THE DATA
	MOV	RDCNT,R3
	MOV	#CMPBUF,R0
	JSR	PC,CMPWDS	; COMPARE THE READ VS. WRITTEN DATA
	TST	R4		; ERROR ?
	BEQ	DAXSH1		; CARRY ON IF NONE
	MOV	#CRLLS,R5
	JSR	PC,SHOTXT	; CR, 2 LF'S & INDENT 10 SPACES
	JSR	PC,SHONUM	; IDENTIFY NUMBER OF ERRORS
	MOV	#DAXSER,R5
	JSR	PC,SHOTXT	; IDENTIFY SHIFTED DMA ERROR
	JSR	PC,WAIT		; WAIT FOR KEYSTROKE AFTER ERROR
DAXSH1:	MOV	(SP)+,R3	; RESTORE R3
	RTS	PC

RDCNT:	.BLKW	1		; STORAGE LOCATION FOR READBACK COUNTER

DAXUBT:	MOV	#1,R2		; INITIALIZE FOR ONE WORD TRANSFER
DAXUB1:	MOV	#513,R1		; SET FOR DMA WRITE UPPER BYTES
	MOV	#OUTBUF,R0	; POINT TO OUTPUT BUFFER
	JSR	PC,DMAXFR	; GO PERFORM DMA UPPER BYTES WRITE
	MOV	R2,R3
	JSR	PC,GETWDS	; I/O READ THE WRITTEN DATA
	MOV	R2,R3
	JSR	PC,CMPUBS	; GO COMPARE THE READ VS. WRITTEN DATA
	TST	R4		; ERROR ?
	BEQ	DAXUB2		; CARRY ON IF NONE
	MOV	#CRLLS,R5
	JSR	PC,SHOTXT	; CR, 2 LF'S & INDENT 10 SPACES
	JSR	PC,SHONUM	; IDENTIFY NUMBER OF ERRORS
	MOV	#DAWUER,R5
	JSR	PC,SHOTXT	; IDENTIFY UPPER BYTE WRITE ERROR
DAXUB2:	ADD	#11,R2		; ADVANCE TRANSFER COUNT BY 9
	CMP	#1002,R2
	BNE	DAXUB1		; CARRY ON UNTIL FULL BUFFER USED
	RTS	PC

DAXWTS:	CLR	R3		; CLEAR SHIFT CONTROL
	MOV	#1,R2		; INITIALIZE WORD COUNT FOR ONE WORD
DAXWT1:	MOV	#503,R1		; SET UP FOR DMA WRITE
	MOV	#OUTBUF,R0	; POINT TO OUTPUT BUFFER
	JSR	PC,DMAXFR	; PERFORM DMA WRITE TO ID-2000 ITT
	MOV	R2,R3
	JSR	PC,GETWDS	; I/O READ THE ITT
	MOV	R2,R3
	MOV	#OUTBUF,R0	; POINT TO OUPUT BUFFER
	JSR	PC,CMPWDS	; COMPARE THE DMA TRANSFER WITH SOURCE
	TST	R4		; ERROR ?
	BEQ	DARDWT		; PROCEED IF OK
	MOV	#CRLLS,R5
	JSR	PC,SHOTXT	; CR, 2 LF'S & INDENT 10 SPACES
	JSR	PC,SHONUM	; GO SHOW NUMBER OF ERRORS
	MOV	#DAWWER,R5
	JSR	PC,SHOTXT	; IDENTIFY DMA WORD WRITE ERROR
	JSR	PC,WAIT		; GO WAIT FOR KEYSTROKE AFTER ERROR
DARDWT:	MOV	#10000,@#XREG	; POINT TO START OF ITT
	MOV	#OUTBUF,R0	; AND TO START OF INPUT BUFFER
	CLR	R1		; ZERO TRANSFER COUNT
SOFWRT:	MOV	(R0)+,@#DREG	; WRITE PATTERN TO ITT
	INC	R1		; BUMP TRANSFER COUNTER
	CMP	R1,R2
	BNE	SOFWRT		; AND CONTINUE UNTIL DESIRED WORDS WRITTEN
	MOV	#505,R1		; SET UP FOR DMA READ
	MOV	#INBUF,R0	; POINT TO INPUT BUFFER
	JSR	PC,DMAXFR	; DMA READ THE DATA
	MOV	R2,R3
	MOV	#OUTBUF,R0	; POINT TO THE OUTPUT BUFFER
	JSR	PC,CMPWDS	; COMPARE DMA READ WITH SOURCE
	TST	R4		; ERROR ?
	BEQ	NXTPAS		; PROCEED IF NONE
	MOV	#CRLLS,R5
	JSR	PC,SHOTXT	; CR, 2 LF'S & INDENT 10 SPACES
	JSR	PC,SHONUM	; SHOW NUMBER OF ERRORS
	MOV	#DARDER,R5
	JSR	PC,SHOTXT	; IDENTIFY DMA READ ERROR
	JSR	PC,WAIT		; GO WAIT FOR KEYSTROKE AFTER ERROR
NXTPAS:	ADD	#11,R2		; ADVANCE WORD COUNT BY 9

;	!!! INSTRUCTION ABOVE MODIFIED TO RTS	PC BY SBLDTS !!!

	CMP	#1002,R2	; LAST PASS ?
	BNE	DAXWT1		; CARRY ON IF NOT
	RTS	PC

DMAXFR:	MOV	#10000,@#XREG	; POINT TO ITT START
	MOV	R0,@#DABA	; LOAD BUS ADDRESS REGISTER
	MOV	R2,@#DAWC	; LOAD WORD COUNT REGISTER
	MOV	R3,@#DASC	; LOAD SHIFT CONTROL REGISTER
	MOV	#400,@#DACS	; PRIME THE BUS
	CLR	INTFLG		; INITIALIZE THE INTERRUPT FLAG
	MOV	R1,@#DACS	; INITIATE THE DMA TRANSFER
PAUSE:	TST	INTFLG
	BEQ	PAUSE		; AWAIT THE INTERRUPT
	CLR	@#DACS		; RESTORE I/O MODE
	RTS	PC
 
GETNUM:	CLR	R1		; INITIALIZE NUMBER SYNTHESIS REGISTER
GETCHR:	JSR	R7,TTYIN	; GET A CHARACTER (0-7 OR CR)
	BCS	DOIT		; GO RETURN IF CR
	CLC
	.REPT	3
	ROL	R1		; ROTATE ONE OCTAL DIGIT
	.ENDR
	BIC	#177770,R0	; STRIP TO LS 3 BITS
	BIS	R0,R1		; OR WITH PREVIOUS DIGIT
	BR	GETCHR		; AND GO FOR THE NEXT DIGIT
DOIT:	RTS	PC

GETWDS: MOV	#INBUF, R0	; POINT TO START OF INPUT BUFFER
	MOV	#10000,@#XREG	; POINT TO START OF ITT
GETWD1:	MOV	@#DREG,(R0)+	; FILL INPUT BUFFER
	DEC	R3
	BNE	GETWD1
	RTS	PC

PREADY:	BIT	#200,@#PRCSR
	BEQ	PREADY		; AWAIT CONSOLE OUTPUT READY
	RTS	PC

REGTST:	MOV	#1,R2		; SET BIT 0 ONLY
	COM	R1		; COMPLEMENT MASK
	MOV	R2,R3		; SAVE TEST BIT
REGTS1:	BIC	R1,R2		; TEST THIS BIT?
	BEQ	REGTS2		; SKIP TEST IF NOT
	MOV	R2,(R0)		; WRITE BIT TO REGISTER
	MOV	(R0),R4		; READ REGISTER
	BIC	R1,R4		; MASK OFF UNWANTED BITS
	CMP	R2,R4
	BNE	MOVBER		; GO SHOW MOVING BIT ERROR
REGTS2:	CLC
	ROL	R3		; ADVANCE TEST BIT
	MOV	R3,R2		; PREPARE FOR NEXT TEST
	BCC	REGTS1		; AND PERFORM IT IF INDICATED
	MOV	#-2,R2		; SET ALL BITS EXCEPT 0
	MOV	R2,R3		; SAVE TEST PATTERN
REGTS3:	BIC	R1,R2		; MASK COMPARISON PATTERN
	MOV	R2,(R0)		; WRITE PATTERN TO REGISTER
	MOV	(R0),R4		; READ REGISTER
	BIC	R1,R4		; MASK READ DATA
	CMP	R2,R4
	BNE	MOVZER		; GO SHOW MOVING ZERO ERROR
REGTS4:	SEC
	ROL	R3		; ADVANCE TEST ZERO
	MOV	R3,R2		; PREPARE FOR NEXT TEST
	BCS	REGTS3		; AND PERFORM IF INDICATED
	CMP	#DACS,R0	; CONTROL/STATUS ?
	BEQ	REGTS9		; SKIP ASCENDING/DESCENDING PATTERNS IF SO
	CLR	R3		; INITIALIZE TEST WORD
REGTS5:	MOV	R3,(R0)		; WRITE TO REGISTER
	MOV	(R0),R4		; READ FROM REGISTER
	BIC	R1,R4		; MASK SUPERFLUOUS BITS READ
	MOV	R3,R2
	BIC	R1,R2		; MASK SUPERFLUOUS COMPARISON BITS
	CMP	R2,R4
	BNE	ASRGER		; GO SHOW ERROR IF ANY
REGTS6:	INC	R3		; ADVANCE PATTERN
	BNE	REGTS5		; AND PROCEED FOR ALL PERMUTATIONS
	DEC	R3		; ALL BITS SET
REGTS7:	MOV	R3,(R0)		; WRITE TO REGISTER
	MOV	(R0),R4		; READ FROM REGISTER
	BIC	R1,R4		; MASK SUPERFLUOUS BITS READ
	MOV	R3,R2
	BIC	R1,R2		; MASK SUPERFLUOUS COMPARISON BITS
	CMP	R2,R4
	BNE	DSRGER		; GO SHOW ERROR IF ANY
REGTS8:	DEC	R3		; REDUCE PATTERN
	BNE	REGTS7		; AND PROCEED FOR ALL PERMUTATIONS
REGTS9:	RTS	PC

MOVBER:	MOV	#MVBETX,R5
	JSR	PC,SHOTXT	; IDENTIFY MOVING BIT ERROR
	MOV	#REGTS2,-(SP)	; SAVE RETURN ADDRESS
	BR	REGERR		; GO DEFINE ERROR
MOVZER:	MOV	#MVZETX,R5
	JSR	PC,SHOTXT	; IDENTIFY MOVING ZERO ERROR
	MOV	#REGTS4,-(SP)	; SAVE RETURN ADDRESS
	BR	REGERR		; GO DEFINE ERROR
ASRGER:	MOV	#ASRGTX,R5
	JSR	PC,SHOTXT	; IDENTIFY ASCENDING ERROR
	MOV	#REGTS6,-(SP)	; SAVE RETURN ADDRESS
	BR	REGERR		; GO DEFINE ERROR
DSRGER:	MOV	#DSRGTX,R5
	JSR	PC,SHOTXT	; IDENTIFY DESCENDING ERROR
	MOV	#REGTS8,-(SP)	; SAVE RETURN ADDRESS
REGERR:	JSR	PC,SHONUM	; SHOW READ VALUE
	MOV	#SHBETX,R5
	JSR	PC,SHOTXT	; SHOW "SHOULD BE"
	MOV	R2,R4
	JSR	PC,SHONUM	; SHOW PROPER VALUE
	RTS	PC		; GO RESUME TESTING

SHOBER:	MOV	R4,-(SP)	; SAVE R4
	MOV	#ELEMTX,R5
	JSR	PC,SHOTXT	; SHOW "ELEMENT"
	MOV	R0,R4
	BIC	#1,R4		; GUARANTEE IT EVEN
	SUB	#OUTBUF,R4
	JSR	PC,SHONUM	; SHOW ELEMENT NUMBER
	MOV	#ISTEXT,R5
	JSR	PC,SHOTXT	; SHOW "IS"
	MOVB	(R1),R4
	SWAB	R4
	MOV	#3,CHRCNT
	CLC
	JSR	PC,SHONU2	; SHOW READ VALUE
	MOV	#SHBETX,R5
	JSR	PC,SHOTXT	; SHOW "SHOULD BE"
	MOVB	(R0),R4
	SWAB	R4
	MOV	#3,CHRCNT
	CLC
	JSR	PC,SHONU2	; SHOW CORRECT VALUE
	MOV	(SP)+,R4	; RESTORE R4
	RTS	PC

SHOERR:	MOV	R4,-(SP)	; SAVE R4
	MOV	#ELEMTX,R5
	JSR	PC,SHOTXT	; SHOW "ELEMENT"
	MOV	R0,R4
	SUB	#OUTBUF,R4
	JSR	PC,SHONUM	; SHOW ELEMENT NUMBER
	MOV	#ISTEXT,R5
	JSR	PC,SHOTXT	; SHOW "IS"
	MOV	(R1),R4
	JSR	PC,SHONUM	; SHOW READ VALUE
	MOV	#SHBETX,R5
	JSR	PC,SHOTXT	; SHOW "SHOULD BE"
	MOV	(R0),R4
	JSR	PC,SHONUM	; SHOW PROPER VALUE
	MOV	(SP)+,R4	; RESTORE R4
	RTS	PC

SHONUM:	MOV	#60,R5		; ASCII ZERO
	TST	R4		; BIT 15 SET?
	BPL	SHONU1		; SKIP INCREMENTATION IF NOT
	INC	R5		; MAKE IT ASCII ONE
SHONU1:	JSR	PC,PREADY	; WAIT FOR CONSOLE OUTPUT READ
	MOV	R5,@#PRDAT	; SHOW ONE OR ZERO
	ROL	R4
	ROL	R4		; BIT 15 THRU CARRY TO BIT 0
	MOV	#5,CHRCNT	; INITIALIZE CHARACTER COUNT
SHONU2:	ROL	R4
	ROL	R4
	ROL	R4		; MS OCTAL DIGIT TO BITS 2-0
	MOV	R4,R5
	BIC	#177770,R5	; MASK OFF ALL BUT BITS 2-0
	BIS	#60,R5		; MAKE ASCII 0-7
	JSR	PC,PREADY
	MOV	R5,@#PRDAT	; SHOW DIGIT
	DEC	CHRCNT
	BNE	SHONU2
	TSTB	@#KEYCSR	; KEYSTROKE ?
	BPL	SHONU3		; NO, CARRY ON
	TST	(SP)+		; YES, BUMP STACK POINTER
	JMP	TSTSEL		; AND ALLOW NEW TEST SELECTION
SHONU3:	RTS	PC

CHRCNT:	.BLKW	1		; CHARACTER COUNTER

;	SUBROUTINE TO DISPLAY TEXT ON A/N TERMINAL CONSOLE


SHOTXT:	MOV	R0,-(SP)	; SAVE R0
SHOTX1:	MOVB	(R5)+,R0	; PICK UP CHARACTER
	BEQ	SHOTX2
	JSR	R7,TTYOUT	; TRANSFER NON-ZERO BYTE TO CONSOLE TERMINAL
	BR	SHOTX1
SHOTX2:	MOV	(SP)+,R0	; RESTORE R0
	RTS	R7		; RETURN ON ALL-ZERO BYTE

;	SUBROUTINE TO SWAP BYTES IN OUTPUT BUFFER


SWAP:	MOV	#OUTBUF,R0	; POINT TO START OF OUTPUT BUFFER
SWAP1:	SWAB	(R0)+		; PUT PATTERN IN UPPER BYTE
	CMP	#OUTBUF+1024.,R0
	BNE	SWAP1
	RTS	PC

;	SUBROUTINE TO FETCH VALID OCTAL DIGITS & CARRIAGE RETURN


TTYIN:	TSTB	@#KEYCSR
	BPL	TTYIN		; WAIT FOR KEYSTROKE
	MOV	@#KEYDAT,R0	; PICK UP CHARACTER
	BIC	#200,R0		; STRIP PARITY BIT
	CMP	#3,R0		; CONTROL C ?
	BEQ	QUIT		; GO EXIT IF SO
	CMP	#15,R0		; CARRIAGE RETURN ?
	BEQ	CRFND		; TERMINATE IF SO
	CMP	#57,R0
	BPL	TTYIN		; IGNORE IF < 60
	CMP	#67,R0
	BMI	TTYIN		; LIKEWISE IF > 67
TTYOUT:	JSR	R7,PREADY	; WAIT FOR OUTPUT READY
	MOV	R0,@#PRDAT	; ECHO CHARACTER
	JSR	R7,PREADY
	CLC			; SHOW VALID DIGIT
	RTS	R7

CRFND:	JSR	R7,PREADY
	MOV	R0,@#PRDAT
	JSR	R7,PREADY
	MOV	#12,@#PRDAT	; LINE FEED FOR FREE
	JSR	R7,PREADY
	SEC		; FLAG TERMINATOR
	RTS	R7

QUIT:	EMT	350		; RETURN TO RT-11 MONITOR

WAIT:	TST	REPEAT		; REPEAT FLAG SET?
	BEQ	WAIT1		; GO AWAIT KEYSTROKE IF NOT
	RTS	PC		; RETURN IMMEDIATELY IF SO
WAIT1:	CLR	@#KEYCSR	; INITIALIZE KEYBOARD
WAIT2:	TSTB	@#KEYCSR
	BPL	WAIT2		; AWAIT KEYSTROKE
	RTS	PC

VECTOR:	INC	INTFLG		; FLAG INTERRUPT
	RTI

INTFLG:	.BLKW	1		; INTERRUPT FLAG
	.PAGE
	.SBTTL	ASCII STRINGS

	.NLIST	BIN		; DON'T BOTHER WITH EXPANSIONS
TSTDSC:	CRLFLF
	.ASCII	/ * * * ID-2000 DMA DIAGNOSTIC * * * /
	CRLFLF
	.ASCII	/ TESTS AVAILABLE:/
	CRLFLF
	.ASCII	/ 1 = WORD COUNT REGISTER /
	CRLF
	.ASCII	/ 2 = BUS ADDRESS REGISTER /
	CRLF
	.ASCII	/ 3 = COMMAND - STATUS REGISTER /
	CRLF
	.ASCII 	/ 4 = INTERRUPT FUNCTION /
	CRLF
	.ASCII	/ 5 = DMA TRANSFER - ASCENDING WORDS /
	CRLF
	.ASCII	/ 6 = DMA TRANSFER - ASCENDING LOWER BYTES /
	CRLF
	.ASCII	/ 7 = DMA TRANSFER - ASCENDING UPPER BYTES /
	CRLF
	.ASCII	/10 = DMA TRANSFER - DESCENDING WORDS /
	CRLF
	.ASCII	/11 = DMA TRANSFER - DESCENDING LOWER BYTES /
	CRLF
	.ASCII	/12 = DMA TRANSFER - DESCENDING UPPER BYTES /
	CRLF
	.ASCII	/13 = INITIAL SHIFT /
	CRLF
	.ASCII	/14 = MULTIPLE TRANSFERS /
	CRLF
	.ASCII	/15 = MULTIPLE SHIFTED TRANSFERS/
	CRLF
	.ASCII	/16 = SPECIFIC BLOCK LENGTH DMA TRANSFER/
	CRLFLF
	.ASCII	/ 0 => EXECUTE ALL TESTS SEQUENTIALLY, /
	.ASCIZ	/>15 => LIST AVAILABLE TESTS./

TSTREQ:	CRLFLF
	.ASCIZ	/TEST #: /

CRLLS:	CRLFLF
	.ASCIZ	/          /

WCTXT:	CRLF
	.ASCIZ	/ WORD COUNT REGISTER TEST /

BATXT:	CRLF
	.ASCIZ	/ BUS ADDRESS REGISTER TEST /

CSTXT:	CRLF
	.ASCIZ	/COMMAND - STATUS REGISTER TEST /

INTXT:	CRLF
	.ASCIZ	/INTERRUPT FUNCTION TEST /

INTERR:	CRLFLF
	.ASCIZ	/ NO INTERRUPT AFTER 16 NO-OPS./

ASWDTX:	CRLF
	.ASCIZ	/ ASCENDING WORDS TEST /

ASWETX:	.ASCIZ	/ ^ WORDS. /

ASLBTX:	CRLF
	.ASCIZ	/ ASCENDING LOWER BYTES TEST /

ASLETX:	.ASCIZ	/ ^ LOWER BYTES./

ASUBTX:	CRLF
	.ASCIZ	/ ASCENDING UPPER BYTES TEST /

ASUETX:	.ASCIZ	/ ^ UPPER BYTES. /

DSWDTX:	CRLF
	.ASCIZ	/ DESCENDING WORDS TEST /

DSWETX:	.ASCIZ	/ V WORDS. /

DSLBTX:	CRLF
	.ASCIZ	/ DESCENDING LOWER BYTES TEST /

DSLETX:	.ASCIZ	/ V LOWER BYTES. /

DSUBTX:	CRLF
	.ASCIZ	/ DESCENDING UPPER BYTES TEST /

DSUETX:	.ASCIZ	/ V UPPER BYTES. /

ISHFTX:	CRLF
	.ASCIZ	/ INITIAL SHIFT TEST /

ISHETX:	.ASCIZ	/ INITIAL SHIFT. /

MULTXT:	CRLF
	.ASCIZ	/ MULTIPLE TRANSFERS TEST /

SBLDTX:	CRLF
	.ASCII	/ SPECIFIC BLOCK LENGTH DMA TRANSFER TEST/
	CRLFLF
	.ASCIZ	/     SUPPLY BLOCK LENGTH (WORDS): /

MULETX:	.ASCIZ	/ MULTIPLE TRANSFERS. /

MSHTXT:	CRLF
	.ASCIZ	/ MULTIPLE SHIFTED TRANSFERS TEST /

MSHETX:	.ASCIZ	/ MULTIPLE SHIFTS. /

DAWWER:	.ASCIZ	/ DMA WORD WRITE ERRORS. /

DARDER:	.ASCIZ	/ DMA WORD READ ERRORS. /

DAWLER:	.ASCIZ	/ DMA LOWER BYTE WRITE ERRORS. /

DAWUER:	.ASCIZ	/ DMA UPPER BYTE WRITE ERRORS. /

DAXSER:	.ASCIZ	/ DMA SHIFTED WRITE ERRORS. /

MVBETX:	CRLF
	.ASCIZ	/ MOVING BIT ERROR - /

MVZETX:	CRLF
	.ASCIZ	/ MOVING ZERO ERROR - /

ASRGTX:	CRLF
	.ASCIZ	/ ASCENDING PATTERN ERROR - /

DSRGTX:	CRLF
	.ASCIZ	/ DESCENDING PATTERN ERROR - /

SHBETX:	.ASCIZ	/ SHOULD BE /

ELEMTX:	CRLF
	.ASCIZ	/ ELEMENT /

ISTEXT:	.ASCIZ	/ IS /
	.LIST	BIN
	.PAGE
	.SBTTL	DATA BUFFERS


	.EVEN
OUTBUF:	.BLKW	512.		; DMA OUTPUT BUFFER 
INBUF:	.BLKW	512.		; DMA INPUT BUFFER

CMPBUF:	.BLKW	512.		; SHIFTED DMA COMPARISON BUFFER
	.END	START