.TITLE	HANDSHAKER

;	VERY SIMPLE HANDSHAKING HANDLER:

;	WRITTEN BY	GEORGE G. PRECKSHOT
;			OCT 15, 1980
;			UNIVERSITY OF ARIZONA

;	COPYRIGHT GEORGE G. PRECKSHOT
;	PERMISSION IS GRANTED FOR ANY USE AS LONG AS
;	CREDIT IS GIVEN.

;	THIS HANDLER PERFORMS A VERY SIMPLE HANDSHAKE AND TRANSMITS
;	DATA LINE BY LINE OR IN 512 BYTE BLOCKS.

;	THE HANDLER USES THE FOLLOWING PROTOCOL:

;	WHEN SENDING:

;		STEP=0	HANDLER INVOKED WITH .WRITX, HANDLER SETS
;			RECEIVER INTERUPT TO "ENABLED" AND BEGINS
;			TRANSMITTING AN ENDLESS SERIES OF ASCII
;			"ENQ" CHARACTERS.

;		STEP=1	STEP 1 IS ENTERED WHEN A RECEIVER INTERUPT
;			RESULTS IN THE RECEPTION OF AN ASCII "ACK"
;			CHARACTER.  THE HANDLER STOPS SENDING "ENQ"
;			AND COMMENCES TRANSMISSION OF BUFFER IF IN
;			LINE MODE, OR PREFACES BUFFER WITH ONE HEADER
;			BYTE AND THEN COMMENCES BUFFER TRANSMISSION IF
;			IN BLOCK MODE, AND THEN TRANSMITS UNTIL IT
;			EITHER:
;
;			  LINE MODE:
;				REACHES END OF BUFFER OR NULL BYTE
;
;				TRANSMITS CONTROL Z
;
;				TRANSMITS LINE FEED (IN THIS CASE
;				HANDLER RETURNS TO STEP 0)
;
;			  BLOCK MODE:
;				REACHES END OF BUFFER (EXPECTED 512. BYTES
;				ALTHOUGH ACTUALLY OTHER SIZES CAN BE USED)
;
;			THE HANDLER THEN RETURNS TO THE INVOKER.
;			AT END OF BUFFER, THE HANDLER WILL APPEND
;			AN "ETB".

;	WHEN RECEIVING:

;		STEP=0	HANDLER CLEARS RECEIVER DATA REGISTER AND RECEIVER
;			BUFFER AND THEN TURNS ON RECEIVER. IT IS LISTENING
;			FOR "ENQ".

;		STEP=1	UPON RECEPTION OF FIRST "ENQ"(AS FAR AS RECEIVER
;			IS CONCERNED) THE RECEIVER ENABLES THE TRANSMITTER
;			TO SEND ONE "ACK". THE RECEIVER THEN LISTENS FOR
;			THE FIRST NON "ENQ" CHARACTER WHICH IT INTERPRETS
;			AS THE FIRST CHARACTER OF A MESSAGE LINE. THIS
;			CAUSES TRANSITION TO STEP 2.

;		STEP=2	CHECKS THE FIRST NON-ENQ BYTE. IF IT IS A STX, THEN
;			THIS IS INTERPRETED AS A NON-ASCII BLOCK MESSAGE
;			AND THE RECEIVER ENTERS BLOCK RECEPTION MODE. IF IT
;			IS A CONTROL Z, THE RECEIVER REPORTS EOF.

;			IF LINE MODE:
;			  RECEIVES THE MESSAGE WHICH CONCLUDES BECAUSE EITHER:

;				BUFFER FULL

;				CONTROL Z (WHICH CAUSES EOF TO BE REPORTED)

;				LINE FEED OR "ETB"

;			IF BLOCK MODE:
;			  RECEIVES THE MESSAGE UNTIL BUFFER FULL

;		UPON CONCLUSION OF MESSAGE THE RECEIVER RETURNS TO THE
;		INVOKER.
;
;	THE HANDLER IS CONFIGURED AS A SPECIAL DEVICE, SO IT IS REQUIRED
;	TO RESPOND TO .LOOKUP,.ENTER,.CLOSE,.DELETE.  IT DOES THE
;	FOLLOWING:

;	.LOOKUP	CLEARS SEND FLAG, HANDLER WILL RECEIVE.

;	.ENTER	SETS SEND FLAG, HANDLER WILL SEND.

;	.CLOSE	SENDS CONTROL Z, CAUSES EOF CONDITION.

;	.DELETE CLEARS SEND FLAG. IT'S USE IS NOT EXPECTED SINCE
;	THIS IS A NON BLOCK STRUCTURED DEVICE.

;	THE POTENTIAL USER CAN SEE THAT ASCII CHARACTERS ETB, 'Z, LF, STX
;	SHOUL BE USED WITH APPROPRIATE CARE, BUT THAT ALL OTHER LEGAL ASCII
;	WILL BE TRANSMITTED.  THERE ARE NO PARITY OR REDUNDANCY
;	CHECKS, AND THE USER IS RESPONSIBLE FOR ENSURING THAT THE
;	RECEIVING END BUFFER IS AT LEAST AS LARGE AS THE TRANSMITTING
;	BUFFER, OR THAT LINE LENGTHS DO NOT EXCEED RECEIVER BUFFER
;	AREA. THE "ETB" CHARACTER IS PROVIDED FOR LONG LINES AND
;	THE USER'S PROGRAM MAY USE THIS FOR SUCH INDICATION.
;	FOR THIS REASON THE USER SHOULD ESCHEW THE USE OF "ETB".

;	IN BLOCK TRANSMISSION MODE, WHICH IS FOR USE BY SUCH SYSTEM UTILITIES
;	AS PIP, THE USER SHOULD NOTE THAT THE BUFFER SIZE AT EACH END OF
;	THE LINK SHOULD BE PRECISELY THE SAME.  THE HANDLER THEN PERFORMS
;	THE SERVICE OF BLOCK BY BLOCK SYNCHRONIZATION BETWEEN THE UTILITY
;	RUNNING INDEPENDENTLY IN EACH CPU.

;	ERRORS:

;	THE HANDLER ZEROS THE RECEIVER BUFFER AND IF NO ERRORS
;	OCCUR THE TEXT WILL END WITH A CONTROL Z, LF, ETB OR
;	WILL FILL THE BUFFER ENTIRELY.  IF BUFFER OVERRUN OCCURS
;	THE HARD ERROR BIT WILL BE SET, AS IT WILL IF WE HAVE
;	EIGHT RECEIVER ERRORS (IN THE HARDWARE).  THE DIFFERENCE
;	MAY BE DETECTED BY CHECKING FOR TRAILING ZEROS IN THE
;	BUFFER, IF THE BUFFER WAS FULL OF NON ZERO CHARACTERS,
;	THAT IS, THE LAST CHARACTER IS NONZERO, THEN A BUFFER OVERRUN
;	OCCURRED.  OTHERWISE HARDWARE ERROR (INABILITY TO SYNCH,
;	FOR INSTANCE) OCCURRED. IF THE BUFFER IS FULL BUT NO ERROR
;	IS REPORTED, THEN THE USER MAY ASSUME THAT IN THE ABSENCE
;	OF LF, 'Z, ETB, THAT THE LINE IS PARTIAL (THIS WILL OCCUR
;	FOR PARTIAL LINES TRANSMITTED BETWEEN HANDLERS HAVING THE
;	SAME BUFFER SIZES.

;	END OF FILE:

;	THIS HANDLER FOLLOWS VERSION THREE PRACTICE IN THAT END OF FILE
;	IS REPORTED ON AN EMPTY BUFFER.  IF END OF FILE OCCURS AT
;	THE END OF A PREVIOUS LINE (EMBEDDED IN THE LINE AS A CONTROL
;	Z) THEN THE LINE, INCLUDING THE CONTROL Z IS PASSED TO THE
;	INVOKER, AND END OF FILE IS REPORTED UPON THE NEXT INVOCATION
;	WITH A MEANINGLESS BUFFER BEING RETURNED.
.PAGE
;	SET OPTIONS:

;	AN ETBZ SET OPTION IS AVAILABLE.  NOETBZ WILL EXCLUDE "ETB" AND
;	CONTROL Z FROM THE RECEIVED BUFFER.

;	A BLOCKS SET OPTION IS AVAILABLE. BLOCKS WILL CAUSE THE HANDLER
;	TO TRANSMIT IN BLOCK MODE.  RECEPTION MODE IS AUTOMATICALLY
;	SELECTED BY DECODING THE FIRST NON-"ENQ" CHARACTER. IN THIS MODE
;	THE RECEIVER AND TRANSMITTER BUFFERS MUST BE IDENTICAL IN SIZE
;	AND A SIMPLE CHECK IS PERFORMED AT THE END OF EACH BLOCK
;	TRANSMITTED;THAT IS, AN "ETB" CHARACTER IS TRANSMITTED AS
;	A TRAILER BYTE.

;	A HYPHEN SET OPTION IS AVAILABLE. IN "HYPHEN" OPERATION THE
;	RECEIVER CONSIDERS THE "ETB" CHARACTER AS A HYPHENATING
;	CHARACTER AND DOES NOT RETURN TO INVOKER UPON RECEPTION OF
;	"ETB".  THIS IS USEFULL IN LINE MODE WHEN THE TRANSMITTING
;	BUFFER IS SMALL AND CANNOT CONTAIN THE LONGEST LINES, IN WHICH
;	CASE THE RECEIVER ACCUMULATES PARTIAL LINES UNTIL IT RECEIVES
;	AND ENTIRE LINE, SIGNIFIED BY "LF".
.PAGE
	.MCALL	.REGDEF,..V2..,.INTEN
	.MCALL	.DRBEG,.DRAST,.DREND,.DRFIN,.FORK,.QELDF
	.MCALL	.DRDEF
	.REGDEF
	..V2..

	MMG$T=1
;VECTOR AND DEVICE REGISTER ADDRESSES-EDIT THESE TWO TO RECONFIGURE
.IIF	NDF,HSVEC	HSVEC=300		;KEYBOARD VECTOR
.IIF	NDF,HSCSR	HSCSR=176500		;KEYBOARD CONTROL REGISTER
.IIF	NDF,MMG$T	MMG$T=0
.IIF	NDF,ERL$G	ERL$G=0
.IIF	NDF,TIM$IT	TIM$IT=0		;ASSUME TIMEOUT
.QELDF
HS$CSR=HSCSR
HS$VEC=HSVEC
;OTHER DEVICE ADDRESSES
	HPVEC=HSVEC+4		;PRINTER VECTOR
	HSBUF=HSCSR+2		;KEYBOARD BUFFER REGISTER
	HPCSR=HSCSR+4		;PRINTER CONTROL REGISTER
	HPBUF=HSCSR+6		;PRINTER BUFFER
	HS$BUF=HSBUF
	HP$VEC=HPVEC
	HP$CSR=HPCSR
	HP$BUF=HPBUF
;OTHER DEVICE CONSTANTS
	HSDSIZ=0
	SPECL$=10000
	HNDLR$=4000

.IIF	NDF,HSSTS	HSSTS=11+SPECL$+HNDLR$

;CONSTANTS
	OFFSET=270		;OFFSET TO MONITOR COMPLETION ENTRY
	ERROFF=272		;OFFSET TO SPUSR ERROR CODE IN RMON
	RMON=54			;LOCATION OF LOCATION OF RMON

	EOF=20000		;EOF BIT IN CSW
	PR7=340			;PSW VALUE FOR PRIORITY 7
	PR4=200			;PSW VALUE FOR PRIORITY 4
	CLOSE=1
	DELETE=2
	LOOKUP=3
	ENTER=4

	ETB=27
	HT=11			;TAB
	LF=12			;LINE FEED
	FF=14			;FORM FEED
	CR=15			;CARRIAGE RETURN=15
	CTRLU=25		;CTRL/U
	CTRLZ=32		;CTRL/Z
	CNTRLZ=32
	SPACE=40		;SPACE
	DELET=177		;RUBOUT
	ENQ=5
	ACK=6
	NAK=25
	STX=2

WCNT=Q.WCNT-Q.BLKN
BUFF=Q.BUFF-Q.BLKN
FUNC=Q.FUNC-Q.BLKN
CSW=Q.CSW-Q.BLKN
.PAGE
;	SET OPTIONS

.ASECT
.=400
	NOP
	.RAD50	/ETBZ  /
	.BYTE	<O.FL-400>/2
	.BYTE	200

	BEQ	Q.BR-ETB.R+.
	.RAD50	/HYPHEN/
	.BYTE	<O.HYP-400>/2
	.BYTE	200

	BR	BLK3-BLKSET+.
	.RAD50	/BLOCKS/
	.BYTE	<O.BLK-400>/2
	.BYTE	200

	.WORD	0

O.FL:	MOV	(PC)+,R3
	BR	STOP-Q.BR+.
	MOV	R3,Q.BR
	RTS	PC

O.HYP:	MOV	(PC)+,R3
	BEQ	HYPHEN-ETB.R+.
	MOV	R3,ETB.R
	RTS	PC

O.BLK:	MOV	(PC)+,R3
	BR	Q.BLK-BLKSET+.
	MOV	R3,BLKSET
	RTS	PC

	.CSECT

.PAGE
;THIS IS THE HANDLER HEADER AREA,USED BY FETCH AND THE
;QUEUE MANAGER TO STORE VARIABLES CRITICAL TO HANDLER OPERATION.

.DRDEF	HS,370,SPECL$,0,HSCSR,HSVEC
.DRBEG	HS

;FOLLOWING IS THE TRANSFER INITIATION CODE.
;THE FIRST WORD OF THIS ROUTINE IS THE ENTRY POINT FOR ALL
;TRANSFER REQUESTS.

	MOV	HSCQE,R4

	CLR	STEP			;CLEAR FLAGS AND RECEIVER
	CLR	STPFLG
	CLR	ETBFLG
	CLR	FIRST
	CLR	BLOCKS
	CLR	BLKSTR
	MOV	#8.,ERRCNT
	MOV	#512.,BLKCNT
	TSTB	@#HSBUF
	TST	EOFFLG
	BEQ	.+6
	JMP	ENDEOF

	CMPB	FUNC(R4),#CLOSE		;WHAT FUNCTION?
	BLO	1$
	BNE	2$

3$:	TST	SNDFLG			;IT WAS A CLOSE
	BEQ	STOP
	INC	SNDEOF
	BR	SEND

2$:	CLR	SNDFLG
	CMPB	FUNC(R4),#LOOKUP	;STILL, WHAT FUNCTION?
	BLOS	DONE
	DEC	SNDFLG
	BR	DONE

1$:	ASL	WCNT(R4)		;CHECK READ,WRITE,SEEK
	BCC	RECV
	BEQ	STOP

SEND:	MOV	#101,@#HSCSR
	BR	TALK

RECV:	MOV	WCNT(R4),R5
	.IF	EQ,MMG$T
	MOV	BUFF(R4),R4
1$:	CLRB	(R4)+			;ZERO RECEIVER BUFFER
	DEC	R5
	BNE	1$
	.IFF
	MOV	BUFF(R4),-(SP)		;SAVE THE ADDRESS
1$:	MOVB	#0,-(SP)		;PLACE A ZERO ON THE STACK
	CALL	@$PTBYT			;PUT IN USER BUFFER
	DEC	R5			;ONE LESS ON WORD COUNT
	BNE	1$			;LOOP IT
	MOV	(SP)+,BUFF(R4)		;RESTORE POINTER
	.ENDC
	JMP	HSIN
.PAGE
;THIS IS THE ABORT ENTRY POINT-THE HANDLER IS ENTERED AT THIS ADDRESS
;IF THE MONITOR RECIEVES A REQUEST TO ABORT ANY IO TRANSFER IN PROGRESS

;	BR	ABORT	PRODUCED BY .DRAST MACRO BELOW

;THIS IS THE TERMINAL OUTPUT INTERRUPT SERVICE.

	.DRAST	HP,4,ABORT

	CLRB	@#HPCSR		;CLEAR XMITTER, CHECK FLAGS
	MOV	HSCQE,R4
	TST	STPFLG
	BEQ	.+6
	JMP	BLKCHK
	TST	SNDFLG
	BEQ	RTSPC

.ENABL	LSB
TALK:	TST	ETBFLG		;CHECK FOR ETB, STEP #
	BNE	22$
	TST	STEP
	BNE	7$
	MOV	#ENQ,R5
	BR	SENDER

7$:	TST	SNDEOF
	BEQ	6$
	INC	STPFLG
	MOVB	#CNTRLZ,R5
	BR	SENDER
BLKSET:
6$:	BR	BLK3		;PLACE FOR BLOCKS SET OPTION
BLK2:				;BR	BLKSND IF BLOCKS SET
	DEC	BLKCNT		;WE RESYNCH EVERY 512. BYTES
	BNE	36$
	INC	ETBFLG
BLK3:
36$:	INC	WCNT(R4)	;CHECK WCNT,SPECIAL CHARACTERS
	BNE	15$
	INC	ETBFLG
15$:
	.IF	EQ,MMG$T
	MOVB	@BUFF(R4),R5	;GET A CHARACTER
	INC	BUFF(R4)	;POINT ONE AHEAD
	.IFF
	CALL	@$GTBYT		;GET A BYTE
	MOVB	(SP)+,R5	;AND SAVE IN R5
	.ENDC
	TST	BLKSTR		;SEE IF WE ARE IN BLOCK MODE
	BNE	SENDER
	BIC	#177600,R5
	BEQ	22$		;IF NULL, WE SEND "ETB" & STOP
	CMP	#CNTRLZ,R5
	BEQ	21$
	CMP	#LF,R5		;START NEW LINE AFTER LF
	BNE	SENDER
	CLR	STEP
	MOVB	#101,@#HSCSR	;START RECVR FOR NEW ACK
	BR	SENDER
22$:	MOVB	#ETB,R5
21$:	INC	STPFLG

SENDER:	MOVB	#100,@#HPCSR
	MOVB	R5,@#HPBUF	;SEND CHARACTER
RTSPC:	RTS	PC		;RETURN TO MONITOR
.DSABL	LSB
Q.BLK:	JMP	BLKSND
.PAGE
;REQUEST TERMINATION AND ABORT CODE
;THIS ROUTINE IS ENTERED WHEN THE I/O TRANSFER IS
;COMPLETED OR ABORTED. THE DEVICE INTERRUPTS ARE DISABLED,AND
;STANDARD MONITOR COMPLETION ENTRY CODE IS EXECUTED.
STOP:
ABORT:	CLR	@#HPCSR		;DISABLE OUTPUT INTERRUPTS
DONE:	CLR	@#HSCSR		;DISABLE INPUT INTERRUPTS
	CCC
	.DRFIN	HS


;	RECEIVER ERROR COUNTER

HARD:	DEC	ERRCNT
	BNE	HSIN
ERROR:	BIS	#1,@CSW(R4)
	BR	ABORT

;	RECEIVER END OF FILE REPORTER

ENDEOF:	CLR	EOFFLG
ENDFIL:	BIS	#EOF,@CSW(R4)
;	--------------SET OPTION----------------

;	BR	STOP here includes ^Z and ETB in buffer,
;	NOP will exclude them.  Command is SET HS NOETBZ.

Q.BR:	BR	STOP
	.IF	EQ,MMG$T
	CLRB	@BUFF(R4)
	.IFF
	MOV	BUFF(R4),-(SP)	;SAVE ADDRESS
	MOVB	#0,-(SP)	;STACK A ZERO
	CALL	@$PTBYT		;GIVE TO USER
	MOV	(SP)+,BUFF(R4)	;RESTORE ADDRESS
	.ENDC
	BR	STOP
;	------------------END-------------------

;	RECEIVER ETB CHECK, LAST CHARACTER AFTER STOP
;	DUE TO BUFFER FULL SHOULD BE ETB, CNTRLZ
;	OR WE HAVE BUFFER OVERFLOW.
.PAGE
;KEYBOARD INTERRUPT SERVICE
;THIS IS THE KEYBOARD INTERRUPT SERVICE ROUTINE. AFTER ENTERING
;SYSTEM STATE,IT GETS THE TYPED CHARACTER INTO R5,THEN
;PROCEEDS DOWN A CHAIN OF CHECKS FOR THE SPECIAL CASE CHARACTERS

	.DRAST	HS,4,ABORT

	TST	@#HSCSR		;CHECK ERRORS AND FLAGS
	BMI	HARD
	CLRB	@#HSCSR
	MOV	HSCQE,R4
	MOVB	@#HSBUF,R5
	TST	SNDFLG
	BNE	SNDCHK
	TST	STPFLG
	BNE	ETBCHK

LISTEN:	CMP	STEP,#1		;WHAT STEP?
	BHI	7$
	BEQ	11$

	CMPB	#ENQ,R5		;STEP 0, WAITING FOR "ENQ"
	BNE	HSIN
	MOVB	#100,@#HPCSR
	MOVB	#ACK,@#HPBUF
	INC	STEP
	BR	HSIN

11$:	CMPB	#ENQ,R5		;STEP 1, WAITING FOR NOT "ENQ"
	BEQ	HSIN
	INC	STEP
	CMPB	#STX,R5		;STEP 1A, LOOKING FOR STX TO
	BNE	7$		;SHIFT TO BLOCK MODE
	INC	BLOCKS
	BR	HSIN		;AND DO NOT PUT INTO BUFFER

7$:	DEC	WCNT(R4)	;STEP 2, FILLING BUFFER
	BNE	21$
	INC	STPFLG
21$:
	.IF	EQ,MMG$T
	MOVB	R5,@BUFF(R4)
	INC	BUFF(R4)
	.IFF
	MOVB	R5,-(SP)	;PLACE ON STACK
	CALL	@$PTBYT		;GIVE TO USER
	.ENDC
	TST	BLOCKS		;SEE IF WE ARE IN BLOCK MODE
	BNE	BLK4		;YES, SO RECEIVE ENTIRE BLOCK
	CMPB	#LF,R5
	BEQ	STOP
	CMPB	#ETB,R5
ETB.R:	BEQ	Q.BR		;PLACE FOR SET HYPHEN
	CMPB	#CNTRLZ,R5
	BNE	HSIN1
	TST	FIRST
	BEQ	ENDFIL
	INC	EOFFLG
	BR	Q.BR

BLK4:	DEC	BLKCNT
	BNE	HSIN1
	INC	STPFLG

HSIN1:	MOV	#1,FIRST
;	INC	BUFF(R4)
HSIN:	MOV	#101,@#HSCSR	;ENABLE KEYBOARD INTERRUPT
	RTS	PC		;RETURN TO MONITOR

SNDCHK:	CMPB	#ACK,R5		;WE ARE WAITING FOR ACK
	BNE	HARD
	INC	STEP
	RTS	PC

ETBCHK:	CMPB	#ETB,R5
	BEQ	1$
	JMP	ERROR
1$:	TST	BLOCKS
	BNE	BLKCHK
STOPIT:	JMP	STOP

HYPHEN:	CLR	STEP		;HERE "ETB" IS A HYPHENATING CHAR
	TST	STPFLG
	BNE	Q.BR
	BR	HSIN		;WE WAIT FOR SENDER TO SEND REST

BLKSND:	TST	BLKSTR		;CHECK FOR FIRST HEADER BYTE
	BEQ	.+6
	JMP	BLK2
	INC	BLKSTR		;SET INDICATOR AND SEND IT
	MOV	#STX,R5
	JMP	SENDER

BLKCHK:	MOV	#512.,BLKCNT
	TST	SNDEOF		;SEE IF WE HAVE JUST SENT EOF
	BEQ	1$		;NO
	CLR	SNDEOF
	BR	STOPIT

1$:	TST	WCNT(R4)	;SEE IF WE ARE DONE
	BEQ	STOPIT		;YES, NO MORE BYTE SPACE

	CLR	STEP		;SET UP TO SYNCHRONIZE AGAIN	
	CLR	ETBFLG
	CLR	STPFLG
	MOV	#8.,ERRCNT
	CLR	BLKSTR		;WE ARE NOW RESET

	TST	BLOCKS
	BNE	2$
	JMP	SEND		;SEND NEXT BLOCK
2$:	CLR	BLOCKS		;RECV NEXT BLOCK
	JMP	HSIN
.PAGE
;DATA AREA


;VARIABLE AREA

SNDEOF:	.WORD	0
EOFFLG:	.WORD	0
FIRST:	.WORD	0
ETBFLG:	.WORD	0
STPFLG:	.WORD	0
SNDFLG:	.WORD	0
STEP:	.WORD	0
ERRCNT:	.WORD	0
BLKSTR:	.WORD	0
BLOCKS:	.WORD	0
BLKCNT:	.WORD	512.

	.DRVTB	HS,HS$VEC,HSINT
	.DRVTB	,HP$VEC,HPINT

;MONITOR SYSTEM STATE ENTRY LINK
	.DREND	HS
	.END