title	floppy drive test	3/15/82

on	equ	0ffffh		;define on
off	equ	not on		;and off

stop	equ	off		;condition on yields RST 7 on error

	if	stop		;examines condition
trap	equ	0ffh		;Restart 7 op code
	endif
	if	not stop	;otherwise
trap	equ	0		;NOP code
	endif

channl	equ	50h		;Start channel address
vector	equ	channl+1	;branch address
startr	equ	0efh		;port address to start the controller
setma	equ	23h		;Command to set DMA address
rdsec	equ	20h		;Command to read a sector
wrsec	equ	21h		;Command to write a sector
snsta	equ	22h		;Command to sense drive status
strtry	equ	28h		;Command to set error retry count
stlgcl	equ	2eh		;Command to set logical drive
sttime	equ	2fh		;Command to set head unload/
				;	drive deselect timeout
rdtrk	equ	29h		;Command to read a track
wrtrk	equ	2ah		;Command to write a track
conhlt	equ	25h		;Command to halt controller
brnch	equ	26h		;Command to branch in channel
setchn	equ	27h		;Command to set channel address
sttksz	equ	2dh		;Command to set track size
tblsz	equ	26		;track table size
good	equ	40h		;normal command completion
fiver	equ	4h		;five inch drive flag
wrtpro	equ	40h		;write protect flag
dblsid	equ	4		;double sided drive & media flag
sd2bit	equ	80h		;side two bit
index	equ	10h		;Delta index status bit
wprtct	equ	40h		;Write protected status bit
proerr	equ	90h		;write-protected error code
dready	equ	80h		;Drive ready status bit
notrdy	equ	82h		;drive not ready
eightk	equ	2000h		;disk buffer size
mapsiz	equ	152		;badmap 76 X 2 sides
retries	equ	1		;Disk retries before verify error

conin	equ	1		;character in console
cout	equ	2		;character out console
wrstrn	equ	9h		;bdos write string
consta	equ	0bh		;get console status
lf	equ	0ah		;line feed
cr	equ	0dh		;carriage return
esc	equ	1bh		;escape character
wboot	equ	0		;warm boot address
bdos	equ	5		;Bdos entry address

start	org	100h
	lxi	sp,stack
	lxi	d,onms		;start-up message
	call	wrterm		;send it
	lxi	h,drvlog	;load log address
	shld	logpnt		;initialize pointer
	mvi	a,brnch		;branch command
	sta	channl		;controller starts here
	lxi	h,setdma	;set dma address command
	shld	vector		;guide controller
	sub	a		;zero A
	sta	vector+2	;extended address byte
	sta	hlted		;zero halt result byte
	out	startr		;start controller
	call	wait1		;wait for it to finish
	lxi	h,retrys	;address of set tries cmnd
	shld	vector		;to guide controller
	sub	a		;zero A
	sta	hlted		;clear halt result byte
	out	startr		;start controller
	call	wait1		;wait for it to finish
	call	drvcks		;look for drives
	call	test		;testem
	jmp	start		;run test again

drvcks	mvi	c,8		;maximum number of drives
	lxi	h,snstat	;get address of sense command
	shld	vector		;store it in vector
drvlp	mvi	a,8		;# of possible drives
	sub	c		;to find current drive
	mov	b,a		;save drive # in B
	push	b		;save count
	sta	snsdrv		;tell sense command
	sub	a		;zero A
	sta	snsrlt		;clear result byte of sense command
	sta	hlted		;clear halt command result byte
	out	startr		;start controller
	call	wait1		;wait for it to finish
cksns	lda	snsrlt		;sense command result status
	call	login		;record results in table
	pop	b		;recover count
	dcr	c		;drive count-down
	jnz	drvlp		;next drive
	ret			;else return

login	cpi	good		;zero means active drive
	jz	ckit		;to find out about it
	cpi	notrdy		;appropriate result
	cnz	logerr		;report to terminal
spec	lhld	logpnt		;get pointer
	mvi	m,0		;indicates inactive drive
	inx	h		;update pointer
	mvi	m,0		;indicates inactive drive
	inx	h		;for next drive
	shld	logpnt		;store pointer
	ret
ckit	push	b		;save BC pair
	lxi	d,drvmsg	;for operator
	call	wrterm		;send it
	pop	b		;recover BC
	mov	a,b		;put drive # in A
	call	bcdout		;send to terminal
	lda	dstat3		;load status byte
	ani	wrtpro		;ck write-protected bit
	jz	notpro		;if its off
	mvi	a,proerr	;write-protected error code
	call	loger2		;advises terminal
	jmp	spec		;goes on to next drive
notpro	lda	dstat1		;to find whether 5 or 8 inch
	ani	4h		;on means 5 inch
	jz	eighin		;else its an 8 inch
	lhld	logpnt		;get log pointer
	mvi	m,40		;number of tracks
	inx	h		;to next entry (sngl or dble sided)
	call	askop		;ask operator # of sides
	mvi	b,0		;zero B
	cpi	'1'		;single-sided?
	jz	skpdbl		;skip double-sided entry
	mvi	b,80h		;double-sided bit
skpdbl	lda	dstat2		;sector size
	add	b		;combine with B
	mov	m,a		;store result in drive log
	inx	h		;to next drive
	shld	logpnt		;store the updated pointer
	ret
eighin	lhld	logpnt		;load log pointer
	mvi	m,77		;number of tracks
	inx	h		;next log entry
	lda	dstat2		;sector size
	cpi	0		;may be wrong if on track 0
	cz	rechk		;moves to track 1 and rechecks
	mov	b,a		;save in B
	lda	dstat3		;3 bit tells sides
	ani	4h		;on means dbl sided
	jz	sngl		;single sided
	mvi	a,80h		;dble sided bit
sngl	add	b		;combine with sector size
	mov	m,a		;record it
	inx	h		;increment pointer for next drive
	shld	logpnt		;save it
	ret

test	mvi	c,8		;number of drive possibilities
	lxi	h,drvlog	;pickup log address
next	mov	a,m		;load tracks
	cpi	0		;active?
	jnz	go		;yes
	inx	h		;else advance pointer
	inx	h		;to next drive
	dcr	c		;decrement drive counter
	jnz	next		;loop till done
	ret
go	shld	logpnt		;save pointer
	mvi	a,8		;number of drive possibilities
	sub	c		;current drive number
	sta	wrtkdr		;tell commands
	sta	rdtkdr
	push	h		;save HL
	push	b		;and BC
	call	seekms		;advise terminal
	call	seeks		;do seek tests
	call	rdwrms		;advise terminal
	call	rdwrts		;do data tests
endrv	pop	b		;recover pointers
	pop	h
	inx	h		;advance pointer
	inx	h		;for next drive
	dcr	c		;drive count down
	jnz	next		;and loop
	ret			;no more drives

seeks	lxi	h,rdtrak	;read track command address
	shld	vector		;guide controller
	mvi	a,80h		;to abort command
	call	clrtbl		;writes A to command table
	lhld	logpnt		;pickup pointer
	mov	d,m		;put # of tracks in D
	dcr	d		;to get highest track number
	mvi	e,0		;Zero E
	call	pat1		;short-long-short
	lhld	logpnt		;pickup log pointer
	mov	d,m		;number of tracks to D
	dcr	d		;to get highest track number
	call	pat2		;long-short-long
	mvi	d,0		;start at 0
	call	pat3		;butterfly (+2-1 out, then -2+1 back)
	ret

pat1	mov	a,d		;D starts at highest track number
	call	seek		;seeks to track in A
	mov	a,e		;E starts at track 0
	call	seek
	dcr	d		;count down
	jm	reverse		;no tracks left
	inr	e		;count up
	cmp	m		;number of tracks
	jnz	pat1
reverse	inr	d		;count up
	mov	a,d
	cmp	m		;M has number of tracks
	rz
	call	seek		;else seek
	dcr	e
	rm			;no tracks left
	mov	a,e
	call	seek
	jmp	reverse

pat2	mov	a,d		;D starts at highest track number
	rar			;divide by 2
	mov	d,a		;reset D
	mov	e,a		;set E=D at start
pat2lp	mov	a,d		;start at middle track
	call	seek		;seeks to track in A
	dcr	e		;count E down, D up
	jm	phase2		;reverse direction
	mov	a,e		;else read it
	call	seek
	inr	d		;count up in first phase
	cmp	m		;number of tracks
	jnz	pat2lp
phase2	inr	e		;count up
	mov	a,e
	call	seek
	dcr	d		;count down
	mov	a,d		;to check
	cmp	e		;looking for crossing point
	rm			;finished
	call	seek		;else continue
	jmp	phase2		;loop

pat3	mov	a,d		;D starts at 0
	call	seek		;takes drive back one in loop
	mov	a,d
	adi	2		;jump ahead two
	cmp	m		;number of tracks
	jz	phaze2		;reverse pattern
	call	seek
	inr	d		;and back one
	jmp	pat3		;repeat
phaze2	dcr	a		;for first shot only
phlp	call	seek
	mov	a,d
	sbi	2		;in two
	rm
	call	seek
	dcr	d		;and back one
	mov	a,d
	jmp	phlp

seek	sta	rdtktk		;start at track indicated by A
	sta	track		;keep record
	push	d		;save DE
	push	h		;save HL
	mov	c,a		;save track in C
	lhld	logpnt		;get log pointer
	inx	h		;advance log pointer to sides byte
	mov	a,m		;load byte
	dcx	h		;return pointer
	ani	80h		;see if dblesided bit is on
	jz	onesid		;if not, forget it
	lda	rdtksd		;else load side byte
	xri	80h		;toggle it
onesid	sta	rdtksd		;replace it
	sta	side		;save it
	mov	b,a		;save side byte in B
	push	b		;save BC
	sub	a		;zero A
	sta	rtrslt		;clear result byte
	out	startr		;start controller
	call	wait1		;wait for it to finish
	pop	b		;restore BC
	lda	rtrslt		;check the results
	cpi	good		;normal completion?
	pop	h		;restore HL
	pop	d		;restore DE
	rz			;gives normal return
grab1	db	trap		;conditional RST 7
	cpi	notrdy		;drive gone away?
	jnz	error		;if not, report error
	call	error		;if yes, report and
	pop	h		;clear 3 returns off stack and
	pop	h
	pop	h
	jmp	endrv		;go to next drive

rdwrts	sub	a		;zero A
	sta	pass		;clear pass counter
	call	clrtbl		;clears command table
	call	trkszr		;puts size of track at tbytes
	nop
tstdat	lxi	h,wrtrak	;write track command address
	shld	vector		;to guide controller
	call	wrdrv		;writes all tracks
	lxi	h,rdtrak	;read track command address
	shld	vector		;guide controller
	call	rddrv		;reads and compares all
	lda	pass		;get pass counter
	inr	a		;increment it
	sta	pass		;put it back
	cpi	4		;one to many
	jnz	tstdat		;continue data test
	ret

wrdrv	lxi	d,wrtmsg	;writing message
	call	wrterm		;send it
	lda	pass		;get pass number
	call	bcdout		;send it
	call	clrmap		;clears badmap to zeros
	lxi	h,badmap	;address of map
	shld	mappnt		;initializes pointer to badmap
	lhld	logpnt		;pickup log pointer
	mov	b,m		;number of tracks
	sub	a		;zero A
	sta	wrtksd		;start with side 0
	sta	side		;store for error message
trklp	push	b		;save track counter
	push	h		;save log pointer
	mov	a,m		;number of tracks
	sub	b		;track counter
	mov	c,a		;save track in C
	sta	wrtktk		;current track to command
	sta	track		;and record
	call	newpat		;get pattern for this track
	call	filbuf		;writes it to disk buffer
wttk	sub	a		;zero A
	sta	wtrslt		;clear result byte
	out	startr		;starts controller
	call	wait1		;wait for it to finish
	lda	wrtksd		;get the side byte
	mov	b,a		;save it in B
	lda	wtrslt		;load result byte
	cpi	good		;ordinary completion
	jz	update		;gives normal return
grab2	db	trap		;conditional RST 7
	cpi	notrdy		;drive gone away?
	jz	abrtdr		;end this drive
	lhld	mappnt		;pickup pointer to badmap
	mov	m,a		;store error code
	inx	h		;advance pointer
	shld	mappnt		;store pointer
	call	error		;report and continue
	jmp	aswas		;normal completion
abrtdr	pop	h		;clear 2 pushes & 2 returns off stack
	pop	h
	pop	h
	pop	h
	jmp	endrv		;go to next drive
update	call	cktbl		;check sector results table
	lhld	mappnt		;pickup pointer to badmap
	inx	h		;advance it
	shld	mappnt		;store it
aswas	lhld	logpnt		;get log pointer
	inx	h		;advance to side byte
	mov	a,m		;load it
	ani	80h		;check sides bit
	jz	cntdwn		;if single-sided, forget it
	lda	wrtksd		;load command side byte
	ani	80h		;check side bit
	jnz	reset		;already done
	mvi	a,80h		;set it
	sta	wrtksd		;store in command
	sta	side		;and store it
	jmp	wttk
reset	sub	a		;reset side bit for next track
	sta	wrtksd		;store in command
	sta	side		;and store it
cntdwn	pop	h		;restore pointer
	pop	b		;restore BC
	dcr	b		;count down the tracks
	jnz	trklp		;do another track
	ret			;pass complete

rddrv	lxi	d,rdnmsg	;reading message
	call	wrterm		;send it
	lda	pass		;get pass
	call	bcdout		;send it
	sub	a		;zero A
	sta	rdtksd		;start with side 0
	sta	side		;and save record
	lxi	h,badmap	;initialize pointer
	dcx	h		;to one less
	shld	mappnt		;and store it
	lhld	logpnt		;get log pointer
	mov	b,m		;loads # of tracks to B
trklp2	push	b		;save track counter
	push	h		;save log pointer
	mov	a,m		;get number of tracks
	sub	b		;track counter
	mov	c,a		;save track in C
	sta	rdtktk		;store in command
	sta	track		;track record
rd	lhld	mappnt		;pickup badmap pointer
	inx	h		;advance it
	shld	mappnt		;put it back
	mov	a,m		;load it
	ani	0ffh		;see if its clear
	jnz	nxtrk		;skip track if not
	sub	a		;zero A
	sta	rtrslt		;clear result byte
	out	startr		;start controller
	call	wait1		;wait for it to finish
	lda	rdtksd		;get side byte
	mov	b,a		;save it in B
	lda	rtrslt		;get result byte
	cpi	good		;compare
	jz	okay		;gives normal return
grab3	db	trap		;conditional RST 7
	cpi	notrdy		;drive gone away?
	jz	abort		;end this drive
	call	error		;report and continue
	jmp	okay		;normal completion
abort	pop	h		;clear 2 pushes & 2 returns off stack
	pop	h
	pop	h
	pop	h
	jmp	endrv		;go to next drive
okay	push	b		;save BC
	call	cktbl		;check sector results table
	pop	b		;restore BC
	call	newpat		;get test pattern
	call	verify		;read and compare data
nxtrk	lhld	logpnt		;get log pointer
	inx	h		;advance to side byte
	mov	a,m		;load it
	ani	80h		;check sides bit
	jz	ignor		;if single-sided, forget it
	lda	rdtksd		;load command side byte
	ani	80h		;check side bit
	jnz	reset2		;already done
	mvi	a,80h		;set it
	sta	rdtksd		;store in command
	sta	side		;save record
	jmp	rd		;do other side
reset2	sub	a		;reset side bit for next track
	sta	rdtksd		;store in command
	sta	side		;save record
ignor	pop	h		;restore pointer
	pop	b		;recover counter
	dcr	b		;count down tracks
	jnz	trklp2		;do next track
	ret			;finish

logerr	push	psw		;save error code
grab5	db	trap		;conditional RST 7
	push	b		;save drive number in B
	lxi	d,drvmsg	;drive message
	call	wrterm		;send it
	pop	b		;get drive number
	mov	a,b		;move it
	call	bcdout		;send it
	pop	psw		;recover error code
loger2	call	errfnd		;loads DE to err msg
	inx	d		;skip crs & lf
	inx	d
	inx	d
	jmp	wrterm		;send to terminal

secerr	push	h		;save HL
grab6	db	trap		;conditional RST 7
	push	b		;and BC
	call	errfnd		;loads DE with err msg
	call	wrterm		;sends it
	lxi	d,trkmsg	;track message
	call	wrterm		;send it
	lda	track		;get track number
	call	bcdout		;send it
	lxi	d,sidems	;side msg
	call	wrterm		;send it
	lda	side		;get current side
	rlc			;move side bit to data 0
	call	bcdout		;send it
	lxi	d,secmsg	;sector message
	call	wrterm		;send it
	pop	b		;recover BC
	push	b		;and re-save
	mov	a,b		;number of sectors
	sub	c		;counter
	call	bcdout		;send it and return
	pop	b		;restore BC
	pop	h		;restore HL
	ret

getscs	lhld	logpnt		;get drive log pointer
	mov	a,m		;get # of tracks
	cpi	77		;if 8 inch
	jz	not5		;skip 5 inch
	mvi	c,0ah		;10 sectors for five inch
	ret
not5	lda	track		;load current track
	cpi	0		;see if its track 0
	jnz	not0		;skip if its not
	mvi	c,26		;else its 26 sectors
	ret
not0	inx	h		;advance to sector size
	mov	a,m		;load sector size byte
	ani	7		;low bits only
	mov	b,a		;save in B
	lxi	h,sctrs		;point M at table
	mov	a,l		;adjust M by B
	add	b
	jnc	notovr		;in case of carry
	inr	h
notovr	mov	l,a		;M now adjusted
	mov	c,m		;put number of sectors in C
	ret

error	push	d
	push	h
	push	b		;save register pairs
	call	errfnd		;loads DE with error msg
	call	wrterm		;send to terminal
	lxi	d,tkmsg		;track message
	call	wrterm		;send it
	lda	track		;get current track
	call	bcdout		;and send it
	lxi	d,sdms		;side msg
	call	wrterm		;send it
	pop	b
	mov	a,b		;get sides
	rlc			;move side bit to data 0
	call	bcdout		;send it
resume	pop	h		;recover register pairs
	pop	d
	ret

errfnd	ani	1fh		;mask off error value
	lxi	h,errtbl	;pickup address of msg table
	call	adjust		;adjust M by twice A
	mov	e,m		;load low address
	inx	h		;increment pointer
	mov	d,m		;load high address
	ret

clrmap	mvi	c,mapsiz	;size of badmap
	lxi	h,badmap	;address of map
	sub	a		;zero A
maplp	mov	m,a		;put zero in map
	inx	h		;advance 
	dcr	c		;count-down
	jnz	maplp		;until done
	ret

badtrk	push	psw		;save error code
	call	error		;report fault
	lhld	mappnt		;pickup badmap pointer
	pop	psw		;recover error code
	mov	m,a		;store it in map
	inx	h		;advance pointer
	shld	mappnt		;store it
	ret

cktbl	call	getscs		;returns # of sectors in C
	mov	b,c		;save # in B
	lxi	h,trktbl	;track r/w result table
cklp	mov	a,m		;load M
	cpi	good		;normal completion
	cnz	secerr		;report error
	inx	h		;advance 
	dcr	c		;decrement counter
	jnz	cklp		;repeat till done
	sub	a		;zero A for clrtbl
	jmp	clrtbl		;clear table and return

clrtbl	mvi	c,tblsz		;size of table
	lxi	h,trktbl	;command result table
tblp	mov	m,a		;fill it with A
	inx	h		;increment memory pointer
	dcr	c
	jnz	tblp
	ret

rechk	push	h		;save HL
	lxi	h,rdtrak	;set-up to read a track
	shld	vector		;to guide controller
	mvi	a,1		;desired track
	sta	rdtktk		;store in command
	out	startr		;start controller
	call	wait1		;wait for it
	lxi	h,snstat	;sense status command
	shld	vector		;guide controller
	out	startr		;start controller
	call	wait1		;wait for it
	lda	dstat2		;load desired result byte
	pop	h		;restore HL
	ret

verify	lxi	d,0		;zero DE
	push	d		;save DE
	lhld	tbytes		;load track size
	xchg			;move to DE
	lxi	h,dskbuf	;set M to disk buffer
verlp	mov	a,m		;pick up memory
	cmp	b		;what it should be
	jz	cntinu		;if correct
	xthl			;save HL & get error count
	inx	h		;increment error count
	xthl			;restore & save
cntinu	inx	h		;increment M
	dcx	d		;decrement size counter
	mov	a,e		;check for zero
	ora	d
	jnz	verlp		;continue if not
	pop	h		;get error count
	mov	a,l		;put L in A
	ora	h		;zero?
	rz
	push	h		;or report
	lxi	d,crlf		;carriage return & line feed
	call	wrterm		;send it
	pop	h		;get error count
	call	putdc		;prints it to terminal
	lxi	d,cmperr	;compare error msg
	call	wrterm		;send it
	lda	rdtktk		;get track number
	call	bcdout		;send it
	lxi	d,sdms		;side msg
	call	wrterm		;send it
	lda	rdtksd		;load side bit
	ani	sd2bit		;get side bit
	rlc			;put it in lowest bit
	call	bcdout		;send it
	ret


trkszr	lhld	logpnt		;pickup log pointer
	mvi	b,0		;zero B
	mov	a,m		;get tracks in A
	cpi	77		;8 inch?
	jnz	skp		;do not change
	mvi	b,3		;to skip 5 inch
skp	inx	h		;advance pointer to 2nd log entry
	mov	a,m		;load sector size & sides
	ani	7		;mask size only
	add	b		;covers 5 or 8 inch drives
	lxi	h,tksiz5	;initialize pointer to sizes
	call	adjust		;adjust M by double A
	mov	e,m		;load low byte
	inx	h		;advance pointer
	mov	d,m		;load high byte
	xchg			;put result in HL
	shld	tbytes		;store result
	ret

newpat	push	h		;save HL
	lxi	h,patble	;set M to test patterns
	lda	pass		;load pass counter
	add	l		;adjust low byte of address
	jnc	nocary		;cover overflow possibility
	inr	h
nocary	mov	l,a		;brings M to current pattern
	lda	track		;get current track number
	rar			;check for even or odd
	mov	a,m		;load test pattern
	jnc	even		;skip on alternate tracks
	cma			;complement test pattern
even	pop	h		;restore HL
	mov	b,a		;save in B
	ret

filbuf	push	h		;save HL
	lhld	tbytes		;track size
	xchg			;puts size in DE
	lxi	h,dskbuf	;points M at disk buffer
buflp	mov	m,b		;stores B in buffer
	inx	h		;steps M
	dcx	d		;decrement counter
	mov	a,e		;to check for zero
	ora	d
	jnz	buflp		;loop till done
	pop	h		;restore HL
	ret

adjust	mov	b,a		;save A in B
	mov	a,l		;pickup pointer low byte
	add	b		;adjust to B
	jnc	skpnc		;if no overflow
	inr	h		;adjust H
skpnc	add	b		;for high byte
	jnc	skpnc2		;if no overflow
	inr	h		;adjust H
skpnc2	mov	l,a		;put in L
	ret			;pointer is adjusted by A


wait1	push	d		;save DE
	lxi	d,0a000h	;load as timer-counter
wtloop	dcx	d		;start countdown
	mov	a,d
	ora	e		;check it for 0
	jz	restrt		;report to terminal & wboot
skip	push	d
	call	ckabrt		;check for keyboard interrupt
	pop	d		;recover local counters
	lda	hlted		;universal halt result
	cpi	0		;done yet?
	jz	wtloop		;wait for it
	ani	good		;normal completion?
	jz	restrt		;abort if not
	sub	a		;zero A
	sta	hlted		;clear result byte
	pop	d		;recover DE
	ret
restrt	lxi	d,eightn	;no response message
grab4	db	trap		;conditional RST 7
	call	wrterm		;send it
	jmp	start		;re-start test


ckabrt	push	b		;save BC
	push	h		;save HL
	push	d		;save DE
	mvi	c,consta	;asks for console status
	call	bdos
	dcr	a		;0ffh means data ready
	pop	d		;recover DE
	pop	h		;recover HL
	pop	b		;recover BC
	rnz			;no abort
	mvi	c,conin		;get the character
	call	bdos
	cpi	esc		;escape character
	rnz			;ignore anything else
	rst	7		;return to DDT
	ret

askop	push	h		;save HL
	push	b		;save BC
	lxi	d,sidesq	;number of sides question
	call	wrterm		;send to terminal
	lxi	d,0		;initialize counter
askwt	push	d		;save counter
	mvi	c,consta	;bdos console status code
	call	bdos
	pop	d		;restore counter
	dcr	a		;A is 1 if data ready
	jz	ckans		;get the answer
	dcx	d		;else wait awhile
	mov	a,e
	ora	d
	jnz	askwt
	mvi	e,'2'		;provide default answer
	mvi	c,cout		;console out
	call	bdos		;send it
	mvi	a,'2'		;default is two-sided
	jmp	eval		;insert it for return
ckans	mvi	c,conin		;console-in code
	call	bdos		;get answer
eval	pop	b		;recover BC
	pop	h		;recover HL
	cpi	cr		;is it a null answer?
	jz	start		;if so, restart program
	cpi	'1'		;or 1
	rz			;good answer
	jm	askop		;bad answer, ask again
	cpi	'2'		;good answer
	jnz	askop		;ask again
	mvi	a,80h		;dble-sided bit
	ret

seekms	lxi	d,seekng	;address of seek message
	call	wrterm		;send to terminal
	jmp	drtype		;tells track and drive number
rdwrms	lxi	d,readng	;address of read/write message
	call	wrterm		;send to terminal
	jmp	drtype		;track and drive number
drtype	lhld	logpnt		;pick up log pointer
	mov	a,m		;get number of tracks
	cpi	77		;see if eight inch
	lxi	d,eighms		;eight inch drive message
	jz	eightr		;for eight inch message
	lxi	d,fivems		;five inch drive message
eightr	call	wrterm		;eight message to terminal
	lda	rdtkdr		;get number of drive
	jmp 	bcdout		;send to terminal

bcdout	mov	l,a
	mvi	h,0

*****************************************************************
*								*
* Putdc prints the ascii decimal equivalent of the number in HL	*
*								*
*****************************************************************

putdc	lxi	b,-10
phl	push	d
	mov	d,b
	mov	e,b
phllp	dad	b
	inx	d
	jc	phllp
	xthl
	xchg
	mov	a,h
	ora	l
	cnz	phl
	pop	h
	mvi	a,'0'
	add	l
	sub	c

pchar	push	h
	push	b
	push	d
	push	psw
	mov	e,a
	mvi	c,2
	call	bdos
	pop	psw
	pop	d
	pop	b
	pop	h
	ret

wrterm	mvi	c,wrstrn
	jmp	bdos
	
snstat	db	snsta		;sense status command
snsdrv	db	0		;physical drive number
dstat1	db	0		;dstat 1
dstat2	db	0		;dstat 2
dstat3	db	0		;dstat 3
snsrlt	db	0		;command result
branch	db	brnch		;branch command
	dw	comhlt
	db	0		;extended address
setdma	db	setma		;set dma for seeks
	dw	dskbuf		;all purpose buffer (eightk-8192 bytes)
	db	0		;extended address byte
	db	brnch		;branch command
	dw	comhlt
	db	0		;extended address
wrtrak	db	wrtrk		;write track command
wrtktk	db	0		;
wrtksd	db	0		;
wrtkdr	db	0		;
wrtabl	dw	trktbl		;
	db	0
wtrslt	db	0
	db	brnch		;branch command
	dw	comhlt
	db	0		;extended address
rdtrak	db	rdtrk		;read track command
rdtktk	db	0		;
rdtksd	db	0		;
rdtkdr	db	0		;
rdsctb	dw	trktbl		;
	db	0 	
rtrslt	db	0
	db	brnch		;branch command
	dw	comhlt
	db	0		;extended address
retrys	db	strtry		;command to set # of retries
	db	retries		;number of retries
	db	brnch		;branch command
	dw	comhlt		;standard halt
	db	0
comhlt	db	conhlt		;universal halt command
hlted	db	0		;result byte

trktbl	ds	tblsz		;table used by write track command

patble	db	0		;test patterns
	db	0ffh
	db	0aah
	db	55h

tksiz5	dw	0		;no equivalent on 5 in
	dw	2560		;5 inch single density
	dw	5120		;5 inch double density
tksiz8	dw	3328		;8 inch single density
	dw	6656		;8 inch 256 byte sectors
	dw	7680		;ditto 512
	dw	8192		;ditto 1024
sctrs	db	26		;single density 8 inch
	db	26		;double density 256 byte sectors
	db	15		;512 byte sectors
	db	8		;1024 byte sectors
tbytes	dw	0		;current track size
track	db	0		;current track
side	db	0		;current side
pass	db	0		;current pass

logpnt	dw	drvlog		;pointer to drvlog
drvlog	ds	16		;drive log (trks, sides & sector sizes)

seekng	db	lf,lf,cr,cr
	db	'Testing seeks on$'
readng	db	lf,cr,cr
	db	'testing read/writes on$'
trkmsg	db	' Track $'
sidems	db	' side $'
secmsg	db	' sector $'
crlf	db	lf,cr,cr
	db	'$'
cmperr	db	' Compare error(s) on Track $'
drvmsg	db	lf,cr,cr
	db	'physical $'
fivems	db	' 5 inch physical $'
eighms	db	' 8 inch physical $'
wrprms	db	' write protected$'
dblmsg	db	' double-sided drive$'
nodrvs	db	lf,cr,cr
	db	'no drives are ready$'
sidesq	db	': How many sides on this drive? $'
zero	db	lf,cr,cr
	db	' Improper command code$'
one	db	lf,cr,cr
	db	' Improper disk drive value$'
two	db	lf,cr,cr
	db	' Disk drive not ready$'
three	db	lf,cr,cr
	db	' Improper track value$'
four	db	lf,cr,cr
	db	' Unreadable media$'
five	db	lf,cr,cr
	db	' Improper sector header - no sync byte(s)$'
six	db	lf,cr,cr
	db	' CRC error in sector header scan$'
seven	db	lf,cr,cr
	db	' Seek error$'
eight	db	lf,cr,cr
	db	' Compare error in sector header scan$'
fourtn	db	lf,cr,cr
	db	' CRC error in data field$'
fiftn	db	lf,cr,cr
	db	' Improper sector value$'
sixtn	db	lf,cr,cr
	db	' Media write protected$'
sevntn	db	lf,cr,cr
	db	' Lost data - DMA channel did not respond$'
eightn	db	lf,cr,cr
	db	' Lost command - Channel did not respond$'
tkmsg	db	' track $'
sdms	db	' side $'
sd1ms	db	' side one$'
sd2ms	db	' side two$'
wrtmsg	db	lf,cr,cr
	db	'Writing all tracks pass $'
rdnmsg	db	lf,cr,cr
	db	'Verifying all tracks written on pass $'
onms	db	lf,lf,cr,cr
	db	'To ABORT TEST hit "esc".  Type G100 for re-run.'
	db	lf,lf,cr,cr,'$'

errtbl	dw	zero,one,two,three,four,five,six,seven,eight
	dw	eight,eight,eight,eight,eight,fourtn
	dw	fiftn,sixtn,sevntn,eightn
	ds	50
stack	equ	$
mappnt	dw	0		;pointer to badmap
badmap	ds	152		;76 trks times 2 sides
dskbuf	ds	8192		;8K disk buffer