.TITLE	FRDTST - FLOPPY READ-WRITE TEST
; FRDTST.MAC  17-NOV-78  DSD FLOPPY READ-WRITE TEST ABSOLUTE.
.SBTTL	OPERATIONAL DESCRIPTION
	.NLIST
	.NLIST SEQ
; 16-NOV-78	SET UNIT, HELP UPGRADES
; 12-OCT-78	MAPADR, HELP ADDITIONS
; 24-FEB-78-3	SINGLE INTERRUPT TESTING AND BIS #INTEN
;			SEEK RANGE TEST ADDITIONS
;			SET-TRACK MODS FOR DOUBLE SIDED OPERATION
;			DUMPB WITH ASCII DUMP ALSO
;	16-OCT-77	DELETED DATA MODS. >8K REQUIRED.

.SBTTL	OPERATIONAL DESCRIPTION.
	.LIST
;**********************************************************
; OPERATIONAL DESCRIPTION
;**********************************************************
; FRDTST - LOADING AND STARTING.	REQUIRES 8 K MEMORY 
;	FROM WITHIN RT-11 TYPE
;	."R FRDTST<CRLF>" 
;		FRDTST TYPES OUT "REMOVE DIAGNOSTIC DISKETTE"
;		AND BRIEF OPERATIONAL DESCRIPTION.
;	FROM PAPER TAPE LOAD USING ABSLDR, FRDTST WILL START
;		 AND TYPE OUT BRIEF OPERATIONAL DESCRIPTION

;	FRDTST WILL ASK "MODE" AFTER IT IS CALLED IN OR AFTER
;	IT HAS FINISHED THE PREVIOUS TEST OR A CNTRL R IS TYPED.

;	RUNNING THE ACCEPTANCE TEST - EXERCISER 
;		TYPE "A" TO 'MODE:'.  FRDTST WILL DO A
;		GRADED SEQUENCE OF TESTS INCLUDING RANDOM
;		READ-WRITE AND ENDING WITH A SEQUENTIAL READ 
;		PASS AND WILL TYPE OUT ANY ERRORS FOUND.

;		EXAMPLE - QUOTED CHARACTERS ARE TYPED BY USER
;		."R FRDTST<CRLF>"
;		REMOVE DIAGNOSTIC DISKETTE
;		< ADDITIONAL DESCRIPTIVE TEXT >
;		FRDTST V5B
;		#MODE: "A"CCEPTANCE TEST 
;		FILL-EMPTY  CRC CHECKED  WRITING  READING
;		INTERRUPT ENABLED  WRITING  READING  RANDOM R-W
;		READING PASS FIN
;		BAD/GOOD 0 / 47000(APPROX)
;		< THE ABOVE REPEATS UNTIL STOPPED WITH CTRL R>
;			WHERE FILL-EMP IS TYPED WHEN STARTING
;			  THE BUFFER FILL-EMPTY TEST
;			"CRC CHECKED" BEFORE A CRC CHECK SCAN
;			"WRITING" TYPED BEFORE WRITE SEQUENTIAL
;			"READING" TYPED BEFORE READ SEQUENTIAL
;			"INTERRUPT ENABLED" ENABLES INTERRUPT
;			"WRITING" - ANOTHER WRITE THEN READ PASS
;			"RANDOM-RW" RANDOMLY READ/WRITE UNTIL
;			 1000(8) READS
;			"READING" BEFORE A SEQUENTIAL READ-ONLY
;			SCAN OVER THE RANDOMLY WRITTEN DATA.

; TYPE CONTROL R OR START AT 1104 TO RESTART FRDTST AT "MODE:"

;  SPECIAL CHAR CODES AND RESULTS
;	CTRL R	RESTARTS AT "MODE"
;	CTRL S  HANG OUTPUT TO TERMINAL UNTIL ANOTHER CHAR TYPED
;	CTRL O	THROWS AWAY OUTPUT UNTIL ANOTHER CHAR
;			IS TYPED OR UNTIL FLAG RESET.
;	CTRL P	INHIBITS ALL PRINTOUT EXCEPT FOR ERRORS.
;		RESET BY ANY OTHER CHAR TYPED IN.
;	CTRL C	  ASKS "EXIT TO RT-11?". TYPE "Y" TO EXIT.
;	CTRL D	  ODT DISPATCH     NOTE: ~C OR "1100G" RETURNS
;	CTRL T	  ODT DISPATCH WITH STACK TRACE.

;	FRDTST TYPES <CRLF># WHEN STARTED THEN ATTEMPTS AN INIT.
;	TYPES "MODE:" WHEN INIT IS SUCCESFUL.
;	USER TYPES KEY CHARACTERS IN () TO SELECT DESIRED MODE.

;********************************************************
; OPERATIONAL MODES:
;********************************************************
;	SPECIFY THE MODE BY TYPING THE CHARACTER STRING ENCLOSED
;	IN PARENTHESIS IN RESPONSE TO "MODE:"
;   *	THE MOST USEFUL MODES ARE ASTERISKED *****
;	THE AVAILABLE MODES ARE

;   *	(H)ELP		TYPES ALL COMMANDS AVAILABLE IN TEST
;   *   (A)CCEPTANCE	DOES FILL-EMPTY BUFFER CHECK, THEN
;			SEQUENTIAL WRITE-READ, THEN SETS INTER-
;	 		-RUPT ENABLE AND DOES EVERYTHING AGAIN
;			THEN DOES RANDOM READ WRITE
;			FOLLOWED BY A READ ALL TO CHECK DATA.
;			NOTE: THIS SEQUENCE SWITCHES THE DATA
;			GENERATION ALGORITHM AFTER EACH PASS.
;	(F)ILEMP	FILLS AND EMPTIES SECTOR DATA BUFFER
;			CHECKING FLAGS, COUNTS AND DATA.
;   *   (SEQW)R		SEQUENTIALLY WRITES DATA ON ALL SELECTED
;			DRIVES THEN READS ALL AND CHECKS DATA.
;			PRINTS "WRITING" WHEN STARTING WRITE PASS
;			PRINTS "READING" WHEN STARTING READ PASS

;	NOTE: ****   THE FOLLOWING 3 TESTS REQUIRE A SEQUENTIAL
;			WRITE PASS BE DONE FIRST IN ORDER TO
;			INITIALIZE THE DATA.  (SEE DATA FORMAT)

;   *   (SEQR)D		SEQUENTIALLY READ ONLY AND CHECK DATA ON
;			ALL SELECTED DRIVES.
;			PRINTS "READ PASS" AT END OF EACH PASS.
;	(RN)D RW	RANDOMLY GET A SECTOR ON SELECTED DRIVE
;			THEN READ OR WRITE IT CHECKING DATA.
;   *   (RD) RANDOM	READ RANDOMLY SELECTED SECTORS ON
;			AND CHECK DATA READ
;   *   (SC)AN		READ ALL SECTORS ON SELECTED DRIVES AND
;			CHECK FOR CRC ERRORS.
;	(RA)NDOM	RANDOMLY SELECT AND READ SECTORS ON
;			SELECTED DRIVES CHECKING STATUS ONLY.
;	(SK) RANGE	SEEKS REPETITIVELY THROUGH A RANGE
;			COVERING ALL SELECTED TRACKS
;	(SA) 125	RADIAL HEAD ALIGNMENT TEST USING SHUGART
;			SA 125 TEST DISKETTE.  MUST BE PROTECTED
;   *	(M)AP ADDRESS	PRINTS OUT ALL ADDRESSES THAT RESPOND
;   *   (ST)ATUS	TYPES CUMULATIVE TRANSFER AND ERROR
;			STATUS.
;	(RE)S STATUS	TYPE CUMULATIVE STATUS AND CLEAR.
;	(DUMPC)		DUMP CIRCULAR BUFFER OF PREVIOUS PRINT-OUT
;			AND ASK "RESET DUMP BUF?" (Y OR N)
; 	(SI)NGLE	REPEATEDLY READ THE SPECIFIED SECTOR
;			CHECKING STATUS.
;			ASKS UNIT, TRACK, SECTOR TO BE CHECKED.
;	(T)AP		REPEATEDLY READS SPECIFIED SECTOR AS
;			ABOVE BUT LIFTS HEAD AFTER EACH READ.

; MODE SETTING COMMANDS.

;   *   (SET )UNIT	ASKS UNITS (LOGICAL DRIVE #'S) TO BE
;			OPERATED ON.  ASKS "UNIT:" EXPECTING A
;			NUMBER <0-3> UNTIL A SPACE OR CR TYPED.
;			ACCEPTS UNIT #'S TILL INVALID # TYPED.
;			INITIALLY SET FOR UNITS 0 AND 1
;	(SET-)TRACK	SET TRACK LIMITS FOR OPERATION
;	(SEC)TIN	SECTOR INCREMENT (PDP11=2, LSI-11=3)
;	(I)NTRPT STT	SET INTERRUPT STATUS
;			0 = DISABLE FLOPPY INTERRUPTS
;			NOT 0 =	ENABLE FLOPPY INTERRUPTS AND
;			CHECK THAT AN INTERRUPT OCCOURS
;	(SETD)EVICE	ASKS DEVICE REGISTER TO BE CYCLED
;			THROUGH FOR MULTI DEVICE OPERATION.
;			STEPS TO NEXT FIELD IF SPACE.
;			EXITS ON <CR> TO "RXCS  :"
;	(SH)ORT		CHANGES ACCEPTANCE TEST LIMITS TO DO 
;			ONLY FIRST 8 TRACKS OF EACH DRIVE THEN
;			STARTS THE ACCEPTANCE TEST
;   *   (V)ERIFY	DOES SHORT ACCEPTANCE TEST THEN
;			RESETS BACK TO USE ALL TRACKS AND
;			SCANS ALL DISKETTES OVER ALL TRACKS.
;			IT THEN DOES A CTRL P TO INHIBIT ALL
;			BUT ERROR PRINTOUT AND GOES TO THE
;			ACCEPT TEST.

; FORMAT INITIALIZATION MODE.

;   *   (X)FORMAT REALLY?  MUST ANSWER WITH "Y TO PROCEEDE.
;			ASKS "UNIT: " TO BE FORMATTED.
;			ASKS "STANDARD FORMAT?"  IF "N" ANSWER
;			ASKS "INTERLEAVED FORMAT?"
;			FORMATS SPECIFIED DISKETTE TO THE
;			BLANK IBM FORMAT BY WRITING THE 
;			SOFT SECTOR SECTOR I.D. MARKS THEN
;			WRITING THE IBM INITIAL DATA.
;			'Y' MUST BE TYPED TO "FORMAT REALLY"
;			AND THE DRIVE MUST BE WRITE ENABLED
;			FOR FORMATTING TO OCCUR
;			SEE SHUGART IBM COMPATIBILITY REF MANUAL
;			FOR FORMAT SPECIFICS

;  DUMP - COPY UTILITY MODES
;	(DUP)L		DUPLICATES SOURCE UNIT ONTO DESTINATION
;			UNIT.  ASKS "SRCUNIT", "DSTUNIT" THEN
;			DOES A SECTOR BY SECTOR READ SRC,
;			WRITE DST, READ DST AND COMPARE.
;	(C)OMPARE	COMPARES 2 DISKETTES STARTING AT SPECI.
;			ADDRESS.  ASKS "SRCUNIT, TRACK, SECTOR,
;			# SECTORS, DSTUNT:"
;			SAME AS DUPL BUT WITHOUT WRITING.
;	(DUMPO)		OCTAL DUMP OF SPECIFIED SECTORS
;	(DUMPB)		BYTE DUMP OF SPECIFIED SECTORS
;	(DUMPA)		ASCII DUMP OF SPECIFIED SECTORS
;***********************************************************
; ERROR PRINTOUT DESCRIPTION
;***********************************************************

; ERROR FORMAT: (DEV<XXX> UN <U> TRK/SEC: <TK>/<SC> <FUNC CODE>
; RXCS=<XY> RXDB=<XY> [INTERRUPT ERROR:<X>]  BAD=<XX> #GOOD=<X>
; #DATA ERRORS:<XX>  ERRREG: <DEFINITIVE ERROR STATUS>

; DEV<XXX>	PRINTED ONLY WHEN RUNNING MULTIPLE SYSTEMS
;		XXX IS LAST 3 DIGITS OF RXCS VALUE FOR SYSTEM
; UN <U>	LOGICAL DRIVE # FOR WHICH PRINTOUT OCCURRED
; TRK/SEC: <TK>/<SC>	TRACK AND SECTOR ADDRESS AT WHICH
;			PRINTOUT OCCURRED.
; FUNCT CODE		IDENTIFICATION OF THE TEST IN PROGRESS
;			WHEN PRINTOUT OCCURRED.
; RXCS=<XY>	RXCS IS THE FLOPPY COMMAND STATUS REG AND
;			INCLUDES    ERROR FLAG	100000
;				    DONE FLAG	40
; RXDB=<XY>		DATA BUFFER REGISTER
;			SHOULD BE 0 NORMALLY OR 214 AFTER INIT
; INTERRUPT ERROR:<X>	IF < 0 INDICATES AN EXPECTED INTERRUPT
;			DIDN'T OCCOUR
;			IF > 0 INDICATES MULTIPLE INTERRUPTS
; #BAD=<XX> #GOOD=<X>	CUMULATIVE SUMMARY OF # STATUS ERRORS
;			DETECTED AND # SECTORS TRANSFERRED OK
; #DATA ERRORS:<XX>	# OF BYTE OF DATA FOUND TO NOT COMPARE
;			WITH EXPECTED VALUE

; ERREG:<DEFINITIVE ERROR STATUS>	SPECIFIC ERROR CODE FOR
;			ERROR TYPE AS DESCRIBED 2 PAGES HENCE

; FUNCTION CODE LIST AND DESCRIPTION

;	TEST	CODE		MEANING
; FILL-EMPTY	FB	PROBLEM LOADING SECTOR BUFFER.
;		E1,E2	SECTOR BUFFER DATA DIDN'T CHECK DURING
;			EMPTY-BUFFER  OPERATION.
; SEQ. WRITE	SW	PROBLEM LOADING SECTOR BUFFER.
; SEQRD		CW,SR	DATA READ BACK WRONG
; RANDOM       RW,RC,RR	RANDOM (WRITE,CHECK,READ)
; ANY READ	XE	EMPTY BUFFER CHECK BEFORE 
;  RETRY		 RETRYING THE READ
; DUP UTILITY	IN	ERROR READING SOURCE
;		CW	ERROR READING WHAT WAS JUST WRITTEN
; DELETED DATA	DW, DR	DELETED DATA FLAG FAILURE

; DATA FORMAT WRITTEN BY FRDTST IN ALL SECTORS.

; BYTE	0, 1	SECTOR #, TRACK #
;	2  -  7	6 BYTES OF ALL ONE'S
;	10 - 17	10 BYTES OF ALL ZEROES
;	20 - 21	SEED FOR RANDOM # GENERATOR
;	22 -177	RANDOM # SEQUENCE.
;***********************************************************
; FLOPPY INTERFACE REGISTERS AND DEFS.
;***********************************************************
.SBTTL	INTERFACE REGISTER DEFS

RXCS=177170	; COMMAND AND STATUS REGISTER.

; WRITE	 RO  IN X X  X X X  X RO IE  UT UN FN  FN FN EX

; READ	ERR  WO X X  X X X  X TR IE  DN WO WO  WO WO WO
;		RO = READ ONLY
;		WO = WRITE ONLY
;		ERR= ERROR DET. (CLEARED BY COMMAND INIT
;		IN = CONTROLLER INIT.
;		TR = TRANSFER REQUEST.
;		IE = INTERRUPT ENABLED ON DONE.
;		DN = DONE FLAG.
;		UT = HIGH UNIT SELECT IF THREE OR MORE DRIVES.
;		UN = UNIT SELECT.
;		FN = FUNCTION SELECT.
;		   0=FILL BUFFER	1=READ BUFFER
;		   2=WRITE SECTOR	3=READ SECTOR
;		   4=NOT USED		5=READ RXDB STATUS
;		   6=WRT.DELETED DATA	7=READ ERROR-REG
;		EX = EXECUTE.		(SEE LIST ON NEXT PAGE)

RXDB=177172	; DATA BUFFER REGISTER.

; CONTEXT CONTROLLED BY COMMAND SEQUENCE.

;	AFTER AN RXCS FUNCTION IS COMPLETE A STATUS
;	IS AVAILABLE TO BE READ IN RXDB LOW BYTE.

; X  X X X  X X X  X DR DD  XX XX WP  ID PA CRC

;	DR = DRIVE READY - CURRENTLY SELECTED DRIVE HAS DISKETTE
;		INSTALLED AND UP TO SPEED.
;	DD = DELETED DATA WAS READ ON LAST SECTOR.
;	WP = WRITE PROTECT ERROR.
;		SETS RXCS ERR BIT.
;	ID = INITIALIZE DONE.
;	PA = PARITY ERROR DETECTED.
;	     SETS RXCS ERR
;	CRC= CRC ERROR DETECTED IN DATA READ.
;	     SETS RXCS ERR

;*********************************************************
; MAPPING PHYSICAL DRIVES TO LOGICAL UNITS
;*********************************************************
; LOGICAL UNIT MAPPING USING SWITCHES ON FORMATTER/CONTROLLER
; PHYS	DRIVE		(OPEN = 0,  CLOSED OR JUMPERED = 1)
; #	LOCATION    SWITCHES USED FOR MAPPING     UNT<1>  UNT<2>
; 0  RIGHT	  LEFT  2 SWITCHES ON LEFT DIP SW  (0-0)  (0-1)
; 1  MIDDLE	  RIGHT 2 SWITCHES ON LEFT DIP SW  (1-0)  (1-1)
; 2  LEFT MOST	  LEFT 2 SWITCHES ON RIGHT DIP SW  (2-0)  (2-1)

; LOGICAL DRIVE 3 IS USED TO SPECIFY A DRIVE AS NON-EXISTANT
;**********************************************************
.SBTTL	ERRREG ERROR CODES
;**********************************************************

; ERROR CODES GIVEN BY READ ERROR-REG STATUS FUNCT (FUNCT 7)
;			PRINTED AS ERRREG: XX ON ERROR PRINTOUT
; CODE	LIGHT #		MEANING
; 10  2   DRIVE 0 FAILED TO HOME ON INIT, OR DIDN'T SELECT
; 20  2   DRIVE 1 FAILED TO HOME ON INIT, OR DIDN'T SELECT
; 30  2   FOUND HOME WHEN STEPPING OUT 10 TRACKS FOR INIT.
; 40  2   TRACK GREATER THAN 77. OR UNIT SELECT ERROR.
; 50  2   HOME BEFORE DESIRED TRACK FOUND.
; 70  2   DESIRED SECTOR COULD NOT BE FOUND AFTER 2 REVS.
;
; 100 3   WRITE PROTECT ERROR. - SETS RXES <10>
; 110     MORE THAN 48 USEC AND NO SEPERATED CLOCK FOUND.
; 120 0   NO PREAMBLE WAS FOUND (24 BITS OF 0'S)
; 130 0   PREAMBLE FOUND BUT NO ID ADDR MARK WITHIN WINDOW
; 140     CRC ERROR ON WHAT APPEARED TO BE HEADER.
;		 DOESEN'T SET ERROR FLAG WHEN ENCOUNTERED.
; 150 2   HEADER TRACK ADDRESS OF A GOOD HEADER DIDN'T
;		MATCH DESIRED TRACK.
; 160 0   TOO MANY TRIES FOR AN I.D. ADDRESS MARK.
; 170 0   DATA ADDRESS MARK NOT FOUND IN ALLOTED TIME.
; 200 0   CRC ERROR ON READING SECTOR FROM DISK.
;		RXES STATUS BIT OF VALUE 1 IS ALSO SET.
; 210 1   PARITY ERROR (INTERFACE <=> CONTROLLER)
;		RXES STATUS BIT OF VALUE 2 IS ALSO SET.
; 220 2   DRIVE 2 FAILED TO HOME ON INIT.
; 230 2   DRIVE 3 FAILED TO HOME ON INIT.
; 240	  SELECTED DRIVE NOT READY (110 ONLY)
;		INDEX HOLE NOT ON TIME
; 250 0   EXPECTED HEADER NOT FOUND AFTER TRACK FORMAT.
; 260 0   INDEX MARK NOT FOUND IN EXPECTED RANGE.
;		 (FORMAT NOT BEGUN)
; 270 0   INDEX MARK NOT FOUND IN EXPECTED RANGE.
;		 (FORMAT HAS OCCOURED)
; 300	  DATA LOST FROM WESTERN DIGITAL 1771 TO 8048.
;		(110 CONTROLLER ONLY)

;	SOFTWARE CONDITIONS REPORTED AS STATUS ERRORS
; 177		TIMEOUT ON DONE
; 176		TIMEOUT ON TRREQ
;   1		INTERRUPT ERROR


; FRONT PANEL ERROR LIGHT DESCRIPTION
; LIGHTS	MEANING
; 0	FRONT   DATA TYPE ERROR
; 1	FRONT	PARITY ERROR BETWEEN CONTROLLER-INTERFACE.
; 2	FRONT	SEEK TYPE ERRORS
; 3	FRONT	SWITCH CONFLICT ERROR OR CONTROLLER ERROR.
;		INCLUDES WRITE PROTECT OR FORMAT INHIBITED
;			ERROR TYPES.
;  BOARD LIGHTS		(210 ONLY)
; UP-LEFT    CONTROLLER WAITING FOR BUS INTERFACE READY.
; UP-RGHT    INIT IN PROGRESS.
; LW-LEFT    READ IN PROGRESS
; LW-RGHT    WRITE IN PROGRESS.
;   START-RESTART ADDRESSES.
;	1104 - NORMAL START -RESTART ADDRESS.
;		CAN BE STOPPED AND RESTARTED HERE AT ANY TIME.
;	1110 - START ADDRESS FROM MONITOR CALL TO SAVE VECTORS
;	1100 - RETURN ADDRESS FROM ODT AFTER CTRL D DISPATCH.
;	       ALSO START ADDRESS FOR ODT.
;	1114 - EMERGENCY RETURN TO "MODE" WITHOUT DOING INIT.

; FRONT END MACRO DEFS.

STRTAD=40	; START ADDRESS FOR REENTER.
JBSTW=44	; JOB STATUS WD: B7=REENTER,B12=SPECIAL TTY
ERRWD=52
MONLOW=54	; ADDRESS OF BEGINNING OF RESIDENT MONITOR.

TKS=177560
TKB=TKS+2
TPS=177564
TPB=TPS+2

.MCALL	..V2..,	.REGDEF,.EXIT,	.SRESET, .SETTOP
	..V2..
	.REGDEF	; DEFINE REGISTERS
	.ENABL AMA

.MACRO	SAVE	ARG1, ARG2, ARG3, ARG4, ARG5, ARG6
	.IIF NB <ARG1>,	MOV	ARG1, -(SP)
	.IIF NB <ARG2>,	MOV	ARG2, -(SP)
	.IIF NB <ARG3>,	MOV	ARG3, -(SP)
	.IIF NB <ARG4>,	MOV	ARG4, -(SP)
	.IIF NB <ARG5>,	MOV	ARG5, -(SP)
	.IIF NB <ARG6>,	MOV	ARG6, -(SP)
	.ENDM

.MACRO	RESTR	ARG1, ARG2, ARG3, ARG4, ARG5, ARG6
	.IIF NB <ARG6>,	MOV	(SP)+, ARG6
	.IIF NB <ARG5>,	MOV	(SP)+, ARG5
	.IIF NB <ARG4>,	MOV	(SP)+, ARG4
	.IIF NB <ARG3>,	MOV	(SP)+, ARG3
	.IIF NB <ARG2>,	MOV	(SP)+, ARG2
	.IIF NB <ARG1>,	MOV	(SP)+, ARG1
 .ENDM

.MACRO	PRINT	ASCSTR	; PRINT THE ASCII STRING
	JSR R5, PRINT
	.ASCIZ	"ASCSTR"
	.EVEN
	.ENDM

.MACRO	ASCIZ	ASCSTR
	.ASCIZ	"ASCSTR"
	.ENDM

.MACRO	TEXTL	TEXT
	.ASCII	"TEXT"<15><12>
	.ENDM

.MACRO	ASCIZE	ASCSTR
	.ASCIZ	"ASCSTR"
	.EVEN
	.ENDM

.MACRO	PCRLF
	JSR	PC, PCRLF
	.ENDM

.MACRO	ASCII	ASCSTR
	.ASCII	"ASCSTR"
	.ENDM

.MACRO	PRNTIT	LABEL, SOURC
	.IIF NB <LABEL>	PRINT	<LABEL>
	.IIF NB <SOURC> MOV	SOURC, R0
	JSR	PC, OCTPNT
	.ENDM

.GLOBL	O.ODT,	ODTRET, DATBFL,	ZZLST
.GLOBL	PRINT,	PCRLF,	OUTCHR
.GLOBL	GETCHR,	GNXCHR,	NXTCHR
.GLOBL	USLTBL, SCTINC, MAXPNT

.B15=	100000
.B14=	40000
.B13=	20000
.B12=	10000
.B11=	4000
.B10=	2000
	.LIST SEQ
	.ASECT

.=772
STACKV:	JMP	XXXRES	; BUFFER SPACE - STACK AT 770
	BR	.


.SBTTL	BOOTSTRAPS - ENTRANCE POINTS

;  MINIMAL BOOTSTRAPS FOR FLOPPY  -  RK-11

BOOTST:	RESET		; INIT ALL RK-11 REGISTERS
	MOV	#177406, R0	; PTR TO WORD COUNTER
	MOV	#-400, (R0)	; LOAD FOR 1 BLOCK XFER
	MOV	#5, -(R0)	; LOAD RKSC (CONTROL STATUS)
	TSTB	(R0)		; IS READ FINISHED?
	 BPL	.-2
	CLR	PC

.=1030

FLPBOT:	CLR	R0		; SET UNIT BOOTED FOR MONITOR
	RESET			; READ SECTOR 1, TRACK 1
	MOV	#177170, R1	; RXCS
	TST	(R1)
	 BEQ	.-2		; WAIT FOR DONE
	  BMI	FLPBOT		; ERROR - RETRY.
	MOV	R1, R4
	MOV	#3, (R4)+	; EMPTY BUFFER
	CLR	R3		; DELAY A LITTLE

4$:	TSTB	(R1)		; WAIT FOR TRANSFER REQUEST
	 BEQ	.-2
	  BPL	6$		; MUST BE DONE.
	MOVB	(R4), (R3)+	; LOAD STARTING AT 0
	BR	4$

6$:	CLR	PC
	.WORD	0		; FILLER.



.=1100	; ENTRANCE POINTS

ODTRTD:	JMP	ODTRET	; ODT RETURN POINT INTO DEBUGGER
RESTAR:	JMP	STARTD	; RESTART ADDRESS.
START:	JMP	STARTS	; START ADDRESS FROM MONITOR.

EMERGN:	BR	EMERGM

RSTTST:	MOV	#STACKV, SP
	JSR	R5, PATCH	; RE-INIT THINGS
	 MONPTK
	JMP	@(PC)+	; RESTART LAST TEST
RSTLOC:	FRDTST

EMERGM:	MOV	#STACKV, SP	; SET STACK
	JSR	R5, PATCH	;INIT THINGS
	 MONPTX	; INIT ALL VECTORS
	JMP	FRDXXX	;START AT MODE
	.SBTTL	FLOPPY BOOTSTRAPS

.=1172

; DEC LSI-11 BOOTSTRAP FOR RT-11  (2 DRIVE SYSTEM ONLY)
; READS SECTOR 1 TRACK 1 INTO CORE STARTING AT 0.
; STARTS AT LOC 0 WITH R0=0 IF UNIT 0, R0=1 IF UNIT 1.

BOTDX1:	MOV	#100267, R2	; DX1 BOOT FOR 2 DRIVE SYS.
	BR	.+6
BOTDX0:	MOV	#100247, R2	; UNIT 0 READ, GO
1$:	MOV	#RXCS, R1
	BITB	R2, (R1)	; TEST DONE
	BEQ	.-2
	MOVB	#7, R3	; SEQUENCE COUNTER FOR SECTOR,TRACK
	MOV	R1, R0	; SET UP RXDB POINTER
;***********************************************************
	MOV	R2, (R0)+ ; EXECUTE READ+ R0 = RXDB PTR
; NOTE: FOR 3 DRIVE BOOT THIS SHOULD BE CHANGED TO
;	MOV	R3, (R0)+ ; SO AS TO NOT SET UNIT SELECT(2)
;***********************************************************
	BR	.+6

2$:	 MOV	#1, (R0)	; SECTOR, TRACK INTO RXDB

	 ASR	R3		; SET = 3
	BCS	.+6	; SET TO LOAD SECTOR, TRACK
	 MOVB	(PC)+, (R1) ; GIVE EMPTY BUF COMMAND. [OR ]
3$:	  MOVB	(R0), (R3)+ ; LOAD DATA INTO CORE IF CARRY CLEAR
	BIT	R2, (R1)    ; ERROR, DONE, OR TRANSFER REQ
	BEQ	.-2	; WAIT FOR ONE OF ABOVE?
	BMI	1$	; ERROR - RETRY FROM BEG.

	BCS	2$	; R3= 3+C - LOAD SECTOR
			;     1+C - LOAD TRACK
			;     0+C - LOADS ANOTHER 1 (IGNORED)
			; THEN LOADS EMPTY BUF COMMAND AT 3$
	TSTB	(R1)	; TRANSFER REQUEST IN EMP BUF.
	BMI	3$	; READ ANOTHER BYTE.

	CLR	R0	; BUF EMPTY, MUST BE DONE.
	CMP	#240, (R0)	; CHECK THE DATA.
	BNE	1$	; NOT GOOD - RETRY.

	CMPB	#247, R2 ; IS UNIT = 0? (SETS CARRY)

	ADC	R0	; R0 = 1 IF UNIT 0, = 0 IF UNIT 1.
	CLR	PC	; START AT 0.
	.WORD	0
; DSD PDP-11 BOOTSTRAP FOR RT-11
; READS SECTOR 1 TRACK 1 INTO CORE STARTING AT 0.
; STARTS AT 0 WITH R0 = 0 IF UNIT 0, R0 = 1 IF UNIT 1.
; THIS IS USED IN THE DSD-210-11 PROM BOOTSTRAP AT 173000.

BOTDSD:	MOV	#7-20, R4	; SET UP READ COMMAND
NXTDRV:	ADD	#20, R4		; BUMP DRIVE SELECT (7,27,47,67
RESTRT:	MOV	#RXCS, R1
	BIC	(PC), R4	; INSURE VALID SELECT
	MOV	R1, R0		; LOAD POINTER FOR RXDB
	MOV	#100240, R5	; BIT TEST MASK FOR CARRY UNCHD
	BITB	R5, (R1)	; TEST DONE
	 BEQ	.-2
	MOV	#7, R3	  ; SEQUENCE COUNTER FOR SECTOR,TRACK
			  ; ALSO SETS R3 = 0 FOR LOAD POINTER
	MOV	R4, (R0)+ ; EXECUTE A READ ON SELECTED DRIVE
	; BR	.+6	; NOT NEEDED FOR DSD SYSTEMS.

LDRXDB:	 MOV	#1, (R0)    ; LOAD SECTOR, TRACK INTO RXDB

	ASR	R3	    ; SET = 3
	 BCS	.+6	    ; SET TO LOAD SECTOR, TRACK
3$:	   MOVB	(PC)+, (R1) ; GIVE EMPTY BUF COMMAND. [OR ]
EMPBFR:	  MOVB	(R0), (R3)+ ; LOAD DATA INTO MEM IF CARRY CLEAR
	BIT	R5, (R1)    ; ERROR, DONE, OR TRANSFER REQ
	 BEQ	.-2	; WAIT FOR ONE OF ABOVE?
	BMI	NXTDRV	; ERROR - RETRY ON NEXT DRIVE.

	BCS	LDRXDB	; R3= 3+C - LOAD SECTOR
			;     1+C - LOAD TRACK
			;     0+C - LOADS ANOTHER 1 (IGNORED)
			; THEN LOADS EMPTY BUF COMMAND AT 3$
	TSTB	(R1)	; TRANSFER REQUEST IN EMP BUF.
	 BMI	EMPBFR	; READ ANOTHER BYTE.

	CLR	R0	; BUF EMPTY, MUST BE DONE.
	CMPB	#7, R4	; IS UNIT = 0? (SETS CARRY IF NOT)
	ADC	R0	; R0 = 0 IF UNIT 0, = 1 IF UNIT 1.
	CLR	PC	; START AT 0.
	.SBTTL	TRAP HANDLER

; TRAP HANDLER FOR BUS TIMEOUT AND RESERVED INSTRUCTIONS.

TRAP4:	PRINT	< TRAP-4 @>
	BR	TRPCOM

TRAP10:	PRINT	< TRAP-10 @ >

TRPCOM:	MOV	SP, 4$	; SAVE POINTER TO ENTRANCE ADDR.
	SAVE	R0, R1, R2, R3, R4, R5	; FOR TYPING
	CLR	R1	; INIT ID COUNTER.
	MOV	(PC)+, R2	; POINTER TO TRAP ADDR.
4$:	0
	MOV	(R2), R0	; LOAD TRAP ADDR.
	JSR	PC, OCTPNT
	PCRLF
	BR	6$	; TYPE R0 - R6.

5$:	MOV	-(R2), R0
	JSR	PC, OCTPNT
6$:	PRINT	< R>	; REGISTER I.D.
	MOV	R1, R0
	JSR	PC, OCTPNT
	INC	R1
	CMP	R1, #6
	BLE	5$

	ADD	#6, SP	; BACK IT OFF
	MOV	4$, R0	; GET STACK POINTER.
	JSR	PC, OCTPNT	; PRINT R6.
	PCRLF
8$:	MOV	#100, @#177560	; ENABLE KEYBOARD INTERRUPT.
	JSR	PC, GETCHR-4
	CMP	R0, #'W-100	; RETURN-PROCEEDE ON CTRL-W
	BNE	8$
	RESTR	R0, R1, R2
	RTI

; POWER FAIL - RESTART ROUTINE.

PWRFAL:	HALT
	; WAIT HERE FOR POWER TO GO DOWN: CAN CONTINUE.
PWRUP:	MOV	#STACKV, SP
	JSR	R5, PATCH	; PATCH MONITOR TO RUN STATE.
	 MONPTX		; RE-ENABLE HARDWARE AND DO 1104G
	JMP	RESTAR

; MACRO TO PRINT A MESSAGE ON ADDRESS BOUNDARY OVERFLOW

.MACRO	SAVPOS	ADDR
	.IF GE ADDR-.
	  .IF GE ADDR-.-00
  .PRINT ADDR-. ; FREE
	  .ENDC
	  .=ADDR
	.IFF
	  .PRINT ADDR	; ADDRESS OVERFLOW
	.ENDC
	.ENDM
.SBTTL	FLOPPY READ TEST DISPATCH
; FLOPPY READ TEST DISPATCH AND MODE SELECT SECTION

FRDTST:	MOV	#STACKV, SP	; INIT STACK
	CLR	-(SP)		; SET PRIORITY BY DOING RTI
	JSR	PC, SETPRI
	JSR	R5, PATCH	; INITIALIZE VARIABLES AND STATE
	 MONPTK	; BUT DON'T CLEAR INPUT BUFFER.
	JSR	PC, INTKSC	; INIT TO FIRST DEVICE AND LOAD
	CLR	(PC)+	; INIT TO NORMAL PRINTOUT MODE
ERRPFG:	0			; 0 = NORMAL, 1 = ONLY ERRORS.
	CLR	LSTCHR		; FOR CTRL O DEFEAT.
	CLR	RANKEY		; INIT TO NORMAL VAL.
	MOV	MTRKLS, TRKLAS	; INIT OPERATIONAL LAST TRACK
	PRINT	<"<15><12>"#>

	MOV	R1, R0	; CHECK FOR A RESPONSE AT RXCS
	JSR	PC, CHKRSP	;  BEFORE INITING
	 BCC	4$
	  PRNTIT < NO RESPONSE @ >,
	  BR	FRDXXX
4$:	MOV	#40000, (R1)	; FORCE AN INIT.
	CLR	@INTPTP	; INIT INTERRUPT FLAG FOR THIS DEVICE
	JSR	R5, CYCDEV	; INIT ALL DEVICES
	  BR	.-4		; PURGED
	  BR	4$		; DO NEXT DEVICE.
	BIT	#100240, (R1)	; WAIT FOR FIRST DEVICE FINISH
	 BEQ	 .-4
	 BPL	 FRDXXX
	  PRNTIT <INIT ERR- RXES=>, (R2)
FRDXXX:	PRINT	<MODE: >
	JSR	R5, FUNIQS	; GET MODE
	 FLRDTB
	BR	4$		; IF NOT FOUND, DO IT AGAIN

	TST	(R4)+		; GET PAST POINTER
	MOV	(R4)+, LOPLOC	; STORE JUMP LOC. FOR MODE
	MOV	(R4), RSTLOC	; KEEP LAST TEST START ADDR.
	MOV	(R4), PC	; GO TO SPECIFIED TEST ROUTINE

4$:	JSR	PC, NXTCHR
	PRINT	< ??"<15><12>">
	BR	FRDXXX



; MODE TABLE FOR MODE FUNIQS--
; FORMAT:  POINTER TO ASCII STRING
;	   POINTER TO NEXT ENTRY
;	   ADDRESS OF INIT ROUTINE OR FLAGS FOR THIS MODE
;	   ADDRESS OF FUNCTION ROUTINE FOR THIS MODE.
	0			; OFFSET FOR CHAR STRINGS
FLRDTB:	XHELP,	.+6,	0,	HELP	; PRINTS ALL COMMANDS
	XACCEP,	.+6,	1,	ACCEPT	; ACCEPTANCE TEST
	XSHORT,	.+6,	1,	SHORTA	; SHORT ACCEPTANCE TEST
	XVERIF,	.+6,	1,	VERIFY	; VERIFY OK THEN NORMAL
	XSETU,	.+6,	0,	SETUNT
	XSCAN,	.+6,	0,	SCAN	; SCAN DISK FOR CRC ERRS
	XFILEM,	.+6,	0,	FILEMP
	XSEQWR,	.+6,	1,	SEQWR	; SEQUENTIAL WRITE/READ
	XSEQRD,	.+6,	0,	SEQWR	; READ ONLY, SEQUENTIAL.
	XRDRND,	.+6,	0,	RNDRW	; RANDOM READ ONLY
	XRNDRW,	.+6,	1,	RNDRW	; RANDOM RD / WRITE
	XSETDV,	.+6,	0,	SETDEV	; SET DEVICE REGISTERS
	XINTRP,	.+6,	0,	INTSTT	; SET INTERRUPT STATUS.
	XSING,	.+6,	SINGLP,	GETADD
	XTAP,	.+6,	TAPLP,	GETADD
	XRANDM,	.+6,	RNDLP,	INITAD	; (RA)NDOM READ-CRC CHK
	XMAPAD,	.+6,	0,	MAPADR	; MAP ADDRESS SPACE
	XFRSTT,	.+6,	0,	FRSTTU	; STATUS BY DEVICE/UNIT
	XRESTT,	.+6,	0,	RESTTU	; RESET CUMULATIVE STATU
	XFORMT,	.+6,	0,	FMTFLP	; FORMATTER.
	XSTRAK,	.+6,	0,	SETTRK	; SET TRACK RANGE
	XSCTIN,	.+6,	0,	SSCTINC	; SET SECTOR INCREMENT
	XSEKRN,	.+6,	0,	SEKRNG	; SEEK THROUGH RANGE
	XSA125,	.+6,	0,	SA125	; SA125 ALIGNMENT
	XDUPL,	.+6,	43,	DUPLIC	; DUPLICATE A FLOPPY
	XCOMPL,	.+6,	42,	DUPLIC	; COMPARE (OCTAL DUMP)
	XBDUMP,	.+6,	40,	DUPLIC	; DUMP  (BYTE OUTPUT)
	XODUMP,	.+6,	44,	DUPLIC	; DUMP  (OCTAL OUTPUT)
	XADUMP,	.+6,	50,	DUPLIC	; DUMP  (ASCII OUTPUT)
	XDUMPC, .+6,	0,	DUMPC	; DUMP CIRC TEXT BUF
	0

; ASCII MODE DESCRIPTORS FOR FUNIQS
XHELP:	ASCIZ	<HELP >
XACCEP:	ASCIZ	<ACCEPTANCE TEST>
XSHORT:	ASCIZ	<SHORT>
XVERIF:	ASCIZ	<VERIFY >
XSTRAK:	ASCIZ	<SET-TRACK >
XSCTIN:	ASCIZ	<SECTIN>	; SET SECTOR INCREMENT
XSETU:	ASCIZ	<SET UNIT>		; SET UNIT:
XSETDV:	ASCIZ	<SETDEVICE>
XINTRP:	ASCIZ	<INTRPT STT >
XSING:	ASCIZ	<SINGLE >
XTAP:	ASCIZ	<TAP >
XSCAN:	ASCIZ	<SCAN>
XRDRND:	ASCII	<RD >
XRANDM:	ASCIZ	<RANDOM >
XFILEM:	ASCIZ	<FIL-EMP>
XMAPAD:	ASCIZ	<MAP ADDRESS>
XRESTT:	ASCII	<RES >
XFRSTT:	ASCIZ	<STATUS>
XFORMT:	ASCIZ	<XFORMAT >
XSEQWR:	ASCIZ	<SEQW/R >
XSEQRD:	ASCIZ	<SEQRD >
XRNDRW:	ASCIZ	<RND R/W>
XSEKRN:	ASCIZ	<SK RANGE>	; SEEK RANGE
XSA125:	ASCIZ	<SA 125>
XDUPL:	ASCIZ	<DUPL>
XCOMPL:	ASCIZ	<COMPARE >
XODUMP:	ASCIZ	<DUMPO>
XADUMP:	ASCIZ	<DUMPA>
XBDUMP:	ASCIZ	<DUMPB>
XDUMPC: ASCIZE	<DUMPC>
; UNIT SELECT TABLE - VALID ENTRIES ARE 0,1,2,3
; NEGATIVE VALUES OR VALUES >3 RESULT IN RETRY OR RECYCLE

USLTBL:	.BYTE	0,	1,	377,	377
USLTBX:	 -1
INTENF:	0	; 0 FOR INTERRUPT DISABLED.
WRTENF:	1	; 0 FOR READ ONLY.
SCTINC:	2	; INC SECTOR BY THIS AMOUNT
		; CAN BE INTERLEAVED BY ANY VALUE (1 - 12.)
		; BY CHANGING THIS LOCATION.
UNIT:	0	; CURRENT UNIT # * 20 FROM USLTBL.
TRACK:	0
SECTOR:	0
MAXPNT:	6	; MAX # COMPARISON ERRORS PRINTED.
MRETCT:	-2	; MAX # TRIES BEFORE GIVING UP
MAXERR: 200.	; MAX # ERRORS BEFORE DEVICE PURGE.

; INITIAL VALUES FOR TRACK AND SECTOR
TRKFST:	0
SCTFST:	1
TRKLAS:	76.
SCTLAS:	26.
MTRKLS:	76.	; MASTER LAST TRACK - USED FOR RESET

RXCSV:	RXCS	; CURRENT DEVICE REGISTER POINTERS.
RXDBV:	RXDB

	.NLIST	BEX
ERRCT:	0, 0	; (0)  HIGH THEN LOW ORDER.
	0, 0	; (1)
	0, 0	; (2)
	0, 0	; (3)
	0, 0	; (4)
	0, 0	; (5)

TRNCTR:	0, 0	; SECTOR TRANSFER COUNTER.
	0, 0	; (1)
	0, 0	; (2)
	0, 0	; (3)
	0, 0	; (4)
	0, 0	; (5)

DATERC:	0, 0	; (0) DATA ERROR COUNTER.
	0, 0	; (1)
	0, 0	; (2)
	0, 0	; (3)
	0, 0	; (4)
	0, 0	; (5)
ENDCLR:
	.LIST	BEX
; HELP - TYPES LIST OF COMMAND NAMES

HELP:	MOV	-4(R4), R4	; POINT TO PTR TO NEXT STRING

HELPL:	PCRLF
	MOV	(R4)+, R1	; GET COMMAND STRING POINTER
	 BEQ	HELPSX		; RETURN TO CALLER
	MOV	(R4), R4	; SET TO NEXT STRING
	JSR	PC, PRINTS	; PRINT THE COMMAND
	JSR	R5, TABCOL
	 40
	MOV	(R4)+, R1	; GET NEXT STRING
	 BEQ	HELPSX
	MOV	(R4), R4	; UPDATE POINTER
	JSR	PC, PRINTS
	BR	HELPL	; GET NEXT STRING

HELPSX:	JMP	FRDTST


	.SBTTL	SET FUNCTIONS

; SETUNT - SET USLTBL TO DESIRED UNITS (0-3) LEGAL.

SETUNT:	CALL	UNTSTT		; PRINT CURRENT UNITS SELECTED
	MOV	#USLTBL, R5
	JSR	PC, GETUNT	; SEE IF CHANGE DESIRED
	 BCC	FRDRT2
	MOV	#-1, (R5)	; INIT TO EMPTY
	MOV	#-1, 2(R5)	; INIT ENTIRE TABLE
	 BR	4$		; GO INSERT UNIT #

2$:	JSR	PC, GETUNT	; GET ANOTHER UNIT #
	 BCC	20$
4$:	MOVB	R4, (R5)+
	MOVB	#-1, (R5)	; INSERT TERMINATOR
	 CMP	R5, #USLTBX
	  BGT	20$		; TOO MANY UNITS, EXIT AND PRINT
	   PRINT  < NEXT >
	   BR	2$

20$:	CALL	UNTSTT
FRDRT2:	BR 	HELPSX

; UNTSTT - PRINT UNIT SELECT STATUS AS SPECIFIED IN "USLTBL"

UNTSTT:	PRINT	<"<15><12>"UNITS SELECTED >
	MOV	#USLTBL, R5		; POINTER TO UNIT TABLE
2$:	MOVB	(R5)+, R0
	 BPL	4$	; FLAG AS ERROR IF NO UNITS SELECTED
	  PRINT	 < NONE - ERROR >
	  BR	10$
4$:	JSR	PC, OCTPNT		; PRINT UNIT WITH LZ SUPPRESSION
	TSTB	(R5)			; IS THERE ANOTHER UNIT?
	 BMI	10$
	  PRINT	<, >
	  BR	2$

10$:	PCRLF
	RETURN
.SBTTL	SET DEVICE
; "SETDEV" - GET DEVICE PARAMETERS FOR CYCLEING.
;	ASKS " RXCS @ ",<# .GE. 170000> "INT VECT=",<# .LE. 500>

SETDEV:	MOV	#CYCTBL, R5	; INIT TO FIRST ENTRY
SETDVL:	PRNTIT	<"<15><12>"RXCS @ >, (R5)  ; ASK FOR DEV REG
	PRINT	<:>
	JSR	PC, OCTIN	; GET THE VAL
	 BCS	 1$		; VALID # TYPED
	  CMP	 YTTICH, #40	; IF SPACE, JUST LOOKING
	  BEQ	 SETINV		; OPEN INTERRUPT VECTOR.
	   CMP	  R5, #CYCTBL	; INHIBIT ZEROING FIRST ENTRY.
	    BGT		SETDVX
	    BR		SETDEV

1$:	JSR	PC, CHKRSP	; DOES IT RESPOND TO READ?
	 BCC	2$		; YES - PROCEEDE NORMALLY
	  PRNTIT < NO RESPONSE @ >,
	  BR	SETDVL
2$:	CMP	R0, #174000	; LOAD IF VALID #
	 BHIS	3$		; VALID DEVICE CODE
	 CMP	R0, #374	; A PURGE?
	  BGT	SETDVL+4	; NO. INVALID ADDRESS.
3$:	MOV	R0, (R5)	; LOAD INTO TABLE

SETINV:	PRNTIT	< INTVEC= >, VCTOFS(R5) ; PRINT CURRENT VECTOR.
	JSR	PC, OCTIN	; GET VECTOR ADDRESS
	BCS	4$		; VALID #
	 CMP	 YTTICH, #40	; WAS IT A SPACE FOR LOOKING AT
	 BNE	SETINV		; NOT SPACE - INVALID
	 BR	10$		; JUST LOOKING.
4$:	CMP	R0, #500	; VALID VECTOR ADDR
	BHIS	SETINV
	CMP	R0, #200	; MUST BE ABOVE 200
	 BLOS	SETINV
	MOV	R0, VCTOFS(R5)	; LOAD IT.

10$:	TST	(R5)	; TERMINATOR STILL AT THIS ENTRY?
	 BEQ	SETDVX	; YES - JUST EXIT.
	TST	(R5)+
	CMP	R5, #INTTBL-2	; AT END OF TABLE?
	 BLT	SETDVL

SETDVX:	CLR	(R5)
	MOV	#200, R5	; INIT VECTOR AREA
2$:	MOV	#INTERR, (R5)+
	CLR	(R5)+
	CMP	R5, #500
	BLT	2$

	CLR	R5
10$:	TST	CYCTBL(R5)	; VALID IF NON ZERO
	 BEQ	20$
	MOV	R5, R4
	ASL	R4		; OFFSET TO FLPIN0
	NEG	R4
	ADD	#FLPIN0, R4	; ACTUAL VECTOR VALUE
	MOV	INTTBL(R5), R0	; GET VECTOR LOCATION
	MOV	R4, (R0)+	; AND LOAD IT
	MOV	#340, (R0)+	; AND PRIORITY	TO LOW
	TST	(R5)+
	BR	10$

20$:	JSR	PC, INTKSC	; INIT FOR A DEVICE
FRDRT:	JMP	FRDTST	; RETURN TO DISPATCHER.

CYCTBL:	RXCS,	0,	0,	0,	0,	0,	0
INTTBL:	264,	0,	0,	0,	0,	0

	VCTOFS=INTTBL-CYCTBL	; INTERRUPT VECTOR TABLE OFFSET.
; FLOPPY INTERRUPT PROCESSOR
; INTFLG SET TO - # INTERRUPTS EXPECTED BY SETUP ROUTINE.
; FLPINT INCREMENTS COUNT AND DISABLES INTERRUPT
; HALTS IF # INTERRUPTS IS EXHORBITANT.
; THUS NORMALLY SET TO -1 IF ONE INTERRUPT IS EXPECTED
; LEAVES SET AT 0 AFTER 1 INTERRUPT

	INC	INTPTR	; 5TH DEVICE
FLPIN4:	INC	INTPTR	; 4TH DEVICE ENTERED
FLPIN3:	INC	INTPTR	; 3RD DEVICE ENTERED
	INC	INTPTR	; 2ND DEVICE ENTERED.
FLPIN1:	INC	INTPTR	; DEVICE # 1
FLPIN0:	SAVE	R0, R1	; USE AS SCRATCH REG.
	MOV	INTPTR, R0
	ASL	R0	; GET WORD OFFSET.
	ADD	#INTFG0, R0	; GET POINTER FOR THIS DEVICE
	INC	@R0		; BUMP INTERRUPT FLAG
	MOV	CYCTBL-INTFG0(R0), R1 ; GET DEVICE REG ADDR
	BIS	#177000, R1	; SET CLEARED BYTE BITS AGAIN.
;	NOTE: SHOULD ONLY INTERRUPT ONCE, CLEARED ON 2ND INTP.
	NOP ;	CLR  (R1)	; CLEAR INTERRUPT ENABLE
	CLR	(PC)+		; INIT OFFSET FOR NEXT INTERRUPT
INTPTR:	0
	CMP	(R0), #0	; IS THIS A MULTIPLE INTERRUPT?
	 BGT	FLPMNY	; YES - PRINT MESSAGE AND CLEAR ENABLE.
	CMP	#520, SP	; TOO MANY LEVELS DOWN IN STACK?
	 BHI	FINTER	; FATAL INTERRUPT ERROR
FLPINX:	RESTR	R0, R1
	RTI

INTFG0:	0
INTFG1:	0
INTFG2:	0
INTFG3:	0
INTFG4:	0
INTFG5:	0


; ROUTINE TO HANDLE MULTIPLE INTERRUPTS

FLPMNY:	CLR	(R1)	; DISABLE THE INTERRUPT
	INC	ERRPFG
	PRNTIT	<MULT-INTP >, R1
	BR	FLPINX

; ROUTINE TO HANDLE UNSTOPPABLE INTERRUPT

FINTER:	INC	ERRPFG
	RESTR	R0, R1
	CLR	(R1)	; DISABLE INTERRUPT
	PRNTIT	< CAN'T CLEAR INTERRUPT, PURGING >, R1
	BIC	#177400, @CURCYP
	JSR	R5, CYCDEV
	 BR	.-4	; SKIP PURGED UNITS
	JMP	RSTTST	; RESTART TEST AGAIN

; ROUTINE TO HANDLE INTERRRUPT THROUGH UNDEFINED VECTOR

INTERR:	INC	ERRPFG
	CLR	(R1)	; DISABLE INTERRUPT
	PRNTIT	< UNDIRECTED INTRPT >, R1
	CLR	ERRPFG
	RTI
.SBTTL	SET-TRACK
; SETTRACK - SET TRACK RANGE FOR OPERATION WITH DOUBLE SIDED
; DRIVE WITH WRAP AROUND MAPPING   <LIMIT = 153.=231(8) VALID>

	JSR	PC, NXTCHR	; KILL TERMINATOR
SETTRK:	PRNTIT	< FROM >, TRKFST ; PRINT CURRENT LOW BOUND
	PRINT	<: >
	JSR	PC, OCTIN	 ; GET NEW VALUE
	 BCC	4$		 ; LEAVE UNCHANGED
	CMP	R0, #153.	 ; VALID ?
	 BHI	SETTRK-4	 ; NO - ASK AGAIN
	MOV	R0, TRKFST	 ; LOAD NEW VALUE

4$:	JSR	PC, NXTCHR
	PRNTIT	< THROUGH >, MTRKLS ; PRINT UPPER BOUND
	PRINT	<: >
	JSR	PC, OCTIN
	 BCC	10$
	CMP	R0, TRKFST
	 BLE	14$		; LOGICALLY INVALID TRACK
	CMP	R0, #153.	; PHYSICALLY VALID?
	 BGT	4$		; NO - ASK AGAIN
	MOV	R0, MTRKLS	; LOAD MASTER TRKLAST
10$:	BR	FRDRT1

14$:	PRINT	< INCONSISTANT VAL >
	 BR	4$


; SET INTERRUPT STATUS TO 0 OR NON-ZERO

INTSTT:	PRNTIT	<=>, INTENF	; PRINT CURRENT STATUS..
	JSR	PC, OCTIN	; GET A NUMBER
	BCC	.+6		; NOT VALID #, JUST EXIT.
	 MOV	 R0, INTENF	; NON-ZERO ENABLES INTERRUPT
FRDRT1:	JMP	FRDTST
; SET SECTOR INCREMENT USED TO CALCULATE NEXT SECTOR # USED

SSCTINC: PRNTIT	<=>, SCTINC
	JSR	PC, OCTIN
	 BEQ	FRDRT1	; 0 IS INVALID
	CMP	R0, #25.
	 BGT	FRDRT1
	MOV	R0, SCTINC
	BR	FRDRT1


; FILL - EMPTY BUFFER TEST.
; DOES FILLS-EMPTIES EQUIVALENT TO WRITING AND READING
; AN ENTIRE DISKETEE

FILEMP:	JSR	PC, FILEMB
	BR	FRDRT1
FILEMS:	PRINT	<"<15><12>"FILL-EMPTY>
FILEMB:	JSR	PC, INTKSC	; INIT TRACK  - SECT. AS COUNTER
2$:	JSR	R5, FILBUF
	 "FB	; FILL-BUF
	JSR	R5, EMPBUF
	 "E1
	JSR	R5, EMPBUF
	 "E2
	JSR	PC, INCSEC
	BR	2$
	RTS	PC
.SBTTL	ACCEPTANCE TEST.

; ACCEPTANCE TEST SERIES.

SHORTA:	MOV	#9., TRKLAS	; DO FIRST 9 TRACKS REPETITIVELY
	MOV	#150., NRNDRD	; INIT # RANDOM READS
	JSR	PC, ACCEPS
	BR	SHORTA


; VERIFY ENTRANCE TO ACCEPTANCE TEST

VERIFY:	MOV	#7, TRKLAS	; DO ONLY FIRST 5 TRACKS
	MOV	#100., NRNDRD	; INIT # RANDOM READS
	JSR	PC, ACCEPV
	MOV	MTRKLS, TRKLAS	; DO FULL SCAN
	JSR	PC, SCANSA
	PRINT	<"<7><15><7><12>"PROCEEDING"<7>">
ACCEPL:	MOV	#'P-100, LSTCHR	; MAKE LIKE CTRL P TYPED


;  NORMAL FULL DURATION ACCEPTANCE TEST.

ACCEPT:	MOV	MTRKLS, TRKLAS	; INIT TO FULL RANGE
	CLR	NRNDRD		; INIT IT.
4$:	ADD	#1000, NRNDRD	; INIT # OF RANDOM READS.
	JSR	R5, CYCDEV	; DO 1000 RANDOM READS / DEVICE
	  BR	 .-4		; PURGED
	  BR	4$
	JSR	PC, ACCEPV	; DO A SERIES
10$:	COM	RANKEY		; ALTERNATE SERIES IN ACCEPS
	JSR	PC, ACCEPS	; START FULL SERIES.
	BR	ACCEPL


; ACCEPTANCE TEST SUBROUTINE SEQUENCER.

ACCEPS:	CLR	INTENF		; DISABLE INTERRUPT
	JSR	PC, SEKRSB	; SEEK THROUGH RANGE TEST
	JSR	PC, FILEMS	; DO BUFFER FILL-EMPTY
ACCEPV:	JSR	PC, SCANSA
	JSR	PC, DELCHK	; DELETED DATA CHECK ON TRACK 0
	JSR	PC, SEQWRS	; SEQUENTIAL WRITE - CHECK DATA
	MOV	#1, INTENF	; ENABLE INTERRUPT AND DO AGAIN
	PRINT	< INTERRUPT ENABLED >
	JSR	PC, SEQWRS
	JSR	PC, FILEMS
	PRINT	< RANDOM-RW >
	JSR	PC, RNDRWS	; RANDOMLY READ AND WRITE UNTIL
				; 1000 READS DONE.
	JSR	PC, SEQRD	; DO A SECOND READ-ONLY
				; TO CHECK RANDOM WRITE.
	PRINT	<PASS FIN "<15><12>">
	JSR	PC, CUMSTT	; PRINT CUMULATIVE STATUS.
	INC	ERRPFG		; ENABLE PRINT
	PRINT	<*>
	CLR	ERRPFG
	RTS	PC

; INIT STUFF.

GETADD:	JSR	PC, GETTRK	; LET USER SPECIFY TRACK, UNIT
	JSR	PC, GETSCT	; AND SECTOR
	BR	ISTAT

INITAD:	JSR	PC, INTKSC	; INIT TRACK, SECTOR
	.SBTTL	SECTOR INTEGRITY CHECK ROUTINES

; CLR STATISTICS, INIT POINTERS, AND INIT FLOPPY CONTR.
ISTAT:	MOV	#40000, (R1)	; FORCE INIT.
	TST	(R1)		; DONE YET?
	BEQ	.-2
	BPL	IDCHK		; CHECK FOR INIT DONE.
	JSR	PC, WTDNS	; INIT - SET DONE FLAG.
; CONTROLLER DONE--CHECK FOR PROPER FLAGS

IDCHK:	BIT	(R2), #4	; INIT. DONE FLAG SET?
	BNE	DOOPR
	PRNTIT	< INIT NOT DONE >, (R2)	; PRINT THE STATUS.

; READY TO DO OPERATION
; START READ OPERATION, THEN SEND SECTOR AND TRACK

DOOPR:	JSR	R5, EXTKSC	; EXECUTE COMMAND
	 7	; READ + GO

; OPERATION STARTED--NOW CALCULATE NEXT SECTOR AND TRACK
; (DEPENDING ON MODE), WAIT FOR DONE, AND DO IT AGAIN

	MOV	(PC)+, PC
LOPLOC:	0

; SINGLE MODE READS SAME LOCATION AS FAST AS IT CAN

SINGLP:	JSR	PC, DONECK	; WAIT FOR DONE
	BR	DOOPR		; AND DO IT AGAIN


; TAP MODE READS SAME LOCATION BUT LIFTS HEAD
; BETWEEN READS

TAPLP:	JSR	PC, DONECK
	MOV	#27300, R4	; WAIT LOOP CONSTANT
		; 27300 = 11928. =58.45 MSEC.
		; 60300 = 24768. =121.36MSEC  FOR 1 / REVOLUTION
		; 163140=65000. =320  MSEC
	DEC	R4
	BNE	.-2		; WAITED 100 MSEC?
	BR	DOOPR		; YEP, DO IT AGAIN


; CHOOSE A RANDOM SECTOR, TRACK AND READ IT,
; CHECK FOR CRC ERRORS AND SECTOR ERRORS.
; DONE CALCULATING NEXT READ LOCATION--
; WAIT FOR OPERATION TO FINISH

RNDLP:	JSR	PC, DONECK
	JSR	PC, GTRAND	; GET A RANDOM #
	JSR	PC, GTNTKS	; GET A RANDOM TRACK AND SECTOR
	BR	DOOPR		; AND DO IT AGAIN


; SCAN SELECTED DISKETTES FOR CRC ERRORS.
; NO DATA CHECK DONE.

SCAN:	JSR	PC, SCANSB	; SCAN THE DISK FOR CRC ERRORS.
	JMP	FRDTST

SCANSA:	PRINT	< SCAN>
SCANSB:	JSR	PC, INTKSC	; INIT TRACK AND SECTOR
	JSR	R5, EXTKSC	; DO A READ.
	 100007	; NEGATIVE TO SUPPRESS EMPTY BUF CHECK.
	JSR	PC, INCSEC	; GET NEXT SECTOR
	 BR SCANSB+4
	PRINT	< CRC CHECKED >
	RTS	PC
	.SBTTL	SEQUENTIAL-RANDOM READ-WRITE
; SEQUENTIAL WRITE / READ-BACK AND CHECK.
; TYPES ANY DATA COMPARISON ERRORS FOUND.

SEQWR:	JSR	PC, SEQWRS
	 BR	.-4

SEQWRS:	TST	LOPLOC
	BEQ	SEQRD	; READ ONLY.
	TST	WRTENF	; CLEARED FOR READ ONLY?
	BEQ	SEQRD	; YES-DON'T WRITE.
	PRINT	< WRITING >	; WRITE PASS
	JSR	PC, INTKSC	; INIT TRACK AND SECTOR
1$:	JSR	R5, FILBUF	; LOAD DATA
	"SW	; SEQUENTIAL WRITE

	JSR	R5, EXTKSC	; EXECUTE WITH TRACK,SECTOR
	 5	; WRITE + GO
	BR	4$	; PATCHABLE FOR READ AFTER WRITE*******

	  JSR	R5, EXTKSC	; READ DATA JUST WRITTEN
	   7
	  JSR	R5, EMPBUF
	   "CW	; CHECK WRITE.

4$:	JSR	PC, INCSEC	; DO NEXT SECTOR
	BR	1$

; SET UP TO READ ENTIRE FLOPPY BACK
SEQRD:	PRINT	< READING >
	JSR	PC, INTKSC
10$:	JSR	R5, EXTKSC	; READ OPERATION
	 7
	JSR	R5, EMPBUF
	 "SR
	JSR	PC, INCSEC
	BR	10$
	RTS	PC

; RNDRW - RANDOM READ AND WRITE.

RNDRW:	JSR	PC, RNDRWS
	 BR	.-4	; KEEP AT IT

RNDRWS:	CLR	NRNDRD-2	; RETURN AFTER 1000 READS / DEV.
RNDRWL:	JSR	R5, CYCDEV	; CYCLE SEQUENTIALLY THROUGH
	 BR	 .-4	; PURGED - GET ANOTHER.
	 NOP		; ALL DEVICES ENTERED.
	JSR	PC, GTRAND
	JSR	PC, GTNTKS	; GET A TRACK AND SECTOR
	JSR	PC, GTRAND	; GET NEW RANDOM # IN R3,R4
	TSTB	R4		; GET A READ OR A WRITE
	BPL	RNDRD		; DO A READ

RNDWT:	TST	LOPLOC		; RD RANDOM?
	BEQ	RNDRD		; READ ONLY
	TST	WRTENF		; IS WRITE ENABLED?
	 BEQ	RNDRD		; NO-DO READ.
	JSR	R5, FILBUF
	 "RW	; RANDOM WRITE.
	JSR	R5, EXTKSC	; DO WRITE
	 5
	NOP	; BR .+10 = 403	;*****************************
	 JSR	R5, EXTKSC	; OPTIONAL READ AFTER WRITE.
	   7
	JSR	R5, EMPBUF
	 "RC	; RANDOM CHECK
	BR	RNDRWL

RNDRD:	INC	NRNDRD-2	; INC RANDOM READ COUNTER
	CMP	#0, (PC)+	; 1000 RANDOM READS YET?
NRNDRD:	1000
	BLT	4$
	 JSR	PC, CYCINT	; INIT TO FIRST DEVICE ON EXIT.
	 RTS	PC		; RETURN FOR ACCEPTANCE

4$:	JSR	R5, EXTKSC
	 7	; READ + GO
	JSR	R5, EMPBUF
	 "RR	; RANDOM READ
	BR	RNDRWL
	.SBTTL	DUPLICATION - DUMP UTILITIES.
; DUPLICATION PACKAGE FOR FLOPPY DUP, COMPARE AND DUMP
; USES LOPLOC FOR MODE SETTING
;	BIT0	1 DOES DUP	0 DOES COMPARE ONLY
;	BIT1	1 CHECKS DEST	0 DUMP MODE - NO DESTINATION
;	BIT2	1 OCTAL DUMP	0 BYTE DUMP MODE
;	BIT3	1 FORCES ASCII PRINTOUT, 0 = NUMERIC
;	BIT4	1 FORCES IMAGE MODE FOR PUNCHING TAPE
;	BIT5	1 FORCES NO UNIT CYCLE	0 NORMAL SEQ[R-W/R]

DUPLIC:	MOV	INTENF, -(SP)	; SAVE INTERRUPT STATUS
	CLR	INTENF		; CLEAR FOR DELETED DATA
	JSR	PC, INTKSC	; INIT STUFF.
	PRINT	< SRC:>
	JSR	PC, GETUNT
	 BCC	DUPLIC
	MOV	R4, (PC)+
SRCUNT:	0
	; INIT STARTING TRACK AND SECTOR
	MOV	#0, TRACK
	MOV	#1, SECTOR
	CLR	SCTCTR	; INCREMENTED SECTOR CTR.
	MOV	#2002., (PC)+	; INIT IT TO FULL TRANSFER
NMSCT:	0
	MOV	#"CE, TXTID+4	; INIT TEXT ID LABEL TO
				; COMPARE ERROR.
	BIT	#1, LOPLOC	; ASK TRACK - SECTOR IF NOT DUP
	 BNE	2$
	 JSR	PC, GETTRK+4	; DON'T ASK UNIT.
	 JSR	PC, GETSCT
	PRINT	< # SECTORS:>
	JSR	PC, OCTIN
	 BCC	2$
	MOV	R0, NMSCT
2$:	JSR	PC, NXTCHR
	BIT	#3, LOPLOC	; IS DESTINATION REQUIRED?
	 BEQ	DUPFLP		; NO: NOT DUP OR COMPARE

	PRINT	<DST>
	JSR	PC, GETUNT
	 BCC	2$	; INSIST ON UNIT
	MOV	R4, (PC)+
DSTUNT:	0



DUPFLP:	MOV	SRCUNT, R0	; SET TO READ SOURCE.
	JSR	PC, LDUNT
	JSR	R5, EXTKSC
	  100007	; READ - NO DATA COMPARE
	MOV	WRXES, (PC)+	; SAVE DELETED DATA FLAG
DUPRDD:	0	; "100" BIT FOR DELETED DATA
	; EMPTY BUFFER INTO DATBUF FOR COMPARISON AND DUMP

	MOV	#DATBUF, R4	; LOAD PTR.
	MOV	#-200, R5	; BYTE CTR.
	JSR	PC, WTDNS
	MOV	#3, (R1)	; EMPTY BUF COMMAND.
4$:	JSR	PC, RXDBR	; READ A BYTE
	MOVB	R0, (R4)+
	INC	R5
	 BLT	4$
	JSR	PC, WTDNS

; CHECK FOR WRITE TO DESTINATION.
	BIT	#1, LOPLOC	; SET FOR WRITE ENABLED.
	 BEQ	CHKFLB

	MOV	DSTUNT, R0
	JSR	PC, LDUNT
	MOV	#5, 10$		; DEFAULT - NORMAL WRITE
	BIT	#100, DUPRDD	; DELETED DATA FLAG SET?
	 BEQ	 .+10
	  MOV	  #15, 10$	; YES - WRITE DELETED DATA
	JSR	R5, EXTKSC	; WRITE THE BUF
10$:	  5

CHKFLB:	INC	(PC)+		; SECTOR COUNTER
SCTCTR:  0
	BIT	#2, LOPLOC	; COMPARE WITH DESTINATION.
	 BEQ	DMPFLP		; NO DUMP MODE.

	MOV	DSTUNT, R0	; LOAD FOR PRINTOUT
	JSR	PC, LDUNT

	JSR	R5, FILBUF	; INSURE NEW DATA
	 "IN	; INIT DATA
	JSR	R5, EXTKSC
	  100007		; READ
	MOV	DUPRDD, R0		; GET DELETED DATA FLAG
	BIC	#214, R0	; IGNORE WRITE PROTECT
	CMP	R0, WRXES
	 BEQ	 5$
	  JSR	PC, PTKSEC
	  PRNTIT  < DELETED DATA SRC=>,	; ALREADY IN R0
	  PRNTIT  < DST=>, WRXES
5$:	MOV	#-200, R5	; BYTE COUNTER
	MOV	#DATBUF, R4
	MOV	#3, (R1)	; EMPTY THE BUF

	MOVB	(R4)+, R3	; COMPARISON DATA
	JSR	PC, RXDBI	; INIT AND COMPARE
CHKFLP:	MOVB	(R4)+, R3
	JSR	PC, RXDBC
	 BLT	CHKFLP
	 BR	DUPNXS		; FINISHED - DO NEXT SECTOR

DUPFLLP: BR	DUPFLP

DMPFLP:	CLR	R1	; OFFSET INTO BUFFER TO BE DUMPED
	MOV	#200, R3	; DUMP TO THIS OFFSET
	BIT	#20, LOPLOC	; IMAGE MODE?
	 BNE	IDUMP
	INC	ERRPFG	; ALLOW CTRL P SUPPRESSION OF DATA
	PRINT	<[>
	BIT	#100, DUPRDD	; PRINT "DELETED DATA"
	 BEQ	2$
	 PRINT	< DELETED DATA >
2$:	JSR	PC, PTKSEC
	MOV	SCTCTR, R0
	JSR	PC, OCTPNT
	PCRLF
	CLR	ERRPFG
	BIT	#10, LOPLOC
	 BNE	DMPASC
	BIT	#4, LOPLOC
	 BNE	4$		; DO OCTAL DUMP
	  JSR	R5, DMPBYT	; BYTE DUMP
	   DATBUF
	  BR	DUPNXS

4$:	JSR	R5, DMPOCT
	 DATBUF


DUPNXS:	MOV	RXCSV, R1	; RESTORE R1
	CMP	SCTCTR, NMSCT	; END OF COUNT?
	 BGE	4$		; WAIT BEFORE RETURN
	JSR	PC, INCSEC
	 BR	DUPFLLP

4$:	MOV	(SP)+, INTENF	; RESTORE INTERRUPT STATUS
	JMP	FRDTST


DMPASC:	MOV	#DATBUF, R5
1$:	MOVB	(R5)+, R0
	JSR	PC, OUTCHR
	DEC	R3
	 BGT	1$
	 BR	DUPNXS

IDUMP:	CLR	R0
	INC	R0
	 BNE	.-2	; DELAY
	MOV	#DATBUF, R5
2$:	MOVB	(R5)+, R0
	JSR	PC, OUTCHR
	DEC	R3
	 BGT	2$
	 BR	DUPNXS
	.SBTTL	DELETED DATA CHECK
; WRITE DELETED DATA ON SECTOR 1 TRACK 0 OF ALL DRIVES

DELCHK:	MOV	INTENF, -(SP)	; SAVE INTERRUPT STATUS
	CLR	INTENF		; TO KEEP RXES STATUS
	JSR	PC, INTKSC	; SECTOR, TRACK, DRIVE, DEVICE
DELCKL:	JSR	R5, FILBUF	; WRITE EXPECTED DATA
	 "DW
	JSR	R5, EXTKSC
	  15			; WRITE DELETED DATA
	CMP	#100, WRXES	; WAS FLAG SET?
	 BEQ	4$
	 JSR	PC, PTKSEC
	 PRNTIT	< WDEL ERR: >, WRXES

; THEN READ IT BACK AND CHECK DELETED DATA FLAG

4$:	JSR	R5, EXTKSC
	  7
	CMP	#100, WRXES	; SET ON READ?
	 BEQ	10$
	 JSR	PC, PTKSEC
	 PRNTIT	< RDEL ERR: >, WRXES
10$:	JSR	R5, EMPBUF
	  "DR
	JSR	PC, CYCUNT	; TRY ANOTHER DRIVE
	  BR	DELCKL
	MOV	(SP)+, INTENF	; RESTORE INTERRUPT STATUS
	RTS	PC
.SBTTL	MAP ADDRESS SPACE
; MAP ADDRESS SPACE RESPONDING TO READ

MAPADR:	CALL	MAPADS		; CALL THE MAP ROUTINE
	BR	FMTFLP-4

; SUB TO DO ADDRESS MAPPING

MAPADS:	MOV	#NCKRSP, @#4	; LOAD TRAP VECTOR
	CLR	R0		; START CHECKING AT 0
MPRSP1:	MOV	R0, (PC)+	; SAVE START OF RESPONDING AREA
STRTRS:	 0
MPRSPL:	TST	(R0)		; CLR CARRY AND CHECK RESPONSE
	 BCS	MPNORS		; BRANCH IF NOT
	MOV	R0, (PC)+	; ELSE UPDATE RESPONDING RANGE
FINRSP:	 0
	ADD	#2, R0		; CHECK NEXT WORD
	 BCC	MPRSPL		; YES - MORE TO GO
MAPADX:	PCRLF
	MOV	#TRAP4, @#4	; RELOAD TRAP VECTOR
	RTS	PC

MPNORS:	SAVE	R0	; SAVE COUNT ADDR
	PRNTIT	<"<15><12>"( >, STRTRS	; PRINT START ADDRESS RESP
	PRNTIT	<- >, FINRSP	; THROUGH LAST ADDR RESPONDING
	PRINT	<)>
	RESTR	R0
MPNORL:	ADD	#2, R0		; MORE MEMORY TO CHECK?
	 BCS	MAPADX
	TST	(R0)		; YES - DOES IT RESPOND?
	 BCS	MPNORL		; NO - STAY IN THIS LOOP
	 BR	MPRSP1		; YES - START RESPONDING RANGE


; CHKRSP - CHECK FOR A BUS RESPONSE TO WRITE AT C(R0)
; JSR	PC, CHKRSP	; R0 = ADDRESS TO BE CHECKED
;   RETURNS	; CARRY SET IF NO RESPONSE

CHKRSP:	SAVE	@#4		; SAVE STANDARD TRAP VECTOR
	MOV	#NCKRSP, @#4	; LOAD BUS TIMOUT TRAP VECTOR
	TST	(R0)		; CLR CARRY AND CHECK RESPONSE
	RESTR	@#4		; RESTORE STANDARD TRAP HANDLER
	RTS	PC

NCKRSP:	MOV	#1, 2(SP)	; SET CARRY IN STATUS ON STACK
	RTI
	.SBTTL	FORMAT FUNCTION
; FORMAT FLOPPY USING FORMAT MODE
; SPECIFIED BY WRITE OF SECTOR #152(8) = 118.
; IF FORMATTING ENABLED ACCEPTS 26. SECTOR #'S THROUGH RXDB
	JMP	FRDTST
FMTFLP:	PRINT	<REALLY?>
	JSR	PC, GETCHR-4
	CMPB	R0, #'Y
	BNE	FMTFLP-4

	JSR	PC, NXTCHR	; THROW THE "Y AWAY
	PCRLF
	TST	TRKFST	; PRINT TRACK RANGE IF NOT STANDARD VAL
	 BNE	 4$
	CMP	MTRKLS, #76.
	 BEQ	6$
4$:	  PRNTIT	< TRACKS >, TRKFST
	  PRNTIT	<- >, MTRKLS
6$:	JSR	PC, GETUNT	; DO ONLY SPECIFIED UNIT.
14$:	PRINT	<"<15><12>"SEQUENTIAL FORMAT?>
	JSR	PC, GETCHR-4
	CMP	R0, #'N
	BEQ	16$
	MOV	#SCTLST, FMTPTR+2 ; BYTE LIST POINTER.
	BR	20$

16$:	PRINT	<"<15><12>"INTERLEAVED FORMAT?>
	JSR	PC, GETCHR-4
	CMP	R0, #'Y
	BNE	14$
	MOV	#SCT2LS, FMTPTR+2
20$:	MOV	TRKFST, TRACK	; INIT TO FIRST TRACK
FORMAT:	JSR	PC, WTDNS
	MOV	#5, R0	; LOAD WRITE
	ADD	UNIT, R0
	MOV	R0, (R1)	; EXECUTE WRITE.
	MOV	#152, R0
	JSR	PC, RXDBLI	; RESET BYTE COUNTER.
	MOV	TRACK, R0
	JSR	PC, RXDBL

	MOV	#-26., R5	; BYTE COUNTER
	MOV	#26.*4, R4	; ALLOW NEGATIVE OFFSET OF 1
	MOV	#0, R0	; #SECTORS OFFSET BETWEEN TRACKS
4$:	DEC	R0
	 BLT	FMTSCL
	  ADD	TRACK, R4
	  BR	4$

FMTSCL:	CMP	R4, #26.	; REDUCE MOD 26(10)
	 BLT	20$
	  SUB	#26., R4
	  BR	FMTSCL

20$:	TST	(R1)	; ERROR?
	BMI	FMTXT
FMTPTR:	MOVB	SCTLST(R4), R0	; GET A SECTOR #
	INC	R4	; BUMP FOR NEXT SECTOR
	JSR	PC, RXDBL
	BLT	FMTSCL

	JSR	PC, DONECK	; CHECK FOR ERRORS ALSO
	INC	TRACK
	CMP	TRACK, MTRKLS	; MASTER VALUE OF TRACK LAST
	BLE	FORMAT
	MOV	TRKFST, TRACK	; INIT FIRST TRACK
	BNE	FMTXT		; ABORT IF TRACK 0 NOT INCLUDED
	MOV	#FMTTBL, R5	; INIT TRACK 0 TO IBM FORMAT.
	JSR	PC, DATINT	; WRITE TRACK 0 DATA.
	JSR	PC, DONECK	; ANY ERRORS?
FMTXT:	JMP	FRDTST

; LIST OF SECTOR #'S TO BE WRITTEN
SCTLST:	.BYTE	1, 2, 3, 4,  5, 6, 7, 10
	.BYTE	11,12,13,14, 15,16,17,20
	.BYTE	21,22,23,24, 25,26,27,30, 31,32
; USER MODIFYABLE SECTOR TABLE FOR SPECIAL FORMATS
; SPECIAL FORMAT FOR LSI-11 TO GIVE 3 SECTOR SPACING WITH 
; STANDARD RT-11 HANDLER.
SCT2LS:	.BYTE	1,  19.,12.,3., 21.,14.,5., 23.,16.
	.BYTE	7., 25.,18.,9., 2., 20.,11.,4., 22.
	.BYTE	13.,6., 24.,15.,8., 26.,17.,10.
; DATA INITIALIZATION TO IBM FORMAT FOR TRACK 0.

DATINT:	MOV	#DATBUF, R4	; OUTPUT POINTER.
	MOV	(R5)+, WRITIT	; POINTER TO WRITE ROUTINE.
	MOVB	(R5)+, SECTOR	; STARTING SECTOR
	MOVB	(R5)+, (PC)+	; ENDING SECTOR
SECTLS:	0

CHRLP:	TST	(R5)		; CHECK FOR END OF FORMAT TABLE
	BEQ	FMTWRT
	BMI	FMTERR

	MOVB	(R5)+, R0	; CHAR VALUE
	MOVB	(R5)+, R3	; REPETITION COUNT.
1$:	MOVB	R0, (R4)+	; LOAD A CHAR
	DEC	R3
	BGT	1$
	CMP	R4, #DATBUF+128.	; PAST END?
	BLE	CHRLP

FMTERR:	HALT
	BR	FDATXT

FMTWRT:	TST	(R5)+		; STEP PAST 0 TERMINATOR
	BNE	FMTERR
	CMP	R4, #DATBUF+128.
	BNE	FMTERR
	JMP	@(PC)+
WRITIT:	0

WRTNRM:	JSR	PC, LDBUF	; LOAD FLOPPY BUFFER
	JSR	R5, EXTKSC
	 5			; WRITE NORMAL DATA.

WRTRET:	INC	SECTOR		; DO NEXT
	CMP	SECTOR, SECTLS	; FINISHED?
	BLE	WRITIT-2	; NO-DO MORE SECTORS
; FINISHED THIS SECTOR RANGE, CHECK FOR TABLE END.
	TST	(R5)
	BNE	DATINT		; DO ANOTHER
FDATXT:	RTS	PC


; WRITE DELETED DATA ROUTINE FOR SECTORS 9-26.
; FIRST INSERTS SECTOR # INTO BYTES 10.-11. IN EBIDIC

WRTDEL:	MOV	SECTOR, R0
	MOV	#360, R3	; EBCDIC "0
	MOVB	R3, @#DATBUF+11	; INIT HIGH DIGIT
2$:	CMP	R0, #10.
	BLT	4$
	SUB	#10., R0
	INCB	@#DATBUF+11	; BUMP HIGH SECTOR # DIGIT.
	BR	2$

4$:	BISB	R0, R3	; SET INTO EBCDIC
	MOVB	R3, @#DATBUF+12	; LOW ORDER DIGIT.
; BUFFER NOW READY TO WRITE
	JSR	PC, LDBUF
	JSR	R5, EXTKSC
	 15		; WRITE WITH DELETED DATA.
	BR	WRTRET


; LDBUF - LOAD FLOPPY BUFFER FROM DATBUF.

LDBUF:	SAVE	R4, R5
	JSR	PC, WTDNS
	MOV	#1, (R1)	; FILL BUFFER.
	MOV	#DATBUF, R4
	MOV	#-200, R5
	CLR	BYTCNT
2$:	MOVB	(R4)+, R0	; LOAD A BYTE
	JSR	PC, RXDBL
	BLT	2$
	RESTR	R4, R5
	RTS	PC
; FMTTBL TO INIT TRACK 0 TO IBM INITIAL STATE.

; ENTRY FORMAT
; WORD	0	POINTER TO WRITE OUT ROUTINE.
; BYTE	FIRST SECTOR, LAST SECTOR
; BYTE	CHAR VAL,	REPEAT COUNT
;	ABOVE REPEATED UNTIL 0 TERMINATOR WORD FOUND.

; NEXT ENTRY OR TABLE TERMINATOR WORD OF 0.

; DEFS FOR FORMAT SPECIFICATIONS.
BLNKS	=100		; EBCDIC BLANK
BLANK=	BLNKS+400	; 1 BLANK.

.EBCA=	301+400
.EBCB=	.EBCA+1
.EBCD=	.EBCA+3
.EBCE=	.EBCA+4
.EBCH=	.EBCA+7
.EBCI=	.EBCA+10

.EBCL=	323+400
.EBCM=	.EBCL+1
.EBCO=	.EBCL+3
.EBCP=	.EBCL+4
.EBCR=	.EBCL+6

.EBCT=	343+400
.EBCV=	.EBCT+2
.EBCW=	.EBCT+3
.EBCX=	.EBCT+4

.EBC0=	360+400
.EBC1=	.EBC0+1
.EBC2=	.EBC0+2
.EBC3=	.EBC0+3
.EBC4=	.EBC0+4
.EBC5=	.EBC0+5
.EBC6=	.EBC0+6
.EBC7=	.EBC0+7
.EBC8=	.EBC0+8.
.EBC9=	.EBC0+9.


FMTTBL:	WRTNRM	; WRITE NORMAL DATA AS SPECIFIED
	.BYTE	1,	4	; SECTORS 1-4
	.BYTE	BLNKS,	80.	; 80 EBCDIC SPACES
	.BYTE	0,	48.	; AND 48. BINARY ZEROES.
	0

	WRTNRM
	.BYTE	5,	5	; SECTOR 5
	.EBCE			; "ERMAP" IN EBCDIC
	.EBCR
	.EBCM
	.EBCA
	.EBCP
	.BYTE	BLNKS,	75.
	.BYTE	0,	48.
	0

	WRTNRM
	.BYTE	6,	6	; SECTOR 6
	.BYTE	BLNKS,	80.
	.BYTE	0,	48.
	0

	WRTNRM
	.BYTE	7,	7	; SECTOR 7
	.EBCV			; "VOL1IBMIRD" IN EBCDIC
	.EBCO
	.EBCL
	.EBC1
	.EBCI
	.EBCB
	.EBCM
	.EBCI
	.EBCR
	.EBCD
	.BYTE	BLNKS,	69.
	.EBCW			; "W"
	.BYTE	0,	48.
	0

	WRTNRM
	.BYTE	8.,	8.	; SECTOR 8
	.EBCH			; "HDR1 DATA 080 01001"
	.EBCD
	.EBCR
	.EBC1
	BLANK
	.EBCD
	.EBCA
	.EBCT
	.EBCA
	.BYTE	BLNKS,	15.
	.EBC0			; LOGICAL RECORD LENGTH OF 80 CH
	.EBC8
	.EBC0
	BLANK
	.EBC0			; BEGINNING OF EXTENT
	.EBC1			; INITIALIZED TO TRACK 1 SECT 1

	.EBC0			; SECTOR 1
	.EBC0
	.EBC1
	BLANK
	.EBC7			; END OF EXTENT INITIALIZED AS
	.EBC3			; TRACK 73

	.EBC0			; SECTOR 26.
	.EBC2
	.EBC6
	.BYTE	BLNKS,	35.
	.EBC0			; END OF DATA INITIALIZED AS
	.EBC1			; TRACK 1

	.EBC0			; SECTOR 1
	.EBC0
	.EBC1
	BLANK
	.BYTE	0,	48.
	0

; REMAINING SECTORS WRITTEN AS DELETED DATA CONTAIN DIRECTORY.

	WRTDEL
	.BYTE	9.,	26.
	.EBCD			; "DDR1 DATA
	.EBCD
	.EBCR
	.EBC1
	BLANK
	.EBCD
	.EBCA
	.EBCT
	.EBCA
	.EBC0			; SECTOR NUMBER, HIGH DIGIT
	.EBC0			; SECTOR NUMBER, LOW DIGIT.
	.BYTE	BLNKS,	13.
	.EBC0			; LOGICAL RECORD LENGTH
	.EBC8			; INITED AS 080
	.EBC0
	BLANK
	.EBC7			; BEGINING OF EXTENT INITIALIZED
	.EBC4			; TO TRACK 74

	.EBC0			; SECTOR 1
	.EBC0
	.EBC1
	BLANK
	.EBC7			; END OF EXTENT INITIALIZED
	.EBC3			; AS TRACK 73

	.EBC0			; SECTOR 26.
	.EBC2
	.EBC6
	.BYTE	BLNKS,	35.
	.EBC7			; END OF DATA INITIALIZED AS
	.EBC4			; TRACK 74

	.EBC0			; SECTOR 1
	.EBC0
	.EBC1
	BLANK
	.BYTE	0,	48.
	0

	0	; END OF TABLE.
.SBTTL	SEEK RANGE
; SK RANGE - DOES SEEKS OF CONSTANT LENGTH OVER SPECIFIED
; TRACK RANGE, BUMPING INITIAL TRACK TILL FINAL TRACK
; OF RANGE IS EXCEEDED, THEN BACKWARDS TO INITIAL TRACK.
;  THE SEEK LENGTH IS THEN BUMPED AND THE PROCESS REPEATED
; UNTIL THE MAX SEEK LENGTH IS EXCEEDED
;  THE WHOLE PROCESS IS THEN REPEATED.

; ASKS "SEEK LENGTH (OLDVAL):<NEWVAL> THROUGH ():<>
; "COVERING TRACK (OLD):<NEW> THROUGH TRACK (OLD):<NEW>

SEKRNG:	PRINT	< SEEK LENGTH>
	JSR	R5, GETNVL	; GET A NEW VALUE
	 MTRKLS		; POINTER TO MAX VAL
SEEKRF:	 1
	BEQ	SEKRNG	; 0 NOT VALID
	PRINT	< THROUGH>
	JSR	R5, GETNVL
	 MTRKLS
SEEKRL:	 25	; MAXIMUM SEEK RANGE USED
	CMP	R0, SEEKRF	; FINAL GREATER THAN INITIAL?
	 BLT	SEKRNG		; ASK AGAIN
	PRINT	< SEEK TIME>
	JSR	R5, GETNVL	; GET NEW VALUE
	 SEKTMX		; POINTER TO MAX VALUE
SEKTIM:	120	; SEEK TIME IN TENTHS OF A MSEC.

	PRINT	<"<15><12>"COVERING TRACKS>
	JSR	R5, GETNVL
	 MTRKLS
TRKRGF:	 0
	PRINT	<THROUGH>
	JSR	R5, GETNVL
	 MTRKLS
TRKRGL:	 114
	CMP	R0, TRKRGF	; GREATER THAN INITIAL?
	 BLE	SEEKRL+10

4$:	JSR	PC, SEKRSB	; EXECUTE THE PATTERN
	PRINT	<!>
	BR	4$


; SUB TO DO SEEKS OF SPECIFIED RANGE OVER FLOPPY

SEKRSB:	JSR	PC, INTKSC	; INIT TO FIRST DRIVE,SYSTEM
	MOV	SEEKRF, (PC)+	; INIT SEEK LENGTH
SEEKRG:	0	; CURRENT SEEK LENGTH
SEKDLP:	MOV	TRKRGF, TRACK	; INITIALIZE TRACK, DRIVE LP

; LOOP BY TRACK STEPPING INWARDS
SEKITL:	CMP	TRACK, TRKRGL	; TRACK > LAST VALID
	 BGT	SEKITC
	JSR	PC, SEKTRK	; DO READ TO SECTOR ON THIS TRK
	ADD	SEEKRG, TRACK	; SET NEXT TRACK
	CMP	TRACK, TRKRGL	; STILL VALID TRACK?
	 BGT	SEKITC		; BRANCH TO STEP NEXT UNIT
	JSR	PC, SEKTRK	; DO THE SEEK
	SUB	SEEKRG, TRACK	; AND SET TO GO OUT AGAIN
	JSR	PC, SEKTRK
	INC	TRACK
	BR	SEKITL

SEKITC:	JSR	PC, CYCUNT	; NEXT DRIVE?
	 BR	SEKDLP	; DO FOR ANOTHER DRIVE

; FINISHED INWARD SERIES ON A DRIVE - NOW GO BACK OUT

	PRINT	<^>	; TELL WHEN GOING OUTWARDS AGAIN
	MOV	TRACK, (PC)+	; SAVE OUTMOST TRACK FOR CYCLING
TRKRGO:	 0
SKODLP:	MOV	TRKRGO, TRACK	; RESET FOR EACH DRIVE
SEKOTL:	SUB	SEEKRG, TRACK	; SEEK INWARDS
	CMP	TRACK, TRKRGF	; TRACK < MIN TRACK?
	 BLT	SEKOTC	; YES - DO NEXT DRIVE
	JSR	PC, SEKTRK
	ADD	SEEKRG, TRACK
	CMP	TRACK, TRKRGL	; PERHAPS ENTRY WAS ILLEGAL
	 BGT	2$
	JSR	PC, SEKTRK
2$:	DEC	TRACK
	JSR	PC, SEKTRK
	BR	SEKOTL

SEKOTC:	JSR	PC, CYCUNT	; NEXT UNIT
	 BR	SKODLP
	INC	SEEKRG		; OTHERWISE BUMP AGAIN
	MOV	TRKRGL, R0	; GET LAST TRACK
	SUB	SEEKRG,	R0	; GET MIN TRACK SEEK
	CMP	R0, TRKRGF	; IN TOO FAR?
	 BLT	4$
	MOV	SEEKRG, R0	; PRINT THE SEEK LENGTH
	JSR	PC, OCTPNT
	CMP	R0, SEEKRL
	 BLT	SEKDLP
4$:	RTS	PC


; SEKTRK - SEEK TO SPECIFIED TRACK WITH OPTIMAL SECTOR
; SECTOR = SECTOR + [ 3.0 MSEC/5.95 * SEEKRG +6.5 ] MOD 26.

SEKTRK:	MOV	SEKTIM, R3	; # TENTHS OF MSEC / STEP
				; OR 30. = 36 FOR 850
	MOV	TRACK, R0	; HOW MANY STEPS THIS TIME
	SUB	SEKLTK, R0	; NEW TRACK - OLD TRACK
	 BPL	 .+4
	  NEG	R0	; INSURE POSITIVE
	MOV	R0, 4$
	JSR	R5, MULT
4$:	 0		; ACTUAL # TRACKS TO BE STEPPED
	MOV	R4, R3		; GET LOW ORDER SINCE SMALL
	JSR	R5, MULT
SEKTMX:	 2115	; (2**16)/ 59.53 TENTH'S MSEC EACH SECTOR
	ASL	R4		; DO ROUNDOFF
	ADC	R3
	ADD	#7, R3		; FINAL SECTOR OFFSET
	ADD	R3, SECTOR

10$:	CMP	SECTOR, #26.	; VALID OR REDUCE MOD 26?
	 BLE	 SEKEXQ		; OK
	SUB	#26., SECTOR
	BR	10$

SEKEXQ:	JSR	R5, EXTKSC	; DO IT
	100007			; SUPPRESS DATA CHECK
	MOV	TRACK, (PC)+
SEKLTK:	 0
	RTS	PC
.SBTTL	SA 125 ALIGNMENT PROCEDURE

; RADIAL HEAD ALIGNMENT USING SA125 DISKETTE RECORDED WITH
; CORRECT ID ADDRESS MARKS IBUT WITH DATA WRITTEN
; OFFSET RADIALLY IN 1 MIL STEPS.

; DISPLACEMENT	TOWARDS		TOWARDS
;   (IN MILLS)	CENTER		OUTSIDE (POSITIVE)
;	0	1, 14
;	1	2, 15		3, 16
;	2	4, 17		5, 18
;	3	6, 19		7, 20
;	4	8, 21		9, 22
;	5	10, 23		11, 24
;	6	12, 25		13, 26.

; PROGRAM ASKS "UNIT: " AND EXPECTS 0, 1, OR 2
; THE DISK IS CHECKED TO INSURE WRITE PROTECTED AND
; TYPES "WRITE PROTECT IT" UNTIL PROTECTED.

; TRACK 0 SECTOR 7 IS READ TO CHECK FOR SA125 DISK.
;	TYPES "SA125 IN PLACE?" IF NOT

; READS ALL SECTORS OF TRACK 71. (OR 73.) AND BUILDS
; UP A TABLE OF SECTORS CORRECTLY READ VS DISPLACEMENT

; PRINTS "OUT-****H......L***-IN  TRK @( /-)X.X  RANGE =YY"

SA125:	PRINT	< >
	JSR	PC, GETUNT	; GET LOGICAL UNIT #
	BCC	SA125
; DO A READ STATUS COMMAND TO CHECK DRIVE WRITE PROTECTED

SAWPCK:	CLR	INTENF		; FORCE INTERRUPT DISABLED
	MOV	#11., R0	; DO A READ STATUS
	JSR	PC, LDCMD
	MOV	(R1), #0	; TAKE A SNAPSHOT
	INC	#0		; DELAY FOR THIS
	 BNE	.-4
	BIT	#100240, (R1)	; WAIT TILL STATUS READY
	BEQ	.-4
	BIT	#10, (R2)	; IS IT PROTECTED?
	BNE	SA125Q	; YES - CHECK DISKETTE
	 PRINT	< WRITE "<007>"PROTECT "<007>"IT >
	 BR	SAWPCK

; READ IN SECTOR 7 TRACK 0 TO CHECK FOR SA125.
SA125Q:	MOV	#7, SECTOR
	CLR	TRACK
	JSR	R5, EXTKSC	; FILL BUFFER WITH SECTOR 7
	  100007	; INHIBIT DATA PRINTOUT
	MOV	#DATBUF, R5	; SET UP TO EMPTY BUFFER
	MOV	#200, R3
	MOV	#3, (R1)	; DO EMPTY BUFFER COMMAND
2$:	JSR	PC, RXDBR	; READ A BYTE
	MOVB	R0, (R5)+	; LOAD INTO DATBUF
	DEC	R3
	BGT	2$
	JSR	PC, WTDNS	; INSURE EMPTY
; CHECK FOR "SA 125" EBCDIC IN BYTES 6-11
	MOV	#ESA125, R4
	MOV	#DATBUF+6, R5
	CMP	(R5)+, (R4)+	; CHECK "SA"
	BNE	4$
	CMP	(R5)+, (R4)+	; CHECK " 1"
	 BNE	4$
	CMP	(R5)+, (R4)+	; CHECK "25"
	 BEQ	SATSTS	; GO DO IT.
4$:	PRINT	<INSERT"<007>" SA 125 DISKETTE"<15><12>">
	BR	SATSTS

	.NLIST	BEX
ESA125:	.BYTE	342, 301, 100, 361, 362, 365
SASTR:	ASCIZ	<*HL.>

SASCTL:	.BYTE	1,  2,  3,  4,  5,  6,  7	; 0 TO +/- 3
	.BYTE	    10, 11, 12, 13, 14, 15	; +/-4 TO +/-6
	.BYTE	16, 17, 20, 21, 22, 23, 24	; 0 TO +/-3
	.BYTE	    25, 26, 27, 30, 31, 32	; +/-4 TO +/-6
	.BYTE	    0

SASCTO:	.BYTE	0,   2,  -2,   4,  -4,   6,  -6	; 0 TO +/-3
	.BYTE	    10, -10,  12, -12,  14, -14	; +/-4 TO +/-6
	.BYTE	1,   3,  -1,   5,  -3,   7,  -5
	.BYTE	    11,  -7,  13, -11,  15, -13


RDDEVO:	0, 0, 0, 0, 0, 0
RDDEV0:	0, 0, 0, 0, 0, 0
RDDEVI:	0
	.LIST	BEX

SATERR:	PRNTIT	<STATERR >, (R1)
	JSR	PC, WTDNS

; START READING SECTORS SEQUENTIALLY.

SATSTS:	MOV	#73., TRACK	; USE EITHER TRACK 71. OR 73.
	PRNTIT	<TRACK=>, TRACK
	JSR	PC, OCTIN
	 BCC	SATST
	  MOV	R0, TRACK
SATST:	CLR	R3		; TABLE OFFSET
	JSR	PC, SALOAD	; DO A READ TO LOAD HEAD
	 BIT	#40,(R1)	; WAIT TILL DONE
	 BEQ	.-4
	MOV	#11., R0	; WAIT TILL INDEX BEFORE READING
	JSR	PC, LDCMD
	BIT	#40, (R1)
	BEQ	.-4

SATSTL:	MOVB	SASCTO(R3), R4	; GET RADIAL OFFSET
	CLRB	RDDEV0(R4)	; INIT BYTE THIS OFFSET
	MOV	#1, (PC)+	; RETRY COUNTER ON 110 ERR.
SATERC:	 0
SATSTI:	MOV	#7, R0		; SET UP TO READ A SECTOR
	JSR	PC, LDCMD	; SET UNIT SELECT AND INT.
	BIT	#100240, (R1)
	 BEQ	.-4
	 BMI	SATERR
	MOVB	SASCTL(R3), (R2) ; LOAD THE SECTOR
	MOVB	SASCTL(R3), SECTOR  ; LOAD FOR STATUS PRINT
	BIT	#100240, (R1)
	 BEQ	.-4
	 BMI	SATERR
	MOV	TRACK, (R2)	; LOAD THE TRACK
	BIT	#100240, (R1)	; WAIT TILL DONE
	BEQ	.-4
	BPL	SARDOK		; NO ERROR THIS READ
	BIT	#1, (R2)	; WAS IT A CRC DATA ERROR
	 BNE	SARDER
; CHECK FOR 110 ERROR AND RETRY IF SO
	MOV	#17, (R1)
	DEC	SATERC	; TRY AGAIN?
	BLT	6$
	MOV	SATERC, R0
	 NOP
	BIT	#40, (R1)
	 BEQ	.-4
	CMP	#110, (R2)
	BEQ	SATSTI
6$:	  SAVE	R3, R4
	  JSR	PC, WTDNS	; PRINT ERROR IF NOT CRC
	  RESTR	R3, R4
SARDER:	INCB	RDDEV0(R4)	; BUMP COUNT IF ERROR.
SARDOK:	INC	R3		; NEXT ENTRY
	TSTB	SASCTL(R3)	; END OF SECTOR LIST?
	BNE	SATSTL

	MOV	#11., R0	; KEEP HEAD LOADED.
	JSR	PC, LDCMD	; WITH A READ STATUS
; SET UP TO PRINT OUT AND CALCULATE HEAD ALIGNMENT
	PRINT	<"<15><12>"OUT->
	CLR	(PC)+		; AVERAGE VAL OF GOOD RANGE
SAAVRG:	0
	CLR	(PC)+		; WIDTH OF RANGE (# MILLS WIDE)
SARNG:	0
	MOV	#RDDEVO, R5	; POINTER INTO RD STATUS TABLE

CKSAST:	CLR	R0	; BAD STATUS ACCUMULATOR
	MOV	R5, R4		; SET UP TO GET DEVIATION
	SUB	#RDDEV0, R4	; CURRENT LOC - ZERO OFFSET LOC
	ASR	R4		; OFFSET IN MILLS
	BNE	1$	; SKIP IF NOT ZERO OFFSET
	 PRINT	<"<74>">
1$:	TSTB	(R5)+		; TEST A RANGE
	 BNE	2$		; LOW READ OK THIS OFFSET
	  INC	R0		; INC IF OK
	  ADD	R4, SAAVRG	; UPDATE AVERAGE POS
	  INC	SARNG		; AND RANGE READ GOOD
2$:	TSTB	(R5)+
	 BNE	4$
	  INC	R0		; UPDATE TEXT STRING OFFSET
	  INC	R0
	  ADD	R4, SAAVRG
	  INC	SARNG
4$:	MOVB	SASTR(R0), R0	; GET THE CHAR VAL
	JSR	PC, OUTCHR
	TST	R4
	 BNE	6$
	  PRINT	<"<76>">
6$:	CMP	R5, #RDDEVI	; FINISHED WITH TABLE?
	BLE	CKSAST

; NOW CALCULATE MEAN AND RANGE VALS
	PRINT	<-IN  HEAD @ >
	CLR	R4		; INIT CONVERSION COUNTER
	MOV	SAAVRG, R3	; SUM OF SECTOR DEV'S READ OK
	ASL	R3
	ASL	R3
	ADD	SAAVRG, R3
	ASL	R3	; 10. * WEIGHTED SUM VAL
	BEQ	SADIVF
	BPL	SADIVR	; POSITIVE VAL
	 PRINT	<->
	 NEG	R3
SADIVR:	SUB	SARNG, R3
	BLT	SADIVF
	INC	R4
	BR	SADIVR

SADIVF:	CLR	R0
2$:	CMP	R4, #10.	; CONVERT TO DECIMAL
	BLT	SADEC
	SUB	#10., R4
	INC	R0
	BR	2$

SADEC:	ADD	#'0, R0	; MAKE THE DIGIT ASCII
	JSR	PC, OUTCHR
	PRINT	<.>
	MOV	R4, R0
	ADD	#'0, R0
	JSR	PC, OUTCHR

	PRINT	<  RNG= >
	MOV	SARNG, R0
	ASR	R0
	JSR	PC, OCTPNT
	JSR	PC, DISCHK
	JMP	SATST


; SALOAD - LOAD HEAD BY READING - < USED WHILE PRINTING. >

SALOAD:	BIT	#40, (R1)	; PREVIOUS COMMAND STILL RUNNING
	BEQ	4$
	MOV	#7, R0		; READ SECTOR 32 THIS TRACK
	JSR	PC, LDCMD
	 TSTB	(R1)		; TRREQ UP?
	 BPL	.-2
	 MOV	#32, (R2)
	 TSTB	(R1)		; TRANSFER REQUEST
	 BPL	.-2
	 MOV	TRACK, (R2)	; LOAD TRACK
4$:	RTS	PC
.SBTTL		TRACK - SECTOR SUBROUTINES.
; SUBROUTINES USED IN FLOPPY RD/WRITE
;INTKSC -INIT TRACK AND SECTOR FOR SEQUENTIAL READ /WRITE

INTKSC:	JSR	PC, CYCINT	; DO FIRST UNIT OF FIRST DEVICE.
	NOP
	MOV	SCTFST, SECTOR	; LOW LIMIT FOR SECTOR
	MOV	TRKFST, TRACK	; AND TRACK
	CLR	INCSCC
	RTS	PC

; INCSEC - INCREMENT SECTOR BY SECTOR INCREMENT (SCTINC).
; AND BUMP TRACK IF RESULT = 1 MODULO 26.

INCSEC:	ADD	SCTINC, SECTOR	; BUMP BY 1, 2 OR 3
	INC	(PC)+	; BUMP # SECTOR CNTR.
INCSCC:	 0	; INCREMENTING SECTOR COUNTER.
	CMP	SECTOR, #26.	; MAXIMUM SECTOR
	BLE	2$
	 SUB	#26., SECTOR	; WRAP AROUND.
	CMP	INCSCC, #26.	; DONE ALL SECTORS?
	 BGE	1$		; YES.
	 CMP	SECTOR, #1
	 BNE	2$
	INC	SECTOR		; DO ODD-EVEN INTERLEAVE.
	BR	2$

1$:	 MOV	SCTFST, SECTOR	; RE-INIT SECTOR
	 INC	TRACK
	CLR	INCSCC
	 CMP	TRACK, TRKLAS	; MAXIMUM TRACK
	 BLE	2$	; STILL LEGAL
	  JSR	PC, CYCUNT	; GET ANOTHER UNIT.
	   BR	.+6		; DO NEXT UNIT
	  ADD	#2, (SP)	; OVER-FLOW RETURN
	MOV	TRKFST, TRACK	; INIT TRACK TO BEGINNING.
2$:	RTS	PC

; CYCUNT - CYCLE THROUGH DRIVE UNITS IN USLTBL
; JSR PC, CYCUNT
;	RETURNS WITH NEW UNIT LOADED
;	RETURNS ON CYCLE THROUGH ALL UNITS WITH FIRST
;		 UNIT SET UP FOR NEXT EXECUTION

CYCINT:	JSR	R5, CYCDVI
	 BR	.-4	; SKIP INITIAL PURGED DEVICES.

	CLR	UNTPTR	; INIT TO BEG.
CYCUNT:	SAVE	R5
	MOV	(PC)+, R5
UNTPTR:	0
	 BNE	1$
	  MOV	#USLTBL, R5
1$:	BIT	#40, LOPLOC	; CHECK FOR UNIT CYCLE DISABLE
	 BNE	6$		; DISABLED, THUS FIN.
2$:	MOVB	(R5)+, R0	; GET A UNIT #
	 BMI	.-2		; SKIP DELETED UNITS
	CMP	R5, #USLTBX	; LAST VALID UNIT
	 BGT	4$
	CMP	R0, #3
	 BGT	2$
	MOV	R5, UNTPTR
	SUB	#USLTBL+1, R5	; OFFSET INTO USLTBL
	MOV	R5, UNTFLG	; SAVE SO FIRST UNIT KNOWN
	JSR	PC, LDUNT	; LOAD A UNIT
	RESTR	R5
	RTS	PC
4$:	JSR	R5, CYCDEV	; ANY MORE DEVICES?
	 BR	.-4		; SKIP PURGED DEVICES.
	 BR	UNTPTR+4	; YES - DO ALL UNITS
	ADD	#2, 2(SP)	; FORCE SKIP RETURN
	BR	UNTPTR+4	; AND LOAD WITH FIRST UNIT

6$:	RESTR	R5
	ADD	#2, (SP)
	RTS	PC
; CYCDEV - CYCLE THROUGH ALL DEVICE CODES ATTACHED.
; JSR	R5, CYCDEV
;	RETURNS WITH PURGED DEVICE.
;	RETURNS WITH ANOTHER DEVICE
;	RETURNS IF CYCLED BACK TO BEGINNING

CYCDVI:	MOV	#CYCTBL, CYCDVP	; FORCE AN INIT TO FIRST ENTRY
CYCDEV:	SAVE	R4
	MOV	(PC)+, R4	; GET POINTER
CYCDVP:	CYCTBL
	BNE	CYCSKP	; NOT CYCLED
CYCRES:	 MOV	#CYCTBL, R4
	TST	(R5)+		; DO RECYCLED RETURN
CYCSKP: MOV	R4, (PC)+
CURCYP: CYCTBL
	MOV	(R4), R1	; LOAD R1
	MOV	R1, RXCSV	; LOAD THE DEV REG PTR
	 BPL	.+4		; IS IT PURGED?
	 TST	(R5)+	; NO - BUMP PAST PURGED RETURN
	MOV	(R4)+, R2	; LOAD RXDB PTR REG
	ADD	#2, R2		; AND SET IT UP
	MOV	R2, RXDBV
; CHECK FOR ANOTHER DEVICE ENTRY.
	TST	@R4	; ANOTHER ENTRY BEFORE RECYCLE?
	BNE	2$
	 CLR	CYCDVP	; WRAP IT AROUND NEXT TIME
	 BR	.+6
2$:	MOV	R4, CYCDVP	; UPDATE POINTER

; GET OFFSET FOR ERROR STATUS INCREMENT
	SUB	#CYCTBL+2, R4	; OFFSET TO TABLE BEGINNING.
	ASL	R4		; 4 * DEVICE ENTRY #
	MOV	R4, (PC)+	; SAVE IT FOR ERRORS.
NUMOFS:	0
	ASR	R4
; GET POINTER TO INTERRUPT FLAG
	ADD	#INTFG0, R4	; GET PTR TO INTERRUPT FLAG
	MOV	R4, (PC)+
INTPTP:	INTFG0	; **** MODIFIED ****
	CLR	INTPTR
	RESTR	R4
	RTS	R5
; SUBROUTINES TO GET TRACK AND SECTOR

GETTRK:	JSR	PC, GETUNT
2$:	PRINT	<TRACK: >
	JSR	PC, OCTIN	; GET TRACK
	BCC	2$
	CMP	R0, #114	; TRACK < 77?
	BGT	2$
	MOV	R0, TRACK	; STORE TRACK
	RTS	PC

; GET UNIT AND LOAD UNIT: IF VALID

GETUNT:	PRINT	<UNIT:>
	JSR	PC, OCTIN
	BCC	GETUNX
LDUNT:	CMP	R0, #4
	BGE	GETUNT
	MOV	#" 0, PTKSTR+6	; INSERT UNIT 0.
	BISB	R0,   PTKSTR+7	; AND SET TO ACTUAL UNIT.
	MOV	R0, R4
	ASL	R0
	ASL	R0
	ASL	R0
	ASL	R0
	MOV	R0, UNIT
	SEC	; SET CARRY
GETUNX:	RTS	PC


; GET SECTOR SUBROUTINE.

GETSCT:	PRINT	<SECTOR: >
	JSR	PC, OCTIN	; GET SECTOR
	BCC	GETSCT		; DEMAND SECTOR
	TST	R0		; SECTOR > 0?
	BLE	GETSCT
	CMP	R0, #33		; SECTOR < 27?
	BGE	GETSCT
	MOV	R0, SECTOR	; STORE SECTOR
	RTS	PC
; EXECUTE FOLLOWING COMMAND AND LOAD SECTOR AND TRACK

EXTKSC:	JSR	PC, WTDNS	; WAIT IF NOT SET.
	MOV	MRETCT, EXRTCT	; SET RETRY COUNT FOR 1 RETRY.
	MOV	#TKSCL, R0	; SAVE UNIT/TRACK/SECTOR HISTORY
	MOV	10(R0), 14(R0)	; 2 BACK TRACK
	MOV	(R0), 6(R0)	; PREVIOUS UNIT
	MOV	PTKSTR+6, (R0)+	; CURRENT UNIT (ASCII " X").
	MOV	(R0), 6(R0)	; PREVIOUS TRACK
	MOV	TRACK, (R0)+	; CURRENT TRACK
	MOV	(R0), 6(R0)	; PREVIOUS SECTOR
	MOV	SECTOR, (R0)	; CURRENT SECTOR

EXTKLD:	CLR	CKNZFG		; ENABLE NZ ERROR PRINT.
	CLR	ERRFLG		; SET BY ERROR FOR RETRY
	MOV	(R5), R0	; GET COMMAND
	ADD	UNIT, R0	; INSERT UNIT #
	CLR	@INTPTP		; INIT INTERRUPT FLAG
	TST	INTENF		; INTERRUPT ENABLED?
	 BEQ	20$
	DEC	@INTPTP		; SET FOR ONLY 1 INTERRUPT
	BIT	#1, INTENF
	 BEQ	20$		; DO IT LATER
	  BIS	#100, R0	; SET INT ENABLED IN COMMAND WORD
20$:	MOV	R0, (R1)	; LOAD THE COMMAND
1$:	BITB	#240, (R1)	; TEST FOR TRREQ BUT NOT INT-ENB
	BEQ	1$		; IF NOT DONE CHECK AGAIN
	BMI	2$		; TRREQ RECEIVED?
	JSR	PC, UNEXDN	; UNEXPECTEDLY DONE! (40 SET)

2$:	MOV	SECTOR, (R2)	;*** SEND SECTOR ***
3$:	BITB	#240, (R1)	; TEST FOR TRREQ, DONE ONLY.
	BEQ	3$		; IF NOT DONE CHECK AGAIN
	BMI	4$		; TRREQ RECEIVED?
	JSR	PC, UNEXDN	; UNEXPECTEDLY DONE

4$:	MOV	TRACK, (R2)	;*** SEND TRACK ***
; ALLOW DOING BIS #INTEN TO ENABLE INTERRUPT.
	MOV	INTENF, R0	; GET ENABLE TYPE, DELAY
	 BEQ	30$		; NOT ENABLED.
	DEC	R0
	 BGT	.-2		; DELAY FOR AWHILE
	BIT	#2, INTENF	; SHOULD IT BE BIS HERE
	 BEQ	30$
	  BIS	 #100, (R1)	; ENABLE THE INTERRUPT.
30$:	JSR	PC, DONECK	; WAIT AND TYPE IF ERROR.
	TST	ERRFLG		; WAS AN ERROR DETECTED?
	BEQ	EXTKXT		; NO - JUST EXIT.

	INC	(PC)+		; RETRY?
EXRTCT:	0	
	BPL	EXTKXT		; NO - COUNT EXCEDED.
	INC	ERRPFG		; ENABLE PRINT FOR MESSAGE.
; DO AN EMPTY BUFFER IF ERROR ON READ BEFORE RETRY
	CMP	(R5), #7	; WAS IT A READ?
	 BNE	4$		; NO - MUST BE SCAN OR WRITE.
	  JSR	R5, EMPBUF	; DO A DATA CHECK.
	   "XE			; "EXTRA EMPTY""
4$:	PRINT	 < RETRY >
	CLR	ERRPFG
	BR	EXTKLD

EXTKXT:	TST	(R5)+	; BUMP RETURN
	RTS	R5

; KEEP A LAST TRACK/ SECTOR HISTORY

TKSCL:	" X,	0,	0	; UNIT, TRACK, SECTOR
	" X,	0,	0	; PREVIOUS UNIT,TRACK, SECTOR
	0			; 2 BACK TRACK
; UNEXDN - UNEXPECTED DONE DURING RD/WRT 

UNEXDN:	INC	ERRPFG	; FORCE OUTPUT IF CTRL P INHIBIT
	PRINT	< UNEXPECTED DONE DURING RD/WRT >
	MOV	#175, R0		; BUMP STATUS COUNTS
	JSR	PC, INCSTT
	BIT	#4, (R2)		; WAS IT AN INIT?
	 BEQ	2$
	  PRINT	<?PWR FAIL?>
2$:	JSR	PC, PTDEV
	CLR	ERRPFG
	RTS	PC
; FILBUF - FILLS THE FLOPPY DATA BUFFER WITH SPECIFIED DATA
; BYTE 0	=SECTOR
; BYTE 1	=TRACK
; BYTE 2-7	=1'S
; BYTE 10 - 17	=0'S
; BYTE 20, 21	=INIT VAL FOR GRNDNO
; BYTE 22 - 177	=RANDOM # SEQUENCE

	.SBTTL		FILL - EMPTY BUFFER SUBS.

FILBUF:	MOV	(R5)+, TXTID+4	; LOAD ID STRING
	SAVE	R5
	JSR	PC, WTDNS	; WAIT FOR DONE
	MOV	#1, R0	; EMPTY BUF + GO.
	JSR	PC, LDCMD	; DO ACTUAL LOAD.
	MOV	SECTOR, R0
	JSR	PC, RXDBLI	; LOAD SECTOR BYTE AND INIT CNT
	MOV	TRACK, R0
	JSR	PC, RXDBL	; LOAD TRACK
	MOV	#-6, R5
	MOV	#-1, R0		; 6 BYTES OF 1'S
	JSR	PC, RXDBL
	 BLT	.-4
	MOV	#-10, R5
	CLR	R0
	JSR	PC, RXDBL	; 10 BYTES OF 0'S
	 BLT	.-4
; LOAD REMAINDER WITH RANDOM #
	MOV	#-160, R5	; BYTE COUNTER
	MOV	X, R0	; GENERATOR STATE.
	JSR	PC, RXDBL
	SWAB	R0	; FULL WORD
	JSR	PC, RXDBL
	JSR	PC, GTRAND	; GET NEXT SEQUENTIAL #
	MOV	R4, RTP4	; TEMPORARY

20$:	MOV	R3, R0
	JSR	PC, RXDBL
	SWAB	R0
	JSR	PC, RXDBL
	BGE	FILBFN
	ADD	R0, RTP4	; ADD SWAPPED R3
	MOV	R4, R0
	MOV	RTP4, R4
	JSR	PC, RXDBL
	SWAB	R0
	JSR	PC, RXDBL
	ADD	R0, R3
	BR	20$

FILBFN:	JSR	PC, WTDNS
	RESTR	R5
	RTS	R5
; EMPTY FLOPPY SECTOR BUFFER AND DO DATA CHECK
; COMPARES DATA AGAINST FILBUF DATA FORMAT AND
; PRINTS DETECTED ERRORS.

; JSR	R5, EMPBUF
;  "ID	; 2 CHAR ID CODE.

EMPBUF:	MOV	(R5)+, TXTID+4	; LOAD ID STRING.
	SAVE	R5
	JSR	PC, WTDNS
	MOV	#3, R0		; EMPTY BUF + GO
	JSR	PC, LDCMD
	MOV	SECTOR, R3
	JSR	PC, RXDBI	; INIT COUNTS.
	MOV	TRACK, R3
	JSR	PC, RXDBC
	MOV	#-6, R5		; 6 REPETITIONS.
	MOV	#-1, R3
	JSR	PC, RXDBC	; 6 -1 BYTES.
	 BLT	.-4
	MOV	#-10, R5
	CLR	R3
	JSR	PC, RXDBC	; 10 0 BYTES
	BLT	.-4

; CHECK REMAINDER AGAINST RANDOM # SEQUENCE.
	MOV	X, (PC)+	; SAVE X FOR SEQUENCE CONTINUITY
XSAV:	0
	JSR	PC, RXDBR	; READ THE BYTE
	MOVB	R0, X
	JSR	PC, RXDBR
	MOVB	R0, X+1		; INIT RANDOM # GEN.
	ADD	#2, BYTCNT	; UPDATE TOTAL COUNT.
	MOV	#-156, R5	; BYTE COUNTER
	JSR	PC, GTRAND	; GET RANDOM #
	MOV	R4, (PC)+
RTP4:	0

	MOV	R3, (PC)+
RTP3:	0
20$:	JSR	PC, RXDBC	; CHECK BYTE
	SWAB	R3
	JSR	PC, RXDBC
	 BGE	EMPBFN
	MOV	RTP4, R4
	ADD	R3, RTP4
	MOV	R4, R3
	JSR	PC, RXDBC
	SWAB	R3
	JSR	PC, RXDBC
	ADD	R3, RTP3
	MOV	RTP3, R3
	BR	20$

EMPBFN:	MOV	XSAV, X		; RESTORE RANDOM #
	CMP	EMPERC, MAXPNT
	BLE	2$
	INC	ERRPFG	; ENSURE PRINTED 
	 PRNTIT	< ERRS=>, EMPERC
	PCRLF
	CLR	ERRPFG
2$:	JSR	PC, WTDNS	; INSURE DONE.
	RESTR	R5
	RTS	R5
; LDCMD - LOAD THE COMMAND IN R0 WITH UNIT AND INTERRUPT ENB.
; JSR	PC, LDCMD

LDCMD:	CLR	ERRFLG	; SET BY ERROR FOR RETRY
	ADD	UNIT, R0	; INSERT UNIT (00, 20, 40, 60)
	CLR	@INTPTP
	TST	INTENF
	 BEQ	2$
	  DEC	@INTPTP	; SET TO 1 INTERRUPT EXPECTED.
	  BIS	#100, R0
2$:	MOV	R0, (R1)	; LOAD IT.
	RTS	PC



; RXDBL - LOAD A BYTE INTO RXDB.
; WAITS FOR TRANSFER REQUEST
; BEFORE TRANSFERING.

RXDBLI:	CLR	BYTCNT		; INIT BYTE TRANSFER COUNTER.
	JSR	PC, DISCHK
	BIT	#100040, (R1)	; SHOULDN'T BE DONE
	BNE	RXDBE		; ERROR OR DONE, PRINT IT.
	INC	RXDBLX+2	; TIMEOUT COUNTER
	 BEQ	TIMEOT
RXDBL:	TSTB	(R1)
	BPL	RXDBLI+4	; KEEP WAITING.

	MOVB	R0, (R2)	; LOAD DATA.
RXDBLX:	CLR	(PC)+		; TIME OUT CNTR.
	 0
	INC	BYTCNT
	INC	R5
	RTS	PC


; TIME - OUT FOR TRNREQ 

TIMEOT:	INC	ERRPFG
	PRINT	< TRN-TIME-OUT >
	MOV	#40000, (R1)
	JSR	PC, WTDNS	; FORCE AN INIT AND PROCEEDE

RXDBE:	INC	ERRPFG
	MOV	R0, -(SP)	; SAVE IT
	PRNTIT	<NO TRREQ @ BYTE # >, BYTCNT
	PRNTIT	<RXCS=>, (R1)	; PRINT RXCS VAL
	JSR	PC, PTDEV	; PRINT DEVICE #
	PRNTIT	<RXDB=>, (R2)	; AND RXDB VAL.
	MOV	#176, R0	; STATUS 176 = TIMEOT ON TRREQ
	 JSR PC, INCSTT
	MOV	(SP)+, R0	; RESTORE R0
	PCRLF
	CLR	ERRPFG	; DISABLE PRINTOUT IF CTRL P
	CLR	R5		; EASY ABORT OUT OF FILL/EMPTY
	BR	RXDBLX



; RXDBR - READ A BYTE FROM FLOPPY RXDB

RXDBRE:	JSR	PC, DISCHK
	BIT	#100040, (R1)	; DONE OR ERROR FLAG SET?
	BNE	RXDBE		; YES: ERROR
	INC	RXDBRT		; TIME-OUT COUNTER.
	 BEQ	TIMEOT		; TIME-OUT ERROR.

RXDBR:	TSTB	(R1)
	BPL	RXDBRE

	MOVB	(R2), R0	; READ THE BYTE.
	CLR	(PC)+
RXDBRT:	 0
	RTS	PC

; RXDBC - GET AND COMPARE A DATA BYTE.

RXDBI:	CLR	(PC)+	; INIT ERROR COUNT THIS SECTOR
EMPERC:	0
	CLR	BYTCNT
RXDBCL:	JSR	PC, RXDBR	; READ A BYTE INTO R0
	BR	RXDBCC		; AND COMPARE IT.

RXDBC:	TSTB	(R1)		; DO SHORT WAIT
	BPL	RXDBCL	; DO FULL CHECK IF BUSY.
	MOVB	(R2), R0	; GET DATA
RXDBCC:	CMPB	R0, R3	; CHECK THE BYTE
	BEQ	RXDBX
	CMP	EMPERC, MAXPNT	; MAX # ERRORS PRINTED
	BGT	RXDBER
	MOV	R0, -(SP)	; SAVE READ BYTE VAL
	INC	ERRPFG		; ENABLE PRINTOUT IF CTRL P
	TST	EMPERC
	BGT	RXDBCB
TXTID:	PRINT	<SE @ LOC >
	MOV	2(SP), R0	; CALL ADDR.
	JSR	PC, OCTPNT
	JSR	PC, PTKSEC	; PRINT TRACK AND SECTOR

RXDBCB:	PRINT	<BYT# >
	MOV	BYTCNT, R0
	JSR	PC, OCTPNT
	PRINT	<RD: >
	MOV	(SP)+, R0
	JSR	PC, PNTBYT
	PRINT	<EXP: >
	MOV	R3, R0
	JSR	PC, PNTBYT
	PCRLF
RXDBER:	JSR	R5, INCCNT	; BUMP CUMULATIVE ERR CNT.
	  DATERC
	INC	EMPERC
	CLR	ERRPFG
RXDBX:	INC	(PC)+
BYTCNT:	0
	INC	R5
	RTS	PC
; GTNTKS - GET NEXT TRACK AND SECTOR RANDOMLY.

GTNTKS:	MOV	R4, R3		; MULT X BY 77/65536
	MOV	TRKLAS, R0
	INC	R0		; GET IN CURRENT TRACK RANGE
	MOV	R0, 4$
	JSR	R5, MULT
4$:	 77.
	CMP	R3, TRKFST	; BEFORE FIRST TRACK?
	 BGE	.+6
	  MOV	 TRKFST, R3	; YES - OVERRRIDE IT
	MOV	R3, TRACK	; STORE NEW TRACK
; CALCULATE NEW SECTOR
	MOV	R4, R3		; MULT REMAINDER BY 26/65536
	JSR	R5, MULT
	 26.
	INC	R3		; SECTORS GO FROM 1-26
	MOV	R3, SECTOR
8$:	MOV	R4, R3	; GET 16 BITS RANDOM
	JSR	R5, MULT
	 4
	MOVB	USLTBL(R3), R0
	BMI	8$
	CMP	R0, #4
	BGE	8$
	JSR	PC, LDUNT	; LOAD UNIT AND SETUP PRINT
	RTS	PC

; PRINT TRACK AND SECTOR

PTKSEC:	PCRLF
PTKSCZ:	JSR	PC, PTDEV	; PRINT DEVICE IF CYCLEING
PTKSTR:	PRINT	<UN X TRK/SEC: >
	MOV	TRACK, R0
	JSR	PC, OCTPNT	; PRINT OLD TRACK
	PRINT	</>
	MOV	SECTOR, R0
	JSR	PC, OCTPNT	; PRINT OLD SECTOR
	RTS	PC
.SBTTL		WAIT FOR DONE, CHECK ERROR STATUS

; WAIT FOR DONE FLAG SET

WTDNL:	JSR	PC, DISCHK
	JSR	PC, CHKTRQ
WTDNS:	MOV	(R1), R0	; GET A STATUS SNAPSHOT
	MOV	R0, (PC)+
	 0
	BIT	#100040, R0
	 BEQ	WTDNL
	 BMI	ESTAT	; ERROR-DO DONECK
	TST	@INTPTP
	 BNE	ESTAT	; INTERRUPT ERROR
	MOV	(R2), (PC)+	; SAVE RXES STATUS
WRXES:	 0
	JSR	PC, CKDEFS	; CHECK DEFINITIVE ERROR STATUS.
	RTS	PC

; DONECK SUBROUTINE--
; WAITS IN LOOP CHECKING KEYBOARD AND DONE FLAG
; THEN UPDATES STATISTICS (PRINTING THEM IF ERROR DETECTED)

DONECL:	JSR	PC, DISCHK
	JSR	PC, CHKTRQ
DONECK:	BIT	#100040, (R1)
	 BEQ	DONECL
  ; DONE--NOW CHECK ERROR FLAG
	 BMI	ESTAT	; ERROR DETECTED

	MOV	(R2), WRXES	; LOAD DELETED DATA FLAG
NOERR:	TST	@INTPTP
	 BNE	ESTAT
	JSR	R5, INCCNT	; INCREMENT  # GOOD TRANSFERS.
	 TRNCTR
	JSR	PC, CKDEFS   ; CHECK DEFINITIVE ERROR STATUS = 0.
	RTS	PC
  ; ERROR DETECTED
ESTAT:	JSR	R5, INCCNT	; UPDATE ERROR COUNT
	 ERRCT
	INC	ERRPFG	; ENABLE PRINT DURING CTRL P
	JSR	PC, PTKSEC	; PRINT TRACK/SECTOR
	MOV	TXTID+4, .+12
	PRNTIT	<   RXCS=>, (R1)	; PRINT RXCS STATUS.
	MOV	R0, (PC)+	; SAVE ERROR STATUS AS FLAG.
ERRFLG:	0
	PRNTIT	< RXDB=>, (R2)	; PRINT ERROR REGISTER
	MOV	@INTPTP, R0	; GET INTERRUPT STATUS.
	 BEQ	CUMSTT		; INTERRUPT STUFF OK
	PRINT	<INTERRUPT ERROR:>
	JSR	PC, OCTPNT
	 MOV	#1, R0		; STATUS = 1 FOR INTERRUPT ERR.
	JSR	PC, INCSTT
	CLR	@INTPTP		; RESET ENTRY POINT OFFSET
CUMSTT:	PRINT	< #BAD=>
	JSR	R5, PNTCWO	; PRINT A DOUBLE PREC COUNTER
	 ERRCT
	PRINT	<#GOOD=>
	JSR	R5, PNTCWO	; # GOOD TRANSFERS.
	 TRNCTR
	PRINT	< DATA ERRORS:>
	JSR	R5, PNTCWO
	 DATERC
	MOV	#17, (R1)	; "READ ERROR REG." FCN.
	TST	(R1)
	 BEQ	.-2
	 BPL	1$
	  PRINT	<"<15><12>"STUCK ERR FLAG >
1$:	MOV	(R2), R0	; PRINT RXDB
	PRINT	<ERREG: >
	JSR	PC, OCTPNT	;   (ERROR REGISTER)
	TST	R0		; DONT INC STATUS COUNT IF 0
	 BEQ	2$
	  JSR	PC, INCSTT	; BUMP STATUS COUNT 
2$:	TST	(R1)
	 BMI	3$
	CMP	#150, R0	; DO INIT IF TRACK SEEK ERROR
	 BNE	10$
3$:	NOP
	 MOV	#40000, (R1)
	 JSR	PC, PTKLAS	; PRINT PREVIOUS TRACK HISTORY
	 PRNTIT	< PREVTRK=>, TKSCL+14 ; 2 BACK TRACK HISTORY
	  NOP			; IS IT WORKING?
	TST	(R1)		; DID ERROR FLAG GO AWAY?
	  BPL	6$		; YES - STILL A CHANCE
	   TST	CYCTBL+2	; DON'T PURGE IF ONLY ONE ENTRY
	    BEQ	.+6
	     BIC #177400, @CURCYP ; NO - PURGE IT
	   JMP	RSTTST		; RESTART TEST AT BEGINNING
6$:	 JSR	PC, WTDNS
10$:	INC	CKNZFG		; SUPPRESS NZ ERROR PRINT FOR
				; THIS ERROR.
	CLR	ERRPFG
	RTS	PC



; ROUTINE TO CHECK FOR NONZERO ERROR STATUS.

CKDEFS:	TST	(PC)+		; ALREADY PRINTED?
CKNZFG:	0
	 BNE	DNTMCT-2		; YES
	MOV	#17, (R1)  ; CHECK THAT DEFINITIVE STATUS IS 0
	CLR	R0	; ALLOW TIMEOUT
	
1$:	INC	R0
	 BEQ	4$
	TSTB	(R1)	; WAIT FOR DONE.
	 BEQ	1$

	MOV	(R2), R0	; GET DEFINITIVE STATUS
	 BEQ	DNTMCT-2		; ERROR ONLY IF NONZERO.

4$:	INC	ERRPFG	; ENABLE PRINTOUT
	PRINT	<"<15><12>"NZ ERROR STATUS =>
	JSR	PC, OCTPNT
	JSR	PC, LOOKST	; LOOK UP STATUS POINTER
	 INC	(R4)
	JSR	PC, PTKSCZ	; CURRENT DEVICE,UNIT,TRACK,SECT
PTKLAS:	MOV	TKSCL+6, 12$+14	; LOAD UNIT DESIGNATOR
12$:	PRNTIT	< FROM UN X T/S >, TKSCL+10 ; PRINT LAST TRK VAL
	PRNTIT	</>, TKSCL+12	; AND SECTOR
	CLR	(PC)+
DNTMCT:	0
	RTS	PC
; PTDEV - PRINT CURRENT DEVICE DEV REG

PTDEV:	TST	CYCTBL+2	; CYCLEING ENABLED?
	BEQ	10$
	PRINT	<DV=>
	MOV	RXCSV, R0
	 BMI	2$
	  PRINT	< **PURGED** >
2$:	BIC	#177000, R0
	JSR	PC, OCTPNT
10$:	RTS	PC


; CHKTRQ- CHECK FOR TRANSFER REQUEST STILL UP
; PRINT "TRREQ @" <WTDNS CALL ADDRESS>

CHKTRQ:	TSTB	(R1)	;TRREQ TRUE..
	BPL	CHKTRC
	INC	ERRPFG	; ENABLE PRINT
	JSR	PC, PTDEV
	PRINT	< TRREQ @ >
	MOV	-2(SP), R0
	JSR	PC,OCTPNT
	MOV	(R2),(R2)	; TRY TO CLEAR
CHKTRC:	INC	DNTMCT		; DONE TIMEOUT COUNTER
	BNE	CHKTRX

	INC	ERRPFG
	JSR	PC, PTDEV	; PRINT DEVICE THAT TIMED OUT.
	PRINT	<DONE-TIME-OUT>
	MOV	#40000, (R1)
	MOV	#177, R0	; 177 = TIME OUT STATUS.
	JSR	PC, INCSTT
CHKTRX:	RTS	PC
; FLOPPY READ STATUS PRINTOUT ON "STATUS" COMMAND

FRSTTU:	JSR	PC, PSTAT
	JMP	FRDTST

; RESTTU - RESET AND PRINT STATUS.

RESTTU:	JSR	PC, PSTAT
	PRINT	<RESET ALL?>
	JSR	PC, GNXCHR	; TYPE "Y" FOR TOTAL RESET
	CMP	R0, #'Y	; DO ALL?
	 BEQ	RXSTTU	; YES
	JSR	PC, INTKSC	; INSURE DRIVE 0

RNXDV:	PCRLF
	JSR	PC, PTDEV	; ASK THE DEVICE
	 PRINT	< RESET:>
	 JSR	PC, GNXCHR
	 CMP	R0, #'Y		; RESET THIS ONE?
	  BNE	RNXTDV		; NO - TRY NEXT SYSTEM

	MOV	NUMOFS, R5	; GET OFFSET THIS DEVICE
	CLR	ERRCT(R5)
	CLR	ERRCT+2(R5)
	CLR	TRNCTR(R5)
	CLR	TRNCTR+2(R5)
	CLR	DATERC(R5)
	CLR	DATERC+2(R5)
	MOV	@#LOOKTB, R0	; SET FOR FIRST STATUS
	JSR	PC, LOOKST	; GET POINTER TO DRIVE 0 STT
	MOV	#60, R0		; CLR ALL STATUS WORDS THIS SYS.
2$:	CLR	(R4)+
	DEC	R0
	BGT	2$
RNXTDV:	JSR	R5, CYCDEV
	 BR	RNXDV	; PURGED
	 BR	RNXDV	; OK, VALID SYS
	BR	FRSTTU+4

RXSTTU:	MOV	#ERRCT, R5	; CLEAR ERRCT, TRNCTR, DATERC
	CLR	(R5)+
	CMP	#ENDCLR, R5	; AT END?
	 BGT	.-6
	MOV	#STTTBL, R5
	CLR	(R5)+
	CMP	#DATBUF, R5	; AT END OF STATUS BUFFER YET?
	 BGT	.-6
	BR	FRSTTU+4
.SBTTL	DUMP CIRCULAR STATUS TEXT BUFFER
; DUMPC  DUMP CIRCULAR BUFFER

DUMPC:	INC	LDCBFG		; DISABLE LOADING BUFFER
	TST	OUTXT-2		; CHECK FOR WRAP AROUND
	BNE	4$
	MOV	PTRCBF, R1	; GET LOAD POINTER
	INC	R1		; BUMP PAST TERMINATOR
	JSR	PC, PRINTS	; PRINT THE MONSTROSITY
4$:	MOV	BEGCBF, R1
	JSR	PC, PRINTS
	CLR	LSTCHR		; ENABLE PRINT IF CTRL O
6$:	PCRLF
	PRINT	<RESET DUMP BUF?>
	JSR	PC, GETCHR-4	; THROW AWAY PREVIOUS CHAR.
	CMPB	R0, #'Y
	BNE	10$
	MOV	#-1, OUTXT-2	; RESET WRAP AROUND FLAG
	MOV	BEGCBF, PTRCBF
	CLR	@PTRCBF		; LOAD TERMINATOR
	BR	14$

10$:	CMPB	R0, #'N		; FORCE A "N BEFORE NO RESET.
	 BNE	6$
14$:	CLR	LDCBFG
	JMP	FRDTST


; PRINT TOTAL STATUS FOR ALL DEVICES WITH STATISTICS BY DRIVE

PSTAT:	SAVE	R5
	JSR	PC, CYCINT	; INIT FOR FIRST DEVICE
PSTATL:	PCRLF
	TST	(PC)+		; 0 FOR FIRST DRIVE EACH DEVICE
UNTFLG:	0
	BNE	PSTATI	;DON'T PRINT HEADER FOR ADDITIONAL UNITS

	JSR	PC, PTDEV	; "DEV=170" .....
	CALL	DEVSTT		; PRINT CUMULATIVE DEVICE STATUS
	BR	PSTATJ

PSTATI:	PRINT	<                    >
PSTATJ:	MOV	PTKSTR+6, 10$+6
10$:	PRINT	<UN X >
; CHECK STATUS ACCUMULATION BY DRIVE AND TYPE.
	MOV	#LOOKTB, R5	; TABLE OFF DEFINITIVE CODES

STTPLP:	MOVB	(R5)+, R0
	BIC	#177400, R0	; CLEAR SIGN EXTENSION
	JSR	PC, LOOKST	; LOOK UP STATUS CODE IN R0 AND
				; GET POINTER TO COUNTS IN R4
	TST	R0		; 0 => OTHER ACCUM
	BEQ	STTPOT		; PRINT OTHER STATUS.
	MOV	(R4), DECBUF+2	;LOAD BUF FOR STATUS COUNT PRINT
	BEQ	STTPLP		; ZERO COUNTS, CHECK NEXT.
	PRINT	< ST=>
	JSR	PC, OCTPNT
	PRINT	<#=>
	JSR	R5, PNTCNT	; PRINT DEC # OF STATUS ERRS.
	 DECBUF		; PRINT IN FORM "ST=100 #=XXXX"
	BR	STTPLP	; DO NEXT

STTPOT:	MOV	(R4), DECBUF+2
	BEQ	STTLPX
	PRINT	< OTHER #=>
	JSR	R5, PNTCNT
	 DECBUF
STTLPX:	JSR	PC, CYCUNT	; ANOTHER UNIT OR DEVICE?
	  BR	PSTATL	; YES - DO IT
	RESTR	R5
	PCRLF
	RTS	PC

; DEVSTT - DEVICE STATUS COUNTS

DEVSTT:	PRINT	< GOOD=>
	JSR	R5, PNTCWO	; # GOOD TRANSFERS
	  TRNCTR
	PRINT	< BAD=>
	JSR	R5, PNTCWO	; # ERROR TRANSFERS.
	  ERRCT
	PRINT	< B-DATA=>
	JSR	R5, PNTCWO	; # DATA ERROR TRANSFERS.
	  DATERC
	RTS	PC
; LOOK UP A PARTICULAR STATUS VAL IN R0 IN LOOKTB AND RETURN
;  POINTER TO COUNT  FOR THIS DEVICE AND UNIT IN R4.

LOOKTB:	.BYTE	40,  50,  70,  100,   110, 120, 140, 150
	.BYTE	160, 170, 200, 210,   177, 176,   1,   0

DECBUF:	0, 0	; TEMP BUF FOR SINGLE PRECISION DECIMAL PRINTOUT

LOOKST:	SAVE	R3
	CLR	R3		; OFFSET INTO LOOKTB

LOOKSL:	TSTB	LOOKTB(R3)	; END OF TABLE = 0
	BEQ	LOOKFN		; LUMP ALL NON MATCHES IN 0 ENT
	CMPB	LOOKTB(R3), R0	; MATCH?
	BEQ	LOOKFN
	INC	R3
	BR	LOOKSL		; DO NEXT ENTRY

LOOKFN:	MOV	NUMOFS, R4	; 0, 4, 10, 14 BY DEVICE ENT #
	ASL	R4
	ADD	NUMOFS, R4	; 0, 14, 30, 44, 60
	ASL	R4
	ASL	R4		; 0, 60, 140, 220, 300
	ADD	R3, R4		; BYTE OFFSET BY STT TYPE 0-17
	ASL	R4		; 0, 140, 300 + 0,2,4...36
	MOV	UNIT, R3	; 0, 20, 40
	ASL	R3		; 0, 40, 100, 140 <3 DRIVE MAX>
	ADD	R3, R4
	ADD	#STTTBL, R4
	RESTR	R3
	RTS	PC

; INCSTT INCREMENT COUNT FOR STATUS VALUE IN R0.

INCSTT:	JSR	PC, LOOKST
	INC	(R4)
PURGCK: CMP	(R4), MAXERR
	BLE	2$
	MOV	#40000, (R1)	;TRY TO INIT IT.
	CLR	(PC)+		; INIT TIMEOUT COUNTER.
10$:	  0

11$:	TST	(R1)		; INIT FINISHED?
	 BGT	14$
	MOV	(SP), (SP)	; INCREASE LOOP TIME.
	INC	10$
	 BNE	11$

14$:	TST	@#CYCTBL+2		; DON'T PURGE IF ONLY 1
	 BEQ	 2$			; DEVICE ENTERED.
	BIC	#177400, @CURCYP	;PURGE THIS DEVICE
					;BY CLEARING HIGH BYTE.
	INC	ERRPFG			; ENSURE PURGE PRINTED.
	JSR	PC, PTDEV
	PRINT	<* PURGED ****"<15><12>">
	JSR	R5, CYCDEV	; DO NEXT SYSTEM
	 BR	.-4		; PURGED.
	 NOP
2$:	RTS	PC

; INCNT - INCREMENT A DOUBLE PRECISION COUNTER

INCCNT:	SAVE	R4
	MOV	(R5)+, R4
	ADD	NUMOFS, R4	; OFFSET FOR THIS DEVICE.
	INC	2(R4)
	BNE	.+4
	INC	(R4)
	RESTR	R4
	RTS	R5
; PNTCNT - PRINT A DOUBLE PRECISION COUNTER.

PNTCWO:	SAVE	R4	; PRINT AT POINTER WITH OFFSET
	MOV	(R5)+, R4
	ADD	NUMOFS, R4
	BR	PNTCNT+4

PNTCNT:	SAVE	R4	; PRINT COUNT AT POINTER.
	MOV	(R5)+, R4
	SAVE	R3, R2, R1, R0
	MOV	#PNTTMP, R3	; POINTER TO TEMP VEC
	MOV	(R4)+, (R3)
	MOV	(R4), 2(R3)	; MOV COUNT INTO TEMP STORAGE
	SAVE	R5
	MOV	#DECTBL, R5	; DECIMAL EQUIV TABLE
	MOV	#10., R2	; DIGIT COUNTER.
	CLR	R1	; LEADING DIGIT FLAG.

NXDGLP:	CLR	R4	; DIGIT COUNTER
CMPLP:	CMP	(R5), (R3)	; HIGH 16 BITS
	BHI	NXTDIG
	BLO	SUBINC	; SUBTRACT AND BUMP DIGIT CTR
	CMP	2(R5), 2(R3)	; LOW ORDER
	BHI	NXTDIG
SUBINC:	CLC
	SUB	2(R5), 2(R3)	; LOW ORDER
	SBC	(R3)		; BORROW IF NECESSARY
	SUB	(R5), (R3)
	INC	R4
	BR	CMPLP

NXTDIG:	TST	R4
	JSR	PC, DIGOUT
	ADD	#4, R5	; NEXT PAIR
	TST	2(R5)
	BNE	NXDGLP

	RESTR	R5
	RESTR	R4, R3, R2, R1, R0
	RTS	R5

PNTTMP:	0, 0
DECTBL:	35632,	145000	; 10**9 = 7,346,545,000
	2765,	160400	; 10**8 =   575,360,400
	230,	113200	; 10**7 =    46,113,200
	17,	041100	; 10**6 =     3,641,100
	1,	103240	; 10**5
	0,	23420	; 10**4
	0,	1750	; 10**3
	0,	144	; 10**2
	0,	12	; 10
	0,	1	; 1
	0,	0

; GET A RANDOM # USING FOLLOWING SEQUENTIAL ALGORITHM
; X(N+1)=31415.*X(N)+6639. TAKEN MOD 2**16

GTRAND:	MOV	(PC)+, R3	; X(N) * 
X:	 123456
	JSR	R5, MULT
	 31415.
	ADD	#6639., R4	; ADDITIVE OFFSET
	ADD	(PC)+, R4	; VARIABLE KEY FOR ACCEPT
RANKEY:	0
	MOV	R4, X
	RTS	PC


; MULTIPLY SUBROUTINE--
; CALL USING JSR  R5, MULT
;		(CONST)
; RESULT OF R3 X CONST GOES TO R3,R4 (MSW IN R3)

MULT:	SAVE	R1, R2
	MOV	#-20, R1	; GO THRU SHIFT LOOP 16 TIMES
	MOV	(R5)+, R2	; STORE CONST IN R2 (SPEED)
	CLR	R4
1$:	ROL	R4		; ROTATE R3, R4 LEFT
	ROL	R3
	BCC	.+6		; CHECK MULTIPLIER FOR A ONE
	ADD	 R2, R4		; ONE FOUND--ADD MULTIPLICAND
	ADC	 R3
	INC	R1
	 BNE	1$		; DONE WITH MULTIPLY?
	RESTR	R1, R2		; YEP, RESTORE REGS.
	RTS	R5		; AND RETURN (RESULTS IN R3, R4)
.SBTTL	STRING - CHAR MATCH ROUTINES.
; FUNIQS - FIND UNIQUE STRING IN LIST.
;	OUTPUT REMAINDER OF STRING IF INMOD .LE. 1
; JSR	R5, FUNIQS
;  TABLE PTR.
;  NO MATCH RETURN	R4 POINTS TO END OF TABLE.
;  MATCH RETURN:	R4 POINTS TO PTR. TO NEXT ENTRY.

FUNIQS:	SAVE	R0, R1, R2, R3
	MOV	(R5), R4
	MOV	-2(R4), CHRCTR+2 ; INIT TO ACTUAL CHAR VALUE.
; SET BIT 15 IN ALL STRING POINTERS AS MATCH FLAG.
1$:	BIS	#.B15, (R4)+
2$:	MOV	(R4), R4	; NEXT TABLE ENTRY.
	TST	(R4)	; TEST TABLE TERMINATOR.
	BNE	1$	; SET ANOTHER STRING PTR BIT.
; ALL STRING POINTERS SET.
FUNIQC:	MOV	(R5), R4
	JSR	PC, GETCHR	; GET A CHAR TO MATCH.
	CLR	MATCHC	; MATCH COUNTER
FUNIS:	MOV	(R4), R3	; POINTER TO STRING
	BPL	FUNXT	; IGNORE THIS ONE
	BIC	#.B15, R3	; CLEAR IT HERE.
CHRCTR:	MOVB	2(R3), R2	; GET A CHAR
				; OFFSET TO STRING BEGINNING.
	BEQ	4$	; END OF STRING: CLEAR FLAG
	CMPB	R0, R2
	BNE	4$	; NO MATCH- CLEAR FLAG
	INC	MATCHC
	MOV	R4, FUNPTR ; SAVE POINTER TO LAST MATCH ENTRY
	BR	FUNXT	; CHECK NEXT STRING

4$:	BIC	#.B15, (R4)	; CLEAR FLAG BIT
FUNXT:	MOV	2(R4), R4	; NEXT ENTRY.
	TST	(R4)	; TABLE END?
	BNE	FUNIS	; DO ANOTHER STRING.
; END OF TABLE:BUMP CHARACTER - CHECK MATCH COUNT
	INC	CHRCTR+2	; SET UP FOR NEXT CHAR
	JSR	PC, NXTCHR
	CMP	#1, (PC)+	; CHECK # STRING MATCHES.
MATCHC:	.WORD	0	; TOTAL # STRING MATCHES THIS PASS.
	BGT	FUNERR	; NO UNIQUE STRINGS POSSIBLE
	BNE	FUNIQC	; CHECK WITH ANOTHER CHAR.

; HAVE A UNIQUE STRING IDENTIFIED: ECHOE REST OF IT.
FUNIQUE: MOV	(PC)+, R4	; GET POINTER TO MATCHED STRING.
FUNPTR:	0	; POINTER TO LAST MATCH TABLE ENTRY
	BIC	#.B15, (R4)	; CLEAR FLAG BIT.
	MOV	(R4)+, R1	; PTR TO STRING BEG
	ADD	CHRCTR+2, R1	; PTR TO CURRENT CHAR.
	TST	(PC)+		; ECHOE REMAINDER?
INMOD:	 0
	BNE	FUNCKR		; NO: MATCH REMAINDER
	JSR	PC, PRINTS	; PRINT REMAINDER
FUNFND:	TST	(R5)+	; DO FOUND RETURN
FUNERR:	RESTR	R0, R1, R2, R3
	TST	(R5)+
	RTS	R5

; JUST CHECK THE REST: DON'T ECHOE REMAINDER.
FUNCKR:	GETCHR
	MOVB	(R1)+, R2	; GET THE CHAR
	BEQ	FUNFND
	CMPB	R0, R2
	BNE	FUNERR
	JSR	PC, NXTCHR
	BR	FUNCKR
.SBTTL	I/O UTILITIES

; OCTIN - OCTAL INPUT ROUTINE: CALLS GETCHR.
; JSR PC, OCTIN
;	RETURNS WITH VALUE IN R0 AND CARRY SET.
;	OR RETURNS WITH R0 UNCHANGED AND CARRY CLEAR.
;	RUBOUT DELETES  LAST OCT # TYPED.

OCTIN:	SAVE	R0, R1, R2
OCTRST:	CLR	R1
	CLR	R2	; MODIFIED FLAG = # DIGITS TYPED.
	JSR	PC, GETCHR
	CMP	R0, #'8	; MUST BE OCTAL.
	BGT	OCTCK

2$:	JSR	PC, GETCHR	; GET A CHAR.
	SUB	#'0, R0
	BLT	OCTCK	; CHAR < 0
	CMP	R0, #8.	; 0-8
	BGT	OCTCK	; NOT OCTAL DIGIT, CHECK R.O OR TERM.
	ASL	R1
	ASL	R1
	ASL	R1
	ADD	R0, R1	; INSERT ANOTHER DIGIT.
	INC	R2	; DIGIT COUNTER
	JSR	PC, NXTCHR
	BR	2$

OCTCK:	JSR	PC, GETCHR
	CMP	R0, #177	; = RUBOUT?
	 BNE	OCTIT
	JSR	PC, NXTCHR
	DEC	R2	; DIGIT COUNTER.
	BLT	OCTRST	; NO MORE DIGITS TO DELETE.
	ASR	R1
	ASR	R1
	ASR	R1
	MOV	#'\, R0	; OUTPUT A "\
	JSR	PC, OUTCHR	; PRINT IT.
	BR	OCTCK-6

OCTIT:	CLR	YTTIFG	; KILL TERMINATOR FLAG.
	TST	R2	; ANY DIGITS ACCEPTED.
	BNE	4$	; YES
	RESTR	R0, R1, R2
	RTS	PC

4$:	MOV	R1, R0	; RETURN THE VALUE.
	RESTR	R1 R2
	TST	(SP)+	; DON'T RESTORE R0.
	SEC	; SET CARRY FOR ARG RETURNED FLAG.
	RTS	PC


; GETNVL - GET A NEW VALUE FOR PARAM
; JSR	R5, GETNVL
;  PTR TO MAX VALID VALUE
;  PARAM TO BE MODIFIED
; RETURNS

GETNVL:	TST	(R5)+		; POINT TO ARG
	PRNTIT	< ( >, (R5)	; PRINT CURRENT VAL
	PRINT	<): >
	JSR	PC, NXTCHR
	JSR	PC, OCTIN
	 BCC	4$
	  CMP	R0, @-2(R5)	; VALID VAL?
	  BGT	GETNVL+2
	MOV	R0, (R5)	; LOAD ARG
4$:	TST	(R5)+		; BUMP PAST ARG
	RTS	R5
; OCTAL OUTPUT ROUTINE. - PRINTS # IN R0 ON CALL
;	JSR	PC, OCTPNT	; R0=NUMBER TO BE PRINTED.
;	RETURNS.

OCTPNT:	SAVE	R0, R1, R2, R3, R4
OCTSW:	CLR	R1	; LEAD ZERO FLAG
	MOV	#6, R2	; DIGIT COUNTER
	MOV	R0, R3	; SHIFTER
	CLR	R4	; JUST PUT IN A SINGLE BIT
	ROL	R3
	ROL	R4
8$:	JSR	PC, DIGOUT
	BLE	NUMOUT
	ROL	R3
	ROL	R3
	ROL	R3
	MOV	R3, R4
	ROL	R4	; CARRY INTO LOW BIT.
	BIC	#177770, R4	; MAKE IT OCTAL
	BR	8$

NUMOUT:	RESTR	R0, R1, R2, R3, R4
	RTS	PC


; DIGIT OUTPUT ROUTINE.

DIGOUT:	BNE	.+6	; A ZERO;
	 TST	R1	; LEADING?
	  BEQ	7$	; YES: SUPPRESS IT.
	ADD	#'0, R4	; MAKE IT ASCII
	CMP	#'9, R4	; NUMERIC;
	BGE	3$	; YES: NO LEADING 0.
	 TST	R1
	 BNE	3$	; NOT FIRST DIGIT.
	  PRINT	<0>	; PRINT INITIAL 0 ON LEADING <A-F>
3$:	MOV	R4, R0	; NOW PRINT THE DIGIT
	CMP	#'9, R0	; MAP 10. TO 15. INTO A-F
	BGE	.+6
	 ADD	#7, R0
	JSR	PC, OUTCHR
	INC	R1	; SET LZ FLAG
7$:	DEC	R2
	BGT	10$	; CHECK FOR SOMETHING TYPED.
	 TST	R1	; # TYPED FLAG.
	 BNE	8$
	  PRINT	<0>	; TYPE AT LEAST A 0.
8$:	 PRINT	< >	; AND TRAILING SPACE.
	 TST	R2
10$:	RTS	PC
; DMPBYT - DUMP A BUFFER NUMERICALLY IN BYTE FORMAT.
; JSR	R5, DMPBYT ; R1= START BYTE OFFSET, R3= LAST BYTE #.
;	BUFFER
;	RETURNS

DMPBYT:	SAVE	R0, R1, R2, R4
	MOV	(R5)+, R4	; GET BUF ADDR.
	BIC	#7, R1	; START EVEN
	ADD	R1, R4	; GET ACTUAL POINTER.
	BR	4$	; SKIP ENTRANCE TEST.

2$:	BIT	#7, R1	; NEW LINE?
	 BNE	6$
	  JSR	R5, PRINT	; PRINT TEXT FOLLOWING
3$:	 ASCIZE	<"<0>"1234567>	; LOADED BY CALL
	 PCRLF
	CMP	R1, R3	; END
	BGE	10$
	JSR	PC, DISCHK
4$:	 MOV	#3$, R2	; GET ASCII DUMP PTR
	MOV	R1, R0
	JSR	PC, PNTBYT
	PRINT	<: >

6$:	MOVB	(R4)+, R0
	JSR	PC, PNTBYT
	CMPB	R0, #' 	; .LE. " "
	 BLT	 .+10
	CMPB	R0, #176
	 BLE	 .+6
	  MOVB	#'^, R0	; DEFAULT WITH ^
	MOVB	R0, (R2)+
	CLRB	(R2)
	INC	R1	; BYTE OFFSET
	BR	2$

10$:	RESTR	R0, R1, R2, R4
	RTS	R5

; PNTBYT - PRINT LOW BYTE IN R0

PNTBYT:	SAVE	R0, R1
	MOV	#3, R1
	BIC	#177400, R0	; CLEAR SIGN EXTENSION
	BR	.+4
2$:	ASL	R0	; PUT BITS INTO HIGH BYTE
	ASL	R0
	ASL	R0
	SWAB	R0
	JSR	PC, OCTOUT
	SWAB	R0
	DEC	R1
	BGT	2$	; DO NEXT DIGIT.
	PRINT	< >	; SPACE AFTER BYTE
	RESTR	R0, R1
	RTS	PC

OCTOUT:	SAVE	R0
	BIC	#177770, R0
	ADD	#'0, R0
	JSR	PC, OUTCHR
	RESTR	R0
	RTS	PC

; DMPOCT - DUMP IN OCTAL.
;	JSR R5, DMPOCT	; R1 = START BYTE OFFSET, R3 = END BYTE
;	  POINTER TO BUFFER

DMPOCT:	SAVE	R0, R1, R4
	MOV	(R5)+, R4 ; BUFFER ADDRESS.
	BIC	#17, R1	; START EVEN
	ADD	R1, R4	; ACTUAL PTR.
	BR	4$	; SKIP EXIT TEST

2$:	BIT	#17, R1	; NEW LINE
	BNE	6$
	PCRLF
	CMP	R1, R3
	BGE	10$
	JSR	PC, DISCHK
4$:	MOV	R1, R0
	JSR	PC, OCTPNT
	PRINT	<: >
6$:	MOV	(R4)+, R0
	JSR	PC, OCTPNT
	TST	(R1)+	; BUMP COUNT
	BR	2$

10$:	RESTR	R0, R1, R4
	RTS	R5
; MACRO EXPANSION OF  PRINT <TEXT STRING>
; PRINT - PRINTS STRING FOLLOWING JSR THROUGH OUTCHR.
; JSR R5, PRINT
; .ASCIZ / TEXT /,	.EVEN

PRINT:	SAVE	R0
2$:	MOVB	(R5)+, R0
	BEQ	4$	; EXIT ON ZERO BYTE.
	JSR	PC, OUTCHR
	BR	2$

4$:	TSTB	(R5)+		; BUMP BY 2
	BIC	#1, R5	; ENSURE EVEN
	RESTR	R0
	RTS	R5

; PRINTS - PRINT A STRING POINTED TO BY R1
; JSR	PC, PRINTS

PRINTS:	SAVE	R0, R1
2$:	MOVB	(R1)+, R0
	BEQ	4$
	JSR	PC, OUTCHR
	BR	2$
4$:	RESTR	R0, R1
	RTS	PC


; PCRLF - PRINTS A CRLF THROUGH OUTCHR
; JSR	PC, PCRLF	OR	<MACRO>  PCRLF

PCRLF:	PRINT<"<15><15><12>">
	CMP	LSTCHR, #'P-100	; DON'T COUNT UNPRINTED LINES
	 BNE	 1$		; TREAT NORMALLY
	TST	ERRPFG		; CONTROL P OVERRIDE?
	 BEQ	 PCRLFX		; NO - PRINT INHIBITED
1$:	DEC	(PC)+	; DO A CTRL O AFTER 512. LINES.
MAXLNP:	1000
	BGT	PCRLFX
	 CLR	MAXLNP
	 MOV	#'O-100, LSTCHR	; DO A CTRL O
PCRLFX:	RTS	PC
; OUTCHR - OUTPUT A CHAR TO THE TTY
; JSR PC, OUTCHR	; CHAR IN R0
; RETURNS: REGISTERS UNCHANGED.

OUTCHR:	SAVE	R0
	CMP	SP, #500
	BHI	.+6
	  JMP	STARTD
	CMP	LSTCHR, #'O-100	; CTRL O INHIBITS PRINT.
	BEQ	OUTXT
; INHIBIT PRINTING ALL BUT ERRORS IF CTRL P LAST CHAR
	CMP	LSTCHR, #'P-100
	 BNE	COLCNT-2	; GO PRINT IT
	 TST	ERRPFG		; ENABLED?
	  BEQ	OUTXT		; NO.
	INC	(PC)+	; UPDATE THE COLUMN COUNTER
COLCNT:	0
	CMP	R0, #15	; COL = 0 AFTER CR
	BNE	.+6
	 CLR	COLCNT
	CMP	R0, #40	; SPACE ?  DO CRLF IF > COL 65
	 BNE	1$
	 CMP	COLCNT, #70.
	BGT	3$	; DO A CRLF
1$:	CMP	COLCNT, #77.
	 BLT	2$	; STILL OK.
3$:	PCRLF	; RESET THE CARRIAGE
	JSR	R5, TABCOL	; TAB OUT AFTER AUTO CRLF
	  10
2$:	TSTB	@#TPS	; WAIT FOR CHAR FINISHED.
	BPL	.-4
	MOVB	R0, @#TPB

	TST	(PC)+
LDCBFG:	0
	BNE	OUTXT		; ALLOW SUPPRESSION
				; WHILE DOING DMPCBF
	MOVB	R0, @(PC)+
PTRCBF: ZZLST		; CIRC BUF POINTER
	INC	PTRCBF
	CLRB	@PTRCBF		; MOVING TERMINATOR CHAR.
	CMP	PTRCBF, ENDCBF	; AT END OF BUF
	 BLO	OUTXT
	  MOV	BEGCBF, PTRCBF
	  CLR	(PC)+		; FLAG FOR PRINTING FROM PTRCBF
	   -1			; INSTEAD OF BEGCBF
OUTXT:	CMP	LSTCHR, #'S-100	; HANG UP PRINTING	
	BEQ	OUTXT		; UNTIL SOMETHING ELSE TYPED.
	RESTR	R0
	RTS	PC


; TABCOL - TAB TO COL # SPECIFIED FOLLOWING CALL
; JSR	R5, TABCOL
;    COL # TO BE TABBED TO
; RETURNS	REGISTERS UNCHANGED

TABCOL:	PRINT	< >
	CMP	COLCNT, (R5)	; ARE WE THERE YET?
	 BLT	TABCOL
	TST	(R5)+
	RTS	R5
; GETCHR - GET A CHAR FROM SPECIFIED DEVICE
; JSR PC, GETCHR
; RETURNS: CHAR IN AC0

GNXCHR:	CLR	(PC)+	; OPTIONAL NXTCHR ENTRANCE.
YTTIFG:	0
GETCHR:	SAVE	R1
	MOV	YTTIFG, R0	; SEND IT AGAIN?
	BNE	GETXT	; USE THIS VAL IF NOT 0.

GETCHI:	MOV	(PC)+, R1	; GET OUTPUT POINTER
TTPTRO:	TTBUF
	CMP	R1, TTPTRI	; SAME AS INPUT PTR?
	BEQ	GETCHI		; BUFFER EMPTY.
	MOVB	(R1)+, R0	; GET A CHAR
	CMP	R1, #TTBFD	; AT END?
	 BLT	.+6
	 MOV	#TTBUF, R1	; WRAP OUTPUT PTR AROUND.
	MOV	R1, TTPTRO
	JSR	PC, DISPTH
	MOV	R0, YTTIFG
	BEQ	GETCHI	; LOADED IF NO DISPATCH.
	MOV	(PC)+, R1  ; CHECK TERMINATOR DISPATCH LIST.
	 FRDTLS

8$:	CMP	R0, (R1)+
	BEQ	10$		; MATCH - GO TO IT.
	TST	(R1)+		; SKIP OVER ADDRESS.
	TST	(R1)	; END;
	BNE	8$	; CHECK NEXT CHAR.
	BR	12$	; DO NORMAL RETURN

10$:	MOV	(R1), 2(SP)	; LOAD A RETURN ADDR
	CLR	R0	; KILL THE DISPATCH CHAR.
	BR	14$	; AND SKIP THE ECHOE.

12$:	TSTB	@#TPS
	BPL	.-4
	MOVB	R0, @#TPB	; ECHOE IT.
	INC	COLCNT	; MAKE ECHOED CHARS COUNT
14$:	MOV	R0, (PC)+
YTTICH:	0	; SET AS NXT CHAR.
GETXT:	RESTR	R1
	RTS	PC



; ODT- STACK TRACE ON CTRL-T
; TRANSFERS TO ODT WITH ALL REGISTERS LOADED
; AS IN DISCHK CALL.

ODTTRC:	MOV	SP, R0	; GET STACK
	ADD	#6, R0	; GET DISCHK CALL ADDR
	MOV	R0, R1	; SAVE FOR LATER PRINTING
	PRINT	<"<15><12>"@SP=>
2$:	JSR	PC, DISCHK	; DANGEROUS-BUT!
	JSR	PC, OCTPNT
	MOV	(R1)+, R0	; GET STACK CONTENTS
	CMP	R1, #STACKV ; UPTO TOP.
	BLE	2$
; WAIT TILL FINISHED TYPING
	BIT	#100, @#TPS
	BNE	.-6


ODTDIS:	RESTR	R1
	MOV	2(SP), R0	; RESTORE R0 IF DISCHK CALL.
	INC	(PC)+		; FLAG FOR ODT ENTRANCE
OFLAG:	 -1
	MOV	SP, (PC)+	; SAVE STACK FOR FLAG
SAVSTK:	0
	TST	ODTRET-2
	 BEQ	ODTRTX	; DON'T DISPATCH IF NOT LINKED.
	JMP	@#O.ODT

ODTRET:	CLR	YTTIFG		; FOR GETCHR CALLS.
	TST	OFLAG		; INSURE O.ODT ENTRANCE INITIALL
	BNE	.+10
	 ADD	#4, ODTRET-2	; SWITCH TO O.ODT+4
	TST	SAVSTK
	BEQ	SAVSTK+2
ODTRTX:	CLR	SAVSTK
	RTS	PC		; RETURN TO DISPTH CALL


; DISCHK -DISPATCH CHECK ROUTINE ON CHAR TYPED.

DISCHK:	SAVE	R0
	MOV	LSTCHR, R0	; LAST CHAR INPUT UNDER INTERRUPT
	BEQ	2$
	CMP	R0, #'O-100	; DON'T CLEAR A CTRL O
	BEQ	2$
	CMP	R0, #'P-100	; OR CTRL P
	BEQ	2$
	 CLR	LSTCHR		; CLEAR IN CASE DISPATCH
	JSR	PC, DISPTH	; CHECK THE CHAR.
2$:	RESTR	R0
	RTS	PC
; DISPTH - DISPATCH ROUTINE FOR CHAR IN R0.

DISPTH:	SAVE	R1
	JSR	R5, MATCH
	FRDTLS
	JSR	R5, MATCH
	SPCLST
DISPRT:	RESTR	R1
	RTS	PC

GCRLF:	PCRLF
	BR	DISPRT	; ECHOE CRLF IF CR

PDVSTT:	INC	ERRPFG	; ENABLE PRINT
	CALL	PTKSEC
	CALL	DEVSTT
	DEC	ERRPFG
NULL:	CLR	R0
	BR	DISPRT	; THROW IT AWAY.

SPCLST:	'T-100,	ODTTRC	; ODT CALL WITH STACK TRACE
	'D-100,	ODTDIS	; ODT DISPATCH
	'O-100,	NULL	; JUST LEAVE IN LSTCHR, DON'T ECHOE.
	12,	PDVSTT
	15,	GCRLF
	0
FRDTLS:	'C-100,	EXIT	; RETURN TO RT-11 IF PRESENT
	'R-100,	STARTR
	0


; MATCH - MATCH C(R0) WITH FIRST ENTRY IN TABLE.
; RETURNS R1 = PTR TO 2ND ENTRY IF MATCHED.

MATCH:	SAVE	R2
	MOV	(R5)+, R1
2$:	MOV	(R1)+, R2
	BEQ	DISPXT	; END OF TABLE
	CMP	R0, R2
	BEQ	4$	; MATCH FOUND.
	TST	(R1)+	; NEXT DISPATCH CHAR
	BR	2$
; FOUND RESTOR R2 AND DO NORMAL RET.
4$:	MOV	(R1), R5	; DIDDLE RET ADDR.
DISPXT:	RESTR	R2
	RTS	R5
; NXTCHR - INIT GETCHR TO RETURN NEXT CHAR
; JSR PC, NXTCHR;  RETURNS: REGISTERS UNCHANGED.

NXTCHR:	CLR	YTTIFG
	RTS	PC

; TTY INPUT INTERRUPT PROCESSOR

TTINT:	SAVE	R0, R1
	MOV	#1000, MAXLNP	; 1000 LINES MAX UNATTENDED.
	MOVB	@#TKB, R0	; READ THE CHAR.
	BIC	#177600, R0	; CLEAR THE MISERABLE PARITY BIT.
	BEQ	SETPRI-4	; IGNORE 0'S
	CMP	R0, #'X-100
	 BEQ	TTIRST
	MOV	R0, (PC)+
LSTCHR:	0	; LAST CHAR INPUT.
	MOV	(PC)+, R1
TTPTRI:	TTBUF		; INPUT INTERRUPT POINTER.
	MOVB	R0, (R1)+	; PUT INTO CIRC BUFFR.
	CMP	R1, #TTBFD
	BLT	2$
	 MOV	#TTBUF, R1	; WRAP IT AROUND.
2$:	CMP	R1, TTPTRO	; CAUGHT UP TO OUTPUT?
	BNE	.+4
	 DEC	R1	; YES - BACK IT OFF.
	MOV	R1, TTPTRI	; RELOAD INPUT POINTER.
	RESTR	R0, R1
SETPRI:	RTI

TTIRST:	MOV	#RSTTST, (SP)	; RESTART CURRENT TEST
	RTI			; BUT RESTORE STATUS WD

	0	; FOR WRAPAROUND
TTBUF:	.BLKW	14
TTBFD:	0
	NOP			; REENTER ENTRANCE
STARTS:	MOV	#STACKV, SP	; SET STACK
	JSR	R5, SAVE
	  MONSAV
	BIS	#20000, 44	; ALLOW REENTER
	MOV	#LSI11P, @#4	; PATCH #SECTORS IF LSI-11
	CLR	@#6
	CLR	@#177776	; TRY TO SET PSW, TRAPS IF LSI-11
	JSR	R5, PATCH
	 MONPTX
	INC	#-1	; PRINT ON FIRST TIME ONLY
	 BNE	BEGCBF + 2
 	 MOV 	#STTTBL, R1	; PRINT INITIAL TEXT ONCE.
	 JSR	PC, PRINTS

; RESTART FOR COMPLETE STATUS RESET.

XXXRES:	MOV	#STACKV, SP
; SECTION TO DETERMINE TOP OF USABLE MEMORY FOR CIRCULAR
; BUFFER AREA.
	MOV	#77400, R0	; 16K AVAILABLE?
	JSR	PC, CHKRSP	;  BUSS TIMEOT
	 BCC	.+6		; NO - USE IT
	  MOV	#36000, R0	; FIT IT INTO 8K
	CMP	@54, #167	; WAS IT A LOAD FROM RT-11? 
	 BNE	ENDCBF - 2	; NO. DON'T DO MONITOR CALLS
	.SETTOP	#-2		; REQUEST ALL AVAILABLE MEM
	MOV	R0, (PC)+
ENDCBF: 0
CHKODL:	CMP	R0, #36000	; BOOTED IN > 8K MEM?
	 BHI	4$
	  MOV	#DATBFL, BEGCBF	; START BUF OVER ODT
	  CLR	ODTRET-2	; CLEAR ODT PRESENT FLAG
4$:	MOV	(PC)+, R0	; DON'T WIPE OUT ODT.
BEGCBF:	 ZZLST
	MOV	R0, PTRCBF		; CIRC BUF POINTER
	CLR	10(R0)		; INSURE THAT TERMINATOR PRESENT
	MOV	#-1, OUTXT-2	; SET NON- WRAPPED AROUND FLG.
	MOV	#STTTBL, R5	 ; 0 ALL STATUS BUFFERS.
	CLR	(R5)+
	CMP	R5, #DATBUF
	 BLT	.-6

STARTD:	JSR	R5, PATCH
	  MONPTH
	PRINT	<"<15><12>"DSD FRDTST V5B>
	CALL	MAPADS		; PRINT ALL RESPONDING ADDRESSES
STARTR:	JSR	R5, PATCH
	  MONPTH	; CLEAR TT-INPUT BUFFER ON CTRL R
	JMP FRDTST

LSI11P:	MOV	#3, SCTINC	; INCREASE INTERLEAVE
	RTI	; RESTORE STATUS.

EXIT:	CMP	@54, #167	; IS RT-11 STILL THERE
	 BEQ	4$
	  PRINT	< NO RT-11>
	  JMP FRDTST
4$:	PRINT	<EXIT TO RT-11?>
	JSR	PC, GETCHR-4
	CMP	R0, #'Y
	 BNE	STARTD
	JSR	R5, PATCH
	 MONSAV
	.EXIT


; PATCH ROUTINE FOR SETTING UP FOR MONITOR RETURN.
; JSR PATCH
;  TABLE POINTER	- .WORD	ADDRESS, CONTENTS.

PATCH:	SAVE	R3, R4
	MOV	(R5)+, R4
2$:	MOV	(R4)+, R3	; ADDRESS POINTER.
	 BEQ	PTCHFN
	MOV	(R4)+, (R3)	; PATCH IT.
	 BR	2$

SAVE:	SAVE	R3, R4
	MOV	(R5)+, R4
4$:	MOV	(R4)+, R3	; ADDRESS POINTER
	 BEQ	PTCHFN
	MOV	(R3), (R4)+	; SAVE IT.
	 BR	4$

PTCHFN:	RESTR	R3, R4
	RTS	R5


MONPTX:	264,	FLPIN0	; FLOPPY INTERRUPT PROC
	266,	340
MONPTH:	TTPTRI,	TTBUF
	TTPTRO,	TTBUF	; INIT TO EMPTY.
MONPTK:	4,	TRAP4	; TRAP VECTOR
	6,	0
	10,	TRAP10
	12,	140
	24,	PWRFAL
	26,	340
	60,	TTINT	; TT INPUT
	62,	340
	64,	66
	66,	0
	INTPTR,	0	; RESET INTERRUPT POINTER.
	TKS,	100	; TT INPUT INTERRUPT ENABLED
	TPS,	0	; TT OUTPUT INTERRUPT DISABLED.
	0

MONSAV:	4,	0	; SAVE MONITOR STUFF FROM RT-11
	10,	0
	24,	0
	60,	0	; TTY IN
	64,	0	; TTY OUT.
	220,	0	; RK-11
	222,	0
	264,	0	; FLOPPY
	266,	0
	0


STTTBL:			; STATUS TABLE BY DEVICE AND UNIT
TEXTL <"<15><12><12>"REMOVE DIAGNOSTIC DISKETTE"<12>">
TEXTL <DSD FLOPPY DISK DIAGNOSTIC WITH FORMAT CAPABILITY>
TEXTL <TYPE 'A' TO DO ACCEPTANCE TEST ON 2 DRIVES>
TEXTL <ON DEVICE 177170  (10 MIN)>
TEXTL <TYPE 'X' TO FORMAT A DISKETTE. PROGRAM WILL ASK UNIT #.>
TEXTL	<       TYPE 0,1 OR 2, PROGRAM WILL ASK SEQ FORMAT:?>
TEXTL	<       TYPE Y FOR STANDARD, N FOR INTERLEAVED FORMAT.>
ASCIZE	<"<15><12><15>">

	.=STTTBL+1200	; FOR 6 SYSTEMS

DATBUF:	.BLKB	300
DATBFL:	0

.CSECT	ENDSEG
ZZLST:		; SOMETHING JUST BEYOND ODT WHEN LINKED

	.END	STARTS