.TITLE	CMDRV
	.IDENT	/V5/	;15-DEC-78

	.SBTTL	CAMAC DRIVER FOR RSX11M
;
 ;
; MODIFICATIONS
;

; D.B.CURTIS MADE MODS TO GO TO VERSION 5


; IF G$$WRD OR P$$WRD NOT DEFINED ERRORS WILL BE PRODUCED
; THIS DRIVER USES THEM AND THEY MUST BE SPECIFIED AT SYSGEN TIME

	.PAGE

;+
;
; THIS IS A CAMAC DRIVER FOR RSX11M. IT HAS THE FOLLOWING FUNCTIONS:
;
; ALL OF THE FUNCTIONS DEFINED BELOW MAY HAVE A SUBFUNCTION FIELD SET
;	THE STRUCTURE OF THE SUBFUNCTION FIELD IS:
;
;	BIT 0-2=	SUBFUNCTION
;	BIT 3-6=	IO STATUS WORD 2 SELECT
;	BIT 7  =	SUPRESS SELECT ERROR MESSAGE
;
; THE USER SHOULD NOT PLACE INFORMATION IN THE SUBFUNCTION FIELD
; THE USER MAY SELECT ANY OF THE FOLLOWING  CODES TO RETURN INFORMATION
; IS THE SECOND WORD OF THE IO STATUS BLOCK:
;
;	CM.CSR=00		CONTROL STATUS REGISTER (DEFAULT)
;	CM.FNA=10		READ FNA WORD (RETURNS ONLINE CRATES AND N AND A
;	CM.CS =20		CRATE SELECT WORD COUNT WORD
;	CM.EWC=30		EXTENDED WORD COUNT
;	CM.ASM=40		BIT ENCODED WORD INDICATING ASSEMBLY OPTIONS
;	CM.TOP=50		RETURNS THE FIRST FREE BYTE (AS AN OFFSET INTO T
;				 OF THE LAST OPERATION OF A CHAIN
;
;
;
; THE USER MAY SET CM.NMS TO INDICATE THAT NO ERROR DISPLAY IS TO BE PRINTED
; ON THE CONSULE TERMINAL WHEN AN X RESPONCE IS MISSING
;
;
;	FUNCTION	MODIFIER
;
;	0=IO.KIL
;	1=WRITE
;			0=PROGRAMED DATA WRITE
;			2=NON DATA TRANSFER
;	2=READ
;			0=PROGRAMMED DATA READ
;			1=BRANCH DRIVER REGISTER READ
;	3=ATTACH
;	4=DETATCH
;	6=DMA TRANSFER
;			0=NORMAL OPERATION
;			1=LIST PROCESSING
;	7-31=ILLEGAL
;

; THE DRIVER IS WRITTEN FOR A EGG BD-011 BRANCH DRIVER
;WITH THE EXTENDED WORD COUNT MODIFICATION.
;IT ALSO SUPPORTS THE JORWAY BRANCH DRIVER INCLUDING EXTENDED
;MEMORY SUPPORT. THIS IS SELECTED BY DEFINING JORW.

; DMA TRANSFERS MUST BE SENT TO AN ODD UNIT, NON DMA TRNASFERS MUST
;BE SENT TO AN EVEN UNIT. IF AN ATTEMPT IS MADE TO ACCESS A NON EXISTANT
;MODULE AND CM.NMS IS NOT SET, A SELECT ERROR MESSAGE WILL BE DISPLAYED
;ON THE CONSULE TERMINAL.
;IF A DEVICE NOT READY IS EVER PRINTED OUT, THE
;BD-011 IS SICK AND THE COMPUTING HARDWARE
;PEOPLE SHOULD BE CONTACTED. THE ONLY SUCCESSFULL ERROR RETURN IS IS.SUC.

; THE ERROR RETURNS OCCURE IN THE FIRST BYTE OF THE IOSW.
;THE SECOND BYTE CONTAINS STATUS INFO
;UNLESS A LIST PROCESSING FUNCTION IS SPECIFIED,
;IN WHICH CASE, IT CONTAINS THE NUMBER OF THE LAST OPERATION ATTEMPTED.

; THE STATIS INFO HAS THE FOLLOWING FORMAT
;
;	BIT 0= Q STATUS
;	BIT 1= X STATUS
;	BIT 2= ABORT
;	BIT 3= CRATE OVERRUN
;	BIT 4= T02 CAMAC TIMEOUT
;	BIT 5= T01
;


;THE SECOND WORD CONTAINS INFORMATION SELECTED BY THE USER.
;IN THE DEFAULT CASE, IT CONTAINS THE CONTENTS OF THE CSW OF THE DRIVER
;AT COMPLEATION OF AN ATTEMPT TO EXECUTE A FUNCTION.

;THE ERROR RETURNS ARE
;IE.VER WHICH IS UNRECOVERABLE ERROR AND
;OCCURES IF THERE IS A BD-011 TIMEOUT. (IE THE CRATE
;IS OFFLINE OR THERE ISN'T ANY MOUDULE IN THE SELECTED STATION)

;IE.BAD WHICH IS BAD PARAMITER AND OCCURES IF AN ATTEMPT WAS
;MADE TO DO A DMA TO UNIT 0 OR A NON DMA TO UNIT 1.

;IE.ONP WHICH IS ILLEGAL SUBFUNCTION AND OCCURES IF THE
;SUBFUNCTIONS FOR FUNCTION 1, 2,  AND 6 ARE INCORRECT.
; THIS ERROR IS ALSO GENERATED IF THE DATA FOR THE CAMAC (IE FNA CODE)
; IS INCOMPATABLE WITH THE DRIVER FUNCTION

;-
	.PAGE
;
;MACRO LIBRARY CALLS
;
	.MCALL	ABODF$,DEVDF$,HWDDF$,PKTDF$,TCBDF$,IOERR$
	ABODF$
	DEVDF$
	HWDDF$
	PKTDF$
	TCBDF$
	IOERR$


;+
; USER DEFINED OFFSETS IN THE UCB
;
U.RTSE=U.CNT+2
U.RTUN=U.CNT+4
U.ST1R=U.CNT+6
.IF DF	LSTPDV
LPD=U.CNT+10
U.EEND=LPD+0
U.FLAG=LPD+2
U.DBBR=LPD+4
U.LNPR=LPD+6
U.CBSZ=LPD+12
U.CBRL=LPD+14
U.COPC=LPD+20
U.REPT=LPD+22
U.BYTR=LPD+24
U.EXWC=LPD+26
.ENDC
;
;	U.RTSE IS THE OFFSET FOR THE DISPATCH TABLE TO PLACE A VALUE INTO
;		U.RTUN
;
;	U.RTUN IS THE LOCATION OF THE RETURN VALUE FOR THE SECOND WORD IN THE
;		IO STATUS BLOCK
;
;	U.ST1R HIGH BYTE IS WHERE THE NUMBER OF ITEMS ON THE LIST THAT
;		HAVE ATTEMPTED TO RUN IS KEPT
;

;+
; THE CAMAC FUNCTION CODES HAVE THE FOLLOWING NMUNONICS:

;
IO.CPW=400	;IO.CPW=CAMAC PROGRAMMED DATA WRITE
IO.ELM=401	;IO.ELM=ENABLE LAM RECOGNITION (THIS IS CURRENTLY DISALBED)
IO.NDT=402	;IO.NDT=NON DATA TRANSFER
IO.CPR=1000	;IO.CPR=CAMAC PROGRAMMED READ
IO.CRR=1001	;IO.CRR=CAMAC REGISTER READ
IO.CDM=3000	;IO.CDM=CAMAC DMA TRANSFER
IO.LPR=3001	;IO.LPR=CAMAC LIST PROCESSING
CM.NMS=200	;CM.NMS=DONOT ALLOW DEVICE SELECT ERROR MESSAGES

;
; INDICATE ASSEMBLY PARAMITERS THAT SHOULD BE PLACED IN RSXMC
;
; IF LOADABLE DRIVER LD$CM=0
;
; IF LIST PROCESSING DRIVER LSTPDV=0
;
;
; PRIORITY OF INTERFACE PL=PR4
; DEFAULT IS PR4
;
; C$$M11=NUMBER OF CAMAC INTERFACES
;
; JORW=0 IF JORWAY J411 INTERFACE ELSE EGG ASSUMED
;

.IIF NDF PL	PL=PR4

;
; ERROR RETURNS  (MAPPING FROM LITERALS IN ROUTINE TO TYPICAL RETURNS)
;

IE.END=IE.DAO		;IF CNA CHECK DOES NOT WORK SET DATA OVERUN

IE.CVF=IE.RBG		;IF UNEXPECTED CRATE OVERFLOW, SET ILLEGEAL RECORD SIZE

IE.IMP=IE.VER		;IF IMPOSSABLE ERROR, SET PARITY ERROR

IE.CT2=IE.RCN		;IF CAMAC TIME OUT DECIDE ILLEGAL RECORD NUMBER

IE.JER=IE.FHE		;IF CALCULATED ADDRESS NOT EQUEAL TO REAL 18 BIT
			;SET FATEL HARDWARE ERROR
			;THIS ERROR ALSO SETS UNIT OFFLINE UNLESS US.OFL IS SET

IE.OVR=IE.SPC		;THIS ERROR OCCURES IF AN ATTEMPT IS MADE TO ACCESS
			;OUTSIDE THE DATA BUFFER


;+
; LOCAL DATA BITS AND OFFSETS AND SPECIAL ASSEMBLY PARAMITERS ARE:
;

BUFOF=1		;BUFOF, WHICH INDICATES THAT A COP HAS A BUFFER OFFSET

REP=4		;REP, WHICHS INDICATES THAT A COP HAS A REPEAT COUNT

CNACK=2		;CNACK, WHICH INDICATES THAT AN ENDING CRATE STATION ADDRESS
		;CHECK IS REQUESTED

WCOFOK=40	;WORDCOUNT OVERFLOW OK IS USED TO INDICATE THAT THE COP
		;SHOULD BE MODIFIED IF IT ATTEMPTS TO ACCESS PAST THE END
		;OF THE DATA BUFFER

CRTOK=200	;CRTOK, WHICH INDICATES THAT A CRATE OVERFLOW IS OK FOR THIS COP

T02OK=100	;T02OK, WHICH INDICATES THAT A CAMAC TIME OUT IS OK FOR THIS COP

DMA=4		;DMA, WHICH SHOWES THAT A DMA OPERATION WAS THE LAST
		;OPERATION THAT COMPLETED.

LSTP=2		;LSTP, WHICH IS USED TO SHOW THAT A CONTROLLER IS IN THE LIST
		;PROCESSING STATE

FIRST=10	;FIRST, WHICH SHOWS THAT SOME ADDRESS INITALIZATION MUST BE
		;DONE FOR LIST PROCESSING

LODAD=20	;LODAD, SHOWS THAT J411 MUST HAVE A NEW ADDRESS GENERATED

T02=2000	;T02, WHICH IS THE CAMAC TIME OUT BIT OF THE CSR

COVF=1000	;COVF, WHICH IS THE CRATE OVERFLOWT OF THE CSR

MD24=40000	;MD24, WHICH IS THE 24 BIT MODE OF THE FNA REGISTER.

MADR=4		;MADR, WHICH IS THE OFFSET FOR THE MEMORY ADDRESS
		;REGISTER.

DATA=2		;DATA, WHICH IS THE OFFSET FOR THE DATA REGISTER.

XTEND=12	;XTEND, WHICH IS THE OFFSET FOR THE EXTENDED
		;WORD COUNT REGISTER.

FNA=10		;FNA, WHICH IS THE OFFSET FOR THE FUNCTION, STATION,
		;AND ADDRESS REGISTER.

CRAT=6		;CRAT, WHICH IS THE OFFSET FOR THE CRATE SELECT.

;US.OFL=0	; UNCOMMENT THIS TO STOP THE DISABLEMENT OF THE NPR
		;PART OF THE INTERFACE WHEN IT HAS HARDWARE ADDRESSING ERRORS

SELER=0		;SELER, WHICH IS A CONDITIONAL TO ALLOW (IF DEFINED)
		;SELECT ERRORS TO BE SENT TO THE CONSUL

MAXOPR=2*4	; THIS SETS THE MAXAMUN NUMBER OF TYPES OF STATUSRETURNS
		;ALLOWED
.IIF DF LSTPDV	MAXOPR=MAXOPR+<2*1>	;IF LIST PROCESSING ONE MORE TYPE OF RET

RTFLD=170	;THIS DEFINES THE FIELD OF THE SUBFUNCTION THAT CONTAINS THE
		;RETURN CODE SELECT

;-
	.PAGE
;
; CHECK FOR GETWORD AND PUTWORD
;
	.IIF NDF	G$$WRD, .ERROR; GETWORD MUST BE SELECTED
	.IIF NDF	P$$WRD, .ERROR; PUTWORD MUST BE DEFINED
	.IF DF		LSTPDV
	.IIF NDF	M$$MGE, .ERROR; MEMORY MANAGEMENT MUST BE USED ON
	.IIF NDF	JORW, .ERROR;  LIST PROCESSING DRIVER
	.IIF NDF	A$$CHK, .ERROR; ADDRESS CHECKING REQUIRED
	.ENDC

;
; GENERATE A WORD THAT SHOWES WHICH OPTIONS HAVE BEEN SELECTED
;


TMP=0
.IIF DF JORW	TMP=TMP!4
.IIF DF LSTPDV	TMP=TMP!2
.IIF DF SELER	TMP=TMP!1

DRVTYP:	.WORD	TMP

;
CNTBL:	.BLKW	C$$M11	;THIS IS USED TO STORE UCB ADDRESS FOR INTERUPT ROUTINE

	.IF GT	C$$M11-1

TEMP:	.BLKW	1

	.ENDC
;
;DRIVER DISPATCH TABLE
;
$CMTBL:: .WORD  CMINI
	.WORD	CMCAN
	.WORD	CMOUT
	.WORD	CMPWF
;
;+
; THE POWER FAIL ROUTINE CMPWF IS ENTERED AT SYSTEM STARTUP AND AFTER
;RECOVERING FROM A POWER OUTAGE.
;ON ENTRY R3-R5 CONTAINE INFORMATION.
;
;	R3=CONTROLER INDEX
;	R4=SCB ADDRESS
;	R5=UCB ADDRESS
;
;-
				;THE ROUTINE WILL
CMPWF:	MOV	S.CSR(R4),R3	;GET THE ADDRESS OF THE BD-011
	CLR	(R3)+		;CLEAR
	CLR	(R3)+		;ALL OF
	CLR	(R3)+		;THE
	CLR	(R3)+		;REGISTERS AND
	CLR	(R3)+		;CLEAR THE
	CLR	@S.CSR(R4)	;CONTROL REGISTER AGAIN TO CLEAN UP ANY JUNK
	MOV	#1,@S.CSR(R4)	;AND THEN CAUSE A BRANCH INITALIZE.
;+
; THE ONLY TIME THAT A BZ CAN BE DONE IS DUE TO THIS ROUTINE!
;IF A CRATE MUST BE INITALIZED THE CRATE CONTROLLER FUNCTION MUST BE USED.
;-
1$:	TST	@S.CSR(R4)	;WAIT FOR THE BZ TO FINISH
	BPL	1$
	RETURN			;AND RETURN
;
;+
; CMCAN IS THE ROUTINE THAT IS CALLED WHEN AN IO.KIL FUNCTION
;IS EXECUTED OR WHEN THE TASK IS ABORTED.
;ON ENTRY THE REGISTERS CONTAIN:
;
;	R0=ADDRESS OF CURRENT I/O PACKET
;	R1=ADDRESS OF TCB OF CURRENT TASK
;	R3=CONTROLLER INDEX
;	R4=ADDRESS OF SCB
;	R5=ADDRESS OF UCB
;
;CMCAN NORMALLY JUST RETURNS WITHOUT ALTERING ANY THING.
;-
;
CMCAN:	RETURN
;
;+
; CMOUT IS ENTERED WHEN A TIMEOUT OCCURES. DUE TO THE INTERNAL TIMEOUTS
;OF THE BD-011, THERE IS LITTLE NEED FOR THIS ROUTINE. HOWEVER DURING
;DEBUGGING OF THE ROUTINE IT HAS COME IN USEFULL AT TIMES.
;THIS IS BECAUSE IF A GROSS ERROR IS MADE IN THE I/O PACKET AND
;THE WRONG RSX FUNCTION IS GIVEN TO THE CAMAC FUNCTION,
;THIS FEATURE WILL TIME YOU OUT EVENTUALLY
;AND LET THE TASK BE ABORTED.
; THE REGISTERS ON ENTRY ARE:
;
;	R0=STATUS CODE
;	R3=CONTROLER INDEX
;	R4=SCB ADDRESS
;	R5=UCB ADDRESS
;-

;
;OPERATION IS AS FOLLOWS:
;
CMOUT:	CLRB	PS		;LOWER PROCESSOR PRIORITY TO 0
	MOV	#T.NDNR,R0	;CAUSE THE DEVICE NOT READY
				;MESSAGE TO BE PRINTED
	BR	DDD
; DD IS JUMPED TO IF THERE IS A TIME OUT OR ABORT
;ERROR. IF THE CM.NMS IS CLEAR IN THE SECOND CONTROLL WORD, DD
; CAUSES A DEVICE SELECT ERROR MESSAGE TO BE PRINTED OUT ON
;THE CONSULE. BOTH CMOUT AND DD ENTRYS CAUSE A IE.VER (IRRECOVERABLE
;ERROR) STATUS BIT TO BE PUT IN THE I/O STATUS BLOCK.
;
DD:	BIC	#400,@S.CSR(R4)	;THE DD ENTRY ALSO ALWAYS RESETS THE ABORT BIT

	.IF DF	SELER
	BIT	#CM.NMS,U.CW2(R5) ;CHECK FOR NO MESSAGE
	BNE	DDDD		;IF NE NO MESSAGE
	MOV	#T.NDSE,R0	;
DDD:	CALL	$DVMSG		;
DDDD:
	.IFF
DDD:
	.ENDC
	MOVB	#IE.VER&377,U.ST1R(R5)	; SAVE THE RETURN CODE FOR IO STATUS 0
	JMP	DON

;+
; CMINI IS ENTERED BEFORE QUEUING THE IO PACKET ON THE QUEUE
; IF THE FUNCTION IS ANY FUNCTION OTHER THEN A LIST PROCESSING FUNCTION,
;THE PACKET IS QUEUED ONTO THE CORRECT QUEUE AND THEN DEQUEUED
;BY CMINI1
;
;IF THE FUNCTION IS A LIST PROCESSING FUNCTION, THE COMMAND LIST IS ADDRESS
;CHECKED AND IT ITS LOCATION IS RELOCATED TO OPTIMIZE MAPPING
;TO THE LIST FOR PROCESSING
;
; THE FORMAT OF THE IO PACKET (USED FOR LIST PROCESSING) IS:
;
;	I.PRN+00=	FIRST WORD OF NPR MAPPING ADDRESS
;	I.PRM+02=	SECOND WORD OF ABOVE
;	I.PRM+04=	BYTE COUNT OF BUFFER
;	I.PRM+06=	RELOCATED ADDRESS OF LIST (FILLED IN HERE)
;	I.PRM+10=	SECOND PART OF ABOVE
;	I.PRM+12=	VERTUAL ADDRESS OF LIST
;	I.PRM+14=	BYTE COUNT OF LIST
;
;
; ON ENTRY TO CMINI THE REGISTERS LOOK LIKE:
;
;	R1=	ADDRESS OF IO PACKET
;	R4=	SCB ADDRESS
;	R5=	UCB ADDRESS
;
;-

CMINI::
	.IF DF	LSTPDV
	BITB	#1,U.UNIT(R5)	;CHECK IF DMA UNIT
	BEQ	5$		;IF EQ NO SO JUST QUEUE PACKET

	BITB	#1,I.FCN(R1)	;CHECK IF LIST PROCESSING DMA
	BEQ	5$		;IF EQ NO JUST NORMAL DMA

	MOV	R1,R3		;SAVE ADDRESS OF IO PACKIT
	MOVB	I.FCN(R3),R1	;CHECK THE SUBFUNCTION
	BIC	#177770,R1	;REMOVE JUNK FIRST
	CMP	R1,#1
	BLE	2$		;IF LE OK
	MOV	#IE.ONP&377,R0	;LOAD BAD SUBFUNCTION ERROR
	BR	3$		;AND ERROR OUT

2$:	MOV	I.PRM+12(R3),R0	;SET UP ADDRESS TO CHECK
	MOV	I.PRM+14(R3),R1	;AND SIZE
	CALL	$ACHCK		;AND DO THE CHECK

	BCC	1$		;IF C CLEAR OK ELSE
	MOV	#IE.SPC&377,R0	;INDICATE ERROR
3$:	CLR	R1
	CALLR	$IOFIN		;AND COMPLEATE PROCESSING OF PACKIT

1$:	CALL	$RELOC		;NOW RELOCATE ADDRESS OF COMMAND BUFFER
	MOV	R1,I.PRM+6(R3)	;SAVE FIRST PART OF MAPPING INFO
	MOV	R2,I.PRM+10(R3)	;SAVE SECOND PART OF MAPPING INFO
	MOV	R3,R1		;RESTORE IOPACKIT ADDRESS

	.ENDC

5$:	MOV	R4,R0		;GET ADDRESS OF SCB TO STICK PACKIT ON
	CALL	$QINSP		;INSERT PACKIT ON QUEUE



	.PAGE

;+
; CMINI1 IS ENTERED AT THE END OF A PREVOUS I/O OPERATION TO PROPAGATE THE
;EXECUTION OF THE DRIVER. IF THE CONTROLLER IS NOT BUSY, AN ATTEMPT
;IS MADE TO DEQUEUE THE NEXT I/O REQUEST. IF THE CONTROLLER IS
;BUSY, A RETURN TO THE CALLER IS MADE. IF THE DEQUEUE ATTEMPT WAS
;SUCCESSFULL, THEN THE I/O OPERATION IS INITIATED AND A RETURN IS DONE.
;ON ENTRY, R5= ADDRESS OF THE UCB OF THE PROPER CONTROLLER.
; THE DEVICE DEPENDANT PARAMITERS FOR THE CAMAC FUNCTIONS
;ARE:
;
;	FUNCTION/SUBFUNCTION	PARAMITERS
;
;	PDW(1/0) <LOW ORDER BITS, HIGH ORDER BITS, 0, CRATE SELSCT, FNA>
;	NDT(1/2) <0, 0, 0, CRATE SELECT, FNA>
;	PDR(2/0) <ADDRESS, 4, CRATE SELECT, FNA>
;	BDRR(2/1) <ADDRESS, 14, 0, 0, 0>
;	DMA(6/0) <ADDRESS, BYTE COUNT, CRATE SELECT, FNA,BMWORD>
;	LDMA(6/1) <BUF ADD, BUF SIZE,,,CONT BUFF ADD,CONT BUFF SIZE>
;
;
;-
;
CMINI1:	CALL	$GTPKT		;ATTEMPT TO DEQUEUE A PACKET
	BCC	1$		;IF CARRY CLEAR DEQUEUED OK
	RETURN			;ELSE RETURN
;+
;ON SUCCESSFULL RETURN FROM $GTPKT, THE REGISTERS ARE:
;
;	R1=ADDRESS OF I/O PACKET
;	R2=PHYSICAL UNIT NUMBER
;	R3=CONTROLLER INDEX
;	R4=ADDRESS OF SCB
;	R5=ADDRESS OF UCB
;-

				; THE FUNCTION DISPATCHING IS THEN DONE BY
1$:	MOV	R5,CNTBL(R3)	;SAVING THE UCB ADDRESS FOR THE INTERUPT
				;ROUTINES
	MOV	R5,R0		;GET UCB ADDRESS
	ADD	#U.CW2,R0	;POINT IT TO CW2
	MOVB	I.FCN(R1),R3	;GET THE FUNCTION MODIFYER
	MOV	R3,(R0)		;SAVE IT AND
	BIC	#^C<RTFLD>,R3	;AND OFF RETURN DISPATCH CODE
	ASR	R3		;AND CONVERT TO WORD COUNT
	ASR	R3
	CMP	R3,#MAXOPR	;CHECK THAT IT IS A LEGAL TYPE OF STATUS RETURN
	BGT	EONP		;IF GT NO ILLEGAL
	MOV	R3,U.RTSE(R5)	;AND SAVE IT
	BIC	#^C<CM.NMS>,(R0) ;INITALIZE THE U.CW2 WORD
	MOV	#IS.SUC,U.ST1R(R5) ;AND THE RETURN STATUS WORD 0
	MOVB	I.FCN+1(R1),R3	;NEXT, THE FUNCTION IS PUT IN R3
	ASL	R3
	CLC			;AND THE CARRY BIT CLEARED TO ASSUME A
				;NON DMA TRANSFER.
	JMP	@DISPAT(R3)
DISPAT:	.WORD	RET		;IF THE FUNCTION IS 0 THEN AN IMMEDIATE
			;RETURN IS DONE. PLEASE NOTE THE DISPATCH TO RET
			;IS NEVER DONE AS THE FUNCTION SHOULD BE
				;HANDLED BY THE QIO ROUTINES.
	.WORD	WRI		;IF THE FUNCTION IS 1 THEN A WRITE OF SOME TYPE
				;IS ASSUMED.
	.WORD	RED		;IF THE FUNCTION IS 2, A READ
	.WORD	RET		;IF 3, 4, OR 5  THE
	.WORD	RET		;FUNCTION IS IMMEDIATLY
	.WORD	RET		;RETURNED.
	.WORD	DMAA		;IF THE FUNCTION IS 6 THEN A DMA
				;IS ASSUMED.
;
; A JUMP TO A TO ALLOW BRANCHES TO A TO GO HERE
;
A1:	MOV	#10,R0		;WAIT FOR A COUNT OF 10
1$:	TST	@S.CSR(R4)	;CHECK IF OPERATION IS DONE
	BMI	2$		;IF MI YES
	SOB	R0,1$		;TRY FOR  THE COUNT
	BR	EONP		;ELSE AN ERROR

2$:	JMP	A
                                                                                
;
; WRI IS WHERE YOU GO IF THE FUNCTION IS ONE.
;
WRI:	MOVB	I.FCN(R1),R3	;THE SUBFUNCTON IS PUT IN R3,
	BIC	#177770,R3	;CLEAR OFF JUNK
	CMP	R3,#3		;AND IT IS CHECKED FOR
	BHIS	EONP		;LEGALITY. IF NOT LEGAL EONP WILL SHOW IT.

	ASL	R3		;IF LEGAL, A WORD INDEX IS GENERATED
	JMP	@DPT1(R3)	;AND THE PROPER FUNCTION IS DISPATCHED.
DPT1:	.WORD	2$,EONP,3$
;
2$:				; FOR A PROGRAMED DATA WRITE THE
	JSR	PC,SETUP	;BD-011 REGISTERS ARE SETUP AND THEN
	MOV	I.PRM(R1),DATA(R2) ;THE LOW 16 BITS ARE WRITTEN INTO THE
				;DATA REGISTER. NEXT, THE FNA WORD IN THE
	BIT	#MD24,I.PRM+10(R1) ;QIO PACKET IS CHECKED FOR 24 BIT MODE
	BEQ	A1		;AND IF SO WILL WRITE THE UPPER 8 BITS.
	MOV	I.PRM+2(R1),DATA(R2) ;IN EITHER CASE,
	BR	A1		;A BRANCH TO A IS DONE.
;
; FOR A NON DATA TRANSFER
;
3$:	JSR	PC,SETUP	;THE REGISTERS ARE SETUP
	BR	A1		;AND A BRANCH TO A IS DONE.
;
; FOR A READ FUNCTION
;
RED:	MOVB	I.FCN(R1),R3	;THE SUBFUNCTION IS CHECKED
	BIC	#177770,R3	;CLEAR OFF JUNK
	CMP	R3,#2		;FOR LEGALITY AND IF NOT
	BLO	TICTAC		;OK IE.ONP IS SENT TO THE $IODON

EONP:	MOVB	#IE.ONP&377,U.ST1R(R5) ;ROUTINE. OTHERWISE, THE SUBFUNCTION
	JMP	DON

TICTAC:	ASL	R3		;IS MADE INTO A WORD INDEX
	JMP	@DPT2(R3)	;AND DISPATCHED.
DPT2:	.WORD	5$,6$
;
;
5$:	JSR	PC,SETUP	; FOR A PROGRAMMED DATA TRANSFER READ THE
	MOV	#20,R0		;WAIT FOR A WHILE
1$:	TST	(R2)		;OPERATION IS STARTED BY A CALL TO SETUP
				;AND THEN WAIT FOR THE TASK COMPLETION
	BMI	11$		;READY BIT TO COME UP.
	SOB	R0,1$
	BR	EONP		;IF TIME OUT ERROR OUT
11$:	SUB	#4,SP		;SAVE SPACE ON THE STACK
	MOV	DATA(R2),(SP)	;READ 16 BITS OF DATA
	MOV	DATA(R2),2(SP)	;READ TOP 8 BITS IF ANY
	BIT	#MD24,I.PRM+10(R1) ;CHECK IF IN 24 BIT MODE
	BNE	2$		;IF NE YES
	CLR	2(SP)		;IF 16 BIT MODE SET HIGH PART TO ZERO
2$:	CALL	$PTWRD		;SAVE LOW 16 BITS
	SUB	#2,U.CNT(R5)	;ADJUST WORD COUNT
	BEQ	3$		;IF EQ ALL DONE SO CLEAN UP

	CALL	$PTWRD		;ELSE SEND NEXT WORD
	BR	A		;AND GOTO A

3$:	ADD	#2,SP		;ADJUST STACK AND
	BR	A		;GOTO A
;
6$:	MOV	R4,-(SP)	; TO READ THE BRANCH DRIVER REGISTERS,
	MOV	S.CSR(R4),R4	;GET THE ADDRESS OF THE CONTROLLER
	MOV	(R4),-(SP)	;AND READ EACH REGISTER INTO THE USERS BUFFER
	CALL	$PTWRD		;WITH THE EXCEPTION OF THE DATA BUFFER
	ADD	#4,R4		;WHOSE POSITION IN THE DATA BUFFER WILL
	MOV	DRVTYP,-(SP)	;BE SET TO THE DRIVER OPTION WORD
	CALL	$PTWRD
	MOV	(R4)+,-(SP)	;
	CALL	$PTWRD
	MOV	(R4)+,-(SP)	;
	CALL	$PTWRD
	MOV	(R4)+,-(SP)
	CALL	$PTWRD
	MOV	(R4),-(SP)
	CALL	$PTWRD
	MOV	(SP)+,R4	;
				;AS NO CAMAC OPERATON WAS DONE A RETURN
	BR	DON		;TO DON IS SUFFICENT TO FINISH THIS
				;OPERATION.

;
;
DMAA:
;
; THE DMA FUNCTION IS SPECIFIED BY CALLING SETUP WITH THE CARRY BIT
;SET. THIS WILL CAUSE THE PROCESSOR PRIORITY TO BE RAISED TO LEVEL
;PL FOR A SHORT TIME.
;
	MOVB	I.FCN(R1),R3	;GET THE SUBFUNCTION
	BIC	#177770,R3	;CLEAR OFF JUNK
	CMP	R3,#1		;CHECK FOR LEGAL SUBFUNCTION
	BGT	EONP		;OPPS AN ERROR
	ASL	R3
	JMP	@DPT3(R3)	;DISPATCH FUNCTION
;
DPT3:	.WORD	NORDMA,LSTDMA
LSTDMA:
	.IF DF	LSTPDV
	MOV	R5,R0		;USE R0 AS A POINTER TO UCB LOCATIONS
	ADD	#U.EEND,R0	;GENERATE A REAL POINTER NOW
	CLR	(R0)+		;CLEAR EXPECTED CAMAC END STATION AND SUBADDRESS
	CLR	(R0)+		;CLEAR FLAG WORD
	CLR	(R0)+		;CLEAR U.DBBR
	CLR	(R0)+		;AND U.LNPR
	CLR	(R0)+
	MOV	I.PRM+14(R1),(R0)+ ;SET IN SIZE OF CONTROLL BUFFER
	MOV	I.PRM+6(R1),(R0)+ ;SET IN RELOCATED CONTROL BUFFER ADDRESS
	MOV	I.PRM+10(R1),(R0)+ ;
	CLR	(R0)+		;CLEAR U.COPC
	CLR	(R0)+		;AND U.REPT
	CLR	(R0)+		;AND U.BYTR
	BIS	#<FIRST!LSTP>,U.CW2(R5) ;SHOW PROCESSING LISTS AND THAT FIRST TI
	MOV	KISAR6,-(SP)	;SAVE MAPPING
	MOV	U.CBRL(R5),KISAR6 ;GENERATE OWN MAPPING
	MOV	U.CBRL+2(R5),R2
	CALL	SETUPL		;SETUP THE LIST STUFF
	BCC	1$		;IF SETUP OK BRANCH AROUND ERROR
	MOVB	R0,U.ST1R(R5)	;SAVE ERROR INFO
	MOV	(SP)+,KISAR6	;RESTORE MAPPING
	BR	DON1		;AND EXIT

1$:	BIS	#PL,PS		;RAISE PROCESSOR LEVEL TO INTERFACE LEVEL
	BIS	#4,@S.CSR(R4)	;AND ENABLE INTERUPT
	CALL	EXCTFN		;AND START TRANSFER
	MOV	(SP)+,KISAR6	;RESTORE MAPPING
	BIC	#PR7,PS		;LOWER PROCESSOR LEVEL TO THAT OF SYSTEM
	BR	RET		;AND GO BACK TO SYSTEM


	.IFF
	JMP	EONP		;IF NOT LIST PROCESSING DRIVER, TAKE ERROR EXIT
	.ENDC


NORDMA:
	SEC			;HERE SET THE CARRY
	MOVB	S.ITM(R4),S.CTM(R4) ;THE TIMEOUT IS ALSO SET FOR THIS FUNCTION
				;EVEN IF IT PROBABLY WON'T BE USED.
	JSR	PC,SETUP	;NOW CALL SETUP TO FIX THE REGISTERS
;
;
; CODE STARTING AT A IS EXECUTED AFTER EVERY FUNCTION/SUBFUNCTION EXCEPT
;THE LAM RECOGNITION FUNCTION.
;
A:
	TST	@S.CSR(R4)	;FIRST THE STATUS/CONTROL REGISTER IS CHECKED
				;AND IF BUSY A BRANCH TO B IS DONE.
	BPL	B		;OTHERWISE,
	BIT	#DMA,U.CW2(R5)	;THE DMA MODE BIT IS CHECKED AND
	BEQ	DON3		;IF OFF BRANCH TO DON3 TO FINISH THE OPERATION.
;
;IF SET, YOU ARE AT PROCESSOR PRIORITY PL AND HAVE BEEN
;SINCE THE CALL TO SETUP IN DMAA.
;
	MOV	@S.CSR(R4),U.CW3(R5) ;SAVE STATUS WORD
	CALL	USRRST		;SAVE SELECTED USER RETURN
	BIC	#44,@S.CSR(R4)	;NEXT, THE COMPLETION SEQUENCER AND
				;INTERUPT ENABLE ARE CLEARED AS THEY WILL
				;BE SET AND AN INTERUPT IS NOT NESSASARY.
;
	BIC	#PR7,PS		;NOW THE PRIORITY IS SET BACK TO ZERO
	BIC	#DMA,U.CW2(R5)	;AND THE DMA MODE BIT CLEARED.
	CLRB	S.CTM(R4)	;ALSO, THE TIMEOUT IS CLEARED AS THE OPERATION
				;IS COMPLETE
	BR	DON1
;
; AT DON3 THE STATUS REGISTER IS PLACED IN U.CW3
; AND THE USERS SELECTED REGISTER IS ALSO SAVED.
; FOR DMA OPERATIONS, INVOLVING INTERUPTS THIS HAS ALREADY BEEN DONE
; IF A DMA W/O INTERUPT IT IS DONE IN A
;
DON3:	MOV	@S.CSR(R4),U.CW3(R5) ;SAVE STATUS
	CALL	USRRST		;SAVE SELECTED USER VALUE
;
; AT  DON1, THE
;
DON1:	BIT	#10400,U.CW3(R5) ;CONTROL/STATUS REGISTER IS CHECKED FOR
	BEQ	DON
	BIT	#LSTP,U.CW2(R5)	;CHECK IF LIST PROCESSING
	BNE	DON		;IF SO JUST RETURN LSTP ERROR STATU
	JMP	DD		;ABORT AND TIMEOUT AND IF SO JUMP TO DD.
DON:
	BIT	#LSTP,U.CW2(R5)	;CHECK IF LIST PROCESSING
	BNE	30$		;IF IT IS DONOT GENERATE PACKED STATUS

	MOV	U.CW3(R5),R0	;GET CSW WORD
	SWAB	R0		;BUILD THE RETURN CODE
	ASLB	R0		;FROM THE STATUS WORD
	BIT	#1000,R0	;CHECK FOR BX SET
	BEQ	10$		; IF EQ NO
	INCB	R0		;SET X BIT
10$:	ASLB	R0		;BQ SET
	BPL	20$		;IF PL NO
	INCB	R0		;SET Q BIT
20$:	BIC	#^C77,R0	;MASK OFF JUNK
	MOVB	R0,U.ST1R+1(R5)	;AND SAVE IN HI BYTE

30$:	MOV	U.ST1R(R5),R0	;GET THE STATUS BLOCK WORD 0 RETURN AND
	MOV	U.RTUN(R5),R1	;SECOND WORD OF THE IOSB AND A CALL TO
	BIC	#LSTP,U.CW2(R5)	;$IODON IS EXECUTED
				;
	CALL	$IODON
	JMP	CMINI1		;AND THEN ATTEMPT TO DEQUEUE ANOTHER IO PACKET.
;
; IF THE OPERATION IS NOT COMPLETE WHEN CHECKED IN A:, THEN
; THIS CODE IS EXECUTED TO LOWER THE PROCESSOR PRIORITY AND ALLOW
; THE COMPLETION INTERUPT TO OCCURE.
;
B:	BIC	#PR7,PS		;
RET:	RETURN
;;
; $CMINT IS THE TASK COMPLETION INTERUPT ENTRY POINT.
;IT IS ENTERED WHEN AN OPERATION WAS NOT DONE WHEN THE PROGRAM JUMPED TO
;A.
; OR WHEN ANY LIST PROCESSING FUNCTION IS OPERATING
;
$CMINT::
	INTSV$	CM,PL,C$$M11	; FIRST CALL INTSV$ TO DO THE INTERUPT STUFF
				;AND PUT THE UCB ADDRESS INTO R5
	MOV	U.SCB(R5),R4	;AND THE SCB ADDRESS IN R4.
	MOVB	#IS.SUC&377,U.ST1R(R5) ;ASSUME SUCCESFUL COMPLEATION

	.IF DF LSTPDV
	BIT	#LSTP,U.CW2(R5)	;CHECK IF LIST OPERATION
	BEQ	NORM		;IF EQ NO

	MOV	KISAR6,-(SP)	;SAVE AR6
	MOV	R0,-(SP)	;AND SOME REGISTERS
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)

CONT:	BIC	#44,@S.CSR(R4)	;CLEAR OUT SEQUENCER AND ENABLE
	MOV	U.CBRL(R5),KISAR6 ;POINT TO CONTROLL BUFFER
	MOV	U.CBRL+2(R5),R2	;GET RELOCATED ADDRESS FOR ABOVE
	CALL	ERRCK		;CHECK FOR ANY ERRORS
	BCS	LDON		;IF CARRY SET, AN ERROR SO EXIT
				;R0 CONTAINS ERROR CODE
	TSTB	1(R2)		;CHECK IF AT END OF LIST
	BNE	1$		;IF NOT EQ NO
	MOV	#IS.SUC,R0	;SHOW SUCCESS
	BR	LDON		;AND EXIT

1$:	CALL	SETUPL		;SETUP NEXT LIST
	BCS	LDON		;IF ERROR EXIT IMMEDEATLY
	BIS	#4,@S.CSR(R4)	;ENABLE INTERUPTS
	CALL	EXCTFN		;AND EXECUTE THE FUNCTION
	TST	@S.CSR(R4)	;CHECK IF DONE
	BMI	CONT		;YES SO PROCESS NEXT PACKIT

	MOV	(SP)+,R3	;ELSE JUST EXIT
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	MOV	(SP)+,KISAR6	;RESET MAPPING
	CALLR	$INTXT

LDON:	DECB	U.COPC(R5)	;ADJUST NUMBER OF PACKITS PROCESSED
	MOVB	U.COPC(R5),U.ST1R+1(R5) ;SAVE NUMBER OF PACKITS
	MOVB	R0,U.ST1R(R5)	;AND SHOW RETURN VALUE
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	MOV	(SP)+,KISAR6

	.ENDC

NORM:	CLRB	S.CTM(R4)	;CLEAR THE TIMEOUT
	CALL	USRRST		;GET USER SELECTED RETURN
	MOV	@S.CSR(R4),U.CW3(R5) ;SAVE STATUS WORD
	BIC	#4,@S.CSR(R4)	;AND CLEAR THE TASK COMPLETION ENABLE
	BIC	#DMA,U.CW2(R5) ;BIT AND THE DMA MODE BIT.
	CALL	$FORK		;NOW A $FORK IS DONE TO PRODUCE A SYSTEM
				;PROCESS.
	CMPB	#IE.JER,U.ST1R(R5) ;CHECK IF INTERFACE ERROR
	BNE	1$		;IF NE NO

	MOV	#T.NDNR,R0	;DISPLAY DEVICE NOT READY MESSAGE
	CALL	$DVMSG		;AND
1$:	JMP	DON1		; GO TO TO DON1.
;
; SETUP IS THE ROUTINE THAT LOADS THE BRANCH DRIVER'S REGISTERS WITH
;THE PROPER STUFF TO START AN OPERATION.
;IF THE CARY IS CLEAR, A NON DMA OPERATION IS ASSUMED, OTHER
;WISE A DMA TRANSFER IS SPECIFIED.
;
;
;;
SETUP:	MOV	R2,-(SP)	; FIRST SAVE THE UNIT NUMBER AND
	MOV	S.CSR(R4),R2	;PUT THE ADDRESS OF THE CONTROL
				;STATUS REGISTER INTO R2.
	BCC	2$		;NEXT CHECK TO SEE IF THE CARRY IS SET
	BIT	#1,(SP)		;AND IF SO CHECK TO SEE THAT THE UNIT IS
	BEQ	4$		;CM1: IF NOT INDICATE AN ERROR
	MOV	U.BUF+2(R5),R3	;OTHERWISE, GET THE ADDRESS OF THE
	BIS	#DMA,U.CW2(R5)	;AND SET THE DMA MODE BIT
	MOV	R3,MADR(R2)	;START LOADING THE BDS REGISTERS STARTING
				;WITH THE ADDRESS REGISTER.
	MOV	U.CNT(R5),R3	;NOW GET THE
	ASR	R3		;BYTE COUNT AND PLACE IN R3 AND SET TO
	BIT	#MD24,I.PRM+10(R1) ;WORD COUNT. THE FNA WORD MUST BE CHECKED
				;FOR 24 BIT TRANSFER AND IF SET DEVIDE THE
				;WORD COUNT BY TWO ONCE AGINE.
	BEQ	5$
	ASR	R3		;
5$:	NEG	R3		;NOW THE WORD COUNT IS NEGATED
	BIC	#^C7777,R3	;EXTRANOUS BITS MASKED OFF
	.IF	DF,JORW
	MOV	I.PRM+12(R1),(SP) ;GET THE BM WORD AND PLACE IN (SP)
	BIC	#^C140000,(SP)	;CLEAR OFF ANY JUNK
	MOV	I.PRM+6(R1),CRAT(R2) ;LOAD THE CRATE SELECT WORD
	BIS	R3,(SP)
	MOV	U.BUF(R5),R3
	BIC	#^C60,R3
	SWAB	R3
	BIS	(SP)+,R3
	.IFF
	BIC	#^C777,R3	;CLEAR OFF EXTRA BITS FOR BD011
	MOV	I.PRM+6(R1),(SP) ;SAVE CRATE SELECT
	BIC	#^C177000,(SP)	;CLEAR POSSABLE WORDCOUNT
	BIS	(SP)+,R3	;OR ON THE CRATE SELECT TO THE WORD COUNT
	MOV	R3,CRAT(R2)	;AND WRITE THE CRATESELECT WORD COUNT OUT
	.ENDC
	MOV	R3,XTEND(R2)	;AND LOADED INTO THE EXTENDED WORD COUNT
	BIS	#PL,PS		;REGISTER. NOW THE PROCESSOR PRIORITY
				;IS RAISED SO THAT IF THE DMA OPERATION
				;FINISHES BEFORE I EXIT THIS ROUTINE
				;I CAN DISABLE THE PENDING INTERUPT
				;AND THEREBY REMOVE THE NEED TO GO
			;THROUGH THE INTERUPT SERVICE CODE.
			;THE TRADE OFF IS THAT I MUST RUN AT THE LEVEL
			;OF THE BD TILL THIS IS DONE BUT IT ONLY TACKS A
			;SHORT TIME.
;
;
	BIS	#4,@S.CSR(R4)	;AT THIS TIME THE COMPLETION INTERUPT
	MOV	I.PRM+10(R1),FNA(R2) ;IS ENABLED AND THE FNA WORD LOADED
				;WHICH CAUSES THE OPERATION TO START
	RTS	PC		;WHICH CAUSES THE OPERATION TO START
;
; FOR A NON DMA TRANSFER, THE UNIT
;
2$:	BIT	#1,(SP)+	;IS CHECKED TO BE CM0:
	BEQ	3$		;AND IF NOT,
4$:	MOVB	#IE.BAD&377,U.ST1R(R5) ;AN ERROR FUNCTON IS SENT OUT
	ADD	#2,SP		;HERE CLEAR OUT THE STACK
	JMP	DON		;AND JUMP TO DONE
3$:	CLR	XTEND(R2)	;CLEAR THE EXTENDED REG (EVEN IF NOT THERE)
	BIC	#777,I.PRM+6(R1) ;MODIFY THE PACKIT SO NO WORD COUNT
	MOV	I.PRM+6(R1),CRAT(R2) ;OTHERWISE, LOAD THE CRATE SELECT
	MOV	I.PRM+10(R1),FNA(R2) ;AND THE FNA WORD
	RTS	PC		;AND RETURN.
;
;
; USRRST IS CALLED TO PLACE THE CORECT RETURN IN IO STATUS +2
;
; R5= UCB ADDRESS
; R4=SCB ADDRESS
;
; ALL REGISTERS MUST BE SAVED ACROSS CALL
;
USRRST:
	MOV	R0,-(SP)	;SAVE R0
	MOV	R1,-(SP)	;AND R1
	MOV	S.CSR(R4),R1	;GET CSR OF CONTROLLER
	MOV	U.RTSE(R5),R0	;GET DISPATCH FUNCTION
	JMP	@1$(R0)		;DISPATCH JUMP

1$:	.WORD	SAVCSR,SAVFNA,SAVCS,SAVEWC,SAVDVT
	.IIF DF LSTPDV	.WORD	SAVTOP
;
SAVCSR:	MOV	(R1),U.RTUN(R5)	;SAVE RETURN
	BR	AL6DN

SAVFNA:	MOV	FNA(R1),U.RTUN(R5) ;SAVE FNA
	BR	AL6DN

SAVCS:	MOV	CRAT(R1),U.RTUN(R5) ;SAVE CRATE SELECT
	BR	AL6DN

SAVEWC:	MOV	XTEND(R1),U.RTUN(R5) ;SAVE EXTENDED WORD COUNT
	BR	AL6DN

SAVDVT:	MOV	DRVTYP,U.RTUN(R5) ;SAVE THE DRIVER TYPE WORD
	BR	AL6DN
	.IF DF LSTPDV
SAVTOP:	MOV	U.CNT(R5),U.RTUN(R5) ;GET NUMBER OF BYTES IN BUFF
	SUB	U.DBBR(R5),U.RTUN(R5) ;REMOVE NUMBER OF BYTES NOT USED
	BR	AL6DN

	.ENDC


AL6DN:	MOV	(SP)+,R1	;RESTORE RTEGISTERS
	MOV	(SP)+,R0	;
	RETURN

;
	.IF DF 	LSTPDV
	.ENDC
	.IF DF	LSTPDV
	.ENABL	LSB

;+
; SETUPL
; THIS ROUTINE IS USED TO SETUP THE UCB LIST PROCESSING DATA BASE
; BEFORE ATTEMPTING TO EXECUTE A FUNCTION

;INPUTS:
;
;	R2=	POINTER TO COP
;	R4=	SCB ADDRESS
;	R5=	UCB ADDRESS

;OUTPUTS:
;
;	IF CARRY SET, AN ERROR HAS OCCURED AND THE ERROR CODE WILL
;	BE IN R0.
;
;	IF CARRY CLEAR, ROUTINE OPERATION IS CORRECT
;
;

;NOTE: IN THE FOLLOWING, R0 IS USED AS A SCRATCH REGISTER AND R1 POINTS
;TO THE CURRENT OPTIONAL WORD.
;
;
;-


SETUPL::
	MOVB	(R2),R1		;GET FLAG BYTE
	MOVB	R1,U.FLAG(R5)	;SAVE IT AND
	MOV	U.CW2(R5),R0	;GET CW2 TO GET FIRST
	BIC	#^C FIRST,R0	;ADD OFF ANY JUNK
	BIC	#^C BUFOF,R1	;ISOLATE BUFOF
	BIS	R1,R0		;MERGE BITS
	MOV	R2,R1		;GENERATE POINTER TO VARIABLE PART
	ADD	#10,R1		;POINT TO VARIABLE PART
	TST	R0		;CHECK IF FIRST OR BUFFOR OFFSET
	BEQ	20$		;IF EQ NO

	BIT	#BUFOF,R0	;NOW CHECK IF BECAUSE OF FIRST OR IF
				;A NEW BUFFER IS REQUESTED
	BEQ	10$		;FIRST IF EQ

;
; HERE A BUFFER OFFSET HAS BEEN REQUESTED, AND A NEW 18 BIT ADDRESS MUST
; BE GENERATED ALSO THE  NUMBER OF BYTES IN THE DATA BUFFER MUST BE UPDATED
;
	CMP	(R1),U.CNT(R5)	;CHECK IF BUFFER OFFSET OUTSIDE OF BUFF
	BGT	50$		;IF GT YES (NOTE, BUFFERS MUST BE <16K WORDS)
	MOV	U.BUF+2(R5),U.LNPR+2(R5) ;GET LOWER 16 BITS OF ADDRESS
	MOV	U.BUF(R5),U.LNPR(R5) ;AND UPPER 2 BITS IN BITS 4 AND 5
	ADD	(R1),U.LNPR+2(R5) ;ADD ON BUFFER BIAIS
	BCC	1$
	ADD	#20,U.LNPR(R5)	;IF CARRY SET NEED TO BUMP UPPER BITS
	BIT	#100,U.LNPR(R5)	;CHECK IF IMPOSSABLE ERROR OCCURED
	BNE	49$
1$:	MOV	U.CNT(R5),U.DBBR(R5) ;SET THE NUMBER OF BYTES REMAINING
	SUB	(R1)+,U.DBBR(R5) ;SUBTRACT OFF BIAIS
	BR	19$		;GO DO NEXT CHECK

;
; HERE IS WHERE THE FIRST PROCESSING IS SET UP
; THIS IS DONE WHEN THE FIRST COP IS BEING DONE AND THAT COP DOES NOT
; SPECIFY A BUFFER OFFSET
;
10$:
	MOV	U.BUF(R5),U.LNPR(R5) ;SAVE FIRST PART OF ADDRESS
	MOV	U.BUF+2(R5),U.LNPR+2(R5) ;AND SECOND PART
	MOV	U.CNT(R5),U.DBBR(R5) ;AND NUMBER OF BYTES REMAINING

;
; RESET THINGS AND SHOW NEED TO LOAD ADDRESS
;
19$:	BIC	#FIRST,U.CW2(R5) ; CLEAR FIRST AS IT ISN'T ANY MORE
	BIS	#LODAD,U.CW2(R5) ; AND SHOW NEED TO LOAD THE ADDRESS

;
; HERE CHECK IF AN CNA CHECK IS TO BE MADE AT THE END OF THE OPERATION
; AND IF SO SETUP THAT CHECK
;
20$:
	CLR	U.EEND(R5)	;ASSUME NO CHECK MADE
	BITB	#CNACK,(R2)	;CHECK IF CHECK IS ENABLED
	BEQ	30$		;IF EQ, NO

	MOV	(R1)+,U.EEND(R5) ;SAVE THE END CHECK
;
; NEXT CHECK FOR A REPEAT COUNT
;
30$:
	BITB	#REP,(R2)	;CHECK FLAG WORD
	BEQ	35$		;IF EQ NO REPEAT COUNT

	TST	U.REPT(R5)	;CHECK IF ALREADY PROCESSING REPEAT COUNT
	BNE	35$		;IF SO DON'T RESET

	MOV	(R1)+,U.REPT(R5) ;GET REPEAT COUNT
35$:	TST	U.REPT(R5)	;IF NO REPEAT COUNT INITALIZE TO 1
	BNE	39$
	INC	U.REPT(R5)
;
; NOW NEED TO GENERATE THE CALCULATED NUMBER OF BYTES REMAINING IN THE
; BUFFER. THIS IS OBTAINED FROM THE EXTENDED WORD COUNT WORD OF THE
; MANDTORY PART OF THE BUFFER
; THIS ALSO GENERATES THE NUMBER OF BYTES TO BE TRNASFERED
;
39$:	MOV	4(R2),U.EXWC(R5)	;GET THE INITIAL EXWC WORD AND SAVE
40$:
	CLR	U.BYTR(R5)	;INITALIZE THE NUMBER OF BYTES IN THE TRNSFER
	MOV	U.EXWC(R5),R0	;GET EXTENDED WORD COUNT WORD
	MOV	#170000,R1	;GET MASK WORD
	CLC			;RETURN OK
	BIC	R1,R0		;CHECK FOR WORD COUNT OF ZERO
	BEQ	51$		;IF IS EXIT ROUTINE

	BIS	R1,R0		;ELSE MAKE THE WORD COUNT A REAL NEGATIVE NUMBER
	NEG	R0		;AND MAKE POSATIVE
	ASL	R0		;BYTE COUNT
	BIT	#MD24,6(R2)	;CHECK FOR 24 BIT MODE OPERATION
	BEQ	44$		;IF EQ 16 BIT MODE
	BIS	#MD24,U.FLAG(R5) ;INDICATE 24 BIT MODE IN FLAG WORD
	ASL	R0		;ADJUST BYTE AGAIN IF 24 BIT MODE
44$:	MOV	U.DBBR(R5),-(SP) ;SAVE NUMBER OF BYTES IN BUFFER
	SUB	R0,U.DBBR(R5)	;SUBTRACT OFF ALLOCATED BYTES
	BPL	47$		;IF POS, ALL OK

	BIT	#WCOFOK,U.FLAG(R5) ;CHECK IF OVERFLOW OK
	BEQ	52$		;IF EQ NO JUST ERROR OUT

	ADD	U.DBBR(R5),R0	;ADJUST BYTE COUNT TO STOP AT END OF DATA BUF
	ASR	R0		;CONVERT TO BYTES
	BIT	#MD24,6(R2)	;CHECK IF 24 BIT MODE OPERATION AND IF IT IS,
	BEQ	45$		;
	ASR	R0		;NEED TO MODIFY WORD COUNT AGAIN
45$:	NEG	R0		;CONVERT TO NEGATIVE BEFORE SAVING IN COP
	BIC	#^C7777,R0	;CLEAN OFF CONTROLL BITS OF ADJUSTED WC
	BIC	#^C170000,U.EXWC(R5)	;AND RESET WORD COUNT IN DATA STRUCTURE
	BIS	R0,U.EXWC(R5)	;AND SET IN DATA STRUCTURE
	MOV	(SP)+,U.DBBR(R5) ;AND RESET THE NUMBER OF FREE BYTES
	BR	40$		;AND TRY AGIAN

47$:	MOV	R0,U.BYTR(R5)	;SAVE NUMBER OF BYTES ALLOWED IN TRANSFER
	ADD	#2,SP		;ADJUST STACK
	CLC
	BR	51$		;LEAVE INDICATING OK

;
; ERROR PROCESSING
;
49$:	MOV	#IE.IMP,R0
	BR	53$

52$:	ADD	#2,SP		;ADJUST STACK
50$:	MOV	#IE.OVR,R0	;SHOW ATTEMPT TO GO OUTSIDE BUFFER
53$:	SEC

;
; EXIT
;
51$:	RETURN

	.ENABL	LSB

;+
; EXCTFN IS CALLED TO EXECUTE THE CAMAC FUNCTION FROM THE INFORMATION IN
; THE UCB DATA BASE AND THE INFORMATION IN THE MANDATORY PART OF THE
; COP
;
;INPUT:
;
;	R2=	ADDRESS OF THE COP
;	R4=	SCB ADDRESS
;	R5=	UCB ADDRESS
;
;
;
;OUTPUT:
;
;	R2=	ADDRESS OF NEXT COP TO EXECUTE
;
; U.COPC IS BUMPED EACH TIME A COP ADVANCE IS MADE THIS IMPLIES THAT
; WHEN EXITING, NEED TO DECREMENT COP COUNT BY ONE
;
;
;NOTE: R1 CONTAINS THE ADDRESS OF THE CSR OF THE INTERFACE AND
; R0 IS USED AS SCRATCH
;
;
;
;-


EXCTFN::
	MOV	S.CSR(R4),R1	;GET THE ADDRESS OF THE INTERFACE
	MOV	XTEND(R1),R0	;GET THE OLD ADDRESS IBT
	BIC	#^C 30000,R0	;AND CLEAR OFF JUNK
	BIT	#LODAD,U.CW2(R5) ;CHECK IF WE NEED TO UPDATE THE JORWAY ADDRESS
	BEQ	10$		;IF EQ NO

	BIC	#LODAD,U.CW2(R5) ;CLEAR LOAD BIT
	MOV	U.LNPR+2(R5),MADR(R1) ;LOAD THE LOW 16 BITS
	MOV	U.LNPR(R5),R0	;GET THE UPPER TWO BITS AND
	SWAB	R0		;POSITION CORECTLY

;
; NOW DO THE OPERATION
;
10$:
	ADD	#2,R2		;POINT R2 TO CRATE SELECT
	MOV	(R2)+,CRAT(R1)	;FILL IN CRATE WORD
	BIS	U.EXWC(R5),R0	;OR THE OP COUNT ON TO EXTENDED ADDRESS
	MOV	R0,XTEND(R1)	;AND SET IN THE INTERFACE
	ADD	#2,R2		;ADJUST POINTER
	MOV	(R2),FNA(R1)	;AND THE FUNCTION
	SUB	#6,R2		;RESET R2 TO POINT TO TOP OF COP
;
; AT THIS POINT, THE CAMAC OPERATION IS IN PROGRESS
; WE WILL NOW DETURMAIN IF THE COP SHOULD BE ADVANCED AND IF SO WILL DO IT
; THIS HOPEFULLY WILL ALLOW SOME OVERLAP OF CAMAC OPERATION AND PROCESSOR
; OPERATION SO THAT THE INTERUPT OVERHEAD CAN BE AVOIDED IN SOME CASES
;
	DEC	U.REPT(R5)	;DECREMENT THE REPEAT COUNT
	BNE	20$		;IF NE THEN THIS PACKIT REPEATS

	MOVB	1(R2),R0	;GET THE OFFSET
	ADD	R0,R2		;AND POINT POINTER TO NEXT COP
	CMP	R2,#150000	;CHECK IF NEED TO ADVANCE APR
	BLO	19$		;IF LO NO

	SUB	#10000,R2	;ADJUST RELOCATE
	ADD	#100,U.CBRL(R5)	;ADJUST NEW APR6 VALUE

19$:	MOV	R2,U.CBRL+2(R5)	;AND OFFSET
	INCB	U.COPC(R5)	;AND BUMP COP COUNT

20$:	RETURN
	

	.ENABL	LSB

;+
;ERRCK
; THIS MODULE IS USED TO CHECK THAT THE CAMAC OPERATION WAS CORRECT
;
;INPUTS:
;
;	R4=	SCB ADDRESS
;	R5=	UCB ADDRESS
;
;	R2 PRESERVED
;
;OUTPUT:
;
;	ERROR IF CARRY SET R0 WILL CONTAIN ERROR VALUE
;	CARRY CLEAR IMPLIES SUCCESS
;
; R1 WILL CONTAIN THE ADDRESS OF THE CSR OF THE DRIVER, R0 AND R3 ARE USED
; FOR SCRATCH
;
;
;-

ERRCK::
;
; FIRST CHECK THE CRATE OVERFLOW AND THE T02 BITS AND THERE RESPECTIVE
; ENABLES TO SEE IF AN ERROR SHOULD OCCURE
;
	MOV	S.CSR(R4),R1	;GET CSR ADDRESS
	BIT	#COVF,(R1)	;CHECK FOR CRATE OVERFLOW
	BEQ	2$		;IF EQ NO
	BITB	#CRTOK,U.FLAG(R5) ;CHECK IF OVERFLOW OK
	BNE	2$		;IF NOT EQ YED
	MOV	#IE.CVF,R0	;SHOW ERROR
	BR	50$		;AND TAKE ERROR EXIT

2$:	BIT	#T02,(R1)	;CHECK FOR CAMAC TIME OUT
	BEQ	3$		;IF EQ NO
	BITB	#T02OK,U.FLAG(R5) ;IS T02 OK?
	BNE	3$		;IF NE YES
	MOV	#IE.CT2,R0	;SHOW ERROR
	BR	50$		;AND TAKE ERROR EXIT

3$:	BIT	#CNACK,U.FLAG(R5) ;CHECK FOR CNA CHECK
	BEQ	10$		;IF EQ NO
	MOV	FNA(R1),R0	;GET FNA WORD
	MOV	U.EEND(R5),R3	;SAVE END CNA
	XOR	R3,R0		;CLEAR EXPECTED BITS IF THEY ARE INDEED ON
	BIC	#177000,R0	;CLEAR OFF JUNK
	BNE	5$		;AND IF NOT EQ N AND A DONT MATCH

	MOV	CRAT(R1),R0	;GET WORD AGAIN FOR CRATE CHECK
	XOR	R3,R0		;CHECK IF CRATES EXPECTED
	BIC	#777,R0		;
	BEQ	10$		;IF EQ ALL IS OK

5$:	MOV	#IE.END,R0	;SHOW ERROR
	BR	50$		;AND TAKE ERROR EXIT

;
; THIS PART NOW CHECKS THAT THE 18 BIT ADDRESS IS CORRECT FROM
;THE CALCULATION OF THE STARTING ADDRESS AND THE NUMBER OF WORDS TRANSFERED
;
10$:	CLR	-(SP)		;SAVE SPACE FOR NUMBER OF BYTES TRANSFERED
	MOV	XTEND(R1),R0	;GET THE EXTENDED WORD COUNT
	BIC	#170000,R0	;AND OFF JUNK
	BEQ	13$		;IF ZERO ALL WORDS TRANSFERED
	BIS	#170000,R0	;ELSE MAKE A REAL NEGAITVE NUMBER
				;AND THIS NUMBER IS THE NEGATIVE
				;NUMBER OF WORDS NOT TRANSFERED
	ASL	R0		;TIMES 2 FOR BYTES
	BIT	#MD24,U.FLAG(R5) ;CHECK FOR 24 BIT MODE
	BEQ	11$		;IF EQ NO
	ASL	R0		;ELSE ADVANCE AGAIN
11$:	SUB	R0,(SP)		;PUT POSATIVE NUMBER OF BYTES IN (SP)

13$:	MOV	(SP)+,R0	;GET NUMBER OF BYTES NOT TRANSFERED
	ADD	R0,U.DBBR(R5)	;ADJUST NUMBER OF BYTES REMAINING
	SUB	R0,U.BYTR(R5)	;ADJUST NUMBER OF BYTES IN TRANSFER
	ADD	U.BYTR(R5),U.LNPR+2(R5) ;GENERATE CALCULATED 18 BIT ADDRESS
	BCC	14$
	ADD	#20,U.LNPR(R5)	;
	BIT	#100,U.LNPR(R5)	;CHECK FOR IMPOSSABLE ERROR
	BEQ	14$
	MOV	#IE.IMP,R0	;SHOW  ERROR
	BR	50$		;AND ERROR EXIT

14$:	MOV	XTEND(R1),R0	;GET UPPER 2 BITS
	SWAB	R0		;POSITION AND
	BIC	#^C60,R0	;CLEAR JUNK
	CMP	U.LNPR(R5),R0	;CHECK THAT BITS ARE SAME
	BNE	19$		;IF NE NO
	CMP	U.LNPR+2(R5),MADR(R1) ;CHECK LOWER BITS
	BEQ	20$		;IF EQ ALL OK

19$:	MOV	#IE.JER,R0	;INDICATE ERROR
	BISB	#US.OFL,U.ST2(R5) ;SET UNIT OFF LINE AS SICK
	BR	50$		;AND EXIT WITH ERROR

20$:	CLC			;ALL DONE SO EXIT NICELY
	BR	51$

50$:	SEC			;ERROR EXIT
51$:	RETURN

	.ENDC


	.END