⟦01a78a075⟧

TextFile

$MODULE	MEMORY_TEST
;
; MTST - Byte/Word Memory Test for the Z-8002
;
;  This test writes every pattern into every memory location
;   specified by the memory address range tables, STARTLCT
;   and STOPLCT.
;  The Byte test writes patterns modulo 256 (%00 to %FF),
;  The Word test writes a modulo 64K pattern (%0000 to %FFFF).
;
;  This module must be ZLK'd with CPMINT, and located at %1006
;   for execution with ZLDX (or ZLD and ZEX).
;
;  Version 1.1
;
$title 'Byte/Word Memory Test'

;
; Conditional Assembly Switches
;
FALSE := 0
TRUE := LNOT FALSE

PAGED_MEMORY := FALSE
;
; Utilities in CPMINT
;
	EXTRN	CONSOLE_IN, CONSOLE_STATUS
	EXTRN	CONSOLE_MESSAGE, CONSOLE_HEX_BYTE
	EXTRN	CONSOLE_HEX_WORD, CONSOLE_INPUT

$PSECT	MEM_TST
	ENTRY	ZPROG
ZPROG:
;
; Power-on Entry
;
	LD	R15,#STACK
;
; Get page to test, if paged version
;
	CLR	R1

	IF	PAGED_MEMORY
GET_PAGE:
	LD	R2,#PAGE_MSG
	CALL	CONSOLE_MESSAGE
	CALR	GET_STRING
	CP	R4,#'00'
	JR	EQ,PAGE_SELECTED
	INC	R1
	CP	R4,#'01'
	JR	EQ,PAGE_SELECTED
;
; Bad entry
;
	LD	R2,#BAD_PAGE_MSG
	CALL	CONSOLE_MESSAGE
	JR	GET_PAGE
	ELSE
	JR	PAGE_SELECTED
	ENDIF

GET_STRING:
	LDB	CONSOLE_BUFFER,#' '
	LD	R2,#CONSOLE_BUFFER
	PUSH	@R15,R2
	DEC	R2,#2		; Point to CONSOLE_MAX
	CALL	CONSOLE_INPUT
	POP	R2,@R15
	LDL	RR4,@R2			; Get operator's answer
	CLRB	RH1
	LDB	RL1,R2(#-1)		; Get CONSOLE_CNT to RL1
	LDB	RH0,#'$'		; Terminate string
	LDB	R2(R1),RH0
	LDB	RH0,#'A'
	CPB	RH4,RH0			; Convert lower to upper
	JR	ULT,UC1
	RESB	RH4,#5
UC1:	CPB	RL4,RH0
	JR	ULT,UC2
	RESB	RL4,#5
UC2:	CPB	RH5,RH0
	JR	ULT,UC3
	RESB	RH5,#5
UC3:	CPB	RL5,RH0
	JR	ULT,UC4
	RESB	RL5,#5
UC4:
	RET

PAGE_SELECTED:
	LDB	TEST_PAGE,RL1
	ADD	R1,R1			; * 2
	LD	R8, STARTLCT(R1)	; Get appropriate start address
	LD	STARTLC,R8
	LD	R8, STOPLCT(R1)
	LD	STOPLC,R8		; and stop
;
; Ask operator which test is to be performed
;
GET_TEST:
	LD	R2,#TEST_MSG
	CALL	CONSOLE_MESSAGE
	CALR	GET_STRING
	CPL	RR4,#'BYTE'
	JR	EQ,MEMTSTB
	CPL	RR4,#'WORD'
	JR	EQ,MEMTSTW
	CPL	RR4,#'STAT'
	JR	EQ,STATIC_TEST
;
; Bad entry
;
	LDA	R2,BAD_ENTRY_MSG
	CALL	CONSOLE_MESSAGE
	LD	R2,#CONSOLE_BUFFER
	CALL	CONSOLE_MESSAGE
	LD	R2,#CRLF_MSG
	CALL	CONSOLE_MESSAGE
	JR	GET_TEST

;
; Byte Memory Test
;
MEMTSTB:
	CLR	R0
	CLR	R1
	CLR	R3
OVER:
	LD	R8,STARTLC
	LDB	RH2,RH1
WT:
	IF	PAGED_MEMORY
	LDB	RL7,TEST_PAGE
	CALR	PAGE
	ENDIF

	LDB	@R8,RH2		; Write into memory

	IF	PAGED_MEMORY
	CLRB	RL7
	CALR	PAGE
	ENDIF

	INC	R8		; Point to next location
	INCB	RH2		; Bump pattern value
	JR	NZ,SKIP		; Offset pattern every 256
	INCB	RH2
SKIP:
	CP	R8,STOPLC	; Are we finished ?
	JR	NZ,WT
;
; Pattern has been written
;  Now read the area and check data
;
	LDB	RH2,RH1		; Get initial pattern byte into RH0
	LD	R8,STARTLC	; Start address to R8
RD:
	IF	PAGED_MEMORY
	LDB	RL7,TEST_PAGE
	CALR	PAGE
	ENDIF

	LDB	RH3,@R8		; Read memory byte

	IF	PAGED_MEMORY
	CLRB	RL7
	CALR	PAGE
	ENDIF

	CPB	RH3,RH2		; Is it correct ?
	JR	NE,ERRB
	INC	R8		; Bump memory pointer
	INCB	RH2		; Bump pattern
	JR	NZ,NOINC
	INCB	RH2		; Offset pattern every 256
NOINC:
	CP	R8,STOPLC	; Are we done ?
	JR	ULT,RD
	INCB	RH1
;
; One pass done, report to user by typing message
;
	PUSH	@R15,R1		; Save RH1 (pattern value)
	LD	R2,#PASS_MSG
	CALL	CONSOLE_MESSAGE
	LD	R2,@R15		; Recover RH2
	LDB	RL2,RH2		; Copy to RL2
	CALL	CONSOLE_HEX_BYTE ; Print pass number on console
	LD	R2,#BYTE_PASS_MSG ; Indicate byte testing
	CALL	CONSOLE_MESSAGE
	CALR	CHECK_ABORT
	POP	R1,@R15		; Recover R1
	TESTB	RH1		; Is pattern byte = 0 ?
	JR	NZ,OVER		; Go do the next pass
	JR	MEMTSTW		; Do Word Test
;
; Memory error in byte test
;
ERRB:	LDB	RL6,#TRUE	; RL6 = Byte/Word indicator
	CALR	ERR
	JR	OVER

;
; Static Memory Test
;
STATIC_LOCATION := %5555

STATIC_TEST:
	CLRB	RL0
	LD	R8,#STATIC_LOCATION
ST_WT:	LDB	@R8,RL0
	LDB	RL3,@R8
	CPB	RL0,RL3		; The same as written?
	JR	NE,ST_ERR
ST_NXT:
	INCB	RL0
	JR	NZ,ST_WT
	PUSH	@R15,R0
	CALR	CHECK_ABORT
	POP	R0,@R15
	JR	ST_WT
ST_ERR:
	PUSH	@R15,R0
	LDB	RL6,#TRUE	; Byte indicator on
	CALR	ERR
	POP	R0,@R15
	JR	ST_WT

;
; 16-Bit WORD MEMORY TEST
;
MEMTSTW:
	CLR	R0
	CLR	R1
OVERW:
	LD	R8,STARTLC
	LD	R2,R1
WTW:
	IF	PAGED_MEMORY
	LDB	RL7,TEST_PAGE
	CALR	PAGE
	ENDIF

	LD	@R8,R2

	IF	PAGED_MEMORY
	CLRB	RL7
	CALR	PAGE
	ENDIF

	INC	R8,#2
	INC	R2,#1
	JR	NZ,SKIPW
	INC	R2,#1
SKIPW:
	CP	R8,STOPLC
	JR	NZ,WTW
	LD	R2,R1		; Get initial pattern word
	LD	R8,STARTLC
RDW:
	IF	PAGED_MEMORY
	LDB	RL7,TEST_PAGE
	CALR	PAGE
	ENDIF

	LD	R3,@R8

	IF	PAGED_MEMORY
	CLRB	RL7
	CALR	PAGE
	ENDIF

	CP	R3,R2
	JR	NZ,ERRW
	INC	R8,#2
	INC	R2,#1
	JR	NZ,NOINCW
	INC	R2,#1
NOINCW:
	CP	R8,STOPLC
	JR	NZ,RDW
	INC	R1,#1
;
; One Word Pass Finished
;
	PUSH	@R15,R1		; Save R1 (pattern value)
	LD	R2,#PASS_MSG
	CALL	CONSOLE_MESSAGE
	LD	R2,@R15		; Recover R2
	CALL	CONSOLE_HEX_WORD ; Print pass number on console
	LD	R2,#WORD_PASS_MSG ; Indicate word testing
	CALL	CONSOLE_MESSAGE
	CALR	CHECK_ABORT
	POP	R1,@R15		; Recover R1
	TEST	R1		; Is pattern word = 0 ?
	JR	NZ,OVERW	; Go do the next pass
	JP	MEMTSTB		; Do Byte Test
;
ERRW:	LDB	RL6,#FALSE
	CALR	ERR
	JR	OVERW

;
; Memory Paging Routine
;  Select the 7-bit page given by register RL7
;
PAGE_PORT := %1000

PAGE:
	OUTB	PAGE_PORT,RL7
	RET
;
;  Memory Error Encountered
;
ERR:
	PUSH	@R15,R1		; Save pattern value
	PUSH	@R15,R8		; Address at fault
	PUSH	@R15,R2		; Save good value
	PUSH	@R15,R3		; and bad value
	LD	R2,#ERROR_MSG
	CALL	CONSOLE_MESSAGE

	IF	PAGED_MEMORY
	LDA	R2,SEG_MSG1	; '<<'
	CALL	CONSOLE_MESSAGE
	LDB	RL2,TEST_PAGE
	CALL	CONSOLE_HEX_BYTE
	LDA	R2,SEG_MSG2	; '>>'
	CALL	CONSOLE_MESSAGE
	ENDIF

	LD	R2,R15(#4)	; Memory address at fault
	CALL	CONSOLE_HEX_WORD
	LD	R2,#GOOD_MSG
	CALL	CONSOLE_MESSAGE
	TESTB	RL6		; Byte test?
	JR	Z,WRD_ERR1	; Jump if not
	LD	R4,R15(#2)
	LDB	RL2,RH4
	CALL	CONSOLE_HEX_BYTE
	JR	BAD_DATUM
WRD_ERR1:
	LD	R2,R4		; Good value
	CALL	CONSOLE_HEX_WORD
BAD_DATUM:
	LD	R2,#BAD_MSG
	CALL	CONSOLE_MESSAGE
	TESTB	RL6		; Byte test?
	JR	Z,WRD_ERR2
	LD	R5,@R15
	LDB	RL2,RH5		; Bad value
	CALL	CONSOLE_HEX_BYTE
	JR	ERR_DONE
WRD_ERR2:
	LD	R2,R5		; Bad value
	CALL	CONSOLE_HEX_WORD
ERR_DONE:
	CALR	CHECK_ABORT
	POP	R3,@R15
	POP	R2,@R15
	POP	R8,@R15
	POP	R1,@R15
	RET

;
; Check for a keyboard hit, which terminates the testing
;
CHECK_ABORT:
	CALL	CONSOLE_STATUS		; Key hit?
	BITB	RL0,#0			; Bit 0 = on if so
	RET	Z
	CALL	CONSOLE_IN		; Clear the character
	JP	ZPROG			; Start all over

$DSECT MEM_TST_DATA

STARTLCT:
	DW	%2000		; Start testing here (page 0)
	DW	%C000		; Page 1


STOPLCT	DW	%D000		; Page 0
	DW	%FF00		; To %FEFF

CR := %0D
LF := %0A

PASS_MSG:
	DB	CR,LF,'Memory Test Pass=$'
BYTE_PASS_MSG:
	DB	' (Byte)$'
WORD_PASS_MSG:
	DB	' (Word)$'
ERROR_MSG:
	DB	CR,LF,'Memory Error at $'
GOOD_MSG:
	DB	', Good=$'
BAD_MSG:
	DB	', Bad=$'
SEG_MSG1:
	DB	'<','<','$'
SEG_MSG2:
	DB	'>','>','$'
PAGE_MSG:
	DB	CR,LF,'Enter Page to test (''00'' or ''01''): $'
BAD_PAGE_MSG:
	DB	CR,LF,'Illegal Page Number$'
TEST_MSG:
	DB	CR,LF,'Enter Desired Test (''Static'', ''Byte'' or ''Word''): $'
BAD_ENTRY_MSG:
	DB	'Illegal Entry: $'
CRLF_MSG:
	DB	CR,LF,'$'

	BYTE	TEST_PAGE	; Test Page #
	WORD	STARTLC, STOPLC

$DSECT CONSOLE_BUFFER
CONSOLE_MAX:
	DB	CONSOLE_BUFFER_SIZE
CONSOLE_CNT:
	DS	1
CONSOLE_BUFFER:
	DS	80
CONSOLE_BUFFER_SIZE := . - CONSOLE_BUFFER

$DSECT MEM_TST_STACK

	DS	40	; 20 words of stack space
STACK:

	END
«eof»
DataMuseum.dk

Bogika Butler

⟦01a78a075⟧ TextFile

Derivation

TextFile
