.TITLE	CMDRV
	.IDENT	/V1/
	.IDENT	/V2/
	.IDENT	/V3/	;3/30/77
	.IDENT	/V3.1/	;7/28/77
	.IDENT	/V3.2/	;9/14/77
	.IDENT	/V3.3/	;12-MAR-78
	.IDENT	/V3.4/	;15-APR-78                                              ;DBC4.0
	.IDENT	/V4.0/	;20-APR-78                                              ;DBC4.0
                                                                                ;**-1
	.SBTTL	CAMAC DRIVER FOR RSX11M
;
;MODIFICATIONS
;

;D.B. CURTIS 8/25/76 ADDED BD COMMAND STATUS WORD
;TO THE SECOND IOSW. ALSO KILLED THE ASSEMBLY ERROR THAT OCCURED.

;D.B. CURTIS 3/30/77 ADDED VERSION 3 MODS FOR LOADABLE DRIVER SUPPORT
;AND FOR MULTAPAL CONTROLLERS
;I HAVE ALSO REMOVED THE EXTRA SPACE IN THE DRIVER THAT WAS
;ADDED FOR POSSABLE EXPANSION AND THE PRINT STATEMENT THAT HELPED
;DETURMIN THE SIZE AS NO LONGER NEEDED.

; D.B.CURTIS ADDED VERSION 3.1 MODS TO ALLOW SETTING OF THE BM BIT
;THIS WILL ALLOW STOP MODE OPERATION OF THE DRIVER  FOR JORWARS.
;AT THIS SAME TIME I CLEANED UP THE CODE FOR HANDLING BD011S
;ALSO ADDED CONDITIONAL SELECT ERROR MESSAGE AND FIXED BUG IN THE
;READ REGISTER FUNCTION THAT WIOLD PRODUCE A SELECT ERROR MESSAG

;D.B. CURTIS ADDED CODE TO ALLOW THE HIGH BIT OF THE SUBFUNCTION CODE
;TO INHIBIT  THE DEVISE SELECT ERROR MESSAGE IF SET

;D.B.CURTIS ADDED CODE TO FIX BUG WHEN HANDLING MULTIPL CONTROLLERS

;D.B.CURTIS ADDED ABILITY TO SELECT WHICH INTERFACE REGISTER TO SEND BACK
; TO THE SECOND WORD OF THE IO STATUS BLOCK
; D.B.CURTIS ADDED LIST PROCESSING TO DRIVER <MAY BE CONDITIONALIZED OUT>       ;DBC4.0
; ALSO ADDED OPTION WORD                                                        ;DBC4.0
; THESE CHANGES ARE EDIT 'DBC4.0'                                               ;DBC4.0
                                                                                ;**-2

; 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                                                                   ;DBC4.0

;+
;
; 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)               ;DBC4.0
;	CM.FNA=10		READ FNA WORD (RETURNS ONLINE CRATES AND N AND A;DBC4.0
;	CM.CS =20		CRATE SELECT WORD COUNT WORD                    ;DBC4.0
;	CM.EWC=30		EXTENDED WORD COUNT                             ;DBC4.0
;	CM.ASM=40		BIT ENCODED WORD INDICATING ASSEMBLY OPTIONS    ;DBC4.0
;	CM.TOP=50		RETURNS THE FIRST FREE BYTE (AS AN OFFSET INTO T;DBC4.0
;				 OF THE LAST OPERATION OF A CHAIN               ;DBC4.0
;                                                                               ;**-4
;
;
; 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
;	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 IS ZERO UNLESS A LIST PROCESSING FUNCTION IS SPECIFIED,
;IN WHICH CASE, IT CONTAINS THE NUMBER OF THE LAST OPERATION ATTEMPTED.

;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.

;-
	.PAGE                                                                   ;DBC4.0
;
;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                                                                    ;DBC4.0
U.EEND=LPD+0                                                                    ;DBC4.0
U.FLAG=LPD+2                                                                    ;DBC4.0
U.DBBR=LPD+4                                                                    ;DBC4.0
U.LNPR=LPD+6                                                                    ;DBC4.0
U.CBSZ=LPD+12                                                                   ;DBC4.0
U.CBRL=LPD+14                                                                   ;DBC4.0
U.COPC=LPD+20                                                                   ;DBC4.0
U.REPT=LPD+22                                                                   ;DBC4.0
U.BYTR=LPD+24                                                                   ;DBC4.0
.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                                   ;DBC4.0
CM.NMS=200	;CM.NMS=DONOT ALLOW DEVICE SELECT ERROR MESSAGES                ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; INDICATE ASSEMBLY PARAMITERS THAT SHOULD BE PLACED IN RSXMC                   ;DBC4.0
;                                                                               ;DBC4.0
; IF LOADABLE DRIVER LD$CM=0                                                    ;DBC4.0
;                                                                               ;DBC4.0
; IF LIST PROCESSING DRIVER LSTPDV=0                                            ;DBC4.0
;                                                                               ;DBC4.0
;                                                                               ;DBC4.0
; PRIORITY OF INTERFACE PL=PR4                                                  ;DBC4.0
; DEFAULT IS PR4                                                                ;DBC4.0
;                                                                               ;DBC4.0
; C$$M11=NUMBER OF CAMAC INTERFACES                                             ;DBC4.0
;                                                                               ;DBC4.0
; JORW=0 IF JORWAY J411 INTERFACE ELSE EGG ASSUMED                              ;DBC4.0
;                                                                               ;DBC4.0
                                                                                ;DBC4.0
.IIF NDF PL	PL=PR4                                                          ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; ERROR RETURNS  (MAPPING FROM LITERALS IN ROUTINE TO TYPICAL RETURNS)          ;DBC4.0
;                                                                               ;DBC4.0
                                                                                ;DBC4.0
IE.END=IE.DAO		;IF CNA CHECK DOES NOT WORK SET DATA OVERUN             ;DBC4.0
                                                                                ;DBC4.0
IE.CVF=IE.RBG		;IF UNEXPECTED CRATE OVERFLOW, SET ILLEGEAL RECORD SIZE ;DBC4.0
                                                                                ;DBC4.0
IE.IMP=IE.VER		;IF IMPOSSABLE ERROR, SET PARITY ERROR                  ;DBC4.0
                                                                                ;DBC4.0
IE.CT2=IE.RCN		;IF CAMAC TIME OUT DECIDE ILLEGAL RECORD NUMBER         ;DBC4.0
                                                                                ;DBC4.0
IE.JER=IE.FHE		;IF CALCULATED ADDRESS NOT EQUEAL TO REAL 18 BIT        ;DBC4.0
			;SET FATEL HARDWARE ERROR                               ;DBC4.0
			;THIS ERROR ALSO SETS UNIT OFFLINE UNLESS US.OFL IS SET ;DBC4.0
                                                                                ;DBC4.0
                                                                                ;DBC4.0
;+                                                                              ;DBC4.0
; LOCAL DATA BITS AND OFFSETS AND SPECIAL ASSEMBLY PARAMITERS ARE:              ;DBC4.0
;                                                                               ;DBC4.0
                                                                                ;DBC4.0
BUFOF=1		;BUFOF, WHICH INDICATES THAT A COP HAS A BUFFER OFFSET          ;DBC4.0
                                                                                ;DBC4.0
REP=4		;REP, WHICHS INDICATES THAT A COP HAS A REPEAT COUNT            ;DBC4.0
                                                                                ;DBC4.0
CNACK=2		;CNACK, WHICH INDICATES THAT AN ENDING CRATE STATION ADDRESS    ;DBC4.0
		;CHECK IS REQUESTED                                             ;DBC4.0
                                                                                ;DBC4.0
CRTOK=200	;CRTOK, WHICH INDICATES THAT A CRATE OVERFLOW IS OK FOR THIS COP;DBC4.0
                                                                                ;DBC4.0
T02OK=100	;T02OK, WHICH INDICATES THAT A CAMAC TIME OUT IS OK FOR THIS COP;DBC4.0
                                                                                ;**-18
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   ;DBC4.0
		;PROCESSING STATE                                               ;DBC4.0
                                                                                ;DBC4.0
FIRST=10	;FIRST, WHICH SHOWS THAT SOME ADDRESS INITALIZATION MUST BE     ;DBC4.0
		;DONE FOR LIST PROCESSING                                       ;DBC4.0
                                                                                ;DBC4.0
LODAD=20	;LODAD, SHOWS THAT J411 MUST HAVE A NEW ADDRESS GENERATED       ;DBC4.0
                                                                                ;DBC4.0
T02=2000	;T02, WHICH IS THE CAMAC TIME OUT BIT OF THE CSR                ;DBC4.0
                                                                                ;DBC4.0
COVF=1000	;COVF, WHICH IS THE CRATE OVERFLOWT OF THE CSR                  ;DBC4.0
                                                                                ;**-2
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.

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        ;DBC4.0
		;ALLOWED                                                        ;DBC4.0
.IIF DF LSTPDV	MAXOPR=MAXOPR+<2*1>	;IF LIST PROCESSING ONE MORE TYPE OF RET;DBC4.0
                                                                                ;**-2
RTFLD=170	;THIS DEFINES THE FIELD OF THE SUBFUNCTION THAT CONTAINS THE
		;RETURN CODE SELECT

;-
	.PAGE                                                                   ;DBC4.0
;
; 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                                                  ;DBC4.0
	.IIF NDF	M$$MGE, .ERROR; MEMORY MANAGEMENT MUST BE USED ON       ;DBC4.0
	.IIF NDF	JORW, .ERROR;  LIST PROCESSING DRIVER                   ;DBC4.0
	.IIF NDF	A$$CHK, .ERROR; ADDRESS CHECKING REQUIRED               ;DBC4.0
	.ENDC                                                                   ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; GENERATE A WORD THAT SHOWES WHICH OPTIONS HAVE BEEN SELECTED                  ;DBC4.0
;                                                                               ;DBC4.0
                                                                                ;DBC4.0
                                                                                ;DBC4.0
TMP=0                                                                           ;DBC4.0
.IIF DF JORW	TMP=TMP!4                                                       ;DBC4.0
.IIF DF LSTPDV	TMP=TMP!2                                                       ;DBC4.0
.IIF DF SELER	TMP=TMP!1                                                       ;DBC4.0
                                                                                ;DBC4.0
DRVTYP:	.WORD	TMP                                                             ;DBC4.0

;
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
;-                                                                              ;DBC4.0
                                                                                ;DBC4.0
;
;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
                                                                               ;DBC4.0
;+                                                                              ;DBC4.0
; CMINI IS ENTERED BEFORE QUEUING THE IO PACKET ON THE QUEUE                    ;DBC4.0
; IF THE FUNCTION IS ANY FUNCTION OTHER THEN A LIST PROCESSING FUNCTION,        ;DBC4.0
;THE PACKET IS QUEUED ONTO THE CORRECT QUEUE AND THEN DEQUEUED                  ;DBC4.0
;BY CMINI1                                                                      ;DBC4.0
;                                                                               ;DBC4.0
;IF THE FUNCTION IS A LIST PROCESSING FUNCTION, THE COMMAND LIST IS ADDRESS     ;DBC4.0
;CHECKED AND IT ITS LOCATION IS RELOCATED TO OPTIMIZE MAPPING                   ;DBC4.0
;TO THE LIST FOR PROCESSING                                                     ;DBC4.0
;                                                                               ;DBC4.0
; THE FORMAT OF THE IO PACKET (USED FOR LIST PROCESSING) IS:                    ;DBC4.0
;                                                                               ;DBC4.0
;	I.PRN+00=	FIRST WORD OF NPR MAPPING ADDRESS                       ;DBC4.0
;	I.PRM+02=	SECOND WORD OF ABOVE                                    ;DBC4.0
;	I.PRM+04=	BYTE COUNT OF BUFFER                                    ;DBC4.0
;	I.PRM+06=	RELOCATED ADDRESS OF LIST (FILLED IN HERE)              ;DBC4.0
;	I.PRM+10=	SECOND PART OF ABOVE                                    ;DBC4.0
;	I.PRM+12=	VERTUAL ADDRESS OF LIST                                 ;DBC4.0
;	I.PRM+14=	BYTE COUNT OF LIST                                      ;DBC4.0
;                                                                               ;DBC4.0
;                                                                               ;DBC4.0
; ON ENTRY TO CMINI THE REGISTERS LOOK LIKE:                                    ;DBC4.0
;                                                                               ;DBC4.0
;	R1=	ADDRESS OF IO PACKET                                            ;DBC4.0
;	R4=	SCB ADDRESS                                                     ;DBC4.0
;	R5=	UCB ADDRESS                                                     ;DBC4.0
;                                                                               ;DBC4.0
;-                                                                              ;DBC4.0
                                                                                ;DBC4.0
CMINI::                                                                         ;DBC4.0
	.IF DF	LSTPDV                                                          ;DBC4.0
	BITB	#1,U.UNIT(R5)	;CHECK IF DMA UNIT                              ;DBC4.0
	BEQ	5$		;IF EQ NO SO JUST QUEUE PACKET                  ;DBC4.0
                                                                                ;DBC4.0
	BITB	#1,I.FCN(R1)	;CHECK IF LIST PROCESSING DMA                   ;DBC4.0
	BEQ	5$		;IF EQ NO JUST NORMAL DMA                       ;DBC4.0
                                                                                ;DBC4.0
	MOV	R1,R3		;SAVE ADDRESS OF IO PACKIT                      ;DBC4.0
	MOVB	I.FCN(R3),R1	;CHECK THE SUBFUNCTION                          ;DBC4.0
	CMP	R1,#1                                                           ;DBC4.0
	BLE	2$		;IF LE OK                                       ;DBC4.0
	MOV	#IE.ONP&377,R0	;LOAD BAD SUBFUNCTION ERROR                     ;DBC4.0
	BR	3$		;AND ERROR OUT                                  ;DBC4.0
                                                                                ;DBC4.0
2$:	MOV	I.PRM+12(R3),R0	;SET UP ADDRESS TO CHECK                        ;DBC4.0
	MOV	I.PRM+14(R3),R1	;AND SIZE                                       ;DBC4.0
	CALL	$ACHCK		;AND DO THE CHECK                               ;DBC4.0
                                                                                ;DBC4.0
	BCC	1$		;IF C CLEAR OK ELSE                             ;DBC4.0
	MOV	#IE.SPC&377,R0	;INDICATE ERROR                                 ;DBC4.0
3$:	CLR	R1                                                              ;DBC4.0
	CALLR	$IOFIN		;AND COMPLEATE PROCESSING OF PACKIT             ;DBC4.0
                                                                                ;DBC4.0
1$:	CALL	$RELOC		;NOW RELOCATE ADDRESS OF COMMAND BUFFER         ;DBC4.0
	MOV	R1,I.PRM+6(R3)	;SAVE FIRST PART OF MAPPING INFO                ;DBC4.0
	MOV	R2,I.PRM+10(R3)	;SAVE SECOND PART OF MAPPING INFO               ;DBC4.0
	MOV	R3,R1		;RESTORE IOPACKIT ADDRESS                       ;DBC4.0
                                                                                ;DBC4.0
	.ENDC                                                                   ;DBC4.0
                                                                                ;DBC4.0
5$:	MOV	R4,R0		;GET ADDRESS OF SCB TO STICK PACKIT ON          ;DBC4.0
	CALL	$QINSP		;INSERT PACKIT ON QUEUE                         ;DBC4.0
                                                                                ;DBC4.0
                                                                                ;DBC4.0
                                                                                ;DBC4.0
	.PAGE                                                                   ;DBC4.0
                                                                                ;DBC4.0
;+                                                                              ;DBC4.0
; CMINI1 IS ENTERED AT THE END OF A PREVOUS I/O OPERATION TO PROPAGATE THE      ;DBC4.0
;EXECUTION OF THE DRIVER. IF THE CONTROLLER IS NOT BUSY, AN ATTEMPT             ;**-3
;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                    ;DBC4.0
	BCC	1$		;IF CARRY CLEAR DEQUEUED OK                     ;**-1
	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                               ;DBC4.0
	MOV	R3,U.RTSE(R5)	;AND SAVE IT                                    ;**-1
	BIC	#^C<CM.NMS>,(R0) ;INITALIZE THE U.CW2 WORD
	CLR	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                                 ;DBC4.0
;                                                                               ;DBC4.0
A1:	JMP	A                                                               ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; WRI IS WHERE YOU GO IF THE FUNCTION IS ONE.                                   ;DBC4.0
;                                                                               ;DBC4.0
WRI:	MOVB	I.FCN(R1),R3	;THE SUBFUNCTON IS PUT IN R3,                   ;DBC4.0
	BIC	#177770,R3	;CLEAR OFF JUNK                                 ;DBC4.0
	CMP	R3,#3		;AND IT IS CHECKED FOR                          ;DBC4.0
	BLO	1$		;LEGALITY.                                      ;DBC4.0
	BR	EONP		;IF NOT LEGAL, EONP WILL INDICAT IT.            ;DBC4.0
1$:	ASL	R3		;IF LEGAL, A WORD INDEX IS GENERATED            ;DBC4.0
	JMP	@DPT1(R3)	;AND THE PROPER FUNCTION IS DISPATCHED.         ;DBC4.0
DPT1:	.WORD	2$,EONP,3$                                                      ;DBC4.0
;                                                                               ;**-10
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.         ;DBC4.0
	MOV	I.PRM+2(R1),DATA(R2) ;IN EITHER CASE,                           ;DBC4.0
	BR	A1		;A BRANCH TO A IS DONE.                         ;DBC4.0
;                                                                               ;**-3
; FOR A NON DATA TRANSFER
;
3$:	JSR	PC,SETUP	;THE REGISTERS ARE SETUP
	BR	A1		;AND A BRANCH TO A IS DONE.                     ;DBC4.0
;                                                                               ;**-1
; FOR A READ FUNCTION
;
RED:	MOVB	I.FCN(R1),R3	;THE SUBFUNCTION IS CHECKED
	BIC	#177770,R3	;CLEAR OFF JUNK                                 ;DBC4.0
	CMP	R3,#2		;FOR LEGALITY AND IF NOT                        ;DBC4.0
	BLO	TICTAC		;OK IE.ONP IS SENT TO THE $IODON                ;DBC4.0
                                                                                ;DBC4.0
EONP:	MOVB	#IE.ONP&377,U.ST1R(R5) ;ROUTINE. OTHERWISE, THE SUBFUNCTION     ;DBC4.0
	JMP	DON                                                             ;DBC4.0
                                                                                ;DBC4.0
TICTAC:	ASL	R3		;IS MADE INTO A WORD INDEX                      ;**-5
	JMP	@DPT2(R3)	;AND DISPATCHED.
DPT2:	.WORD	5$,6$
;
;
5$:	JSR	PC,SETUP	; FOR A PROGRAMMED DATA TRANSFER READ THE
1$:	TST	(R2)		;OPERATION IS STARTED BY A CALL TO SETUP
				;AND THEN WAIT FOR THE TASK COMPLETION
	BPL	1$		;READY BIT TO COME UP.
	MOV	DATA(R2),-(SP)	;THEN THE LOW 16 BITS ARE PUSHED ON
	CALL	$PTWRD		;THE STACK AND PLACED IN THE BUFFER BY A CALL
				;TO $PTWRD.
	BIT	#MD24,I.PRM+10(R1) ;THE FNA WORD IS THEN CHECKED FOR
	BNE	2$		;24 BIT MODE AND IF NOT SET WILL
	CLR	-(SP)		;CLEAR THE NEXT LOCATION IN THE USERS BUFFER
	BR	3$		;OTHERWISE, THE UPPER 8 BITS ARE
2$:	MOV	DATA(R2),-(SP)	;PLACED THERE.
3$:	CALL	$PTWRD		;
	BR	A		;THEN BRANCH TO A OF COURSE.
;
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               ;DBC4.0
	CALL	$PTWRD                                                          ;**-1
	MOV	(R4)+,-(SP)	;
	CALL	$PTWRD
	MOV	(R4)+,-(SP)	;
	CALL	$PTWRD
	MOV	(R4)+,-(SP)
	CALL	$PTWRD
	MOV	(R4),-(SP)
	CALL	$PTWRD
	MOV	(SP)+,R4	;
	MOVB	#IS.SUC&377,U.ST1R(R5) ;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                                 ;DBC4.0
	CMP	R3,#1		;CHECK FOR LEGAL SUBFUNCTION                    ;DBC4.0
	BGT	EONP		;OPPS AN ERROR                                  ;DBC4.0
	ASL	R3                                                              ;DBC4.0
	JMP	@DPT3(R3)	;DISPATCH FUNCTION                              ;DBC4.0
;                                                                               ;DBC4.0
DPT3:	.WORD	NORDMA,LSTDMA                                                   ;DBC4.0
LSTDMA:                                                                         ;DBC4.0
	.IF DF	LSTPDV                                                          ;DBC4.0
	MOV	R5,R0		;USE R0 AS A POINTER TO UCB LOCATIONS           ;DBC4.0
	ADD	#U.EEND,R0	;GENERATE A REAL POINTER NOW                    ;DBC4.0
	CLR	(R0)+		;CLEAR EXPECTED CAMAC END STATION AND SUBADDRESS;DBC4.0
	CLR	(R0)+		;CLEAR FLAG WORD                                ;DBC4.0
	CLR	(R0)+		;CLEAR U.DBBR                                   ;DBC4.0
	CLR	(R0)+		;AND U.LNPR                                     ;DBC4.0
	CLR	(R0)+                                                           ;DBC4.0
	MOV	I.PRM+14(R1),(R0)+ ;SET IN SIZE OF CONTROLL BUFFER              ;DBC4.0
	MOV	I.PRM+6(R1),(R0)+ ;SET IN RELOCATED CONTROL BUFFER ADDRESS      ;DBC4.0
	MOV	I.PRM+10(R1),(R0)+ ;                                            ;DBC4.0
	CLR	(R0)+		;CLEAR U.COPC                                   ;DBC4.0
	CLR	(R0)+		;AND U.REPT                                     ;DBC4.0
	CLR	(R0)+		;AND U.BYTR                                     ;DBC4.0
	BIS	#<FIRST!LSTP>,U.CW2(R5) ;SHOW PROCESSING LISTS AND THAT FIRST TI;DBC4.0
	MOV	KISAR6,-(SP)	;SAVE MAPPING                                   ;DBC4.0
	MOV	U.CBRL(R5),KISAR6 ;GENERATE OWN MAPPING                         ;DBC4.0
	MOV	U.CBRL+2(R5),R2                                                 ;DBC4.0
	CALL	SETUPL		;SETUP THE LIST STUFF                           ;DBC4.0
	BCC	1$		;IF SETUP OK BRANCH AROUND ERROR                ;DBC4.0
	MOVB	R0,U.ST1R(R5)	;SAVE ERROR INFO                                ;DBC4.0
	MOV	(SP)+,KISAR6	;RESTORE MAPPING                                ;DBC4.0
	BR	DON1		;AND EXIT                                       ;DBC4.0
                                                                                ;DBC4.0
1$:	BIS	#PL,PS		;RAISE PROCESSOR LEVEL TO INTERFACE LEVEL       ;DBC4.0
	BIS	#4,@S.CSR(R4)	;AND ENABLE INTERUPT                            ;DBC4.0
	CALL	EXCTFN		;AND START TRANSFER                             ;DBC4.0
	MOV	(SP)+,KISAR6	;RESTORE MAPPING                                ;DBC4.0
	BIC	#PR7,PS		;LOWER PROCESSOR LEVEL TO THAT OF SYSTEM        ;DBC4.0
	BR	RET		;AND GO BACK TO SYSTEM                          ;DBC4.0
                                                                                ;DBC4.0
                                                                                ;DBC4.0
	.IFF                                                                    ;DBC4.0
	JMP	EONP		;IF NOT LIST PROCESSING DRIVER, TAKE ERROR EXIT ;DBC4.0
	.ENDC                                                                   ;DBC4.0
                                                                                ;DBC4.0
                                                                                ;DBC4.0
NORDMA:                                                                         ;DBC4.0
	SEC			;HERE SET THE CARRY                             ;**-2
	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
	MOVB	#IS.SUC&377,U.ST1R(R5) ;ASSUME SUCCESS                          ;DBC4.0
	BR	DON1                                                            ;DBC4.0
;                                                                               ;**-3
; 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                                                             ;DBC4.0
	JMP	DD		;ABORT AND TIMEOUT AND IF SO JUMP TO DD.        ;DBC4.0
DON:                                                                            ;**-4
	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
				;$IODON IS EXECUTED
				;
	CALL	$IODON
	JMP	CMINI1		;AND THEN ATTEMPT TO DEQUEUE ANOTHER IO PACKET. ;DBC4.0
;                                                                               ;**-1
; 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.                           ;DBC4.0
;IT IS ENTERED WHEN AN OPERATION WAS NOT DONE WHEN THE PROGRAM JUMPED TO        ;DBC4.0
;A.                                                                             ;DBC4.0
; OR WHEN ANY LIST PROCESSING FUNCTION IS OPERATING                             ;DBC4.0
;                                                                               ;**-3
$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            ;DBC4.0
                                                                                ;DBC4.0
	.IF DF LSTPDV                                                           ;DBC4.0
	BIT	#LSTP,U.CW2(R5)	;CHECK IF LIST OPERATION                        ;DBC4.0
	BEQ	NORM		;IF EQ NO                                       ;DBC4.0
                                                                                ;DBC4.0
	MOV	KISAR6,-(SP)	;SAVE AR6                                       ;DBC4.0
	MOV	R0,-(SP)	;AND SOME REGISTERS                             ;DBC4.0
	MOV	R1,-(SP)                                                        ;DBC4.0
	MOV	R2,-(SP)                                                        ;DBC4.0
	MOV	R3,-(SP)                                                        ;DBC4.0
                                                                                ;DBC4.0
CONT:	BIC	#44,@S.CSR(R4)	;CLEAR OUT SEQUENCER AND ENABLE                 ;DBC4.0
	MOV	U.CBRL(R5),KISAR6 ;POINT TO CONTROLL BUFFER                     ;DBC4.0
	MOV	U.CBRL+2(R5),R2	;GET RELOCATED ADDRESS FOR ABOVE                ;DBC4.0
	CALL	ERRCK		;CHECK FOR ANY ERRORS                           ;DBC4.0
	BCS	LDON		;IF CARRY SET, AN ERROR SO EXIT                 ;DBC4.0
				;R0 CONTAINS ERROR CODE                         ;DBC4.0
	TSTB	1(R2)		;CHECK IF AT END OF LIST                        ;DBC4.0
	BNE	1$		;IF NOT EQ NO                                   ;DBC4.0
	MOV	#IS.SUC,R0	;SHOW SUCCESS                                   ;DBC4.0
	BR	LDON		;AND EXIT                                       ;DBC4.0
                                                                                ;DBC4.0
1$:	CALL	SETUPL		;SETUP NEXT LIST                                ;DBC4.0
	BCS	LDON		;IF ERROR EXIT IMMEDEATLY                       ;DBC4.0
	BIS	#4,@S.CSR(R4)	;ENABLE INTERUPTS                               ;DBC4.0
	CALL	EXCTFN		;AND EXECUTE THE FUNCTION                       ;DBC4.0
	TST	@S.CSR(R4)	;CHECK IF DONE                                  ;DBC4.0
	BMI	CONT		;YES SO PROCESS NEXT PACKIT                     ;DBC4.0
                                                                                ;DBC4.0
	MOV	(SP)+,R3	;ELSE JUST EXIT                                 ;DBC4.0
	MOV	(SP)+,R2                                                        ;DBC4.0
	MOV	(SP)+,R1                                                        ;DBC4.0
	MOV	(SP)+,R0                                                        ;DBC4.0
	MOV	(SP)+,KISAR6	;RESET MAPPING                                  ;DBC4.0
	CALLR	$INTXT                                                          ;DBC4.0
                                                                                ;DBC4.0
LDON:	DECB	U.COPC(R5)	;ADJUST NUMBER OF PACKITS PROCESSED             ;DBC4.0
	MOVB	U.COPC(R5),U.ST1R+1(R5) ;SAVE NUMBER OF PACKITS                 ;DBC4.0
	MOVB	R0,U.ST1R(R5)	;AND SHOW RETURN VALUE                          ;DBC4.0
	MOV	(SP)+,R3                                                        ;DBC4.0
	MOV	(SP)+,R2                                                        ;DBC4.0
	MOV	(SP)+,R1                                                        ;DBC4.0
	MOV	(SP)+,R0                                                        ;DBC4.0
	MOV	(SP)+,KISAR6                                                    ;DBC4.0
                                                                                ;DBC4.0
	.ENDC                                                                   ;DBC4.0
                                                                                ;DBC4.0
NORM:	CLRB	S.CTM(R4)	;CLEAR THE TIMEOUT                              ;DBC4.0
	CALL	USRRST		;GET USER SELECTED RETURN                       ;DBC4.0
	MOV	@S.CSR(R4),U.CW3(R5) ;SAVE STATUS WORD                          ;DBC4.0
	BIC	#4,@S.CSR(R4)	;AND CLEAR THE TASK COMPLETION ENABLE           ;DBC4.0
	BIC	#LSTP!DMA,U.CW2(R5) ;BIT AND THE DMA MODE BIT.                  ;DBC4.0
	CALL	$FORK		;NOW A $FORK IS DONE TO PRODUCE A SYSTEM        ;DBC4.0
				;PROCESS.                                       ;DBC4.0
	JMP	DON1		;TO DON1.                                       ;DBC4.0
;                                                                               ;**-66
; 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                       ;DBC4.0
	MOV	R3,MADR(R2)	;START LOADING THE BDS REGISTERS STARTING       ;**-2
				;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$:	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                               ;DBC4.0
	.IIF DF LSTPDV	.WORD	SAVTOP                                          ;DBC4.0
;                                                                               ;**-1
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                    ;DBC4.0
	BR	AL6DN                                                           ;DBC4.0
	.IF DF LSTPDV                                                           ;DBC4.0
SAVTOP:	MOV	U.CNT(R5),U.RTUN(R5) ;GET NUMBER OF BYTES IN BUFF               ;DBC4.0
	SUB	U.DBBR(R5),U.RTUN(R5) ;REMOVE NUMBER OF BYTES NOT USED          ;DBC4.0
	BR	AL6DN                                                           ;DBC4.0
                                                                                ;DBC4.0
	.ENDC                                                                   ;DBC4.0
                                                                                ;DBC4.0
                                                                                ;DBC4.0
AL6DN:	MOV	(SP)+,R1	;RESTORE RTEGISTERS
	MOV	(SP)+,R0	;
	RETURN

;
	.IF DF 	LSTPDV                                                          ;DBC4.0
	.ENDC                                                                   ;DBC4.0
	.IF DF	LSTPDV                                                          ;DBC4.0
	.ENABL	LSB                                                             ;DBC4.0
                                                                                ;DBC4.0
;+                                                                              ;DBC4.0
; SETUPL                                                                        ;DBC4.0
; THIS ROUTINE IS USED TO SETUP THE UCB LIST PROCESSING DATA BASE               ;DBC4.0
; BEFORE ATTEMPTING TO EXECUTE A FUNCTION                                       ;DBC4.0
                                                                                ;DBC4.0
;INPUTS:                                                                        ;DBC4.0
;                                                                               ;DBC4.0
;	R2=	POINTER TO COP                                                  ;DBC4.0
;	R4=	SCB ADDRESS                                                     ;DBC4.0
;	R5=	UCB ADDRESS                                                     ;DBC4.0
                                                                                ;DBC4.0
;OUTPUTS:                                                                       ;DBC4.0
;                                                                               ;DBC4.0
;	IF CARRY SET, AN ERROR HAS OCCURED AND THE ERROR CODE WILL              ;DBC4.0
;	BE IN R0.                                                               ;DBC4.0
;                                                                               ;DBC4.0
;	IF CARRY CLEAR, ROUTINE OPERATION IS CORRECT                            ;DBC4.0
;                                                                               ;DBC4.0
;                                                                               ;DBC4.0
                                                                                ;DBC4.0
;NOTE: IN THE FOLLOWING, R0 IS USED AS A SCRATCH REGISTER AND R1 POINTS         ;DBC4.0
;TO THE CURRENT OPTIONAL WORD.                                                  ;DBC4.0
;                                                                               ;DBC4.0
;                                                                               ;DBC4.0
;-                                                                              ;DBC4.0
                                                                                ;DBC4.0
                                                                                ;DBC4.0
SETUPL::                                                                        ;DBC4.0
	MOVB	(R2),R1		;GET FLAG BYTE                                  ;DBC4.0
	MOVB	R1,U.FLAG(R5)	;SAVE IT AND                                    ;DBC4.0
	MOV	U.CW2(R5),R0	;GET CW2 TO GET FIRST                           ;DBC4.0
	BIC	#^C FIRST,R0	;ADD OFF ANY JUNK                               ;DBC4.0
	BIC	#^C BUFOF,R1	;ISOLATE BUFOF                                  ;DBC4.0
	BIS	R1,R0		;MERGE BITS                                     ;DBC4.0
	MOV	R2,R1		;GENERATE POINTER TO VARIABLE PART              ;DBC4.0
	ADD	#10,R1		;POINT TO VARIABLE PART                         ;DBC4.0
	TST	R0		;CHECK IF FIRST OR BUFFOR OFFSET                ;DBC4.0
	BEQ	20$		;IF EQ NO                                       ;DBC4.0
                                                                                ;DBC4.0
	BIT	#BUFOF,R0	;NOW CHECK IF BECAUSE OF FIRST OR IF            ;DBC4.0
				;A NEW BUFFER IS REQUESTED                      ;DBC4.0
	BEQ	10$		;FIRST IF EQ                                    ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; HERE A BUFFER OFFSET HAS BEEN REQUESTED, AND A NEW 18 BIT ADDRESS MUST        ;DBC4.0
; BE GENERATED ALSO THE  NUMBER OF BYTES IN THE DATA BUFFER MUST BE UPDATED     ;DBC4.0
;                                                                               ;DBC4.0
	CMP	(R1),U.CNT(R5)	;CHECK IF BUFFER OFFSET OUTSIDE OF BUFF         ;DBC4.0
	BGT	50$		;IF GT YES (NOTE, BUFFERS MUST BE <16K WORDS)   ;DBC4.0
	MOV	U.BUF+2(R5),U.LNPR+2(R5) ;GET LOWER 16 BITS OF ADDRESS          ;DBC4.0
	MOV	U.BUF(R5),U.LNPR(R5) ;AND UPPER 2 BITS IN BITS 4 AND 5          ;DBC4.0
	ADD	(R1),U.LNPR+2(R5) ;ADD ON BUFFER BIAIS                          ;DBC4.0
	BCC	1$                                                              ;DBC4.0
	ADD	#20,U.LNPR(R5)	;IF CARRY SET NEED TO BUMP UPPER BITS           ;DBC4.0
	BIT	#100,U.LNPR(R5)	;CHECK IF IMPOSSABLE ERROR OCCURED              ;DBC4.0
	BNE	49$                                                             ;DBC4.0
1$:	MOV	U.CNT(R5),U.DBBR(R5) ;SET THE NUMBER OF BYTES REMAINING         ;DBC4.0
	SUB	(R1)+,U.DBBR(R5) ;SUBTRACT OFF BIAIS                            ;DBC4.0
	BR	19$		;GO DO NEXT CHECK                               ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; HERE IS WHERE THE FIRST PROCESSING IS SET UP                                  ;DBC4.0
; THIS IS DONE WHEN THE FIRST COP IS BEING DONE AND THAT COP DOES NOT           ;DBC4.0
; SPECIFY A BUFFER OFFSET                                                       ;DBC4.0
;                                                                               ;DBC4.0
10$:                                                                            ;DBC4.0
	MOV	U.BUF(R5),U.LNPR(R5) ;SAVE FIRST PART OF ADDRESS                ;DBC4.0
	MOV	U.BUF+2(R5),U.LNPR+2(R5) ;AND SECOND PART                       ;DBC4.0
	MOV	U.CNT(R5),U.DBBR(R5) ;AND NUMBER OF BYTES REMAINING             ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; RESET THINGS AND SHOW NEED TO LOAD ADDRESS                                    ;DBC4.0
;                                                                               ;DBC4.0
19$:	BIC	#FIRST,U.CW2(R5) ; CLEAR FIRST AS IT ISN'T ANY MORE             ;DBC4.0
	BIS	#LODAD,U.CW2(R5) ; AND SHOW NEED TO LOAD THE ADDRESS            ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; HERE CHECK IF AN CNA CHECK IS TO BE MADE AT THE END OF THE OPERATION          ;DBC4.0
; AND IF SO SETUP THAT CHECK                                                    ;DBC4.0
;                                                                               ;DBC4.0
20$:                                                                            ;DBC4.0
	CLR	U.EEND(R5)	;ASSUME NO CHECK MADE                           ;DBC4.0
	BITB	#CNACK,(R2)	;CHECK IF CHECK IS ENABLED                      ;DBC4.0
	BEQ	30$		;IF EQ, NO                                      ;DBC4.0
                                                                                ;DBC4.0
	MOV	(R1)+,U.EEND(R5) ;SAVE THE END CHECK                            ;DBC4.0
;                                                                               ;DBC4.0
; NEXT CHECK FOR A REPEAT COUNT                                                 ;DBC4.0
;                                                                               ;DBC4.0
30$:                                                                            ;DBC4.0
	BITB	#REP,(R2)	;CHECK FLAG WORD                                ;DBC4.0
	BEQ	35$		;IF EQ NO REPEAT COUNT                          ;DBC4.0
                                                                                ;DBC4.0
	TST	U.REPT(R5)	;CHECK IF ALREADY PROCESSING REPEAT COUNT       ;DBC4.0
	BNE	35$		;IF SO DON'T RESET                              ;DBC4.0
                                                                                ;DBC4.0
	MOV	(R1)+,U.REPT(R5) ;GET REPEAT COUNT                              ;DBC4.0
35$:	TST	U.REPT(R5)	;IF NO REPEAT COUNT INITALIZE TO 1              ;DBC4.0
	BNE	40$                                                             ;DBC4.0
	INC	U.REPT(R5)                                                      ;DBC4.0
;                                                                               ;DBC4.0
; NOW NEED TO GENERATE THE CALCULATED NUMBER OF BYTES REMAINING IN THE          ;DBC4.0
; BUFFER. THIS IS OBTAINED FROM THE EXTENDED WORD COUNT WORD OF THE             ;DBC4.0
; MANDTORY PART OF THE BUFFER                                                   ;DBC4.0
; THIS ALSO GENERATES THE NUMBER OF BYTES TO BE TRNASFERED                      ;DBC4.0
;                                                                               ;DBC4.0
40$:                                                                            ;DBC4.0
	MOV	4(R2),R0	;GET EXTENDED WORD COUNT WORD                   ;DBC4.0
	MOV	#170000,R1	;GET MASK WORD                                  ;DBC4.0
	CLC			;RETURN OK                                      ;DBC4.0
	BIC	R1,R0		;CHECK FOR WORD COUNT OF ZERO                   ;DBC4.0
	BEQ	51$		;IF IS EXIT ROUTINE                             ;DBC4.0
                                                                                ;DBC4.0
	BIS	R1,R0		;ELSE MAKE THE WORD COUNT A REAL NEGATIVE NUMBER;DBC4.0
	NEG	R0		;AND MAKE POSATIVE                              ;DBC4.0
	ASL	R0		;BYTE COUNT                                     ;DBC4.0
	BIT	#MD24,6(R2)	;CHECK FOR 24 BIT MODE OPERATION                ;DBC4.0
	BEQ	44$		;IF EQ 16 BIT MODE                              ;DBC4.0
	BIS	#MD24,U.FLAG(R5) ;INDICATE 24 BIT MODE IN FLAG WORD             ;DBC4.0
	ASL	R0		;ADJUST BYTE AGAIN IF 24 BIT MODE               ;DBC4.0
44$:	SUB	R0,U.DBBR(R5)	;SUBTRACT OFF ALLOCATED BYTES                   ;DBC4.0
	BMI	50$		;IF NEGATIVE, BUFF TOO BIG                      ;DBC4.0
	MOV	R0,U.BYTR(R5)	;SAVE NUMBER OF BYTES ALLOWED IN TRANSFER       ;DBC4.0
	CLC                                                                     ;DBC4.0
	BR	51$		;LEAVE INDICATING OK                            ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; ERROR PROCESSING                                                              ;DBC4.0
;                                                                               ;DBC4.0
49$:	MOV	#IE.IMP,R0                                                      ;DBC4.0
	BR	52$                                                             ;DBC4.0
                                                                                ;DBC4.0
50$:	MOV	#IE.OVR,R0	;SHOW ATTEMPT TO GO OUTSIDE BUFFER              ;DBC4.0
52$:	SEC                                                                     ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; EXIT                                                                          ;DBC4.0
;                                                                               ;DBC4.0
51$:	RETURN                                                                  ;DBC4.0
                                                                                ;DBC4.0
	.ENABL	LSB                                                             ;DBC4.0
                                                                                ;DBC4.0
;+                                                                              ;DBC4.0
; EXCTFN IS CALLED TO EXECUTE THE CAMAC FUNCTION FROM THE INFORMATION IN        ;DBC4.0
; THE UCB DATA BASE AND THE INFORMATION IN THE MANDATORY PART OF THE            ;DBC4.0
; COP                                                                           ;DBC4.0
;                                                                               ;DBC4.0
;INPUT:                                                                         ;DBC4.0
;                                                                               ;DBC4.0
;	R2=	ADDRESS OF THE COP                                              ;DBC4.0
;	R4=	SCB ADDRESS                                                     ;DBC4.0
;	R5=	UCB ADDRESS                                                     ;DBC4.0
;                                                                               ;DBC4.0
;                                                                               ;DBC4.0
;                                                                               ;DBC4.0
;OUTPUT:                                                                        ;DBC4.0
;                                                                               ;DBC4.0
;	R2=	ADDRESS OF NEXT COP TO EXECUTE                                  ;DBC4.0
;                                                                               ;DBC4.0
; U.COPC IS BUMPED EACH TIME A COP ADVANCE IS MADE THIS IMPLIES THAT            ;DBC4.0
; WHEN EXITING, NEED TO DECREMENT COP COUNT BY ONE                              ;DBC4.0
;                                                                               ;DBC4.0
;                                                                               ;DBC4.0
;NOTE: R1 CONTAINS THE ADDRESS OF THE CSR OF THE INTERFACE AND                  ;DBC4.0
; R0 IS USED AS SCRATCH                                                         ;DBC4.0
;                                                                               ;DBC4.0
;                                                                               ;DBC4.0
;                                                                               ;DBC4.0
;-                                                                              ;DBC4.0
                                                                                ;DBC4.0
                                                                                ;DBC4.0
EXCTFN::                                                                        ;DBC4.0
	MOV	S.CSR(R4),R1	;GET THE ADDRESS OF THE INTERFACE               ;DBC4.0
	MOV	XTEND(R1),R0	;GET THE OLD ADDRESS IBT                        ;DBC4.0
	BIC	#^C 30000,R0	;AND CLEAR OFF JUNK                             ;DBC4.0
	BIT	#LODAD,U.CW2(R5) ;CHECK IF WE NEED TO UPDATE THE JORWAY ADDRESS ;DBC4.0
	BEQ	10$		;IF EQ NO                                       ;DBC4.0
                                                                                ;DBC4.0
	BIC	#LODAD,U.CW2(R5) ;CLEAR LOAD BIT                                ;DBC4.0
	MOV	U.LNPR+2(R5),MADR(R1) ;LOAD THE LOW 16 BITS                     ;DBC4.0
	MOV	U.LNPR(R5),R0	;GET THE UPPER TWO BITS AND                     ;DBC4.0
	SWAB	R0		;POSITION CORECTLY                              ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; NOW DO THE OPERATION                                                          ;DBC4.0
;                                                                               ;DBC4.0
10$:                                                                            ;DBC4.0
	ADD	#2,R2		;POINT R2 TO CRATE SELECT                       ;DBC4.0
	MOV	(R2)+,CRAT(R1)	;FILL IN CRATE WORD                             ;DBC4.0
	MOV	(R2)+,-(SP)	;GET THE EXTENDED WORDCOUNT WORD                ;DBC4.0
	BIC	#30000,(SP)	;RESET HIGH ADDRESS BITS                        ;DBC4.0
	BIS	(SP)+,R0	;AND NOW OR ON CORRECT SETTING                  ;DBC4.0
	MOV	R0,XTEND(R1)	;AND SET IN THE INTERFACE                       ;DBC4.0
	MOV	(R2),FNA(R1)	;AND THE FUNCTION                               ;DBC4.0
	SUB	#6,R2		;RESET R2 TO POINT TO TOP OF COP                ;DBC4.0
;                                                                               ;DBC4.0
; AT THIS POINT, THE CAMAC OPERATION IS IN PROGRESS                             ;DBC4.0
; WE WILL NOW DETURMAIN IF THE COP SHOULD BE ADVANCED AND IF SO WILL DO IT      ;DBC4.0
; THIS HOPEFULLY WILL ALLOW SOME OVERLAP OF CAMAC OPERATION AND PROCESSOR       ;DBC4.0
; OPERATION SO THAT THE INTERUPT OVERHEAD CAN BE AVOIDED IN SOME CASES          ;DBC4.0
;                                                                               ;DBC4.0
	DEC	U.REPT(R5)	;DECREMENT THE REPEAT COUNT                     ;DBC4.0
	BNE	20$		;IF NE THEN THIS PACKIT REPEATS                 ;DBC4.0
                                                                                ;DBC4.0
	MOVB	1(R2),R0	;GET THE OFFSET                                 ;DBC4.0
	ADD	R0,R2		;AND POINT POINTER TO NEXT COP                  ;DBC4.0
	CMP	R2,#150000	;CHECK IF NEED TO ADVANCE APR                   ;DBC4.0
	BLO	19$		;IF LO NO                                       ;DBC4.0
                                                                                ;DBC4.0
	SUB	#10000,R2	;ADJUST RELOCATE                                ;DBC4.0
	ADD	#100,U.CBRL(R5)	;ADJUST NEW APR6 VALUE                          ;DBC4.0
                                                                                ;DBC4.0
19$:	MOV	R2,U.CBRL+2(R5)	;AND OFFSET                                     ;DBC4.0
	INCB	U.COPC(R5)	;AND BUMP COP COUNT                             ;DBC4.0
                                                                                ;DBC4.0
20$:	RETURN                                                                  ;DBC4.0
	                                                                        ;DBC4.0
                                                                                ;DBC4.0
	.ENABL	LSB                                                             ;DBC4.0
                                                                                ;DBC4.0
;+                                                                              ;DBC4.0
;ERRCK                                                                          ;DBC4.0
; THIS MODULE IS USED TO CHECK THAT THE CAMAC OPERATION WAS CORRECT             ;DBC4.0
;                                                                               ;DBC4.0
;INPUTS:                                                                        ;DBC4.0
;                                                                               ;DBC4.0
;	R4=	SCB ADDRESS                                                     ;DBC4.0
;	R5=	UCB ADDRESS                                                     ;DBC4.0
;                                                                               ;DBC4.0
;	R2 PRESERVED                                                            ;DBC4.0
;                                                                               ;DBC4.0
;OUTPUT:                                                                        ;DBC4.0
;                                                                               ;DBC4.0
;	ERROR IF CARRY SET R0 WILL CONTAIN ERROR VALUE                          ;DBC4.0
;	CARRY CLEAR IMPLIES SUCCESS                                             ;DBC4.0
;                                                                               ;DBC4.0
; R1 WILL CONTAIN THE ADDRESS OF THE CSR OF THE DRIVER, R0 AND R3 ARE USED      ;DBC4.0
; FOR SCRATCH                                                                   ;DBC4.0
;                                                                               ;DBC4.0
;                                                                               ;DBC4.0
;-                                                                              ;DBC4.0
                                                                                ;DBC4.0
ERRCK::                                                                         ;DBC4.0
;                                                                               ;DBC4.0
; FIRST CHECK THE CRATE OVERFLOW AND THE T02 BITS AND THERE RESPECTIVE          ;DBC4.0
; ENABLES TO SEE IF AN ERROR SHOULD OCCURE                                      ;DBC4.0
;                                                                               ;DBC4.0
	MOV	S.CSR(R4),R1	;GET CSR ADDRESS                                ;DBC4.0
	BIT	#COVF,(R1)	;CHECK FOR CRATE OVERFLOW                       ;DBC4.0
	BEQ	2$		;IF EQ NO                                       ;DBC4.0
	BITB	#CRTOK,U.FLAG(R5) ;CHECK IF OVERFLOW OK                         ;DBC4.0
	BNE	2$		;IF NOT EQ YED                                  ;DBC4.0
	MOV	#IE.CVF,R0	;SHOW ERROR                                     ;DBC4.0
	BR	50$		;AND TAKE ERROR EXIT                            ;DBC4.0
                                                                                ;DBC4.0
2$:	BIT	#T02,(R1)	;CHECK FOR CAMAC TIME OUT                       ;DBC4.0
	BEQ	3$		;IF EQ NO                                       ;DBC4.0
	BITB	#T02OK,U.FLAG(R5) ;IS T02 OK?                                   ;DBC4.0
	BNE	3$		;IF NE YES                                      ;DBC4.0
	MOV	#IE.CT2,R0	;SHOW ERROR                                     ;DBC4.0
	BR	50$		;AND TAKE ERROR EXIT                            ;DBC4.0
                                                                                ;DBC4.0
3$:	BIT	#CNACK,U.FLAG(R5) ;CHECK FOR CNA CHECK                          ;DBC4.0
	BEQ	10$		;IF EQ NO                                       ;DBC4.0
	MOV	FNA(R1),R0	;GET FNA WORD                                   ;DBC4.0
	MOV	U.EEND(R5),R3	;SAVE END CNA                                   ;DBC4.0
	XOR	R3,R0		;CLEAR EXPECTED BITS IF THEY ARE INDEED ON      ;DBC4.0
	BIC	#177000,R0	;CLEAR OFF JUNK                                 ;DBC4.0
	BNE	5$		;AND IF NOT EQ N AND A DONT MATCH               ;DBC4.0
                                                                                ;DBC4.0
	MOV	CRAT(R1),R0	;GET WORD AGAIN FOR CRATE CHECK                 ;DBC4.0
	XOR	R3,R0		;CHECK IF CRATES EXPECTED                       ;DBC4.0
	BIC	#777,R0		;                                               ;DBC4.0
	BEQ	10$		;IF EQ ALL IS OK                                ;DBC4.0
                                                                                ;DBC4.0
5$:	MOV	#IE.END,R0	;SHOW ERROR                                     ;DBC4.0
	BR	50$		;AND TAKE ERROR EXIT                            ;DBC4.0
                                                                                ;DBC4.0
;                                                                               ;DBC4.0
; THIS PART NOW CHECKS THAT THE 18 BIT ADDRESS IS CORRECT FROM                  ;DBC4.0
;THE CALCULATION OF THE STARTING ADDRESS AND THE NUMBER OF WORDS TRANSFERED     ;DBC4.0
;                                                                               ;DBC4.0
10$:	CLR	-(SP)		;SAVE SPACE FOR NUMBER OF BYTES TRANSFERED      ;DBC4.0
	MOV	XTEND(R1),R0	;GET THE EXTENDED WORD COUNT                    ;DBC4.0
	BIC	#170000,R0	;AND OFF JUNK                                   ;DBC4.0
	BEQ	13$		;IF ZERO ALL WORDS TRANSFERED                   ;DBC4.0
	BIS	#170000,R0	;ELSE MAKE A REAL NEGAITVE NUMBER               ;DBC4.0
				;AND THIS NUMBER IS THE NEGATIVE                ;DBC4.0
				;NUMBER OF WORDS NOT TRANSFERED                 ;DBC4.0
	ASL	R0		;TIMES 2 FOR BYTES                              ;DBC4.0
	BIT	#MD24,U.FLAG(R5) ;CHECK FOR 24 BIT MODE                         ;DBC4.0
	BEQ	11$		;IF EQ NO                                       ;DBC4.0
	ASL	R0		;ELSE ADVANCE AGAIN                             ;DBC4.0
11$:	SUB	R0,(SP)		;PUT POSATIVE NUMBER OF BYTES IN (SP)           ;DBC4.0
                                                                                ;DBC4.0
13$:	MOV	(SP)+,R0	;GET NUMBER OF BYTES NOT TRANSFERED             ;DBC4.0
	ADD	R0,U.DBBR(R5)	;ADJUST NUMBER OF BYTES REMAINING               ;DBC4.0
	SUB	R0,U.BYTR(R5)	;ADJUST NUMBER OF BYTES IN TRANSFER             ;DBC4.0
	ADD	U.BYTR(R5),U.LNPR+2(R5) ;GENERATE CALCULATED 18 BIT ADDRESS     ;DBC4.0
	BCC	14$                                                             ;DBC4.0
	ADD	#20,U.LNPR(R5)	;                                               ;DBC4.0
	BIT	#100,U.LNPR(R5)	;CHECK FOR IMPOSSABLE ERROR                     ;DBC4.0
	BEQ	14$                                                             ;DBC4.0
	MOV	#IE.IMP,R0	;SHOW  ERROR                                    ;DBC4.0
	BR	50$		;AND ERROR EXIT                                 ;DBC4.0
                                                                                ;DBC4.0
14$:	MOV	XTEND(R1),R0	;GET UPPER 2 BITS                               ;DBC4.0
	SWAB	R0		;POSITION AND                                   ;DBC4.0
	BIC	#^C60,R0	;CLEAR JUNK                                     ;DBC4.0
	CMP	U.LNPR(R5),R0	;CHECK THAT BITS ARE SAME                       ;DBC4.0
	BNE	19$		;IF NE NO                                       ;DBC4.0
	CMP	U.LNPR+2(R5),MADR(R1) ;CHECK LOWER BITS                         ;DBC4.0
	BEQ	20$		;IF EQ ALL OK                                   ;DBC4.0
                                                                                ;DBC4.0
19$:	MOV	#IE.JER,R0	;INDICATE ERROR                                 ;DBC4.0
	BISB	#US.OFL,U.ST2(R5) ;SET UNIT OFF LINE AS SICK                    ;DBC4.0
	BR	50$		;AND EXIT WITH ERROR                            ;DBC4.0
                                                                                ;DBC4.0
20$:	CLC			;ALL DONE SO EXIT NICELY                        ;DBC4.0
	BR	51$                                                             ;DBC4.0
                                                                                ;DBC4.0
50$:	SEC			;ERROR EXIT                                     ;DBC4.0
51$:	RETURN                                                                  ;DBC4.0
                                                                                ;DBC4.0
	.ENDC                                                                   ;DBC4.0
                                                                                ;DBC4.0
                                                                                ;DBC4.0
	.END