;
.SBTTL	DTE20 - DRIVE A PDP-10 THROUGH A DTE20
;
; THIS MODULE REPLACES THE DL10 MODULE IN THE DN60 FRONT-END
;  PROGRAM TO USE THE DTE20 ON A 2040 CONFIGURATION RATHER
;  THAN THE DTE10 ON THE 1090 OR THE DL10 ON A 1070.
;
; NOTE THAT THE DTE10 AND DTE20 ARE THE SAME HARDWARE; THE
;  DIFFERENCE LIES IN THE PDP-10 SOFTWARE BEHIND THEM.
;  THE DTE10 IS DRIVEN BY D60SER/D6SINT, WHICH INTERFACE
;  TO THE TOPS-10 DTESER MODULE FOR THE DN60.  THE DTE20 IS
;  DRIVEN BY THE TOPS-20 MODULE FESRV WHICH INTERFACES TO
;  DTESRV.  FESRV WAS ENHANCED FOR THE DN60 PROJECT, BUT
;  IT IS NOT SPECIAL-PURPOSE AS D60SER/D6SINT IS.
;
;
.REPT 0


                          COPYRIGHT (c) 1980, 1979
            DIGITAL EQUIPMENT CORPORATION, maynard, mass.

THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND  COPIED
ONLY  IN  ACCORDANCE  WITH  THE  TERMS  OF  SUCH  LICENSE AND WITH THE
INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR  ANY  OTHER
COPIES  THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE  SOFTWARE  IS  HEREBY
TRANSFERRED.

THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE  WITHOUT  NOTICE
AND  SHOULD  NOT  BE  CONSTRUED  AS  A COMMITMENT BY DIGITAL EQUIPMENT
CORPORATION.

DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF  ITS
SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.

.ENDR
;
.SBTTL	DTE20 DRIVER
;
;THIS SECTION CONTAINS THE DTE20 DRIVER AND THE QUEUED PROTOCOL
;INTERFACE CONFORMING TO THE RSX-20F SPECIFICATIONS FOR
;COMMUNICATION BETWEEN THE PDP-11 AND DECSYSTEM-20.
;
; AT THE FRONT ARE SUBROUTINES CALLED FOR INTERRUPT,
;  INITIALIZATION, ONCE-A-CLOCK-TICK PROCESSING AND 
;  ONCE-A-SECOND PROCESSING.  AFTER THESE IS THE TASK.
;
; COPYRIGHT, 1979, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS  01754
;
;
;
;		REVISION HISTORY
;
; 3(001) BS	UNSUSPEND DEVICE WHEN LESS THAN 2 MESSAGES QUEUED TO DTE TASK
;
; 3(002) BS	PREVENT ENABLING OF LINE GREATER THAN WHAT FE IS SET UP FOR
;
; 3(003) BS	ADD LINE COMMAND TO SET LINE SIGNATURE
;
; 3(004) BS	INCLUDE LINE FLAGS IN DEVICE STATUS
;
; 3(005) BS	DO NOT CLEAR ACTIVITY BIT ON EOF NEW INPUT PERMISSION REQUESTED
;
; 3(006) BS	CLEAR DEVICE ACTIVE BIT WHEN ABORT COMPLETE ACKED
;
; 3(007) BS	ADD SECOND BYTE OF LINE FLAGS TO LINE STATUS
;		ADD LINE SIGNATURE TO DEVICE STATUS
;
; 3(010) BS	GIVE REJECT FOR DEVICE STATUS ON DISABLED LINE
;
; 3(011) BS	REJECT DEVICE COMMAND ON DISABLED LINE
;
; 3(012) BS	REJECT WRITE DATA COMMAND ON DISABLED LINE
;
; 3(013) BS	DO NOT DELETE LCB TO PREVENT KMC11 CONFUSION
;
; 3(014) BS	GIVE REJECTS FOR INCORRECT DEVICE NUMBERS HASP/3780/2780
;
; 3(015) BS	CLEAN UP LINE BLOCK STATISTICS WHEN LINE IS DISABLED
;
; 4(016) BS	PREVENT DTE INTERRUPT ROUTINE AND DRIVER FROM LOSING MESSAGES
;
; 4(017) BS	MODIFY TGHA CODE TO HANDLE CHANGE 4(016)
;
; 4(020) BS	ADD SOME MORE DEBUG CODE
;
; 4(021) BS	IMPROVE PERFORMANCE OF DT.INT
;
; 4(022) BS	CHANGE OFFSET INTO COMMUNICATIONS REGION FOR TGHA
;
; 4(023) BS	RAISE PRIORITY OF DLDRVR TASK
;
; 4(024) BS	LOCK OUT DTE20 INTERRUPTS DURING ONCE A SECOND SUBROUTINE
;
; 4(025) BS	CHANGE READ LINE STATUS TO TRANSFER CORRECT NUMBER OF BYTES
;
; 4(026) BS	CORRECT LINE COMMAND ONE TO FIND PROPER OFFSET FOR BSC TASK
;
; 4(027) BS	CORRECT OFFSET TO MESSAGE POINTERS FOR HASP
;
; 4(030) BS	LOWER PRIORITY OF DTE TASK TO PREVENT RECEIVER OVERRUNS
;
;
VDTE20=030
;
;
VEDIT=VEDIT+VDTE20
;
;
;
;
.SBTTL	DTE20 INTERRUPT
;
; THE FOLLOWING SERVICES THE BASIC DTE20 INTERRUPTS BY TURNING
; BITS OFF IN THE TCB OF THE DRIVERS TASK; THE ACTUAL PROCESSING
; IS DONE BY THE TASKS SCHEDULED AS A RESULT OF INDICATION OF 
; ARRIVAL OF HARDWARE INTERRUPTS
; THE LEVEL FOR THE INTERRUPTS IS 6
;
;
DT.INT:	MOV	R0,-(SP)	;SAVE R0
	MOV	R1,-(SP)	;SAVE R1
	MOV	R2,-(SP)	;SAVE R2

	CLR	DBLFLG		;CLEAR DOORBELL FLAG 4(016)

	MOV	DTEBAD,R1	;GET THE BASE ADR OF REGS
11$:	MOV	TE.STW(R1),R0	;LOOK AT THE STATUS WORD TO FIGURE OUT
				; WHY WE ARE HERE.
	BIT	#TS.ETD!TS.XNT!TS.XEE,R0 ;EXIT ONLY IF ALL INTP BITS ARE OFF
	BEQ	18$		;ALL CLEAR,FREE TO LEAVE
	TRACE	TRCTEN,R0	;TRACE STATUS
	MOV	R0,DLSSAV	;SAVE FOR ERROR TRACE
	BIT	#TS.XER!TS.MPE!TS.EPE!TS.EET,R0 ;ANY ERROR BITS  SET?
	BNE	19$		;YES,FATAL ERROR
	MOV	TCDLDR,R2	;POINT R2 TO DTE20 TASK
	BIT	#TS.ETD,R0	 ;IS 11 DONE SET?
	BEQ	12$		;NO
	INC	DTIEDN		;COUNT ELEVEN DONE INTPS
	MOV	#TS.ENT,TE.STW(R1) ;CLEAR INTP CONDITION
	TRACE	TRCTEN,DTIEDN	;ON ELEVEN DONE COUNT
12$:	TST	DTIEDN		;ANY PENDING INTERRUPTS?
	BEQ	13$		;NO
	BIT	#EBTEDN,(R2)	;IS IT WAITING FOR TO11DONE
	BEQ	13$		;NO
	BIC	#EBTEDN!EBWAIT,(R2) ;MAYBE,UNWAIT IT
;
;
; HERE TEST FOR TO TEN DONE INTERRUPT
;
13$:	BIT	#TS.XNT,R0	 ;TEN DONE INTP?
	BEQ	14$		;NO,CHECK FOR OTHERS
	INC	DTIXDN		;COUNT TEN DONE INTERRUPTS
	MOV	#TS.XTS,TE.STW(R1) ;CLEAR INTP CONDITION
	TRACE	TRCTEN,DTIXDN	;ON TEN DONE COUNT
14$:	TST	DTIXDN		;ANY TO-TEN DONE PENDING INTPS?
	BEQ	15$		;NO
	BIT	#EBTXDN,(R2)	;IS IT WAITING FOR TO10DONE?
	BEQ	15$		;NO
	BIC	#EBTXDN!EBWAIT,(R2) ;YES,UNWAIT IT
15$:	BIT	#TS.XEE,R0	 ;DID-10 REQUEST -11 INTERRUPT?
	BEQ	16$		;NO
	INC	DTIDBL		;COUNTS # OF OUTSTANDING
				; DOORBELL INTERRUPTS

	MOV	#1, DBLFLG	;SET THE DOORBELL FLAG 4(016)

	MOV	#TS.EIS,TE.STW(R1) ;CLEAR INTERRUPT CONDITION 
	TRACE	TRCTEN,DTIDBL	;TRACE DOORBELL COUNT
16$:	TST	DTIDBL		;ANY PENDING DOORBELLS?
	BEQ	17$		;NO
	BIT	#EBTENI,(R2) 	;YES,IS IT WAITING FOR DOORBELL INTP
	BEQ	17$		;NO,CHECK FOR OTHER CONDITIONS
;4(021)	BIC	#EBTENI!EBWAIT,(R2) ;MAYBE,UNWAIT IT
;
; RESTORE ALL THE REGS USED AND COMPLETE THE INTERRUPT
;
17$:

	BR	11$		;SEE IF ALL INTP CONDITIONS TAKEN CARE OF
;

;
;

18$:				;WHEN ALL CLEAR COME HERE


	TST	DBLFLG		;DID WE GET A DOORBELL ? 4(016)
	BEQ	21$		;NO, EXIT 4(021)
	CLR	DBLFLG		;YES, CLEAR THE DOORBELL FLAG 4(016)

	JSR	PC, DVLECK	;CHECK FOR TGHA AND VALID EXAM
	TST	TGFLAG		;IS TGHA RUNNING ?
	BEQ	20$		;NO, COUNT AS REGULAR DOORBELL
	DEC	DTIDBL		;YES, CANCEL THIS DOORBELL
	BR	21$		;EXIT WITHOUT WAKING DTE TASK 4(021)
20$:

	TST	DTIDBL		;ANY PENDING DOORBELLS?
	BEQ	22$		;NO
	BIT	#EBTENI,(R2) 	;YES,IS IT WAITING FOR DOORBELL INTP
	BEQ	22$		;NO,CHECK FOR OTHER CONDITIONS

	BIC	#EBTENI!EBWAIT,(R2);WAITING FOR DOORBELL, WAKE DTE TASK 4(021)
22$:

	JSR	PC, DVWAKE	;WAKE THE DTE DRIVER IF WAITING FOR TGHA 4(017)

21$:				;NEW LABEL 4(021)

	MOV	(SP)+,R2	;RESTORE R2
	MOV	(SP)+,R1	;RESTORE R1
	MOV	(SP)+,R0	;RESTORE R0
	RTI			;EXIT THE INTERRUPT
;
; HERE IF THE DTE20 HAS AN ERROR
;
19$:	STOPCD	DL10		;DTE20 ERROR.
;

DBLFLG:	.WORD	0		;DOORBELL FLAG 4(016)


;
; ROUTINE CALLED AT STARTUP TO INITIALIZE THE DTE SOFTWARE INTERFACE
;  (THE HARDWARE NEEDS NO INITIALIZATION). IT WAITS FOR THE -10 TO EXIT
;  PRIMARY PROTOCOL BECAUSE THERE IS NO PRESENT MECHANISM FOR RESTARTING
;  THE QUEUED PROTOCOL. IT MUST BE RESTARTED BECAUSE OTHERWISE WE WOULD
;  NOT KNOW WHAT STATE WE WERE IN WHEN WE GOT RESTARTED AND THEREFORE
;  CANNOT CONTINUE USING THE PRESENT INCARNATION.
;
INITDL:				;INITIALIZE THE COMM AREA'S
	CLR	TGFLAG		;CLEAR TGHA RUNNING FLAG
	MOV	DTEBAD,R0	;GET DTE REGS BASE ADR
	MOV	#50,R2		;NO OF TRIES
	TST	DLACKF		;OUT OF PRIMARY PROTOCOL?
	BEQ	14$		;YES
	MOV	#TS.RST,TE.DG2(R0) ;RESET DTE20
11$:	CLR	TE.XA1(R0)	;TRY TO EXAMINE START OF COMM AREA
	CLR	TE.XA2(R0)	;TO SEE IF QUEUED PROTOCOL IS RUNNING
	MOV	#3000,DTEDTO	;TIME OUT FOR DEP/EXAM
12$:	BIT	#TS.XDN,TE.STW(R0) ;EXAMINE DONE?
	BNE	13$		;YES
	DEC	DTEDTO		;DECREMENT TIME COUNT
	BNE	12$		;LOOP IF TIMER NOT EXPIRED
	BR	14$		;EXAMINE FAILED,MUST BE OUT OF PRIMARY PROTOCOL
;
13$:	BIT	#TS.EPE,TE.STW(R0) ;ANY PARITY ERROR?
	BNE	21$		;YES,GO TO STOP CODE
	TST	TE.XW2(R0)	;DO WE WAIT FOR PRIM PROTO TO GO AWAY?
	BEQ	14$		;IT IS OUT OF PRIMARY PROTOCOL
	DEC	R2		;DONE WITH ALL TRIES
	BNE	11$		;NO,LOOP
	RTS	PC		;GIVE UP AFTER ALL THE TRIES
;
;
; HERE WE ARE OUT OF PRIMARY PROTOCOL, SAFE TO RESTART
;
14$:	CLR	DLACKF		;INDICATE OUT OF PRIMARY PROTOCOL
	MOV	#TS.EEX,TE.STW(R0) ;RING -10'S DOORBELL
;
;NOW TRY TO GET BACK INTO PRIMARY PROTOCOL AGAIN
;
15$:	CLR	TE.XA1(R0)	;TRY TO EXAMINE COMM AREA
	CLR	TE.XA2(R0)
	MOV	#3000,DTEDTO	;TIMEOUT FOR EXAMINE
16$:	BIT	#TS.XDN,TE.STW(R0) ;EXAMINE DONE?
	BNE	17$		;YES
	DEC	DTEDTO		;NO, TIMEOUT YET?
	BNE	16$		;NO, LOOP TILL TIME EXPIRES
	RTS	PC		;GIVE UP
;
;
17$:	TST	TE.XW2(R0)	;IN PRIMARY PROTOCOL?
	BEQ	18$		;NO
	TST	TE.XW3(R0)	;YES,IS  VALID EXAMINE ON?
	BNE	19$		;YES,VALID EXAMINE IS ON
18$:	RTS	PC		;GIVE UP AFTER ALL THE TRIES
;
19$:	MOV	#-1,DLACKF	;IN PRIMARY PROTOCOL
	CLR	DLGONE		;INDICATE TEN IS UP
	CLR	TGFLAG		;CLEAR TGHA RUNNING FLAG
	MOV	#10,R1		;NO OF TRIES
20$:	JSR	PC,DSPDLS	;CHECK FOR TEN TO BE REALLY UP
	TST	DLGONE		;IS TEN STILL UP?
	BNE	18$		;NO
	SOB	R1,20$		;TRY AGAIN
	CLR	DTIDBL		;CLEAR INTERRUPT COUNTERS
	CLR	DTIXDN		;FOR TO-TEN DONE
	CLR	DTIEDN		;TO-ELEVEN DONE
	CLR	DT10AK		;PERMIT TO ACK TO TEN
	CLR	DTPTCT		;COUNT OF PUNTED MESSAGES
.IIF NE,DEBUG,BIS #TRCTEN,TRCBTS ;TRACE -10 INTERACTIONS TO DEBUG EXAMINE/DEPOSIT
	JSR	PC,DLINDB	;SETUP AND INIT THE DATA BASES
	BCS	21$		;INITIALIZATION ERROR
	RTS	PC		;ALL DONE INITIALIZING,EXIT

21$:	STOPCD	DTA20		;DTE20 INITIALIZATION ERROR
;
;
; ROUTINE TO REQUEST -10 TO RELOAD US. DONE SO BY SETTING THE RELOAD
;  FLAG IN OUR STATUS WORD IN THE COMM AREA.
;
DLSTCS:	MOV	DLGONE,R1	;ARE WE TALKING TO -10?
	INC	R1		;IF DLGONE -1,10 IS DOWN
	BEQ	12$		;NO, FORGET IT
.IF NE,DEBUG
	MOV	DTEBAD,R0	;GET BASE ADR OF DTE REGS
	MOV	#20,R2		;NO OF DTE20 REGISTERS TO SAVE
	MOV	#DTESAV,R1	;POINT TO AREA TO BE SAVED
11$:	MOV	(R0)+,(R1)+	;SAVE THE REGISTER
	SOB	R2,11$		;LOOP IF NOT DONE SAVING ALL 20 REGS
.ENDC ;NE,DEBUG
;
;NOW WE CAN CHANGE STATUS AROUND
;
	BIS	#DLLD11,DTSTT	;SET RELOAD REQUEST FLAG
	MOV	DTEPCA,R3	;GET ADDRESS OF COMM AREA DATA BLOCK
	MOV	DTEBAD,R0	;SETUP DTE BASE ADR
	MOV	#DLSTAT-DLPIN,R2 ;INDICATE THAT -11 IS FINISHED
	ADD	DTDMYN(R3),R2	;POINT TO STATUS WORD
	MOV	#TS.DEP,TE.XA1(R0) ;INDICATE WRITE
	MOV	DTSTT,TE.XW1(R0) ;SET UP TO DEPOSIT
	MOV	DTSTT+2,TE.XW2(R0) ;
	MOV	DTSTT+4,TE.XW3(R0) ;
	MOV	R2,TE.XA2(R0)	;START XFER
	MOV	#TS.EEX,TE.STW(R0) ;TELL -10 ABOUT CATASTROPHE
12$:	RTS	PC		;-10 SHOULD RELOAD US IMMEDIATELY
;
.SBTTL	DTE20 ONCE-A-TICK
;
; SUBROUTINE TO CHECK ON THE DTE20 ONCE A JIFFIE
;
DSPDLT:	CLC			;FLAG SUCCESS
	RTS	PC		;RETURN
;
.SBTTL	DTE20 ONCE-A-SECOND
;
; ONCE-A-SECOND SUBROUTINE FOR DTE20 THINGS
;
DSPDLS:
	MFPS	-(SP)		;SAVE OLD PSW 4(024)
	MTPS	#BR3		;LOCK OUT DTE20 INTERRUPTS 4(030)

;	MOV	R1,-(SP)	;SAVE R1
;	MOV	R0,-(SP)	;SAVE R0
	MOV	DTEBAD,R0	;BASE ADR OF REGS
	CLR	TE.XA1(R0)	;LOOK AT HEADER WORD TO FIND
	CLR	TE.XA2(R0)	;IF -10 IS DEAD
	JSR	PC,DLWEDN	;IS TEN TALKING TO US?
	BCS	11$		;-10 IS DOWN
;	TST	TE.XW2(R0)	;GET PROCESSOR #
;	BEQ	11$		;NOT IN PRIMARY PROTOCOL YET
	TST	TE.XW3(R0)	;CHECK FOR VALID EXAMINE?
;	BNE	13$		;-10 IS UP
	BNE	18$		;-10 IS UP, WAKE DL DRIVER TASK
	TST	TGFLAG		;-10 MAY BE DOWN, CHECK FOR TGHA
	BNE	10$		;YES, TGHA HAS BEEN RUNNING
	CLR	TGCNT		;NO, INITIALIZE THE 5 SECOND WAIT
	MOV	#1, TGFLAG	;SET TGHA RUNNING FLAG
10$:	INC	TGCNT		;ADD 1 TO # OF SECONDS WAITING
	CMP	TGCNT, #7	;HAS TIME ELAPSED ?
	BGE	11$		;YES, -10 IS REALLY DEAD
	BR	13$		;NO, UPDATE COUNTERS AND CONTINUE WAITING
;
; HERE WHEN THE PDP-10 HAS GONE DOWN.
;
11$:	MOV	#TS.DEI,TE.STW(R0) ;DONT LISTEN TO TEN
	MOV	#-1,DLGONE	;TELL THE WORLD DTE20 DOWN
	CLR	JIFCLK		;MAKE SURE LOOP CATCHER DOES'NT  GO
	CLR	DLGNTM		;CLEAR TIME SINCE DTE20 GONE
12$:
	MTPS	(SP)+		;RESTORE OLD PSW 4(024)

	SEC			;SET CARRY FOR FAILURE
;	BR	14$		;RETURN
	RTS	PC		;RETURN
13$:	INCB	DTKPLV		;INCREMENT KEEP ALIVE CTR
	MOV	DTEBAD,R0	;PREPARE TO DEPOSIT
	MOV	DTKPLV,TE.XW3(R0) ;THE COUNT TO -20
	MOV	#TS.DEP,TE.XA1(R0);SET DEPOSIT FLAG
	MOV	#DLPW1,TE.XA2(R0) ;START XFER
	JSR	PC,DLWEDN	;WAIT FOR EXAM/DEP
;14$:	MOV	(SP)+,R0	;RESTORE REGS
;	MOV	(SP)+,R1
	MTPS	(SP)+		;RESTORE OLD PSW 4(024)
15$:	RTS	PC		;RETURN
;

;
; HERE TO WAKE DL DRIVER TASK AFTER TGHA HAS RUN


18$:

	TST	TE.XW2(R0)	;GET PROCESSOR #
	BEQ	11$		;NOT IN PRIMARY PROTOCOL
				;THE -10 LIED TO US

	BR	13$		;UPDATE COUNTERS AND CONTINUE 4(017)

DVWAKE:				

	CLR	TGFLAG		;CLEAR TGHA RUNNING FLAG
	MOV	R0, -(SP)	;SAVE R0
	MOV	TCDLDR, R0	;POINT TO DL DRIVER TASK

	BIT	#EBVALE, (R0)	;ARE WE WAITING FOR VALID EXAMINE ? 4(016)
	BEQ	19$		;NO, CONTINUE 4(016)
				;YES, WAKE THE DTE TASK UP 4(016)

	BIC	#EBVALE!EBWAIT, (R0) ;NOT WAITING FOR VALID EXAMINE
19$:				;NEW LABEL 4(016)

	MOV	(SP)+, R0	;RESTORE R0

	RTS	PC		;RETURN 4(017)

;4(017)	BR	13$		;UPDATE COUNTERS AND CONTINUE



; HERE TO CHECK FOR DISABLED LINES
;
DLCKDL:	CLR	R1		;START WITH LINE ZERO
11$:	ASL	R1		;LINE # * 2
	MOV	DQLCB(R1),R0	;POINT TO LCB
	BEQ	12$		;NONE THERE
	BIT	#LS.ENB,(R0)	;LINE DISABLED?
	BNE	12$		;NO.
	BIT	#LF.ABC,LB.FGS(R0) ;YES, CHECK IF ABORT COMPLETE
	BEQ	12$		;NOT YET
	MOV	R0,R4		;LCB PTR IN R4
	MOV	LB.TC1(R4),R0	;POINT TO BSC TCB
;3(013)	BEQ	13$		;ERROR, BSC TCB MISSING
	BEQ	12$		;;++BS-BSC TCB ALREADY DELETED 3(013)
	MOV	R1,-(SP)	;SAVE LINE # * 2
	MOV	TCBP1,R3	;POINT TO START OF CHAIN
	JSR	PC,DLRLTC	;RELEASE THE BSC TCB
	MOV	R3,TCBP1	;UPADTE THE BSC CHAIN PTR
	CLR	LB.TC1(R4)	;;++BS-CLEAR THE POINTER TO BSC TCB 3(013)
;3(013)	MOV	R4,R0		;POINT TO LCB
;3(013)	JSR	PC,FRESTG	;FREE THE LCB ALSO
	MOV	(SP)+,R1	;GET BACK THE LINE # * 2
;3(013)	CLR	DQLCB(R1)	;CLEAR LCB POINTER

	JSR	PC, HSSAVR	;;++BS-SAVE THE REGISTERS 3(015)
	MOV	DQLCB(R1), R2	;;++BS-POINT R2 TO LCB 3(015)
	MOV	R2, R3		;;++BS-POINT R3 TO LCB 3(015)
	ADD	#LB.ST1, R2	;;++BS-POINT TO START OF LINE STATISTICS 3(015)
	ADD	#LB.ST2-2, R3	;;++BS-DO ALL EXCEPT LINE DRIVER TYPE 3(015)
14$:	CLR	(R2)+		;;++BS-CLEAR AN ENTRY 3(015)
	CMP	R2, R3		;;++BS-HAVE WE REACHED THE END ? 3(015)
	BNE	14$		;;++BS-NO 3(015)
	JSR	PC, HSRESR	;;++BS-YES, ALL DONE, RESTORE REGISTERS 3(015)

12$:	ASR	R1		;LINE # BACK
	INC	R1		;FOR NEXT LINE
	CMP	R1,#NLINES	;IF LINE CONFIGURED
	BLO	11$		;LOOP FOR NEXT LINE
	RTS	PC		;RETURN 
;
;3(013) 13$:	STOPCD	DTM		;TCB MISSING
;

.SBTTL	DLINDB -- TURN THE DTE20 ON
; AND SETUP PROCESSOR COMMUNICATION DATA BASE
;
; THIS ROUTINE WILL SET UP THE TABLES NECESSARY TO
;  INITIALIZE THE COMMUNICATIONS BETWEEN THE PDP-10
;  AND THE PDP-11.
;
; CALL: JSR PC,DLINDB
;
; ON RETURN:
;		C = 0: R0 = 1 TO INDICATE SUCCESS
;		C = 1: ERROR
;
; NOTE THAT THIS ROUTINE USES R5 IN A NON-STANDARD WAY.
;  THIS IS BECAUSE IT WAS TAKEN FROM THE DN87S CODE AND
;  WE WOULD PREFER NOT TO HAVE TO RE-WRITE IT TO MAKE IT
;  CONFORM TO THE DN60 CODING CONVENTIONS.
;
DLINDB:	MOV	R5,-(SP)
	CLR	-(SP)
	CLR	-(SP)
	MOV	DTEBAD,R0	;FIND THE COMMON DTE20
	CLR	R1		;SET UP TO FIND PROCESSOR NUMBER
	CLR	R2		;START TRANSFER OF ABS WORD 0 OF EPT (MY PROCESSOR NUMBER
	MOV	#DTXTM3,R3	;SET UP ADDRESS TO STORE WORDS
	CLR	R4
	JSR	PC,DLSWED	;WAIT FOR EXAMINE/DEPOSIT
	BCS	11$		;E BOX STOP
	MOV	@R3,R4		;YES --FIND OFFSET TO MY R/W AREA
	MOVB	@#DTXTM2+1,R2	;FIND THE PROCESSOR NUMBER
				; PROCESSOR NUMBER TO LOW ORDER BITS
	BIC	#177760,R2	;MASK OFF JUNK(0.-15. LEGAL)
	MOV	R2,DLMYPN	;SAVE PROCESSOR NUMBER
	INC	R2		;FIND COMMUNICATIONS VIRTUAL 2
	MOV	R2,DLCMBS	;SAVE BASE OF COMMUNICATIONS AREA
	ADD	R4,R2		;ADD OFFSET TO BASE OF COMM AREA
	MOV	R2,DLDPOF	;SET CORRECT OFFSETT
	JSR	PC,DLSWED	;WAIT FOR TRANSFER
11$:	BCS	DLINDR		;
12$:	MOV	@#DTXTM2,R5	;PICK UP THE NUMBER OF 8 TM BLOCKS
	BIC	#177770,R5	;FIND THE NUMBER OF 8 WORD BLOCKS IN MY AREA
	SUB	#2,R5		;ACCOUNT FOR MY GENERAL SECTION
	MOV	R2,2(SP)
;
; CONTINUED ON THE NEXT PAGE
;
;
; CONTINUATION OF DLINDB
;
	MOV	R5,0(SP)	;SAVE	COUNT OF BLOCKS
DLIND1:	ADD	#DLPIN,2(SP)	;LOOK AT A COMMUNICATIONS AREA TO ANOTHER PROCESSOR
	MOV	2(SP),R2
	CLR	R4
	JSR	PC,DLSWED	;WAIT FOR TRANSFER
11$:	BCS	DLINDR		; E BOX STOPPED
	MOV	@R3,R4		;FIND @ROCESSOR NUMBER
	MOV	#DTPIDT,R5	;SET INITIAL POINTER
	BIC	#177770,R4	;MASK OFF JUNK
	BEQ	13$		;YES -- CONTINUE
12$:	ADD	#5*2,R5		;NO -- LOOK AT NEXT ENTRY
	SOB	R4,12$		;TRY UNTIL ALL DONE
13$:	MOV	@#DTXTM2,R4	;FIND NUMBER OF 8 WORD BLOCS
	BIC	#177770,R4	;MASK OFF POSSIBLE GARBAGE
	SUB	R4,@SP		;UPDATE COUNT OF BLOCKS
	CLR	@R5		;SET UP TO CLEAR TABLE IF NO DTE
	MOV	@#DTXTM1,R4	;PICK UP DTE NUMBER
	BIT	#4,R4		;DTE HERE?
	BEQ	15$		;NO -- DON'T ENTER IN TABLE
	SWAB	R4		;MAKE MOD 40 (8)
	ROR	R4
	ROR	R4
	ROR	R4
	BIC	#177637,R4	;MASKOFF JUNK
	ADD	#174400,R4	;POINT TO FIRST BLOCK OF DTE'S
	CMP	R4,DTEBAD	;PRIMARY DTE?
	BNE	14$		;NO -- DON'T SET TABLE POINTER
	MOV	R5,DTEPCA	;SAVE TABLE OFFSET
14$:	MOV	R4,@R5		;SET DTE ADDRESS IN TABLE
	MOV	#37777,@R4	 ;SET UP DELAY COUNTER
	MOV	#TS.EEE,TE.STW(R4) ;YES -- ENABLE INTERRUPT ON IT
15$:	MOV	R2,DTEMYN(R5) 	;SET THE ADDRESS OF EXAMINE MY AREA FOR N
;
; CONTINUED ON NEXT PAGE
;
;
; CONTINUATION OF DLINDR.
;  MAKE ADDRESS OF THE ADDRESS OF DEPOSIT MY AREA FOR N
	MOV	R2,DTDMYN(R5) 	;STORE IT
	SUB	DLDPOF,DTDMYN(R5) ;RESTORE SUBRESS FOR EXAMINE OF THIS BLOCK
	ADD	#DLPCA-DLPIN,R2 ;READ POINTER TO HIS COMM AREA
	CLR	R4
	JSR	PC,DLSWED	;WAIT FOR EXAMINE/DEPOSIT
16$:	BCS	DLINDR		;E BOX STOPPED
	MOV	@R3,R2		;FIND THE EXAMINE ADDRESS
	ADD	DLCMBS,R2	;ADD OFFSET TO COMMON AREA
	MOV	R2,DTEHSG(R5) 	;SET DTEHSG ADDRESS IN TABLE
	ADD	#DLPIN,R2	;POINT TO HIS FIRST TABLE FOR OTHER PROCESSORS
17$:	CLR	R4
	JSR	PC,DLSWED	;WAIT FOR EXAMINE/DEPOSIT
18$:	BCS	DLINDR
	CMPB	DLMYPN,@R3 	;SAME PROCESSOR NUMBER?
	BEQ	19$		;YES -- FOUND MY ENTRY
	MOV	@#DTXTM2,R4	;NO -- FIND NEXT ENTRY IN LIST
	BIC	#177770,R4	;IT IS IN 8 WORD INCREMENTS
;;++KR-FIX FOR TOPS-20 MONITOR PROBLEM
	BNE	20$		;;++KR-NON ZERO IS GOOD
	INC	R4		;;++KR-MAKE IT NON ZERO
20$:
;;++KR-END FIX
	ASL	R4		;SO IT MUST BE SHIFTED LEFT 3 BITS
	ASL	R4		;
	ASL	R4		;
	ADD	R4,R2		;READ NEXT BLOCK
	BR	17$		;AND TRY AGAIN
;
19$:	MOV	R2,DTEHSM(R5)	;STORE DTEHSM ADDRESS
	MOV	@SP,R5		;DONE ALL BLOCKS??
	BHI	DLIND1		;NO -- TRY NEXT BLOCK
	CLR	DTQCNT		;RESET PROTOCOL COUNTERS
	CLR	DTQSTA		;INIT STATE MECHANISM, CLEAR CARRY
DLINDR:	MOV	(SP)+,R5	;RESTORE STACK 
	MOV	(SP)+,R5
	MOV	(SP)+,R5
	RTS	PC
;
.SBTTL	DLSWED -- INTERNAL SUBROUTINE START AND WAIT FOR EX/DEP
;
; THIS SUBROUTINE STARTS A DEPOSIT/EXAMINE SEQUENCE AND WAITS FOR
;  ITS COMPLETION.  IT CHECKS TO SEE IF THE BOOTSTRAP
;  PROTOCOL IS NECESSARY BY CHECKING THE EXAMINE VALID BIT
;  AFTER EVERY EXAMINE/DEPOSIT.  IT IS NOT NECESSARY TO
;  CHECK MORE THAN ANY ONE RANDOM EXAMINE VAILD BIT
;  BECAUSE IF ONE IS 0 THEN THE PROCESSOR HAS
;  TO REVERT TO THE BOOTSTRAP PROTOCOL.
;
; CALL:	JSR	PC,DLSWED
;
;	R0 -- ADDRESS OF DTE20
;	R1 -- HIGH ORDER EXAMINE/DEPOSIT ADDRESS WORD (FOR TE.XA1)
;	R2 -- LOW ORDER EXAMINE/DEPOSIT ADDRESS WORD (FOR TE.XA2)
;	R3 -- ADDRESS TO XFER 3 WORD BLOCK TO OR FROM
;
; ON RETURN:
;
;	C = 0: SUCCESS, NO REGISTERS ALTERED.
;	C = 1: ERROR.
;
DLSWED:	MOV	R3,-(SP)	;SAVE REGISTERS
	BIT	#TS.DEP,R1	;CHECK FOR DEPOSIT
	BNE	12$		;YES -- GO TO DEPOSIT PART OF SUB
	MOV	R1,TE.XA1(R0)	;SET UP ADDRESS OF XFER IN DTE
	MOV	R2,TE.XA2(R0)	;START XFER
	JSR	PC,DLWEDN	;WAIT FOR EXAMINE/DEPOSIT
	BCS	14$		;COMPLAIN ABOUT E BOX STOPPED
	MOV	TE.XW3(R0),(R3)+ ;STORE THE WORD XFERED
	MOV	TE.XW2(R0),(R3)+
	MOV	TE.XW1(R0),(R3)+
11$:	TST	R4		;PRIV EXAMINE/DEP?
	BNE	14$		;YES -- DON'T DO CHECKS
	CLR	TE.XA1(R0)	;SEE IF WE CAN READ ANYTHING
	CLR	TE.XA2(R0)	;START TRANSFER
	JSR	PC,DLWEDN	;WAIT FOR XFER
	BCS	14$		;E BOX STOPPED
	TST	TE.XW3(R0)	;VALID?
	BNE	14$		;YES -- PROCEED
	BR	13$		; NO - JUST SET CARRY AND RETURN
;
;
; HERE TO DO AN EXAMINE.
;
12$:	MOV	(R3)+,TE.XW3(R0) ;TRANSFER TO 10
	MOV	(R3)+,TE.XW2(R0) ;SET UP WORD IN DTE
	MOV	(R3)+,TE.XW1(R0)
	MOV	R1,TE.XA1(R0)	;SET HIGH ORDER ADDRESS
	MOV	R2,TE.XA2(R0)
	JSR	PC,DLWEDN	;WAIT FOR EXAMINE/DEPOSIT
	BCC	11$		;GO TO COMMON EXAMINE VALID BIT CHECK
;
; HERE IF THE 'EXAMINE VALID' BIT IS OFF.  GIVE AN ERROR RETURN.
;
13$:
.IF NE,DEBUG
	STOPCD	DBG		;-10 STOPPED UNEXPECTEDLY
.ENDC
	SEC
14$:	MOV	(SP)+,R3	;RESTORE R3
	RTS	PC		;RETURN TO CALLER
;
.SBTTL	DLWEDN -- INTERNAL SUBROUTINE  WAIT FOR EXAMINE/DEPOSIT
;
; THIS SUBROUTINE WAITS FOR EXAMINE/DEPOSIT TRANSFERS AND
;  CHECKS TO SEE THAT E BOX HAS NOT STOPPED.
;
; CALL:	JSR	PC,DLWEDN
;
;	R0 -- ADDRESS OF DTE20
;
; ON RETURN:
;	C = 0: SUCCESS
;	C = 1: ERROR
;
DLWEDN:	MOV	#3000,DTEDTO	;SET UP TIMEOUT FOR TS.XDNE
11$:	BIT	#TS.XDN,TE.STW(R0) ;WAIT FOR TRANSFER TO COMPLETE
	BNE	12$		;DONE
	DEC	DTEDTO		;TIMEOUT?
	BNE	11$		;NO -- CONTINUE WAITING
	SEC			;YES, ERROR.
	RTS	PC		;RETURN.
;
; HERE WHEN THE TRANSFER IS COMPLETE.
;
12$:	BIT	#TS.EPE,TE.STW(R0) ;CHECK FOR E BUS PARITY ERROR
	BNE	13$		;WE HAVE E-BUS PARITY
	CLC			;CLEAR CC-C
	RTS	PC		;RETURN TO CALLER
;
; WE HAVE AN E-BUS PARITY ERROR.  CALL THIS A FATAL ERROR.
;
13$:	STOPCD	DTE20		;E-BUS PARITY ERROR
;
;
.SBTTL	DTE20 TASK
;
; THIS TASK INTERFACES TO THE PDP-10 THROUGH THE DTE20
;
DLDRVR:				;DRIVER INTERFACE FOR DTE20


	MFPS	-(SP)		;SAVE PSW 4(023)
	MTPS	#BR3		;LOCK OUT DTE INTERRUPTS 4(030)

11$:				;CHK FOR TGHA AND VALID EXAMINE

	TST	TGFLAG		;IS TGHA RUNNING
	BNE	20$		;YES, PUT TASK BACK TO SLEEP



18$:	MOV	#EBTENI!EBTXDN!EBTEDN!EBWAIT,(R5) ;SET UP FOR WAIT
	MOV	#JIFSEC,TCTIM(R5) ;TIME LIMIT FOR WAITING
12$:	TST	DTIEDN		;ANY TO-ELEVEN DONE INTP?
	BEQ	13$		;NONE
	JSR	PC,DLELDN	;YES,GO PROCESS TO ELEVEN DONE
	BCS	16$		;FAILURE
	BR	11$		;SUCCESS, LOOK FOR MORE INTERRUPTS
;
13$:	TST	DTIXDN		;ANY TO TEN DONE INTERRUPTS
	BEQ	14$		;NONE
	TST	DTIEDN		;HAS ANY 11-DONE SNEAKED IN?
	BNE	12$		;YES,IT HAS
	JSR	PC,DLTXDN	;NO,THEN PROCESS TO TEN DONE
	BCS	16$		;FAILURE RETURN
	BR	11$		;LOOK FOR MORE
;
14$:	TST	DTIDBL		;ANY DOORBELL INTERRUPTS?
	BEQ	15$		;NONE
	TST	DTIXDN		;ANY TO-TEN DONE SNEAKED IN?
	BNE	12$		;YES,START OVER
	TST	DTIEDN		;ANY TO-11 DONE SNEAKED IN?
	BNE	12$		;YES,START OVER
	JSR	PC,DLDRBL	;NO,THEN PROCESS DOORBELL
	BCS	16$		;FAILED
	BR	11$		;SUCCESS, LOOK FOR MORE WORK
;
15$:
	MTPS	(SP)+		;RESTORE OLD PSW 4(023)
	JSR	PC,WAIT		;WAIT FOR AN INTERRUPT
	BR	DLDRVR		;
;4(023)	BR	11$		;LOOK FOR WORK TO DO
;
; HERE ON FATAL PROTOCOL ERROR OR 10 CRASHED
;
16$:


.IF NE,DEBUG			;4(020)

	BIT	#TRCTER,TRCHLT	;STOP ON PDP-10 ERROR?
	BEQ	17$		;NO.

	STOPCD	TER		;YES, PDP-10 ERROR

17$:

.ENDC 				;.IF NE,DEBUG 4(020)

;


	TST	TGFLAG			;IS TGHA RUNNING?
	BNE	20$			;YES, PUT TASK TO SLEEP
19$:
	MTPS	(SP)+			;RESTORE OLD PSW 4(023)

	JSR	PC, DTCERR		;DTE ERROR, DISABLE ALL LINES
	JMP	DLDRVR			;WAIT FOR ANOTHER COMMAND



;HERE TO PUT TASK TO SLEEP BECAUSE OF TGHA


20$:	BIS	#EBTENI!EBTXDN!EBTEDN!EBVALE!EBTIME!EBWAIT,(R5)	;WAITING FOR VALID EXAMINE
	MOV	#JIFSEC,TCTIM(R5)	;TIME LIMIT FOR WAITING

	MTPS	(SP)+			;RESTORE OLD PSW 4(023)

	JSR	PC, WAIT		;WAIT FOR VALID EXAMINE AND/OR TGHA TO FINISH
	JMP	DLDRVR			;CHECK CONDITIONS AGAIN 4(023)

;4(023)	JMP	11$			;CHECK CONDITIONS AGAIN



;
; SUBROUTINE TO CHECK FOR VALID EXAMINE BEFORE EXECUTING
; A FUNCTION. THIS IS TO HANDLE TGHA PROTOCOL PAUSE.


DVLECK:

	MOV	R0, -(SP)	;SAVE R0
	MOV	R1, -(SP)	;SAVE R1
	MOV	R2, -(SP)	;SAVE R2
	MOV	R3, -(SP)	;SAVE R3
	MOV	DTEBAD,R0	;GET BASE ADR OF DTE REGS
	MOV	DTEPCA,R3	;SETUP COMMUN ADR
	CLR	TE.XA1(R0)	;READ STATUS WORD
	MOV	#DLSTAT-DLPIN,R2 ;FIND THE ADDRESS OF HIS DLSTAT-TO ME
	ADD	DTEHSM(R3),R2
	MOV	R2,TE.XA2(R0)	;READ THAT STATUS WORD
	JSR	PC,DLWEDN	;WAIT FOR EXAMINE
	BCS	1$		;IGNORE INTERRUPT IF NOT STARTED
	TST	TE.XW1(R0)	;VALID EXAMINE ? 4(022)
;4(022)	TST	TE.XW3(R0)	;VALID EXAMINE ?
	BNE	2$		;YES
1$:	CLR	TGCNT		;NO, SET UP 5 SECOND WAIT
	MOV	#1,TGFLAG	;NO, SET TGHA PROGRAM FLAG
	BR	3$		;EXIT
2$:	CLR	TGFLAG		;CLEAR TGHA PROGRAM FLAG
3$:	MOV	(SP)+, R3	;RESTORE R3
	MOV	(SP)+, R2	;RESTORE R2
	MOV	(SP)+, R1	;RESTORE R1
	MOV	(SP)+, R0	;RESTORE R0
	RTS	PC		;RETURN



TGFLAG:	.WORD	0		;FLAG TO INDICATE TGHA IS RUNNING
TGCNT:	.WORD	0		;5 SECOND COUNTER TO WAIT FOR TGHA


;
;THIS ROUTINE HAS BEEN REMOVED
;ITS FUNCTIONS ARE PERFORMED ELSEWHERE


;; HERE ON PDP-10 PROTOCOL ERROR.
;;  ABORT ALL STREAMS AND DISABLE ALL LINES.
;;
;	CLR	R3		;START WITH LINE NUMBER 0
;18$:	MOV	DQLCB(R3),R0	;GET LCB POINTER
;	BEQ	19$		;NONE.
;	BIC	#LS.ENB,(R0)	;DISABLE THE LINE
;	MOV	LB.TC1(R0),R1	;POINT TO BSC TASK
;	BIS	#TCOAB!TCIAB,TCFG2(R1) ;SIGNAL ABORT
;	CMP	#TTHASP,LB.DVT(R0)	;HASP LINE?
;	BEQ	21$		;YES.
;	MOV	LB.TCD(R0),R1	;POINT TO XLATE TASK
;	BIS	#TCOAB!TCIAB,TCFG2(R1) ;SIGNAL ABORT
;19$:	ADD	#2,R3		;NEXT LINE NUMBER * 2
;	CMP	#<NLINES*2>,R3	;DONE ALL THE LINES?
;	BNE	18$		;NO, DO THE REST.
;	BR	DLDRVR		;YES, GO WAIT FOR ANOTHER COMMAND
;;
;; HERE TO ABORT ALL DEVICES ON HASP-LINE
;;
;21$:	MOV	LB.NTC(R0),R2	;GET # OF TCBS FOR HASP LINE
;	BNE	22$		;IF IT HAS'NT BEEN SET, MAKE IT 5
;	MOV	#5,R2		;THATS MAX # OF TCBS HASP LINE
;22$:	MOV	R0,R1		;GET LCB PTR
;23$:	ASL	R2		;DEVICE NUMBER * 2
;	ADD	R2,R1		;ADD DEVICE #
;	ASR	R2		;GET ORIGINAL DEV #
;	MOV	LB.TCD(R1),R1	;POINT TO XLATE TCB OF DEVICE
;	BEQ	24$		;NO TCB FOR THE DEVICE
;	BIS	#TCOAB!TCIAB,TCFG2(R1) ;SIGNAL ABORT
;24$:	SOB	R2,23$		;DO FOR ALL DEVICES ON HASP LINE
;	BR	19$		;GO TO NEXT LINE
;;
;
; SUBROUTINE TO CALL A SUBROUTINE BASED ON AN INDEX.
;  THIS IS USED AS A DISPATCHER.
;
;	R0 = POINTER TO DISPATCH TABLE.  THE FIRST ENTRY IS
;	     THE MAX INDEX, THE REMAINDER BEING POINTERS
;	     TO SUBROUTINES.
;	R1 = INDEX, 0 BASED.
;
; RETURNS WITH C SET IF THE INDEX IS OUT OF RANGE OR IF THE
;  TABLE ENTRY SELECTED CONTAINS A ZERO.  OTHERWISE RETURNS
;  WITH C AS SPECIFIED BY THE SUBROUTINE.
;
DLDISP:	TRACE	TRCTEN,R1	;TRACE DISPATCH PROCESS
	CMP	R1,(R0)+	;IS INDEX IN RANGE?
	BHI	11$		;NO, FATAL ERROR.
	ASL	R1		;YES, COMPUTE INDEX*2
	ADD	R1,R0		;COMPUTE PLACE IN THE TABLE
	MOV	(R0),R1		;PICK UP SUBROUTINE POINTER
	BEQ	11$		;0 = ERROR
	JSR	PC,(R1)		;NON-ZERO, CALL THE SUBROUTINE
	RTS	PC		;RETURN TO CALLER.
;
; HERE IF THE INDEX IS OUT OF RANGE OR IF THE SUBROUTINE POINTER
;  IS ZERO.
;
;11$:	SEC			;FLAG ERROR
;	RTS	PC		;RETURN.


11$:				;HERE TO FLAG ERROR
;	SEC			;FLAG ERROR--THIS MAY BE NECCESSARY
.IF NE,DEBUG
	STOPCD	TER		;TEN ERROR IN ARGUMENTS
.ENDC ;.IF NE DEBUG
	RTS	PC		;RETURN.
;
;
;
; THE FOLLOWING COMMENTS DESCRIBE THE STATES FOR THE STATE-DRIVEN
;  DTE PROCESSOR.  THERE ARE TWO, LOOSELY COUPLED STATE
;  MACHINES.
;
; ABBREVIATIONS USED IN THE DESCRIPTION BELOW ARE AS FOLLOWS:
;
;  FEH - FRONT-END HEADER.  THIS IS A DIRECT MESSAGE THAT
;	DESCRIBES THE INDIRECT DATA THAT FOLLOWS AS "STRING DATA".
;
;  EH - ED HEADER.  THIS IS AN INDIRECT MESSAGE THAT DESCRIBES THE
;	FOLLOWING INDIRECT MESSAGE (IF ANY) AS "WRITE DATA", 
;	"WRITE LINE COMMAND", "READ DATA", ETC.
;
;  ED - ED DATA.  THIS IS THE INDIRECT MESSAGE DESCRIBED BY
;	THE EH MESSAGE ABOVE.
;
;  ACK - ACKNOWLEDGE.  THIS MESSAGE ACKNOWLEDGES RECEIPT AND
;	PROCESSING OF THE LAST INDIRECT MESSAGE.
;
; A PROPER SEQUENCE CONSISTS OF FEH, EH OR FEH, EH, FEH, ED.
;  WHERE RELAVENT, AN FEH IS REFERED TO AS "FEH FOR EH" OR
;  "FEH FOR ED" BASED ON THE MESSAGE THAT FOLLOWS THE FEH.
;
; EACH MESSAGE IS PRECEEDED BY A DOORBELL.
;
; BEFORE AN FEH MAY BE SENT THE PREVIOUS FEH AND ITS FOLLOWING
;  EH OR ED MUST BE ACKNOWLEDGED.  THIS IS A SIMPLIFICATION OF
;  THE TOPS-20 RULE.
;
; A COMPLETE TRANSACTION IS ALWAYS INITIATED BY THE -20
;  WITH AN FEH FOLLOWED BY AN EH.  DEPENDING ON THE
;  CONTENTS OF THE EH, IT MAY BE FOLLOWED BY FEH, ED.
;  THE PDP-11 REPLIES WITH FEH, EH AND, DEPENDING ON THE
;  CONTENTS OF THE FIRST EH, MAY FOLLOW THIS BY
;  FEH, ED.  EXAMINE AND DEPOSIT DO NOT USE ED IN
;  EITHER DIRECTION.  NO FUNCTIONS USES ED IN BOTH
;  DIRECTIONS.
;
; BELOW THE DESCRIPTION OF EACH STATE IS A BRIEF DESCRIPTION OF
;  THE ACTION TAKEN WHEN THE APPROPRIATE EVENT OCCURS.
;
;
; STATE MACHINE "A" IS DRIVEN BY 11-DONE INTERRUPTS AND BY DOORBELLS.
;
;
;  0: WAITING FOR INITIAL DOORBELL.  11-DONE IS INVALID.
;	READ FEH FOR EH.
;
;  2: WAITING FOR FEH FOR EH.  DOORBELL IS INVALID.
;	IF DEVICE IS WRONG, GO TO STATE 34.
;	IF ALLOCATION MESSAGE, GO TO STATE 34.
;	OTHERWISE, READ EH.
;
;  4: WAITING FOR DOORBELL FOR EH.  11-DONE IS INVALID.
;	READ EH.
;
;  6: WAITING FOR EH.  DOORBELL IS INVALID.
;	IF FLAG DT10AK INDICATES THAT ED IS TO COME, THEN
;	SEND ACK ONLY.  SET MACHINE B FROM STATE 0 TO 2.
;	IF DT10AK INDICATES THAT THERE IS NO ED, GO TO
;	  STATE 20, ELSE GO TO STATE 10.
;
; 10: WAITING FOR DOORBELL FOR FEH FOR ED.  11-DONE IS INVALID.
;	READ FEH FOR ED.
;
; 12: WAITING FOR FEH FOR ED.  DOORBELL IS INVALID.
;	GO TO STATE 14.
;
; 14: WAITING FOR DOORBELL FOR ED.  11-DONE IS INVALID.
;	READ ED.
;
; 16: WAITING FOR ED.  DOORBELL IS INVALID.
;	IF MACHINE "B" IS AT STATE 4, SEND ACK+FEH AND
;	  SET MACHINE "B" TO STATE 10, THEN GO TO STATE 22.
;	IF MACHINE "B" IS NOT AT STATE 4, GO TO STATE 20.
;
; 20: WAITING FOR ACK OF EH TO COMPLETE.  (I.E., FOR MACHINE "B"
;      TO GO FROM STATE 2 TO STATE 6 OR 10.)  NEITHER 11-DONE
;      NOR DOORBELL ARE VALID.
;
;
; 22: WAITING FOR DOORBELL FOR ACK FOR EH.  11-DONE IS INVALID.
;	READ ACK FOR EH.
;
; 24: WAITING FOR ACK FOR EH.  DOORBELL IS INVALID.
;	IF THE EH INDICATES THAT NO ED WILL BE RETURNED, 
;	  AND MACHINE "B" IS IN STATE 14, SET BOTH STATES TO ZERO.
;	  IF MACHINE "B" IS NOT IN STATE 14,
;	  GO TO STATE 32.
;	IF THE EH INDICATES THAT AN ED WILL BE RETURNED,
;	  AND MACHINE "B" IS IN STATE 14,
;	  SEND FEH FOR ED, SET MACHINE "B" TO STATE 16
;	  AND GO TO STATE 26.
;	  IF MACHINE "B" IS NOT IN STATE 14, JUST GO TO STATE 26.
;
; 26: WAITING FOR DOORBELL FOR ACK FOR ED.  11-DONE IS INVALID.
;	READ ACK FOR ED.
;
; 30: WAITING FOR ACK FOR ED.  DOORBELL IS INVALID.
;	IF MACHINE "B" IS IN STATE 22, SET
;	  THE STATES OF BOTH MACHINES TO 0.
;	IF MACHINE "B" IS NOT IN STATE 22, GO TO STATE 32.
;
; 32: GOT FINAL ACK.  11-DONE AND DOORBELL ARE INVALID.
;
; 34: IGNORING 11-DONE.
;	IF WE GET AN 11-DONE, IGNORE IT.
;	IF WE GET A DOORBELL, TREAT IT THE SAME AS FOR STATE 0.
;
;
; STATE MACHINE "B" IS DRIVEN BY 10-DONE.
;
;  0: IDLE.  10-DONE IS INVALID.
;
;  2: WAITING FOR COMPLETION OF ACK (OR ACK+FEH) FOR EH.
;	IF MACHINE "A" IS NOT IN STATE 20, JUST GO TO STATE 4.
;	IF MACHINE "A" IS IN STATE 20, SET IT TO STATE 22.
;	IF DT10AK INDICATES THAT AN ED WILL FOLLOW IT,
;	SEND AN ACK + FEH (MACHINE "A" HAS ALREADY PROCESSED THE ED
;	OR IT WOULD NOT BE IN STATE 20) AND GO TO STATE 10.
;	IF DT10AK INDICATES THAT AN ED WILL NOT FOLLOW IT,
;	SEND EH TO-TEN FOR SENDING RESULTS BACK.
;	AND THEN GO TO STATE 10 TO WAIT FOR EH COMPLETION.
;
;  4: GOT COMPLETION OF ACK FOR EH.  10-DONE IS INVALID.
;
;  6: WAITING FOR COMPLETION OF ACK FOR ED.
;	SEND FEH FOR EH.
;
; 10: WAITING FOR COMPLETION OF FEH FOR EH.
;	SEND EH.
;
; 12: WAITING FOR COMPLETION OF EH.
;	IF MACHINE "A" IS IN STATE 26 THEN
;	  SEND FEH FOR ED AND GO TO STATE 16.
;	IF MACHINE "A" IS NOT IN STATE 26 THEN
;	  GO TO STATE 14.
;
; 14: WAITING FOR ACK FOR EH.  10-DONE IS INVALID.
;
; 16: WAITING FOR COMPLETION OF FEH FOR ED.
;	SEND ED.
;
; 20: WAITING FOR COMPLETION OF ED.
;	IF MACHINE "A" IS IN STATE 32 THEN SET BOTH STATES
;	  TO 0, OTHERWISE GO TO STATE 22.
;
; 22: WAITING FOR ACK FOR ED.  10-DONE IS INVALID.
;
.SBTTL 		TO-TEN DONE INTERRUPT PROCESSING FOR DTE20
;
; THIS ROUTINE DECIDES WHAT TO DO WHEN A TO-TEN DONE INTERRUPT
;  IS RECOGNIZED.  IT IMPLEMENTS MACHINE "B" DESCRIBED ABOVE.
;
DLTXDN:	TRACE	TRCTEN,DTQSTA	;TRACE FOR TEN STATE
	MOV	DTEBAD,R0	;GET BASE ADR OF DTE REGS
	MOV	DTEPCA,R3	;SETUP COMMUNICATION BASE ADR
	DEC	DTIXDN		;DECREMENT INTP COUNT
	MOVB	DT10ST,R1	;FIND WHAT STATE THE TEN IS
	JSR	PC,@11$(R1)	;THEN CALL APPROPRIATE ROUTINE
				;TO PROCESS TO-TEN DONE INTERRUPT
	CLC			;SUCCESSFUL 
	RTS	PC		;RETURN
;
; TO TEN DONE SUBROUTINE CALL TABLE
;
11$:	.WORD	DTXDED		;IDLE STATE
	.WORD	DTXS02		;WAITING FOR COMPLETION OF ACK FOR EH
	.WORD	DTXDED		;GOT COMPLETION OF ACK FOR EH
	.WORD	DTXDED		;THIS IS CURRENTLY UNUSED STATE.
	.WORD	DTXS10		;WAITING FOR COMPLETION OF 
				;ACK + FEH FOR EH
	.WORD	DTXS12		;WAITING FOR COMPLETION OF EH
	.WORD	DTXDED		;WAITING FOR ACK FOR EH
	.WORD	DTXS16		;WAITING FOR COMPLETION OF FEH FOR ED
	.WORD	DTXS20		;WAITING FOR COMPLETION OF ED
	.WORD	DTXDED		;WAITING FOR ACK FOR ED
;
DTXDED:	STOPCD	DTC20		;GOOFY TEN DONE INTERRUPTS
;
;
; HERE ON 10-DONE IN STATE 2.  THE ACK FOR EH IS COMPLETE (WRITES)
; OR WHEN ACK + FEH ARE COMPLETED FOR A READ OPERATION.
;
DTXS02:	CMPB	#20,DT11ST	;IS THE OTHER MACHINE WAITING FOR US?
	BEQ	11$		;YES.
	MOVB	#4,DT10ST	;NO, WE MUST WAIT FOR IT.
	RTS	PC		;RETURN UNTIL IT IS READY.
;
11$:	MOVB	#22,DT11ST	;UNWAIT THE OTHER MACHINE
	TST	DT10AK		;DOES MACHINE "A" WANT ANOTHER ACK (FOR ED)?
	BEQ	DTXS10		;NO.
	JSR	PC,DTSACK	;YES, SEND AN ACK
	MOVB	#10,DT10ST	;WAIT FOR IT TO COMPLETE
	RTS	PC		;RETURN UNTIL IT IS DONE.
;
; HERE WHEN ACK + FEH FOR EH ARE COMPLETE.
;  SEND THE EH.
;
DTXS10:	MOVB	DT10UC(R5),R2	;AMOUNT OF DATA TO BE SENT NOW
	CLRB	DT10UC(R5)	;NO DATA TO FOLLOW THIS
	SWAB	DT10DF(R5)	;SWAP BYTES TO CORRECT DIRECTION IN TEN
	SWAB	DT10AD(R5)	;SWAP DIRECTION OF ADR
	SWAB	DT10DT(R5)	;EXAMINE DATA OR AMT OF XFER
	MOV	R5,R1		;BUILD POINTER TO SECOND PART
	ADD	#DT10DF,R1	; OF HEADER TO TEN
	JSR	PC,DTXISD	;SEND INDIRECT DATA TO TEN
	MOVB	#12,DT10ST	;WAITING FOR EH TO COMPLETE
	RTS	PC		;RETURN
;
;
; HERE WHEN THE EH IS COMPLETE.  WAIT FOR MACHINE "A"
;  IF NECESSARY.  OTHERWISE SEND FEH FOR ED.  IF THERE IS NO
;  ED TO BE RETURNED THEN MACHINE "A" WILL NOT BE IN STATE 26.
;
DTXS12:	CMPB	#26,DT11ST	;IS THE OTHER MACHINE WAITING?
	BEQ	11$		;YES, SEND FEH FOR ED.
	MOVB	#14,DT10ST	;NO, WAIT FOR IT.
	RTS	PC		;RETURN.
;
11$:	MOVB	DT10DT+1(R5),DT10UC(R5)	;BYTE COUNT TO FOLLOW
				;REMEMBER DT10DT WAS SWAPPED EARLIER
	MOV	R5,R1		;BUILD POINTER TO HEADER
	ADD	#DT10HD,R1	;IN TCB AREA
	MOV	#12,R2		;NO OF BYTES TO XFER
	JSR	PC,DTXMSD	;SEND AS DIRECT HEADER
	MOVB	#16,DT10ST	;WAIT FOR FEH FOR ED TO COMPLETE
	RTS	PC		;RETURN
;
; HERE WHEN THE FEH FOR ED IS COMPLETE.  NOW SEND ED.
;
DTXS16:	MOVB	DT10UC(R5),R2	;AMOUNT OF DATA TO XFER NOW
	BIC	#^C<377>,R2	;ONLY 8 BITS PERMITTED IN COUNT
	CLRB	DT10UC(R5)	;NO DATA TO FOLLOW AFTER THIS
	MOV	DTXADR(R5),R1	;R1 PONTS TO DATA TO-TEN
	JSR	PC,DTXISD	;SEND DATA INDIRECT
	MOVB	#20,DT10ST	;WAIT FOR DATA TO COMPLETE
	RTS	PC		;RETURN
;
; HERE WHEN THE ED MESSAGE IS COMPLETE.  BE SURE ITS ACK HAS BEEN PROCESSED
;  (WAIT FOR IT IF NECESSARY).
;
DTXS20:	CMPB	#32,DT11ST	;IS OTHER MACHINE WAITING FOR US?
	BEQ	11$		;YES, MUST BE ALL DONE.
	MOVB	#22,DT10ST	;NO, WE ARE WAITING FOR IT.
	RTS	PC		;RETURN.
;
11$:	JSR	PC,DTCLRS	;CLEAR STATE OF DTE
	RTS	PC		;RETURN.
;
; SUBROUTINE TO CLEAR THE STATE OF THE DTE
;
DTCLRS:	CLRB	DT10ST		;SET TO IDLE STATE
	CLRB	DT11ST		;OTHER MACHINE, TOO.
	CLR	DTXADR(R5)	;INITIALIZE PTR TO IND DATA
	BIC	#DLTHIP!DLTHBM,DTSTT+2 ;CLEAR INDIRECT IN PROGRESS
.IIF NE,DEBUG,CLR DTO10Q(R5)	;DONE WITH SENDING HEADER
	CLR	DT10FN(R5)	;ALL DONE WITH THIS OPERATION
	CLR	DT10AK		;NO EXTRA ACK NEEDED
	RTS	PC		;RETURN
;
;
; SUBROUTINE TO START AN INDIRECT DATA TRANSFER TO - TEN
;
;  R1 = POINTER TO THE DATA TO BE SENT TO TEN
;  R2 = AMOUNT OF DATA TO BE TRANSFERRED
;	(MUST NOT BE LARGER THAN 255)
;
DTXISD:				;START INDIRECT DATA XFER TO-TEN
	MOV	R1,TE.XAD(R0)	;SET THE TO TEN ADDRESS
.IF NE,DEBUG
	MOV	R1,DTXTAS(R5)	;SAVE TO TEN ADR
	MOV	R2,DTXTSZ(R5)	;SAVE SIZE OF XFER
.ENDC
	CLR	TE.XW1(R0)	;DEPOSIT THE WORD COUNT
	CLR	TE.XW2(R0)
.IF NE,DEBUG
	BIT	#^C<377>,R2	;MORE THAN 8 BITS?
	BEQ	11$		;NO.
	STOPCD	DBG		;PROTOCOL CAN'T HANDLE THIS
11$:
.ENDC ;.IF NE,DEBUG
	MOV	R2,TE.XW3(R0)
	MOV	#DLXFSZ-DLPIN,R1 ;DEPOSIT THE SIZE IN 10 MEMORY
	ADD	DTDMYN(R3),R1	;GET OFFSET
	MOV	#TS.DEP,TE.XA1(R0) ;SET DEPOSIT
	MOV	R1,TE.XA2(R0)	;START XFER
	JSR	PC,DLWEDN	;WAIT FOR DEPOSIT
	BCS	12$		;CANNOT
	BIS	#DLTHIP,DTSTT+2	;SAY WE'RE DOING INDIRECT
	MOV	#TS.TBM,TE.DG3(R0) ;AND TELL HARDWARE THAT WE'RE DOING
				; IT IN BYTE MODE
	MOV	DTSTT,TE.XW1(R0);SET IN 10 MEMORY
	MOV	DTSTT+2,TE.XW2(R0)
	MOV	DTSTT+4,TE.XW3(R0)
	ADD	#DLSTAT-DLXFSZ,TE.XA2(R0) ;DEPOSIT IN 10 MEMORY
	JSR	PC,DLWEDN	;WAIT FOR DEPOSIT
	BCS	12$		;CANNOT
	MOV	#TS.EEX,TE.STW(R0) ;RING TENS DOORBELL
	RTS	PC		;RETURN
;
;
; HERE IF EXAMINE OR DEPOSIT FAILED
;
12$:	STOPCD	TER		;UNABLE TO TALK TO THE 10
;
;
; THIS SUBROUTINE HAS TWO ENTRY POINTS . DTSACK TO SEND 
; AN ACK + FEH TO THE TEN AND DTSAK FOR SENDING THE 
; ACK ALONE TO THE TEN TO ACKNOWLEDGE RECEIPT OF DATA.
;
DTSACK:	MOV	#24,R2		;SEND ACK + FEH TOGETHER
	BR	DTSAC		;SET UP ACK HEADER
DTSAK:	MOV	#12,R2		;SEND ONLY THE ACK TO-TEN
DTSAC:
	MOV	#12,DTAKHD(R5)	;LENGTH OF HEADER
	MOV	#DTFSAK,DTAKFN(R5) ;ACK FUNCTION
	MOV	#DLDPFE,DTAKDV(R5) ;FE DEVICE
	CLR	DTAKUC(R5)	;CLEAR BEFORE PUTTING FE#
	MOVB	DT11UC+1(R5),DTAKUC(R5) ;FE# RIGHT JUSTIFIED
	MOV	R5,R1		;GET TCB ADR
	ADD	#DTAKHD,R1	;POINT TO "ACK" BLOCK HEADER
	JSR	PC,DTXMSD	;SEND ACK TO TEN
	RTS	PC		;RETURN
;
.SBTTL		 TO-ELEVEN DONE INTERRUPT PROCESSING
;
; THIS ROUTINE DECIDES WHAT TO DO WHEN A TO-11 DONE
;  INTERRUPT IS RECOGNIZED.  IT IMPLEMENTS PART OF MACHINE "A"
;  DESCRIBED ABOVE.
;
DLELDN:	TRACE	TRCTEN,DTQSTA	;ON ELEVEN DONE STATE
	MOV	DTEBAD,R0	;GET DTE REGS ADR
	MOV	DTEPCA,R3	;PROCESSOR COMM AREA IN R3
	DEC	DTIEDN		;DECREMENT COUNT OF UNPROCESSED INTERRUPTS
	MOVB	DT11ST,R1	;GET PRESENT TO-ELEVEN STATE
	JSR	PC,@11$(R1)	;CALL APPROPRIATE ROUTINE
	RTS	PC		;RETURN
;
11$:	.WORD	DTDED		;IDLE
	.WORD	DTIS02		;WAITING FOR FEH FOR EH
	.WORD	DTDED		;WAITING FOR DOORBELL FOR EH
	.WORD	DTIS06		;WAITING FOR EH
	.WORD	DTDED		;WAITING FOR DOORBELL FOR FEH FOR EH
	.WORD	DTIS12		;WAITING FOR FEH FOR ED
	.WORD	DTDED		;WAITING FOR DOORBELL FOR ED
	.WORD	DTIS16		;WAITING FOR ED
	.WORD	DTDED		;WAITING FOR ACK OF EH TO COMPLETE
	.WORD	DTDED		;WAITING FOR DOORBELL FOR ACK FOR EH
	.WORD	DTIS24		;WAITING FOR ACK FOR EH
	.WORD	DTDED		;WAITING FOR DOORBELL FOR ACK FOR ED
	.WORD	DTIS30		;WAITING FOR ACK FOR ED
	.WORD	DTDED		;GOT FINAL ACK
	.WORD	DTIS34		;IGNORING 11-DONE
;
DTDED:	STOPCD	DTG20		;PROTOCOL BROKEN
;
;
; HERE WHEN FIRST PART OF HEADER IS IN. A CHECK IS MADE FOR FE
;  DEVICE AND IF DEVICE IS INDEED AN FE THEN WE EXPECT A SECOND
;  PART OF HEADER TO FOLLOW; OTHERWISE JUST IGNORE THE HEADER.
;
DTIS02:	SWAB	DT11HD(R5)	;SWAP BYTES TO CORRECT DIRECTION
	SWAB	DT11FN(R5)	;THE PROTOCOL FUNCTION
	SWAB	DT11DV(R5)	;PROTOCOL DEVICE
	SWAB	DT11UC(R5)	;FE#,,COUNT OF BYTES TO FOLLOW
	CMP	#DLDPFE,DT11DV(R5) ;IS THIS HEADER FOR FE DEVICE?
	BNE	11$		;NO,IGNORE THE IRRELEVANT DEVICES
	TST	DT11FN(R5)	;IS IT INDIRECT  DATA
	BMI	12$		;YES,MUST BE STRING DATA
11$:	MOVB	#34,DT11ST	;STATE TO IGNORE 11-DONES.
	RTS	PC		;RETURN
;
12$:	CMPB	#DTFSTR,DT11FN(R5) ;BETTER BE STRING DATA FUNCTION
	BNE	11$		;THROW AWAY OTHER FUNCTIONS
	MOVB	#4,DT11ST	;EXPECT SECOND PART OF HEADER
	RTS	PC		;RETURN
;
;
; HERE WHEN THE EH IS IN.  ACKNOWLEDGE IT AND CONSIDER IT.
;
DTIS06:	SWAB	DT11DF(R5)	;THE DN60 FUNCTION CODE
	SWAB	DT11AD(R5)	;ADDRESS FOR EXAMINE / DEPOSIT
	SWAB	DT11DT(R5)	;DATA FOR DEPOSIT
	TST	DT11FN(R5)	;ALL DATA MUST BE INDIRECT
	BPL	11$		;ITS NOT,PUNISH HIM
	CMPB	#DTFSTR,DT11FN(R5) ;IS IT DN60 FUNCTION?
	BNE	11$		;CANT HANDLE OTHER THAN DN60 FUNCTIONS
	CMP	#DLDPFE,DT11DV(R5) ;LEGAL DEVICE?
	BEQ	12$		;YES, ALL O.K
;
11$:	STOPCD	DTH20		;NO, PROTOCOL BROKEN,ILLEGAL DEVICE
				; OR ILLEGAL FUNCTION
;
12$:	CLR	TCXFR(R5)	;CLEAR BYTE COUNT FOR TO-TEN STATUS BUFFER
	CLR	DT11GW(R5)	;CLEAR SHORT OF CHUNK FLAG
	CLR	DLMBCT(R5)	;INITIALIZE MESSAGE BYTE COUNT
	CLR	DLMCTL(R5)	;AND MESSAGE COUNT LEFT
	MOVB	DT11DF(R5),R1	;GET DN60 FUNCTION-USED AS INDEX
	MOV	#15$,R0		;POINT TO DISPATCH TABLE
	JSR	PC,DLDISP	;DISPATCH
	BCS	14$		;FATAL ERROR
	MOVB	#2,DT10ST	;ARRANGE TO UNDERSTAND WHEN ACK COMPLETES
	TST	DT10AK		;IS THERE AN ED TO COME?
	BNE	13$		;YES.
	JSR	PC,DTSACK	;NO,SEND ACK + FEH TO-TEN
	MOVB	#20,DT11ST	;AND, WAIT FOR ACK TO COMPLETE
	RTS	PC		;RETURN.
;
13$:	JSR	PC,DTSAK	;SEND ACK ALONE TO-TEN
	MOVB	#10,DT11ST	;WAIT FOR DOORBELL FOR THE FEH FOR THE ED
	RTS	PC		;RETURN
;


14$:

;14$:	JSR	PC,DTCERR	;FATAL ERROR

	SEC			;FATAL ERROR

	RTS	PC		;RETURN
;
;
; TABLE FOR PDP-10 INITIATED OPERATIONS
;
15$:	.WORD	<<16$-15$>/2>-2 ;MAXIMUM INDEX
	.WORD	0		;FUNCTION ZERO INVALID
	.WORD	DLTRDT		;1=READ DATA INTO THE PDP-10
	.WORD	DLTWDT		;2=WRITE DATA FROM THE PDP-10
	.WORD	DLTRDS		;3=READ DEVICE STATUS
	.WORD	DLTWDC		;4=WRITE DEVICE COMMAND
	.WORD	DLTRLS		;5=READ LINE STATUS
	.WORD	DLTWLC		;6=WRITE LINE COMMAND
	.WORD	DLTRES		;7=READ DN60 STATUS
	.WORD	DLTWEC		;8=WRITE DN60 COMMAND
	.WORD	DLTEXM		;9=EXAMINE 11 LOCATION
	.WORD	DLTDEP		;10=DEPOSIT IN 11 LOCATION
;
16$:				;END OF TABLE
;
;
; HERE WHEN WE RECEIVE THE FEH FOR THE ED.  NOW WE NEED THE ED.
;
DTIS12:	SWAB	DT11HD(R5)	;SWAP BYTES TO CORRECT DIRECTION
	SWAB	DT11FN(R5)	;PROTOCOL FUNCTION
	SWAB	DT11DV(R5)	;PROTOCOL DEVICE CODE
	SWAB	DT11UC(R5)	;UNIT AND BYTE COUNT
	MOVB	#14,DT11ST	;WAIT FOR ANOTHER DOORBELL
	RTS	PC		;RETURN.
;
; HERE WHEN THE ED HAS ARRIVED.  PROCESS IT.
;
DTIS16:	
.IF NE,DEBUG
	CMPB	#2,DT11DF(R5)	;DOING A WRITE OF DATA?
	BNE	11$		;NO.
	TST	@DT11AS(R5)	;TEST FOR ZERO WORD
	BNE	11$		;NON ZERO, IT IS OK.
.IF NE,PADBUG
	BR	11$		;DON'T STOP, HE TRANSMITS ZERO'S
.ENDC				;IF NE, PADBUG
	STOPCD	DBG		;THIS IS PROBABLY AN ERROR
11$:
.ENDC ;.IF NE,DEBUG
	TST	DT11GW(R5)	;OPERATION DELAYED OR REJECTED??
	BNE	19$		;YES
	CMPB	#2,DT11DF(R5)	;IS IT A WRITE?
	BEQ	16$		;YES
	CMPB	#4,DT11DF(R5)	;WAS IT DATA FOR DEVICE STATUS?
	BNE	12$		;NO
	JSR	PC,DLTWD1	;YES,SETUP DEVICE STATUS
	BCS	15$		;FATAL ERROR
	BR	19$		;UPDATE STATE
;
12$:	CMPB	#6,DT11DF(R5)	;IS IT FOR WRITE LINE STATUS?
	BNE	13$		;NO
	JSR	PC,DLTWL1	;YES,SETUP LINE STATUS
	BCS	15$		;FATAL ERROR
	BR	19$		;UPDATE STATE AND RETURN
;
13$:	CMPB	#10,DT11DF(R5)	;NO,IS IT WRITE DN60 STATUS
	BNE	14$		;NO,
	JSR	PC,DLTWS1	;YES,SETUP DN60 STATUS
	BCS	15$		;FATAL ERROR
	BR	19$		;UPDATE STATE AND RETURN
;
14$:	STOPCD	DTB20		;GOOFY ELEVEN DONE INTP
;




15$:
;15$:	JSR	PC,DTCERR	;COMMON ERROR RETURN

	SEC			;COMMON ERROR RETURN

	RTS	PC		;RETURN
;
;
; HERE IT HAS TO BE A PLAIN SIMPLE WRITE TO - ELEVEN DATA
;
16$:	MOV	R0,R2		;SAVE DTE ADDRESS
	JSR	PC,DLTEDN	;SETUP CHUNKS TO RECEIVE DATAIN
	TST	DT11GW(R5)	;SHORT OF CHUNKS??
	BNE	21$		;YES
	TST	R0		;ANYTHING LEFT TO TRANSFER?
	BEQ	18$		;NOTHING LEFT TO XFER
17$:	JSR	PC,DTSTRT	;MORE TO RECEIVE, START IT
	RTS	PC
;
; HERE WHEN WE APPEAR TO HAVE RUN OUT OF DATA TO TRANSFER.
;
18$:	TST	DLMCTL(R5)	;ANY MORE TO XFER?
	BGT	14$		;BETTER NOT BE!!!
	MOVB	#1,DT10DF+1(R5)	;SUCCESS CODE TO TEN
19$:	JSR	PC,DTCMRT	;SET UP INFO TO RETURN TO THE 10
	CMPB	#4,DT10ST	;IS OTHER MACHINE WAITING FOR US?
	BEQ	20$		;YES, SEND ACK AND ADVANCE IT.
	MOVB	#20,DT11ST	;NO, WAIT FOR IT.
	RTS	PC		;RETURN.
;
; HERE IF THE OTHER STATE MACHINE IS WAITING FOR US.
;
20$:	JSR	PC,DTSACK	;SEND ACK FOR ED
	MOVB	#10,DT10ST	;ARRANGE TO UNDERSTAND THAT ACK
	MOVB	#22,DT11ST	;WAIT FOR DOORBELL FOR ACK FOR EH
	RTS	PC		;RETURN.
;
; HERE IF WE ARE SHORT OF CHUNKS.
;
21$:	MOV	#1,R0		;TRANSFER ONE DUMMY WORD
	MOV	R5,R1		;IN THE TCB
	ADD	#DT11GW,R1	;AT THIS LOCATION
	BR	17$		;AND INTERRUPT BOTH PROCESSORS
;
;
; HERE WHEN WE SHOULD HAVE GOTTEN AN ACK FOR THE EH.
;
DTIS24:	SWAB	DT11HD(R5)	;SWAP BYTES TO CORRECT DIRECTION
	SWAB	DT11FN(R5)	;PROTOCOL FUNCTION
	SWAB	DT11DV(R5)	;PROTOCOL DEVICE CODE
	SWAB	DT11UC(R5)	;BE SURE THEY'RE ALL SWAPPED
	CMPB	#DTFSAK,DT11FN(R5) ;IS IT REALLY AN ACK?
	BEQ	11$		;YES.
	STOPCD	TER		;NO, SOMETHING HAS GONE WRONG.
;
11$:	TST	DTXADR(R5)	;WILL AN ED BE RETURNED?
	BNE	13$		;YES.
	CMPB	#14,DT10ST	;NO, IS OTHER MACHINE WAITING?
	BNE	12$		;NO.
	JSR	PC,DTCLRS	;YES, CLEAR OUT STATE
	RTS	PC		;ALL DONE.
;
; HERE WHEN OTHER SIDE IS NOT WAITING.
;
12$:	MOVB	#32,DT11ST	;WE MUST WAIT FOR IT
	RTS	PC		;RETURN.
;
; HERE WHEN AN ED WILL BE RETURNED
;
13$:	CMPB	#14,DT10ST	;IS THE OTHER MACHINE WAITING?
	BEQ	14$		;YES.
	MOVB	#26,DT11ST	;NO, WAIT FOR IT.
	RTS	PC		;RETURN.
;
; HERE WHEN THE OTHER SIDE IS WAITING FOR US TO START THE ED
;
14$:	MOVB	DT10DT+1(R5),DT10UC(R5)	;ED BYTE COUNT TO FOLLOW
	MOV	R5,R1		;BUILD POINTER TO HEADER
	ADD	#DT10HD,R1	; IN TCB AREA
	MOV	#12,R2		;NO. OF BYTES TO XFER TO TEN
	JSR	PC,DTXMSD	;SEND AS DIRECT HEADER
	MOVB	#16,DT10ST	;ARRANGE TO UNDERSTAND WHEN TO-10 DONE COMES UP
	MOVB	#26,DT11ST	;WAIT FOR ACK OF ED
	RTS	PC		;RETURN.
;
;
; HERE WHEN WE EXPECT AN ACK FOR ED
;
DTIS30:	SWAB	DT11HD(R5)	;SWAP BYTES TO CORRECT DIRECTION
	SWAB	DT11FN(R5)	;PROTOCOL FUNCTION
	SWAB	DT11DV(R5)	;PROTOCOL DEVICE CODE
	SWAB	DT11UC(R5)	;BE SURE THEY'RE ALL SWAPPED
	CMPB	#DTFSAK,DT11FN(R5) ;IS IT REALLY AN ACK?
	BEQ	11$		;YES.
	STOPCD	TER		;NO, SOMETHING HAS GONE WRONG.
;
11$:	CMPB	#22,DT10ST	;IS THE OTHER SIDE WAITING?
	BNE	12$		;NO, WAIT FOR IT.
	JSR	PC,DTCLRS	;YES, CLEAR STATE.
	RTS	PC		;RETURN.
;
; HERE WHEN THE OTHER SIDE IS NOW WAITING.  WAIT FOR IT.
;
12$:	MOVB	#32,DT11ST	;GOT FINAL ACK
	RTS	PC		;RETURN.
;
; HERE WHEN WE ARE IGNORING 11-DONE INTERRUPTS
;
DTIS34:	INC	DTPTCT		;COUNT TIMES 11-DONE IGNORED
	RTS	PC		;RETURN, LEAVING STATE AS IS.
;
.SBTTL		 DOORBELL INTERRUPT PROCESSING FOR DTE20
;
; THIS IS THE REST OF MACHINE "A".
;
DLDRBL:	TRACE	TRCTEN,DTQSTA	;ON THE ELEVEN DONE STATE
	DEC	DTIDBL		;DECREMENT DOORBELL INTP COUNT
	MOV	DTEBAD,R0	;GET BASE ADR OF DTE REGS
	MOV	DTEPCA,R3	;SETUP COMMUN ADR
	CLR	TE.XA1(R0)	;READ STATUS WORD
	MOV	#DLSTAT-DLPIN,R2 ;FIND THE ADDRESS OF HIS DLSTAT-TO ME
	ADD	DTEHSM(R3),R2
	MOV	R2,TE.XA2(R0)	;READ THAT STATUS WORD
	JSR	PC,DLWEDN	;WAIT FOR EXAMINE
	BCS	13$		;IGNORE INTERRUPT IF NOT STARTED
	MOV	TE.XW1(R0),TCSTFX(R5)	;SAVE STATUS
	MOV	TE.XW2(R0),TCSTFX+2(R5)
	MOV	TE.XW3(R0),TCSTFX+4(R5)
	TST	TCSTFX(R5)	;VALID EXAMINE?
	BEQ	13$		;IGNORE WHEN NOT IN PRIMARY PROTOCOL
11$:	BIT	#DLTHIP,TCSTFX+2(R5) ;INDIRECT IN PROGRESS
	BNE	12$		;YES, DONT CHECK COUNTS
	CMPB	TCSTFX+4(R5),DT10QC ;IS THIS THE CORRECT COUNT
	BEQ	13$		;YES -- CONTINUE PROCESSING
12$:	MOVB	DT11ST,R1	;GET STATE OF THIS "MACHINE"
	JSR	PC,@14$(R1)	;CALL APPROPRIATE ROUTINE
13$:	RTS	PC		;RETURN.
;
; DISPATCH TABLE FOR DOORBELL INTERRUPTS, BASED ON STATE OF MACHINE "A"
;
14$:	.WORD	DTIS00		;WAITING FOR INITIAL DOORBELL
	.WORD	15$		;WAITING FOR FEH FOR EH
	.WORD	DTIS04		;WAITING FOR DOORBELL FOR EH
	.WORD	15$		;WAITING FOR EH
	.WORD	DTIS10		;WAITING FOR DOORBELL FOR FEH FOR ED
	.WORD	15$		;WAITING FOR FEH FOR ED
	.WORD	DTIS14		;WAITING FOR DOORBELL FOR ED
	.WORD	15$		;WAITING FOR ED
	.WORD	15$		;WAITING FOR ACK OF EH TO COMPLETE
	.WORD	DTIS22		;WAITING FOR DOORBELL FOR ACK FOR EH
	.WORD	15$		;WAITING FOR ACK FOR EH
	.WORD	DTIS26		;WAITING FOR DOORBELL FOR ACK FOR ED
	.WORD	15$		;WAITING FOR ACK FOR ED
	.WORD	15$		;GOT FINAL ACK
	.WORD	16$		;IGNORING 11-DONE
;
; HERE ON DOORBELL IN INVALID STATE
;
15$:	STOPCD	DTD20		;ERROR
;
;
; HERE ON DOORBELL WHEN IGNORING 11-DONE
;
16$:	JSR	PC,DTCLRS	;CLEAR STATE
;	JMP	DTIS00		;TREAT AS INITIAL DOORBELL
;
; HERE ON DOORBELL INITIALLY
;
DTIS00:	MOV	R5,R1		;BUILD POINTER TO WHERE HEADER
	ADD	#DT11HD,R1	; MUST BE SAVED
	JSR	PC,DTHDST	;START TRANSFER OF HEADER
	MOVB	#2,DT11ST	;UNDERSTAND THE RESULTING 11-DONE
	RTS	PC		;RETURN.
;
; HERE WHEN WE ARE WAITING FOR DOORBELL FOR FEH FOR EH
;
DTIS04:	JSR	PC,DTINDH	;GET SECOND PART OF HEADER
	MOVB	#6,DT11ST	;UNDERSTAND RESULTING 11-DONE
	RTS	PC		;RETURN.
;
; HERE WHEN WE ARE WAITING FOR DOORBELL FOR FEH FOR ED
;
DTIS10:	MOV	R5,R1		;BUILD POINTER TO WHERE HEADER
	ADD	#DT11HD,R1	; SHOULD GO
	JSR	PC,DTHDST	;GET FEH FOR ED IN
	MOVB	#12,DT11ST	;UNDERSTAND RESULTING 11-DONE INTERRUPT
	RTS	PC		;RETURN.
;
; HERE WHEN WE ARE WAITING FOR DOORBELL FOR ED.
;
DTIS14:	JSR	PC,DTINST	;SET UP TO READ REAL DATA (FINALLY!)
	MOVB	#16,DT11ST	;UNDERSTAND RESULTING 11-DONE
	RTS	PC		;RETURN.
;
; HERE WHEN WE ARE WAITING FOR DOORBELL FOR ACK FOR EH.
;
DTIS22:	MOV	R5,R1		;BUILD POINTER TO WHERE HEADER
	ADD	#DT11HD,R1	; SHOULD GO
	JSR	PC,DTHDST	;GET ACK IN
	MOVB	#24,DT11ST	;UNDERSTAND RESULTING 11-DONE
	RTS	PC		;RETURN.
;
; HERE WHEN WE ARE WAITING FOR DOORBELL FOR ACK FOR ED.
;
DTIS26:	MOV	R5,R1		;BUILD POINTER TO WHERE HEADER
	ADD	#DT11HD,R1	; SHOULD GO
	JSR	PC,DTHDST	;GET ACK IN
	MOVB	#30,DT11ST	;UPDATE THE STATE
	RTS	PC		;RETURN.
;
.SBTTL		 QUEUED PROTOCOL INTERFACE FOR DTE20
;
; CALLED TO START THE TRANSFER OF A DIRECT TO-11 MESSAGE.
;
; R1 = ADDRESS OF PLACE TO PUT THE HEADER
;
DTHDST:	BIT	#DLTHIP,TCSTFX+2(R5) ;IS THE MESSAGE DIRECT?
	BEQ	11$		;YES.
	STOPCD	TER		;NO, TEN MADE AN ERROR.
;
11$:	BIS	#DLTOIT,DTSTT+2	;SET QUEUE IN PROGRESS
	INCB	DT10QC		;INDICATE Q UPDATED
	CMPB	TCSTFX+4(R5),DT10QC ;COUNT CORRECT?
	BEQ	12$		;YES -- PROCEED
	STOPCD	DTF20		;COUNT INCORRECT ERROR
;
12$:	MOV	#TS.DEP,TE.XA1(R0) ;SET UP TO DEPOSIT
	MOV	DTSTT,TE.XW1(R0) ;THE STATUS
	MOV	DTSTT+2,TE.XW2(R0) ;IN MY AREA TO HIM
	MOV	DTSTT+4,TE.XW3(R0) ;TO TELL QUE IN PROGRESS
	MOV	#DLSTAT-DLPIN,R2 ;GET STATUS WORD OFFSET
	ADD	DTDMYN(R3),R2 	;IN COMM AREA
	MOV	R2,TE.XA2(R0)	;START THE DEPOSIT
	JSR	PC,DLWEDN	;WAIT FOR DEPOSIT
	BCS	14$		;ERROR
	MOV	#DLXFSZ-DLPIN,R2 ;FIND THE QUEUE SIZE
	ADD	DTEHSM(R3),R2	;EXAMINE HIS FOR ME
	CLR	TE.XA1(R0)	;CLEAR DEPOSIT BIT
	MOV	R2,TE.XA2(R0)	;DO THE EXAMINE FOR SIZE
	MOV	R0,R2		;SAVE BASE ADR OF DTE20
	JSR	PC,DLWEDN	;WAIT FOR EXAMINE/DEPOSIT
	BCS	14$		;EXAMINE FAILED
	MOV	TE.XW3(R0),DTEQSZ(R5) ;SET UP Q SIZE
				;THIS AUTOMATICALLY SETS UP DTEQSZ
	MOV	DTEQSZ(R5),R0	;NO OF BYTES TO XFER FOR HEADER
13$:	MOV	R0,DLMCTL(R5)	;NO OF BYTES LEFT TO XFER
	JSR	PC,DTSTRT	;START TRANSFER
	RTS	PC		;RETURN TO CALLER
;
; HERE IF EXAMINE OR DEPOSIT FAILS
;
14$:	STOPCD	TER		;SOMETHING FAILED
;
;
; HERE ON DOORBELL WHEN WE ARE EXPECTING THE EH.  READ IT
;  INTO THE SECOND PART OF THE HEADER AREA OF THE TCB.
;
DTINDH:	BIS	#DLTOIT,DTSTT+2	;TELL -10 WE SHOULD BE MOVING DATA
	ADD	#DLXFSZ-DLSTAT,TE.XA2(R0) ;READ THE STATUS WORD
	JSR	PC,DLWEDN	;WAIT FOR EXAMINE
	BCS	11$		;CANNOT
	MOV	R0,R2		;WE NEED R0
	MOV	TE.XW3(R2),R0	;GET MESSAGE LENGTH
	MOV	R0,DTEQSZ(R5)	;SAVE LENGTH OF MESSAGE
	MOV	R0,DLMCTL(R5)	;SETUP MESSAGE COUNT LEFT TO XFER
	CMP	R0,#6		;SECOND PART OF HEADER MUST NOT BE GREATER THAN
				; SIX BYTES
	BHI	12$		;SOMETHING VERY WRONG WITH DDT60 OR D60SPD (OR D60SPL?)
	MOV	R5,R1		;POINT TO WHERE SECONDARY HEADER MUST GO
	ADD	#DT11DF,R1	; IN THE TCB AREA
	JSR	PC,DTSTRT	;START THE TRANSFER
	JMP	DTSTIP		;SET STATUS AND RETURN
;
; HERE IF WE CANNOT EXAMINE THE -10'S MEMORY
;
11$:	STOPCD	TER		;PERHAPS IT HAS FAILED
;
; HERE IF THE LENGTH IS MORE THAN 6 BYTES
;
12$:	STOPCD	TER		;ERROR IN DEC-20 USER PROGRAM
;
;
; HERE ON PDP-10 PROTOCOL ERROR.
;  ABORT ALL STREAMS AND DISABLE ALL LINES.
;
DTCERR:				;ERROR RETURN FOR SET DEV AND LINE
.IF NE,DEBUG
	BIT	#TRCTER,TRCHLT	;STOP ON PDP-10 ERRORS?
	BEQ	11$		;NO.
	STOPCD	TER		;YES, PDP-10 ERROR
11$:
.ENDC ;.IF NE,DEBUG
	CLR	R3		;START WITH LINE NUMBER 0
12$:	MOV	DQLCB(R3),R0	;GET LCB POINTER
	BEQ	13$		;NONE.
	BIS	#LF.DIS,LB.FGS(R0) ;DTE DISABLED THE LINE
	MOV	LB.TC1(R0),R1	;POINT TO BSC TASK
	CMP	#TTHASP,LB.DVT(R0)	;HASP LINE?
	BEQ	21$		;YES.
	BIS	#TCOAB!TCIAB,TCFG2(R1) ;SIGNAL ABORT
	MOV	LB.TCD(R0),R1	;POINT TO XLATE TASK
	BIS	#TCOAB!TCIAB,TCFG2(R1) ;SIGNAL ABORT
13$:	ADD	#2,R3		;NEXT LINE NUMBER * 2
	CMP	#<NLINES*2>,R3	;DONE ALL THE LINES?
	BNE	12$		;NO, DO THE REST.
	SEC			;SIGNAL FAILURE
	RTS	PC		;RETURN
;
;
; HERE TO ABORT ALL DEVICES ON HASP-LINE
;
21$:	BIT	#LF.ENC,LB.FGS(R0) ;LINE ENABLE COMPLETE?
	BEQ	13$		;NO, CHECK NEXT LINE
	MOV	LB.NTC(R0),R2	;GET # OF TCBS FOR HASP LINE
	BNE	22$		;IF IT HAS'NT BEEN SET, MAKE IT 5
	MOV	#5,R2		;THATS MAX # OF TCBS HASP LINE
22$:	MOV	R0,R1		;GET LCB PTR
	ASL	R2		;DEV NO * 2
	ADD	R2,R1		;ADD DEVICE #
	ASR	R2		;GET BACK DEV NO
	MOV	LB.TCD(R1),R1	;POINT TO XLATE TCB OF DEVICE
	BEQ	24$		;NO TCB FOR THE DEVICE
	BIS	#TCOAB!TCIAB,TCFG2(R1) ;SIGNAL ABORT
24$:	SOB	R2,22$		;DO FOR ALL DEVICES ON HASP LINE
	BR	13$		;GO TO NEXT LINE
;
;
; CALLED WHEN THE DOORBELL REQUESTING THE START OF THE INDIRECT
;  DATA RINGS. DLEDBL IS NOTIFIED AND RETURNS WHERE THE DATA SHOULD BE
;  SENT. NOTE THAT IT NEED NOT ALLOCATE SPACE FOR THE ENTIRE MESSAGE.
;
DTINST:	BIS	#DLTOIT,DTSTT+2	;TELL -10 WE SHOULD BE XFERRING DATA
	ADD	#DLXFSZ-DLSTAT,TE.XA2(R0) ;READ THE STATUS WORD
	JSR	PC,DLWEDN	;WAIT FOR EXAMINE
	BCS	13$
	MOV	R0,R2		;WE NEED R0
	MOV	TE.XW3(R2),R0	;GET MESSAGE LENGTH
	MOV	R0,DTEQSZ(R5)	;SAVE LENGTH OF MESSAGE
	MOV	R0,DLMBCT(R5)	;SAVE MESSAGE BYTE COUNT
	MOV	R0,DLMCTL(R5)	;SETUP MESSAGE COUNT LEFT TO XFER
	TST	DT11GW(R5)	;OPERATION DELAYED BY XLATE?
	BNE	11$		;YES,TRANSFER ONLY DUMMY WORD
	JSR	PC,DLEDBL	;TELL DN64 INTERFACE THE GOOD NEWS
	BCS	14$		;FATAL ERROR
	TST	DT11GW(R5)	;SHORT OF CHUNKS?
	BEQ	12$		;NO,LOOKS O.K
11$:	MOV	#1,R0		;YES,THEN TRANSFER ONE DUMMY WORD
	MOV	R5,R1		;GET TCB ADR
	ADD	#DT11GW,R1	;AT THIS LOCATION
12$:	JSR	PC,DTSTRT	;START UP THE TRANSFER
	BR	DTSTIP		;STORE STATUS WORD IN COMM 
				;REGION AND DISMISS INTERRUPT
;
13$:	RTS	PC
;
14$:	STOPCD	TER		;ERROR FROM DLEDBL
;
;
; SERVICE ROUTINES FOR INTERRUPT CODE
;
DTIPDN:	BIC	#DLTOIT,DTSTT+2	;CLEAR PROCESSING QUEUE STATUS
DTSTIP:	MOV	DTEBAD,R0	;MAKE SURE THIS IS SETUP
	MOV	#DLSTAT-DLPIN,R2 ;YES -- BETTER INDICATE THAT 11 IS FINISHED
	ADD	DTDMYN(R3),R2	;POINT TO STATUS WORD
	MOV	#TS.DEP,TE.XA1(R0) ;INDICATE WRITE
	MOV	DTSTT,TE.XW1(R0) ;SET UP TO DEPOSIT
	MOV	DTSTT+2,TE.XW2(R0)
	MOV	DTSTT+4,TE.XW3(R0)
	MOV	R2,TE.XA2(R0)	;START XFER
	JSR	PC,DLWEDN	;WAIT FOR DEPOSIT
11$:	RTS	PC		;RETURN TO TOELDN OR DBLRNG
;
;
; ROUTINE TO START A TO-11 BYTE MODE TRANSFER.
;
; CALL:
;
;	R0/	# OF BYTES TO TRANSFER
;	R1/	WHERE TO START DATA
;
DTSTRT:	MOV	R0,DT11QP(R5)	;SAVE AMOUNT TO BE XFERED
	TST	DT11GW(R5)	;NO CHUNK FLAG SET?
	BNE	11$		;YES,BYPASS MANIPULATING COUNT
	SUB	R0,DLMCTL(R5)	;COUNT LEFT FOR NEXT XFER
	ADD	R0,TCXFR(R5)	;TOTAL AMOUNT OF DATA WRITTEN FOR XLATE
11$:	NEG	R0		;MAKE COUNT NEGITIVE
	BIC	#170000,R0	;MASK OFF COUNT
	RORB	R0		;!!!WARNING THIS ASSUMES C BIT IS SET BY NEG R0!!!!^^
	BIT	#DLTHBM,TCSTFX+2(R5) ;WORD MODE?
	BNE	12$		;YES -- DON'T SET BYTE FLAG
	ROLB	R0		;!!^^SEE ABOVE -- RESTORE TO BYTE COUNT!!
	BIS	#TS.EBM,R0	;SET BYTE MODE
	TST	DT11GW(R5)	;DUMMY WORD XFER??
	BNE	13$		;YES,INTERRUPT BOTH
12$:	TST	DLMCTL(R5)	;WILL THIS FINISH MESSAGE?
	BGT	14$		;NO, DON'T INTERRUPT -10
13$:	BIS	#TS.IFB,R0 	;SET INTERRUPT BOTH
14$:	MOV	R1,TE.EAD(R2)	;AND START XFER
	MOV	R0,TE.EBC(R2)	;SET BYTE COUNT
.IF NE,DEBUG
	MOV	R1,DT11AS(R5)
	MOV	R0,DT11BS(R5)
.ENDC
	RTS	PC
;
; ROUTINE CALLED WHEN QPR DOORBELL FINDS IT HAS DATA FOR -11
;
; CALL:
; R0/	# OF BYTES IN MESSAGE
; RETURN:
;	IF C SET, ERROR.  OTHERWISE...
;
; R0/	# OF BYTES TO XFER
; R1/	ADDRESS OF WHERE TO PUT DATA
;
DLEDBL:	TST	DT11FN(R5)	;MUST COME FROM INDIRECT DATA
	BPL	15$		;TROUBLE,DATA NOT INDIRECT
	MOV	R0,DLMBCT(R5)	;SAVE QPR MESSAGE COUNT
	BEQ	14$		;IF ZERO MSG COUNT,THEN NOTHING  TO DO
	CMPB	#2,DT11DF(R5)	;IS IT A WRITE FUNCTION?
	BNE	13$		;NO,FOR STATUS WRITES SETUP AREA
	CLR	R0		;INITIALLY NO CHUNKS TO QUE
;
; THE FOLLOWING CODE GETS A CHUNK AND SETS UP R3 TO DATA
;
11$:	JSR	PC,DLNWCK	;GET A CHUNK
	BCS	16$		;SHORT ON CHUNKS
	MOV	R0,DLCMSG(R5)	;SAVE ADR OF CURRENT MESSAGE
	MOV	DLMBCT(R5),R0	;GET MESSAGE BYTE COUNT
	CMP	#CHDATL,R0	;DOES IT FIT IN ONE CHUNK?
	BHIS	12$		;YES,SET UP RO AND R1
	MOV	#CHDATL,R0	;NO,THEN XFER A CHUNK FULL
12$:	MOV	DLCMSG(R5),R1	;CURRENT CHUNK POINTER
	MOV	R0,CHLEN(R1)	;SETUP THE LENGTH OF DATA IN CHUNK
	MOV	R3,R1		;R1 POINTS TO WHERE DATA GOES
	BR	14$		;WIN RETURN.
;
13$:	MOV	#DTTTSB,R1	;POINT TO AREA WHERE STATUS MUST GO
	MOV	R1,DT11Q(R5)	;JUST IN CASE WE NEED IT
	CMP	DLMBCT(R5),#DTSBLN ;MUST NOT OVERFLOW OUR BUFFER
	BGT	15$		;THROW HIM OUT FOR GIVING TOO MUCH
;
; HERE FOR SUCCESS RETURN.
;
14$:	CLC			;CLEAR C BIT
	RTS	PC		;RETURN.
;
; HERE ON FAILURE RETURN.
;
15$:	SEC			;SET C BIT
	RTS	PC		;RETURN.
;
;
; IF WE ARE SHORT ON CHUNKS WE LAND HERE!!!
;
16$:	MOV	TCXLT(R5),R1	;POINT TO XLATE TASK
	BIT	#TCOAB,TCFG2(R1);HAS STEAM BEEN ABORTED?
	BEQ	DLSDLY		;NO,INDICATE "DELAYED"
;
DLSERR:	MOVB	#3,DT10DF+1(R5)	;OPERATION REJECTED
	MOV	#-1,DT11GW(R5)	;SET FLAG TO INDICATE ERROR OR DELAYED
	CLC			;NOT A FATAL ERROR
	RTS	PC		;RETURN
;
DLSDLY:	MOVB	#2,DT10DF+1(R5)	;OPERATION DELAYED
	MOV	#-1,DT11GW(R5)	;FLAG OPERATION DELAYED
	CLC			;NOT A FATAL ERROR
	RTS	PC		;RETURN
;
;
; ROUTINE CALLED FROM TO-11 DONE ROUTINE TO ADD NEW CHUNK
;  OR PROCESS END OF FRAGMENT
;
; CALL - NO REGISTERS NEEDED
; ON RETURN:
;	R0/	LENGTH OF NEXT FRAGMENT TO TRANSFER
;	R1/	ADDRESS TO STORE DATA
;	PS/	Z BIT SET IF EVERYTHING IN
;
DLTEDN:	MOV	DLMCTL(R5),R0	;CHECK IF ANY THING LEFT TO XFER
	BGT	11$		;FOR +VE COUNT,SETUP CHUNK ADR
;
; IF THE COUNT IS -VE OR ZERO, THEN APPEND THE LAST CHUNK DONE 
;  TO THE MESSAGE FOR XLATE TASK
;
	MOV	TCXLT(R5),R1	;POINT TO THE XLATE TASK
	MOV	DLCMSG(R5),R0	;POINT TO CHUNK TO BE QUED
	JSR	PC,QUECHK	;SEND IT THE CHUNK
	CLR	DLCMSG(R5)	;INITIALIZE MESSAGE PTR
	CLR	R0		;INDICATE NOTHING LEFT TO XFER
	RTS	PC		;RETURN
;
11$:	MOV	DLCMSG(R5),R0	;POINT TO LAST FILLED CHUNK
	JSR	PC,DLNWCK	;GIVE CHUNK TO XLATE AND GET NEW
	BCS	DLSDLY		;SHORT ON CHUNKS
	MOV	R0,DLCMSG(R5)	;SAVE PTR TO CHUNK TO BE FILLED
	MOV	#CHDATL,R0	;CAN WE XFER A CHUNK FULL
	CMP	DLMCTL(R5),R0	;COUNT LEFT LESS THAN CHUNK FULL?
	BGT	12$		;NO, TRANSFER IT ALL.
	MOV	DLMCTL(R5),R0	;YES, AMOUNT LEFT TO XFER FOR NEXT TIME
12$:	MOV	DLCMSG(R5),R1	;GET CURRENT CHUNK PTR
	MOV	R0,CHLEN(R1)	;SETUP THE LENGTH OF DATA
	MOV	R3,R1		;R1 POINTS TO WHERE THE DATA GOES
	CLC			;CLEAR C
	RTS	PC		;RETURN
;
;
; DTXMSD -- SUBROUTINE TO START A DIRECT TO TEN TRANSFER 
;
; R1 = ADDRESS OF PACKET TO BE SENT TO - TEN
; R2 = COUNT OF BYTES GOING TO THE TEN
;
;	ALWAYS RETURNS WITH C CLEAR.
;
DTXMSD:	MOV	R1,-(SP)	;SAVE REGISTERS
	MOV	R0,-(SP)	;
	MOV	DTEBAD,R0	;SET UP ADDRESS OF DTE20
	CLR	TE.XW1(R0)
	CLR	TE.XW2(R0)
.IIF NE,DEBUG,MOV R2,DTXTSZ(R5)
	MOV	R2,TE.XW3(R0)	;SET THE QUEUE SIZE IN MY AREA TO HIM
	MOV	R1,TE.XAD(R0)	;SET UP THE TO 10 ADDRESS
	MOV	#1,TE.DG3(R0)	;SET BYTE MODE
.IIF NE,DEBUG,MOV R1,DTXTAS(R5)
	MOV	DTEPCA,R1	;FIND THE CORRECT DTE
	MOV	DTDMYN(R1),R1	;FIND THE OFFSET INTO MY AREA
	ADD	#DLXFSZ-DLPIN,R1 ; FIND Q SIZE
	MOV	#TS.DEP,TE.XA1(R0) ;SET UP TO DO DEPOSIT
	MOV	R1,TE.XA2(R0)
	JSR	PC,DLWEDN
	INCB	DT11QC		;INCREMENT THE COUNT
	MOV	DTSTT,TE.XW1(R0)
	MOV	DTSTT+2,TE.XW2(R0)
	MOV	DTSTT+4,TE.XW3(R0)
	ADD	#DLSTAT-DLXFSZ,TE.XA2(R0)
	JSR	PC,DLWEDN	;EXAMINE/DEPOSIT
	MOV	#TS.EEX,TE.STW(R0) ;RING UP THE 10
	MOV	(SP)+,R0
	MOV	(SP)+,R1	;RESTORE REGISTERS
	CLC			;INDICATE SUCCESS (ALWAYS)
	RTS	PC		;RETURN
;
;
; THE FOLLOWING SUBROUTINE SETS UP HEADER FOR SENDING MESSAGES TO 
;  THE TEN
;
DTSHDR:	MOV	#12,DT10HD(R5)	;LENGTH OF HEADER IS 12
	MOV	DT11DV(R5),DT10DV(R5) ;SETUP THE DEVICE CODE
	MOV	DT11FN(R5),DT10FN(R5) ;FUNCTION CODE
	MOVB	DT11DF(R5),DT10DF(R5) ;DN60 FUNCTION CODE
	MOV	DT11AD(R5),DT10AD(R5)	;THE ADDRESS OR LINE #
	MOVB	DT11UC+1(R5),DT10UC+1(R5) ;SETUP FE#
	MOVB	#6,DT10UC(R5)	;SET UP NO OF BYTES FOR NEXT XFER
	RTS	PC
;
; THE FOLLOWING ENTRY POINTS ARE SENDING MESSAGES TO THE TEN
; THE FOLLOWING ROUTINES ARE FOR SENDING O.K, DELAYED OR
; ERROR RETURN TO THE TEN IN RESPONSE TO THE OPERATIONS 
; INVOKED BY THE TEN
;
DTDSOK:	MOVB	#1,DT10DF+1(R5)	;SET SUCCESS CODE FOR 10
;
DTCMRT:	JSR	PC,DTSHDR	;SETUP THE HEADER
	JSR	PC,DTIPDN	;SET STATUS FOR INDIRECT DONE
	MOV	DLMBCT(R5),R1	;MESSAGE COUNT
	SUB	DLMCTL(R5),R1	;SUBTACT BYTE COUNT LEFT
	MOV	R1,DT10DT(R5)	;TO GET # OF BYTES XFERRED
	RTS	PC		;RETURN PEACEFULLY
;
;
; SUBROUTINE TO GET A BYTE OF DATA FROM THE PDP-10 THROUGH
;  THE INDIRECT PORTION OF THE MESSAGE.
;
;	R2 = POINTER TO CURRENT BYTE OF MESSAGE
;	R4 = REMAINING COUNT IN THIS MESSAGE
;
; ON RETURN:
;
;	C SET -- END OF DATA
;	C CLEAR -- R1 = NEXT CHARACTER
;
DLGBYT:	TST	R4		;ANY BYTES LEFT IN THIS POINTER?
	BEQ	12$		;NO, TRY NEXT PAIR
11$:	DEC	R4		;YES, COUNT DOWN BYTE COUNTER
	MOVB	(R2)+,R1	;PICK UP BYTE
	INC	TCXFR(R5)	;COUNT A BYTE TRANSFERED
	CLC			;SUCCESS RETURN
	RTS	PC
;
; HERE IF THE COUNT IS DEPLETED.
;
12$:
	SEC			;0 COUNT = EOF
	RTS	PC		;GIVE EOF RETURN.
;
;
; SUBROUTINE TO PUT A BYTE OF DATA INTO PDP-10 MEMORY
;  BY APPENDING TO THE INDIRECT MESSAGE BEING BUILT.
;
; THIS SUBROUTINE MAY BE CALLED ONLY FROM DTE20 SUBROUTINES.
;
;	R1 = BYTE TO STORE
;	R2 = POINTER TO THE INDIRECT MESSAGE
;	R4 = REMAINING COUNT IN THIS MESSAGE
;
; ON RETURN:
;
;	C SET -- THERE IS NO ROOM FOR ANY MORE BYTES
;	C CLEAR -- THERE IS ROOM FOR ANOTHER BYTE
;
DLPBYT:	MOVB	R1,(R2)+	;STORE BYTE IN PDP-10 MEMORY
	INC	TCXFR(R5)	;COUNT A BYTE TRANSFERED
	DEC	R4		;ANY ROOM LEFT IN THIS BYTE POINTER?
	BEQ	12$		;NO, CHECK FOR ANOTHER.
11$:	CLC			;YES, INDICATE MORE ROOM
	RTS	PC		;RETURN.
;
; HERE WHEN THE COUNT RUNS OUT
;
12$:	SEC			;NO MORE ROOM
	RTS	PC		;RETURN.
;
;
; SUBROUTINE TO PUT A WORD OF DATA INTO PDP-10 MEMORY,
;  LOW BYTE FIRST.
;
;	R1 = WORD TO STORE
;	R2 = POINTER TO INDIRECT MESSAGE BEING BUILT
;	R4 = REMAINING COUNT IN THIS MESSAGE
;
; ON RETURN:
;
;	C SET -- THERE IS NO ROOM FOR ANY MORE BYTES
;		(POSSIBLY HIGH BYTE WAS NOT STORED)
;	C CLEAR -- THERE IS ROOM FOR ANOTHER BYTE
;
DLPWRD:	JSR	PC,DLPBYT	;STORE LOW BYTE IN PDP-10 MEMORY
	BCS	11$		;NO MORE ROOM
	SWAB	R1		;GET HIGH BYTE
	JSR	PC,DLPBYT	;STORE HIGH BYTE
11$:	RTS	PC		;RETURN.
;
;
; SUBROUTINE TO COPY A STRING OF WORDS OUT THROUGH THE DTE20
;
;	R0 = POINTER TO FIRST WORD
;	R2 = POINTER TO INDIRECT MESSAGE BEING BUILT
;	R3 = POINTER TO LAST WORD + 2
;	R4 = REMAINING COUNT IN THE INDIRECT MESSAGE
;
; ON RETURN:
;
;	C SET -- NO MORE ROOM FOR MORE BYTES
;		(POSSIBLY NOT ALL OF THIS STRING WAS STORED)
;	C CLEAR -- ROOM FOR MORE BYTES
;
DLPSTR:	MOV	(R0)+,R1	;GET WORD TO STORE
	JSR	PC,DLPWRD	;STORE IT
	BCS	11$		;NO MORE ROOM
	CMP	R0,R3		;DONE ALL WORDS YET?
	BNE	DLPSTR		;NO, DO ANOTHER.
	CLC			;YES, ALL DONE.
11$:	RTS	PC		;RETURN.
;
.SBTTL		 DN60 FUNCTIONS INITIATED BY TEN
;
; DLTEXM  SUBROUTINE TO DO THE EXAMINE FUNCTION
; DLTDEP SUBROUTINE TO DO THE DEPOSIT FUNCTION
;
DLTEXM:
DLTDEP:				;SAME ENTRY FOR DEPOSIT FUNCTION
	JSR	PC,DTSHDR	;SET UP HEADER FOR TO-10 MSG
	MOV	R5,R1		;BUILD POINTER TO HEADER IN TCB
	ADD	#DT10HD,R1	;POINT TO HEADER TO BE SENT TO TEN
.IIF NE,DEBUG,MOV R1,DTO10Q(R5)	;SAVE IT FOR REF
	MOV	NXMGO,-(SP)	;SAVE PREV NXMGO ADDRESS
	MOV	#14$,NXMGO	;SET CURRENT NXM PROCESSING ADR
	CMPB	DT11DF(R5),#12	;IS IT A DEPOSIT FUNCTION?
	BEQ	13$		;YES,GO DO DEPOSIT
	MOV	@DT11AD(R5),DT10DT(R5)	;EXAMINE LOCATION PUT DATA IN 10 SIDE
11$:	MOV	(SP)+,NXMGO	;RESTORE XMGO
	MOVB	#1,DT10DF+1(R5)	;SET RESULT CODE =1;SUCCESS
12$:
	CLR	DTXADR(R5)	;NO DATA FOR IND XFER
	RTS	PC		;RETURN
;
13$:	MOV	DT11DT(R5),@DT11AD(R5) ;DEPOSIT THE DATA
	BR	11$		;SEND RESULT TO TEN
;
14$:	MOV	(SP)+,NXMGO	;RESTORE NXMGO
	MOVB	#3,DT10DF+1(R5)	;BAD ADR ;REJECT CODE
	BR	12$
;
;
; DLTRES-SUBROUTINE TO PERFORM THE " READ DN60 STATUS "
;
DLTRES:	JSR	PC,DTSHDR	;SET UP THE HEADER FOR SENDING TO-TEN
	MOV	DT11DT(R5),DT10DT(R5) ;SET COUNT TO BE SENT TO TEN
	BEQ	11$		;ZERO COUNT UNREASONABLE
	MOV	DT11DT(R5),R4	;COUNT OF BYTES IN STATUS
	MOV	#DTTTSB,R2	;POINT TO STATUS BLOCK
	MOV	R2,DTXADR(R5)	;ADR OF INDIRECT DATA SET
	MOV	#D60ST1,R0	;POIN TO THE FIRST WORD OF STATUS
	MOV	#D60ST2+2,R3	;POINT TO LAST WORD+2
	JSR	PC,DLPSTR	;MOVE A WORDS IN BUFFER
	MOV	TCXFR(R5),DT10DT(R5) ;NO OF BYTES TO XFER
	BIS	#B15,DT10FN(R5)	;INDICATE INDIRECT DATA
	MOVB	#1,DT10DF+1(R5)	;SUCCESS CODE TO TEN
	CLC			;SUCCESS ALWAYS
	RTS	PC		;RETURN
;
; HERE IF WE GET A ZERO COUNT ON 'READ DN60 STATUS'.
;  THIS IS UNREASONABLE.
;
11$:
	STOPCD	TER		;ZERO LENGTH INVALID
;
;
; SUBROUTINE TO PERFORM THE "READ DATA" FUNCTION.
;  MESSAGE QUE IS EXAMINED FOR A MESSAGE FROM THAT LINE
;  AND IF ONE IS FOUND IT BECOMES CURRENT MESSAGE. THE
;  USER MAY ASK FOR A MAXIMUM OF ONE CHUNK ONLY,HOWEVER
;  IF ASKED FOR MORE THAN CHUNK HAS CURRENTLY, HE GETS
;  WHATS LEFT IN THE CURRENT CHUNK.
;
DLTRDT:	JSR	PC,DTSHDR	;SETUP HEADER FOR TEN XFER
	MOV	DT11DT(R5),DT10DT(R5) ;LENGTH OF INDIRECT DATA
	BEQ	23$		;ZERO LENGTH UNREASONABLE
	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	CMP	R0,NDQ11S	;IS IT REASONABLE?
	BHIS	23$		;NO.
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R4	;POINT TO LCB
	BEQ	23$		;IT HAS NOT BEEN CREATED
	BIT	#LS.ENB,(R4)	;IS IT ENABLED?
	BEQ	23$		;NO, LOSE.
	MOV	R4,TCLCB(R5)	;AND REMEMBER LCB POINTER
	MOVB	DT11AD(R5),R1	;GET DEVICE #
	BIC	#177770,R1	;EXTRACT DEVICE # FROM RCB

;3(014).IF NE,DEBUG
;3(014)	BNE	10$		;TO TRACK -10 SCREW UPS
;3(014)	CMP	#TTHASP,LB.DVT(R4) ;CHECK DEV FOR HASP
;3(014)	BNE	10$		;
;3(014)	STOPCD	TER		;TEN ERROR
;3(014) 10$:
;3(014).ENDC ;.IF NE,DEBUG

	JSR	PC, DLMCHK	;;++BS- CHECK FOR LEGAL DEVICE NUMBER 3(014)
	BCS	23$		;;++BS- BAD DEVICE NUMBER, REJECT 3(014)

	ASL	R1		;DEVICE * 2
	MOV	R1,R2		;KEEP DEVICE # FOR LATER 
	ADD	R4,R1		;ADD DEVICE #
	MOV	LB.TCD(R1),TCXLT(R5) ; GET XLATE TASK POINTER
11$:	JSR	PC,DLGTCM	;GET CURRENT OR NEW MESSAGE
	BCS	22$		;NO MESSAGE FOR THIS DEVICE
12$:	MOV	MSGLCH(R0),R1	;GET POINTER TO THE CHUNK
13$:	MOV	R1,R3		;BUILD PONTER TO DATA
	BEQ	21$		;END OF MESSAGE FOUND
	MOV	(R3)+,DLPMST(R5) ;SAVE POINTER TO NEXT CHUNK
	MOV	(R3)+,R2	;GET COUNT, POINT TO DATA
;
;
; THE FOLLOWING IS THE REGISTER ALLOCATION:
;
; R0 = POINTS TO THE CURRENT MESSAGE BEING PROCESSED
; R1 = POINTS TO CURRENT CHUNK
; R2 = AMOUNT OF BYTES IN THIS CHUNK
; R3 = POINTS TO DATA IN CURRENT CHUNK
; R5 = POINTER TO DTE20 DRIVER TCB
; MSGLCH(R0) = CURRENT CHUNK TO BE SENT
; MSGPTR(R0) = CURRENT BYTE TO BE SENT
;
14$:	TST	R2		;ANY BYTES LEFT IN THIS CHUNK?
	BEQ	20$		;NO, LOOK FOR ANOTHER.
	ADD	R3,R2		;POINT TO END OF THE CHUNK
	CMP	MSGPTR(R0),R2	;DOES CHAR PTR LIE IN THIS RANGE
	BLOS	15$		;YES,IT DOES
	STOPCD	TER		;ERROR,CHAR PTR OUT OF RANGE
;
15$:	MOV	MSGPTR(R0),DTXADR(R5) ;SET UP INDIRECT DATA ADR
	SUB	MSGPTR(R0),R2	;THIS IS MAX DATA WE HAVE IN CHUNK
	CMP	DT11DT(R5),R2	;IS IT LESS THAN ASKED FOR?
	BLT	19$		;YES
	MOV	R2,DT10DT(R5)	;NO,GIVE HIM WHAT WE HAVE
	MOV	DLPMST(R5),R1	;GET ADR OF NEXT CHUNK IN MESSAGE
	MOV	R1,MSGLCH(R0)	;SAVE IN MESSAGE HEADER
	ADD	#CHDAT,R1	;BUILD DATA POINTER
	MOV	R1,MSGPTR(R0)	;SAVE NEW DATA POINTER
16$:	BIS	#B15,DT10FN(R5)	;SET INDIRECT FLAG
17$:	MOVB	#1,DT10DF+1(R5)	;SUCCESS CODE
18$:	CLC			;NO FATAL ERRORS
	RTS	PC		;RETURN
;
19$:	MOV	DT11DT(R5),DT10DT(R5) ;SET AMOUNT TO BE XFERRED
	ADD	DT11DT(R5),MSGPTR(R0) ;UPDATE CHAR PTR
	BR	16$		;SEND TO TEN
;
;
; HERE WHEN THE CHUNK RUNS OUT.  GO ON TO THE NEXT CHUNK.
;
20$:	MOV	DLPMST(R5),R1	;POINT TO NEXT CHUNK
	BNE	13$		;PROCESS IT, IF ANY.
;
; HERE ON END OF MESSAGE
;
21$:				;R0 DOES POINT TO MESSAGE
	MOV	TCIDLE,R1	;POINT TO IDLE TASK
	JSR	PC,QUEMSG	;SEND IT THE MSG TO FREE
	CLR	DT10DT(R5)	;ZERO BYTES SENT TO TEN
	CMP	#TTHASP,LB.DVT(R4) ;HASP LINE?
	BNE	33$		;NO.
	CLR	@TCPDM(R5)	;CLEAR DEVICE MESSAGE PTR
	BR	11$		;JOIN THE MAIN LOOP
33$:
	MOV	LB.LNU(R4),R1	;GET LINE NUMBER
	ASL	R1		;LINE NUMBER * 2
	ADD	R5,R1		;POINT INTO TCB
	CLR	TCCMSG(R1)	;WE HAVE NO CURRENT MESSAGE
	BR	11$		;FIND NEXT MESSAGE AND SENT TO TEN
;
;
; HERE IF THERE IS NO MESSAGE FOR THAT LINE
;
22$:	CLR	DT10DT(R5)	;NO INDIRECT DATA TO SEND
	MOV	TCXLT(R5),R1	;POINT TO XLATE TASK
	BIT	#TCIAB!TCIEC,TCFG2(R1) ;EOF OR ABORT?
	BEQ	24$		;NO.  "DELAYED" RETURN.
23$:	MOVB	#3,DT10DF+1(R5)	;YES, GIVE "REJECT" RETURN

	BIT	#TCIAB, TCFG2(R1) ;;++BS- ABORT ? 3(005)
	BNE	36$		;;++BS- YES, CLEAR THE ACTIVE BIT 3(005)
	BIT	#TCIPR, TCFG2(R1) ;;++BS- INPUT PERMISSION REQUESTED ? 3(005)
	BNE 	18$		;;++BS- YES, DO NOT CLEAR THE ACTIVE BIT 3(005)
				;;++BS- NO, CLEAR THE ACTIVE BIT 3(005)

36$:				;;++BS-NEW LABEL 3(005)

	JSR	PC, DLRCAB	;CLEAR THE DEVICE ACTIVE BIT
	BR	18$		;SEND REJECT TO TEN
;
24$:	MOVB	#2,DT10DF+1(R5)	;INDICATE "DELAYED"
	JSR	PC, DLRCAB	;CLEAR DEVICE ACTIVE BIT
25$:	BR	18$		;SEND IT TO TEN



;;++BS-CODE TO CLEAR THE DEVICE ACTIVE BIT

DLRCAB:	JSR	PC, HSSAVR	;SAVE THE REGISTERS
	MOVB	DT11AD+1(R5), R0 ;GET LINE NUMBER
	BIC	#177770, R0	;CLEAR JUNK
	MOVB	DT11AD(R5),R1	;GET DEVICE NUMBER
	BIC	#177400, R1	;CLEAR JUNK
	TST	R1		;CHECK FOR ZERO DEVICE NUMBER
	BNE	35$		;NON ZERO, CONTINUE
	MOV	TCLCB(R5), R2	;POINT TO LCB
	BIT	#LF.SIM, LB.FGS(R2)	;SIMULATION ?
	BNE	34$		;YES
	MOV	#3, R1		;NO, SUPPORT, MUST BE CDR
	BR	35$		;CLEAR DEVICE ACTIVE BIT
34$:	MOV	#4, R1		;SIMULATION, MUST BE LPT
35$:	JSR	PC, HSAMPC	;CLEAR DEVICE ACTIVE BIT
	JSR	PC, HSRESR	;RESTORE THE REGISTERS
	RTS	PC		;RETURN

;;++BS-END OF CODE TO CLEAR THE DEVICE ACTIVE BIT


;

; THIS SUBROUTINE LOOKS FOR A CURRENT MESSAGE AND IF 
; NONE IS FOUND, GETS OLDEST MESSAGE WITH THE ID.
;
DLGTCM:	MOV	TCLCB(R5),R4	;POINT TO LCB
	MOV	LB.LNU(R4),R1	;GET LINE NUMBER
	ASL	R1		;LINE NUMBER * 2
	ADD	R5,R1		;POINT INTO TCB
	CMP	#TTHASP,LB.DVT(R4)	;HASP LINE?
	BEQ	11$		;YES
	MOV	TCCMSG(R1),R0	;IS THERE A CURRENT MESSAGE?
	BNE	16$		;YES, CONTINUE WITH IT.
	BR	13$		;GO GET MESSAGE FOR THE LINE
11$:	MOV	TCCMSG(R1),R1	;GET PTR TO DEV MSG
	BNE	12$		;THERE'S ONE
	STOPCD	HSB		;NONE EXISTS
;
12$:	ADD	R2,R1		;GET DEVICE MSG PTR
	MOV	R1,TCPDM(R5)	;SAVE PTR TO DEV MSG
	MOV	(R1),R0		;ANY DEVICE MESSAGE?
	BNE	17$		;YES.
	MOV	TCXLT(R5),R0	;POINT TO DEVICE'S TCB
	MOV	TCCTP(R0),R1	;GET THE RCB 
	MOV	LB.LNU(R4),R0	;GET LINE #
	SWAB	R0		;PUT IN LEFT BYTE
	ADD	R0,R1		;MAKE I.D. FOR THE MESSAGE
	JSR	PC,DEQMID	;GET OLDEST MSG WITH THAT ID
	BCS	16$		;THERE IS NONE.

;;++BS-CODE TO UNSUSPEND A DEVICE IF LESS THAN 2 MESSAGES QUEUED

	MOV	R3, -(SP)	;;++BS-SAVE R3
	MOV	TCXLT(R5), R3	;;++BS-POINT TO XLATE TASK
	DEC	TCIMC(R3)	;;++BS-DECREMENT COUNT OF INPUT MESSAGES
	CMP	TCIMC(R3), #2	;;++BS-LESS THAN 2 ?
	BGE	31$		;;++BS-NO, CONTINUE
	MOV	R1, -(SP)	;;++BS-YES, SAVE R1
	MOV	TCCTP(R3), R1	;;++BS-GET DEVICE TYPE
	BIC	#177770, R1	;;++BS-GET DEVICE NUMBER
	JSR	PC, HSUNSP	;;++BS-UNSUSPEND THE DEVICE
				;;++BS-TCLCB(R5) POINTS TO XLATE LCB
	MOV	(SP)+, R1	;;++BS-RESTORE R1
31$:	MOV	(SP)+, R3	;;++BS-RESTORE R3

;;++BS-END OF CODE TO UNSUSPEND A DEVICE IF LESS THAN 2 MESSAGES QUEUED

	MOV	R0,@TCPDM(R5)	;SAVE DEVICE MSG PTR
17$:	CLC			;SUCCESSFUL
	RTS	PC		;RETURN
;
13$:	MOV	LB.LNU(R4),R1	;GET LINE # (I.D. FOR 2780/3780)
	JSR	PC,DEQMID	;GET MESSAGE FOR THE I.D.
	BCS	16$		;NO MESSAGE FOR THIS I.D.
	MOV	LB.LNU(R4),R1	;GET LINE NUMBER
	ASL	R1		;LINE NUMBER * 2
	ADD	R5,R1		;POINT INTO TCB
	MOV	R0,TCCMSG(R1)	;REMEMBER CURRENT MESSAGE
	CLC			;SUCCESS
16$:	RTS	PC		;EXIT
;
;
;
; SUBROUTINE TO PERFORM THE "WRITE DATA" FUNCTION.  DATA IS
;  FETCHED THROUGH THE DTE20 AND PLACED IN CHUNKS.  THE CHUNKS
;  ARE SENT TO THE XLATE TASK FOR TRANSLATION AND SUBSEQUENT
;  QUEUEING TO THE DQ11.
;
; ON RETURN:
;
;	C IS SET IF THE DTE20 FAILS OR THERE IS SOME INCONSISTENCY
;	  IN THE PDP-10 INFORMATION.  OTHERWISE, R0 = RESULT CODE.
;
DLTWDT:	TST	DT11FN(R5)	;BETTER BE INDIRECT FUNCTION
	BMI	11$		;YES,CHECK FOR LINE ETC.
	STOPCD	DTI20		;DATA NOT INDIRECT
;
11$:	MOVB	DT11AD+1(R5),R0	;GET LINE NO
	CMP	R0,NDQ11S	;IS IT REASONABLE?
	BHIS	14$		;NO, PARM ERROR.
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R4	;POINT TO LCB
	BEQ	14$		;NOT INITIALIZED
	BIT	#LS.ENB,(R4)	;IS THE LINE ENABLED?
	BEQ	14$		;NO.
	MOVB	DT11AD(R5),R1	;GET RCB OR DEVICE #
	BIC	#177770,R1	;EXTRACT DEVICE # FROM RCB

;3(014).IF NE,DEBUG
;3(014)	BNE	10$		;
;3(014)	CMP	#TTHASP,LB.DVT(R4) ;CHECK FOR HASP
;3(014)	BNE	10$		;ONLY
;3(014)	STOPCD	TER		;TEN ERROR
;3(014) 10$:
;3(014).ENDC

	JSR	PC, DLMCHK	;;++BS- CHECK FOR LEGAL DEVICE NUMBER 3(014)
	BCS	14$		;;++BS- BAD DEVICE NUMBER, REJECT 3(014)

	ASL	R1		;DEVICE * 2
	ADD	R4,R1		;ADD DEVICE #
	MOV	LB.TCD(R1),R0	;POINT TO XLATE TASK
	MOV	R0,TCXLT(R5)	;REMEMBER TCB OF XLATE TASK
	MOV	#-1,DT10AK	;NOTE THAT WE EXPECT ED DATA
	TST	TCCHK1(R0)	;INPUT WAITING FOR XLATE TASK??
	BNE	12$		;YES, WAKE UP PDP-10 WAIT A WHILE

;;;++BS-CODE TO SET DEVICE ACTIVE BIT FOR OUTPUT

;	JSR	PC, HSSAVR	;SAVR THE REGISTERS
;	MOVB	DT11AD+1(R5), R0 ;GET LINE NUMBER
;	BIC	#177770, R0	;CLEAR JUNK
;	MOVB	DT11AD(R5), R1	;GET DEVICE NUMBER-RCB
;	BIC	#177400, R1	;CLEAR JUNK
;	TST	R1		;CHECK FOR ZERO DEVICE NUMBER
;	BNE	35$		;NON ZERO, CONTINUE
;	MOV	TCLCB(R5), R2	;POINT TO LCB
;	BIT	#LF.SIM, LB.FGS(R2)	;SIMULATION ?
;	BNE	34$		;YES
;	MOV	#4, R1		;NO, SUPPORT, MUST BE LPT
;	BR	35$		;SET DEVICE ACTIVE BIT
;34$:	MOV	#3, R1		;SIMULATION, MUST BE CDR
;35$:	JSR	PC, HSACMP	;SET THE DEVICE ACTIVE BIT
;	JSR	PC, HSRESR	;RESTORE THE REGISTERS

;;;++BS-END OF CODE TO SET THE DEVICE ACTIVE BIT

	CLC			;INDICATE SUCCESSFUL RETURN
	RTS	PC		;RETURN
;
;

;;++BS-CODE TO CLEAR DEVICE ACTIVE BIT

12$:
	JSR	PC, HSSAVR	;SAVE THE REGISTERS
	MOVB	DT11AD+1(R5), R0 ;GET LINE NUMBER
	BIC	#177770, R0	;CLEAR JUNK
	MOVB	DT11AD(R5), R1	;GET DEVICE NUMBER-RCB
	BIC	#177400, R1	;CLEAR JUNK
	TST	R1		;CHECK FOR ZERO DEVICE NUMBER
	BNE	37$		;NON ZERO, CONTINUE
	MOV	TCLCB(R5), R2	;POINT TO LCB
	BIT	#LF.SIM, LB.FGS(R2)	;SIMULATION ?
	BNE	36$		;YES
	MOV	#4, R1		;NO, SUPPORT, MUST BE LPT
	BR	37$		;CLEAR DEVICE ACTIVE BIT
36$:	MOV	#3, R1		;SIMULATION, MUST BE CDR
37$:	JSR	PC, HSAMPC	;CLEAR THE DEVICE ACTIVE BIT
	JSR	PC, HSRESR	;RESTORE THE REGISTERS

;;++BS-END OF CODE TO CLEAR THE DEVICE ACTIVE BIT

	MOV	TCXLT(R5),R1	;POINT TO XLATE TASK
	BIT	#TCOAB,TCFG2(R1) ;HAS STREAM BEEN ABORTED?
	BEQ	13$		;NO,INDICATE DELAYED OPERATION
	JMP	DLSERR		;OPERATION REJECTED
;
13$:	JMP	DLSDLY		;OPERATION DELAYED
;
14$:
	MOV	#-1,DT10AK	;;++BS-NOTE THAT WE EXPECT ED DATA 3(012)
	JMP	DLSERR		;;++BS-REJECT THE REQUEST 3(012)
;3(012)	SEC			;FATAL ERROR
;3(012)	RTS	PC		;RETURN
;
;
; SUBROUTINE TO PERFORM THE "READ DEVICE STATUS" FUNCTION.
;  THE STATUS MESSAGE IS ASSEMBLED IN A BUFFER AND SENT TO-TEN
;  AS INDIRECT DATA.  NO EXCEPTIONAL CONDITIONS ARE POSSIBLE.
;
DLTRDS:	JSR	PC,DTSHDR	;SETUP HEADER FOR TEN XFER
	TST	DT11DT(R5)		;ASKING FOR ZERO?
	BEQ	13$		;YES, THROW HIM OFF.
	MOVB	DT11AD+1(R5),R0	;GET LINE NO
	CMP	R0,NDQ11S	;IS IT REASONABLE?
	BHIS	13$		;NO, ERROR.
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R4	;POINT TO SPECIFIED LCB
	BEQ	13$		;NOT INITIALIZED.
	BIT	#LS.ENB,(R4)	;IS THE LINE ENABLED?
	BEQ	13$		;NO.
	MOVB	DT11AD(R5),R1	;GET RCB OR DEVICE #
	BIC	#177770,R1	;EXTRACT DEVICE # FROM RCB

;3(014).IF NE,DEBUG
;3(014)	BNE	10$		;TRACK 10 ERRORS
;3(014)	CMP	#TTHASP,LB.DVT(R4) ;CHECK HASP DEV #
;3(014)	BNE	10$		;ONLY
;3(014)	STOPCD	TER		;
;3(014) 10$:
;3(014).ENDC

	JSR	PC, DLMCHK	;;++BS-CHECK FOR LEGAL DEVICE NUMBER 3(014)
	BCS	13$		;;++BS-BAD DEVICE NUMBER, REJECT 3(014)

;
;
;
	ASL	R1		;DEV NO * 2
	ADD	R4,R1		;ADD DEVICE # TO
	MOV	LB.TCD(R1),TCXLT(R5) ; POINT TO XLATE TASK
	MOV	R4,TCLCB(R5)	;SAVE LCB IN CASE WE NEED IT LATER
	MOV	#DTTTSB,R2	;POINT TO THE STATUS BLOCK
	MOV	R2,DTXADR(R5)	;SAVE IT FOR TO-TEN XFER
	MOV	DT11DT(R5),R4	;SET COUNT PROVIDED BY TEN
	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	MOVB	TCDVT(R0),R1	;GET DEVICE TYPE
	JSR	PC,DLPBYT	;SEND TO PDP-10
	BCS	13$		;MUST BE MORE ROOM
	MOV	TCCTP(R0),R1	;GET COMPONENT TYPE
	JSR	PC,DLPBYT	;SEND TO PDP-10
	BCS	13$		;MUST BE MORE ROOM
	MOV	TCPGC(R0),R1	;GET PAGE COUNT REGISTER
	JSR	PC,DLPWRD	;SEND TO PDP-10
;	BCS	11$		;NO MORE ROOM
	BCS	13$		;;++BS-NO MORE ROOM 3(004)
	MOV	TCFG1(R0),R1	;GET FLAGS WORD 1
	JSR	PC,DLPWRD	;SEND TO PDP-10
	BCS	13$		;MUST BE MORE ROOM
	MOV	TCFG2(R0),R1	;GET FLAGS WORD 2
	JSR	PC,DLPWRD	;SEND TO PDP-10
	BCS	13$		;MUST BE MORE ROOM
	MOV	TCRSZ(R0),R1	;GET RECORD SIZE FOR  THE DEVICE
	JSR	PC,DLPWRD	;SEND TO PDP-10
;	BCS	11$		;NO MORE ROOM
	BCS	13$		;;++BS-NO MORE ROOM 3(004)
	MOV	TCLCB(R5), R1	;;++BS-POINT TO LCB 3(004)
	MOV	LB.FGS(R1), R1	;;++BS-GET THE LINE FLAGS 3(004)
	JSR	PC, DLPWRD	;;++BS-SEND TO PDP-10 3(004)
	BCS	13$		;;++BS-ERROR, NO MORE ROOM 3(007)
	MOV	TCLCB(R5), R1	;;++BS-POINT TO LCB 3(007)
	MOV	LB.SIG(R1), R1	;;++BS-GET THE LINE SIGNATURE 3(007)
	JSR	PC, DLPWRD	;;++BS-SEND TO PDP-10 3(007)
	BCS	11$		;;++BS-SEND THE INDIRECT MESSAGE 3(004)



;
; CONTINUED ON NEXT PAGE
;
;
;
; HERE WHEN THE INDIRECT MESSAGE HAS BEEN BUILT.
;
11$:	BIS	#B15,DT10FN(R5)	;INDICATE INDIRECT DATA FOLLOWS
	MOVB	#1,DT10DF+1(R5)	;SEND SUCCESS CODE
	MOV	TCXFR(R5),DT10DT(R5) ;SETUP INDIRECT DATA LENGTH
	CLC			;INDICATE SUCCESS
12$:	RTS	PC		;RETURN
;
; HERE IF THERE IS ANY ERROR
;
13$:
	CLR	DT10DT(R5)	;;++BS-ZERO DATA LENGTH 3(010)
	BIS	#B15, DT10FN(R5) ;;++BS-NO INDIRECT DATA 3(010)
;3(010)	SEC			;FATAL ERROR
	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST 3(010)
	RTS	PC		;RETURN
;
;
; SUBROUTINE TO PERFORM THE "WRITE DEVICE COMMAND" FUNCTION.
;  THE FIRST BYTE OF THE DATA IS THE FUNCTION CODE, IF OTHER
;  DATA IS NEEDED IT FOLLOWS THE FUNCTION CODE.
;
; ON RETURN:
;
;	C SET -- DTE20 FAILURE OR BADLY FORMED COMMAND
;	C CLEAR -- R0 = 1 TO MEAN "SUCCESS", 2 TO MEAN "DELAYED"
;
DLTWDC:	TST	DT11FN(R5)	;BETTER BE INDIRECT DATA
	BMI	11$		;YES,IT IS
	STOPCD	DTI20		;DATA NOT INDIRECT ERROR
;
11$:	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	CMP	R0,NDQ11S	;IN RANGE?
	BHIS	12$		;NO, ERROR.
	ASL	R0		;YES, LINE NUMBER*2
	MOV	DQLCB(R0),R0	;PICK UP LCB POINTER
	BEQ	12$		;NONE IS ERROR
	BIT	#LS.ENB,(R0)	;IS THE LINE ENABLED?
	BEQ	12$		;NO.
	MOV	R0, R4		;;++BS-POINT R4 TO LCB 3(014)
	MOVB	DT11AD(R5),R1	;GET RCB OR DEVICE #
	BIC	#177770,R1	;EXTRACT DEVICE # FROM RCB

;3(014).IF NE,DEBUG
;3(014)	BNE	10$		;TRACK 10 ERRORS
;3(014)	CMP	#TTHASP,LB.DVT(R0) ;HASP DEV 
;3(014)	BNE	10$		;ONLY
;3(014)	STOPCD	TER
;3(014) 10$:
;3(014).ENDC

	JSR	PC, DLMCHK	;;++BS-CHECK FOR LEGAL DEVICE NUMBER 3(014)
	BCS	12$		;;++BS-BAD DEVICE NUMBER, REJECT 3(014)

	ASL	R1		;DEVICE * 2
	ADD	R0,R1		;ADD DEVICE #
	MOV	LB.TCD(R1),TCXLT(R5) ;POINT TO XLATE TASK
13$:				;;++BS-NEW LABEL 3(011)
	MOV	#-1,DT10AK	;NOTE THAT WE EXPECT ED DATA
	CLC			;INDICATE SUCCESS
	RTS	PC		;RETURN
;
12$:
	CLR	TCXLT(R5)	;;++BS-NO XLATE TASK FOR ERROR 3(011)
	BR	13$		;;++BS-REJECT HIS REQUEST ON ED DATA 3(011)
;3(011)	SEC			;FATAL ERROR
;3(011)	RTS	PC		;RETURN

;
;
;
DLTWD1:	MOV	DT11Q(R5),R2	;POINT TO WHERE STATUS IS
	MOV	DT11DT(R5),R4	;COUNT OF BYTES RECEIVED
	JSR	PC,DLGBYT	;GET COMMAND CODE BYTE INTO R1
	BCS	11$		;NONE, ERROR.
	TST	TCXLT(R5)	;;++BS-IS THERE A XLATE TASK ? 3(011)
	BEQ	14$		;;++BS-NO, REJECT THE REQUEST 3(011)
				;;++BS-YES, CONTINUE 3(011)
	MOV	#12$,R0		;POINT TO DISPATCH TABLE
	MOVB	#1,DT10DF+1(R5)	;SUCCESS CODE
	JSR	PC,DLDISP	;DISPATCH TO HANDLER
11$:	RTS	PC		;RETURN
;
;
;

14$:	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST 3(011)
	BR	11$		;;++BS-CONTINUE 3(011)



;
;
;
; DISPATCH TABLE
;
12$:	.WORD	<<13$-12$>/2>-2	;MAX TABLE INDEX
	.WORD	0		;0 = INVALID
	.WORD	DLTD01		;1 = SET CHARACTERISTICS
	.WORD	0		;2 = RESERVED
	.WORD	DLTD03		;3 = DUMP OUTPUT [1(627)]
	.WORD	DLTD04		;4 = CLEAR "INPUT PERMISSION WAS REQUESTED"
	.WORD	0		;5 = RESERVED
	.WORD	DLTD06		;6 = INTERPRET CC ON INPUT
	.WORD	DLTD07		;7 = DONT
	.WORD	DLTD08		;8 = INTERPRET CC ON OUTPUT
	.WORD	DLTD09		;9 = DONT
	.WORD	0		; RESERVED
	.WORD	0		; RESERVED
	.WORD	DLTD12		;12 = DO COMPONENT SELECTION
	.WORD	DLTD13		;13 = DONT
	.WORD	DLTD14		;14 = ENABLE PAGE COUNTER
	.WORD	DLTD15		;15 = DISABLE IT
	.WORD	0		;16 = RESERVED
	.WORD	DLTD17		;17 = DO SPACE COMPRESSION
	.WORD	DLTD18		;18 = DONT
	.WORD	DLTD19		;19 = USE OLD BSC PROTOCOL
	.WORD	DLTD20		;20 = DONT
	.WORD	DLTD21		;21 = REQUEST OUTPUT PERMISSION
	.WORD	DLTD22		;22 = GRANT INPUT PERMISSION
	.WORD	DLTD23		;23 = SIGNAL OUTPUT EOF
	.WORD	DLTD24		;24 = CLEAR OUTPUT EOF COMPLETE
	.WORD	DLTD25		;25 = SIGNAL OUTPUT ABORT
	.WORD	DLTD26		;26 = CLEAR OUTPUT ABORT COMPLETE
	.WORD	DLTD27		;27 = CLEAR INPUT EOF COMPLETE
	.WORD	DLTD28		;28 = SIGNAL INPUT ABORT
	.WORD	DLTD29		;29 = CLEAR INPUT ABORT COMPLETE
	.WORD	DLTD30		;30 = SUSPEND DEVICE (HASP)
	.WORD	DLTD31		;31 = UNSUSPEND DEVICE (HASP)
	.WORD	DLTD32		;32 = SET DEVICE RECORD SIZE
13$:
;
;
; SUBROUTINE TO PERFORM THE "READ LINE STATUS" FUNCTION.
;  IF THE LINE IS NOT INITIALIZED, GIVE A 0-LENGTH REPLY
;
DLTRLS:	JSR	PC,DTSHDR	;SETUP HEADER FOR TO-TEN XFER
	MOV	DT11DT(R5),DT10DT(R5) ;SET LENGTH OF IDIRECT DATA
	BEQ	14$		;ZERO LENGTH UNREASONABLE
	MOVB	DT11AD+1(R5),R0	;GET LINE NO
	MOV	R1,-(SP)	;;++BS-SAVE R1
	MOVB	NDQ11S, R1	;;++BS-GET NUMBER OF DQ11S
	DEC	R1		;;++BS-CONVERT TO LINE NUMBER
	CMPB	R1, R0		;;++BS-EXCEED MAX NUMBER ?
	BGE	31$		;;++BS-NO, CONTINUE
	MOV	(SP)+, R1	;;++BS-YES, RESTORE R1
	BR	32$		;;++BS-REJECT THE REQUEST
;	CMP	R0,NDQ11S	;IS IT REASONABLE?
;	BHIS	14$		;NO, ERROR.
31$:	MOV	(SP)+, R1	;;++BS-RESTORE R1
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R4	;POINT TO SPECIFIED LCB
	BEQ	11$		;NOT INITIALIZED.
	BIT	#LS.ENB,(R4)	;IS THE LINE ENABLED?
	BEQ	11$		;NO.
	MOV	R4,TCLCB(R5)	;SAVE LCB IN CASE WE NEED IT LATER
	MOV	DT11DT(R5),R4	;SET UP COUNT FOR DLPBYT
	MOV	#DTTTSB,R2	;POINT TO THE STATUS BLOCK
	MOV	R2,DTXADR(R5)	;SAVE ADR OF INDIRECT DATA
	MOV	TCLCB(R5),R0	;POINT TO LCB
	MOVB	LB.DVT(R0),R1	;GET TERMINAL TYPE
	JSR	PC,DLPBYT	;STORE IN USER'S BUFFER
	BCS	14$		;ERROR IF NO MORE ROOM
;3(007)	MOVB	LB.FGS(R0),R1	;GET LINE FLAGS
;3(007)	JSR	PC,DLPBYT	;STORE IN USER'S BUFFER
	MOV	LB.FGS(R0), R1	;;++BS-GET LINE FLAGS 3(007)
	JSR	PC, DLPWRD	;;++BS-SEND TO PDP-10 3(007)
	BCS	14$		;ERROR IF NO MORE ROOM
	MOV	#B0,R1		;INDICATE LINE IS ENABLED
	BIT	#LF.TSP,LB.FGS(R0) ;OUTPUT TRANSPARENT?
	BEQ	21$		;NO.
	BIS	#B3,R1		;HOPE NOBODY ELSE USES BIT 3
21$:	JSR	PC,DQMDMS	;SET DTR AND DSR INTO R1
	JSR	PC,DLPBYT	;STORE STATUS BYTE IN USER'S BUFFER
;
; CONTINUED ON NEXT PAGE
;
;
;  INCLUDE BSC STATISTICS IN LINE STATUS
;
	BCS	14$		;ERROR IF NO ROOM
;3(007)	CLR	R1		;SEND RESERVE BYTE ALSO [[RELEASE 4]]
;3(007)	JSR	PC,DLPBYT	;IN USERS BUFFER
;3(007)	BCS	14$		;ERROR IF NO ROOM
	MOV	TCLCB(R5),R0	;POINT R0 TO LCB
	MOV	#LB.ST2,R3	;COMPUTE ADDRESS OF LAST WORD + 2 4(025)
;4(025)	MOV	#LB.ST2+2,R3	;COMPUTE ADDRESS OF LAST WORD + 2
	ADD	R0,R3
	ADD	#LB.ST1,R0	;COMPUTE ADDRESS OF FIRST WORD
	JSR	PC,DLPSTR	;SEND LOTS OF WORDS
11$:	MOV	TCXFR(R5),DT10DT(R5) ;SETUP INDIRECT DATA LENGTH
	BEQ	12$		;DONT SET INDIRECT FOR ZERO LENGTH
	BIS	#B15,DT10FN(R5)	;INDICATE INDIRECT DATA TO FOLLOW
12$:				;JUST SEND THE DIRECT HEADER
	MOVB	#1,DT10DF+1(R5)	;SEND SUCCESS CODE = 1
	CLC			;INDICATE SUCCESS
13$:	RTS	PC		;RETURN
;
; HERE ON A PROTOCOL ERROR
;
14$:	SEC			;FATAL ERROR
	RTS	PC		;RETURN
;
;
; HERE WITH INCORRECT LINE NUMBER
;
32$:	MOV	TCXFR(R5), DT10DT(R5) ;;++BS-SET UP INDIRECT DATA LENGTH
	BEQ	33$		;;++BS-DON'T SET INDIRECT FOR ZERO LENGTH
	BIS	#B15, DT10FN(R5);;++BS-INDICATE INDIRECT DATA TO FOLLOW
33$:				;;++BS-JUST SEND THE DIRECT HEADER
	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST
	RTS	PC		;;++BS-RETURN
; 


;
; SUBROUTINE TO PERFORM THE "WRITE LINE COMMAND" FUNCTION.
;  THE FIRST BYTE OF THE DATA IS THE FUNCTION CODE, IF OTHER
;  DATA IS NEEDED IT FOLLOWS THE FUNCTION CODE.
;
; ON RETURN:
;
;	C SET -- DTE20 FAILURE OR BADLY FORMED COMMAND
;	C CLEAR -- R0 = 1 TO MEAN "SUCCESS", 2 TO MEAN "DELAYED"
;
DLTWLC:	TST	DT11FN(R5)	;BETTER BE INDIRECT DATA!!
	BMI	11$		;YES,IT IS
	STOPCD	DTI20		;DATA NOT INDIRECT ERROR
;
11$:
	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	CMP	R0,NDQ11S	;IN RANGE?
;	BHIS	12$		;NO, ERROR.
	MOV	#-1,DT10AK	;NOTE THAT WE EXPECT ED DATA
	CLC			;INDICATE SUCCESS
	RTS	PC		;RETURN
;
12$:	SEC			;FATAL ERROR
	RTS	PC		;RETURN
;
;
; COME HERE WHEN THE INDIRECT DATA HAS ARRIVED.
;
DLTWL1:	MOV	DT11Q(R5),R2	;POINT TO WHERE STATUS IS KEPT
	MOV	DT11DT(R5),R4	;SETUP THE COUNT
	JSR	PC,DLGBYT	;GET COMMAND CODE BYTE
	BCS	11$		;NONE, ERROR.
	MOV	#12$,R0		;POINT TO DISPATCH TABLE
	MOVB	#1,DT10DF+1(R5) ;SET SUCCESS CODE
	JSR	PC,DLDISP	;DISPATCH TO HANDLER
11$:	RTS	PC		;RETURN
;
; DISPATCH TABLE
;
12$:	.WORD	<<13$-12$>/2>-2	;MAX TABLE INDEX
	.WORD	0		;0 = INVALID
	.WORD	DLTL01		;1 = ENABLE
	.WORD	DLTL02		;2 = SET DTR
	.WORD	DLTL03		;3 = ABORT AND HANG UP
	.WORD	DLTL04		;4 = DISABLE
	.WORD	DLTL05		;5 = SET CTS DELAY
	.WORD	DLTL06		;6 = SET LENGTH OF SILO WARNING AREA
	.WORD	DLTL07		;7 = SET OUTPUT IN TRANSPARENT MODE
	.WORD	DLTL08		;8 = SET OUTPUT IN NON-TRANSPARENT MODE
	.WORD	DLTL09		;9 = SET TRANSMISSION BLOCK LENGTH
	.WORD	DLTL10		;10= SET RECORDS PER MESSAGE
	.WORD	DLTL11		;11= SET LINE SIGNATURE (;;++BS-)
13$:
;
;
;
; SUBROUTINE TO PERFORM THE "WRITE DN60 COMMAND" FUNCTION.
;  THE FIRST BYTE OF THE DATA IS THE FUNCTION CODE, IF OTHER
;  DATA IS NEEDED IT FOLLOWS THE FUNCTION CODE.
;
; ON RETURN:
;
;	C SET -- DTE20 FAILURE OR BADLY FORMED COMMAND
;	C CLEAR -- R0 = 1 TO MEAN "SUCCESS", 2 TO MEAN "DELAYED"
;
DLTWEC:
	TST	DT11FN(R5)	;MUST BE INDIRECT
	BMI	11$		;YES,IT IS
	STOPCD	DTI20		;DATA NOT INDIRECT
;
11$:	MOV	#-1,DT10AK	;NOTE THAT WE EXPECT ED DATA
	CLC			;INDICATE SUCCESS
	RTS	PC		;RETURN
;
;
; COME HERE WHEN THE INDIRECT DATA ARRIVES.
;
DLTWS1:	MOV	DT11Q(R5),R2	;POINT TO STATUS
	MOV	DT11DT(R5),R4	;SETUP COUNT
	JSR	PC,DLGBYT	;GET COMMAND CODE BYTE
	BCS	11$		;NONE, ERROR.
	MOV	#12$,R0		;POINT TO DISPATCH TABLE
	MOVB	#1,DT10DF+1(R5) ;SET SUCCESS CODE
	JSR	PC,DLDISP	;DISPATCH TO HANDLER
11$:	RTS	PC		;RETURN
;
; DISPATCH TABLE
;
12$:	.WORD	<<13$-12$>/2>-2	;MAX TABLE INDEX
	.WORD	0		;0 = INVALID
;	.WORD	DLTE01		;1 = ???
13$:
;
;
; SUBROUTINE FOR LINE COMMAND 1: ENABLE THE LINE
;
DLTL01:	CLR	NWLFLG		;;++BS- ASSUME THIS IS A NEW LINE

	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	MOV	R1,-(SP)	;;++BS-SAVE R1
	MOVB	NDQ11S, R1	;;++BS-GET NUMBER OF DQ11S
	DEC	R1		;;++BS-CONVERT TO LINE NUMBER
	CMPB	R1, R0		;;++BS-EXCEED MAX NUMBER ?
	BGE	29$		;;++BS-NO, CONTINUE
	MOV	(SP)+, R1	;;++BS-YES, RESTORE R1
	JMP	24$		;;++BS-YES, REJECT REQUEST, NOT FATAL
29$:	MOV	(SP)+, R1	;;++BS-RESTORE R1

	ASL	R0		;LINE NUMBER * 2
	TST	DQLCB(R0)	;ALREADY A LINE CONTROL BLOCK?
	BNE	11$		;YES.
	ASR	R0		;NO, PUT LINE NUMBER IN R0
	JSR	PC,DLENLN	;BUILD AN LCB
	BCS	18$		;OUT OF CORE
	MOV	#1, NWLFLG	;;++BS- INDICATE THIS IS A NEW LINE
11$:	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R0	;POINT R0 TO LCB
	BIT	#LS.ENB,(R0)	;IS THE LINE ENABLED?
	BNE	17$		;YES, CAN'T ENABLE IT AGAIN.
;3(013)	BIT	#LF.DIP!LF.ABC,LB.FGS(R0) ;DISABLE IN PROGRESS?
	BIT	#LF.DIP, LB.FGS(R0) ;;++BS-DISABLE IN PROGRESS ? 3(013)
	BNE	18$		;YES, GIVE DELAYED RETURN
;
;;++BS- THIS CODE DELETES THE BSC TASK AFTER THE LINE IS DISABLED


	TST	NWLFLG		;IS THIS A NEW LINE ?
	BNE	25$		;YES, THERE WAS NO BSC TASK

	BIT	#LF.DAC, LB.FGS(R0) ;NO, DID BSC DISABLE THE LINE ?
	BEQ	18$		;NO, GIVE DELAYED RETURN

	JSR	PC, HSSAVR	;YES, SAVE THE REGISTERS
	MOV	R0, R4		;PUT POINTER TO LCB IN R4
	MOV	LB.TC1(R4), R0	;GET POINTER TO BSC TASK
	BEQ	26$		;NO BSC, EXIT
	MOV	TCBP1, R3	;R3 MUST POINT TO START OF CHAIN
	JSR	PC, DLRLTC	;RELEASE TCB AND UNLINK FROM CHAIN
	MOV	R3, TCBP1	;UPDATE START OF CHAIN OF TCBS
	CLR	LB.TC1(R4)	;CLEAR BSC TCB POINTER

26$:				;CLEAN UP LCB

	MOV	#NDHASP, R2	;GET NUMBER OF XLATE TCBS
27$:	MOV	R4, R1		;POINT TO LCB 4(026)
;4(026)	MOV	R0, R1		;POINT TO LCB
	CLC			;CLEAR FOR ROTATE
	ASL	R2		;MAKE EVEN FOR WORD OFFSET
	ADD	R2, R1		;OFFSET INTO LCB
	CLC			;CLEAR FOR ROTATE
	ASR	R2		;GET BACK # OF XLATE TCBS
	CLR	LB.TC1(R1)	;CLEAR XLATE TCB POINTER IN LCB
	SOB	R2, 27$		;CLEAR THE REST OF THE XLATE POINTERS
	JSR	PC, HSRESR	;RESTORE THE REGISTERS

25$:

;;++BS- END OF CODE THAT DELETES THE BSC TASK AFTER THE LINE IS DISABLED
;
;
	MOV	R0,TCLCB(R5)	;REMEMBER LCB 
	JSR	PC,DLGBYT	;GET DEVICE TYPE
	BCS	17$		;NONE SPECIFIED
	MOV	R1,LB.DVT(R0)	;STORE DEVICE TYPE
	JSR	PC,DLGBYT	;GET CHARACTERISTICS
	BCS	17$		;NOT SPECIFIED
	MOV	R1,LB.FGS(R0)	;STORE CHARACTERISTICS
	BIT	#LF.PRI,R1	;PRIMARY?
	BNE	12$		;YES.
	MOV	#3*JIFSEC,LB.EQW(R0) ;NO, MAKE SECONDARY
;12$:	JSR	PC,DLBTCB	;BUILD TCB'S FOR XLATE TASKS
12$:
	.IF EQ, XLOPHP		;CHECK IF HASP PRESENT

	CMP	#TTHASP,LB.DVT(R0)	;IS THIS A HASP LINE?
	BNE	20$			;NO, CONTINUE
	BR	19$			;YES, BUT HASP NOT PRESENT- ERROR

20$:

	.ENDC				;.IF EQ, XLOPHP
	JSR	PC,DLBTCB	;BUILD TCB'S FOR XLATE TASKS
	BCS	18$		;OUT OF STORAGE
	MOV	LB.TC1(R0),R1	;POINT TO BSC TASK
	BNE	13$		;MAKE SURE BSC TCB EXISTS
	STOPCD	HSC		;TRAP OTHERWISE
13$:
	CLR	TCST2(R1)	;BE SURE IT IS INITIALIZED
	CLR	TCFG1(R1)	; SO THERE IS NO PROBLEMS WITH
	CLR	TCFG2(R1)	; ANY EARLIER ABORTS
	BIS	#LS.ENB,(R0)	;ENABLE THE LINE
	CLR	R2		;INITIALIZE OFFSET IN TABLE
	MOV	LB.LNU(R0),R1	;NO, INITIALIZE CURRENT MSG PTR
	ASL	R1		;FOR WORD BOUNDARY PTR
	CMP	#TTHASP,LB.DVT(R0)	;HASP LINE?
	BEQ	14$		;YES.
	ADD	R5,R1		;POINT TO CURRENT MSG FOR LINE
	CLR	TCCMSG(R1)	;CLEAR IT
	BR	16$		;AND EXIT
;
;
; HERE FOR HASP LINE, SET DEVICE MSG PTR
;
14$:	JSR	PC,DLGDTA	;GET DEVICE TABLE ADDRESS
	ADD	R5,R2		;R2 IS RETURNED WITH OFFSET
	ADD	R5,R1		;POINT TO PLACE TO SAVE
	MOV	R2,TCCMSG(R1)	;SAVE PTR TO DEVICE MESSAGES
	MOV	#5,R1		;INITIALIZE ALL DEVICE MSG PTRS
15$:	CLR	(R2)		;CLEAR MSG PTR
	ADD	#2,R2		;INCREMENT PTR FOR NEXT MSG
	SOB	R1,15$		;COVER ALL DEVICE MSG PTRS
16$:
	BIS	#LF.ENC,LB.FGS(R0) ;ENABLE COMPLETE
	BIC	#LF.DAC,LB.FGS(R0) ;CLEAR DISABLE COMPLETE
21$:	CLC			; NOT FATAL ERROR
	RTS	PC		; AND RETURN.
;
; HERE ON UNREASONABLE ERROR.
;
17$:	SEC			;INDICATE FATAL ERROR
	RTS	PC		;RETURN.
;
; HERE IF SHORT ON STORAGE
;
18$:	MOVB	#2,DT10DF+1(R5) ;INDICATE OPERATION DELAYED
	CLC			;BUT NOT UTTER FAILURE
	RTS	PC		;RETURN.

;
;HERE IF REQUESTED A LINE WE DO NOT HAVE
;
24$:	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST
	RTS	PC		;;++BS-RETURN

	.IF EQ, XLOPHP		;NO HASP BUT HASP LINE INDICATED-ERROR

; HERE IF HASP REQUEST AND NO HASP SUPPORT



19$:	MOVB	#3, DT10DF+1(R5)	;INDICATE REQUEST REJECTED 
	BIS	#LF.DAC, LB.FGS(R0)	;INDCATE LINE HAS BEEN DISABLED BY BSC TASK
	BR 21$			;NO HASP SUPPORT- RETURN

	.ENDC			;.IF EQ, XLOPHP


NWLFLG:	.WORD	0		;FLAG TO INDICATE A NEW LCB WAS BUILT



;
;
; SUBROUTINE TO GET DEVICE TABLE OFFSET FOR MESSAGES
;
DLGDTA:
	MOV	R1,-(SP)	;SAVE LINE # * 2
	ASR	R1		;GET LINE # BACK
	TST	R1		;LOOP FOR NON-ZERO LINE
	BEQ	12$		;SKIP FOR LINE ZERO
11$:	ADD	#2*NDHASP,R2	;GO OVER ONE LINE TABLE FOR DEVICES 4(027)
;4(027)	MOV	#2*NDHASP,R2	;GO OVER ONE LINE TABLE FOR DEVICES
	SOB	R1,11$		;GET OFFSET FOR THE LINE
12$:	ADD	#TCDMSG,R2	;COMPLETE OFFSET IN R2
	MOV	(SP)+,R1	;RESTORE LINE # * 2
	RTS	PC		;AND RETURN
;
;
; SUBROUTINE TO BUILD THE LINE CONTROL BLOCK AND THE
;  TASK CONTROL BLOCKS NEEDED FOR EACH DQ11 LINE.
;
; R0 = LINE NUMBER
;
; ON RETURN:
;
; C CLEAR: LCB ALLOCATED
;
; C SET: OUT OF STORAGE
;
DLENLN:	MOV	R0,-(SP)	;SAVE LINE NUMBER
	MOV	#LB.SIZ,R0	;LENGTH OF A LCB
	JSR	PC,GETSTG	;GET SPACE FOR A LCB
	BCC	11$		;BRANCH IF ENOUGH SPACE
	MOV	(SP)+,R0	;OUT OF SPACE--GET LINE NUMBER
	SEC			;FLAG FAILURE
	RTS	PC		; AND RETURN, NO LCB CREATED.
;
; HERE IF THERE IS ENOUGH STORAGE FOR THE LCB
;
11$:	MOV	(SP)+,R1		;GET LINE NUMBER
	ASL	R1		;LINE NUMBER * 2
	MOV	R0,DQLCB(R1)	;STORE POINTER TO LCB
	MOV	DQCSR(R1),LB.SLA(R0) ;STORE CSR ADDRESS
	MOV	DQVEC(R1),LB.SLV(R0) ;STORE VECTOR ADDRESS
	ASR	R1		;GET LINE NUMBER * 1
	MOV	R1,LB.LNU(R0)	;STORE LINE NUMBER
	MOV	#1*JIFSEC,LB.EQW(R0) ;TIME BETWEEN SENDING ENQ'S
	MOV	#3,LB.EQN(R0)	;NUMBER OF ENQ'S TO SEND BEFORE
				; ASSUMING LINE IS DOWN.
	MOV	#MDMXSD,LB.MDS(R0) ;LENGTH OF SILO WARNING AREA FOR KMC11
	MOV	#DQTYPE,LB.TYP(R0) ;LINE DRIVER TYPE
	CLR	LB.FGS(R0)	;CLEAR LINE FLAGS
	RTS	PC		;RETURN AFTER BULDING LCB
;
;
;THIS SUBROUTINE BUILDS TCB FOR THE BSC AND XLATE TASKS.
; IN 3780/2780 WE NEED ONLY ONE TCB FOR XLATE TASK
; WHILE FOR HASP-MULTILEAVING WE NEED 5 TCB'S IN SIMULATE
; AND 4 TCB'S IN SUPPORT MODE OF OPERATION
;
DLBTCB:	MOV	R0,-(SP)	;SAVE POINTER TO LCB
	MOV	R0,R4		;LCB POINTER IN R4
	MOV	LB.TC1(R0),R0	;POINT TO BSC TCB
	BNE	17$		;ITS ALREADY SET UP
	JSR	PC,GETTCB	;GET A TASK CONTROL BLOCK
	bcc	7$		;got the tcb
	jmp	dlenlo		;out of storage
7$:	MOV	#DQDRVR,TCPC(R0) ;STORE INITIAL ADDRESS
	BIS	#BR3,TCPS(R0)	;SET PRIORITY LEVEL TO 3
	MOV	(SP),R4		;GET POINTER TO LCB
	MOV	R4,TCLCB(R0)	;STORE LCB POINTER
	MOV	R0,LB.TC1(R4)	;STORE BSC TASK POINTER
	MOV	TCBP1,R1	;GET HIGHEST-PRIORITY TCBS
	MOV	R0,TCBP1	;PUT THIS TCB ON THE LIST
	MOV	R1,TCHAIN(R0)	; ...
17$:	CLR	R2		;CLEAR DEVICE # INITIALLY
	CMP	#TTHASP,LB.DVT(R4)	;HASP LINE?
	BEQ	11$		;YES.
	MOV	#1,LB.NTC(R4)	;NO, SET UP FOR 1 TCB FOR 2780/3780
	JSR	PC,GETTCB	;GET A TASK CONTROL BLOCK
	BCS	dlenlo		;NO ROOM.
	MOV	#XLATE,TCPC(R0)	;STORE START ADR OF TASK
	CLR	TCDEV(R0)	;DEVICE IS 0 FOR 2780/3780
	BR	13$		;GO PAST HASP SETTINGS
11$:	MOV	#4,LB.NTC(R4)	;SET UP # OF TCB'S FOR HASP DEVICES
	BIT	#LF.SIM,LB.FGS(R4) ;IN SIMULATE MODE?
	BEQ	12$		;NO.
	INC	LB.NTC(R4)	;5 TCB FOR SIMULATE MODE
12$:	INC	R2		;MAKE R2 DEVICE #
	JSR	PC,GETTCB	;GET TCB FOR XLATE TASK
	BCS	dlenlo		;NO ROOM
	.IF NE, XLOPHP		;HASP PRESENT
	MOV	#XLHASP,TCPC(R0) ;SET UP START ADR OF TASK
	.ENDC			;.IF NE, XLOPHP
	MOV	R2,TCDEV(R0)	;AND DEVICE # IN THE TCB
	CLR	TCFG1(R0)	;CLEAR FLAGS TO AVOID 
	CLR	TCFG2(R0)	;PROBLEMS LATER
13$:	BIS	#BR1,TCPS(R0)	;SET PRIORITY LEVEL TO 1
	MOV	R4,TCLCB(R0)	;STORE LCB POINTER
	MOV	R4,R1		;PRESERVE LCB PTR IN R4
	ASL	R2		;DEVICE # * 2 FOR WORD PTR
	ADD	R2,R1		;ADD DEVICE # TO GET XLATE TCB ADR
	ASR	R2		;RESTORE R2 BACK TO DEVICE #
	MOV	R0,LB.TCD(R1)	;STORE COMP. POINTER
	MOV	TCBP3,R1	;GET LOW-PRIORITY TCBS
	MOV	R0,TCBP3	;PUT THIS TCB ON THE LIST
	MOV	R1,TCHAIN(R0)	; ...
;
; continued on next page
;
;
; here to get storage for line buffer for each device
;
	MOV	#150.,R0	;LENGTH OF LINE BUFFER
	JSR	PC,GETSTG	;GET STORAGE FOR IT
	BCS	dlenlo		;OUT OF STORAGE
	MOV	TCBP3,R1	;GET POINTER TO XLATE TCB
	MOV	R0,TCBFP(R1)	;STORE POINTER TO LINE BUFFER
	MOV	#150.,TCBFC(R1)	;STORE LENGTH OF LINE BUFFER
;
	CMP	#TTHASP,LB.DVT(R4) 	;HASP LINE?
	bne	14$		;all done for 2780/3780
	CMP	LB.NTC(R4),R2	;DONE WITH ALL DEVICES XLATE TCB'S
	BNE	12$		;NO
	jsr	pc,dlsiom	;set device in input/output mode
14$:	MOV	LB.SLV(R4),R1	;GET VECTOR ADDRESS
	MOV	#BR7,R0		;GET INITIAL PS
	ADD	LB.LNU(R4),R0	;ADD LINE NUMBER
.IIF NE,FTRACE,BIS TRCFLG,R0	;ADD TRACE BIT IF REQUESTED
	MOV	#DQAINT,(R1)+	;STORE PC FOR INTERRUPT A
	MOV	R0,(R1)+	;STORE PS FOR INTERRUPT A
	MOV	#DQBINT,(R1)+	;STORE PC FOR INTERRUPT B
	MOV	R0,(R1)+	;STORE PS FOR INTERRUPT B
	MOV	(SP)+,R0	;RESTORE LCB POINTER IN R0
	CLC			;CLEAR C TO FLAG SUCCESS
	RTS	PC		; AND RETURN.
;
;
; HERE IF WE RUN OUT OF STORAGE GETTING A TCB.
;
DLENLO:	MOV	(SP),R4		;GET LCB POINTER
	JSR	PC,DLRTCB	;RELEASE ALL STORAGE FOR TCB AND LCB
	MOV	(SP)+,R0	;GET LCB POINTER
	SEC			;SET C AS A FLAG
	RTS	PC		; AND RETURN.
;
;
; THIS SUBROUTINE SETS A FLAG TO INDICATE WHETHER THE DEVICE
; IS DOING INPUT OR OUTPUT. FLAG IS USED BY XLATE TASKS.
;
DLSIOM:	MOV	R4,R1		;PRESERVE R4
	BIT	#LF.SIM,LB.FGS(R4) ;SIMULATE MODE?
	BEQ	11$		;NO, MUST BE SUPPORT
	ADD	#2,R1		;DEVICE 1 IS CONSOLE INPUT TO IBM
	MOV	LB.TCD(R1),R0	;GET XLATE TCB PTR
	BIS	#TCIOM,TCFG1(R0) ;MARK AS INPUT DEVICE
	JSR	PC,DLFRBF	;DONT NEED BUFFER FOR INPUT
	ADD	#2,R1		;BYPASS CONSOLE OUT
11$:	ADD	#4,R1		;FOR CONSOLE INPUT (SUP), LPT (SIM)
	MOV	LB.TCD(R1),R0	;GET XLATE TCB PTR
	BIS	#TCIOM,TCFG1(R0) ;FLAG INPUT DEVICE
	JSR	PC,DLFRBF	;FREE THE LINE BUFFER
	ADD	#2,R1		;FOR PUNCH DEVICE
	MOV	LB.TCD(R1),R0	;GET PTR TO XLATE TCB
	BIS	#TCIOM,TCFG1(R0) ;FLAG AS INPUT DEVICE
	JSR	PC,DLFRBF	;FREE THE INPUT LINE BUFFER
	RTS	PC		;AND RETURN
;








; THIS SUBROUTINE FREES THE LINE BUFFER STORAGE AND 
; CLEARS THE POINTER IN THE XLATE TCB'S.
;
DLFRBF:	MOV	R0,-(SP)	;SAVE R0
	MOV 	TCBFP(R0),R0	;GET BUFFER POINTER
	BEQ	11$		;ITS ALREADY FREED
	JSR	PC,FRESTG	;FREE THE STORAGE
11$:	MOV	(SP)+,R0	;RESTORE R0
	CLR	TCBFP(R0)	;CLEAR POINTER IN TCB
	RTS	PC		;RETURN
;
;
; SUBROUTINE TO RELEASE BSC AND XLATE TCBS
; NEEDS LCB POINTER IN R4 ON ENTRY
; R4 IS PRESERVED, R0, R2 ARE DESTROYED
;
DLRTCB:	MOV	LB.TC1(R4),R0	;GET PTR TO BSC TASK
	BEQ	DLXTCB		;NO BSC, LOOK FOR XLATE TCB'S
	MOV	TCBP1,R3	;R3 MUST POINT TO START OF CHAIN
	JSR	PC,DLRLTC	;RELEASE TCB AND UNLINK FROM CHAIN
	MOV	R3,TCBP1	;UPDATE START OF CHAIN OF TCBS
	CLR	LB.TC1(R4)	;CLEAR BSC TCB POINTER
DLXTCB:	MOV	LB.NTC(R4),R2	;GET # OF TCBS FOR XLATE
	BEQ	16$		;JUST IN CASE ITS ZERO
	CMP	#1,R2		;2780/3780 MODE
	BNE	11$		;NO.
	CLR	R1		;FOR 2780/3780 MODE
	BR	12$		;BYPASS HASP DEVICE LOGIC
11$:	MOV	R2,R1		;START WITH HIGHEST DEVICE #
	ASL	R1		;DEVICE # MUTLIPLIED BY 2
12$:	ADD	R4,R1		;GET TCB PTR TO DEVICE'S
	MOV	LB.TCD(R1),R0	;XLATE TASK
	BEQ	15$		;NONE FOR THIS, CHECK NEXT DEVICE
	JSR	PC,DLFRBF	;RELAESE LINE BUFFER
	MOV	R0,-(SP)	;SAVE XLATE TCB PTR
	MOV	TCSBF(R0),R0	;ANY COMPRESSED BUFFER TO RELEASE?
	BEQ	14$		;NO.
	JSR	PC,FRESTG	;YES, RELEASE IT
14$:	MOV	(SP)+,R0	;RESTORE XLATE PTR
	CLR	LB.TCD(R1)	;CLEAR POINTER TO TCB
	MOV	TCBP3,R3	;POINT TO START OF TCB CHAIN
	JSR	PC,DLRLTC	;RELEASE AND UNLINK TCB FOR XLATE
	MOV	R3,TCBP3	;UPDATE POINTER TO START OF TCB CHAIN
15$:	SOB	R2,11$		;DO FOR ALL DEVICE XLATE TCB'S
	CLR	LB.TCD(R4)	;CLEAR ANY PREV XLATE POINTER
;
16$:	CLC			;INDICATE SUCCESS
	RTS	PC		;RETURN
;
	CLC			;INDICATE SUCCESS
	RTS	PC		;RETURN
;
;
;
; THIS SUBROUTINE FREES THE TCB WHOSE ADDRESS IS IN R0 AND
; UNLINKS THE TCB FROM THE CHAIN WHOSE START IS POINTED TO 
; BY R3. R3 IS RETURNED WITH UPDATED POINTER TO START OF CHAIN.
; R1 IS DESTROYED BY THIS ROUTINE. R0 AND R2 ARE PRESERVED.
;
DLRLTC:	MOV	R2,-(SP)	;SAVE R2
	CMP	R3,R0		;IS IT FIRST TCB OF CHAIN?
	BNE	13$		;NO, HUNT THRU THE CHAIN
	MOV	TCHAIN(R0),R3	;YES, UPDATE POINTER TO START OF CHAIN
11$:	JSR	PC,FRETCB	;FREE THE TCB
12$:	MOV	(SP)+,R2	;RESTORE R2
	CLC			;INDICATE SUCCESS
	RTS	PC		;RETURN
;
13$:	MOV	R3,R1		;MAKE FIRST TCB THE PREVIOUS ONE
14$:	MOV	TCHAIN(R1),R2	;POINT TO NEXT TCB IN CHAIN
	BEQ	16$		;TCB MISSING FROM QUE
	CMP	R0,R2		;MATCH OUR TCB?
	BEQ	15$		;YES.
	MOV	R2,R1		;MAKE CURRENT THE PREV ONE
	BR	14$		;HUNT TILL MATCH
;
15$:	MOV	TCHAIN(R2),TCHAIN(R1) ;UNLINK TCB FROM CHAIN
	BR	11$		;FREE THE TCB AND EXIT
;
; HERE IF TCB IS FOUND MISSING FROM THE QUE
;
16$:	STOPCD	DTM		;TCB MISSING
;
;
; SUBROUTINE TO DO LINE COMMAND 02: SET DTR
;
DLTL02:	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R0	;GET LCB
	BEQ	11$		;SHOULD BE THERE
	BIT	#LS.ENB,(R0)	;IS THE LINE ENABLED?
	BEQ	11$		;NO.  CAN'T SET DTR.
	JSR	PC,DQDTR1	;SET DATA TERMINAL READY
	CLC			;NOT FATAL ERROR
	RTS	PC		;RETURN.
;
; HERE IF NO LCB OR NOT ENABLED
;
11$:	;SEC			;INDICATE FATAL ERROR
	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST
	RTS	PC		;RETURN.
;
; SUBROUTINE TO DO LINE COMMAND 03: CLEAR DTR
;
DLTL03:	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R0	;GET LCB
	BEQ	11$		;SHOULD BE THERE
	BIT	#LS.ENB,(R0)	;IS THE LINE ENABLED?
	BEQ	11$		;NO, CAN'T CLEAR DTR.
	JSR	PC,DQDTR0	;CLEAR DATA TERMINAL READY [1(665)]
	CLC			;NOT FATAL ERROR
	RTS	PC		;RETURN.
;
; HERE IF NO LCB OR NOT ENABLED.
;
11$:	;SEC			;INDICATE FATAL ERROR
	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST
	RTS	PC		;RETURN.
;
; SUBROUTINE TO DO LINE COMMAND 04: DISABLE
;
DLTL04:	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	MOV	R1, -(SP)	;;++BS-SAVE R1
	MOVB	NDQ11S, R1	;;++BS-GET NUMBER OF DQ11S
	DEC	R1		;;++BS-CONVERT TO LINE NUMBER
	CMPB	R1, R0		;;++BS-EXCEED MAX NUMBER ?
	BLT	11$		;;++BS-YES, IGNORE
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R0	;GET LCB POINTER
	BEQ	11$		;DOESN'T MATTER IF NOT THERE
;	BIC	#LS.ENB,(R0)	;THERE, DISABLE IT.
;	MOV	R0,R4		;POINT R4 TO LCB
;	JSR	PC,DLRTCB	;RELEASE BSC AND XLATE TCB'S
	BIT	#LS.ENB,(R0)	;WAS LINE ENABLED?
	BEQ	11$		;NO.
	BIC	#LS.ENB,(R0)	;THERE, DISABLE IT.
11$:	MOV	(SP)+, R1	;;++BS-RESTORE R1
	CLC			;NO FATAL ERROR
	RTS	PC		;RETURN.
;
;
; SUBROUTINE TO DO LINE COMMAND 05: SET CTS DELAY
;
DLTL05:	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R0	;GET LCB POINTER
	BEQ	11$		;SHOULD BE THERE
	BIT	#LS.ENB,(R0)	;IS THE LINE ENABLED?
	BEQ	11$		;NO, CAN'T SET CTS DELAY
	JSR	PC,DLGBYT	;GET LOW BITS OF CTS DELAY
	BCS	11$		;NOT SPECIFIED
	MOVB	R1,LB.CSD(R0)	;STORE LOW BITS
	JSR	PC,DLGBYT	;GET HIGH BITS
	BCS	11$		;NOT SPECIFIED
	MOVB	R1,LB.CSD+1(R0)	;STORE HIGH BITS
	CLC			;NO FATAL ERROR
	RTS	PC		;RETURN.
;
; HERE IF THE LINE IS NOT ENABLED OR IF THE ARGUMENT IS
;  NOT COMPLETELY SPECIFIED.
;
11$:	;SEC			;INDICATE ERROR
	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST
	RTS	PC		;RETURN.
;
; SUBROUTINE TO DO LINE COMMAND 06: SET LENGTH OF SILO WARNING AREA
;  (THIS IS ONLY EFFECTIVE IF THE LINE DRIVER INCLUDES A KMC11)
;
DLTL06:	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R0	;GET LCB POINTER
	BEQ	11$		;NONE, ERROR.
	BIT	#LS.ENB,(R0)	;IS THE LINE ENABLED?
	BEQ	11$		;NO, ERROR.
	JSR	PC,DLGBYT	;GET LOW BITS OF LENGTH OF SILO WARNING AREA
	BCS	11$		;NOT SPECIFIED, ERROR.
	MOVB	R1,LB.MDS(R0)	;STORE LOW BITS
	JSR	PC,DLGBYT	;GET HIGH BITS
	BCS	11$		;NOT SPECIFIED, ERROR
	MOVB	R1,LB.MDS+1(R0)	;STORE HIGH BITS
	CLR	LB.MDU(R0)	;CLEAR MAX DEPTH USED
	CLC			;NO FATAL ERROR
	RTS	PC		;RETURN.
;
; HERE IF THE LINE IS NOT ENABLED OR IF THE ARGUMENT
;  IS OMITTED OR NOT COMPLETELY SPECIFIED.
;
11$:	;SEC			;FLAG AN ERROR
	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST
	RTS	PC		;RETURN.
;
;
;
; SUBROUTINE TO DO LINE COMMAND 07: SET OUTPUT IN TRANSPARENCY
; THIS APPLIES ONLY TO HASP-MULTILEAVING LINES
;
DLTL07:	MOVB	DT11AD+1(R5),R0 ;GET THE LINE NUMBER
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R0	;GET LCB POINTER
	BEQ	11$		;NONE, ERROR.
	BIT	#LS.ENB,(R0)	;IS THE LINE ENABLED?
	BEQ	11$		;NO, ERROR.
	BIS	#LF.TSP,LB.FGS(R0) ;SET FLAG IN LINE CONTROL BLOCK
	MOV	LB.TC1(R0),R1	;GET POINTER TO BSC TCB
	BIS	#TCTSP,TCFG1(R1) ;SET TRASPARENT FLAG FOR BSC
	CLC			;NO FATAL ERROR
	RTS	PC		;RETURN
;
; HERE IF THE LINE IS NOT ENABLED OR IF THE ARGUMENT
;  IS OMITTED OR NOT COMPLETELY SPECIFIED.
;
11$:	;SEC			;FLAG AN ERROR
	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST
	RTS	PC		;RETURN.
;
; SUBROUTINE TO DO LINE COMMAND 08: SET OUTPUT IN NON-TRANSPARENCY
; THIS APPLIES ONLY TO HASP-MULTILEAVING LINES
;
DLTL08:	MOVB	DT11AD+1(R5),R0 ;GET THE LINE NUMBER
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R0	;GET LCB POINTER
	BEQ	11$		;NONE, ERROR.
	BIT	#LS.ENB,(R0)	;IS THE LINE ENABLED?
	BEQ	11$		;NO, ERROR.
	BIC	#LF.TSP,LB.FGS(R0) ;SET FLAG IN LINE CONTROL BLOCK
	MOV	LB.TC1(R0),R1	;POINT TO BSC TCB
	BIC	#TCTSP,TCFG1(R1) ;CLEAR TRANSPARENCY FOR BSC TO LOOK AT
	CLC			;NO FATAL ERROR
	RTS	PC		;RETURN
;
; HERE IF THE LINE IS NOT ENABLED OR IF THE ARGUMENT
;  IS OMITTED OR NOT COMPLETELY SPECIFIED.
;
11$:	;SEC			;FLAG AN ERROR
	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST
	RTS	PC		;RETURN.
;

;
; SUBROUTINE TO SET TRANSMISSION BLOCK SIZE
;
DLTL09:	MOVB	DT11AD+1(R5),R0 ;GET THE LINE NUMBER
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R0	;POINT TO THE LCB
	BEQ	11$		;NONE THERE, ERROR
	BIT	#LS.ENB,(R0)	;IS THE LINE ENABLED?
	BEQ	11$		;NO, ERROR
	JSR	PC,DLGBYT	;GET LOW ORDER BYTE OF BLOCK SIZE
	BCS	11$		;NOT SPECIFIED, ERROR
	MOVB	R1,LB.MBL(R0)	;STORE LOW BITS
	JSR	PC,DLGBYT	;GET HIGH ORDER BITS
	BCS	11$		;NOT SPECIFIED, ERROR
	MOVB	R1,LB.MBL+1(R0)	;STORE HIGH BITS
	CLC			;INDICATE SUCCESS
	RTS	PC		;RETURN
;
11$:	;SEC			;INDICATE FAILURE
	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST
	RTS	PC		;AND RETURN
;
; SUBROUTINE TO SET RECORDS PER MESSAGE FOR TRANSMISSION BLOCK
;
DLTL10:	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R0	;POINT TO THE LCB
	BEQ	11$		;NONE THERE, ERROR
	BIT	#LS.ENB,(R0)	;IS THE LINE ENABLED?
	BEQ	11$		;NO, ERROR
	JSR	PC,DLGBYT	;GET LOW ORDER BYTE OF # OF RECORDS
	BCS	11$		;NOT SPECIFIED, ERROR
	MOVB	R1,LB.MLR(R0)	;STORE LOW BITS
	JSR	PC,DLGBYT	;GET HIGH ORDER BITS
	BCS	11$		;NOT SPECIFIED, ERROR
	MOVB	R1,LB.MLR+1(R0)	;STORE HIGH BITS
	CLC			;INDICATE SUCCESS
	RTS	PC		;RETURN
;
11$:	;SEC			;INDICATE FAILURE
	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST
	RTS	PC		;AND RETURN

;
;
;
; SUBROUTINE TO SET LINE SIGNATURE (;;++BS-)


DLTL11:	MOVB	DT11AD+1(R5),R0	;GET LINE NUMBER
	ASL	R0		;LINE NUMBER * 2
	MOV	DQLCB(R0),R0	;GET LCB POINTER
	BEQ	11$		;NONE, ERROR.
	BIT	#LS.ENB,(R0)	;IS THE LINE ENABLED?
	BEQ	11$		;NO, ERROR.
	JSR	PC,DLGBYT	;GET LOW BITS OF LENGTH OF SILO WARNING AREA
	BCS	11$		;NOT SPECIFIED, ERROR.
	MOVB	R1,LB.SIG(R0)	;STORE LOW BITS
	JSR	PC,DLGBYT	;GET HIGH BITS
	BCS	11$		;NOT SPECIFIED, ERROR
	MOVB	R1,LB.SIG+1(R0)	;STORE HIGH BITS
	CLC			;NO FATAL ERROR
	RTS	PC		;RETURN.
;
; HERE IF THE LINE IS NOT ENABLED OR IF THE ARGUMENT
;  IS OMITTED OR NOT COMPLETELY SPECIFIED.
;
11$:	;SEC			;FLAG AN ERROR
	JSR	PC, DLRJRQ	;;++BS-REJECT THE REQUEST
	RTS	PC		;RETURN.



;
; EACH SUBROUTINE OF THE FORM DLTDXX WHERE XX IS A DECIMAL NUMBER
;  PERFORMS THE DEVICE COMMAND NUMBER XX.
;
; SUBROUTINE TO DO DEVICE COMMAND 01: SET CHARACTERISTICS
;
DLTD01:	JSR	PC,DLGBYT	;GET DEVICE TYPE
	BCS	11$		;NONE SPECIFIED
	MOV	TCXLT(R5),R0	;POINT TO XLATE TCB
	MOV	R1,TCDVT(R0)	;STORE DEVICE TYPE
	JMP	DLTDOK		;SUCCESS.
;
11$:	RTS	PC		;ERROR RETURN.
;
;THE SUBROUTINE HAS BEEN NO OPTED. THIS IS NOW A LINE COMMAND FUNCTION
; SUBROUTINE TO DO DEVICE COMMAND 02: SET MAX LOGICAL RECORDS PER BLOCK
;
;DLTD02:	JSR	PC,DLGBYT	;GET LOW BYTE OF NUMBER
;	BCS	11$		;NOT SPECIFIED, ERROR
;	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
;;	MOVB	R1,TCMLR(R0)	;STORE LOW BYTE OF NUMBER
;	MOV	R3, -(SP)	;SAVE R3
;	MOV	TCLCB(R5), R3	;GET LCB POINTER
;	MOVB	R1,LB.MLR(R3)	;STORE LOW BYTE OF NUMBER
;	MOV	(SP)+,R3	;RESTORE R3
;	JSR	PC,DLGBYT	;GET HIGH BYTE
;	BCS	11$		;NOT SPECIFIED, ERROR.
;;	MOVB	R1,TCMLR+1(R0)	;STORE LOW BYTE
;	MOV	R3, -(SP)	;SAVE R3
;	MOV	TCLCB(R5),R3	;GET LCB POINTER
;	MOVB	R1,LB.MLR+1(R3)	;STORE HIGH BYTE OF NUMBER
;	MOV	(SP)+,R3	;RESTORE R3
;	JMP	DLTDOK		;INDICATE SUCCESS
;
;11$:	RTS	PC		;ERROR RETURN.
;
; SUBROUTINE TO DO DEVICE COMMAND 03: DUMP OUTPUT [1(627)]
;
DLTD03:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK [1(627)]
	BIS	#TCDMP,TCFG1(R0) ;SET "DUMP OUTPUT" [1(627)]
	JMP	DLTDOK		;INDICATE SUCCESS [1(627)]
;
; SUBROUTINE TO DO DEVICE COMMAND 04: CLEAR "INPUT PERMISSION WAS REQUESTED"
;
DLTD04:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK [2(770)]
	BIC	#TCIWR,TCFG2(R0) ;CLEAR "INPUT PERMISSION WAS REQUESTED" [2(770)]
	JMP	DLTDOK		;INDICATE SUCCESS [2(770)]
;
; NOTE THAT COMMAND 05 IS RESERVED.
;
; SUBROUTINE TO DO DEVICE COMMAND 06: SET "INTERPRET CC ON INPUT"
;
DLTD06:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIS	#TCPRI,TCFG1(R0) ;SET "CC ON INPUT"
	JMP	DLTDOK		;INDICATE SUCCESS
;
;
; SUBROUTINE TO DO DEVICE COMMAND 07: NO INTERPRET CC ON INPUT
;
DLTD07:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIC	#TCPRI,TCFG1(R0) ;CLEAR "CC ON INPUT"
	JMP	DLTDOK		;INDICATE SUCCESS
;
; SUBROUTINE TO DO DEVICE COMMAND 08: INTERPRET CC ON OUTPUT
;
DLTD08:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIS	#TCPRO,TCFG1(R0) ;SET "CC ON OUTPUT"
	JMP	DLTDOK		;INDICATE SUCCESS
;
; SUBROUTINE TO DO DEVICE COMMAND 09: NO CC ON OUTPUT
;
DLTD09:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIC	#TCPRO,TCFG1(R0) ;CLEAR "CC ON OUTPUT"
	JMP	DLTDOK		;INDICATE SUCCESS
;
; SUBROUTINE TO DO DEVICE COMMAND 12: DO COMPONENT SELECTION
; THIS IS USED BY HASP-MULTILEAVING ONLY
;
DLTD12:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIS	#TCCMP,TCFG1(R0) ;INDICATE "COMPONENT SELECTION"
	JSR	PC,DLGBYT	;GET COMPONENT CODE
	BCS	11$		;NONE SPECIFIED
	MOVB	R1,TCCTP(R0)	;STORE COMPONENT CODE
	JMP	DLTDOK		;INDICATE SUCCESS.
;
11$:	RTS	PC		;ERROR RETURN.
;
; SUBROUTINE TO DO DEVICE COMMAND 13: NO COMPONENT SELECTION
;
DLTD13:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIC	#TCCMP,TCFG1(R0) ;INDICATE NO COMPONENT SELECTION
	JMP	DLTDOK		;INDICATE SUCCESS
;
;
; SUBROUTINE TO DO DEVICE COMMAND 14: SET PRINTER PAGE COUNTER
;  (NOT YET COMPLETELY IMPLEMENTED IN XLATE)
;
DLTD14:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIS	#TCPCE,TCFG1(R0) ;TURN ON PAGE COUNTER
	BIC	#TCPCO,TCFG1(R0) ; AND TURN OFF INTERRUPT FLAG
	JSR	PC,DLGBYT	;GET LOW BYTE OF PAGE COUNTER
	BCS	11$		;NOT SUPPLIED
	MOVB	R1,TCPGC(R0)	;STORE LOW BYTE OF PAGE COUNTER
	JSR	PC,DLGBYT	;GET HIGH BYTE OF PAGE COUNTER
	BCS	11$		;NOT SUPPLIED
	MOVB	R1,TCPGC+1(R0)	;STORE HIGH BYTE OF PAGE COUNTER
	JMP	DLTDOK		;INDICATE SUCCESS
;
11$:	RTS	PC		;ERROR RETURN.
;
; SUBROUTINE TO DO DEVICE COMMAND 15: NO PRINTER PAGE COUNTING
;
DLTD15:	MOV	TCXLT(R5),R0	;GET POINTER TO XLATE TASK
	BIC	#TCPCE!TCPCO,TCFG1(R0) ;CLEAR PAGE COUNTER BITS
	JMP	DLTDOK		;INDICATE SUCCESS
;
; SUBROUTINE TO DO DEVICE COMMAND 16: SET BLOCK SIZE
;
;THIS SUBROUTINE HAS BEEN NO OPTED 
;DLTD16:	JSR	PC,DLGBYT	;GET LOW BYTE OF SIZE
;	BCS	11$		;NONE SPECIFIED
;	MOV	TCXLT(R5),R0	;POINT TO XLATE TCB
;;	MOVB	R1,TCMBL(R0)	;STORE LOW BYTE OF MAX BLOCK LENGTH
;	MOV	R3, -(SP)	;SAVE R3
;	MOV	TCLCB(R5),R3	;GET LCB POINTER
;	MOVB	R1, LB.MBL(R3)	;STORE LOW BYTE OF MAX BLOCK LENGTH
;	MOV	(SP)+,R3	;RESTORE R3
;	JSR	PC,DLGBYT	;GET HIGH BYTE
;	BCS	11$		;NONE SPECIFIED
;;	MOVB	R1,TCMBL+1(R0)	;STORE HIGH BYTE
;	MOV	R3, -(SP)	;SAVE R3
;	MOV	TCLCB(R5),R3	;GET LCB POINTER
;	MOVB	R1,LB.MBL+1(R3)	;STORE HIGH BYTE OF MAX BLOCK LENGTH
;	MOV	(SP)+, R3	;RESTORE R3
;	JMP	DLTDOK		;INDICATE SUCCESS
;;
;11$:	RTS	PC		;ERROR RETURN.
;;
; SUBROUTINE TO DO DEVICE COMMAND 17: DO SPACE COMPRESSION
;
DLTD17:	MOV	TCXLT(R5),R0	;POINT R0 TO XLATE TASK
	BIS	#TCCPS,TCFG1(R0) ;INDICATE DO COMPRESSION
	JMP	DLTDOK		;INDICATE SUCCESS
;
; SUBROUTINE TO DO DEVICE COMMAND 18: DON'T DO SPACE COMPRESSION
;
DLTD18:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIC	#TCCPS,TCFG1(R0) ;INDICATE DONT DO COMPRESSION
	JMP	DLTDOK		;INDICATE SUCCESS
;
;
; SUBROUTINE TO DO DEVICE COMMAND 19: USE OLD BSC PROTOCOL
;
DLTD19:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIS	#TCOBS,TCFG1(R0) ;INDICATE USE OLD BSC
;	MOV	TCLCB(R5),R0	;POINT TO LCB
	MOV	TCLCB(R0), R0	;;++BS-POINT TO LCB
	MOV	LB.TC1(R0),R0	;POINT TO BSC TASK
	BIS	#TCOBS,TCFG1(R0) ;TELL BSC TASK TO USE OLD BSC
	JMP	DLTDOK		;INDICATE SUCCESS
;
; SUBROUTINE TO DO DEVICE COMMAND 20: DONT USE OLD BSC
;
DLTD20:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIC	#TCOBS,TCFG1(R0) ;NO OLD BSC PROTOCOL
;	MOV	TCLCB(R5),R0	;POINT TO LCB
	MOV	TCLCB(R0), R0	;;++BS-POINT TO LCB
	MOV	LB.TC1(R0),R0	;POINT TO BSC TASK
	BIC	#TCOBS,TCFG1(R0) ;TELL BSC TASK NOT TO USE OLD BSC PROTOCOL
	JMP	DLTDOK		;INDICATE SUCCESS
;
; SUBROUTINE TO DO DEVICE COMMAND 21: REQUEST OUTPUT PERMISSION
;
DLTD21:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIT	#TCIPR,TCFG2(R0) ;INPUT PERMISSION REQUESTED?
	BNE	11$		;YES, THIS IS A NO-OP.
	BIS	#TCOPR,TCFG2(R0) ;NO, FLAG OUTPUT PERMISSION REQUESTED
;	MOV	TCLCB(R5),R0	;POINT TO LCB
	MOV	TCLCB(R0), R0	;;++BS-POINT TO LCB
	CMP	#TTHASP,LB.DVT(R0) ;HASP LINE?
	bne	11$		;no
	MOV	LB.TC1(R0),R0	;POINT TO BSC TASK
	BIS	#TCOPR,TCFG2(R0) ;TELL BSC TASK THERE IS OUTPUT TO DO
11$:	JMP	DLTWOK		;WAKE XLATE AND GIVE OK RETURN.
;
; SUBROUTINE TO DO DEVICE COMMAND 22: GRANT INPUT PERMISSION
;
DLTD22:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIT	#TCIPR,TCFG2(R0) ;HAS INPUT PERMISSION BEEN REQUESTED?
	BEQ	11$		;NO, THIS IS A NO-OP.
	BIS	#TCIPG,TCFG2(R0) ;YES, FLAG INPUT PERMISSION GRANTED
11$:	JMP	DLTWOK		;WAKE XLATE AND GIVE OK RETURN.
;
; SUBROUTINE TO DO DEVICE COMMAND 23: SIGNAL OUTPUT EOF
;
DLTD23:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIS	#TCOEF,TCFG2(R0) ;FLAG END-OF-FILE ON OUTPUT
	JMP	DLTWOK		;WAKE XLATE AND GIVE OK RETURN.
;
; SUBROUTINE TO DO DEVICE COMMAND 24: CLEAR OUTPUT EOF COMPLETE
;
DLTD24:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIC	#TCOEF!TCOEC,TCFG2(R0) ;CLEAR OUTPUT EOF FLAGS
	JMP	DLTWOK		;WAKE XLATE AND GIVE OK RETURN.
;
;
; SUBROUTINE TO DO DEVICE COMMAND 25: SIGNAL OUTPUT ABORT
;
;DLTD25:	MOV	TCLCB(R5),R0	;POINT TO LCB
;	MOV	LB.TC1(R0),R0	;POINT TO BSC TASK
DLTD25:	MOV	TCXLT(R5), R0	;;++BS-POINT TO XLATE TASK
	MOV	TCLCB(R0), R0	;;++BS-POINT TO LCB
	CMP	#TTHASP,LB.DVT(R0) ;HASP LINE?
	BEQ	11$		;YES, INDICATE ABORT TO DEVICE
	MOV	LB.TC1(R0), R0	;;++BS-POINT TO BSC TASK
	BIS	#TCOAB,TCFG2(R0) ;SIGNAL ABORT TO BSC TASK
11$:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIS	#TCOAB,TCFG2(R0) ;SIGNAL ABORT TO XLATE TASK
	JMP	DLTWOK		;AWAKEN XLATE AND GIVE OK RETURN.
;
; SUBROUTINE TO DO DEVICE COMMAND 26: CLEAR OUTPUT ABORT COMPLETE
;
DLTD26:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIC	#TCOAB!TCOAC,TCFG2(R0) ;CLEAR ABORT BITS
	JSR	PC, HCLAOA	;;++BS-CLEAR ACTIVE BIT 3(006)
	JMP	DLTWOK		;AWAKEN XLATE AND GIVE OK RETURN.
;
; SUBROUTINE TO DO DEVICE COMMAND 27: CLEAR INPUT EOF COMPLETE
;
DLTD27:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIC	#TCIEC,TCFG2(R0) ;CLEAR INPUT EOF COMPLETE
	JMP	DLTWOK		;WAKE XLATE AND GIVE OK RETURN.
;
; SUBROUTINE TO DO DEVICE COMMAND 28: SIGNAL INPUT ABORT
;
;DLTD28:	MOV	TCLCB(R5),R0	;POINT TO LCB
;	MOV	LB.TC1(R0),R0	;POINT TO BSC TASK
DLTD28:	MOV	TCXLT(R5), R0	;;++BS-POINT TO XLATE TASK
	MOV	TCLCB(R0), R0	;;++BS-POINT TO LCB
	CMP	#TTHASP,LB.DVT(R0) ;HASP LINE?
	BEQ	11$		;YES, INDICATE ABORT TO DEVICE
	MOV	LB.TC1(R0), R0	;;++BS-POINT TO BSC TASK
	BIS	#TCIAB,TCFG2(R0) ;SIGNAL ABORT
11$:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIS	#TCIAB,TCFG2(R0) ;SIGNAL ABORT
	JSR	PC,DLDRAI	;DRAIN INPUT QUEUE
	JMP	DLTWOK		;WAKE XLATE AND GIVE OK RETURN.
;
; SUBROUTINE TO DO DEVICE COMMAND 29: CLEAR INPUT ABORT COMPLETE
;
DLTD29:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIC	#TCIAB!TCIAC,TCFG2(R0) ;CLEAR ABORT BITS
	JSR	PC, HCLAIA	;;++BS-CLEAR THE ACTIVE BIT 3(006)
	JSR	PC,DLDRAI	;BE SURE THE QUEUE IS DRAINED
	JMP	DLTWOK		;WAKE XLATE AND GIVE OK RETURN.
;




;
; SUBROUTINE TO DO DEVICE COMMAND 30: SUSPEND DEVICE
; HAS MEANING FOR HASP ONLY
;
DLTD30:	MOV	TCXLT(R5),R0	;GET XLATE TASK POINTER
	BIS	#TCDSP,TCFG2(R0) ;MARK DEVICE SUSPENDED
;	BIT	#TCIOM,TCFG1(R1) ;INPUT DEVICE?
	BIT	#TCIOM,TCFG1(R0) ;;++BS-INPUT DEVICE ?
	BEQ	11$		;NO, EXIT
	MOV	TCDEV(R0),R1	;GET DEV #
;	MOV	TCLCB(R5),R0	;POINT TO LCB
	MOV	TCLCB(R0), R0	;;++BS-POINT TO LCB
	MOV	LB.TC1(R0),R0	;POINT TO BSC TCB
	ASL	R1		;DEV # * 2
	MOV	SUSTBL(R1),R1	;GET SUSPEND BIT FOR DEVICE
	BIC	R1,TCTFCS(R0)	;R0 STILL POINTS TO BSC
				;THIS INDICATION GOES TO REMOTE
11$:
	BR	DLTWOK		;ALWAYS OK RETURN
;
; THIS SUBROUTINE TO DO DEVICE COMMAND 31: UNSUSPEND DEVICE
;
DLTD31:	MOV	TCXLT(R5),R0	;POINT TO  DEVICE'S XLATE TCB
	BIC	#TCDSP,TCFG2(R0) ;MARK DEVICE UNSUSPENDED
;	BIT	#TCIOM,TCFG1(R1) ;INPUT DEVICE?
	BIT	#TCIOM,TCFG1(R0) ;;++BS-INPUT DEVICE ?
	BEQ	11$		;NO, EXIT
	MOV	TCDEV(R0),R1	;GET DEV #
;	MOV	TCLCB(R5),R0	;POINT TO LCB
	MOV	TCLCB(R0), R0	;;++BS-POINT TO LCB
	MOV	LB.TC1(R0),R0	;POINT TO BSC TCB
	ASL	R1		;DEV # * 2
	MOV	SUSTBL(R1),R1	;GET SUSPEND BIT FOR DEVICE
	BIS	R1,TCTFCS(R0)	;R0 STILL POINTS TO BSC
				;THIS INDICATION GOES TO REMOTE
11$:
	BR	DLTWOK		;ALWAYS SUCCESS
;
; SUBROTINE TO DO DEVICE COMMAND 32: SET DEVICE RECORD SIZE
;
DLTD32:	JSR	PC,DLGBYT	;GET LOW BYTE OF SIZE


	BCS	11$		;NOT SPECIFIED, ERROR
	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	MOVB	R1,TCRSZ(R0)	;STORE LOW BYTE OF SIZE
	JSR	PC,DLGBYT	;GET HIGH BYTE
	BCS	11$		;NOT SPECIFIED, ERROR
	MOVB	R1,TCRSZ+1(R0)	;STORE HIGH BYTE
	JMP	DLTDOK		;INDICATE SUCCESS
;
11$:	RTS	PC		;ERROR RETURN
;






;
; SUBROUTINE TO DRAIN THE INPUT QUEUE ON AN ABORT.
;
DLDRAI:
;11$:	MOV	TCLCB(R5),R4	;POINT TO LCB
11$:	MOV	TCXLT(R5), R4	;;++BS-POINT TO XLATE TASK
	MOV	TCLCB(R4), R4	;;++BS-POINT TO LCB
	MOV	LB.LNU(R4),R1	;GET LINE NUMBER
	CMP	#TTHASP,LB.DVT(R4) ;HASP LINE?
	BNE	12$		;NO, USE LINE NO AS I.D.
	SWAB	R1		;PUT LINE # IN LEFT BYTE
	ADD	TCCTP(R0),R1	;MAKE I.D. FOR HASP DEVICE
12$:	JSR	PC,DEQMID	;GET MESSAGE FROM THIS LINE
	BCS	13$		;NO MORE, ALL DONE.
	MOV	TCIDLE,R1	;POINT TO "IDLE" TASK
	JSR	PC,QUEMSG	;SEND IT THE MESSAGE
	BR	11$		;GET THE REST
;
; HERE WHEN THERE ARE NO MORE MESSAGES FROM THIS LINE
;
13$:	RTS	PC		;RETURN.
;
; HERE TO WAKE THE XLATE TASK AND GIVE OK RETURN.
;
DLTWOK:	MOV	TCXLT(R5),R0	;POINT TO XLATE TASK
	BIT	#EBINTR,(R0)	;WAITING FOR US?
	BEQ	DLTDOK		;NO.
	BIC	#EBINTR!EBWAIT,(R0) ;MAYBE, WAKE IT.
;
; HERE TO SUCCESSFULLY RETURN FROM A DEVICE COMMAND SUBROUTINE
;
DLTDOK:				;SUCCESS RETURN
	CLC			;NO FATAL ERROR
	RTS	PC		;RETURN.
;
;
; SUBROUTINE TO SEND THE CURRENT CHUNK TO THE XLATE TASK AND
;  OBTAIN A NEW ONE.
;
;  R0 POINTS TO THE OLD CHUNK, OR CONTAINS 0 IF THERE IS
;   NO OLD CHUNK.
;  TCXLT(R5) POINTS TO THE TRANSLATION TASK TO BE SENT THE CHUNK.
;
; ON RETURN:
;
;  C SET: OUTPUT ABORTED OR SHORT OF CHUNKS.
;  C CLEAR:
;
;	 R0 POINTS TO NEW CHUNK
;	 R3 POINTS TO DATA PORTION OF NEW CHUNK
;	 R1 DESTROYED
;
DLNWCK:	MOV	R2,-(SP)	;PRESERVE R2
	TST	R0		;ANY OLD CHUNK?
	BEQ	11$		;NO.
	MOV	TCXLT(R5),R1	;YES, POINT TO XLATE TASK
	JSR	PC,QUECHK	;SEND IT THE OLD CHUNK
11$:	MOV	TCXLT(R5),R1	;POINT TO XLATE TASK
	BIT	#TCOAB,TCFG2(R1) ;HAS BSC STREAM ABORTED?
	BNE	12$		;YES.
	CMP	CHFREC,#CHLTEN	;NO, HAVE WE ENOUGH FREE CHUNKS?
	BLE	12$		;NO.
	MOV	TCLCB(R1),R0	;YES, POINT TO LCB (R4 MAY BE IN USE)
	CMP	#TTHASP,LB.DVT(R0) ;HASP LINE?
	BNE	13$		;NO
	CMP	TCMSC(R1),#MSGXML ;ALREADY ENOUGH MESSAGES TO XMIT
	BGT	12$		;YES, WAIT BEFORE DOING ANY MORE
	BR	14$		;JOIN MAIN PATH
13$:	CMP	LB.MSC(R0),#MSGXML ;ALREADY ENOUGH MSGS TO XMIT?
	BGT	12$		;YES, WAIT BEFORE DOING ANY MORE.
14$:	CMP	TCXFR(R5),#DLWLMT ;HAVE WE PROCESSED ENOUGH BYTES?
	BGE	12$		;YES, WAIT UNTIL TRANSLATED.
	MOV	CHLST,R0	;NO, GET LAST CHUNK ON FREE LIST.
	JSR	PC,GETCHK	;GET ANOTHER CHUNK FOR PDP-10 DATA
	BCS	12$		;SHORT ON CHUNKS
;
; HERE WHEN WE HAVE GOTTEN THE CHUNK.
;
	MOV	R0,R3		;BUILD POINTER TO DATA SPACE
	ADD	#CHDAT,R3
	MOV	(SP)+,R2	;RESTORE R2
	CLC			;SIGNAL SUCCESS
	RTS	PC		;RETURN.
;
; HERE IF THE STREAM HAS BEEN ABORTED OR WE ARE SHORT OF CHUNKS.
;
12$:	MOV	(SP)+,R2	;RESTORE R2
	SEC			;SIGNAL FAILURE
	RTS	PC		;RETURN.
;
;
;SUBROUTINE TO SET UP A REJECT TO THE PDP-10
;
;
;

DLRJRQ:	MOVB	#3, DT10DF+1(R5) ;;++BS-INDICATE COMMAND REJECTED
	CLC			;;++BS-NOT A FATAL ERROR
	RTS	PC		;;++BS-RETURN
;
;
;
;
;;++BS-3(014) THIS SUBROUTINE CHECKS IF A DEVICE NUMBER IS LEGITIMATE
;;++BS-3(014) FOR THE MODE OF THE LINE. THE DEVICE NUMBER MUST BE ZERO
;;++BS-3(014) FOR 3780/2780. THE DEVICE NUMBER MUST BE BETWEEN ONE AND
;;++BS-3(014) FIVE, INCLUSIVE, FOR HASP. THIS ROUTINE ALSO SAVES THE
;;++BS-3(014) ADDRESS OF THE LAST CALL THAT HAD THE A DEVICE NUMBER.
;
;
; ON ENTRY:
;
;	R1 = DEVICE NUMBER
;
;	R4 = POINTER TO THE LINE CONTROL BLOCK
;
;
; ON RETURN:
;
;	C-BIT CLEAR IMPLIES DEVICE NUMBER OK FOR MODE
;
;	C-BIT SET IMPLIES DEVICE NUMBER ILLEGITIMATE FOR MODE
;
;

DLMCHK:

	BIC	#177770, R1		;EXTRACT THE DEVICE NUMBER
	BEQ	1$			;IF ZERO, BETTER BE 3780/2780

	BIT	#LF.SIM, LB.FGS(R4)	;ARE WE DOING SIMULATION ?
	BNE	4$			;YES, UP TO DEVICE # 5 ALLOWED

	CMP	R1, #4			;NO, SUPPORT, ONLY DEVICE # 4 ALLOWED
	BGT	2$			;ERROR, > THAN 4 FOR HASP SIMULATION
	BR	5$			;NOW MAKE SURE LINE IS IN HASP MODE

4$:	CMP	R1, #5			;GREATER THAN 5 ?
	BGT	2$			;YES, ERROR, NUMBER TO BIG FOR HASP
5$:	CMP	#TTHASP, LB.DVT(R4)	;NO, HASP MODE ?
	BNE	2$			;NO, ERROR, ITS 3780/2780
	BR	3$			;YES, DEVICE NUMBER IS GOOD

1$:	CMP	#TTHASP, LB.DVT(R4)	;HASP MODE ?
	BNE	3$			;NO, 3780/2780, ZERO IS GOOD

2$:	MOV	(SP), DLIMPC		;SAVE THE ADDRESS OF THE CALLER
	SEC				;TELL CALLER HE HAD A BAD DEVICE NUMBER
	RTS	PC			;RETURN TO CALLER

3$:	CLC				;TELL CALLER HIS DEVICE NUMBER IS GOOD
	RTS	PC			;RETURN TO CALLER


DLIMPC:	.WORD	0			;PC OF LAST CALL WITH BAD DEVICE NUMBER


;;++BS-3(014) END OF DLMCHK
;
;
;
;