Google
 

Trailing-Edge - PDP-10 Archives - BB-F492Z-DD_1986 - 10,7/703mon/fedser.mac
There are 6 other files named fedser.mac in the archive. Click here to see a list.
TITLE FEDSER - FRONT END DEVICE SERVICE ROUTINES V031
SUBTTL E. SOCCI/EVS			10 SEP 85
	SEARCH	F,S,DTEPRM

;NOTE:
; IF ANY CHANGES ARE MADE TO DTEPRM THAT DTESER MUST HAVE, UPDATE
; THE FOLLOWING SYMBOL TO THE VERSION OF DTEPRM THAT MUST BE USED
	PRMMIN==10
; THIS WAY, ASSEMBLING THIS MODULE WITH WRONG VERSION OF DTEPRM FOR SOME REASON
; (LIKE FORGETTING TO ASSEMBLE IT) WILL CAUSE ASSEMBLY TO TERMINATE
; THIS SCHEME DOES NOT CAUSE EXTRA EDITING, SINCE ONLY FILES
; WHICH NEED THE CHANGES NEED PRMMIN TO BE UPDATED. MODULES
; THAT DO NOT NEED A NEW VERSION OF DTEPRM NEED NOT DEMAND IT.

IFL VDTPRM-PRMMIN,<PRINTX ?PLEASE USE LATEST VERSION OF DTEPRM
			PASS2
			END>
	$RELOC
	$HIGH



;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
;  OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
.CPYRT<1976,1986>
;COPYRIGHT (C) 1976,1977,1978,1979,1980,1982,1984,1986
;BY DIGITAL EQUIPMENT CORP., MAYNARD, MASS.
;ALL RIGHTS RESERVED.
;
;
;DATE		LOAD	EDIT #
;____		____	______
;
;
XP VFEDSR,031

	SALL		;CLEAN MACRO EXPANSIONS
	ENTRY	FEDSER

FEDSER::
SUBTTL DTE. UUO FRONT END DEVICE FUNCTIONS


;FUNCTION TO GET FRONT END DEVICE
; ADDR/CPU#,,DTE#
; ADDR+1/FED UNIT #
;

FEDGET::PUSHJ	P,GETFEB	;GET FRONT END DEVICE BLOCK IN F FROM USER AREA
	  JRST	DTUNXF##	;FRONT END DEVICE DOES NOT EXIST
	LOAD.	T1,FE.JOB,(F)	;GET JOB OWNING THE FRONT END DEVICE
	JUMPN	T1,DTUFDB##	;SOMEONE ALREADY HAS IT
	PUSHJ	P,FEDCLR	;CLEAR OUT THE BITS IN FEDSTS FIRST
	STOR.	J,FE.JOB,(F)	;STORE OUR JOB NUMBER
	PUSHJ	P,FEDGTC	;ALLOCATE INPUT AND OUTPUT BUFFERS
	  POPJ	P,		;OOPS, COULDN'T DO IT
				; WAIT FOR EVENTUAL RELEASE
	JRST	CPOPJ1##	;RETURN

;FUNCTION TO RETURN A FRONT END DEVICE

FEDGIV::PUSHJ	P,GETFEB	;GET FRONT END DEVICE BLOCK IN F
	  JRST	DTUNXF##	;DOESN'T EXIST
	JSP	T4,FEJCHK	;MAKE SURE WE OWN IT
	PUSHJ	P,FEDCLR	;CLEAR OUT THE FRONT END DEVICE
	JRST	CPOPJ1##	;AND RETURN

;HERE FROM RESET. CHECK TO SEE IF THE JOB OWNS A FRONT END DEVICE,
; AND GIVE IT UP IF SO.

IFE FTMP,< ;SINGLE PROCESSORS DON'T HAVE TO SAVE SO MUCH
FEDRST::PUSHJ	P,SAVE2##	;SAVE P1,P2
>  ;IFE FTMP
IFN FTMP,< ;MULTI-CPU SYSTEMS DO TRIPLE LOOPS
FEDRST::PUSHJ	P,SAVE3##	;SAVE P1,P2,P3
	MOVEI	P3,CPUN##	;FOR EACH CPU
FEDRS4: > ;IFN FTMP
	MOVEI	P2,3		;SCAN 4 FRONT ENDS
FEDRS0:	MOVEI	P1,3		;AND 4 FRONT END DEVICES
FEDRS1:	MOVE	F,P2		;GET CPU#,,DTE# IN F FOR GETETD
IFN FTMP,<
	HRLI	F,-1(P3)	;P3 IS 1 HIGHER THAN CPU NO.
> ;IFN FTMP
	PUSHJ	P,GETETD##	;GET DTE CONTROL BLOCK ADDR FOR GETFE0
	  JRST	FEDRS3		;THIS FRONT END DOESN'T EXIST
	MOVE	T1,P1		;GET UNIT NUMBER IN T1
	PUSHJ	P,GETFE0	;GET THAT FRONT END BLOCK
	  JRST	FEDRS2		;DOESN'T EXIST
	LOAD.	T1,FE.JOB,(F)	;GET JOB OWNING IT
	CAMN	J,T1		;SAME AS THIS JOB?
	PUSHJ	P,FEDCLR	;YES, RELEASE THIS FRONT END DEVICE
FEDRS2:	SOJGE	P1,FEDRS1	;DO NEXT FRONT END DEVICE ON THIS FE
FEDRS3:	SOJGE	P2,FEDRS0	;DO NEXT FRONT END
IFN FTMP,<
	SOJG	P3,FEDRS4	;LOOP FOR NEXT CPU
> ;IFN FTMP
	POPJ	P,		;DONE
;ROUTINE TO DO ACTUAL RELEASE OF FRONT END DEVICE. CALLED FROM DTE.
; UUO, RESET UUO. CALL WITH FRONT END DEVICE BLOCK IN F.

FEDCLR:	SETZ	T1,		;CLEAR OUT JOB NUMBER
	STOR.	T1,FE.JOB,(F)	;IN FED BLOCK
	MOVE	T1,[FE.CLR]	;BITS TO CLEAR IN STATUS
	ANDCAM	T1,FEDSTS(F)	;CLEAR THEM
	PJRST	FEDRLC		;RELEASE BUFFER CORE AND RETURN
SUBTTL FRONT END DEVICE INPUT ROUTINES


FEDUIN::PUSHJ	P,SAVE4##
	PUSHJ	P,GETFEB	;GET FRONT END BLOCK ADDRESS IN F
	  JRST	DTUNXF##	;DOES NOT EXIST
	JSP	T4,FEJCHK	;MAKE SURE WE OWN THE FRONT END DEVICE IN QUESTION

	PUSHJ	P,GETWD1##	;GET BYTE COUNT,,ADDRESS
	HRRI	M,-1(T1)	;POINT TO WORD BEFORE THE ADDRESS
	HLRZ	P3,T1		;GET COUNT IN P3
	JUMPE	P3,DTUBCE##	;IF ZERO, ERROR IN BYTE COUNT
	MOVE	T2,P3		;GET 16 BIT BYTE COUNT
	ASH	T2,-1		;TURN INTO 36 BIT WORD COUNT
	TLZ	T1,-1		;C(T1) NOW HAS FIRST ADDRESS
	ADDI	T2,(T1)		;C(T2) NOW HAS LAST ADDRESS
	PUSHJ	P,TRNGE##	;MAKE SURE ITS ALL IN CORE
	MOVSI	T1,(FE.EOF)	;CLEAR END OF FILE FLAG
	ANDCAM	T1,FEDSTS(F)
	SETZ	P1,		;CLEAR COUNT OF BYTES GIVEN TO USER

FEDUI1:	MOVE	T3,FEDPPT(F)	;GET PUT POINTER
	CAMN	T3,FEDTPT(F)	;SEE IF SAME AS TAKE
	JRST	FEDUI2		;THEY ARE, NEED MORE DATA
	ILDB	T2,FEDTPT(F)	;GET A BYTE
	TRNN	P1,1		;GOES IN LH?
	JRST	[HRLZ	T1,T2	;YES
		 JRST	.+2]
	HRR	T1,T2		;NO, PUT IN RH WITH THE OTHER BYTE
	AOS	P1		;ONE MORE BYTE FOR USER
	TRNN	P1,1		;BACK TO A LH BYTE?
	PUSHJ	P,PUTWD1##	;YES, GIVE 2 BYTES TO THE USER
	CAMGE	P1,P3		;ITS NOT, HAVE WE GIVEN USER ALL HE ASKED FOR?
	JRST	FEDUI1		;NO, KEEP GIVING
	TRNE	P1,1		;YES, STILL KEEPING A LH BYTE IN T1?
	PUSHJ	P,PUTWD1##	;YES, STORE THE ODD BYTE
	JRST	CPOPJ1##	;RETURN TO USER WITH THE DATA IN HIS BUFFER.
FEDUI2:	PUSH	P,T1		;SAVE POSSIBLE BYTE IN LH(T1)
	SYSPIF			;MUST TURN OFF PI SO WE DON'T GET INPUT
				; DATA FOR FED WHILE UPDATING PUT POINTER
	PUSHJ	P,FEDSPT	;SETUP THE POINTERS AND FREE COUNT
	SYSPIN			;TURN PI BACK ON.
				; NOTE THAT FRONT END CAN NOW SEND DATA,
				; BEFORE WE SEND ACK THUS WE SEND ACK
				; WHEN LESS THAN WHOLE BUFFER IS AVAILABLE.
				; TO GET AROUND THIS, BUFFER SIZE IS TWICE
				; ALLOCATION
	PUSH	P,P1		;SAVE COUNT OF BYTES GIVEN TO USER
	PUSH	P,P3		;AND COUNT USER WANTS
	LOAD.	P1,FE.DTN,(F)	;GET DTE NUMBER OF THIS FE DEVICE
	LOAD.	T1,FE.CPN,(F)	;CPU #
	HRL	P1,T1		;CPU#,,DTE# IN P1
	LOAD.	T1,FE.UNI,(F)	;GET FRONT END UNIT NUMBER
	LSH	T1,^D35-^D15	;POSITION LINE NUMBER IN 1ST 16 BIT BYTE
	PUSH	P,T1		;SAVE IT SOMEWHERE
	MOVEI	P4,(P)		;GET ADDRESS OF DATA TO PUT INTO MSG IN P4
	HRLI	P4,(POINT 8,)	;MAKE INTO 8 BIT BYTE POINTER
	MOVEI	P3,2		;2 8 BIT BYTES TO COPY FOR LONG DIRECT MSG
	MOVE	P2,[.EMFED,,.EMACK]	;ACK TO FRONT END DEVICE
	MOVSI	S,CPOPJ##	;POST ADDRESS,,DATA
	PUSHJ	P,DTEQUE##	;ASK FOR DATA
	JRST	[ADJSP P,-4	;POP ALL THAT STUFF OFF STACK
		 JRST DTUCSM##]	;AND GIVE CAN'T SEND -11 MESSAGE ERROR
	POP	P,T1		;TAKE TEMPORARY PART OF MSG OFF STACK
	POP	P,P3		;AND USER'S SUPPLIED BYTE COUNT
	POP	P,P1		;AND COUNT GIVEN TO USER SO FAR
	PUSHJ	P,FEDWTI	;WAIT FOR THE BUFFER
	  JRST	FEDUI6		;OOPS, FATAL ERROR.
	POP	P,T1		;RESTORE POSSIBLE LH BYTE
	JRST	FEDUI1		;REJOIN LOOP AS IF BUFFER WAS INFINITE

FEDUI6:	POP	P,T1		;GET JUNK OFF STACK
	JRST	DTUFER##	;GO GIVE FATAL ERROR


;ROUTINE TO WAIT FOR FRONT END DEVICE INPUT BUFFER TO BECOME
; AVAILABLE. RETURNS CPOPJ1 IF IT IS, CPOPJ IF A FATAL ERROR
; HAS OCCURED IN THE FED.

FEDWTI:	MOVSI	T1,(FE.FER)	;HAS AN ERROR OCCURED?
	TDNE	T1,FEDSTS(F)
	POPJ	P,		;YES, GIVE THE ERROR RETURN.
	MOVE	T1,FEDTPT(F)	;GET TAKE POINTER
	CAME	T1,FEDPPT(F)	;NEED TO WAIT?
	JRST	CPOPJ1##	;NO, WE HAVE MORE DATA
	MOVEI	T1,EV.FEI	;FRONT END INPUT WAIT
	PUSHJ	P,ESLEEP##	;GO INTO EVENT WAIT, WAKE UP WHEN DATA IS READY
	JRST	FEDWTI		;MAKE SURE ALL IS OK

;HERE TO TAKE STRING DATA FOR A FRONT END DEVICE. P1-P4 SETUP BY
; DTESER TO BE THE STANDARD THINGS (SEE DTESER).

FEDTKD:	PUSHJ	P,FDIGET	;GET FED CONTROL BLOCK ADDRESS IN F
	LOAD.	T1,FE.JOB,(F)	;GET CONTROLLING JOB NUMBER
	JUMPE	T1,EATMSG##	;IF NONE, JUST EAT UP THE DATA
	HRRZ	T2,P3		;GET 8 BIT BYTE COUNT IN T2
				; IT HAD BETTER BE EVEN
	TRNE	T2,1		;BYTE COUNT EVEN? (SHOULD BE 16 BIT BYTES)
	JRST	FEDTKE		;NO, GIVE ERROR
	ASH	T2,-1		;CONVERT TO 16 BIT BYTE COUNT
	CAMLE	T2,FEDFBI(F)	;ENOUGH ROOM? (HAD BETTER BE OR ELSE
				; FRONT END IS PROBABLY SENDING TOO MUCH)
	JRST	FEDTKE		;YES TO EITHER, GIVE FATAL ERROR TO UUO
	MOVN	T3,T2		;GET COPY OF LENGTH OF MESSAGE
	ADDM	T3,FEDFBI(F)	;UPDATE COUNT OF FREE BYTES IN BUFFER
	MOVSI	S,FEDTDD	;THE POST PLACE
	MOVE	P4,FEDPPT(F)	;GET POINTER TO STORE DATA WITH
	ADJBP	T2,P4		;PUT POINTER TO NEXT PLACE TO STORE DATA
	MOVEM	T2,FEDPPT(F)
	POPJ	P,		;RETURN TO DTESER, WHO WILL DO INDIRECT
				; XFER.

;HERE IF THERE WAS A PROBLEM, GIVE UUO FATAL ERROR RETURN WHEN IT
; NEXT LOOKS.
FEDTKE:	MOVSI	T1,(FE.FER)	;YES TO EITHER, GIVE FATAL ERROR TO UUO
	IORM	T1,FEDSTS(F)	;SET BIT
	PUSHJ	P,FEDWKJ	;WAKE UP CORRECT JOB IF WAITING
	PJRST	EATMSG##	;EAT REMAINING DATA AND RETURN

;HERE WHEN DATA TRANSFER TO THE TO-10 BUFFER IS COMPLETE.

FEDTDD:	PUSHJ	P,FDIGET	;GET FED BLOCK FROM C(P2), C(P3)
				;FALL INTO FEDWKJ



;HERE TO REMOVE A JOB FROM EVENT WAIT ASSOCIATED WITH A FRONT END DEVICE IF IT
; EXISTS. CALL WITH FRONT END DEVICE BLOCK ADDRESS IN F.
; ALWAYS RETURNS CPOPJ.


FEDWKJ:	LOAD.	T1,FE.JOB,(F)	;GET JOB NUMBER OWNING THIS
	JUMPE	T1,CPOPJ##	;DO NOTHING IF THERE IS NONE
	PJRST	EWAKE##		;THERE IS ONE, WAKE THE JOB UP IF ITS WAITING FOR SOMETHING
SUBTTL FRONT END DEVICE OUTPUT ROUTINES


;HERE FROM DTESER ON FRONT END DEVICE OUTPUT FUNCTION OF DTE. UUO

FEDUOU::PUSHJ	P,SAVE4##	;WE WILL BE CALLING DTEQUE
	PUSHJ	P,GETFEB	;SETUP FED BLOCK ADDRESS IN F FROM USER ARGS
	  JRST	DTUNXF##	;NON-GOOD
	MOVE	P1,T1		;GETFEB RETURNS CPU#,,DTE# IN T1
				; SO SAVE IN P1 FOR MAKING MESSAGE LATER
	JSP	T4,FEJCHK	;DOES THIS GUY HAVE THE RIGHT?
				; IF NOT, GO AWAY AND GIVE HIM UUO ERROR RETURN


	PUSHJ	P,GETWD1##	;GET BYTE COUNT,,ADDRESS
	HLRZ	P3,T1		;GET 16 BIT BYTE COUNT IN P3
	HRRI	M,-1(T1)	;ADDRESS-1 IN RH(M) FOR GETWD1
	JUMPE	P3,DTUBCE##	;ZERO IS ERROR
	MOVE	T2,P3		;GET 16 BIT COUNT
	ASH	T2,-1		;MAKE 36 BIT COUNT
	TLZ	T1,-1		;FIRST ADDRESS
	ADDI	T2,(T1)		;MAKE IT LAST ADDRESS
	PUSHJ	P,TRNGE##	;MAKE SURE ALL PAGES ARE THERE

FEDUO2:	PUSHJ	P,FEDWTO	;WAIT FOR OUTPUT BUFFER TO BE OURS
	  JRST	DTUFER##	;SOMETHING HAPPENED . . .
	MOVE	P4,FEDOBF(F)	;ADDRESS TO PUT BYTES
	HRLI	P4,(POINT 16,)	;MAKE INTO A POINTER
	MOVE	P2,P3		;GET COPY OF COUNT FOR LOOP
	CAILE	P2,.FEOSZ	;IS COUNT BIGGER THAN A BUFFER?
				; (/2 BECAUSE BUFFER SIZE IS TWICE ALLOCATION)
	MOVEI	P2,.FEOSZ	;YES, JUST DO A BUFFER FULL NOW - 
	PUSH	P,P2		;SAVE COUNT OF DATA TO SEND OUT NOW

FEDUO3:	PUSHJ	P,GETWD1##	;GET 2 BYTES FROM USER
	HLRZ	T2,T1		;GET FIRST BYTE
	IDPB	T2,P4		;PUT INTO FED BUFFER
	SOJLE	P2,FEDU3A	;JUMP IF FINISHED
	IDPB	T1,P4		;PUT SECOND ONE INTO FED OUTPUT BUFFER
	SOJG	P2,FEDUO3	;LOOP UNTIL USER DATA EXHAUSTED

FEDU3A:	EXCH	P3,(P)		;SAVE TOTAL COUNT, GET COUNT FOR THIS OUTPUT
	ASH	P3,1		;MAKE THIS # 8 BIT BYTES FOR DTESER
	LOAD.	T1,FE.UNI,(F)	;GET UNIT NUMBER OF THIS FRONT END DEVICE
	HRL	P3,T1		;UNIT,,COUNT
	MOVE	P4,FEDOBF(F)	;GET ADDRESS OF BUFFER
	HRLI	P4,(POINT 16,)	;MAKE IT BYTE POINTER
	MOVE	P2,[.EMFED,,EM.16B+EM.IND+.EMSTR]	;DEVICE,,FN
				;P1 WAS SETUP AT VERY BEGINNING
	MOVSI	S,CPOPJ##	;NO POST, WAIT FOR THE ACK THATS COMING
	MOVSI	T1,(FE.OAE)	;GIVE UP THE BUFFER, MAKING THE NEXT UUO BLOCK
	IORM	T1,FEDSTS(F)	;
	PUSHJ	P,DTEQUE##	;SEND THE DATA TO THE -11
	  JRST	[POP P,P3	;GET P3 BACK OFF STACK
		 JRST DTUCSM##]	;CAN'T SEND -11 MESSAGE
	POP	P,P3		;RESTORE COUNT OF BYTES LEFT TO BE DONE
	SUBI	P3,.FEOSZ	;WE'VE JUST DONE LESS THAN OR EQUAL TO A
				; WHOLE BUFFER - ANY BYTES LEFT TO DO?
	JUMPG	P3,FEDUO2	;YES, GO DO THEM
	JRST	CPOPJ1##	;NO, RETURN TO USER RIGHT AWAY, LETTING HIM
				; FILL ANOTHER BUFFER


;ROUTINE TO WAIT FOR OUTPUT BUFFER TO FREE UP
; SKIP RETURN WHEN OUTPUT BUFFER IS READY, NON-SKIP IF FATAL ERROR FLAG
; IS UP.

FEDWTO:	MOVSI	T1,(FE.FER)	;CHECK FOR FATAL ERROR
	TDNE	T1,FEDSTS(F)	;?
	PJRST	DTUFER##	;YEAH, GOODBYE.
	MOVSI	T1,(FE.OAE)	;CAN WE STUFF OUTPUT BUFFER WITH DATA?
	TDNN	T1,FEDSTS(F)	;?
	JRST	CPOPJ1##	;YES, GIVE SKIP RETURN
	MOVEI	T1,EV.FEO	;NO, GO INTO OUTPUT WAIT
	PUSHJ	P,ESLEEP##	;ZZZZ
	JRST	FEDWTO		;MAKE SURE EVERYTHING IS OK
;HERE WHEN THE 11 CAN ACCEPT MORE DATA FOR A FRONT END DEVICE
; (ACK)

FEDACK:	ILDB	T1,P4		;GET LINE NUMBER
	IBP	P4		;ADVANCE PAST BLANK BYTE
	SUBI	P3,2		;REMEMBER WE'VE TAKEN 2 BYTES
	PUSHJ	P,FDIGT0	;GET FED BLOCK ADDRESS IN F
	MOVSI	T1,(FE.OAE)	;MAKE OUTPUT BUFFER AVAILABLE TO UUO AGAIN
	ANDCAM	T1,FEDSTS(F)
	PUSHJ	P,FEDWKJ	;AND WAKE UP THE JOB IF ITS SLEEPING
	JUMPN	P3,FEDACK	;LOOP IF MORE ACKS ARE IN THIS MESSAGE
	POPJ	P,		;ALL DONE


;HERE ON ACK ALL - IF SOMEONE IS USING A FRONT END DEVICE, GIVE HIM
; AN ERROR

FEDAAL:	LOAD.	F,ED.FED,(F)	;GET FIRST FRONT END DEVICE ADDRESS
FEDAA1:	JUMPE	F,CPOPJ##	;DONE
	LOAD.	T1,FE.JOB,(F)	;GET JOB #, IF ANY
	JUMPE	T1,FEDAA2	;NO JOB OWNS IT, GET NEXT FED ON THIS FE
	MOVSI	T1,(FE.FER)	;SOMEONE IS USING, GIVE HIM THE FINGER
	IORM	T1,FEDSTS(F)	;
	PUSHJ	P,FEDWKJ	;RUDE AWAKENING
FEDAA2:	LOAD.	F,FE.LNK,(F)	;GET NEXT ADDRESS
	JRST	FEDAA1		;AND LOOP FOR ALL FRONT END DEVICES ON THIS DTE


SUBTTL FRONT END DEVICE STATUS HANDLING

;HERE ON DTE. UUO THAT OBTAINS STATUS
;ADDR/CPU#,,DTE#
;ADDR+1/FE DEVICE #
; USER GETS STATUS OF FRONT END DEVICE RETURNED IN HIS AC.


FEDUGS::PUSHJ	P,GETFEB	;GET FED BLOCK FROM USER ARGS
	  JRST	DTUNXF##	;SORRY
	JSP	T4,FEJCHK	;MAKE SURE HE OWNS THE FE DEVICE
	MOVE	T2,FEDSTS(F)	;GET STATUS WORD
	SETZ	T1,		;PREPARE RESULT

	TLNE	T2,(FE.EOF)	;EOF?
	TRO	T1,EM.EOF	;YES
	TLNE	T2,(FE.FER)	;FATAL ERROR?
	TRO	T1,EM.FER	;YES
	JRST	STOTC1##	;RETURN RESULT IN T1


;HERE FOR DTE. UUO FUNCTION TO SET FRONT END DEVICE STATUS
;ADDR/CPU#,,DTE#
;ADDR+1/FE DEVICE #
;ADDR+2/STATUS

FEDUSS::PUSHJ	P,SAVE4##	;WE WILL BE CALLING DTEQUE
	PUSHJ	P,GETFEB	;GET FRONT END DEVICE BLOCK, AS USUAL
	  JRST	DTUNXF##
	JSP	T4,FEJCHK	;MAKE SURE HE OWNS THE FE DEVICE
	PUSHJ	P,GETWD1##	;GET THE STATUS SETTING DESIRED
	DPB	T1,[POINT 16,FEDSOB(F),15]	;PUT INTO THE MESSAGE
	MOVEI	P4,FEDSOB(F)	;GET ADDRESS OF INDIRECT DATA
	HRLI	P4,(POINT 16,)	;MAKE INTO A BYTE POINTER
	LOAD.	T1,FE.UNI,(F)	;GET UNIT NUMBER OF FRONT END DEVICE
	HRL	P3,T1		;SETUP UNIT # IN LH(P3)
	HRRI	P3,.FESMS*2	;# 8 BIT BYTES IN THE INDIRECT MESSAGE
	MOVE	P2,[.EMFED,,EM.16B+EM.IND+.EMHDS] ;HERE IS DEVICE STATUS, 16 BIT STYLE
	LOAD.	P1,FE.DTN,(F)	;GET DTE #
	LOAD.	T1,FE.CPN,(F)	;CPU #
	HRL	P1,T1		;CPU#,,DTE# IN P1
	MOVSI	S,CPOPJ##	;FORGET ABOUT POST
	PUSHJ	P,DTEQUE##	;SEND THE STATUS
	  JRST	DTUCSM##	;CAN'T SEND -11 MESSAGE
	JRST	CPOPJ1##	;RETURN
;HERE TO TAKE STATUS OF A FRONT END DEVICE FROM THE -11
;	(DTESER HAS ALREADY RECEIVED IT)

FEDTKS:	PUSHJ	P,FDIGET	;GET FED BLOCK IN F
	ILDB	T1,P4		;GET GOOD INFO
	MOVSI	T2,(FE.EOF)	;EOF BIT WILL BE SET OR CLEARED
	TRNE	T1,EM.EOF	;EOF BIT ON?
	IORM	T2,FEDSTS(F)	;YES, SET EOF IN THE BLOCK
	MOVSI	T2,(FE.FER)	;DO SAME FOR FATAL ERROR BIT
	TRNE	T1,EM.FER	;FATAL ERROR?
	IORM	T2,FEDSTS(F)	;YES, SET THE FATAL ERROR BIT IN STATUS
	PJRST	EATMSG##	;EAT UP REMAINING INDIRECT DATA
;ROUTINE TO GET FRONT END DEVICE BLOCK IN F FROM USER
; ARGUMENTS TO DTE. UUO
; USER ADDR+1/CPU#,,DTE#
; USER ADDR+2/FE DEVICE UNIT #
; SKIP RETURN IF OK, NON-SKIP IF SOMETHING WAS WRONG
; WITH CPU#,,DTE# IN T1

GETFEB:	PUSHJ	P,DTUGTF##	;CHECK AND GET CPU#,,DTE# IN T1
	PUSH	P,T1		;SAVE CPU#,,DTE#
	PUSHJ	P,GETWD1##	;GET FE DEVICE UNIT #
	CAILE	T1,.FEMXU	;LEGAL UNIT NUMBER?
	JRST	TPOPJ##		;NO, ERROR RETURN
	PUSHJ	P,GETFE0	;YES, GO GET THE BLOCK
	  JRST	TPOPJ##		;DOESN'T EXIST
	JRST	TPOPJ1##	;RETURN WITH CPU#,,DTE# IN T1

;THIS ROUTINE IS FOR DRIVER INTERRUPT LEVEL TO GET THE FED ADDRESS IN F.
; CALL WITH CPU#,,DTE# IN P1, FED UNIT NUMBER IN LH(P3)
; ALWAYS RETURNS CPOPJ, IF FED DOESNT EXIST, STOPCD.

FDIGET:	HLRZ	T1,P3		;GET FED UNIT


;ENTER HERE WITH UNIT # IN T1, CPU#,,DTE# IN P1

FDIGT0:	MOVE	F,P1		;GET CPU#,,DTE# IN F
	PUSH	P,T1		;SAVE FED UNIT NUMBER
	PUSHJ	P,GTETDS##	;GET DTE CONTROL BLOCK ADDR OR DIE
	POP	P,T1		;RESTORE FED UNIT NUMBER
	PUSHJ	P,GETFE0	;GET THE BLOCK OR
	  STOPCD .,STOP,NFB,	;++NO FRONT END DEVICE BLOCK
	SALL
	POPJ	P,		;OK, RETURN



;HERE WITH FED UNIT NUMBER IN T1, DTE CONTROL BLOCK ADDR IN F
; RETURN CPOPJ1 WITH FED BLOCK ADDRESS IN F, OR CPOPJ IF ERROR.

GETFE0:	LOAD.	F,ED.FED,(F)	;GET FIRST FEB ADDRESS ON THIS FRONT END
GETFE1:	JUMPE	F,CPOPJ##	;END OF CHAIN, GIVE ERROR RETURN
	LOAD.	T3,FE.UNI,(F)	;GET UNIT NUMBER OF THIS FE DEVICE
	CAMN	T1,T3		;THIS THE ONE?
	JRST	CPOPJ1##	;YES, RETURN WITH FEB ADDRESS IN F
	LOAD.	F,FE.LNK,(F)	;NO, GET NEXT ADDRESS
	JRST	GETFE1		;AND KEEP LOOKING



SUBTTL CORE ALLOCATION

;ROUTINE TO SETUP INPUT AND OUTPUT BUFFERS FOR FED. CALLED
; WHEN JOB GETS FED. CALL WITH C(F) = FED BLOCK. NON-SKIP
; WITH CORRECT ERROR CODE IN T1 IF NO CORE AVAILABLE, SKIP
; RETURN IF ALL OK.

FEDGTC:	MOVEI	T2,<.FEISZ+<^D36/^D16-1>>/<^D36/^D16>
				;GET NUMBER OF WORDS IN FED BUFFER, ROUNDED UP
	PUSHJ	P,GETWDS##	;GET THAT MANY FOR INPUT BUFFER
	  PJRST	DTUNFC##	;NO FREE CORE, GIVE ERROR RETURN
	MOVEM	T1,FEDIBF(F)	;OK, SAVE ADDRESS
	MOVEI	T2,<.FEOSZ+<^D36/^D16-1>>/<^D36/^D16>
				;GET NUMBER OF WORDS IN FED BUFFER, ROUNDED UP
	PUSHJ	P,GETWDS##	;GET CORE FOR OUTPUT BUFFER NOW
	  PJRST	DTUNFC##	;LOSE
	MOVEM	T1,FEDOBF(F)	;SAVE THAT TOO
	JRST	CPOPJ1##	;OK RETURN


;ROUTINE TO GIVE BACK FED BUFFER CORE. ALWAYS NON-SKIP RETURN.
; IGNORE IF NO BUFFERS TO GIVE BACK.

FEDRLC:	MOVEI	T1,<.FEISZ+<^D36/^D16-1>>/<^D36/^D16>
				;GET NUMBER OF WORDS IN FED BUFFER, ROUNDED UP
	SKIPE	T2,FEDIBF(F)	;GET ADDRESS
	PUSHJ	P,GIVWDS##	;GIVE BACK THE INPUT BUFFER
	SETZM	FEDIBF(F)	;OK, NO MORE INPUT BUFFER
	MOVEI	T1,<.FEOSZ+<^D36/^D16-1>>/<^D36/^D16>
				;GET NUMBER OF WORDS IN FED BUFFER, ROUNDED UP
	SKIPE	T2,FEDOBF(F)	;GET ADDRESS
	PUSHJ	P,GIVWDS##	;GET RID OF OUTPUT BUFFER
	SETZM	FEDOBF(F)	;SAY NO MORE BUFFER
	POPJ	P,		;RETURN
SUBTTL UTILITY ROUTINES


;ROUTINE TO CHECK TO SEE IF A JOB OWNS A FRONT END DEVICE, RETURN
; TO NEXT LEVEL IF NOT.  CALL:
;	MOVE	J,<JOB>
;	MOVE	F,<FED BLOCK ADDRESS>
;	JSP	T4,FEJCHK
;	<RETURN IF JOB OWNS FRONT END DEVICE>


FEJCHK:	LOAD.	T1,FE.JOB,(F)
	CAME	J,T1		;DOES JOB OWN THIS FRONT END DEVICE?
	JRST	DTUDOF##	;NO, GIVE ERROR (AND POPJ BACK TO UPPER LEVEL)
	JRST	(T4)		;YES, RETURN TO CALLER


;ROUTINE TO SETUP PUT AND TAKE POINTERS, AND FREE BYTES IN
; FED INPUT BUFFER. CALLED AT FED INITIALIZATION TIME AFTER
; BUFFERS HAVE BEEN ALLOCATED, AND JUST BEFORE AN ACK IS SENT TO
; THE -11. CALL WITH FED BLOCK ADDRESS IN F


FEDSPT:	MOVE	T1,FEDIBF(F)	;SETUP INITIAL INPUT BUFFER POINTER
	HRLI	T1,(POINT 16,)	;MAKE IT A POINTER
	MOVEM	T1,FEDTPT(F)	;SETUP TAKE POINTER
	MOVEM	T1,FEDPPT(F)	;AND PUT POINTER
	MOVEI	T1,.FEISZ	;SETUP NUMBER OF BYTES IN BUFFER FREE
	MOVEM	T1,FEDFBI(F)	;FREE BYTES IN INPUT BUFFER
	POPJ	P,		;RETURN
SUBTTL INTERRUPT LEVEL ROUTINES


;PROTOCOL FUNCTION DISPATCH TABLE

	CPOPJ##			;(-1)INTERNAL FUNCTION FOR TO-10 MESSAGE RUINED
FEDDSP::EATMSG##		;(0)
	EATMSG##		;(1)
	EATMSG##		;(2)
	FEDTKD			;(3)HERE IS STRING DATA
	EATMSG##		;(4)
	EATMSG##		;(5)
	EATMSG##		;(6)
	FEDTKS			;(7)HERE IS DEVICE STATUS
	EATMSG##		;(10)
	EATMSG##		;(11)
	EATMSG##		;(12)
	EATMSG##		;(13)
	EATMSG##		;(14)
	EATMSG##		;(15)
	EATMSG##		;(16)
	FEDACK			;(17)ACK
	EATMSG##		;(20)
	EATMSG##		;(21)
	EATMSG##		;(22)
	EATMSG##		;(23)
	EATMSG##		;(24)
	FEDAAL			;(25)ACK ALL
	EATMSG##		;(26)
	EATMSG##		;(27)
	EATMSG##		;(30)
	EATMSG##		;(31)
	EATMSG##		;(32)
	EATMSG##		;(33)
	EATMSG##		;(34)

	END