.DSABL GBL .ENABL LC ; ; MACRO DEFINITIONS FOR MIOP PROGRAM ASSEMBLY ; ; INSTRUCTIONS: ; MV,INM,DEM,AD,SB,IOR,EOR,AND,BCT,BCF,ST,LD ; ; REGISTERS: ; T,ILR,FCNA,WCR,TMP4,QCNT,XCNT,BADD,BSIZ,PSR(PC),MDR,BDL,BDH ; PDR,MAR(ISR),BAR(SWR) ; ; MODIFIERS: ; RDH,RDR,WTR,BRR,BRW,BRC,BGL,EXM,EXC,EXT,INT,CLRC,WTH,BREQ, ; IMM ; ; TEST CONDITIONS: ; DCD,BRD,O,N,Z,BZ,C,Q,X,B10,B11,B12,B13,B14,B15 ; .NLIST ; ; Register definitions ; T = 0 ; TEMPORARY REGISTER ILR = 1 ; INSTRUCTION LOGIC REGISTER (GETS COMMANDS) FCNA = 2 ; THIS REGISTER HOLDS FCNA WCR = 3 ; WORD COUNT REGISTER TMP4 = 4 ; REGISTER 4 QCNT = 5 ; Q ERROR COUNTER REGISTER XCNT = 6 ; COUNTS NUMBER OF X ERRORS BADD = 7 ; Current buffer address BSIZ = 10 ; Currrent buffer size PSR = 11 ; PROGRAM STATUS REGISTER MDR = 12 ; MEMORY DATA REGISTER BDL = 13 ; BRANCH DATA LO REGISTER (16 LO BITS 0-15) BDH = 14 ; BRANCH DATA HI (BITS 16-23) PDR = 15 ; PROGRAM DATA REGISTER ISR = 16 ; INTERNAL STATUS REGISTER (CHAN #) (source) MAR = 16 ; MEMORY ADDRESS REGISTER (destination only) SWR = 17 ; SWITCH REGISTER (source only) BAR = 17 ; Branch address register (destination) ; ; Instruction definitions ; RTN = 120000 ; RETURN INSTRUCTION NO S ALLOWED IMM = 7400 ; IMMEDIATE RH BYTE = SOURCE SLL = 150000 ; SHIFT LEFT LOGICAL SRL = 154000 ; SHIFT RIGHT LOGICAL SLLD = 151000 ; SHIFT LEFT LOGICAL DOUBLE SRLD = 155000 ; SHIFT RIGHT LOGICAL DOUBLE SLR = 152000 ; SHIFT LEFT ROTATE SRR = 156000 ; SHIFT RIGHT ROTATE ; ; Test functions ; DCD = 400 ; TEST DATA CHAN DONE BRD = 1000 ; TEST BRANCH DONE O = 1400 ; TEST OVERFLOW N = 2000 ; TEST CONDITION NEGATIVE Z = 2400 ; TEST CONDITION ZERO ZB = 3000 ; TEST CONDITION BYTE ZERO 0-7 BITS C = 3400 ; TEST CONDITION CARRY OCCURRED Q = 4000 ; TEST CONDITION Q RESPONSE X = 4400 ; TEST BRANCH X RESPONSE B10 = 5000 ; TEST BIT # 12 B11 = 5400 ; TEST BIT # 11 B12 = 6000 ; TEST BIT # 12 B13 = 6400 ; TEST BIT # 13 B14 = 7000 ; TEST BIT # 14 B15 = 7400 ; TEST BIT # 15 ; ; Control functions ; RDH = 400 ; READ + HOLD RDR = 1000 ; READ BUS WTR = 1400 ; WRITE BRR = 2000 ; BRANCH READ BRW = 2400 ; BRANCH WRITE BRC = 3000 ; BRANCH EXECUTE CONTROL FUNCTION BGL = 3400 ; BRANCH GL CYCLE EXM = 4000 ; EXIT WITH QUICK RETURN , MIOP EXIT EXC = 4400 ; EXIT + WAIT FOR LAM, CAMAC RETURN EXT = 5000 ; EXIT NO RETURN INT = 5400 ; INTERRUPT CLRC = 6000 ; CLEAR CARRY WTH = 6400 ; WRITE + HOLD BREQ = 7000 ; BRANCH REQUEST IMM = 7400 ; IMMEDIATE MODE, DATA = LOW BYTE ; ; DEFINE ALL OF THE INSTRUCTIONS ; .MACRO MV ,S,D,F ; MOVE INSTRUCTION .IF NB F .WORD 0+F++D .IFF .WORD 0++D .ENDC .ENDM MV ; .MACRO INM ,S,D,F ; INCREMENT REGISTER .IF NB F .WORD 10000+F++D .IFF .WORD 10000++D .ENDC .ENDM INM ; .MACRO DEM ,S,D,F ; DECREMENT REGISTER .IF NB F .WORD 20000+F++D .IFF .WORD 20000++D .ENDC .ENDM DEM ; .MACRO AD ,S,D,F ; ADD INSTRUCTION .IF NB F .WORD 30000+F++D .IFF .WORD 30000++D .ENDC .ENDM AD ; .MACRO SB ,S,D,F ; SUBTRACT INSTRUCTION .IF NB F .WORD 40000+F++D .IFF .WORD 40000++D .ENDC .ENDM SB ; .MACRO IOR ,S,D,F ; INCLUSIVE OR INSTRUCTION .IF NB F .WORD 50000+F++D .IFF .WORD 50000++D .ENDC .ENDM IOR ; .MACRO EOR ,S,D,F ; EXCLUSIVE OR INSTRUCTION .IF NB F .WORD 60000+F++D .IFF .WORD 60000++D .ENDC .ENDM EOR ; .MACRO AND ,S,D,F ; LOGICAL AND INSTRUCTION .IF NB F .WORD 70000+F++D .IFF .WORD 70000++D .ENDC .ENDM AND ; .MACRO BCT ,D,F ; BRANCH ON CONDITION TRUE INSTRUCTION .WORD 100000+F+</2> .ENDM BCT ; .MACRO BCF ,D,F ; BRANCH IF CONDITION FALSE INSTRUCTION .WORD 110000+F+</2> .ENDM BCF ; .MACRO ST ,D ; STORE INSTRUCTION .WORD 130000+</2> .ENDM ST ; .MACRO LD ,D ; LOAD INSTRUCTION (T = CONTENTS OF MEMORY) .WORD 140000+</2> .ENDM LD ; .MACRO STP ,D ; STORE PDR .WORD 134000+</2> .ENDM STP ; .MACRO LDP ,D ; LOAD PDR .WORD 144000+</2> .ENDM LDP .LIST ; ; ; RSX1M COMMAND LIST ; ; B14 = FAST (NO EXITS) ALWAYS TRUE ; B13 = CAMAC EXIT ALWAYS TRUE ; B12 = RANDOM READ/WRITE/CTRL/ERROR ; B11 = 2 WORD TRANSFERS ; B10 = ADD TO BUFFER ; ; B12&B14=WAIT FOR LAM THEN CONTINUE WITH NO EXITS ; NOTE: RANDOM READ/WRITE ARE FOLLOWED BY DUMMY WORD ; .TITLE MBLOAD .LIST MEB .PSECT RSX11M,D,OVR,GBL RSXLOD:: BASE: RTN ; RETURN IS ALWAYS FIRST STATEMENT DEM T,PSR,CLRC ; SET ALL PS BITS MV PSR,PSR,EXM ; Save current address + exit INIT: MV ISR,T,BREQ ; T = CHANNEL # & REQUEST DATA CHAN SLLD ; T = T * 4 BCF .,DCD ; WAIT FOR DATA CHAN DONE AD PDR,MAR,RDH ; GET (PDR+CHAN*4) AD T,TMP4 ; SET UP TABLE ADDRESS IN TMP4 BCF .,DCD ; WAIT FOR DATA CHAN DONE INM TMP4,MAR,RDR ; GET NEXT WORD MV MDR,T ; TEST BUFFER ADDRESS BCT END,Z ; Z = END THE CLIST AD T,BADD ; BUFF ADDRESS IN BADD BCF .,DCD ; WAIT FOR DATA CHAN DONE INM TMP4,MAR,RDR ; GET NEXT WORD FROM MEMORY MV MDR,BSIZ ; # OF WORDS IN BUFF TO READ/WRITE BCF RETURN,B12 ; BIT 12 NOT SET DO NOT RELOAD CLIST BCF .,DCD ; WAIT FOR DATA CHAN DONE MV MDR,ILR ; CLIST ADDRESS -1 ; ; COME TO HERE TO PROCESS NEW COMMAND ; RETURN: BCF .,DCD ; WAIT FOR 11 DONE INM ILR,MAR,RDH ; GET NEXT ENTRY IN CLIST MV 0,TMP4 ; TMP4 = 0 MV 0,370,IMM ; T = 370 BCF .,DCD ; WAIT FOR DATA CHAN DONE IOR MDR,PSR ; PSR = T .OR. MDR BCF END,N ; EXIT FROM THIS CHAN FOREVER INM ILR,MAR,RDR ; START READIN OF NEXT ENTRY IN CLIST RTN ; EXECUTE NEXT SUBROUTINE ; ; SECTION TO LOAD REGISTERS R4 TO R2 ; LOAD4: BCF .,DCD ; WAIT FOR DATA CHAN DONE INM ILR,MAR,RDH ; GET NEXT WORD FROM CLIST MV MDR,TMP4 LOAD3: BCF .,DCD ; WAIT FOR DATA CHAN DONE INM ILR,MAR,RDR ; GET NEXT WORD FROM CLIST MV MDR,WCR LOAD2: BCF .,DCD ; WAIT FOR DATA CHAN DONE MV MDR,FCNA BCT XCAM,B13 ; WAIT FOR LAM BCT RW5 ; NOW DO NORMAL RETURN ; SECTION TO END THE COMMAND LIST ; END1: DEM 0,BSIZ ; BSIZ = -1 INDICATES BUFF OVERFLOW END: MV ISR,T ; GET CURRENT CHAN # SLLD ; SHIFT LEFT TWICE AD PDR,TMP4 ; POINTS TO INITIATOR TABLE BCF .,DCD ; WAIT FOR DATA CHAN DONE INM TMP4,MAR,BREQ ; POINTS TO BUFFER SIZE MV BSIZ,MDR,WTH ; WRITE BUFF SIZE LEFT TO PDP-11 DEM T,PSR ; PSR = -1 BCF .,DCD ; WAIT FOR DATA CHAN DONE INM TMP4,MAR ; POINTS TO CLIST ADDRESS MV ILR,MDR,WTR ; WRITE CURRENT ADDRESS MV T,T ; No operation wait 1 cycle BCF .,DCD ; WAIT FOR BUS READY INM TMP4,MAR ; POINTS TO BUFER ADDRESS MV BADD,MDR,WTR ; WRITE CURRENT ADDRESS MV PSR,PSR,INT ; RETURN HERE + SET INTERUPT EXT ; EXIT FOREVER ; ; ROUTINE TO DO Q SCAN (FUNCTION 7) ; ; B10=0 ; B11 SAME AS READ ; B12=0 READ SAME FCNA TILL COUNT EXHAUSTED ; STOP IF Q=FALSE OR COUNT EXHAUSTED ; B12=1 READ FCNA INCREMENTED EACH TIME ; ; B10=1 ; B11=0 ; B12=0 COUNT,FCNA (CONTINUE , NO OTHER OPERATION) ; B12=1 OFFSET,COUNT,OFF1,OFF2,OFF3...OFFN (N=COUNT-1) ; MULTIPLE WAY BRANCH ON DATA ; OFF1 USED IF VALUE-OFFSET=N ; OFFN USED IF VALUE-OFFSET=1 ; B11=1 OFFSET (CHAIN UNCONDITIONA, NO WAITS) ; SCAN: BCF SC1,B10 ; B10 = 0 IS READ FUNCTION BCT CH11,B11 ; B11 = 1 IS UNCONDITIONAL CHAIN INM PSR,PSR ; SET UP FOR SUBROUTINE BCT LOAD3 ; LOAD R3,R2 BCF RETURN,B12 ; B12 = 0 IS RETURN ; ; MULTIWAY BRANCH ; MV WCR,T ; GET OFFSET SB QCNT,T ; T = (VALUE - OFFSET) BCT CHY2,N ; NEGATIVE= GO TO END OF TABLE SB FCNA,T ; T =FCAN-(VALUE-OFFSET) BCT CHY2,N ; NEGATIVE=SKIP CHAIN BCT CHY2,Z ; OR ZERO AD ILR,MAR,RDR ; ADDRESS=ILR + T AD T,ILR ; ILR = ILR + OFFSET CH11: BCF .,DCD ; WAIT FOR DATA CHAN DONE MV MDR,T ; GET OFFSET BCT CHY3 ; NOW CHAIN ; ROUTINE TO PERFORM A Q SCAN SC1: INM ILR,T ; POINTS DOWN 2 WORDS FROM COMMAND DEM BSIZ,XCNT ; ROOM FOR STATUS? BCT END,N ; NO, END CLIST INM BADD,TMP4 ; SAVE BADD+1 BCF .,DCD ; WAIT FOR DATA READY MV BADD,MAR ; ADDRESS TO WRITE DEM 0,MDR,WTR ; -1 WRITTEN TO PDP-11 SC1A: DEM XCNT,T ; DECREMENT COUNT BCF SC2,B11 ; ONLY 1 INCRMENT DEM XCNT,T ; DECREMENT AGAIN SC2: BCF SC3,B12 ; WRITE FCNA? DEM XCNT,T ; YES, DECREMENT AGAIN SC3: BCT END1,N ; NO MORE BUFFER LEFT MV PSR,PSR ; RETURN HERE MV FCNA,BAR,BRR ; READ USING FCNA BCF SC4,B12 ; DO NOT CHANGE ADDRESS INM FCNA,T ; NEXT FCNA TO TEST SC4: BCF .,BRD ; WAIT FOR DONE BCT SC5,Q ; CONTINUE IF Q RESPONSE BCT RW3,B12 ; TRY AGAIN UNTIL COUNT EXHAUSTED BCT RW4 ; DONE, WRITE COUNT TO BUFFER SC5: BCF SC6,B12 ; NOT RANDOM SCAN BCF .,DCD ; WAIT FOR DATA CHAN DONE INM BADD,MAR,BREQ ; SET UP ADDRESS + REQUEST DATA CHAN MV FCNA,MDR,WTH ; WRITE FCNA FIRST SC6: INM PSR,PSR ; RETURN HERE+1 NEXT BCT STO1 ; TRANSFER DATA BCT SC1A ; NEXT WORD ; ; READ ROUTINE (FUNCTION 2) ; READ: INM PSR,PSR ; SAVE NEXT ADRESS IN FCNA $$$$$ BCT RWSET ; GET AND CHECK DATA FOR READ,WRITE MV FCNA,BAR,BRR ; READ CAMAC DATA BCF .,DCD ; WAIT FOR DATA CHAN DONE BCF NONRAN,B12 ; NOT RANDOM READ, WRITE INM ILR,MAR,RDH ; READ NEXT FCNA FROM PDP-11 MV T,T ; NO OPERATION ; WAIT 1 CYCLE BCF .,DCD ; WAIT FOR UNIBUS DONE MV MDR,FCNA ; NEXT FCNA TO EXECUTE NONRAN: INM BADD,MAR,BREQ ; SET UP TO WRITE DATA BCF .,BRD ; WAIT FOR CAMAC OPERATION DONE BCT RD2,Q ; NO Q ERRROR INM QCNT,T ; INCREMENT NUMBER OF Q ERRRORS BCT RD2,X ; NO X ERROR INM XCNT,T ; INCEMENT NUMBER OF X ERRORS RD2: BCT AD2,B10 ; ADD DATA TO BUFFER MV BDL,MDR,WTR ; WRITE TO MEMORY BCF RW3,B11 ; SINGLE WORD WRITE ONLY BCF .,DCD ; WAIT FOR DATA CHAN DONE INM BADD,MAR,BREQ ; NEXT ADRESS IN BUFFER TO WRITE MV BDH,MDR,WTR ; WRITE HI BITS ; ; SECTION USED BY READ/WRITE/CTRL ; RW3: DEM WCR,T ; DECREMENT READ COUNTER ,IS IT 0? BCF RW5,Z ; NO, CONTINUE RW4: BCF .,DCD ; WAIT FOR DATA CHAN DONE MV TMP4,MAR ; GET SAVED START OF BUFF. BCT RETURN,Z ; IT IS ZERO, SO IGNORE IT SB BADD,MDR,WTR ; WRITE COUNT = MDR = BADD - TMP4 SB BSIZ,BSIZ ; BSIZ = BSIZ - COUNT BCT RETURN RW5: BCT BASE,B14 ; IF BIT14 EXECUTE DIRECT RETURN BCT XCAM,B13 ; IF BIT 13 ON WAIT FOR LAM EXM ; EXIT, RETURN IMMEDIATELY XCAM: EXC ; EXIT, WAIT FOR CAMAC (LAM) ; ; SECTION TO ADD BRANCH DATA TO BUFFER ; AD2: MV BDH,TMP4 ; Save BDH MV BDL,T,RDH ; T=LOW BITS, READ+HOLD BCF ADD4,B11 ; Single word ADD BCF .,DCD ; WAIT FOR DATA CHAN DONE AD MDR,MDR,WTR ; (BADD) = (BADD) + BDL BCF ADD2,C ; No carry INM TMP4,T ; Increment hi bits ADD2: BCF .,DCD ; WAIT FOR BUS DONE INM BADD,MAR,RDH ; GET NEXT DATA WORD FROM BUFF MV TMP4,T ; GET HI BITS TO AD ADD4: BCF .,DCD ; WAIT FOR DATA CHAN DONE AD MDR,MDR,WTR ; ADD T TO DATA + WRITE RESULT MV T,TMP4 ; Clear the temporary reg. BCT RW3 ; CONTINUE W/READ CLIST ; ; WRITE ROUTINE (FUNCTION 1) ; ; B10=1 COUNT,DUMMY (COUNT IS ADDED TO CURRENT BUFF. ADDRESS) ; WRITE0: BCF .,DCD ; WAIT FOR DATA CHAN DONE BCF RETURN,B10 ; RETURN IF B10=0 MV QCNT,MDR ; WCR WILL NOW BE QCNT WRITE: INM PSR,PSR ; RETURN ADDRESS INTO FCNA $$$$$ BCT RWSET ; GET INPUT DATA FOR READ/WRITE BCF WR0,B10 ; B10 =0 NORMAL READ MV BADD,T ; GET ADDRESS AD WCR,BADD ; ADD COUNT TO ADDRESS BCF RETURN,B11 ; ONLY 1 WORD ADD AD WCR,BADD ; AGAIN ADD COUNT TO ADDRESS BCT RETURN WR0: BCF .,DCD ; WAIT FOR DATA CHAN DONE INM BADD,MAR,RDR ; GET DATA TO WRITE TO CAMAC MV T,BDH ; SET HI BITS TOZ BCF .,DCD ; WAIT FOR DATA CHAN DONE MV MDR,BDL ; LO BIT DATA BCF WILR,B11 ; DO ONLY 1 WORD TRANSFER INM BADD,MAR,RDR ; GET NEXT DATA WORD FROM BUFFER MV T,T ; NO OPERATION BCF .,DCD ; WAIT FOR DATA CHAN DONE MV MDR,BDH ; HIGH BIT DATA WILR: MV FCNA,BAR,BRW ; WRITE DATA TO CAMAC ; ; THIS PART OF WRITE IS COMMON TO BOTH WRITE & CTRL ; WFCNA: BCF WWCR,B12 ; DO NOT GET NEXT FCNA INM ILR,MAR,RDR ; GET NEXT FCNA MV T,T ; NO OPERATION BCF .,DCD ; WAIT FOR DATA CHAN DONE MV MDR,FCNA ; NEXT FCNA INTO FCNA WWCR: BCF .,BRD ; WAIT FOR CAMAC DONE BCT RW3,Q ; NO Q ERROR, FINISH I/O INM QCNT,T ; INCREMENT Q ERRORS BCT RW3,X ; NO X ERRORS, FINISH I/O INM XCNT,T ; INCREMENT X ERROR COUNNT BCT RW3 ; FINISH I/O ; HERE WE EXECUTE CONTROL FUNCTION (FUNCTION 3) ; B11=0 B12=1 COUNT,FCNA1,FCNA2,.... FCNAN,0 ; B12=0 COUNT,FCNA ; B11=1 OFFSET,FCNA, (EXECUTE + BRANCH ON Q) ; B10=0 BRANCH IF Q=.FALSE. ; B10=1 BRANCH IF Q=.TRUE. ; CTRL: MV 0,QCNT ; SET Q COUNT TO 0 MV 0,XCNT ; SET X COUNT TO 0 INM PSR,PSR ; SAVE RETURN ADRESS IN FCNA $$$$$ BCT LOAD3 ; GET INPUT PARAM MV FCNA,BAR,BRC ; EXECUTE CONTROL FUNCTION BCF .,DCD ; WAIT FOR DATA CHANEL DONE BCF WFCNA,B11 ; CONTINUE WITH NORMAL SEQUENCE DEM WCR,FCNA ; SET UP FOR BRANCH BCF .,BRD ; WAIT FOR CAMAC DONE BCT CHN,Q ; DO NORMAL RETURN, EXECUTE NEXT BCT CHY ; NEXT COMMAND ; ; SUBROUTINE TO SET UP FOR READ/WRITE ; RWSET: MV 0,QCNT ; CLEAR Q COUNT MV 0,XCNT ; CLEAR X ERROR COUNT RWSET2: BCF .,DCD ; WAIT FOR CDATA CHAN DONE $$$$$ INM ILR,MAR,RDR ; GET NEXT WORD MV MDR,WCR ; GET COUNT BCF RWS1,B11 ; SINGLE WORD READ/WRITE BCT END,N ; IF NEGATIVE EXIT SLL ; MULTIPLY COUNT BY 2 RWS1: BCT END,N ; IF NEGATIVE EXIT BCT END,Z ; IF ZERO EXIT SB BSIZ,BSIZ ; BSIZ = BSIZ - T BCF LOAD2,N ; NOW GET FCNA BCT END ; NO ROOM LEFT SO TERMINATE WITH ERR. ; ; STORE ROUTINE ; ; COUNT,DUMMY (XERR,QERR ARE TRANSFERRED) ; B12=1 B10=1 ADD QCNT TO BUFFER ADDRESS (BADD) ; B10=1 IMMEDIATE RETURN ; ; B12=0 ; B11,B10 SAME AS READ ; ; STORE: BCT WRITE0,B12 ; ADD XCNT TO BUFFER ADDRESS INM PSR,PSR ; SAVE RETURN ADRESS BCT RWSET2 ; SET UP FOR WRITE TO BUFFER MV QCNT,BDL ; Q COUNT IN LOW ORDER WORD MV XCNT,BDH ; X ERROR COUNT IN HIGH ORDER STO1: BCF .,DCD ; DATA CHAN READY? INM BADD,MAR,BREQ ; GET ADDRESS BCT RD2 ; NOW DO TRANSFER ; ; CHAIN,DATALO,DATAHI,OFFSET (FUNCTION 5) ; B12=0 TEST WORD COUNT ; B12=1 TEST STORED DATA (R5,R6) ; B10=0 B11=0 CHAIN WHEN DATA .EQ. VALUE ; B11=1 CHAIN WHEN DATA .GE. VALUE ; B10=1 B11=0 CHAIN WHEN DATA .NE. VALUE ; B11=1 CHAIN WHEN DATA .LT. VALUE ; ; ; CHAIN: INM PSR,PSR ; GET READY FOR SUBROUTINE BCT LOAD4 ; LOAD R4-R2 MV BSIZ,T ; GET BSIZ BCF CHL,B12 ; TEST BSIZ ,1 WORD TEST MV WCR,T ; GET HIGH TEST WORD BCT CH2,N ; IF NEGATIVE DO ONLY LOWER MV XCNT,T ; T = XCNT SB WCR,T ; T = DATA - VALUE BCF CH4,Z ; NOT ZERO, SKIP LO WORD CH2: MV QCNT,T ; GET Q ERROR COUNT CHL: SB TMP4,T ; T=DATA - VALUE CH4: BCT CHY,Z ; CHAIN IF ZERO BCF CHN,B11 ; NO CHAIN IF NON ZERO+B11 CLEAR BCT CHY,C ; CHAIN IF (DATA-VALUE = C) DAT .AND. MASK ; ; B12=1 WRITE R5,R6 TO ; B12=0 NO WRITE ; C1: INM PSR,PSR ; SAVE RETURN ADRESS $$$$$ BCT LOAD4 ; GO TO LOAD TMP4,WCR,FCNA MV QCNT,BDL ; LOW DATA MV XCNT,BDH ; HI DATA BCT C1A,B10 ; SKIP LOADING CONSTANT MV TMP4,BDL ; LOW DATA MV WCR,BDH ; HI DATA C1A: BCF C1B,B11 ; SKIP READING CAMAC MV FCNA,BAR,BRR ; READ CAMAC ACCORDING TOFCNA IN FCNA C1B: MV WCR,T ; GET MASK WORD HI BITS BCF .,BRD ; WAIT FOR CAMAC TO FINISH AND BDH,XCNT ; XCNT = HI BITS & MASK WORD MV TMP4,T ; GET REST OF MASK LO BITS AND BDL,QCNT ; QCNT = LO BITS + MASK BCF RETURN,B12 ; SKIP WRITE IF B12=0 MV FCNA,BAR,BRW ; WRITE RESULT TO CAMAC BCT RETURN ; END OF C1 ROUTINE ; ; DISPATCH TABLE ; THIS MUST OCCUPY THE LAST 8 MEMORY LOCATIONS ; .=BASE+760 BCT INIT ; REINITIALIZE BUFFER ADDRESS OR.. BCT WRITE ; WRITE DATA TO CAMAC BCT READ ; READ DATA FROM CAMAC BCT CTRL ; EXECUTE CONTROL FUNCTIONS BCT STORE ; PUT FIXED DATA INTO BUFFER BCT CHAIN ; CONDITIONAL CHAIN TO NEW COMMANDS BCT C1 ; (C1) DIRECT MEM INCREMENT,READ + WRITE BCT SCAN ; (SCAN) Q SCAN, UNCONDITIONAL CHAIN,MULTI CHAIN .END