.TITLE	RT11 CD DR11-W HANDLER  V04.01
	.IDENT	/V04.01/
;
; VERSION: 1.0 
;
; AUTHOR: MARK PYATETSKY
;	  COMPUTING DEPARTMENT
;	  FERMI NATIONAL ACCELERATOR LABORATORY
;	  MARCH 1983
;  
;	THE FOLLOWING IS A BISON GROUP PRODUCTION...
;
;+
; FUNCTION:
;
;	DR11-W INTERPROCESSOR COMMUNICATIONS DRIVER
;
; INPUTS:
; OUTPUTS:
; NOTES:
;
;*USE RT CONDITIONAL FILE FOR:* TIM$IT = 1 ;SET TIME-OUT CONDITIONAL **5-APR-84**
;-
;
	.SBTTL	PREAMBLE SECTION
;
; MACRO CALLS:
;
	.MCALL	.DRDEF,.MFPS,.MTPS,.INTEN
	.DRDEF	CD,300,SPFUN$,0,172414,300
;
; LOCAL SYMBOLS:
;
;DEBUG=1 			;DEFINE IF DEBUG VERSION, ADDS "BPT"'S
;DEBG=1				;DEFINE IF DEBUG VERSION, DISABLES TIMEOUTS
TRACE=1				;DEFINE IF TRACE ENABLED
TRBSZE=20			;DEFINE THE SIZE OF THE TRACE BUFFERS (WORDS)
;
;     			;DEFINE REGISTER OFFSETS FROM CSR FOR DR11-W
CDWORD 	=	-4		;OFFSET FROM CSR FOR WORD COUNT REGISTER
CDBUFA 	=	-2		;OFFSET FROM CSR FOR BUFFER ADDRESS REGISTER
CDCSR 	=	 0		;CSR OFFSET ZERO
CDDATA 	=	 2		;OFFSET FROM CSR FOR DATA BUFFER REGISTER
;
;	FUNCTION BIT MASKS
;
GO	=	1		;GO BIT
FNCT1	=	2		;FUNCTION 1 BIT
FNCT2	=	4		;INTERRUPT PARTNER
FNCT3	=	10		;IF SET CAUSES ONE DMA CYCLE
IE	=	100		;INTERRUPT ENABLE
CYCLE	=	400		;CYCLE BIT
STATA	=	4000		;STATUS A BIT
STATB	=	2000		;STATUS B BIT
STATC	=	1000		;STATUS C BIT
ATTN	=	20000		;ATTENTION BIT
ERROR	=	100000		;ERROR BIT
;
; LINK FUNCTION CODES
;
; FUNCTION CODE MASK BITS:
;
NOTWC	=	100000		;IF CLEAR DATA WORD IS A WORD COUNT
PTC	=	40000		;IF SET, DATA BYTE IS A PACKET TYPE CODE
ACK	=	20000		;IF SET, DATA BYTE IS AN ACK OR NACK OF A
				;  PTC,SIGNAL, WC, OR LINK REQUEST.
EOM	=	10000		;IF SET, DATA BYTE IS AN EOM STATUS
REQLK	=	4000		;IF SET, SENDER IS REQUESTING THE LINK
START	=	2000		;IF SET, SENDERIS REQUESTING TO START OR
				;  RE-START THE PROTOCOL
SIGNAL	=	1000		;IF SET, DATA BYTE IS A SIGNAL
DELAY	=	400		;PLEASE DELAY BEFORE INITIATING LINK BID,
				; REQUESTING UNIT HAS WORK QUEUED.
;
; FUNCTION CODES:
;
ACKNCD	=  NOTWC!ACK!5		;LINK ACKNOWLEDGE CODE
RECLCD	=  NOTWC!REQLK		;REQUEST LINK CODE (GLOBAL)
PTCACD	=  NOTWC!ACK!1		;PTC ACKNOWLEDGE CODE
PTCNCD	=  NOTWC!ACK!2		;PTC NACK CODE
SIGACD	=  NOTWC!EOM!EM.SUC	;SIGNAL ACKNOWLEDGE CODE
WCNACD	=  NOTWC!ACK!4		;WORD COUNT NACK CODE (TRANSFER REJECTED)
STRTCD	=  NOTWC!START		;PROTOCOL START CODE
STAKCD	=  NOTWC!ACK!3		;PROTOCOL START ACKNOWLEDGE
EOMSCD	=  NOTWC!EOM		;END OF MESSAGE STATUS CODE MASK
	EM.SUC	=	32.	;SUCCESSFUL END OF MESSAGE SUBFUNCTION
	EM.ABO	=	9.	;I/O KILLED WHILE IN PROGRESS
	EM.FHE	=	8.	;FATAL HARDWARE ERROR SUBFUNCTION
PTCDCD	=  NOTWC!PTC		;PACKET TYPE CODE MASK
SIGNCD	=  NOTWC!SIGNAL		;SIGNAL MASK
;
; LINK OWNERSHIP CODES:
;
FREE	=	0		;NEITHER MASTER NOR SLAVE
MASTER	=	1		;UNIT IS LINK MASTER
SLAVE	=	2		;UNIT IS LINK SLAVE
BUSY	=	400		;UNIT IS BUSY - THE OTHER PARTY
;				;    REQUESTED DELAY
;
;	DRIVER STATE CODES 
;
SLDOWN	=	13		;LINK DOWN
SWPRST	=	12		;WAITING FOR PROTOCOL START
SIDLE	=	11		;IDLE
SWLACK	=	 1		;WAIT LINK-ACK
SWPTC	=	 2		;WAIT PTC
SWAPTC	=	 3		;WAIT PTC-ACK
SWCSIG	=	 4		;WAIT WC OR SIGNAL
SWEOMS	=	 5		;WAIT EOM (END-OF-MESSAGE) STATUS
SWREWC	=	 6		;WAIT RECEIVER WC
SXMIT	=	 7		;TRANSMITTING
SREC	=	10		;RECEIVING
SLIMIT	=	SLDOWN		;MAX NUMBER (OCTAL) OF THE CURRENTLY
;				;  DEFINED STATES
;
;
; TIME-OUT CONSTANTS:
;
TMTICK	=	2		;LENGTH OF A TIMER TICK (NO OF CLOCK TICKS)
TMDEL	=	20.		;DELAY TIMEOUT
TMXMT	=	4		;TIMEOUT FOR XMIT TRANSACTIONS
TMREC	=	5		;TIMEOUT FOR RECEIVE TRANSACTIONS
TMWC	=	30.		;'WAIT FOR WORD COUNT' TIMEOUT
TMSYNC	=	2		;TIMEOUT FOR SYNCHRONIZATION
;				;(WHEN ONE PROCESSOR IS SLOWER THAN OTHER)
NOTOUT	=	0		;NO TIMEOUT NECESSARY
;
;
; MAX NUMBER OF OPENED 'READ' SESSIONS:
;
S$NOPN	=	16		;MUST BE CORRELATED WITH THE SIZE OF
;				;  THE DATA STRUCTURE 'S$OPEN'
;
;
;		OFFSETS INTO THE READ/WRITE REQUEST'S CONTROL 
;		  AND STATUS AREA
;
B$PTC	=	0		;OFFSET TO PACKET TYPE CODE (PTC)
B$MSGN	=	2		;OFFSET TO MESSAGE BLOCK NUMBER
B$ERR	=	4		;OFFSET TO ERROR CODE RETURNED BY 
;				;  THE DRIVER
B$WC	=	6		;OFFSET TO WORD COUNT RETURNED BY
;				;  THE DRIVER
;
	.PAGE
;
;		ERROR REPORTING
;
;		   (1) IMMEDIATE ERROR RESPONCE IN BYTE 52
E52PTC	=	11		;INVALID PTC
E52CHN	=	2		;CHANNEL IS NOT OPEN
E52MNS	=	3		;MAXIMUM NUMBER OF OPEN SESSIONS EXCEEDED
E52SPF	=	4		;NO SESSION OPEN FOR THIS PTC
;				;   (ON FUNC.=376)
E52SES	=	5		;NO SESSION OPEN FOR THIS PTC
E52BLK	=	6		;INVALID BLOCK ADDRESS GIVEN
E52WCN	=	7		;WORD COUNT IS 0
E52ISF	=	10		;INVALID SPFUN CODE
E.LKUP	=	30		;LOOKUP ERROR ON OPEN CHANNEL
;				; (NOT USED BY THE HANDLER;
;				;  INCLUDED FOR CONSISTENCY ONLY)
;
;		   (2) FINAL ERROR RESPONCE IN B$ERR
EFNSUC	=	1		;SUCCESSFUL - MESSAGE RECEIVED
EFNDTR	=	-10		;DATA RECEIVED/XMITTED WAS TRUNCATED
EFNPTC	=	-20		;PTC REJECTED - RECEIVER HAS NO OPEN SESSION
;				;               FOR THIS PTC
EFNTIO	=	-30		;READ/WRITE REQUEST TIMEOUT (OPTIONAL)
EFNHER	=	-40		;HARDWARE ERRORS
EFNTMX	=	-50		;TIMEOUT DURING MESSAGE XFER
EFNWRR	=	-60		;WRITE REQUEST REJECTED - THE OTHER PARTY
;				;   HAS NO READ FOR THIS PTC
EFNABO	=	-70		;I/O KILLED (BY THE OTHER PARTY)
;				;   WHILE IN PROCESS
EFNABY	=	-100		;I/O KILLED (BY YOURSELF)
;				;   WHILE IN PROCESS
;
;
	.PAGE
;
; SPECIAL FUNCTION DEFINITIONS:
;
SFOPNR	=	377		;OPEN 'READ' SESSION
SFCLSR	=	376		;CLOSE 'READ' SESSION
SFDFRT	=	375		;SET NEW DEFAULT REQUEST TIMEOUT
SFSGNL	=	374		;SEND SIGNAL
SFSYNC	=	373		;RECEIVE SIGNAL IN SYNC MODE
;
;
; TIMER BLOCK OFFSETS DEFINITIONS:
;
C.HOT	=	 0		;HIGH-ORDER TIME WORD
C.LOT	=	 2		;LOW-ORDER TIME WORD
C.LINK	=	 4		;LINK TO NEXT QUEUE ELEMENT
C.JNUM	=	 6		;OWNER'S JOB NUMBER
C.SEQ	=	10		;SEQUENCE NUMBER OF TIME REQUEST
C.SYS	=	12		;MONITOR PUTS  -1  HERE
C.COMP	=	14		;ADDRESS OF COMPLETION ROUTINE
;
;
;
PR7	=	340		;DEFINE PRIORITY 7
;
RMON$	=	54		;ADDRESS OF THE POINTER TO THE
;				;  START OF THE MONITOR
;
	.PAGE
;
;  CONTROL PARAMETERS FOR LOCAL MACROS
;
;
;		CONTROL PARAMETERS FOR DR11W MACRO
;
MSEND	=	0
MRECV	=	1
MDMA	=	0
MSIGNL	=	1
;
;		CONTROL PARAMETERS FOR ENTIME MACRO
;
TMFORK	=	1
;
;		CONTROL PARAMETERS FOR ODDBIO AND EXTMA MACRO'S
;
;*********** 17-FEBR-1984 *****************
; TO DISABLE EITHER "ODD BIT I/O" OR "BULK MEMORY" FEATURES
; PUT A ";" IN FRONT OF THE APPROPRIATE CONTROL PARAMETER.
; WHEN YOU DISABLE "ODD BIT I/O", THE "BULK MEMORY" FEATURE
; GETS DISABLED REGARDLESS OF THE SETTING OF 'O$BULK'
;*********** END: 17-FEBR-1984 *****************
;
ODB$IO	=	1		;CONTROL PARAMETER FOR "ODD BIT I/O"
;*********** 17-FEBR-1984 *****************
O$BULK	=	1		;CONTROL PARAMETER FOR "BULK MEMORY"
;*********** END: 17-FEBR-1984 *****************
;
;
	.PAGE
;
; LOCAL MACROS:
;
	.MACRO	DR11W	SEND,DMA,WCOUNT,BUFADR,REG
;		-----
;		THIS MACRO SETS UP THE DR11-W REGISTERS FOR 
;		  SEND/RECEIVE OPERATION IN A DMA/SIGNAL MODE.
;
	.IF	EQ	SEND
;
	.IF	EQ	DMA
	MOV	R3,-(SP)		;;;SAVE R3
	CLR	R3
	ODDBIO	BUFADR,CDBUFA(REG),R3	;;;LOAD BUFFER ADDRESS REGISTER
	MOV	WCOUNT,-(SP)
	NEG	(SP)			;;;NEGATE IT
	MOV	(SP)+,CDWORD(REG)	;;;LOAD WORD COUNT REGISTER
	BIS	#FNCT3!IE,R3		;;;SET UP CSR	
	MOV	R3,CDCSR(REG)		;;;	
	BIS	#GO!CYCLE,R3		;;;OR IN GO AND CYCLE
	MOV	R3,CDCSR(REG)		;;;	
	MOV	(SP)+,R3		;;;RESTORE R3
	.IFF
	MOV	WCOUNT,CDDATA(REG)	;;;LOAD ODR WITH SIGNAL OR WC
	DISINT
	MOV	#FNCT2!FNCT1!IE,CDCSR(REG) ;;;INTERRUPT PARTNER
	MOV	#FNCT1!IE,CDCSR(REG)	;;;DROP INTERRUPT SIGNAL
	ENINT
	.ENDC
;
	.IFF
;
	.IF	EQ	DMA
	MOV	R3,-(SP)		;;;SAVE R3
	CLR	R3
	ODDBIO	BUFADR,CDBUFA(REG),R3	;;;LOAD BUFFER ADDRESS REGISTER
	MOV	WCOUNT,CDDATA(REG)	;;;LOAD ODR WITH WC
	MOV	WCOUNT,-(SP)
	NEG	(SP)			;;;NEGATE IT
	MOV	(SP)+,CDWORD(REG)	;;;LOAD WORD COUNT REGISTER
	DISINT
	BIS	#FNCT2!FNCT1!IE,R3 	;;;INTERRUPT PARTNER	
	MOV	R3,CDCSR(REG)		;;;	
	BIC	#FNCT2,R3		;;;DROP INTERRUPT	
	BIS	#FNCT3!GO,R3		;;;  AND SET FNCT3 OR GO	
	MOV	R3,CDCSR(REG)		;;;	
	ENINT
	MOV	(SP)+,R3		;;;RESTORE R3
	.IFF
	MOV	CDDATA(REG),WCOUNT	;;;GET SIGNAL FROM IDR
	.ENDC
;
	.ENDC
;
	.ENDM	DR11W			;;;END OF DR11W MACRO
	.PAGE
;
	.MACRO	ODDBIO	BUFADR,ADRREG,CSR
;		------
;		THIS MACRO LOADS THE BUFFER ADDRESS REGISTER
;		  AND PERFORMS AN ODD BIT I/O IF NECESSARY
;
;			BUFADR	IS A MEMORY BUFFER ADDRESS
;			ADRREG	IS A DMA ADDRESS REGISTER
;			CSR	IS A CONTROL AND STATUS REGISTER
;					OF THE DEVICE
;
;		THIS MACRO USES REGISTERS:  R2 (SAVED/RESTORED BY THE MACRO)
;
	.IF	DF	ODB$IO
;
	MOV	R2,-(SP)			;;;SAVE R2
	MOV	BUFADR,-(SP)			;;;LOAD 'BUFADR' FOR 'EXTMA'
;						;;;  SUBROUTINE
	JSR	PC,CDOBIO			;;;CALL 'EXTMA' ODD BIT I/O
;						;;;  SUBROUTINE
	MOV	(SP)+,ADRREG			;;;GET LOW 16 BITS OF ADDRESS
	MOV	CSR,R2				;;;GET CSR CONTENTS
	BIC	#60,R2				;;;CLEAR BITS 4 AND 5 (HI BITS)
	BIS	(SP)+,R2			;;;GET HIGH 17 AND 18 BITS
;						;;;  OF ADDRESS
	MOV	R2,CSR				;;;LOAD CSR
	MOV	(SP)+,R2			;;;RESTORE R2
;
	.IFF
;
	MOV	BUFADR,ADRREG			;;;LOAD BUFFER ADDRESS REGISTER
;
	.ENDC
	.ENDM	ODDBIO
;	
	.PAGE
;
	.MACRO	EXTMA
;		-----
	.IF	DF	ODB$IO
;
;&.LITERAL
;+
;	SUBROUTINE EXTMA
;	CALL:	JSR PC,EXTMA
;	INPUT:
;		MEMORY ADDRESS ON STACK IN
;		NON-18 BIT CASE OR ADDRESS OF MEMORY ADDRESS
;		WITH BIT 0 SET ON STACK IN 18 BIT CASE
;	OUTPUT:
;		(SP)=LOW 16 BITS OF ADDRESS
;		2(SP)=HI 2 BITS OF ADDRESS SHIFTED OVER
;			SO THAT THEY APPEAR IN BITS 4 AND 5 FOR
;			OR-ING WITH CSR WORD(AS REQUIRED BY MOST DMA DEVICES)
;	MODIFICATIONS
;	DATE		AUTHOR		MODIFICATION
;	24-MAR-77	D. RITCHIE	FIXED ASR AND STACK PLACE BUGS
;	03-NOV-82	M. PYATETSKY	SOME COSMETIC CHANGES
;					  TO MAKE IT A MACRO
;	14-FEB-83	M. PYATETSKY	BULK MEMORY ADDED
;-
;&.END LITERAL
;.PAGE

;EXTMA:
	MOV	(SP),-(SP)	;COPY PC DOWN
	MOV	R2,-(SP)	;SAVE REG
	MOV	SP,R2		;POINT TO ARGS
	ADD	#6,R2		;HERE
	MOV	R1,-(SP)	;SAVE MORE REGS
	MOV	(R2),R1		;GET INPUT MEM ADDRESS OR ADDR OF ADR
	BIC	#1,R1		;ZAP OUT FLAG BIT
	CMP	R1,(R2)		;WAS IT REALLY THERE?
	BNE	20$		;SKIP IF SO
	CLR	(R2)		;NO EXTENDED BITS
	MOV	R1,-(R2)	;JUST LOW 16 (PUT ON STACK)
	BR	30$		;MERGE FOR RETURN
20$:	MOV	(R1)+,(R2)	;LOAD EXTENDED BITS
	BIC	#^C<3>,(R2)	;PROTECT AGAINST OTHERS SET
	ASL	(R2)		;BELIEVE IT OR NOT THIS IS LESS SPACE
	ASL	(R2)		;THAN ASH BECAUSE THAT REQUIRES A
	ASL	(R2)		;REG SAVE AND RESTORE-GET THE
	ASL	(R2)		;EXTD BITS TO BITS 4 AND 5 PLACE FOR CSR
;*********** 17-FEBR-1984 *****************
	.IF	NDF	O$BULK
	MOV	(R1),-(R2)	;LOAD LOW 16
	.IFF
;*********** END: 17-FEBR-1984 *****************
; @@@	   BULK MEMORY WINDOW SETTING
	MOV	(R1)+,-(R2)	;LOAD LOW 16
	MOV	-4(R1),R2	;GET 1ST WORD OF THE B.M. MSGE BLOCK	
	BIC	#100000,R2	;CLEAR B.M. FLAG BIT
	CMP	-4(R1),R2	;WAS IT REALLY THERE?
	BEQ	25$		;SKIP IF NO B.M.
	SWAB	R2		;SWAP BYTES
	BIC	#^C<377>,R2	;GET 'M' (# OF B.M. PAGES)
	TST	R2		;IS M=0?
	BEQ	25$		;SKIP IF YES
	MOV	R3,-(SP)	;SAVE R3
	MOV	(R1),R3		;GET 'LBN' (LOGICAL BLOCK #)
	MOV	2(R1),R1	;GET 'SAT' ADDR
21$:
	MOV	R3,(R1)+	;SET
	INC	R3		;    B.M.
	SOB	R2,21$		;	  WINDOW
	MOV	(SP)+,R3	;RESTORE R3
25$:
; @@@	   END OF BULK MEMORY WINDOW SETTING
;*********** 17-FEBR-1984 *****************
	.ENDC	;O$BULK
;*********** END: 17-FEBR-1984 *****************
;
30$:	MOV	(SP)+,R1	;RESTORE R1
	MOV	(SP)+,R2	;AND R2
	RTS	PC		;RETURN
;
	.ENDC
	.ENDM	EXTMA
	.PAGE
;
	.MACRO	DISINT			;DISABLE INTERRUPTS
;		------
	.MFPS				   ;SAVE OLD PS ON STACK
	.MTPS	#PR7			   ;SET PRIORITY 7
	.ENDM	DISINT
;
;
	.MACRO	ENINT			;;;ENABLE INTERRUPTS
;		-----
	.MTPS				   ;;;SET PRIORITY FROM STACK
	.ENDM	ENINT
;
;
	.MACRO	ENTIME	TIMBLK,TIMTCK,TIMLNG,REG,TIMFRK,ALTEXT,?L1
;		------
;		THIS MACRO ENABLES TIME-OUT WHEN NECESSARY.
;
;			TIMBLK	IS A .TIMIO BLOCK
;			TIMTCK	IS A LENGTH OF A TIMER TICK
;			TIMLNG	IS A LENGTH OF A TIMEOUT
;				     (IN NUMBER OF TICKS)
;			TIMFRK	SPECIFIES IF A FORK (FOR .TIMIO) 
;				     IS NECESSARY
;			REG	IS A REGISTER CONTAINING THE UNIT NUMBER
;			?L1	IS A LABEL USED INSIDE THIS MACRO
;			ALTEXT	IS AN ALTERNATE EXIT
;
	.IF	EQ	TIMBLK - D$TIMB
	.IF	B	ALTEXT		;;;*$* BEGIN
	MOV	#TIMLNG,D$TMU-B.(REG)	;;;LOAD THE UNIT TIME COUNTER
	.IFF
	MOV	TIMLNG,D$TMU-B.(REG)	;;;LOAD THE UNIT TIME COUNTER
	.ENDC				;;;*$* END
	.ENDC
	TST	TIMBLK+C.COMP   	;;;IS TIMER RUNNING?
	BNE	L1			;;;IF NE  YES
	.IIF DF DEBG BR	L1		;;;NO TIMEOUT WHEN DEBUGGING
	MOV	PC,-(SP)		;;;NO TIMEOUT
	ADD	#CDTIME-.,(SP)		;;;           RUNNING
	MOV	(SP)+,TIMBLK+C.COMP	;;;    LOAD C.COMP
	.IF	B	TIMFRK		;;;  ENABLE IT
	.TIMIO	TIMBLK,0,TIMTCK		;;;    EITHER HERE,
	.IFF				;;;    OR
	.IF	B	ALTEXT		;;;*$* BEGIN
	JMP	CDFORK			;;;ENABLE ON THE FORK LEVEL
	.IFF				;;;
	BR	ALTEXT			;;;
	.ENDC				;;;*$* END
	.ENDC
;
L1:	MOV	R0,R0			;;;END OF ENTIME
	.ENDM	ENTIME
;
	.PAGE
;
	.MACRO	QUEXFR	FROM,TO,REG,?L1,?L2,?L3,?L4
;		------
;		THIS MACRO TRANSFERS A QUEUE ELEMENT (BUFFER)
;		  FROM THE BEGINNING OF ONE QUEUE TO THE END OF ANOTHER
;
;			FROM  -  QUEUE FROM WHICH THE BUFFER IS XFERED
;			TO    -  QUEUE TO   WHICH THE BUFFER IS XFERED
;			REG   -  REGISTER USED BY THIS MACRO
;
;		ON EXIT FROM THIS MACRO,
;		  REGISTER 'REG' CONTAINS A POINTER TO THE QUEUE ELEMENT MOVED
;		  (OR '0' IF QUEUE WAS EMPTY)
;
;
	MOV	FROM'CQE,REG		;;;GET 'FROM' QUEUE ELEMENT
	TST	REG			;;;IS 'FROM' QUEUE EMPTY?
	BEQ	L4			;;;IF EQ  YES
	TST	TO'CQE   		;;;IS 'TO' QUEUE EMPTY?
	BNE	L1			;;;IF NE  NO
	MOV	FROM'CQE,TO'CQE		;;;LOAD THE CQE POINTER OF 'TO' Q
	BR	L2			;;;
;
L1:	MOV	TO'LQE,REG		;;;LINK THE BUFFER
	MOV	FROM'CQE,Q$LINK(REG)	;;;      TO THE END OF 'TO' QUEUE
;
L2:	MOV	FROM'CQE,REG		;;;UPDATE THE LQE POINTER
	MOV	REG,TO'LQE		;;;     OF THE 'TO' QUEUE
	CMP	FROM'CQE,FROM'LQE	;;;WAS IT THE ONLY BUFFER IN 'FROM' Q
	BNE	L3			;;;IF NE  NO
	CLR	FROM'LQE		;;;DELINK THE BUFFER
;
L3:	MOV	Q$LINK(REG),FROM'CQE	;;;    FROM THE
	CLR	Q$LINK(REG)		;;;        'FROM' QUEUE
	.IF	DIF	CD	FROM	;;;IF 'FROM' Q IS INTERNAL
	DEC	FROM'CNT		;;;    DECREMENT ITS BUFFER COUNT
	.ENDC
	.IF	DIF	CD	TO	;;;IF 'TO' Q IS INTERNAL
	INC	TO'CNT			;;;    INCREMENT ITS BUFFER COUNT
	.ENDC
;
L4:	MOV	R0,R0			;;;END OF QUEXFR
	.ENDM	QUEXFR
;
	.PAGE
;*********** FIXING THE CD-TO-MONITOR EXIT DEADLOCK: 17-FEBR-1984 *****************
;
	.MACRO	QUEXST	FROM,TO,REG,?L1,?L3,?L4
;		------
;		THIS MACRO TRANSFERS A QUEUE ELEMENT (BUFFER)
;		  FROM THE BEGINNING OF ONE QUEUE TO THE BEGINNING OF ANOTHER
;		  (AS IN STACK OPERATIONS)
;
;			FROM  -  QUEUE FROM WHICH THE BUFFER IS XFERED
;			TO    -  QUEUE TO   WHICH THE BUFFER IS XFERED
;			REG   -  REGISTER USED BY THIS MACRO
;
;		ON EXIT FROM THIS MACRO,
;		  REGISTER 'REG' CONTAINS A POINTER TO THE QUEUE ELEMENT MOVED
;		  (OR '0' IF QUEUE WAS EMPTY)
;
;
	MOV	FROM'CQE,REG		;;;GET 'FROM' QUEUE ELEMENT
	TST	REG			;;;IS 'FROM' QUEUE EMPTY?
	BEQ	L4			;;;IF EQ  YES
	TST	TO'LQE   		;;;IS 'TO' QUEUE EMPTY?
	BNE	L1			;;;IF NE  NO
	MOV	FROM'CQE,TO'LQE		;;;LOAD THE LQE POINTER OF 'TO' Q
;
L1:
	CMP	FROM'CQE,FROM'LQE	;;;WAS IT THE ONLY BUFFER IN 'FROM' Q
	BNE	L3			;;;IF NE  NO
	CLR	FROM'LQE		;;;DELINK THE BUFFER
;
L3:	MOV	Q$LINK(REG),FROM'CQE	;;;    FROM THE 'FROM' QUEUE, AND
	MOV	TO'CQE,Q$LINK(REG)	;;;LINK THE BUFFER TO THE BEGINNING
	MOV	REG,TO'CQE		;;;     OF THE 'TO' QUEUE
	.IF	DIF	CD	FROM	;;;IF 'FROM' Q IS INTERNAL
	DEC	FROM'CNT		;;;    DECREMENT ITS BUFFER COUNT
	.ENDC
	.IF	DIF	CD	TO	;;;IF 'TO' Q IS INTERNAL
	INC	TO'CNT			;;;    INCREMENT ITS BUFFER COUNT
	.ENDC
;
L4:	MOV	R0,R0			;;;END OF QUEXST
	.ENDM	QUEXST
;
;***** END OF  FIXING THE CD-TO-MONITOR EXIT DEADLOCK: 17-FEBR-1984 *****************
;
	.PAGE
;
	.MACRO	CHKPTC	PTCQUE,PTCSCD,OUTLBL,?L1,?L2,?L3,?LL1
;		------
;		THIS MACRO VERIFIES (CHECKS) WHETHER A QUEUE ELEMENT
;		WITH A GIVEN 'PTC' IS PRESENT IN THE QUEUE (PTCQUE).
;		  IF PRESENT, THE QUEUE ELEMENT IS MADE THE FIRST
;		  IN THE QUEUE.
;
;			PTCQUE	-  QUEUE VERIFIED
;			PTCSCD	-  GIVEN PTC SEARCHED
;			OUTLBL	-  LABEL TO GO IF THE QUEUE ELEMENT
;				     IS NOT PRESENT
;
;		THIS MACRO USES REGISTERS:  R2,R3,R4
;
;		ON EXIT FROM THIS MACRO,
;		  REGISTER R4 CONTAINS A POINTER TO THE QUEUE ELEMENT MOVED
;		  (OR '0' IF QUEUE WAS EMPTY)
;
	MOV	PTCQUE'CQE,R4		;;;GET CURRENT QUEUE ELEMENT
	TST	R4			;;;IS QUEUE EMPTY?
	BNE	L1			;;;IF NE  NO
	JMP	OUTLBL			;;;EXIT
;
L1:	MOV	Q$BLKN(R4),R3		;;;GET PTC BLOCK POINTER
	CMP	B$PTC(R3),PTCSCD	;;;IS ITS PTC = PTC SEARCHED?
	BEQ	L2			;;;IF EQ YES
	TST	Q$LINK(R4)		;;;IS IT END OF QUEUE?
	BNE	LL1			;;;IF NE  NO
	JMP	OUTLBL			;;;EXIT
;
LL1:	MOV	R4,R2			;;;SAVE PREVIOUS Q.EL. PTR
	MOV	Q$LINK(R4),R4		;;;GET NEXT Q. ELEMENT
	BR	L1			;;;CONTINUE
;
L2:	CMP	PTCQUE'CQE,R4		;;;IS IT FIRST ELEMENT IN QUEUE?
	BEQ	L3			;;;IF EQ  YES
	MOV	Q$LINK(R4),Q$LINK(R2)	;;;OTHERWISE,
	MOV	PTCQUE'CQE,Q$LINK(R4)	;;;	      MAKE IT
	MOV	R4,PTCQUE'CQE		;;;		      FIRST
	CMP	PTCQUE'LQE,R4		;;;UPDATE
	BNE	L3			;;;	THE
	MOV	R2,PTCQUE'LQE		;;;	  LAST Q. ELEMENT PTR
;
L3:	MOV	R0,R0			;;;END OF CHKPTC
	.ENDM	CHKPTC
;
;
	.PAGE
;
	.MACRO	CHKFNC	FNCQUE,FNCSCD,OUTLBL,?L1,?L2,?L3,?LL1
;		------
;		THIS MACRO VERIFIES (CHECKS) WHETHER A QUEUE ELEMENT
;		WITH A GIVEN '.SPFUN' IS PRESENT IN THE QUEUE (FNCQUE).
;		  IF PRESENT, THE QUEUE ELEMENT IS MADE THE FIRST
;		  IN THE QUEUE.
;
;			FNCQUE	-  QUEUE VERIFIED
;			FNCSCD	-  GIVEN .SPFUN SEARCHED
;			OUTLBL	-  LABEL TO GO IF THE QUEUE ELEMENT
;				     IS NOT PRESENT
;
;		THIS MACRO USES REGISTERS:  R2,R3,R4
;
;		ON EXIT FROM THIS MACRO,
;		  REGISTER R4 CONTAINS A POINTER TO THE QUEUE ELEMENT MOVED
;		  (OR '0' IF QUEUE WAS EMPTY)
;
	MOV	FNCQUE'CQE,R4		;;;GET CURRENT QUEUE ELEMENT
	TST	R4			;;;IS QUEUE EMPTY?
	BNE	L1			;;;IF NE  NO
	JMP	OUTLBL			;;;EXIT
;
L1:	CMP	Q$FUNC(R4),FNCSCD	;;;IS Q.ELEMENT'S FNC = FNC SEARCHED?
	BEQ	L2			;;;IF EQ YES
	TST	Q$LINK(R4)		;;;IS IT END OF QUEUE?
	BNE	LL1			;;;IF NE  NO
	JMP	OUTLBL			;;;EXIT
;
LL1:	MOV	R4,R2			;;;SAVE PREVIOUS Q.EL. PTR
	MOV	Q$LINK(R4),R4		;;;GET NEXT Q. ELEMENT
	BR	L1			;;;CONTINUE
;
L2:	CMP	FNCQUE'CQE,R4		;;;IS IT FIRST ELEMENT IN QUEUE?
	BEQ	L3			;;;IF EQ  YES
	MOV	Q$LINK(R4),Q$LINK(R2)	;;;OTHERWISE,
	MOV	FNCQUE'CQE,Q$LINK(R4)	;;;	      MAKE IT
	MOV	R4,FNCQUE'CQE		;;;		      FIRST
	CMP	FNCQUE'LQE,R4		;;;UPDATE
	BNE	L3			;;;	THE
	MOV	R2,FNCQUE'LQE		;;;	  LAST Q. ELEMENT PTR
;
L3:	MOV	R0,R0			;;;END OF CHKFNC
	.ENDM	CHKFNC
;
;
	.PAGE
;
	.MACRO	JSRFIN	DD,REG
;		------
;		THIS MACRO IS A 'JSR' VERSION OF .DRFIN MACRO.
;
;			DD	-  NAME OF THE HANDLER
;			REG	-  REGISTER USED BY THIS MACRO
;
;
;		THIS MACRO USES REGISTERS:  'REG',R5
;
;		REGISTER 'REG' MUST CONTAIN A POINTER TO THE
;		  QUEUE ELEMENT RETURNED BEFORE THIS MACRO IS CALLED
;
	MOV	PC,REG
	ADD	#'DD'CQE-.,REG
	MOV	@#RMON$,R5
	JSR	PC,@270(R5)
	.ENDM	JSRFIN
;
;
;
;
	.MACRO	CHKATN	ELALBL,?L1
;		------
;		THIS MACRO CHECKS WHETHER AN 'ATTN' BIT IS SET ('BUSY')
;		  IF 'BUSY', IT SPECIFIES AN ERROR LOGGING ACTION
;		  NECESSARY.
;
;			ELALBL	-  LABEL TO ERROR LOGGING ACTION IF 'ATTN'
;				     IS SET 'BUSY'
;
;
;		THIS MACRO USES REGISTERS:  NONE (R1 IS REFERENCED ONLY)
;
	CMP	#BUSY,D$ATTN-B.(R1)	;;;IS IT SET 'BUSY'?
	BNE	L1			;;;IF NE  NO
	JMP	ELALBL			;;;GO TO 'ERROR LOGGING ACTION'
;
L1:	MOV	R0,R0			;;;END OF CHKATN
	.ENDM	CHKATN
;
;
	.PAGE
;
	.MACRO	ACTION	SEND,STATE,TIMOUT
;		------
;		THIS IS A 'CODE SIZE REDUCTION' MACRO.
;		  IT SETS UP PARAMETERS ON STACK AND
;		  CALLS EITHER 'C$ACT' OR 'C$DR11' SUBROUTINES.
;
;			SEND	-  SIGNAL TO BE SENT
;			STATE	-  NEW CD DRIVER'S STATE TO BE SET,
;				     IF BLANK, 'C$DR11' IS CALLED
;			TIMOUT	-  TIMEOUT VALUE TO BE SET,
;				     IF ZERO - NO TIMEOUT WILL BE SET. 
;
;
;		THIS MACRO USES REGISTERS:  NONE.
;
	MOV	SEND,-(SP)		;;*$* GET SIGNAL
	.IF	B	STATE		;;*$*
	JSR	PC,C$DR11		;;*$* CALL DR11-W SUBROUTINE
	.IFF				;;*$*
	MOV	TIMOUT,-(SP)		;;*$* GET TIMEOUT VALUE
	MOV	STATE,-(SP)		;;*$* GET NEW STATE
	JSR	PC,C$ACT		;;*$* CALL ACTION SUBROUTINE
	.ENDC
	.ENDM	ACTION
;
;
	.PAGE
	.SBTTL	SET OPTION PARAMETER TABLE AND PROCESSING ROUTINES
;
	.DRSET	CSR0,160000,O.CSR0,OCT	;MIN VALUE FOR CSR
	.DRSET	VECTR0,477,O.VEC0,OCT	;MAX VALUE FOR VECTOR
;
;
;
O.CSR0:
	MOV	R0,176			;SET NEW CSR VALUE IN BLOCK 0 OF CD
	MOV	R0,O$CSR		;SET NEW CSR0
	CMP	R0,R3			;ERROR IF  < 160000
	RTS	PC			;RETURN
;
O.VEC0:
	MOV	R0,CDSTRT		;SET NEW VECTR0
	CMP	R3,R0			;ERROR IF  > 477
	RTS	PC			;RETURN
;
	.PAGE
	.SBTTL	HEADER SECTION
	.DRBEG	CD
;
;
	.SBTTL	I/O INITIATION SECTION
;	   
;	START OF CODE
;	----- -- ----
;
;
; INPUTS:
;
;
; OUTPUTS:
;
	ASR	#1			;SKIP
	BCC	CDCRQ			;    IF NOT FIRST TIME
CDB.:
	MOV	PC,-(SP)		;ESTABLISH
B.:
	MOV	(SP)+,BASE.		;          BASE RELOCATION ADDR
;
	MOV	O$CSR,D$CSR		;SET THE CSR ADDR OF UNIT #0
;
CDCRQ:
	.IIF DF DBUG BPT
	MOV	CDCQE,R4		;R4 POINTS TO CURRENT Q ENTRY
	TST	Q$FUNC(R4)		;IS IT SPFUN REQUEST?
	BEQ	5$			;IF EQ  NO
	CMP	#SFSGNL,Q$FUNC(R4)	;IS IT 'SEND SIGNAL' REQUEST?
	BNE	CDCLK			;IF NE  NO
5$:
;
; VERIFY CORRECTNESS OF THE APPLICATION PROGRAM'S READ/WRITE REQUEST
;
;   1.	BLK = EVEN ADDRESS
;
	MOV	Q$BLKN(R4),R1		;GET BLOCK NUMBER
	BIC	#1,R1			;CHECK IF
	CMP	R1,Q$BLKN(R4)		;  EVEN BLOCK NUMBER
	BEQ	10$			;IF EQ YES
	JMP	ERRBLK			;IF NE NO
;
;   2.	PTC WITHIN THE RANGE (0-255)
10$:
	TST	B$PTC(R1)		;IS PTC > 0 ?
	BGT	20$
	JMP	ERRPTC
20$:
	CMP	#255.,B$PTC(R1)		;YES, NOW IS PTC < 256 ?
	BGE	CDCLK
	JMP	ERRPTC
;
O$CSR:	.WORD	CD$CSR			;SET CSR, UNIT #0
;
	.PAGE
;
; THE REQUEST IS DEEMED TO BE CORRECT
;
CDCLK:					;CHECK DR11-W LINK
	MOVB	Q$UNIT(R4),R1		;GET
	SWAB	R1			;    UNIT
	BIC	#^C<7>,R1		;         NUMBER
	ASL	R1			;GET BYTE OFFSET
	ADD	BASE.,R1		;ADD BASE RELOC. ADDR
	MOV	D$CSR-B.(R1),R5		;GET CSR ADDRESS
;	DISINT				;*$* DISABLE INTERRUPTS
	JSR	PC,C$DSIN		;*$* 
	CMP	#SLDOWN,D$STAT-B.(R1)	;;;IS STATE LINK-DOWN ?
	BNE	10$			;;;IF NE NO
;*$$*	MOV	CDCSR(R5),R3		;;;GET CSR CONTENTS
;*$$*	BIC	#^C<ATTN!ERROR>,R3 	;;;CLEAR ALL BUT ATTN
;*$$*;					     ;;;AND ERROR BITS
;*$$*	BIS	#IE,R3			;;;ENABLE DR11-W INTERRUPTS
;*$$*	MOV	R3,CDCSR(R5)		;;;SET BACK THE CSR
	JSR	PC,C$RSET		;;;*$$*  RESET DR11-W AND
;					;;;*$$*   ENABLE INTERRUPTS
10$:
;	ENINT				;;;*$* ENABLE INTERRUPTS
	JSR	PC,C$ENIN		;*$* 
	MOV	R0,R0			;GIVE IT A CHANCE TO INTERRUPT
;	DISINT				;*$* DISABLE INTERRUPTS
	JSR	PC,C$DSIN		;*$* 
	CMP	#SLDOWN,D$STAT-B.(R1)	;;;IS STATE LINK-DOWN ?
	BNE	100$			;;;IF NE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I1.2
;	DR11W	MSEND,MSIGNL,#STRTCD,,R5;;;*$* SEND 'START'
	.LIST	MEB			;;;*$*
	ACTION	#STRTCD			;;;*$* 
	.NLIST	MEB			;;;*$*
;	STATE
	MOV	#SWPRST,D$STAT-B.(R1)	;;;NEW STATE = WAITING PROT. START
;	ENTIME	D$TIMB,TMTICK,TMXMT,R1	;;;*$* SET TIMEOUT
.IIF NE TIM$IT	JSR	PC,C$ETIO		;*$* **5-APR-84**
100$:
;	ENINT				;;;*$* ENABLE INTERRUPTS
	JSR	PC,C$ENIN		;*$* 
;
; DECODE THE REQUEST
;
	TST	Q$FUNC(R4)		;IS IT SPFUN REQUEST?
	BEQ	200$			;IF EQ  NO
	JMP	CDSPFN			;
200$:
	TST	Q$WCNT(R4)		;IS IT READ REQUEST?
	BLT	CDWRTE			;IF LT (I.E.NEGATIVE) NO
	BGT	CDREAD			;IF GT (I.E.POSITIVE) YES
	JMP	ERRREQ			;WORD COUNT MUST NOT BE 0
;					;  FOR READ OR WRITE REQUESTS
	.PAGE
CDREAD:
;
;  CHECK IF A SESSION OPENED FOR THIS PTC
;
	MOV	#S$NOPN,R3		;MAX # OF OPENED SESSIONS
	MOV	PC,R2			;GET
	ADD	#S$OPEN-.,R2		;    OPEN PTC TABLE ADDR
	MOV	R1,-(SP)		;SAVE UNIT NUMBER
	MOV	Q$BLKN(R4),R1		;GET BLOCK NUMBER
100$:
	CMP	(R2)+,B$PTC(R1)		;IS SESSION OPENED FOR THIS PTC?
	BEQ	200$			;IF EQ YES
	SOB	R3,100$			;CONTINUE
	MOV	(SP)+,R1		;RESTORE UNIT NUMBER
	JMP	ERRSES			;NO SESSION OPENED
200$:
;*********** SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
	MOV	B$PTC(R1),R2		;SAVE THIS PTC FOR 'SYNC-T/OUT' BELOW
;***** END OF SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
	MOV	(SP)+,R1		;RESTORE UNIT NUMBER
CDRD1:
;	DISINT				;*$* DISABLE INTERRUPTS
	JSR	PC,C$DSIN		;*$* 
	QUEXFR	CD,IQR,R4		;;;XFER A BUFFER FROM CD TO READ Q
;*********** SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
	TST	R2			;;;IS IT SIGNAL-RELATED ?
	BEQ	20$			;;;IF EQ  YES -- SKIP THE REST
	MOV	D$RPTC-B.(R1),R3	;;;IS 'READ-IN-PROGRESS'
	NEG	R3			;;;  SYNC-DELAYED BY
	CMP	R2,R3			;;;    THIS PTC ?
	BNE	20$			;;;IF NE  NO -- SKIP THE REST
	MOV	R3,D$RPTC-B.(R1)	;;;RESET CURRENT PTC
;	     SEE ALSO AROUND LABEL 'CDTM04:' FOR THE NEXT 7 LINES
	JSR	PC,C$CRWC		;;;*$* CHECK FOR 'READ' POSTED
;					;;;*$*   AND 'RECEIVER WORD COUNT'
;					;;;*$* AND SET UP 'DMA RECEIVE' & STATE
	BPT		; **-**		;;;*$* NO 'READ' POSTED -- IMPOSSIBLE HERE 
	MOV	#TMREC,D$TMU-B.(R1)	;;;SET TIMEOUT
;	JMP	CDTEND	; **-**		;;;RETURN
20$:
;***** END OF SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
;	ENINT				;;;*$* ENABLE INTERRUPTS
	JSR	PC,C$ENIN		;*$* 
	JMP	CDRWEX			;RETURN
;
;
CDWRTE:
;	DISINT				;*$* DISABLE INTERRUPTS
	JSR	PC,C$DSIN		;*$* 
	QUEXFR	CD,IQW,R4		;;;XFER A BUFFER FROM CD TO WRITE Q
	CMP	#SIDLE,D$STAT-B.(R1)	;;;IS STATUS IDLE?
	BNE	100$			;;;IF NE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I3.3
;	DR11W	MSEND,MSIGNL,#RECLCD,,R5;;;*$* SEND 'REQUEST LINK'
	MOV	D$CODR-B.(R1),R2	;;;*$$*  RESTORE 'EOM STATUS'
	BIS	#RECLCD,R2		;;;*$$*  SET 'REQUEST LINK'
	ACTION	R2			;;;*$*  *$$*
	CLR	D$CODR-B.(R1)		;;;*$$* CLEAR LAST 'EOM STATUS'
;	STATE
	MOV	#SWLACK,D$STAT-B.(R1)	;;;NEW STATE = WAIT LINK-ACK
;	ENTIME	D$TIMB,TMTICK,TMXMT,R1	;;;*$* SET TIMEOUT
.IIF NE TIM$IT	JSR	PC,C$ETIO		;*$* **5-APR-84**
;
100$:
;	ENINT				;;;*$* ENABLE INTERRUPTS
	JSR	PC,C$ENIN		;*$* 
	JMP	CDRWEX			;RETURN
;
CDSPFN:
	CMP	#SFOPNR,Q$FUNC(R4)	;IS IT 'OPEN READ SESSION'?
	BEQ	10$			;IF EQ  YES
	CMP	#SFCLSR,Q$FUNC(R4)	;IS IT 'CLOSE READ SESSION'?
	BEQ	20$			;IF EQ  YES
	CMP	#SFDFRT,Q$FUNC(R4)	;IS IT 'DEFAULT REQ. T/OUT'?
	BEQ	6$			;IF EQ  YES
	CMP	#SFSGNL,Q$FUNC(R4)	;IS IT 'SEND SIGNAL'?
	BEQ	CDWRTE			;IF EQ  YES
	CMP	#SFSYNC,Q$FUNC(R4)	;IS IT 'SIGNAL - SYNC MODE'?
	BEQ	5$			;IF EQ  YES
	JMP	ERRISF			;INVALID SPFUN
5$:
;*********** SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
	CLR	R2			;CLEAR 'R2' FOR 'SYNC-T/OUT' ABOVE
;***** END OF SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
	JMP	CDRD1
6$:
	JMP	30$
	.PAGE
;
;  OPEN READ SESSION
10$:
	TST	Q$BLKN(R4)		;IS
	BGT	100$			;   PTC
	JMP	ERRPTC			;       WITHIN
100$:
	CMP	#255.,Q$BLKN(R4)	;	       ITS
	BGE	110$			;		  RANGE?
	JMP	ERRPTC			;	(1 - 255)
110$:					;YES, IT IS
	MOV	#S$NOPN,R3		;GET MAX # OF OPENED SESSIONS
	MOV	PC,R2			;GET POINTER
	ADD	#S$OPEN-.,R2		;	TO S$OPEN
120$:
	CMP	Q$BLKN(R4),(R2)		;HAS SESSION BEEN OPENED FOR THIS PTC?
	BEQ	140$			;IF EQ  YES
	TST	(R2)+   		;IS THERE A FREE SLOT IN IT ?
	BEQ	130$			;IF EQ YES
	SOB	R3,120$			;CONTINUE
	JMP	ERRMNS			;NUMBER OF OPEN SESSIONS EXCEEDED MAX
130$:
	MOV	Q$BLKN(R4),-(R2)	;OPEN THIS SESSION
	NEG	R3			;ASSIGN
	ADD	#S$NOPN,R3		;	SIG-
	ASL	R3			;	    NAL
	ADD	BASE.,R3		;*$* *$$*
	MOV	Q$BUFF(R4),S$SGNL-B.(R3);		AREA
	CLR	@S$SGNL-B.(R3)  	;CLEAR IT
140$:
	JMP	CDSFEX			;RETURN
	.PAGE
;
;  CLOSE READ SESSION
20$:
	MOV	#S$NOPN,R3		;GET MAX # OF OPENED SESSIONS
	MOV	PC,R2			;GET POINTER
	ADD	#S$OPEN-.,R2		;	TO S$OPEN
220$:
	CMP	Q$BLKN(R4),(R2)+	;IS  SESSION OPENED FOR IT?
	BEQ	230$			;IF EQ YES
	SOB	R3,220$			;CONTINUE
	JMP	ERRSPF			;NO SESSION OPENED FOR THIS PTC
230$:
	CLR	-(R2)   		;CLOSE THIS SESSION
	NEG	R3			;RECLAIM
	ADD	#S$NOPN,R3		;	SIG-
	ASL	R3			;	    NAL
	ADD	BASE.,R3		;*$* *$$*
	CLR	S$SGNL-B.(R3)   	;		AREA
;
240$:					;RECLAIM Q.ELEMENTS
	CLR	R1			;UNIT NUMBER 0
	ADD	BASE.,R1		;ADD BASE RELOC. ADDR
;					; (DO IT FOR ALL UNITS)
;	DISINT				;*$* DISABLE INTERRUPTS
	JSR	PC,C$DSIN		;*$* 
;*********** SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
;	CMP	D$RPTC-B.(R1),(R2)	;CHECK CURRENT PTC
	MOV	D$RPTC-B.(R1),R3	;CHECK CURRENT PTC
	CMP	R3,(R2)			;TRY 'NO SYNC-DELAYED'
	BEQ	245$			;IF EQ - READ IN PROGRESS
	NEG	R3			;TRY
	CMP	R3,(R2)			;    'SYNC-DELAYED' NOW
	BNE	250$			;IF NE - NO READ IN PROGRESS
245$:
;***** END OF SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
	CLR	D$RPTC-B.(R1)		;CLEAR PTC RECEIVED
250$:
;	   REPEAT '240$' TO HERE FOR EACH DR11-W UNIT
	MOV	(R2),R5			;SAVE PTC
251$:
;	CHKPTC	IQR,R5,260$		;*$* IS PTC FOUND 
	MOV	R5,-(SP)		;*$*  *$$*
	JSR	PC,C$CHKP		;*$*	    AMONG 'READ' REQUESTS?
	BR	260$			;*$* ALTERNATE EXIT
	JSR	PC,CDREXT		;CALL 'R"EXIT'
	MOV	#EFNABY,R2		;REPORT 'KILL' ERROR
	JSR	PC,CDERR		;  TO APPL. PROGRAM
	BR	251$			;CONTINUE
260$:
;	ENINT				;*$* ENABLE INTERRUPTS
	JSR	PC,C$ENIN		;*$* 
	BR	CDSFEX			;RETURN
;
;  SET NEW DEFAULT REQUEST T/OUT
30$:
	BR	CDSFEX			;RETURN
;
;  KILL SPFUN
;
;40$:
;;	DISINT				;*$* DISABLE INTERRUPTS
;	JSR	PC,C$DSIN		;*$* 
;410$:
;	JSR	PC,CDREXT		;CALL 'R"EXIT'
;	TST	R4			;IS R.QUEUE EMPTY?
;	BEQ	420$			;IF EQ  YES
;	MOV	#EFNABY,R2		;REPORT 'KILL' ERROR
;	JSR	PC,CDERR		;  TO APPL. PROGRAM
;	BR	410$			;CONTINUE FLASHING 'READ'S
;420$:
;	JSR	PC,CDWEXT		;CALL 'W"EXIT'
;	TST	R4			;IS W.QUEUE EMPTY?
;	BEQ	430$			;IF EQ  YES
;	MOV	#EFNABY,R2		;REPORT 'KILL' ERROR
;	JSR	PC,CDERR		;  TO APPL. PROGRAM
;	BR	420$			;CONTINUE FLASHING 'WRITE'S
;430$:
;	CLR	R1			;UNIT NUMBER 0
;	ADD	BASE.,R1		;ADD BASE RELOC. ADDR
;;					; (DO IT FOR ALL UNITS)
;	MOV	D$CSR-B.(R1),R5		;GET CSR ADDRESS
;	CLR	CDCSR(R5)		;;;RESET CSR 
;	    RESET DR11-W
;;	ENINT				;*$* ENABLE INTERRUPTS
;	JSR	PC,C$ENIN		;*$* 
;	BR	CDSFEX			;RETURN
;;
;;;	  CLEAR S$OPEN AND S$SGNL
;;;
;;;
;;;
CDEREX:
CDSFEX:
;	DISINT				;*$* DISABLE INTERRUPTS
	JSR	PC,C$DSIN		;*$* 
	QUEXFR	CD,IQE,R4		;;;XFER A BUFFER FROM CD TO EXIT Q
;	ENINT				;;;*$* ENABLE INTERRUPTS
	JSR	PC,C$ENIN		;*$* 
CDRWEX:
	JMP	CDDONE			;RETURN
;
;  INVALID SPFUN
ERRISF:
	MOVB	#E52ISF,@#52		;SET ERROR CODE IN BYTE 52
	BR	ERRSET			;
;
;
ERRBLK:
	MOVB	#E52BLK,@#52		;SET ERROR CODE IN BYTE 52
	BR	ERRSET			;
;
ERRMNS:
	MOVB	#E52MNS,@#52		;SET ERROR CODE IN BYTE 52
	BR	ERRSET			;
;
ERRSPF:
	MOVB	#E52SPF,@#52		;SET ERROR CODE IN BYTE 52
	BR	ERRSET			;
;
ERRSES:
	MOVB	#E52SES,@#52		;SET ERROR CODE IN BYTE 52
	BR	ERRSET			;
;
ERRPTC:
	MOVB	#E52PTC,@#52		;SET ERROR CODE IN BYTE 52
	BR	ERRSET			;
;
ERRREQ:
	MOVB	#E52WCN,@#52		;SET ERROR CODE IN BYTE 52
	BR	ERRSET			;
;
ERRSET:
	BIS	#HDERR$,@Q$CSW(R4)	;SET HARD ERROR BIT IN CSW
	JMP	CDEREX			;RETURN
;
;
;
	.PAGE
	.SBTTL	INTERRUPT SERVICE SECTION
;
	.DRAST	CD,5,CDDEC	        ;;;LOWER PRIORITY TO LEVEL 5 
;
;
	BR	CDCONT			;;;THIS CODE IS NECESSARY,
CDDEC:	JMP	CDDONE			;;;BECAUSE DEC USES 'BR'INSTEAD OF
CDCONT:					;;;'JMP' INSTRUCTION IN ITS
;					;;;'.DRAST' MACRO EXTENTION.
;
;
	.IIF DF DBUG BPT
;
	MOV	R1,-(SP)		;;;SAVE
	MOV	R2,-(SP)		;;;     REG-
	MOV	R3,-(SP)		;;;         ISTERS
;
; FOR MULTIPLE DR11-W:
; DETERMINE HERE WHICH DR11-W INTERRUPTED AND MOVE ITS UNIT NUMBER
;  INTO R1.
; IN THIS VERSION IT IS ASSUMED THAT THE UNIT NUMBER IS 0.
;
	CLR	R1			;;;UNIT NUMBER 0
	ADD	BASE.,R1		;;;ADD BASE RELOC. ADDR
	MOV	D$CSR-B.(R1),R5		;;;GET CSR ADDRESS
;
;  READ IDR AND ERROR REGISTER.
;
	MOV	CDDATA(R5),D$CIDR-B.(R1);;;SAVE IDR
	MOV	CDCSR(R5),R3		;;;GET CSR CONTENTS
	MOV	R3,D$CCSR-B.(R1)	;;;SAVE CSR
	BIC	#^C<FNCT3!FNCT2!FNCT1!IE>,R3 ;;;CLEAR ALL BUT FUNCTION
;					     ;;;AND IE BITS
	MOV	R3,R2			;;;SET
	BIS	#ERROR,R2		;;;    TO READ
	MOV	R2,CDCSR(R5)		;;;            ERROR REGISTER
	MOV	(R5),D$CEIR-B.(R1)	;;;READ ERROR REGISTER
	MOV	R3,CDCSR(R5)		;;;SET BACK TO READ THE CSR
;
	.IF	DF	TRACE
	MOV	T$$CUR,R2		;;;GET TRACE PTR
	INC	R2			;;;
	CMP	#TRBSZE,R2		;;;IS IT AT THE END?
	BNE	1$			;;;IF NE  NO
	CLR	R2			;;;RESET IT
1$:
	MOV	R2,T$$CUR		;;;SAVE IT
	ASL	R2			;;;GET BYTE OFFSET
	ADD	BASE.,R2		;;;ADD BASE RELOC. ADDR
	MOV	D$CCSR-B.(R1),T$$CSR-B.(R2);;;SAVE CSR TRACE
	MOV	D$CEIR-B.(R1),T$$EIR-B.(R2);;;SAVE EIR TRACE
	MOV	D$CIDR-B.(R1),T$$IDR-B.(R2);;;SAVE IDR TRACE
	MOV	CDBUFA(R5),T$$BUF-B.(R2);;;SAVE BUF TRACE
	MOV	CDWORD(R5),T$$WCT-B.(R2);;;SAVE WCT TRACE
	MOV	D$RPTC-B.(R1),T$$PTC-B.(R2);;;SAVE RPTC TRACE
	MOV	D$STAT-B.(R1),T$$STA-B.(R2);;;SAVE STATUS TRACE
	MOV	D$ATTN-B.(R1),T$$ATN-B.(R2);;;SAVE ATTN TRACE
	.ENDC
;
	BIT	#ERROR,CDCSR(R5)	;;;CHECK THAT ERROR CONDITION
	BEQ	100$			;;;  CLEARED
;
;  DO IT AGAIN
;
	MOV	#10.,R2			;;;REPEAT IT 10. TIMES
50$:
	MOV	R3,CDCSR(R5)		;;;CLEAR 'ATTN' BIT IN THE CSR
	BIT	#ERROR,CDCSR(R5)	;;;CHECK THAT ERROR CONDITION
	BEQ	100$			;;;  CLEARED
	SOB	R2,50$			;;;CONTINUE
;
;  ERROR CONDITION DID NOT CLEAR SEVERAL TIMES IN A ROW.
;  REPORT HARDWARE ERROR
;
	MOV	#BUSY,D$ATTN-B.(R1)	;;;SET 'ATTN' BIT BUSY
	JMP	CDDSP  			;;;      
;
;
100$:
	MOV	#FREE,D$ATTN-B.(R1)	;;;SET 'ATTN' BIT FREE
;
;  CHECK THE CURRENT STATE FOR VALIDITY.
;  IF VALID, DISPATCH.
;
CDCST:
	TST	D$STAT-B.(R1) 		;;;IS STATE > 0?
	BGT	20$
	BR	30$
20$:
	CMP	#SLIMIT,D$STAT-B.(R1)	;;;YES, IS STATE < SLIMIT+1?
	BGE	CDDSP			;;;IF GE YES, STATE OK.
;
;  INVALID STATE.
;  GO TO LINK-DOWN STATE AND RE-SYNCHRONIZE.
;
30$:
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;GO TO
	JMP	CDDSP  			;;;      LINK-DOWN STATE
;
DSPTBL:
	.WORD	0			;;;STATE =  0   INVALID STATE
	.WORD	CDIN01-B.		;;;STATE =  1   SWLACK
	.WORD	CDIN02-B.		;;;STATE =  2   SWPTC
	.WORD	CDIN03-B.		;;;STATE =  3   SWAPTC
	.WORD	CDIN04-B.		;;;STATE =  4   SWCSIG
	.WORD	CDIN05-B.		;;;STATE =  5   SWEOMS
	.WORD	CDIN06-B.		;;;STATE =  6   SWREWC
	.WORD	CDIN07-B.		;;;STATE =  7   SXMIT
	.WORD	CDIN10-B.		;;;STATE = 10   SREC
	.WORD	CDIN11-B.		;;;STATE = 11   SIDLE
	.WORD	CDIN12-B.		;;;STATE = 12   SWPRST
	.WORD	CDIN13-B.		;;;STATE = 13   SLDOWN
;
; NOW DO THE DISPATCH
;
CDDSP:
	MOV	D$STAT-B.(R1),R2	;;;GET OFFSET TO DISPATCH TABLE
	ASL	R2			;;;GET BYTE OFFSET
	ADD	BASE.,R2		;;;ADD BASE RELOCATION ADDR
	MOV	DSPTBL-B.(R2),R3	;;;GET THE DISPATCH ADDRESS
	ADD	BASE.,R3		;;;ADD BASE RELOCATION ADDR
	JMP	@R3			;;;DISPATCH TO INDIVIDUAL STATE
;
;
	.PAGE
;		I1	STATE = SLDOWN	(LINK DOWN)
;		--	--------------
;
CDIN13:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	JSR	PC,C$RSET		;;;*$$*  RESET DR11-W AND
;					;;;*$$*   ENABLE INTERRUPTS
	BIC	#BUSY,D$LNKO-B.(R1)	;;;CLEAR "LINK BUSY"
	CLR	D$RPTC-B.(R1)		;;;CLEAR CURRENT PTC
	TST	D$ATTN-B.(R1)		;;;*$$*  IS 'ATTN' CLEARED?
	BNE	5$			;;;*$$*  IF NE  NO
	MOV	D$CIDR-B.(R1),R2	;;;GET
	BIC	#^C<STRTCD>,R2		;;;    EVENT
	CMP	#STRTCD,R2		;;;IS EVENT = START?
	BNE	10$			;;;IF NE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I1.1
;			;;;THIS ACTION IS IDENTICAL TO I3.1
;			;;;  WHICH IS ACTUALLY EXECUTED INSTEAD OF I1.1
;	DR11W	MSEND,MSIGNL,#STAKCD,,R5;;;SEND 'START-ACK'
;	STATE
	MOV	#SIDLE,D$STAT-B.(R1)	;;;NEW STATE = IDLE
;	MOV	#SLAVE,D$LNKO-B.(R1)	;;;MAKE IT SLAVE
;					;;;NO TIMEOUT
	JMP	CDDSP			;;;GO TO 'PROCESS IDLE STATE'
5$:
	CLR	D$ATTN-B.(R1)		;;;*$$* SET 'ATTN' FREE
10$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I1.2
	.LIST	MEB			;;;*$*
	ACTION	#STRTCD,#SWPRST,#TMXMT	;;;*$* 
	.NLIST	MEB			;;;*$*
;	DR11W	MSEND,MSIGNL,#STRTCD,,R5;;;*$* SEND 'START'
;	STATE
;	MOV	#SWPRST,D$STAT-B.(R1)	;;;*$* NEW STATE = WAITING PROT. START
;	ENTIME	D$TIMB,,TMXMT,R1,TMFORK	;;;*$* SET TIMEOUT
	JMP	CDRTRN			;;;RETURN
;
	.PAGE
;		I2	STATE = SWPRST	(WAITING FOR PROTOCOL START)
;		--	--------------
;
CDIN12:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	CHKATN	10$			;;;CHECK 'ATTN' BIT
	CMP	#STAKCD,D$CIDR-B.(R1)	;;;IS EVENT = START-ACK?
	BNE	10$			;;;IF NE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I2.1
;	STATE
	MOV	#SIDLE,D$STAT-B.(R1)	;;;NEW STATE = IDLE
	MOV	#MASTER,D$LNKO-B.(R1)	;;;MAKE IT MASTER
;					;;;NO TIMEOUT
	JMP	CDDSP			;;;GO TO 'PROCESS IDLE STATE'
10$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I2.2
;	STATE
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE = LINK DOWN
	MOV	#FREE,D$LNKO-B.(R1)	;;;MAKE IT FREE
;					;;;NO TIMEOUT
	MOV	D$CIDR-B.(R1),R2	;;;*$$* GET EVENT
	BIC	#377,R2			;;;*$$* IS IT
	CMP	#STRTCD,R2		;;;*$$*	      'START'?
	BEQ	15$			;;;*$$* IF EQ  YES
	BIS	#1,D$ATTN-B.(R1)	;;;*$$* NO, THEN SET 'ATTN' BIT
15$:					;;;*$$*
	JMP	CDDSP			;;;GO TO 'PROCESS LINK-DOWN STATE'
;
	.PAGE
;		I3	STATE = SIDLE	(IDLE)
;		--	--------------
;
CDIN11:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	CHKATN	40$			;;;CHECK 'ATTN' BIT
	MOV	D$CIDR-B.(R1),R2	;;;GET
	BIC	#^C<STRTCD>,R2		;;;    EVENT
	CMP	#STRTCD,R2		;;;IS EVENT = START?
	BNE	10$			;;;IF NE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I3.1
;	DR11W	MSEND,MSIGNL,#STAKCD,,R5;;;*$* SEND 'START-ACK'
;	STATE
;	MOV	#SIDLE,D$STAT-B.(R1)	;;;*$* NEW STATE = IDLE
	MOV	#SLAVE,D$LNKO-B.(R1)	;;;MAKE IT SLAVE
;	ENTIME	D$TIMB,,TMREC,R1,TMFORK	;;;*$* SET TIMEOUT
	ACTION	#STAKCD,#SIDLE,#TMREC	;;;*$* 
	JMP	CDRTRN			;;;RETURN
10$:
	MOV	D$CIDR-B.(R1),R2	;;;GET
	BIC	#^C<RECLCD>,R2		;;;    EVENT
	CMP	#RECLCD,R2		;;;IS EVENT = REQUEST LINK?
	BNE	20$			;;;IF NE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I3.2
	ACTION	#ACKNCD,#SWPTC,#TMREC	;;;*$* 
;	DR11W	MSEND,MSIGNL,#ACKNCD,,R5;;;*$* SEND 'LINK-ACK'
;	STATE
;	MOV	#SWPTC,D$STAT-B.(R1)	;;;*$* NEW STATE = WAIT PTC
;	ENTIME	D$TIMB,,TMREC,R1,TMFORK	;;;*$* SET TIMEOUT
	JMP	CDRTRN			;;;RETURN
20$:
	BIT	#BUSY,D$LNKO-B.(R1)	;;;IS LINK BUSY?
	BNE	30$			;;;IF NE  YES
	TST	IQWCNT			;;;IS EVENT = WRITE-CNT>0?
	BLE	30$			;;;IF LE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I3.3
	ACTION	#RECLCD,#SWLACK,#TMXMT	;;;*$* 
;	DR11W	MSEND,MSIGNL,#RECLCD,,R5;;;*$* SEND 'REQUEST LINK'
;	STATE
;	MOV	#SWLACK,D$STAT-B.(R1)	;;;*$* NEW STATE = WAIT LINK-ACK
;	ENTIME	D$TIMB,,TMXMT,R1,TMFORK	;;;*$* SET TIMEOUT
	JMP	CDRTRN			;RETURN
30$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I3.4
;					;;;NO TIMEOUT
	JMP	CDRTRN			;RETURN
;
40$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I4.2
;	STATE
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE =LINK DOWN
;					;;;NO TIMEOUT
	JMP	CDDSP			;;;GO TO 'PROCESS LINK-DOWN STATE'
;
	.PAGE
;		I4	STATE = SWLACK	(WAIT LINK-ACK)
;		--	--------------
;
CDIN01:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	CHKATN	30$			;;;CHECK 'ATTN' BIT
	CMP	#ACKNCD,D$CIDR-B.(R1)	;;;IS EVENT = LINK-ACK?
	BNE	10$			;;;IF NE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I4.1
	MOV	IQWCQE,R4		;;;GET WRITE Q PTR
	MOV	Q$BLKN(R4),R3		;;;GET
	MOV	B$PTC(R3),R2		;;;    PTC
	BIS	#PTCDCD,R2		;;;        TO SEND
	ACTION	R2,#SWAPTC,#TMXMT	;;;*$* 
;	DR11W	MSEND,MSIGNL,R2,,R5	;;;*$* SEND 'PTC'
;	STATE
;	MOV	#SWAPTC,D$STAT-B.(R1)	;;;*$* NEW STATE = WAIT PTC-ACK
;	ENTIME	D$TIMB,,TMXMT,R1,TMFORK	;;;*$* SET TIMEOUT
	JMP	CDRTRN			;;;RETURN
10$:
;    CHECK FOR COLLISION
	CMP	#RECLCD,D$CIDR-B.(R1)	;;;IS EVENT = REQUEST LINK?
	BNE	30$			;;;IF NE NO
	CMP	#MASTER,D$LNKO-B.(R1)	;;;IS IT MASTER?
	BNE	20$			;;;IF NE NO
;	ENTIME	D$TIMB,,TMXMT,R1,TMFORK	;;;*$* SET TIMEOUT
	MOV	#TMXMT,-(SP)		;;;*$* 
	JSR	PC,C$ENTM		;;;*$* 
	BR	2$			;;;*$* 
	JMP	CDRTRN			;;;RETURN
2$:
	JMP	CDFORK			;;;*$*
20$:
	CMP	#SLAVE,D$LNKO-B.(R1)	;;;IS IT SLAVE?
	BNE	30$			;;;IF NE NO
;	STATE
	MOV	#SIDLE,D$STAT-B.(R1)	;;;NEW STATE = IDLE
;					;;;NO TIMEOUT
	JMP	CDDSP			;;;GO TO 'PROCESS IDLE STATE'
;    END COLLISION CHECK
30$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I4.2
;	STATE
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE =LINK DOWN
;					;;;NO TIMEOUT
	JMP	CDDSP			;;;GO TO 'PROCESS LINK-DOWN STATE'
;
	.PAGE
;		I5	STATE = SWPTC	(WAIT PTC)
;		--	--------------
;
CDIN02:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	CHKATN	20$			;;;CHECK 'ATTN' BIT
	JSR	PC,C$SOPN		;;;*$* CHECK, IF EVENT IS PTC (RECEIVED)
;					;;;*$*  AND IF SESSION IS OPENED
	BR	20$			;;;*$* IF EVENT NOT PTC (RECEIVED)
	BR	10$			;;;*$* IF NO SESSION OPENED
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I5.1 
	ACTION	#PTCACD,#SWCSIG,#TMREC	;;;*$* 
;	DR11W	MSEND,MSIGNL,#PTCACD,,R5;;;*$* SEND 'PTC-ACK'
;	STATE
;	MOV	#SWCSIG,D$STAT-B.(R1)	;;;*$* NEW STATE = WAIT WC OR SIGNAL
;	ENTIME	D$TIMB,,TMREC,R1,TMFORK	;;;*$* SET TIMEOUT
	JMP	CDRTRN			;;;RETURN
10$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I5.2 DELAYED
;	ENTIME	D$TIMB,,TMSYNC,R1,TMFORK ;;;*$*  SET TIMEOUT
	MOV	#TMSYNC,-(SP)		;;;*$* 
	JSR	PC,C$ENTM		;;;*$* 
	BR	2$			;;;*$* 
	JMP	CDRTRN			;;;RETURN
2$:
	JMP	CDFORK			;;;*$*
20$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I5.3
;	STATE
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE = LINK-DOWN
;					;;;NO TIMEOUT
	JMP	CDDSP			;;;GO TO 'PROCESS LINK-DOWN STATE'
;
	.PAGE
;		I6	STATE = SWAPTC	(WAIT PTC-ACK)
;		--	--------------
;
CDIN03:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	CHKATN	30$			;;;CHECK 'ATTN' BIT
	CMP	#PTCACD,D$CIDR-B.(R1)	;;;IS EVENT = PTC-ACK?
	BNE	20$			;;;IF NE NO
5$:
	MOV	IQWCQE,R4		;;;IS APPL. PROGRAM'S
	CMP	#SFSGNL,Q$FUNC(R4)	;;;REQUEST = SEND SIGNAL?
	BNE	10$			;;;IF NE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I6.1
	MOV	Q$WCNT(R4),R2		;;;GET
	BIC	#^C<377>,R2		;;;    SIG-
	BIS	#SIGNCD,R2		;;;        NAL
	ACTION	R2,#SWEOMS,#TMXMT	;;;*$* 
;	DR11W	MSEND,MSIGNL,R2,,R5	;;;*$* SEND 'SIGNAL'
;	STATE
;	MOV	#SWEOMS,D$STAT-B.(R1)	;;;*$* NEW STATE = WAIT EOM STATUS
;	ENTIME	D$TIMB,,TMXMT,R1,TMFORK	;;;*$* SET TIMEOUT
	JMP	CDRTRN			;RETURN
10$:
;					;;;REQUEST IS SEND DMA
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I6.2
	MOV	IQWCQE,R4		;;;GET
	MOV	Q$WCNT(R4),R2		;;;    WORD
	NEG	R2			;;;         COUNT
	ACTION	R2,#SWREWC,#TMWC	;;;*$* 
;	DR11W	MSEND,MSIGNL,R2,,R5	;;;*$* SEND 'WC (WORD COUNT)'
;	STATE
;	MOV	#SWREWC,D$STAT-B.(R1)	;;;*$* NEW STATE = WAIT RECEIVER WC
;	ENTIME	D$TIMB,,TMWC,R1,TMFORK	;;;*$* SET TIMEOUT
	JMP	CDRTRN			;RETURN
20$:
	CMP	#PTCNCD,D$CIDR-B.(R1)	;;;IS EVENT = PTC-NACK?
	BNE	30$			;;;IF NE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I6.3
;	STATE
	MOV	#SIDLE,D$STAT-B.(R1)	;;;NEW STATE = IDLE
;					;;;NO TIMEOUT
	JSR	PC,CDWEXT		;;;CALL 'W"EXIT'
	MOV	#EFNPTC,R2		;;;REPORT 'NO PTC' ERROR
	JSR	PC,CDERR		;;;  TO APPL.PROGRAM
	JMP	CDEXIT
30$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I6.4
;	STATE
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE = LINK-DOWN
;					;;;NO TIMEOUT
	JSR	PC,CDWEXT		;;;CALL 'W"EXIT'
	MOV	#EFNHER,R2		;;;REPORT HDWR ERROR
	JSR	PC,CDERR		;;;  TO APPL.PROGRAM
	JMP	CDDSP			;;;GO TO 'PROCESS LINK-DOWN STATE'
;
	.PAGE
;		I7	STATE = SWCSIG	(WAIT WC OR SIGNAL)
;		--	--------------
;
CDIN04:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	CHKATN	30$			;;;CHECK 'ATTN' BIT
	MOV	D$CIDR-B.(R1),R2	;;;GET
	BIC	#^C<SIGNCD>,R2		;;;   SIGNAL QUALIFIER
	BIT	#NOTWC,R2		;;;IS EVENT = WC(RECEIVED)
	BEQ	10$			;;;IF EQ YES
	CMP	#SIGNCD,R2		;;;IS EVENT = SIGNAL(RECEIVED)?
	BEQ	5$			;;;IF EQ  YES
	JMP	30$			;;;INVALID EVENT
5$:
	TST	D$RPTC-B.(R1)		;;;IS 'READ' SESSION STILL OPEN?
	BNE	6$			;;;IF NE  YES
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I7.5
	ACTION	#EOMSCD!EM.ABO,#SIDLE,#NOTOUT	;;;*$* 
;	DR11W	MSEND,MSIGNL,#EOMSCD!EM.ABO,,R5;;;*$* SEND 'EOM-STATUS' ABORTED
;	STATE
;	MOV	#SIDLE,D$STAT-B.(R1)	;;;*$* NEW STATE = IDLE
;					;;;NO TIMEOUT
	JMP	CDEXIT
6$:
	MOV	D$SIND-B.(R1),R2	;;;GET CURRENT SIGNAL AREA INDEX
	ASL	R2			;;;GET BYTE OFFSET
	ADD	BASE.,R2		;;; *$* *$$*
	MOV	S$SGNL-B.(R2),R3	;;;GET ADDR OF SIGNAL AREA
	MOV	D$CIDR-B.(R1),R2	;;;GET SIGNAL
	MOVB	R2,(R3)+		;;;LOAD SIGNAL VALUE INTO THE
;					;;;  SIGNAL AREA
	INCB	(R3)			;;;INCREMENT SIGNAL COUNTER 
	CLR	D$RPTC-B.(R1)		;;;CLEAR CURRENT PTC
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I7.2
	ACTION	#EOMSCD!EM.SUC,#SIDLE,#NOTOUT	;;;*$* 
;	DR11W	MSEND,MSIGNL,#EOMSCD!EM.SUC,,R5;;;*$* SEND 'EOM-STATUS' SUCCESS
;	STATE
;	MOV	#SIDLE,D$STAT-B.(R1)	;;;*$* NEW STATE = IDLE
;					;;;NO TIMEOUT
	CHKFNC	IQR,#SFSYNC,9$		;;;IS IT SYNC MODE?
	JSR	PC,CDREXT		;;;CALL 'R"EXIT'
	MOV	#EFNSUC,R2		;;;REPORT SUCCESS (ERR)
	JSR	PC,CDERR		;;;  TO APPL. PROGRAM
9$:
	JMP	CDEXIT
;
10$:
	JSR	PC,C$CRWC		;;;*$* CHECK FOR 'READ' POSTED
;					;;;*$*   AND 'RECEIVER WORD COUNT'
;					;;;*$* AND SET UP 'DMA RECEIVE' & STATE
	BR	20$			;;;*$* IF NO 'READ' POSTED
.IIF NE TIM$IT	ENTIME	D$TIMB,,TMREC,R1,TMFORK	;;;SET TIMEOUT **5-APR-84**
	JMP	CDRTRN			;RETURN
20$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I7.3 DELAYED
;*********** SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
	NEG	D$RPTC-B.(R1)		;;;MARK THE CURRENT PTC
;***** END OF SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
;	ENTIME	D$TIMB,,TMSYNC,R1,TMFORK ;;;*$*  SET TIMEOUT
	MOV	#TMSYNC,-(SP)		;;;*$* 
	JSR	PC,C$ENTM		;;;*$* 
	BR	2$			;;;*$* 
	JMP	CDRTRN			;;;RETURN
2$:
	JMP	CDFORK			;;;*$*
30$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I7.4
;	CHKPTC	IQR,<D$RPTC-B.(R1)>,40$	;;;*$* IS PTC RECV'D VIA DR11-W
;					;;;  FOUND AMONG 'READ' REQUESTS?
	MOV	D$RPTC-B.(R1),-(SP)	;*$* *$$*
	JSR	PC,C$CHKP		;*$* 
	BR	40$			;*$* ALTERNATE EXIT
	JSR	PC,CDREXT		;;;CALL 'R"EXIT'
	MOV	#EFNHER,R2		;;;REPORT HRDW ERROR
	JSR	PC,CDERR		;;;  TO APPL. PROGRAM
40$:
;	STATE
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE = LINK-DOWN
;					;;;NO TIMEOUT
	JMP	CDDSP			;;;GO TO 'PROCESS LINK-DOWN STATE'
;
	.PAGE
;		I8	STATE = SWEOMS	(WAIT EOM STATUS)
;		--	--------------
;
CDIN05:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	CHKATN	10$			;;;CHECK 'ATTN' BIT
	MOV	D$CIDR-B.(R1),R2	;;;GET
	BIC	#^C<EOMSCD>,R2		;;;   EOM STATUS QUALIFIER
	CMP	#EOMSCD,R2		;;;HAS 'EOM STATUS' BEEN REPORTED?
	BNE	10$			;;;IF NE NO
	MOV	D$CIDR-B.(R1),R2	;;;GET
	BIC	#EOMSCD!DELAY!RECLCD,R2	;;;   EOM STATUS 
	CMP	#EM.SUC,R2		;;;IS 'EOM STATUS' = SUCCESS?
	BNE	100$			;;;IF NE NO
	MOV	#EFNSUC,-(SP)		;;;SET SUCCESS (ERR)
	BR	1000$			;;;
100$:
	CMP	#EM.ABO,R2		;;;IS 'EOM STATUS' = I/O KILLED?
	BNE	200$			;;;IF NE NO
	MOV	#EFNABO,-(SP)		;;;SET 'I/O KILLED' ERROR
	BR	1000$			;;;
200$:
	MOV	#EFNHER,-(SP)		;;;SET HDWR ERROR
1000$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I8.1 MODIFIED
	MOV	D$CIDR-B.(R1),R2	;;;GET EVENT
	BIT	#REQLK,R2		;;;IS LINK REQUESTED?
	BNE	1100$			;;;IF NE  YES
	BIT	#DELAY,R2		;;;IS DELAY REQUESTED?
	BNE	1200$			;;;IF NE  YES
	BR	1300$			;;;PROCESS OTHER CASES
1100$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I3.2 (A COPY OF)
	ACTION	#ACKNCD,#SWPTC,#TMREC	;;;*$* 
;	DR11W	MSEND,MSIGNL,#ACKNCD,,R5;;;*$* SEND 'LINK-ACK'
;	STATE
;	MOV	#SWPTC,D$STAT-B.(R1)	;;;*$* NEW STATE = WAIT PTC
;	ENTIME	D$TIMB,,TMREC,R1,TMFORK	;;;*$* SET TIMEOUT
	BR	1400$			;;;
1200$:
	BIS	#BUSY,D$LNKO-B.(R1)	;;;SET LINK BUSY
;	ENTIME	D$TIMB,,TMDEL,R1,TMFORK	;;;SET TIMEOUT
	MOV	#TMDEL,D$TMU-B.(R1)	;;;*$* *$$*
;	STATE
	MOV	#SIDLE,D$STAT-B.(R1)	;;;NEW STATE = IDLE
	BR	1400$			;;;
1300$:
;	STATE
	MOV	#SIDLE,D$STAT-B.(R1)	;;;NEW STATE = IDLE
;					;;;NO TIMEOUT
1400$:
	JSR	PC,CDWEXT		;;;CALL 'W"EXIT'
	MOV	(SP)+,R2		;;;REPORT ERROR
	JSR	PC,CDERR		;;;  TO APPL. PROGRAM
;
	CMP	#SIDLE,D$STAT-B.(R1)	;;;IS STATE = IDLE?
	BNE	1410$			;;;IF NE  NO
	JMP	CDDSP			;;;GO TO 'PROCESS IDLE STATE'
1410$:
	JMP	CDEXIT
10$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I8.2
;	STATE
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE = LINK-DOWN
;					;;;NO TIMEOUT
	JSR	PC,CDWEXT		;;;CALL 'W"EXIT'
	MOV	#EFNHER,R2		;;;REPORT HDWR ERROR
	JSR	PC,CDERR		;;;  TO APPL.PROGRAM
	JMP	CDDSP			;;;GO TO 'PROCESS LINK-DOWN STATE'
;
	.PAGE
;		I9	STATE = SWREWC	(WAIT RECEIVER WC)
;		--	--------------
;
CDIN06:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	CHKATN	20$			;;;CHECK 'ATTN' BIT
	CMP	#WCNACD,D$CIDR-B.(R1)	;;;IS EVENT = WORD COUNT NACK?
	BNE	10$			;;;IF NE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I9.2
;	STATE
	MOV	#SIDLE,D$STAT-B.(R1)	;;;NEW STATE = IDLE
;					;;;NO TIMEOUT
	JSR	PC,CDWEXT		;;;CALL 'W"EXIT'
	MOV	#EFNWRR,R2		;;;REPORT 'NO READ REQUEST' ERROR
	JSR	PC,CDERR		;;;  TO APPL.PROGRAM
	JMP	CDEXIT
10$:
	BIT	#NOTWC,D$CIDR-B.(R1)	;;;IS EVENT = WORD COUNT?
	BNE	20$			;;;IF NE NO
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I9.1
	MOV	IQWCQE,R4		;;;GET
	MOV	Q$WCNT(R4),R2		;;;    WORD
	NEG	R2			;;;         COUNT
	CMP	R2,D$CIDR-B.(R1)	;;;COMPARE XMIT AND RECEIVE WC
	BLE	11$			;;;IF LE  YES
	MOV	D$CIDR-B.(R1),R2	;;;GET WORD COUNT
;		RETURN ERROR CODE TO APPL. PROGRAM
	BR	15$
11$:
	BEQ	14$			;;;IF EQ  YES
;		RETURN ERROR CODE TO APPL. PROGRAM
	MOV	R2,-(SP)		;;;SAVE WORD COUNT
	MOV	IQWCQE,R4		;;;GET QUEUE ELEMENT PTR
	MOV	#EFNDTR,R2		;;;REPORT 'DATA TRUNC' ERROR
	JSR	PC,CDERR		;;;  TO APPL.PROGRAM
	MOV	(SP)+,R2		;;;RESTORE WORD COUNT
14$:
15$:
	MOV	Q$BLKN(R4),R3		;;;REPORT
	MOV	R2,B$WC(R3)		;;;    WCNT
	ADD	#2,R2			;;;TO DISABLE 'DMA COMPLETE' INTERPT
	DR11W	MSEND,MDMA,R2,Q$BUFF(R4),R5;;;SET 'DMA SEND'
;	STATE
	MOV	#SXMIT,D$STAT-B.(R1)	;;;NEW STATE = TRANSMITTING
;	ENTIME	D$TIMB,,TMXMT,R1,TMFORK	;;;*$*  SET TIMEOUT
	MOV	#TMXMT,D$TMU-B.(R1)	;;;*$* *$$*
	JMP	CDRTRN			;RETURN
20$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I9.3
;	STATE
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE = LINK-DOWN
;					;;;NO TIMEOUT
	JSR	PC,CDWEXT		;;;CALL 'W"EXIT'
	MOV	#EFNHER,R2		;;;REPORT HDWR ERROR
	JSR	PC,CDERR		;;;  TO APPL.PROGRAM
	JMP	CDDSP			;;;GO TO 'PROCESS LINK-DOWN STATE'
;
	.PAGE
;		I10	STATE = SXMIT	(TRANSMITTING)
;		---	--------------
;
CDIN07:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	CHKATN	5$			;;;CHECK 'ATTN' BIT
	MOV	D$CSR-B.(R1),R5		;;;GET WORD COUNT
	CMP	#<-1>,CDWORD(R5)	;;;IS IT -1?
	BEQ	10$			;;;IF EQ  YES
;	REPORT ERROR CONDITION (HDWR ERR) TO APPL. PROGRAM
;	************
5$:
	JSR	PC,CDWEXT		;;;CALL 'W"EXIT'
	MOV	#EFNHER,R2		;;;REPORT HRDW ERROR
	JSR	PC,CDERR		;;;  TO APPL. PROGRAM
;	STATE
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE = LINK-DOWN
;					;;;NO TIMEOUT
	JMP	CDDSP			;;;GO TO 'PROCESS LINK-DOWN STATE'
10$:
	MOV	D$CIDR-B.(R1),R2	;;;GET
	BIC	#^C<EOMSCD>,R2		;;;   EOM STATUS QUALIFIER
	CMP	#EOMSCD,R2		;;;HAS 'EOM STATUS' BEEN REPORTED?
	BNE	20$			;;;IF NE  NO
	MOV	#SWEOMS,D$STAT-B.(R1)	;;;GO TO
	JMP	CDDSP			;;;     PROCESS 'EOM STATUS'
20$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I10.1
;	STATE
	MOV	#SWEOMS,D$STAT-B.(R1)	;;;NEW STATE = WAIT EOM STATUS
;	ENTIME	D$TIMB,,TMXMT,R1,TMFORK	;;;*$*  SET TIMEOUT
	MOV	#TMXMT,D$TMU-B.(R1)	;;;*$* *$$*
	JMP	CDRTRN			;RETURN
;
	.PAGE
;		I11	STATE = SREC	(RECEIVING)
;		---	--------------
;
CDIN10:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	CHKATN	5$			;;;CHECK 'ATTN' BIT
	MOV	D$CSR-B.(R1),R5		;;;GET WORD COUNT
	TST	CDWORD(R5)		;;;IS IT 0?
	BEQ	10$			;;;IF EQ  YES
5$:
	MOV	#EOMSCD!EM.FHE,R2	;;;EOM-STATUS=FATAL HDWR ERROR
	MOV	#EFNHER,-(SP)		;;;SET HRDW ERROR
	BIC	#BUSY,D$LNKO-B.(R1)	;;;CLEAR "LINK BUSY"
	BIS	#STRTCD,R2		;;;SEND 'START'
	BR	30$			;;;
10$:
	TST	D$RPTC-B.(R1)		;;;IS 'READ' SESSION STILL OPEN?
	BNE	15$			;;;IF NE  YES
	MOV	#EOMSCD!EM.ABO,R2	;;;EOM-STATUS=ABORTED
	CLR	-(SP)   		;;;SET DUMMY ERROR
	BR	20$
15$:
	MOV	#EOMSCD!EM.SUC,R2	;;;EOM-STATUS=SUCCESSFUL END OF MSGE
	MOV	#EFNSUC,-(SP)		;;;SET SUCCESS (ERR)
20$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I11.1 MODIFIED
	BIT	#BUSY,D$LNKO-B.(R1)	;;;IS LINK BUSY?
	BNE	30$			;;;IF NE  YES
	TST	IQWCNT			;;;IS EVENT = WRITE-CNT>0?
	BLE	30$			;;;IF LE NO
	BIS	#RECLCD,R2		;;;REQUEST THE LINK
30$:
	ACTION	R2			;;;*$* 
;	DR11W	MSEND,MSIGNL,R2,,R5	;;;*$* SEND 'EOM-STATUS'
;	STATE
	BIT	#REQLK,R2		;;;IS LINK REQUESTED?
	BEQ	35$			;;;IF EQ  NO
	MOV	#SWLACK,D$STAT-B.(R1)	;;;NEW STATE = WAIT LINK-ACK
	BR	36$
35$:
	BIT	#START,R2		;;;IS  PROT. START  REQUESTED?
	BEQ	40$			;;;IF EQ  NO
	MOV	#SWPRST,D$STAT-B.(R1)	;;;NEW STATE = WAIT LINK-ACK
36$:
;	ENTIME	D$TIMB,,TMXMT,R1,TMFORK	;;;SET TIMEOUT
	MOV	#TMXMT,D$TMU-B.(R1)	;;;*$* *$$*
	BR	50$			;;;
40$:
	MOV	R2,D$CODR-B.(R1)	;;;SAVE 'EOM STATUS'
	MOV	#SIDLE,D$STAT-B.(R1)	;;;NEW STATE = IDLE
;					;;;NO TIMEOUT
50$:
	CLR	R4			;;;RESET Q.ELEMENT POINTER
	TST	D$RPTC-B.(R1)		;;;IS CURRENT 'READ' KILLED BY APPL. PRGM?
	BEQ	60$			;;;IF EQ  YES
	CLR	D$RPTC-B.(R1)		;;;CLEAR CURRENT PTC
	JSR	PC,CDREXT		;;;CALL 'R"EXIT'
60$:
	MOV	(SP)+,R2		;;;REPORT ERROR
	JSR	PC,CDERR		;;;  TO APPL. PROGRAM
	JMP	CDEXIT
;
;
	.PAGE
;
CDRTRN:
	.IIF DF DBUG BPT
;	MOV	(SP)+,R3		;;;RESTORE
;	MOV	(SP)+,R2		;;;        REG-
;	MOV	(SP)+,R1		;;;            ISTERS
;
;	RTS	PC			;;;RETURN
;
	JMP	CDEXIT			;;;RETURN
;
;
	.PAGE
	.SBTTL	(INTERRUPT) FORK PROCESSING 
;
;
CDFORK:
;
.IF NE TIM$IT				;;; **5-APR-84**
	.IIF DF DBUG BPT
	MOV	(SP)+,R3		;;;RESTORE
	MOV	(SP)+,R2		;;;        REG-
	MOV	(SP)+,R1		;;;            ISTERS
;
	.FORK	D$FORK
;
	.TIMIO	D$TIMB,0,TMTICK		;ENABLE TIMEOUT
;
	RTS	PC			;;;RETURN
.ENDC	;TIM$IT				;;; **5-APR-84**
;
;
	.PAGE
	.SBTTL	TIMEOUT PROCESSING SECTION
;
;
CDTIME:
;
.IF NE TIM$IT				; **5-APR-84**
;
;  ENTER SYSTEM STATE
;
	MOV	@SP,-(SP)		;MAKE ROOM ON THE STACK
	CLR	2(SP)			;FAKE INTERRUPT PS=0
	.MTPS	#PR7			;GO TO PRIORITY 7
	.INTEN	0,PIC			;ENTER SYSTEM STATE
;
;
	.IIF DF DBUG BPT
;
	MOV	R1,-(SP)		;SAVE
	MOV	R2,-(SP)		;     REG-
	MOV	R3,-(SP)		;         ISTERS
;
; FOR MULTIPLE DR11-W:
; DETERMINE HERE WHICH DR11-W TIMED OUT AND MOVE ITS UNIT NUMBER
;  INTO R1.
; IN THIS VERSION IT IS ASSUMED THAT THE UNIT NUMBER IS 0.
;
	DISINT				;DISABLE INTERRUPTS
	CLR	R1			;;;UNIT NUMBER 0
	ADD	BASE.,R1		;;;ADD BASE RELOC. ADDR
	MOV	D$CSR-B.(R1),R5		;;;GET CSR ADDRESS
;****************************** TIMEOUT PATCH 12-JUNE-1983 **************
	MOV	(R5),R3			;;;GET CSR CONTENTS
	BIT	#IE,R3			;;;IS 'IE' SET ?
	BEQ	100$			;;;IF EQ  NO -> DISABLE TIMEOUTS
;****************************** END OF TIMEOUT PATCH 12-JUNE-1983 *******
;
;		VERIFY DS-077 TRANSACTION TIMEOUT
;
	TST	D$TMU-B.(R1)		;;;IS TIMEOUT ACTIVE?
	BEQ	100$			;;;IF EQ  NOT ACTIVE
	MOV	PC,-(SP)		;;;NO TIMEOUT
	ADD	#CDTIME-.,(SP)		;;;           RUNNING
	MOV	(SP)+,D$TIMB+C.COMP	;;;    LOAD C.COMP
	.TIMIO	D$TIMB,0,TMTICK		;;;RESET THE TIMER
	DEC	D$TMU-B.(R1)		;;;DECREMENT THE TIME COUNTER
	BEQ	200$			;;;IF EQ  D$TMU=0 (I.E. TIMEOUT)
	JMP	CDTEND			;;;RETURN
100$:	
	CLR	D$TIMB+C.COMP   	;;;DISABLE THE TIMER
	JMP	CDTEND			;;;RETURN
200$:
;
;			PROCESS DS-077 TRANSACTION TIMEOUT
;
;  CHECK THE CURRENT STATE FOR VALIDITY.
;  IF VALID, DISPATCH.
;
	.IF	DF	DEBUG		;;;IF 'DEBUG', SET A BREAKPOINT
	CMP	#SWPRST,D$STAT-B.(R1)	;;;IS STATE = WAIT PROT. START?
	BNE	1$			;;;IF NE  NO
	BPT				;;;IF 'DEBUG', SET A BREAKPOINT
1$:
	.ENDC
	TST	D$STAT-B.(R1)		;;;IS STATE > 0?
	BGT	20$
	BR	30$
20$:
	CMP	#SLIMIT,D$STAT-B.(R1)	;;;YES, IS STATE < SLIMIT+1?
	BGE	CDTDSP			;;;IF GE YES, STATE OK.
;
;  INVALID STATE.
;  GO TO LINK-DOWN STATE AND RE-SYNCHRONIZE.
;
30$:
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;GO TO
	JMP	CDTDSP 			;;;      LINK-DOWN STATE
;
DSPTAB:
	.WORD	0			;;;STATE =  0   INVALID STATE
	.WORD	CDTM01-B.		;;;STATE =  1   SWLACK
	.WORD	CDTM02-B.		;;;STATE =  2   SWPTC
	.WORD	CDTM01-B.		;;;STATE =  3   SWAPTC
	.WORD	CDTM04-B.		;;;STATE =  4   SWCSIG
	.WORD	CDTM01-B.		;;;STATE =  5   SWEOMS
	.WORD	CDTM01-B.		;;;STATE =  6   SWREWC
	.WORD	CDTM01-B.		;;;STATE =  7   SXMIT
	.WORD	CDTM10-B.		;;;STATE = 10   SREC
	.WORD	CDTM11-B.		;;;STATE = 11   SIDLE
	.WORD	CDTM12-B.		;;;STATE = 12   SWPRST
	.WORD	CDTM13-B.		;;;STATE = 13   SLDOWN
;
; NOW DO THE DISPATCH
;
CDTDSP:
	MOV	D$STAT-B.(R1),R2	;;;GET OFFSET TO DISPATCH TABLE
	ASL	R2			;;;GET BYTE OFFSET
	ADD	BASE.,R2		;;;ADD BASE RELOCATION ADDR
	MOV	DSPTAB-B.(R2),R3	;;;GET THE DISPATCH ADDRESS
	ADD	BASE.,R3		;;;ADD BASE RELOCATION ADDR
	JMP	@R3			;;;DISPATCH TO INDIVIDUAL STATE
	.PAGE
;
;
;		*	STATE = SLDOWN	(LINK DOWN)
;		^	--------------
;		^--->T1	       
CDTM13:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	BIC	#BUSY,D$LNKO-B.(R1)	;;;CLEAR "LINK BUSY"
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER T1.1
	JMP	CDTEND			;;;RETURN
;
;		*	STATE = SIDLE	(IDLE)
;		^	--------------
;		^--->T3	       
CDTM11:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	BIC	#BUSY,D$LNKO-B.(R1)	;;;CLEAR "LINK BUSY"
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER T3.1
	TST	IQWCNT			;;;IS EVENT = WRITE-CNT>0?
	BLE	30$			;;;IF LE NO
	ACTION	#RECLCD			;;;*$*
;	DR11W	MSEND,MSIGNL,#RECLCD,,R5;;;*$* SEND 'REQUEST LINK'
;	STATE
	MOV	#SWLACK,D$STAT-B.(R1)	;;;NEW STATE = WAIT LINK-ACK
	MOV	#TMXMT,D$TMU-B.(R1)	;;;SET TIMEOUT
30$:
	JMP	CDTEND			;;;RETURN
;
;		*	STATE = SWPRST	(WAITING FOR PROTOCOL START)
;		^ 	--------------
;		^--->T2
CDTM12:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER T2.1
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE = LINK DOWN
	JSR	PC,CDTACN		;;;CALL ACTION I1.2
	JMP	CDTEND			;;;RETURN
;
	.PAGE
;
;		*	STATE = SWPTC	(WAIT PTC)
;		^	--------------
;		^--->T5
CDTM02:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	JSR	PC,C$SOPN		;;;*$* CHECK, IF EVENT IS PTC (RECEIVED)
;					;;;*$*  AND IF SESSION IS OPENED
	BR	20$			;;;*$* IF EVENT NOT PTC (RECEIVED)
	BR	10$			;;;*$* IF NO SESSION OPENED
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I5.1 
	ACTION	#PTCACD			;;;*$*
;	DR11W	MSEND,MSIGNL,#PTCACD,,R5;;;*$* SEND 'PTC-ACK'
;	STATE
	MOV	#SWCSIG,D$STAT-B.(R1)	;;;NEW STATE = WAIT WC OR SIGNAL
	MOV	#TMREC,D$TMU-B.(R1)	;;;SET TIMEOUT
	JMP	CDTEND			;;;RETURN
10$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I5.2
	ACTION	#PTCNCD			;;;*$*
;	DR11W	MSEND,MSIGNL,#PTCNCD,,R5;;;*$* SEND 'PTC-NACK'
;	STATE
	MOV	#SIDLE,D$STAT-B.(R1)	;;;NEW STATE = IDLE
;*********** FIXING THE CD-TO-MONITOR EXIT DEADLOCK: 17-FEBR-1984 *****************
;17-FEB	MOV	#TMSYNC,D$TMU-B.(R1)	;;;SET TIMEOUT
;17-FEB	JMP	CDTEND			;;;RETURN
	JMP	CDTDSP			;;;GO BACK TO PROCESS 'IDLE' STATE
;***** END OF  FIXING THE CD-TO-MONITOR EXIT DEADLOCK: 17-FEBR-1984 *****************
20$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER T2.1
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE = LINK DOWN
	JSR	PC,CDTACN		;;;CALL ACTION I1.2
	JMP	CDTEND			;;;RETURN
;
	.PAGE
;
;		*	STATE = SWLACK	(WAIT LINK-ACK)
;		^	--------------
;		^	        SWAPTC	(WAIT PTC-ACK)
;		^	        ------
;		^	        SWEOMS	(WAIT EOM STATUS)
;		^	        ------
;		^	        SWREWC	(WAIT RECEIVER WC)
;		^	        ------
;		^	        SXMIT	(TRANSMITTING)
;		^	       -------
;		^--->T4,T6,T8,T9,T10
CDTM01:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER T10.1
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE = LINK DOWN
	JSR	PC,CDTACN		;;;CALL ACTION I1.2
	JSR	PC,CDWEXT		;;;CALL 'W"EXIT'
	JMP	CDTEXT			;;;RETURN
;
	.PAGE
;
;		*	STATE = SWCSIG	(WAIT WC OR SIGNAL)
;		^	--------------
;		^--->T7
CDTM04:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
	MOV	D$CIDR-B.(R1),R2	;;;GET
	BIC	#^C<PTCDCD>,R2		;;;    EVENT
	CMP	#PTCDCD,R2		;;;IS EVENT = PTC(RECEIVED)?
	BNE	5$			;;;IF NE NO
	JMP	30$			;;;
5$:
;*********** SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
	CLR	D$RPTC-B.(R1)		;;;CLEAR CURRENT PTC
;	     THE NEXT 7 LINES ARE MOVED TO AROUND LABEL 'CDRD1:'
;	JSR	PC,C$CRWC		;;;*$* CHECK FOR 'READ' POSTED
;					;;;*$*   AND 'RECEIVER WORD COUNT'
;					;;;*$* AND SET UP 'DMA RECEIVE' & STATE
;	BR	20$			;;;*$* IF NO 'READ' POSTED
;	MOV	#TMREC,D$TMU-B.(R1)	;;;SET TIMEOUT
;	JMP	CDTEND			;;;RETURN
;20$:
;***** END OF SPEED-UP ON A 'SYNC' TIMEOUT CHANGE: 15-JULY-1983 *****************
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I7.3
	ACTION	#WCNACD			;;;*$*
;	DR11W	MSEND,MSIGNL,#WCNACD,,R5;;;*$* SEND 'WC-NACK'
;	STATE
	MOV	#SIDLE,D$STAT-B.(R1)	;;;NEW STATE = IDLE
;*********** FIXING THE CD-TO-MONITOR EXIT DEADLOCK: 17-FEBR-1984 *****************
;17-FEB	MOV	#TMSYNC,D$TMU-B.(R1)	;;;SET TIMEOUT
;17-FEB	JMP	CDTEND			;;;RETURN
	JMP	CDTDSP			;;;GO BACK TO PROCESS 'IDLE' STATE
;***** END OF  FIXING THE CD-TO-MONITOR EXIT DEADLOCK: 17-FEBR-1984 *****************
30$:
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER T11.1
	JMP	CDTM10			;;;RETURN
;
;		*	STATE = SREC	(RECEIVING)
;		^	------------
;		^--->T11
CDTM10:
	.IIF DF DBUG BPT				;;;*DEBUG* BREAK OUT TO XDT
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER T11.1
	MOV	#SLDOWN,D$STAT-B.(R1)	;;;NEW STATE = LINK DOWN
	JSR	PC,CDTACN		;;;CALL ACTION I1.2
;
	CLR	R4			;;;RESET Q.ELEMENT POINTER
	TST	D$RPTC-B.(R1)		;;;IS CURRENT 'READ' KILLED BY APPL. PRGM?
	BEQ	60$			;;;IF EQ  YES
	CLR	D$RPTC-B.(R1)		;;;CLEAR CURRENT PTC
	JSR	PC,CDREXT		;;;CALL 'R"EXIT'
60$:
	JMP	CDTEXT			;;;RETURN
;
;
	.PAGE
CDTEND:
;	ENINT				;;;*$* ENABLE INTERRUPTS
	JSR	PC,C$ENIN		;*$* 
;
	.IIF DF DBUG BPT
	MOV	(SP)+,R3		;;;RESTORE
	MOV	(SP)+,R2		;;;        REG-
	MOV	(SP)+,R1		;;;            ISTERS
;
	RTS	PC			;;;RETURN
;
;
CDTACN:					;;;TIMEOUT ACTION SUBROUTINE
;					;;;  (ACTION AS IN I1.2)
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I1.2
	ACTION	#STRTCD			;;;*$*
;	DR11W	MSEND,MSIGNL,#STRTCD,,R5;;;*$* SEND 'START'
;	STATE
	MOV	#SWPRST,D$STAT-B.(R1)	;;;NEW STATE = WAITING PROT. START
	MOV	#TMXMT,D$TMU-B.(R1)	;;;SET TIMEOUT
	RTS	PC			;;;RETURN
;
.ENDC	;TIM$IT				;;; **5-APR-84**
;
	.PAGE
	.SBTTL	I/O COMPLETION SECTION
;
;
CDREXT:					;;;SUBROTINE
	QUEXFR	IQR,IQE,R4		;;;XFER A BUFFER FROM READ TO EXIT Q
	RTS	PC			;;;RETURN
;
CDWEXT:					;;;SUBROUTINE
	QUEXFR	IQW,IQE,R4		;;;XFER A BUFFER FROM WRTE TO EXIT Q
	RTS	PC			;;;RETURN
;
;
CDERR:					;;;ERROR LOGGING SUBROUTINE
	.IF	DF	DEBUG		;;;IF 'DEBUG', SET A BREAKPOINT
	CMP	#EFNHER,R2		;;;IS IT HDWRE ERROR?
	BNE	1$			;;;IF NE  NO
	BPT				;;;IF 'DEBUG', SET A BREAKPOINT
1$:
	.ENDC
;
	TST	R4			;;;IS QUEUE EMPTY?
	BEQ	10$			;;;IF EQ  YES
	MOV	Q$BLKN(R4),R3		;;;GET ERROR BLOCK POINTER
	MOV	R2,B$ERR(R3)		;;;LOG ERROR
10$:
	RTS	PC			;;;RETURN
;
;
CDTEXT:					;;;TIMEOUT PROCESSING EXIT
.IF NE TIM$IT				;;; **5-APR-84**
	MOV	#EFNTMX,R2		;;;REPORT TIMEOUT ERROR
	JSR	PC,CDERR		;;;  TO APPL. PROGRAM
;	ENINT				;;;*$* ENABLE INTERRUPTS
	JSR	PC,C$ENIN		;*$* 
.ENDC	; TIM$IT			;   **5-APR-84**
;
;
CDEXIT:
	.IIF DF DBUG BPT
	MOV	(SP)+,R3		;;;RESTORE
	MOV	(SP)+,R2		;;;        REG-
	MOV	(SP)+,R1		;;;            ISTERS
;
;
CDDONE:
	DISINT			;DISABLE INTERRUPTS
;*********** FIXING THE CD-TO-MONITOR EXIT DEADLOCK: 17-FEBR-1984 *****************
;17-FEB	TST	CDCQE		;;;IS CD-RT/11MONITOR'S QUEUE EMPTY?
;17-FEB	BNE	10$		;;;IF NE  NO
	CMP	#FREE,D$FFIN	;;;IS JSRFIN ALREADY CALLED?
	BNE	10$		;;;IF NE  YES
;17-FEB	QUEXFR	IQE,CD,R4	;;;XFER A BUFFER FROM EXIT TO CD QUEUE
	QUEXST	IQE,CD,R4	;;;XFER A BUFFER FROM EXIT TO CD QUEUE
;***** END OF  FIXING THE CD-TO-MONITOR EXIT DEADLOCK: 17-FEBR-1984 *****************
	TST	R4		;;;IS EXIT QUEUE EMPTY?
	BEQ	10$		;;;IF EQ  YES
	MOV	#BUSY,D$FFIN	;;;ENTERING CRITICAL SECTION
;	ENINT			;;;*$* ENABLE INTERRUPTS
	JSR	PC,C$ENIN	;*$* 
	JSRFIN	CD,R4		; RETURN QUEUE ELEMENT TO MONITOR.
	MOV	#FREE,D$FFIN	;EXITING CRITICAL SECTION
	BR	CDDONE		;CONTINUE FLASHING THE EXIT QUEUE
10$:
;	ENINT			;;;*$* ENABLE INTERRUPTS
	JSR	PC,C$ENIN	;*$* 
	RTS	PC		;RETURN
;
;
CDOBIO:
	EXTMA			;;;'EXTMA' ODD BIT I/O SUBROUTINE
	.PAGE
	.SBTTL	COMMON SUBROUTINES
;
;
C$DSIN:				;;*$* DISABLE INTERRUPTS SUBROUTINE
	DISINT
	MOV	2(SP),-(SP)	;;       PUT
	MOV	2(SP),4(SP)	;;	    INTERRUPT MASK
	MOV	(SP),2(SP)	;;			ON STACK
	TST	(SP)+		;;POP THE STACK
	RTS	PC
C$ENIN:				;;*$* ENABLE INTERRUPTS SUBROUTINE
	MOV	2(SP),-(SP)	;;       GET
	MOV	2(SP),4(SP)	;;	    INTERRUPT MASK
	MOV	(SP),2(SP)	;;			FROM STACK
	TST	(SP)+		;;POP THE STACK
	ENINT
	RTS	PC
;
C$DR11:				;;*$* DR11-W SUBROUTINE
	JSR	PC,C$GVR2	;;GET PARAM. VALUE IN 'R2'
	DR11W	MSEND,MSIGNL,R2,,R5;;SEND XACTION SGNL
	MOV	(SP)+,R2	;;RESTORE R2
	RTS	PC		;;RETURN
;
;	.LIST	MEB
;
C$ENTM:				;;*$* ENABLE TIMEOUT SUBROUTINE
	JSR	PC,C$GVR2	;;GET PARAM. VALUE IN 'R2'
.IIF NE TIM$IT	ENTIME	D$TIMB,,R2,R1,TMFORK,1$ ;;SET TIMEOUT **5-APR-84**
	ADD	#2,2(SP)	;;SET NORMAL EXIT
1$:
	MOV	(SP)+,R2	;;RESTORE R2
	RTS	PC		;;RETURN
;
C$ETIO:				;;*$* ENABLE TIMEOUT SUBROUTINE (INIT. SCTN)
.IIF NE TIM$IT	ENTIME	D$TIMB,TMTICK,TMXMT,R1	;;SET TIMEOUT **5-APR-84**
	RTS	PC		;;RETURN
;
C$ACT:				;;*$* ACTION SUBROUTINE
	MOV	R2,-(SP)	;;SAVE R2
	MOV	10(SP),R2	;;GET XACTION SGNL
	MOV	2(SP),10(SP)	;;SAVE RET ADDR
	MOV	R2,2(SP)	;;SET XACTION SGNL
	MOV	(SP)+,R2	;;RESTORE R2
	JSR	PC,C$DR11	;;SEND XACTION SIGNAL
	MOV	(SP)+,D$STAT-B.(R1);;SET NEW STATE
	TST	(SP)		;;IS TIMEOUT REQUESTED?
	BNE	1$		;;IF NE  YES
	TST	(SP)+		;;POP THE STACK
	RTS	PC		;;RETURN
1$:
	JSR	PC,C$ENTM	;;SET TIMEOUT
	BR	2$		;;ALTERNATE EXIT
	RTS	PC		;;RETURN
2$:
	TST	(SP)+		;;POP THE STACK
	JMP	CDFORK		;;GO TO FORK LEVEL
;
C$CHKP:				;;*$* CHECK PTC SUBROUTINE
	JSR	PC,C$GVR2	;;GET PARAM. VALUE IN 'R2'
	CHKPTC	IQR,R2,1$	;;SET PTC
	ADD	#2,2(SP)	;;SET NORMAL EXIT
1$:
	MOV	(SP)+,R2	;;RESTORE R2
	RTS	PC		;;RETURN
;
C$GVR2:				;;*$* 'GET VALUE IN R2' SUBROUTINE
	MOV	R2,-(SP)	;;SAVE R2
	MOV	6(SP),R2	;;GET VALUE FROM STACK
	MOV	4(SP),6(SP)	;;SAVE RET ADDR
	MOV	(SP),4(SP)	;;SAVE R2
	TST	(SP)+		;;POP THE STACK
	RTS	PC		;;RETURN
;
C$SOPN:					;;*$*  PTC & 'SESSION OPEN' CHECK
	MOV	D$CIDR-B.(R1),R2	;;;GET
	BIC	#^C<PTCDCD>,R2		;;;    EVENT
	CMP	#PTCDCD,R2		;;;IS EVENT = PTC(RECEIVED)?
	BNE	400$			;;;IF NE NO
;  CHECK IF SESSION OPENED FOR THIS PTC
	MOV	#S$NOPN,R3		;;;MAX # OF OPENED SESSIONS
	MOV	R3,D$SIND-B.(R1)	;;;
	MOV	D$CIDR-B.(R1),-(SP)	;;;GET
	BIC	#PTCDCD,(SP)		;;;    PTC
	MOV	PC,R2			;;;
	ADD	#S$OPEN-.,R2		;;;
100$:
	CMP	(R2)+,(SP)		;;;IS SESSION OPENED FOR IT?
	BEQ	200$			;;;IF EQ YES
	SOB	R3,100$			;;;CONTINUE
	MOV	(SP)+,R2		;;;POP THE STACK
	BR	300$			;;;NO SESSION OPENED
200$:
	MOV	(SP)+,D$RPTC-B.(R1)	;;;SAVE CURRENT PTC
	SUB	R3,D$SIND-B.(R1)	;;;SAVE CURRENT SIGNAL AREA INDEX
;  END OF SESSION OPENED CHECK 
	ADD	#2,(SP)			;;;*$*
300$:
	ADD	#2,(SP)			;;;*$*
400$:
	RTS	PC			;;;*$*
	.PAGE
;
C$CRWC:					;; *$*  CHECK FOR 'READ' POSTED
;					;; *$*   AND 'RECEIVER WORD COUNT'
;					;;;*$* AND SET UP 'DMA RECEIVE' & STATE
;	CHKPTC	IQR,<D$RPTC-B.(R1)>,100$;;;*$* IS PTC RECV'D VIA DR11-W
;					;;;  FOUND AMONG 'READ' REQUESTS?
	MOV	D$RPTC-B.(R1),-(SP)	;*$* *$$*
	JSR	PC,C$CHKP		;*$* 
	BR	100$			;*$* ALTERNATE EXIT
;	ACTION	ZZZZZ		***	;;;ACTION NUMBER I7.1
	MOV	IQRCQE,R4		;;;GET
	MOV	Q$WCNT(R4),R2		;;;    WORD COUNT
	CMP	R2,D$CIDR-B.(R1)	;;;COMPARE XMIT AND RECEIVE WC
	BLE	11$			;;;IF LE  YES
	MOV	D$CIDR-B.(R1),R2	;;;GET WORD COUNT
;		RETURN ERROR CODE TO APPL. PROGRAM
	BR	15$
11$:
	BEQ	14$			;;;IF EQ  YES
;		RETURN ERROR CODE TO APPL. PROGRAM
	MOV	R2,-(SP)		;;;SAVE WORD COUNT
	MOV	IQRCQE,R4		;;;GET QUEUE ELEMENT PTR
	MOV	#EFNDTR,R2		;;;REPORT 'DATA TRUNC' ERROR
	JSR	PC,CDERR		;;;  TO APPL.PROGRAM
	MOV	(SP)+,R2		;;;RESTORE WORD COUNT
14$:
15$:
	MOV	Q$BLKN(R4),R3		;;;REPORT
	MOV	R2,B$WC(R3)		;;;    WCNT
	DR11W	MRECV,MDMA,R2,Q$BUFF(R4),R5;;;SEND 'WC' AND SET DMA RECEIVE
;	STATE
	MOV	#SREC,D$STAT-B.(R1)	;;;NEW STATE = RECEIVING
	ADD	#2,(SP)			;;;*$*
100$:
	RTS	PC			;;;*$*
;
;
C$RSET:					;; *$$*  RESET MAINT. BIT IN DR11-W
	MOV	#10000,CDCSR(R5)	;;;*$$*  PUT DEVICE IN MAINT. MODE
	CLR	CDCSR(R5)		;;;*$$*  RESET DEVICE
	MOV	#20.,R3			;;;*$$*  DO 20. 'DEC' AND 'BR' 
1$:	DEC	R3			;;;*$$*         INSTRUCTIONS
	BGT	1$			;;;*$$*             TO DELAY
	MOV	#IE,CDCSR(R5)		;;;*$$*  RE-ENABLE INTERRUPTS
	RTS	PC			;;;*$$*  RETURN
;
	.PAGE
	.SBTTL	DATA STRUCTURES - IMPURE AREA
;
;
;			BASE RELOCATION ADDRESS.
BASE.:	.WORD	0
;
;			INTERNAL QUEUE DATA STRUCTURES.
;
;		(1) INTERNAL QUEUE FOR READ'S
IQRCNT:	.WORD	0		;NUMBER OF QUEUE ELEMENTS IN THE QUEUE
IQRCQE:	.WORD	0		;POINTER TO THE CURRENT QUEUE ELEMENT
IQRLQE:	.WORD	0		;POINTER TO THE LAST QUEUE ELEMENT
;
;		(2) INTERNAL QUEUE FOR WRITE'S
IQWCNT:	.WORD	0		;NUMBER OF QUEUE ELEMENTS IN THE QUEUE
IQWCQE:	.WORD	0		;POINTER TO THE CURRENT QUEUE ELEMENT
IQWLQE:	.WORD	0		;POINTER TO THE LAST QUEUE ELEMENT
;
;		(3) INTERNAL EXIT QUEUE 
IQECNT:	.WORD	0		;NUMBER OF QUEUE ELEMENTS IN THE QUEUE
IQECQE:	.WORD	0		;POINTER TO THE CURRENT QUEUE ELEMENT
IQELQE:	.WORD	0		;POINTER TO THE LAST QUEUE ELEMENT
;
;
;			PACKET TYPE CODES (PTC)
;			FOR WHICH SESSIONS ARE OPENED.
;
S$OPEN:	.WORD	0,0,0,0		; 
	.WORD	0,0,0,0
	.WORD	0,0,0,0
	.WORD	0,0,0,0
;
;			SIGNAL AREA ADDRESSES
;			FOR WHICH SESSIONS ARE OPENED.
S$SGNL:	.WORD	0,0,0,0		;
	.WORD	0,0,0,0
	.WORD	0,0,0,0
	.WORD	0,0,0,0
;
	.PAGE
;			DEVICE (DR11-W) CONTROL BLOCKS.
;
;		(1) CSR ADDRESS
D$CSR:	.WORD	CD$CSR		; UNIT NUMBER 0
;
;		(2) CSR CONTENTS
D$CCSR:	.WORD	0		; UNIT NUMBER 0
;
;		(3) EIR CONTENTS (ERROR AND INFORMATION REGISTER)
D$CEIR:	.WORD	0		; UNIT NUMBER 0
;
;		(4) IDR CONTENTS (INPUT DATA REGISTER)
D$CIDR:	.WORD	0		; UNIT NUMBER 0
;
;		(5) CURRENT PTC RECEIVED
D$RPTC:	.WORD	0		; UNIT NUMBER 0
;
;		(6) INDEX IN S$SGNL FOR CURRENT PTC 
D$SIND:	.WORD	0		; UNIT NUMBER 0
;
;		(7) STATE OF THE DR11-W LINK
D$STAT:	.WORD	SLDOWN		; UNIT NUMBER 0
;
;		(8) LINK OWNERSHIP
D$LNKO:	.WORD	FREE		; UNIT NUMBER 0
;
;		(9) TIMEOUT COUNTERS
D$TMU:
D$TMU0:	.WORD	0		; UNIT NUMBER 0
;
.IF NE TIM$IT			;  **5-APR-84**
;		(10) .TIMIO BLOCK
D$TIMB:	.WORD	0		; UNIT NUMBER (ALL)
;				    HI ORDER TIME
	.WORD	0		;   LO ORDER TIME
	.WORD	0		;   LINK
	.WORD	0		;   JOB NUMBER
	.WORD	^O177400	;   SEQUENCE NUMBER
	.WORD	0		;   MONITOR PUTS -1 HERE
	.WORD	0		;   ADDRESS OF TIMEOUT COMPLETION ROUTINE
;
;		(11) .FORK BLOCK
D$FORK:	.WORD	0,0,0,0		; UNIT NUMBER (ALL)
.ENDC	; TIM$IT		;  **5-APR-84**
;
;		(12) JSRFIN/.DRFIN FLAG (TO PREVENT RE-ENTRANCY)
D$FFIN:	.WORD	FREE		; UNIT NUMBER (ALL)
;
;		(13) 'ATTN' BIT IN DR11-W CSR
D$ATTN:	.WORD	FREE		; UNIT NUMBER (0)
;
;		(14) ODR CONTENTS (OUTPUT DATA REGISTER)
D$CODR:	.WORD	0		; UNIT NUMBER 0
;
;
	.IF	DF	TRACE
	.PAGE
;
T$$CUR:	.WORD	0		;CURRENT PTR TO TRACE BUFFERS
;
T$$CSR:	.REPT	TRBSZE
	.WORD	0
	.ENDR
;
T$$EIR:	.REPT	TRBSZE
	.WORD	0
	.ENDR
;
T$$IDR:	.REPT	TRBSZE
	.WORD	0
	.ENDR
;
T$$BUF:	.REPT	TRBSZE
	.WORD	0
	.ENDR
;
T$$WCT:	.REPT	TRBSZE
	.WORD	0
	.ENDR
;
T$$PTC:	.REPT	TRBSZE
	.WORD	0
	.ENDR
;
T$$STA:	.REPT	TRBSZE
	.WORD	0
	.ENDR
;
T$$ATN:	.REPT	TRBSZE
	.WORD	0
	.ENDR
;
	.ENDC
;
	.PAGE
	.SBTTL	HANDLER TERMINATION SECTION
;
	.DREND	CD
;
	.END