IMD 1.16: 1/09/2008 12:23:23 84-93438-03 a030 f43803 synchronous communications handler source diskette #2 8feb83    @0{)vvЀЀsQpk)p " }fA __M@IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIOS4 MA283011213334440830112133344 830112133344KF43803 VOLSYNCHRONOUS COMMUNICATIONS HANDLER SOURCE DISKETTE II (A030)   IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII_M@qGyy GGG`HX@ b G`^Y e GQ @@p@987 85P@ G:پN 8)0. * C'xC# b# }B* @0DAJL w+™ЀЀΖQA1"   i  ž} š} @EEFF)DEۄF8 џ} ԟ} ̟} * `jUBBI,v BI, # @ G7H@pܾrCHC C GTq` Lg gEXC P+s=胾P+c fQN p $Rxnj  ޔniZ ތ⊞ } }HGž Ÿ@ALS)"$ C k20j.h( +$`%ꂜ\1 !M' y %'+os慾)sY ed|{ @8 o O m J K i gN )V% t%sLn`"E F. F„ D>) =`;nrgy w"G,{Kq1 A&}E*`(t@% ;c  765y342(.OS:: SYSG @ @G6BDāCGDĀ# BC @E OB TITL SYNCHRONOUS HANDLER RECEIVE CONTROL (93438-13/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:SIG EXTR R:WAIT EXTR INI:EVNT EXTR RLS:EVNT EXTR PRO:EVNT EXTR ALOC:EPT EXTR RELS:EPT EXTR B:RECVD EXTR WAIT:FLG EXTR TERM:ACT * * EXTERNAL DEFINITIONS * NAM B:RECVC * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:4 NAM G:4 ENDC TITL SYSTEM REQUEST CONTROL BLOCKS FOR THE RECEIVE CONTROL TASK * * RECEIVE CONTROL TASK DEFINITION BLOCK * TDB:A C:RECVC,RECV:CTL,SIZE:RST,,STACK:RC,,4096 * * RECEIVE CONTROL TASK BEGIN BLOCK * BGIN:A B:RECVC,C:RECVC,:8000 TITL ASGN:CTL - PROCESS ASSIGNMENT OF RECEIVE CONTROL * * ASGN:CTL * * PROCEDURE PROCESSES AN ASSIGNMENT OF RECEIVE CONTROL, SETTING THE * APPROPRIATE FLAGS IN THE RECEIVE STATUS TABLE AND LINK CONTROL * BLOCK, RETURNING THE RESPONSE EVENT TO THE PROTOCOL HANDLER * ACTIVITY WHICH ORIGINATED THE EVENT REQUESTING RECEIVE CONTROL, *  AND SETTING UP FOR THE RECEIVE DRIVER TO BE SIGNALLED FOR BUFFER * AVAILABLE IF NECESSARY. * * CALL PARAMETERS: *  X - BASE ADDRESS OF EVENT INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * ASGN:CTL EQU $ SIN 2 P REVENT ANY INTERRUPTION WHILE MODIFYING FLAGS COPY RS:RCF(Y),Q RECEIVE CONDITION FLAGS BITS:ON Q,RCF:RCG SET RECEIVE CONTROL GRANTED FLAG COPY Q,RS:RCF(Y) COPY EI:LCB(X),X BASE ADDRESS OF LCB REQUESTING RECEIVE CONTROL COPY X,RS:LCB(Y) SET AS HOLDER OF RECEIVE CONTROL COPY LC:LAF(X),A LINE ACCESS FLAGS TBIT LAF:RBU,A RECEIVE BUFFER UNAVAILABLE FLAG JF OV,AC01 JUMP IF RECEIVE BUFFERS PREVIOUSLY AVAILABLE COPY LC:DIB(X),X BASE ADDRESS OF ASSOCIATED DIB COPY RS:DET(Y),A BASE ADDRESS OF RECEIVE DRIVER ACTIVITY EPT ADD =EP:SEM,A SET ADDRESS OF RECEIVE DRIVER ACTIVITY SEMAPHORE COPY A,DI:RQS(X) SAVE AS SEMAPHORE TO SIGNAL FOR READ REQUESTS AC01 EQU $ REPORT CONTROL ALLOCATION TO PROTOCOL COPY =E:RCVGRN,A SET EVENT TYPE CODE FOR RECEIVE CONTROL GRANTED COPY RS:LCB(Y),Q SET BASE ADDRESS OF PROTOCOL ACTIVITY EPT JSK PRO:EVNT GENERATE EVENT FOR PROTOCOL HANDLER ACTIVITY COPY RS:DET(Y),X SET ADDRESS OF RECEIVE DRIVER SEMAPHORE ADD =EP:SEM,X JSK R:SIG ALERT DRIVER TO ASSIGNMENT OF RECEIVE CONTROL RSK  RETURN TO CALLER TITL RECV:CTL - RECEIVE CONTROL TASK MAIN PROGRAM * * RECV:CTL * * MAIN PROGRAM PROCESSES EVENTS REQUESTING RECEIVE CONTROL, AND * HANDLES INITIALIZATION AND TERMINATION OF THE RECEIVE INSTANCE AS * A WHOLE. * * START PARAMETERS: * A - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * Y - BASE ADDRESS OF RECEIVE STATUS TABLE * RECV:CTL EQU $ COPY A,RS:CIB(Y) SAVE CIB BASE ADDRESS COPY =0,Q COPY Q,RS:LCB(Y) SET NULL RECEIVE CONTROL LCB COPY Q,RS:CET(Y) SET NULL RECEIVE CONTROL ACTIVITY EPT COPY Q,RS:DET(Y) SET NULL RECEIVE DRIVER ACTIVITY EPT COPY Q,RS:RCF(Y) CLEAR ALL RECEIVE CONDITION FLAGS JSK ALOC:EPT ALLOCATE EPT FOR RECEIVE CONTROL ACTIVITY JEQ X,RC08 TERMINATE ACTIVITY IF UNABLE TO ALLOCATE COPY X,RS:CET(Y) SAVE ADDRESS OF EVENT PROCESSOR TABLE COPY X,A ALSO SAVE ADDRESS IN CIB COPY RS:CIB(Y),X COPY A,CI:RCP(X) R:BGIN B:RECVD START THE RECEIVE DRIVER ACTIVITY COPY Y,A SET ADDRESS OF SIGNAL WORD ADD =RS:DET,A COPY RS:CET(Y),X SET BASE ADDRESS OF EPT JSK WAIT:FLG WAIT FOR ACTIVITY START UP JMP RC07 TERMINATE ACTIVITY IF REQUESTED COPY =E:RCVOPR,A SET EVENT CODE FOR RECEIVE COMPONENT ACTIVATION COPY =0,Q SET NULL LCB ADDRESS COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:LCP(X),X BASE ADDRESS OF LINE CONTROL ACTIVITY EPT JSK INI:EVNT SEND EVENT TO LINE CONTROL ACTIVITY RC01 EQU $ LOOP FOR ASSIGNMENT OF RECEIVE CONTROL COPY RS:CET(Y),X BASE ADDRESS OF RECEIVE CONTROL ACTIVITY EPT COPY EP:TRM(X),A TERMINATION FLAG JNE A,RC05 JUMP IF TERMINATION SIGNALLED COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS TBIT RCF:RCG,A RECEIVE CONTROL GRANTED FLAG JT OV,RC04 JUMP IF RECEIVE CONTROL ALREADY ACTIVE COPY EP:EQH(X),X BASE ADDRESS OF FIRST EIB ON EVENT QUEUE JEQ X,RC04 JUMP IF NONE ARE PRESENT COPY EI:ECI(X),A EVENT CONTROL INFORMATION WORD BITS:EXT A,ECI:TYP EXTRACT THE EVENT TYPE CODE SUB =E:REQRCV,A CHECK FOR A REQUEST RECEIVE CONTROL EVENT JEQ A,RC02 JUMP IF REQUEST RECEIVE CONTROL ERR:D RC03 ERROR EXIT TO DEBUG IF PRESENT RC02 EQU $ ESTABLISH NEW HOLDER OF RECEIVE CONTROL JSK ASGN:CTL PROCESS ASSIGNMENT OF RECEIVE CONTROL RC03 EQU $ DISCARD CURRENT EVENT FROM INPUT QUEUE COPY RS:CET(Y),X BASE ADDRESS OF RECEIVE CONTROL ACTIVITY EPT JSK RLS:EVNT DISCARD CURRENT EVENT FROM QUEUE  JMP RC01 RC04 EQU $ END OF MAIN LOOP FOR ASSIGNING RECEIVE CONTROL COPY RS:CET(Y),X BASE ADDRESS OF ACTIVITY EPT ADD =EP:SEM,X SET ADDRESS OF SEMAPHORE JSK R:WAIT WAIT FOR A SIGNAL BEFORE REPEATING LOOP JMP RC01 RC05 EQU $ TERMINATE WITH NOTIFICATION TO RECEIVE DRIVER COPY RS:DET(Y),X BASE ADDRESS OF RECEIVE DRIVER ACTIVITY EPT JSK TERM:ACT SET TERMINATION FLAG AND SIGNAL ACTIVITY RC06 EQU $ WAIT FOR TERMINATION OF RECEIVE DRIVER ACTIVITY COPY RS:DET(Y),A BASE ADDRESS OF RECEIVE DRIVER EPT JEQ A,RC07 JUMP UNLESS STILL PRESENT COPY RS:CET(Y),X BASE ADDRESS OF ACTIVITY EPT ADD =EP:SEM,X SET ADDRESS OF SEMAPHORE JSK R:WAIT WAIT FOR SIGNAL BEFORE REPEATING CHECK JMP RC06 RC07 EQU $ RELEASE MEMORY FROM TABLES COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY =0,A COPY A,CI:RCP(X) SET NULL ADDRESS FOR EPT IN CIB COPY RS:CET(Y),X BASE ADDRESS OF ACTIVITY EPT JSK RELS:EPT RELEASE MEMORY USED FOR EPT RC08 EQU $ REPORT TERMINATION TO LINE CONTROL ACTIVITY COPY =E:RCVTRM,A SET EVENT CODE FOR RECEIVE TERMINATION COPY =0,Q SET NULL LCB ADDRESS COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:LCP(X),X SET ADDRESS OF LINE CONTROL ACTIVITY EPT JSK INI:EVNT SEND EVENT FOR RECEIVE TERMINATION R:END TERMINATE THE ACTIVITY SPACE 2 END TITL SYNCHRONOUS HANDLER RECEIVE DRIVER (93438-13/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:SIG EXTR R:WAIT EXTR GEN:EVNT EXTR INI:EVNT EXTR DIS:EVNT EXTR RLS:EVNT EXTR SND:EVNT EXTR PRO:EVNT EXTR PUT:REQ EXTR GET:REQ EXTR ALOC:EPT EXTR RELS:EPT EXTR INIT:TMR EXTR STRT:TMR EXTR CNCL:TMR EXTR TERM:TMR EXTR STRT:RCV EXTR ABRT:RCV EXTR TERM:RCV * * EXTERNAL DEFINITIONS * NAM B:RECVD * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:5 NAM G:5 ENDC TITL SYSTEM REQUEST CONTROL BLOCKS FOR THE RECEIVE DRIVER TASK * * RECEIVE DRIVER TASK DEFINITION BLOCK * TDB:A C:RECVD,RECV:DRV,,,STACK:RD,,4096 * * RECEIVE DRIVER TASK BEGIN BLOCK * BGIN:A B:RECVD,C:RECVD,:8100 TITL CHK:COND - CHECK TERMINATION CONDITIONS * * CHK:COND * * PROCEDURE CHECKS FOR TERMINATION OF THE CURRENT RECEIVE OPERATION * DUE TO A RELEASE RECEIVE CONTROL EVENT BEING ENTERED ON THE EVENT * QUEUE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A - ZERO IF NO TERMINATION, NONZERO IF TERMINATION * Q - UNCHANGED * X - DESTROYED * CHK:COND EQU $ COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS TBIT RCF:TRC,A CHECK FOR TERMINATING RECEIVE CONTROL JT OV,CC01 RETURN WITH CODE FOR TERMINATION IF SO COPY RS:DET(Y),X BASE ADDRESS OF RECEIVE DRIVER ACTIVITY EPT COPY EP:EQH(X),X BASE ADDRESS OF FIRST EIB ON EVENT QUEUE JEQ X,CC04 RETURN WITHOUT TERMINATION IF QUEUE EMPTY COPY EI:ECI(X),A EVENT CONTROL INFORMATION WORD BITS:EXT A,ECI:TYP EXTRACT THE EVENT TYPE CODE SUB =E:RELRCV,A CHECK FOR A RELEASE RECEIVE CONTROL EVENT JNE A,CC02 JUMP IF ANYTHING ELSE COPY EI:LCB(X),A BASE ADDRESS OF LCB ASSOCIATED WITH REQUEST SUB RS:LCB(Y),A COMPARE WITH ADDRESS OF LCB HAVING CONTROL JNE A,CC03 IGNORE REQUEST IF NOT CORRECT LCB COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS BITS:ON A,RCF:TRC SET FLAG FOR TERMINATING RECEIVE CONTROL COPY A,RS:RCF(Y) COPY RS:DET(Y),X SET BASE ADDRESS OF EPT JSK RLS:EVNT DISCARD THE FIRS T EIB ON EVENT QUEUE CC01 EQU $ RETURN WITH TERMINATION CODE COPY =-1,A SET TERMINATION CODE FOR CALLER RSK CC02 EQU $ INVALID EVENT TYPE IN QUEUE ERR:D ENTER DEBUGGER IF DEBUG ASSEMBLY CC03 EQU $ DISCARD THE FIRST EIB OF EVENT QUEUE COPY RS:DET(Y),X BASE ADDRESS OF RECEIVE DRIVER ACTIVITY EPT JSK RLS:EVNT DISCARD THE FIRST EIB ON EVENT QUEUE JMP CC02 LOOP TO PROCESS ANY OTHER EVENTS ON THE QUEUE CC04 EQU $ RETURN WITH NON-TERMINATION CODE COPY =0,A SET NON-TERMINATION CODE FOR CALLER RSK  TITL RELS:FRM - RELEASE CONTROL BLOCKS USED FOR RECEIVE FRAME * * RELS:FRM * * PROCEDURE RELEASES THE EVENT INFORMATION BLOCK AND BUFFER * INFORMATION BLOCK USED FOR A RECEIVE FRAME. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * RELS:FRM EQU $ COPY RS:EIB(Y),X BASE ADDRESS OF ALLOCATED EIB COPY EI:BIB(X),A BASE ADDRESS OF ALLOCATED BIB JEQ A,RF01 JUMP IF NONE WAS ALLOCATED COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB ADD =LC:RRH,X SET ADDRESS OF READY QUEUE POINTER BLOCK JSK PUT:REQ RETURN BIB TO READY FOR RECEIVE QUEUE COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB IMS LC:RRC(X) COUNT ANOTHER BUFFER AVAILABLE NOP RF01 EQU $ RELEASE EVENT INFORMATION BLOCK AND RETURN COPY RS:EIB(Y),X BASE ADDRESS OF ALLOCATED EIB COPY =-1,A SET INVALID CODE IN EVENT CONTROL INFORMATION COPY A,EI:ECI(X) JSK DIS:EVNT RETURN EIB TO AVAILABLE POOL RSK RETURN TO CALLER * LPOOL TITL GET:BUFF - ALLOCATE USER BUFFER FOR RECEIVE OPERATION * * GET:BUFF * * PROCEDURE ATTEMPTS TO ALLOCATE A USER BUFFER FOR USE WITH THE NEXT * RECEIVE OPERATION. IF ANY ARE CURRENTLY AVAILABLE, IT RETURNS * IMMEDIATELY. OTHERWISE, IF WAIT FOR RECEIVE BUFFERS HAS BEEN * SPECIFIED, THE PROCEDURE WILL WAIT UNTIL EITHER A RECEIVE BUFFER * BECOMES AVAILABLE OR A TIMEOUT EXPIRES (OR THE OPERATION IS * TERMINATED). * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,X - DESTROYED * Q - ZERO IF NO BUFFER AVAILABLE, BASE ADDRESS OF ASSOCIATED * BUFFER INFORMATION BLOCK OTHERWISE * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS AN ERROR RETURN, * INDICATING THAT RECEIVE CONTROL IS BEING TERMINATED, IN WHICH CASE * NO BUFFER WILL BE RETURNED; RETURN TO CALL+2 IS NORMAL. * GET:BUFF EQU $ COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB COPY LC:LAF(X),A LINE ACCESS FLAGS TBIT LAF:UBF,A USE RECEIVE BUFFER FLAG JF OV,GB04 JUST EXIT IF NO BUFFER REQUIRED SIN 3 PREVENT INTERFERENCE WHILE MODIFYING COUNT COPY LC:RRC(X),A COUNT OF READY FOR RECEIVE BUFFERS PRESENT SUB =1,A DECREMENT FOR BUFFER TO BE ALLOCATED JLT A,GB01 JUMP IF NONE ARE PRESENT COPY A,LC:RRC(X) SAVE BACK MODIFIED COUNT ADD =LC:RRH,X SET ADDRESS OF QUEUE POINTER BLOCK JSK GET:REQ REMOVE FIRST BIB FROM READY FOR RECEIVE QUEUE JNE A,GB06 JUMP IF BIB PRESENT ON QUEUE ERR:D COUNT ERROR OTHERWISE, ENTER DEBUGGER IF DEBUGGING GB01 EQU $ GET A BIB FROM THE READY REQUEST QUEUE IN THE DIB COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB COPY LC:DIB(X),X BASE ADDRESS OF ASSOCIATED DIB ADD =DI:RQH,X SET ADDRESS OF QUEUE POINTER BLOCK JSK GET:REQ REMOVE THE FIRST BIB FROM THE READ REQUEST QUEUE JNE A,GB06 JUMP IF BIB PRESENT ON QUEUE COPY RS:LCB(Y), X BASE ADDRESS OF RECEIVE CONTROL LCB COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS TBIT RCF:WFB,A WAITING FOR BUFFER FLAG JT OV,GB02 JUMP IF NOT FIRST TIME WAIT COPY LC:LAF(X),Q LINE ACCESS FLAGS TBIT LAF:RBU,Q RECEIVE BUFFER UNAVAILABLE FLAG JT OV,GB04 RETURN WITH NO BUFFER FOUND IF SET BITS:ON A,RCF:WFB SET WAITING FOR BUFFER FLAG COPY A,RS:RCF(Y) COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB COPY LC:DIB(X),X BASE ADDRESS OF ASSOCIATED DIB COPY RS:DET(Y),A BASE ADDRESS OF RECEIVE DRIVER ACTIVITY EPT ADD =EP:SEM,A SET ADDRESS OF RECEIVE DRIVER ACTIVITY SEMAPHORE COPY A,DI:RQS(X) SAVE AS SEMAPHORE TO SIGNAL FOR READ REQUESTS COPY DI:BTI(X),A BUFFER AVAILABLE TIMEOUT INTERVAL JEQ A,GB03 JUMP IF NO TIMEOUT SPECIFIED COPY RS:TCB(Y),X BASE ADDRESS OF BUFFER AVAILABLE TIMER TCB COPY A,TC:INT(X) SET TIMEOUT INTERVAL JSK STRT:TMR START THE BUFFER AVAILABLE TIMEOUT JMP GB05 GB02 EQU $ CHECK FOR BUFFER AVAILABLE TIMEOUT EXPIRATION COPY RS:TCB(Y),X BASE ADDRESS OF BUFFER AVAILABLE TIMER TCB COPY TC:EXP(X),A TIMER EXPIRATION SIGNAL JGE A,GB05 JUMP UNLESS BUFFER AVAILABLE TIMEOUT EXPIRED GB03 EQU $ INITIAL BUFFER AVAILABLE TIMEOUT EXPIRATION COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS BITS:OFF A,RCF:WFB TURN OFF WAITING FOR BUFFER FLAG COPY A,RS:RCF(Y) COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB COPY LC:LAF(X),Q LINE ACCESS FLAGS BITS:ON Q,LAF:RBU SET RECEIVE BUFFER UNAVAILABLE FLAG COPY Q,LC:LAF(X) COPY =E:ASRFLO,A SET EVENT TYPE TO ASSERT FLOW CONTROL COPY X,Q SET RECEIVE CONTROL LCB ADDRESS JSK PRO:EVNT INITIATE PROTOCOL EVENT TO ACTIVATE FLOW CONTROL GB04 EQU $ RETURN WITH NO BUFFER FOUND COPY =0,Q SET NULL BUFFER ADDRESS JMP GB08 RETURN WITHOUT ALLOCATED BUFFER GB05 EQU $ WAIT FOR BUFFER TO BECOME AVAILABLE COPY RS:DET(Y),X COMPUTE ADDRESS OF ACTIVITY SEMAPHORE ADD =EP:SEM,X JSK R:WAIT WAIT FOR A SIGNAL BEFORE REPEATING CHECKS JSK CHK:COND CHECK FOR STANDARD RECEIVE OPERATION TERMINATIONS JEQ A,GET:BUFF LOOP TO CHECK AGAIN IF NO TERMINATION COPY =0,Q SET NULL BIB BASE ADDRESS FOR RETURN JMP GB09 TAKE TERMINATION RETURN TO CALLER GB06 EQU $ CHECK IF TO RELEASE FLOW CONTROL COPY RS:LCB(Y),X BASE ADDRESS OF LCB COPY LC:LAF(X),Q LINE ACCESS FLAGS TBIT LAF:RBU,Q RECEIVE BUFFER UNAVAILABLE FLAG JF OV,GB07 JUMP IF NOT FIRST TIME UNAVAILABLE BITS:OFF Q,LAF:RBU RESET RECEIVE BUFFER UNAVAILABLE FLAG COPY Q,LC:LAF(X) COPY A,X SAVE BASE ADDRESS OF BUFFER COPY =E:RELFLO,A SET EVENT TYPE TO RELEASE FLOW CONTROL COPY RS:LCB(Y),Q SET RECEIVE CONTROL LCB ADDRESS JSK PRO:EVNT INITIATE PROTOCOL EVENT TO RELEASE FLOW CONTROL COPY X,A RESTORE BASE ADDRESS OF BUFFER GB07 EQU $ RETURN WITH ALLOCATED BUFFER COPY A,Q SAVE THE ADDRESS OF BUFFER COPY A,X BASE ADDRESS OF BUFFER COPY BI:ORF(X),A OPERATION REQUEST FLAGS BITS:OFF A,ORF:NSI,ORF:BRD,ORF:ERR,ORF:AHL,ORF:TRM INITIALIZE FLAGS COPY A,BI:ORF(X) COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB COPY LC:DIB(X),X BASE ADDRESS OF ASSOCIATED DIB COPY =0,A SET NULL READ REQUEST QUEUE SEMAPHORE ADDRESS COPY A,DI:RQS(X) GB08 EQU $ CLEAN UP FOR RETURN TO CALLER COPY K,X STACK POINTER CURRENT POSITION IMS 0(X) BUMP RETURN ADDRESS FOR NORMAL RETURN NOP GB09 EQU $ TERMINATION RETURN TO CALLER COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS TBIT RCF:WFB,A WAITING FOR BUFFER FLAG JF OV,GB 10 JUMP IF NO WAITING WAS REQUIRED BITS:OFF A,RCF:WFB TURN OFF THE WAITING FOR BUFFER FLAG COPY A,RS:RCF(Y) COPY RS:TCB(Y),X BASE ADDRESS OF BUFFER AVAILABLE TIMER TCB COPY TC:INT(X),A JUMP IF NO TIMEOUT SPECIFIED JEQ A,GB10 JSK CNCL:TMR CANCEL THE BUFFER AVAILABLE TIMEOUT GB10 EQU $ RETURN TO CALLER RSK TITL SET:ROP - SET UP FOR A RECEIVE OPERATION * * SET:ROP * *  PROCEDURE SETS UP THE SYNCHRONOUS COMMUNICATIONS CONTROLLER * CONTROL BLOCK FOR A RECEIVE OPERATION. * * CALL PARAMETERS: * Q - BASE ADDRESS OF BUFFER INFORMATION BLOCK TO BE USED * * RETURN PARAMETERS: * A,Q,X - DESTROYED * SET:ROP EQU $ COPY RS:EIB(Y),X BASE ADDRESS OF ALLOCATED EIB COPY Q,EI:BIB(X) SAVE BASE ADDRESS OF BIB IN EIB ADD =EI:FRM,X SET ADDRESS OF HEADER BUFFER IN CONTROL BLOCK COPY X,RS:HBA(Y) COPY =8,A SET DEFAULT HEADER LENGTH IF NO USER BUFFER JEQ Q,SR01 JUMP IF NO USER BUFFER FOR OPERATION COPY Q,X BASE ADDRESS OF BIB COPY BI:ORF(X),A OPERATION FLAGS FOR USER READ REQUEST BITS:EXT A,ORF:EHL SET HEADER LENGTH TO THAT OF USER HEADER BUFFER ADD =2,A INCLUDE TWO BYTES FOR NORMAL CONTROL FIELD LENGTH COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB COPY LC:LAF(X),Q LINE ACCESS FLAGS TBIT LAF:ECF,Q EXTENDED CONTROL FIELD FORMAT FLAG JF OV,SR01 JUMP IF USING NORMAL CONTROL FIELD FORMAT ADD =1,A COUNT AN EXTRA BYTE FOR EXTENDED SR01 EQU $ SAVE LENGTH OF HEADER IN CONTROL BLOCK COPY A,RS:HBC(Y) SET LENGTH OF HEADER IN CONTROL BLOCK COPY RS:EIB(Y),X BASE ADDRESS OF EIB COPY EI:BIB(X),X BASE ADDRESS OF BIB JEQ X,SR02 JUMP IF NO USER BUFFER FOR OPERATION COPY BI:BCT(X),A REQUEST COUNT FOR BODY BUFFER JEQ A,SR02 JUMP IF HEADER BUFFER ONLY COPY A,RS:BBC(Y) SAVE BODY BYTE COUNT COPY BI:BUF(X),A SET BODY BUFFER ADDRESS COPY A,RS:BBA(Y) JMP SR03 GO TO START THE OPERATION SR02 EQU $ SET NULL BODY BUFFER COPY =0,A COPY A,RS:BBA(Y) SET NULL BODY BUFFER ADDRESS COPY A,RS:BBC(Y) SET NULL BODY BYTE COUNT SR03 EQU $ SET UP THE CHANNEL SELECTION WORD COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DLS(X),A DEVICE AND LINE STATE FLAGS BITS:OUT A,DLS:CHN MASK OUT CHANNEL SELECTION FLAG SHIFT: A,SCS:CHN-DLS:CHN POSITION CHANNEL SELECTION FLAG ADD =SCC:ROP,A SET OPERATION CODE FOR RECEIVE COPY A,RS:SCS(Y) SAVE SELECTION WORD IN CONTROL BLOCK RSK RETURN TO CALLER * LPOOL TITL PRC:HEAD - PROCESS HEADER OF RECEIVED FRAME * * PRC:HEAD * * PROCEDURE ESTABLISHES THE VARIOUS COUNTS FOR PORTIONS OF THE * RECEIVED FRAME, COPIES OVER THE USER HEADER IF ONE IS PRESENT, AND * RELEASES THE BUFFER INFORMATION BLOCK FOR THE USER READ REQUEST IF * ONE WAS USED FOR THE FRAME BUT NO USER DATA IS PRESENT. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * PRC:HEAD EQU $ COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY DC:RBC(X),Q RECEIVE BYTE COUNT COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:AAR(X),A ADD TO TOTAL CHARACTER COUNT RECEIVED ADD Q,A COPY A,CI:AAR(X) COPY RS:EIB(Y),X BASE ADDRESS OF RECEIVE FRAME EIB COPY EI:BIB(X),A BASE ADDRESS OF ASSOCIATED BIB JNE A,PH01 JUMP IF BIB PRESENT CSK Q,RS:HBC(Y) COMPARE ACTUAL COUNT WITH HEADER BUFFER SIZE JMP $+2 COPY RS:HBC(Y),Q USE HEADER BUFFER SIZE IF LESS THAN ACTUAL COUNT COPY Q,EI:HDL (X) SAVE LENGTH OF HEADER IN EIB RSK RETURN TO CALLER PH01 EQU $ ESTABLISH LENGTHS OF HEADERS COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB COPY LC:LAF(X),A LINE ACCESS FLAGS BITS:EXT A,LAF:ECF EXTRACT EXTENDED CONTROL FIELD FORMAT FLAG ADD =2,A SET LENGTH OF PROTOCOL HEADER EXPECTED CSK A,Q COMPARE PROTOCOL HEADER LENGTH WITH ACTUAL COUNT JMP $+2 COPY Q,A SET HEADER LENGTH TO ACTUAL COUNT IF ACTUAL LESS COPY RS:EIB(Y),X BASE ADDRESS OF RECEIVE FRAME EIB COPY A,EI:HDL(X) SAVE LENGTH OF HEADER IN EIB COPY RS:HBC(Y),A TOTAL LENGTH OF HEADER BUFFER SUB A,Q COMPUTE LENGTH OF FRAME BODY JGE Q,PH02 JUMP IF FULL COMBINED HEADER READ ADD Q,A SET ACTUAL LENGTH OF HEADER READ COPY =0,Q SET FRAME BODY LENGTH OF ZERO PH02 EQU $ FIND USER HEADER LENGTH AND DETERMINE IF BIB USED SUB EI:HDL(X),A FIND LENGTH OF USER HEADER READ JNE A,PH03 JUMP IF USER HEADER PRESENT  JNE Q,PH03 JUMP IF FRAME BODY PRESENT EXCH EI:BIB(X),A GET ADDRESS OF BIB AND CLEAR FROM EIB COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB ADD =LC:RRH,X SET ADDRESS OF READY QUEUE POINTER BLOCK JSK PUT:REQ RETURN BIB TO READY FOR RECEIVE QUEUE  COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB IMS LC:RRC(X) COUNT ANOTHER BUFFER AVAILABLE NOP RSK RETURN TO CALLER PH03 EQU $ SET LENGTHS AND COPY HEADER TO BIB COPY EI:BIB(X),X BASE ADDRESS OF RECEIVE FRAME BIB COPY Q,BI:ACT(X) SAVE ACTUAL COUNT IN USER BUFFER COPY BI:ORF(X),Q OPERATION REQUEST FLAGS BITS:OFF Q,ORF:AHL CLEAR THE HEADER LENGTH FIELD SHIFT: A,ORF:AHLB POSITION ACTUAL HEADER LENGTH OR A,Q MERGE ACTUAL HEADER LENGTH INTO FLAGS COPY Q,BI:ORF(X) SAVE BACK MODIFIED OPERATION REQUEST FLAGS JEQ A,PH05 JUST RETURN IF NO USER HEADER PRESENT COPY RS:EIB(Y),X BASE ADDRESS OF RECEIVE FRAME EIB COPY EI:HDL(X),A FRAME CONTROL FIELD LENGTH CLSN A,=3 JUMP IF EXTENDED CONTROL FIELD JMP PH04 COPY EI:FRM+1(X),A LOAD FOUR BYTES OF USER HEADER COPY EI:FRM+2(X),Q COPY EI:BIB(X),X COPY TO BUFFER IN BIB COPY A,BI:HDR(X) COPY Q,BI:HDR+1(X) RSK RETURN TO CALLER PH04 EQU $ COPY USER HEADER TO BIB FOR EXTENDED CONTROL FIELD COPY EI:FRM+1(X),A LOAD FIRST THREE BYTES OF USER HEADER COPY EI:FRM+2(X),Q SHIFT A,LO,8 FORM FIRST WORD OF USER HEADER SHIFT Q,RO,8 OR Q,A COPY EI:BIB(X),X SAVE IN BIB USER HEADER BUFFER COPY A,BI:HDR(X) COPY RS:EIB(Y),X BASE ADDRESS OF RECEIVE FRAME EIB COPY EI:FRM+2(X),A LOAD BYTES TWO THROUGH FOUR OF USER HEADER COPY EI:FRM+3(X),Q SHIFT A,LO,8 FORM SECOND WORD OF USER HEADER SHIFT Q,RO,8 OR Q,A COPY EI:BIB(X),X SAVE IN BIB USER HEADER BUFFER COPY A,BI:HDR+1(X) PH05 EQU $ JUST RETURN WITH NO USER HEADER PRESENT RSK RETURN TO CALLER * LPOOL TITL RECV:PER - PERFORM A RECEIVE OPERATION * * RECV:PER * * PROCEDURE EXECUTES RECEIVE OPERATIONS UNTIL EITHER A VALID FRAME * IS RECEIVED OR AN ABORT CONDITION OCCURS. ABORT CONDITIONS ARE * ACTIVITY TERMINATION REQUESTED, RECEIVE TIMEOUT EXPIRED, AND * RELEASE OF RECEIVE CONTROL REQUESTED BY PROTOCOL ACTIVITY. * * CALL PARAMETERS: *  NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS AN ERROR RETURN, * INDICATING THAT RECEIVE CONTROL IS BEING TERMINATED, AND DOES NOT * RETURN THE EVENT INFORMATION BLOCK; RETU RN TO CALL+2 IS THE NORMAL * RETURN. * RECV:PER EQU $ COPY =E:RCVFRM,A SET EVENT TYPE CODE FOR RECEIVED FRAME COPY RS:LCB(Y),Q SET BASE ADDRESS OF ASSOCIATED LCB JSK GEN:EVNT ALLOCATE AND INITIALIZE EIB FOR RECEIVED FRAME COPY X,RS:EIB(Y) SAVE BASE ADDRESS OF ALLOCATED EIB RP01 EQU $ LOOP FOR RETRYING BUFFER ALLOCATION JSK GET:BUFF ALLOCATE USER BUFFER FOR RECEIVE OPERATION JMP RP10 DEALLOCATE EIB AND PASS ON ERROR RETURN JSK SET:ROP SET UP FOR RECEIVE OPERATION RP02 EQU $ LOOP FOR PERFORMING A RECEIVE OPERATION COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS BITS:OFF A,RCF:AIP FORCE ABORT IN PROGRESS FLAG OFF COPY A,RS:RCF(Y) COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY Y,A SET ADDRESS OF RECEIVE REQUEST CONTROL BLOCK ADD =RS:SCS,A JSK STRT:RCV START RECEIVE OPERATION RP03 EQU $ LOOP FOR TESTING OPERATION COMPLETION COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY DC:RIP(X),A RECEIVE DRIVER ACTIVE FLAG JEQ A,RP06 JUMP IF ACTIVE FLAG FALSE COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS TBIT RCF:AIP,A ABORT IN PROGRESS FLAG JT OV,RP05 SKIP CHECK FOR TERMINATION IF ALREADY ABORTING JSK CHK:COND CHECK FOR TERMINATION CONDITIONS JNE A,RP04 JUMP IF TERMINATION CONDITION COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB  COPY LC:LAF(X),A LINE ACCESS FLAGS TBIT LAF:RBU,A RECEIVE BUFFERS UNAVAILABLE FLAG JF OV,RP05 JUMP UNLESS RECEIVE BUFFERS UNAVAILABLE COPY LC:RRH(X),A READY FOR RECEIVE LIST HEAD JNE A,RP04 TERMINATE OPERATION IF BUFFER NOW AVAILABLE COPY LC:DIB(X),X BASE ADDRESS OF DIB COPY DI:RQH(X),A READ LIST HEAD JEQ A,RP05 JUMP IF NO RECEIVE BUFFER AVAILABLE RP04 EQU $ TERMINATE RECEIVE OPERATION IN PROGRESS COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS BITS:ON A,RCF:AIP SET ABORT IN PROGRESS FLAG COPY A,RS:RCF(Y) COPY RS:CIB(Y),X BASE ADDRESS OF CIB JSK ABRT:RCV FORCE RECEIVE OPERATION ABORT TERMINATION RP05 EQU $ WAIT BEFORE REPEATING LOOP COPY RS:DET(Y),X SET ADDRESS OF RECEIVE DRIVER ACTIVITY SEMAPHORE ADD =EP:SEM,X JSK R:WAIT WAIT FOR A SIGNAL BEFORE REPEATING LOOP JMP RP03 RP06 EQU $ TERMINATION OF RECEIVE OPERATION COPY RS:CIB(Y),X BASE ADDRESS OF CIB JSK TERM:RCV CLEAN UP RECEIVE OPERATION AND CHECK COMPLETION JNE Q,RP07 JUMP IF NORMAL COMPLETION COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS BITS:ON A,RCF:TRC SET TERMINATING RECEIVE CONTROL FLAG COPY A,RS:RCF(Y) JMP RP10 RELEASE FRAME AND EXIT FOR DEVICE INOPERATIVE RP07 EQU $ RECEIVE OPERATION PERFORMED BY DEVICE BITS:OUT Q,DSF:CRC,DSF:ROV,DSF:ABO,DSF:DMA CHECK ERROR CONDITIONS JEQ Q,RP11 JUMP IF NO ERRORS FOUND TBIT DSF:ABO,Q SKIP COUNTING OF ABORTED RECEIVE FRAMES JT OV,RP09 COPY =CI:MCS,X ASSUME MODEM CONTROL SIGNAL ERROR TBIT DSF:INT,Q COUNT AS SUCH IF INTERFACE ERROR FLAG SET JT OV,RP08 COPY =CI:HDW,X ASSUME CONTROLLER HARDWARE ERROR TBIT DSF:DMA,Q COUNT AS SUCH IF DMA ERROR FLAG SET JT OV,RP08 COPY =CI:OVR,X ASSUME RECEIVE OVERRUN ERROR TBIT DSF:ROV,Q COUNT IT IF SO JT OV,RP08 COPY =CI:FCS,X NONE OF THE ABOVE, MUST BE FCS ERROR RP08 EQU $ COUNT ERROR FOR RECEIVE OPERATION IMS *RS:CIB(X,Y) COUNT THE APPROPRIATE TYPE OF ERROR NOP RP09 EQU $ RETRY OR EXIT AFTER RECEIVE OPERATION ERROR JSK CHK:COND CHECK FOR TERMINATION CONDITIONS JNE A,RP10 RETURN IF TERMINATING CONTROL COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB COPY L C:LAF(X),A LINE ACCESS FLAGS TBIT LAF:RBU,A RECEIVE BUFFERS UNAVAILABLE FLAG JF OV,RP02 JUST RETRY OPERATION IF NOT JMP RP01 RETRY RECEIVE BUFFER ALLOCATION RP10 EQU $ RELEASE EIB AND BIB FOR TERMINATION RETURN JSK RELS:FRM RELEASE THE TABLES RSK  TAKE TERMINATION RETURN TO CALLER RP11 EQU $ SUCCESSFUL COMPLETION OF RECEIVE OPERATION JSK CHK:COND CHECK FOR TERMINATION CONDITIONS JNE A,RP10 JUST DISCARD FRAME IF RELEASING RECEIVE CONTROL COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY DC:RBC(X),A RECEIVE BYTE COUNT CSK A,=2 MAKE SURE MINIMUM PROTOCOL HEADER WAS READ JMP RP09 TREAT AS A RECEIVE OPERATION ERROR OTHERWISE NOP COPY RS:EIB(Y),X BASE ADDRESS OF EIB COPY EI:FRM(X),Q GET ADDRESS FROM RECEIVED FRAME COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB BITS:VAL A,ECI:PSF ASSUME THAT THIS IS A RESPONSE FRAME XOR LC:ADR(X),Q MATCH ADDRESS AGAINST THAT OF REMOTE STATION AND =:FF00,Q CORRECT ASSUMPTION IF ADDRESSES EQUAL JEQ Q,RP12 XOR LC:ADR(X),Q RESTORE ORIGINAL ADDRESS SHIFT: A,ECI:SSF-ECI:PSF ASSUME INSTEAD THAT THIS IS A COMMAND FRAME SHIFT Q,RO,8 POSITION TO MATCH WITH LOCAL STATION ADDRESS XOR LC:ADR(X),Q CORRECT ASSUMPTION IF ADDRESSES EQUAL CLSN Q,=0 JMP RP12 XOR LC:ADR(X),Q ELSE CORRECT FOR MISTAKE CLSN Q,=:FF ALSO TREAT AS COMMAND FRAME IF BROADCAST ADDRESS JMP RP12 JMP RP09 OTHERWISE TREAT AS RECEIVE OPERATION ERROR RP12 EQU $ CHECK POLL/FINAL FLAG FOR EXTENDED CONTROL FIELD COPY LC:LAF(X),Q LINE ACCESS FLAGS COPY RS:EIB(Y),X BASE ADDRESS OF RECEIVE FRAME EIB TBIT LAF:ECF,Q EXTENDED CONTROL FIELD FORMAT FLAG JF OV,RP13 JUMP IF USING NORMAL CONTROL FIELD FORMAT COPY EI:FRM+1(X),Q WORD CONTAINING POLL/FINAL FLAG TBIT 8,Q JUMP IF POLL/FINAL FLAG RESET JF OV,RP14 BITS:ON A,ECI:PFF SET POLL/FINAL FRAME FLAG JMP RP14 RP13 EQU $ CHECK POLL/FINAL FLAG FOR NORMAL CONTROL FIELD COPY EI:FRM(X),Q WORD CONTAINING POLL/FINAL FLAG TBIT 4,Q JUMP IF POLL/FINAL FLAG RESET JF OV,RP14 BITS:ON A,ECI:PFF SET POLL/FINAL FRAME FLAG RP14 EQU $ FINISH FLAGS AND COMPUTE COUNTS COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY DC:RBC(X),Q RECEIVE BYTE COUNT SUB RS:HBC(Y),Q CHECK FOR OVERRUN OF BUFFERS SUB RS:BBC(Y),Q JLE Q,$+2 JUMP IF NO OVERRUN BITS:ON A,ECI:OVR SET BUFFER OVERRUN FLAG COPY RS:EIB(Y),X BASE ADDRESS OF RECEIVE FRAME EIB COPY A,EI:ECI(X) SAVE EVENT CONTROL INFORMATION JSK PRC:HEAD PROCESS USER HEADER AND ESTABLISH COUNTS COPY K,X CURRENT STACK POINTER IMS 0(X) SET RETURN ADDRESS TO SECOND LOCATION PAST CALL RSK RSK RETURN COMPLETED FRAME TO CALLER * LPOOL TITL RECV:DRV - RECEIVE DRIVER TASK MAIN PROGRAM * * RECV:DRV * * MAIN PROGRAM PROCESSES EVENTS RELEASING RECEIVE CONTROL OF THE * COMMUNICATIONS LINE, AND GENERATES RECEIVE FRAME EVENTS. * * START PARAMETERS: * Y - BASE ADDRESS OF RECEIVE STATE TABLE * RECV:DRV EQU $ JSK ALOC:EPT ALLOCATE AND INITIALIZE EPT FOR ACTIVITY JEQ X,RD01 JUMP IF NO MEMORY AVAILABLE COPY =0,A SET NULL TIMEOUT INTERVAL FOR NOW  COPY X,Q COPY BASE ADDRESS OF RECEIVE DRIVER EPT ADD =EP:SEM,Q SET ADDRESS OF ACTIVITY SEMAPHORE JSK INIT:TMR ALLOCATE AND INITIALIZE TIMER CONTROL BLOCK COPY X,RS:TCB(Y) SAVE ADDRESS OF ALLOCATED TCB SUB =EP:SEM,Q RESTORE BASE ADDRESS OF EPT JNE X,R  D02 JUMP IF TCB SUCCESSFULLY ALLOCATED COPY Q,X DEALLOCATE EPT BEFORE TERMINATING JSK RELS:EPT RD01 EQU $ MEMORY NOT AVAILABLE FOR TABLES COPY RS:CET(Y),X BASE ADDRESS OF RECEIVE CONTROL EPT COPY =-1,A SET TERMINATION FLAG COPY A,EP:TRM(X) JMP RD11 SIGNAL TERMINATION TO RECEIVE CONTROL ACTIVITY RD02 EQU $ SAVE ADDRESS OF EPT AND SIGNAL RECEIVE CONTROL ACTIVITY COPY Q,RS:DET(Y) SAVE BASE ADDRESS OF EPT COPY RS:CIB(Y),X ALSO SAVE ADDRESS IN CIB COPY Q,CI:RDP(X) COPY CI:DCT(X),X BASE ADDRESS OF DCT ADD =EP:SEM,Q SET RECEIVE COMPLETION SEMAPHORE ADDRESS COPY Q,DC:RSA(X) COPY RS:CET(Y),X BASE ADDRESS OF RECEIVE CONTROL EPT ADD =EP:SEM,X SET ADDRESS OF SEMAPHORE JSK R:SIG SIGNAL BEGINNING OF RECEIVE DRIVER OPERATION RD03 EQU $ LOOP FOR WAITING FOR RECEIVE CONTROL ALLOCATION COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS TBIT RCF:RCG,A RECEIVE CONTROL GRANTED FLAG JT OV,RD04 JUMP IF RECEIVE CONTROL ACTIVE COPY RS:DET(Y),X BASE ADDRESS OF RECEIVE DRIVER ACTIVITY EPT COPY EP:TRM(X),A TERMINATION FLAG FOR RECEIVE DRIVER ACTIVITY JNE A,RD10 JUMP IF TERMINATION OF ACTIVITY REQUESTED ADD =EP:SEM,X SET ADDRESS OF RECEIVE DRIVER ACTIVITY SEMAPHORE JSK R:WAIT WAIT FOR SOMETHING TO HAPPEN JMP RD03 RD04 EQU $ LOOP FOR RECEIVE CONTROL ACTIVE JSK RECV:PER PERFORM A RECEIVE OPERATION JMP RD08 JUMP TO PROCESS TERMINATION OF RECEIVE CONTROL COPY RS:EIB(Y),X BASE ADDRESS OF RECEIVED FRAME EIB COPY EI:ECI(X),Q EVENT CONTROL INFORMATION COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS TBIT RCF:TRC,A TERMINATING RECEIVE CONTROL FLAG JT OV,RD05 REPORT TERMINATION WITH FRAME IF SET TBIT ECI:PSF,Q JUMP UNLESS A RESPONSE FRAME JF OV,RD06 TBIT ECI:PFF,Q JUMP UNLESS FINAL FLAG SET IN FRAME JF OV,RD06 COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DLS(X),A DEVICE AND LINE STATE FLAGS TBIT DLS:MTP,A JUMP UNLESS A MULTIPOINT LINE JF OV,RD06 COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS BITS:ON A,RCF:TRC SET FLAG FOR TERMINATING RECEIVE CONTROL COPY A,RS:RCF(Y) RD05 EQU $ REPORT TERMINATION OF RECEIVE CONTROL COPY RS:EIB(Y),X BASE ADDRESS OF RECEIVE FRAME EIB BITS:ON Q,ECI:TCF SET FLAG FOR TERMINATING LINE CONTROL COPY Q,EI:ECI(X) JMP RD07 GO TO GENERATE EVENT FOR PROTOCOL HANDLING RD06 EQU $ CHECK IF ENOUGH EIB'S AVAILABLE TO SEND EVENT COPY RS:CIB(Y),X BASE ADDRESS OF CIB  COPY CI:AEC(X),A COUNT OF EIB'S AVAILABLE SUB CI:AET(X),A CHECK IF ENOUGH AVAILABLE TO SEND EVENT JGE A,RD07 JUMP TO SEND FRAME EVENT IF SO JSK RELS:FRM RELEASE THE EIB AND BIB USED FOR FRAME JMP RD04 LOOP FOR ANOTHER RECEIVE OPERATION RD07 EQU $ GENERATE RECEIVE FRAME EVENT FOR PROTOCOL HANDLING COPY RS:EIB(Y),Q BASE ADDRESS OF RECEIVE FRAME EIB COPY RS:LCB(Y),X BASE ADDRESS OF RECEIVE CONTROL LCB COPY LC:EPT(X),X SET ADDRESS OF PROTOCOL ACTIVITY EPT JSK SND:EVNT SEND RECEIVED FRAME EVENT TO PROTOCOL HANDLING COPY RS:RCF(Y),A RECEIVE CONDITION FLAGS TBIT RCF:TRC,A LOOP UNLESS TERMINATING RECEIVE CONTROL JF OV,RD04 JMP RD09 RELEASE RECEIVE CONTROL AND SIGNAL ALLOCATION RD08 EQU $ TERMINATING RECEIVE CONTROL WITHOUT RECEIVED FRAME COPY =E:RCVREL,A SET EVENT TYPE CODE FOR CONTROL RELEASED COPY RS:LCB(Y),Q SET BASE ADDRESS OF RECEIVE CONTROL LCB JSK PRO:EVNT SEND EVENT REPORTING RELEASE OF RECEIVE CONTROL RD09 EQU $ RELEASE CONTROL AND SIGNAL FOR NEW ALLOCATION COPY RS:RCF(Y),A RECEIVE CONDITION   FLAGS BITS:OFF A,RCF:TRC,RCF:RCG TURN OFF TERMINATING AND GRANTED FLAGS COPY A,RS:RCF(Y) COPY RS:LCB(Y),X BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB COPY =0,A SET NULL READ LIST SEMAPHORE ADDRESS COPY A,DI:RQS(X) COPY A,RS:LCB(Y) SET NULL RECEIVE CONTROL LCB ADDRESS COPY RS:CET(Y),X SET ADDRESS OF RECEIVE CONTROL ACTIVITY SEMAPHORE ADD =EP:SEM,X JSK R:SIG SIGNAL RECEIVE CONTROL ACTIVITY TO ALLOCATE CONTROL OF LINE JMP RD03 BACK TO BEGINNING TO WAIT FOR CONTROL TO BE GRANTED RD10 EQU $ RELEASE MEMORY USED FOR TABLES COPY RS:TCB(Y),X BASE ADDRESS OF BUFFER TIMEOUT TCB JSK TERM:TMR RELEASE MEMORY FOR OTHER USAGE COPY =0,A SET NULL EPT ADDRESS IN RST COPY A,RS:DET(Y) COPY RS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:RDP(X),Q BASE ADDRESS OF EPT COPY A,CI:RDP(X) SET NULL RECEIVE DRIVER EPT ADDRESS COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY A,DC:RSA(X) SET NULL RECEIVE SEMAPHORE ADDRESS COPY Q,X DEALLOCATE THE EPT JSK RELS:EPT RD11 EQU $ SIGNAL RECEIVE CONTROL ACTIVITY AND TERMINATE COPY RS:CET(Y),X BASE OF RECEIVE CONTROL ACTIVITY EPT ADD =EP:SEM,X SET ADDRESS OF SEMAPHORE JSK R:SIG SIGNAL THE RECEIVE CONTROL ACTIVITY R:END TERMINATE THIS ACTIVITY SPACE 2 END S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S SIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII TITL SYNCHRONOUS HANDLER TRANSMIT CONTROL (93438-14/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:SIG EXTR R:WAIT EXTR RLS:EVNT EXTR INI:EVNT EXTR PRO:EVNT EXTR ALOC:EPT EXTR RELS:EPT EXTR B:XMITD EXTR WAIT:FLG EXTR TERM:ACT * * EXTERNAL DEFINITIONS * NAM B:XMITC * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:6 NAM G:6 ENDC TITL SYSTEM REQUEST CONTROL BLOCKS FOR THE TRANSMIT CONTROL TASK * * TRANSMIT CONTROL TASK DEFINITION BLOCK * TDB:A C:XMITC,XMIT:CTL,SIZE:TST,,STACK:XC,,4096 * * TRANSMIT CONTROL TASK BEGIN BLOCK * BGIN:A B:XMITC,C:XMITC,:8000 TITL XMIT:CTL - TRANSMIT CONTROL TASK MAIN PROGRAM * * XMIT:CTL * * MAIN PROGRAM PROCESSES EVENTS REQUESTING TRANSMIT CONTROL, AND * HANDLES INITIALIZATION AND TERMINATION OF THE TRANSMIT INSTANCE * AS A WHOLE. * * START PARAMETERS: * A - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * Y - BASE ADDRESS OF TRANSMIT STATE TABLE * XMIT:CTL EQU $ COPY A,TS:CIB(Y) SAVE CIB BASE ADDRESS COPY =0,A COPY A,TS:CET(Y) SET NULL TRANSMIT CONTROL EPT COPY A,TS:DET(Y) SET NULL TRANSMIT DRIVER EPT COPY A,TS:LCB(Y) SET NULL TRANSMIT CONTROL LCB COPY A,TS:TCF(Y) SET NULL TRANSMIT CONDITION FLAGS JSK ALOC:EPT ALLOCATE EPT FOR TRANSMIT CONTROL ACTIVITY JEQ X,XC07 TERMINATE ACTIVITY IF UNABLE TO ALLOCATE COPY X,TS:CET(Y) SAVE ADDRESS OF EVENT PROCESSOR TABLE COPY X,A ALSO SAVE ADDRESS IN CIB COPY TS:CIB(Y),X COPY A,CI:TCP(X) R:BGIN B:XMITD START THE TRANSMIT DRIVER ACTIVITY COPY Y,A SET ADDRESS OF SIGNAL WORD FOR ACTIVATION ADD =TS:DET,A COPY TS:CET(Y),X SET BASE ADDRESS OF EPT JSK WAIT:FLG WAIT FOR TRANSMIT DRIVER ACTIVITY START UP JMP XC06 TERMINATE IF REQUESTED COPY =E:  XMTOPR,A SET EVENT CODE FOR TRANSMIT COMPONENT ACTIVATION COPY =0,Q SET NULL LCB ADDRESS COPY TS:CIB(Y),X BASE ADDRESS OF CIB  COPY CI:LCP(X),X BASE ADDRESS OF LINE CONTROL ACTIVITY EPT JSK INI:EVNT SEND EVENT TO LINE CONTROL ACTIVITY XC01 EQU $ LOOP FOR ASSIGNMENT OF TRANSMIT CONTROL COPY TS:CET(Y),X BASE ADDRESS OF TRANSMIT CONTROL ACTIVITY EPT COPY EP:TRM(X),A TERMINATION FLAG JNE A,XC04 JUMP IF TERMINATION SIGNALLED COPY TS:TCF(Y),A TRANSMIT CONDITION FLAGS TBIT TCF:TCG,A TRANSMIT CONTROL GRANTED FLAG JT OV,SC03 BACK TO WAIT IF CONTROL ALREADY ACTIVE COPY EP:EQH(X),X BASE ADDRESS OF FIRST EIB ON EVENT QUEUE JEQ X,SC03 JUMP IF NONE ARE PRESENT COPY EI:ECI(X),A EVENT CONTROL INFORMATION WORD BITS:EXT A,ECI:TYP EXTRACT THE EVENT TYPE CODE SUB =E:REQXMT,A CHECK FOR A REQUEST TRANSMIT CONTROL EVENT JNE A,XC02 IGNORE ANYTHING OTHER THAN TRANSMIT CONTROL REQUEST COPY EI:LCB(X),Q BASE ADDRESS OF LCB REQUESTING CONTROL COPY Q,TS:LCB(Y) SET AS HOLDER OF TRANSMIT CONTROL COPY TS:TCF(Y),A TRANSMIT CONDITION FLAGS BITS:ON A,TCF:TCG SET TRANSMIT CONTROL GRANTED FLAG COPY A,TS:TCF(Y) COPY =E:XMTGRN,A SET EVENT CODE FOR CONTROL GRANTED JSK PRO:EVNT GENERATE PROTOCOL EVENT FOR TRANSMIT CONTROL GRANTED XC02 EQU $ RELEASE CURRENT EVENT FROM INPUT QUEUE  COPY TS:CET(Y),X BASE ADDRESS OF TRANSMIT CONTROL ACTIVITY EPT JSK RLS:EVNT FLUSH ANY OTHER EVENT FROM QUEUE SC03 EQU $ END OF MAIN LOOP FOR ASSIGNING TRANSMIT CONTROL COPY TS:CET(Y),X BASE ADDRESS OF ACTIVITY EPT ADD =EP:SEM,X SET ADDRESS OF SEMAPHORE IN EPT JSK R:WAIT WAIT FOR A SIGNAL BEFORE REPEATING CHECKS JMP XC01 XC04 EQU $ TERMINATE ALL OF TRANSMIT COMPONENT COPY TS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DLS(X),A DEVICE AND LINE STATE FLAGS COPY TS:DET(Y),X BASE ADDRESS OF TRANSMIT DRIVER EPT JSK TERM:ACT SET FLAG FOR TERMINATION AND SIGNAL XC05 EQU $ WAIT FOR TRANSMIT DRIVER ACTIVITY TERMINATION COPY TS:DET(Y),A OUT OF LOOP IF ACTIVITY TERMINATED JEQ A,XC06 COPY TS:CET(Y),X SET ADDRESS OF CONTROL ACTIVITY SEMAPHORE ADD =EP:SEM,X JSK R:WAIT WAIT FOR SIGNAL BEFORE REPEATING CHECK JMP XC05 XC06 EQU $ RELEASE MEMORY AND TERMINATE COPY TS:CIB(Y),X BASE ADDRESS OF CIB COPY =0,A SET NULL TRANSMIT CONTROL LCB ADDRESS COPY A,CI:TCP(X) COPY TS:CET(Y),X BASE ADDRESS OF TRANSMIT CONTROL EPT JSK RELS:EPT RELEASE MEMORY USED FOR EPT XC07 EQU $ REPORT TERMINATION TO LINE CONTROL ACTIVITY COPY =E:XMTTRM,A SET EVENT CODE FOR TRANSMIT TERMINATION COPY TS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:LCP(X),X SET ADDRESS OF LINE CONTROL ACTIVITY EPT COPY =0,Q SET NULL LCB ADDRESS JSK INI:EVNT SEND EVENT FOR TRANSMIT TERMINATION R:END TERMINATE THE ACTIVITY SPACE 2 END TITL SYNCHRONOUS HANDLER TRANSMIT DRIVER (93438-14/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:SIG EXTR R:WAIT EXTR INI:EVNT EXTR RLS:EVNT EXTR PRO:EVNT EXTR PUT:REQ EXTR ALOC:EPT EXTR RELS:EPT EXTR INIT:TMR EXTR STRT:TMR EXTR CNCL:TMR EXTR TERM:TMR EXTR STRT:XMT EXTR TERM:XMT * * EXTERNAL DEFINITIONS * NAM B:XMITD * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:8 NAM G:8 ENDC TITL SYSTEM REQUEST CONTROL BLOCKS FOR THE TRANSMIT DRIVER TASK * * TRANSMIT DRIVER TASK DEFINITION BLOCK * TDB:A C:XMITD,XMIT:DRV,,,STACK:XD  ,,4096 * * TRANSMIT DRIVER TASK BEGIN BLOCK * BGIN:A B:XMITD,C:XMITD,:8100 TITL XMIT:PER - PERFORM TRANSMISSION OF A FRAME * * XMIT:PER * * PROCEDURE SETS UP FOR THE TRANSMISSION OF A FRAME, STARTS THE * TRANSMIT OPERATION GOING, WAITS FOR COMPLETION, AND COUNTS ANY * ERRORS IN THE TERMINATION STATUS. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * XMIT:PER EQU $ COPY TS:EIB(Y),X BASE ADDRESS OF TRANSMIT FRAME EIB COPY X,A COMPUTE ADDRESS OF HEADER BUFFER ADD =EI:FRM,A COPY A,TS:HBA(Y) COPY EI:HDL(X),A COPY OVER LENGTH OF HEADER COPY A,TS:HBC(Y) COPY EI:BIB(X),X BASE ADDRESS OF BIB INCLUDED IN FRAME JNE X,XP01 JUMP IF A BIB IS PRESENT COPY X,TS:BBA(Y) SET NO BODY BUFFER FOR FRAME COPY X,TS:BBC(Y) JMP XP02 XP01 EQU $ SET UP PARAMETERS FOR BODY BUFFER COPY BI:BUF(X),A COPY OVER BODY BUFFER ADDRESS COPY A,TS:BBA(Y) COPY BI:BCT(X),A COPY OVER BODY BUFFER BYTE COUNT COPY A,TS:BBC(Y) XP02 EQU $ SET UP THE CHANNEL SELECTION WORD COPY TS:EIB(Y),X BASE ADDRESS OF TRANSMIT FRAME EIB COPY EI:ECI(X),A EVENT CONTROL INFORMATION COPY TS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DLS(X),Q DEVICE AND LINE STATE FLAGS BITS:OUT Q,DLS:CHN MASK OUT CHANNEL SELECTION FLAG SHIFT: Q,SCS:CHN-DLS:CHN POSITION CHANNEL SELECTION FLAG ADD =SCC:TOP,Q SET OPERATION CODE FOR TRANSMIT TBIT ECI:PFF,A JUMP UNLESS POLL/FINAL FRAME TRANSMISSION JF OV,XP03 COPY CI:DLS(X),A DEVICE AND LINE STATE FLAGS TBIT DLS:TWS,A JUMP IF TWO-WAY SIMULTANEOUS LINE JT OV,XP03 BITS:ON Q,SCS:NRTS SET FLAG TO TURN OFF REQUEST TO SEND XP03 EQU $ START UP THE OPERATION COPY Q,TS:SCS(Y) SAVE SELECTION WORD IN CONTROL BLOCK COPY Y,A SET ADDRESS OF TRANSMIT REQUEST CONTROL BLOCK ADD =TS:SCS,A JSK STRT:XMT START TRANSMIT OPERATION XP04 EQU $ LOOP FOR TESTING OPERATION COMPLETION COPY TS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY DC:TIP(X),A TRANSMIT OPERATION IN PROGRESS FLAG JEQ A,XP05 JUMP IF OPERATION COMPLETED COPY TS:DET(Y),X SET ADDRESS OF ACTIVITY SEMAPHORE ADD =EP:SEM,X JSK R:WAIT WAIT FOR COMPLETION SIGNAL JMP XP04 XP05 EQU $ TERMINATION OF TRANSMIT OPERATION  COPY TS:CIB(Y),X BASE ADDRESS OF CIB JSK TERM:XMT CLEAN UP AFTER TERMINATION OF OPERATION TBIT DSF:DMA,Q JUMP UNLESS DMA ERROR JF OV,XP06 COPY TS:CIB(Y),X BASE ADDRESS OF CIB IMS CI:HDW(X) COUNT AS CONTROLLER HARDWARE ERROR NOP XP06 EQU $ COUNT CHARACTERS TRANSMITTED AND RETURN COPY TS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY DC:TBC(X),A COUNT OF CHARACTERS TRANSMITTED COPY TS:CIB(Y),X BASE ADDRESS OF CIB ADD CI:AAT(X),A INCLUDE IN TOTAL COUNT TRANSMITTED COPY A,CI:AAT(X) RSK RETURN TO CALLER TITL TERM:CTL - TERMINATE NORMAL TRANSMIT CONTROL * * TERM:CTL * * PROCEDURE PROCESSES AN EVENT RELEASING TRANSMIT CONTROL OF THE * COMMUNICATIONS LINE, RETURNING AN EVENT FOR TRANSMIT CONTROL * RELEASED TO THE ORIGINATOR. * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * TERM:CTL EQU $ COPY TS:TCF(Y),Q TRANSMIT CONDITION FLAGS BITS:OFF Q,TCF:TCG TURN OFF TRANSMIT CONTROL GRANTED FLAG COPY Q,TS:TCF(Y) COPY =E:XMTREL,A SET EVENT CODE FOR TRANSMIT CONTROL RELEASED COPY TS:LCB(Y),Q SET ADDR  ESS OF TRANSMIT CONTROL LCB JSK PRO:EVNT GENERATE PROTOCOL EVENT FOR RELEASING CONTROL COPY =0,A SET NULL TRANSMIT CONTROL LCB COPY A,TS:LCB(Y) COPY TS:CET(Y),X BASE ADDRESS OF TRANSMIT CONTROL EPT ADD =EP:SEM,X SET ADDRESS OF SEMAPHORE WORD JSK R:SIG SIGNAL TRANSMIT CONTROL ACTIVITY TO ALLOCATE RSK RETURN TO CALLER TITL XMIT:CPL - PERFORM COMPLETION PROCESSING FOR TRANSMIT FRAME * * XMIT:CPL * * PROCEDURE PERFORMS COMPLETION PROCESSING FOR A TRANSMIT FRAME * EVENT, RETURNING THE ASSOCIATED BUFFER INFORMATION BLOCK TO THE * COMPLETION QUEUE IN THE LINK CONTROL BLOCK AND UPDATING THE COUNT * OF TRANSMIT FRAMES OUTSTANDING. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * XMIT:CPL EQU $ COPY TS:EIB(Y),X BASE ADDRESS OF TRANSMIT FRAME EIB COPY =0,A GET ASSOCIATED BIB ADDRESS AND SET NULL EXCH A,EI:BIB(X) COPY EI:LCB(X),X BASE ADDRESS OF ORIGINATING LCB COPY LC:TOC(X),Q TRANSMIT OUTSTANDING COUNT SUB =1,Q DECREMENT FOR FRAME TRANSMITTED COPY Q,LC:TOC(X) JEQ A,XC01 JUMP IF NO BIB ASSOCIATED WITH FRAME ADD =LC:TCH,X SET BASE ADDRESS OF POINTER BLOCK JSK PUT:REQ ADD BIB TO TRANSMIT COMPLETE QUEUE IN LCB ADD A,Q XC01 EQU $ SIGNAL ORIGINATOR OF FRAME IF NECESSARY JEQ Q,XC02 JUMP IF NO NEED TO SIGNAL COPY TS:LCB(Y),X BASE ADDRESS OF TRANSMIT CONTROL LCB COPY LC:EPT(X),X SET ADDRESS OF EPT FOR FRAME ORIGINATOR ADD =EP:SEM,X SET ADDRESS OF SEMAPHORE JSK R:SIG SIGNAL ORIGINATING PROTOCOL HANDLER ACTIVITY XC02 EQU $ RETURN TO CALLER RSK RETURN TO CALLER * LPOOL TITL XMIT:DRV - TRANSMIT DRIVER TASK MAIN PROGRAM * * XMIT:DRV * * MAIN PROGRAM PROCESSES EVENTS SUPPLING FRAMES TO BE TRANSMITTED * AND RELEASING TRANSMIT CONTROL OF THE COMMUNICATIONS LINE. * * START PARAMETERS: * Y - BASE ADDRESS OF TRANSMIT STATUS TABLE * XMIT:DRV EQU $ JSK ALOC:EPT ALLOCATE AND INITIALIZE EPT FOR ACTIVITY JNE X,XD01 JUMP IF SUCCESSFULLY ALLOCATED COPY TS:CET(Y),X BASE ADDRESS OF TRANSMIT CONTROL EPT COPY =-1,A SET TERMINATION SIGNAL COPY A,EP:TRM(X) JMP XD09 SIGNAL TERMINATION TO TRANSMIT CONTROL ACTIVITY XD01 EQU $ SET POINTERS TO ALLOCATED EPT COPY X,TS:DET(Y) SAVE ADDRESS OF ALLOCATED EPT IN TST COPY X,A ALSO SAVE ADDRESS IN CIB COPY TS:CIB(Y),X COPY A,CI:TDP(X) COPY CI:DCT(X),X BASE ADDRESS OF DCT ADD =EP:SEM,A SET ADDRESS OF TRANSMIT COMPLETION SEMAPHORE COPY A,DC:TSA(X) COPY TS:CET(Y),X BASE ADDRESS OF TRANSMIT CONTROL EPT ADD =EP:SEM,X SET ADDRESS OF SEMAPHORE WORD JSK R:SIG SIGNAL TRANSMIT CONTROL ACTIVITY XD02 EQU $ MAIN LOOP FOR TRANSMIT DRIVER PROCESSING COPY TS:DET(Y),X BASE ADDRESS OF EPT COPY EP:TRM(X),A TERMINATION FLAG JNE A,XD08 JUMP IF TERMINATION REQUESTED COPY TS:TCF(Y),A TRANSMIT CONDITION FLAGS TBIT TCF:TCG,A TRANSMIT CONTROL GRANTED FLAG JF OV,XD07 JUMP IF TRANSMIT CONTROL INACTIVE COPY EP:EQH(X),X BASE ADDRESS OF FIRST EIB ON EVENT QUEUE JEQ X,XD07 JUMP IF EVENT QUEUE NULL COPY EI:ECI(X),A EVENT CONTROL INFORMATION BITS:EXT A,ECI:TYP EXTRACT EVENT TYPE CODE CLSN =E:RELXMT,A CHECK FOR A RELEASE TRANSMIT CONTROL EVENT JMP XD04 SUB =E:XMTFRM,A ELSE MUST BE A TRANSMIT FRAME EVENT JNE A,XD05  COPY X,TS:EIB(Y) SAVE ADDRESS OF TRANSMIT FRAME EIB COPY EI:LCB(X),Q BASE ADDRESS OF ORIGINATING LCB XOR TS:LCB(Y),Q COMPARE  WITH LCB HOLDING TRANSMIT CONTROL JEQ Q,XD03 JUMP IF CORRECT LCB TO ORIGINATE FRAMES ERR:D EXIT TO DEBUG IF PRESENT JSK XMIT:CPL PERFORM COMPLETION PROCESSING FOR TRANSMIT FRAME JMP XD06 RELEASE CURRENT EVENT XD03 EQU $ PERFORM TRANSMISSION OF FRAME AND PROCESS BUFFER JSK XMIT:PER PERFORM TRANSMISSION OF THE FRAME JSK XMIT:CPL PERFORM COMPLETION PROCESSING FOR TRANSMIT FRAME COPY TS:EIB(Y),X BASE ADDRESS OF TRANSMIT FRAME EIB COPY EI:ECI(X),A EVENT CONTROL INFORMATION TBIT ECI:TCF,A TERMINATE CONTROL FRAME FLAG JF OV,XD06 JUMP UNLESS TERMINATING TRANSMIT CONTROL XD04 EQU $ VALIDATE RELEASE OF TRANSMIT CONTROL COPY TS:TCF(Y),A TRANSMIT CONDITION FLAGS TBIT TCF:TCG,A TRANSMIT CONTROL GRANTED FLAG JF OV,XD05 INVALID EVENT IF CONTROL NOT ACTIVE COPY EI:LCB(X),Q BASE ADDRESS OF ORIGINATING LCB XOR TS:LCB(Y),Q INVALID EVENT IF LCB ADDRESS DOES NOT MATCH JNE Q,XD05  JSK TERM:CTL PROCESS TERMINATION OF RECEIVE CONTROL JMP XD06 DISGARD FIRST EVENT ON QUEUE XD05 EQU $ INVALID EVENT ON QUEUE ERR:D EXIT TO DEBUG IF PRESENT XD06 EQU $ DISCARD CURRENT EVENT FROM QUEUE COPY TS:DET(Y),X BASE ADDRESS OF TRANSMIT DRIVER EPT JSK RLS:EVNT RELEASE CURRENT EVENT ON QUEUE JMP XD02 GET NEXT EVENT FROM QUEUE XD07 EQU $ WAIT FOR A SIGNAL BEFORE REPEATING CHECKS COPY TS:DET(Y),X BASE ADDRESS OF TRANSMIT DRIVER EPT ADD =EP:SEM,X SET ADDRESS OF SEMAPHORE JSK R:WAIT WAIT FOR A SIGNAL BEFORE REPEATING CHECKS JMP XD02 XD08 EQU $ RELEASE MEMORY USED FOR TABLES COPY TS:CIB(Y),X BASE ADDRESS OF CIB COPY =0,A SET NULL EPT ADDRESS IN CIB COPY A,CI:TDP(X) COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY A,DC:TSA(X) SET NULL TRANSMIT SEMAPHORE ADDRESS COPY TS:DET(Y),X BASE ADDRESS OF TRANSMIT DRIVER EPT COPY A,TS:DET(Y) SET NULL ADDRESS JSK RELS:EPT RETURN MEMORY USED FOR EPT TO SYSTEM XD09 EQU $ SIGNAL TRANSMIT CONTROL ACTIVITY AND TERMINATE COPY TS:CET(Y),X BASE ADDRESS OF TRANSMIT CONTROL EPT ADD =EP:SEM,X SET ADDRESS OF SEMAPHORE JSK R:SIG SIGNAL TERMINATION TO TRANSMIT CONTROL ACTIVITY R:END  TERMINATE THE ACTIVITY SPACE 1 END X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X XIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII TITL SYNCHRONOUS HANDLER DEVICE CONTROL (93438-15/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:SIG EXTR R:WAIT EXTR INI:EVNT EXTR ALOC:EPT EXTR RELS:EPT EXTR INIT:TMR EXTR STRT:TMR EXTR CNCL:TMR EXTR TERM:TMR EXTR STRT:RCV EXTR STRT:XMT EXTR STRT:OPR EXTR ABRT:RCV EXTR TERM:OPR * * EXTERNAL DEFINITIONS * NAM B:DEVCC * *  REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:3 NAM G:3 ENDC TITL SYSTEM REQUEST CONTROL BLOCKS FOR THE DEVICE CONTROL TASK * * DEVICE CONTROL TASK DEFINITION BLOCK * TDB:A C:DEVCC,DEVC:CTL,,,STACK:DC,,4096 * * DEVICE CONTROL TASK BEGIN BLOCK * BGIN:A B:DEVCC,C:DEVCC,:8100 TITL INIT:TBL - INITIALIZE TABLES * * INIT:TBL *  * PROCEDURE INITIALIZES THE DEVICE CONTROL TABLE, AND ENTERS THE * ADDRESS OF THE ALLOCATED EVENT PROCESSOR TABLE FOR THE DEVICE * CONTROL ACTIVITY INTO THE CONTROLLER INFORMATION BLOCK. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * INIT:TBL EQU $ COPY =0,A COPY A,DC:RIP(Y) SET RECEIVE IN PROGRESS FLAG FALSE COPY A,DC:TIP(Y) SET TRANSMIT IN PROGRESS FLAG FALSE COPY A,DC:CIP(Y) SET CONTROL OPERATION IN PROGRESS FLAG FALSE COPY A,DC:SIC(Y) SET NULL STATUS INTERRUPT COUNT COPY A,DC:WRC(Y) SET WAITING FOR RESET COMPLETION FLAG FALSE COPY A,DC:DCF(Y) SET ALL DEVICE CONDITION FLAGS FALSE COPY Y,A COMPUTE ADDRESS OF TERMINATION TABLE ADD =DC:RCS,A COPY A,DC:TRM(Y) SAVE TERMINATION TABLE ADDRESS FOR INITIALIZE COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:ADR(X),A LOAD AND POSITION ADDRESS OF THIS STATION SHIFT A,LO,8 OR =:7E,A SET FLAG CODE IN LOW ORDER BYTE COPY A,DC:REG(Y) SAVE REGISTER DATA FOR INITIALIZE COPY DC:EPT(Y),A BASE ADDRESS OF EPT COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY A,CI:DCP(X) SAVE ADDRESS OF DEVICE CONTROL ACTIVITY EPT IN CIB ADD =EP:SEM,A COMPUTE ADDRESS OF SEMAPHORE IN EPT COPY A,DC:CSA(Y) SAVE AS COMPLETION SEMAPHORE FOR CONTROL OPERATIONS RSK RETURN TO CALLER TITL DEV:INIT - DEVICE INITIALIZATION * * DEV:INIT * * PROCEDURE SETS UP AN INITIALIZATION OPERATION CONTROL BLOCK, GIVES * THE ADDRESS OF THE CONTROL BLOCK TO THE CONTROLLER, AND WAITS FOR * A COMPLETION INTERRUPT. IF INITIALIZATION TIMEOUTS OCCUR, UP TO * THREE RETRYS ARE PERFORMED BEFORE GIVING UP. * * CALL PARAMETERS: * A - FLAGS TO BE SET IN INITIALIZE CHANNEL SELECTION WORD * * RETURN PARAMETERS: * A,Q,X - DESTROYED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS AN ERROR RETURN, * INDICATING THAT TERMINATION OF THE DEVICE CONTROL ACTIVITY HAS * BEEN REQUESTED; RETURN TO CALL+2 IS NORMAL. * DEV:INIT EQU $ COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DLS(X),Q DEVICE AND LINE STATE FLAGS BITS:OUT Q,DLS:CHN MASK OUT CHANNEL SELECTION BIT SHIFT: Q,SCS:CHN-DLS:CHN POSITION TO MATCH THAT IN CONTROL BLOCK  OR Q,A MERGE CHANNEL SELECTION BIT COPY CI:DLS(X),Q DEVICE AND LINE STATE FLAGS TBIT DLS:TWS,Q TWO-WAY SIMULTANEOUS FLAG JT OV,DI01 JUMP UNLESS TWO-WAY ALTERNATE LINE BITS:ON A,SCS:NRTS SET FLAG FOR INITIALIZE WITH REQUEST TO SEND LOW DI01 EQU $ CHECK ADDRESS MATCHING TO BE DONE TBIT DLS:MTP,Q JUMP UNLESS MULTIPOINT LINE JF OV,DI02 COPY CI:PIB(X),X BASE ADDRESS OF PIB COPY PI:LOF(X),Q LINK OPTIONS FLAGS BITS:OUT Q,LOF:NS,LOF:AS MASK OUT SECONDARY STATION ENABLE FLAGS JNE Q,DI03 JUMP IF A SECONDARY STATION DI02 EQU $ SET FLAG FOR ALL ADDRESSES ACCEPTED BITS:ON A,SCS:NMA SET NO ADDRESS MATCHING FLAG DI03 EQU $ COMPLETE SETUP OF SELECTION WORD OR =SCC:IOP,A SET CODE FOR INITIALIZATION OPERATION COPY A,DC:SCS(Y) SAVE SELECTION WORD IN CONTROL BLOCK COPY =0,A INITIALIZE CONTROL OPERATION RETRY COUNT COPY A,DC:CRC(Y) DI04 EQU $ OUTPUT ADDRESS OF CONTROL BLOCK TO CONTROLLER  COPY =-1,A SET FLAG FOR CONTROL OPERATION IN PROGRESS COPY A,DC:CIP(Y) COPY Y,A SET ADDRESS OF CONTROL BLOCK ADD =DC:SCS,A COPY DC:CIB(Y),X BASE ADDRESS OF CIB JSK STRT:OPR START THE INITIALIZE OPERATION DI05 EQU $ WAIT LOOP FOR COMPLETION COPY DC:C IP(Y),A CONTROL OPERATION IN PROGRESS FLAG JEQ A,DI07 JUMP IF OPERATION COMPLETED COPY DC:RDR(Y),A RESET DEVICE REQUESTED FLAG JNE A,DI08 TAKE ERROR RETURN IF FLAG SET COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB COPY TC:EXP(X),A TIMER EXPIRATION FLAG JGE A,DI06 JUMP UNLESS TIMER EXPIRED COPY DC:CRC(Y),A COUNT OF RETRYS ATTEMPTED CLSN A,=RETRYS: OUT IF MAXIMUM NUMBER OF RETRYS ATTEMPTED JMP DI09 IMS DC:CRC(Y) COUNT ANOTHER RETRY ATTEMPT JMP DI04 TRY REQUESTING INITIALIZATION AGAIN DI06 EQU $ WAIT FOR SIGNAL BEFORE REPEATING CHECKS COPY DC:EPT(Y),X BASE ADDRESS OF EPT ADD =EP:SEM,X SET ADDRESS OF ACTIVITY SEMAPHORE JSK R:WAIT WAIT FOR SIGNAL JMP DI05 DI07 EQU $ TERMINATION OF INITIALIZATION OPERATION COPY K,X CURRENT STACK POINTER ADDRESS IMS 0(X) SET RETURN ADDRESS FOR NORMAL EXIT DI08 EQU $ UNABLE TO COMPLETE INITIALIZATION COPY DC:CIB(Y),X BASE ADDRESS OF CIB JSK TERM:OPR TERMINATE OPERATION AND CANCEL TIMER DI09 EQU $ ERROR RETURN WITH TIMER INACTIVE RSK RETURN TO CALLER TITL INIT:CON - INITIALIZE CHANNEL AND ESTABLISH OPERATION * * INIT:CON * * PROCEDURE PERFORMS INITIALIZATION OF THE DEVICE CHANNEL BEING USED * AND WAITS UNTIL A SUCCESSFUL CONNECTION HAS BEEN ESTABLISHED. * * CALL PARAMETERS: *  NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS AN ERROR RETURN, * INDICATING THAT TERMINATION OF THE ACTIVITY HAS BEEN REQUESTED; * RETURN TO CALL+2 IS NORMAL. * INIT:CON EQU $  COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:PCC(X),X BASE ADDRESS OF PAIRED CHANNEL CIB JEQ X,IC01 JUMP IF PAIRED CHANNEL UNUSED COPY CI:DCT(X),X BASE ADDRESS OF PAIRED CHANNEL DCT SIN 5 PREVENT INTERRUPTS WHILE CHECKING RESET COPY DC:ACT(X),A PAIRED CHANNEL ACTIVE FLAG JEQ A,IC01 JUMP IF PAIRED CHANNEL INACTIVE COPY DC:WRC(X),A WAITING FOR COMPLETION OF RESET FLAG JEQ A,IC01 JUMP UNLESS PAIRED CHANNEL DOING RESET COPY DC:EPT(Y),X BASE ADDRESS OF EPT COPY EP:TRM(X),A TERMINATION FLAG JNE A,IC05 ERROR EXIT IF TERMINATION REQUESTED COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB JSK STRT:TMR START THE WATCHDOG TIMER RUNNING COPY DC:EPT(Y),X BASE ADDRESS OF EPT ADD =EP:SEM,X SET ADDRESS OF ACTIVITY SEMAPHORE JSK R:WAIT WAIT FOR A SIGNAL BEFORE REPEATING CHECK COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB JSK CNCL:TMR CANCEL TIMER REQUEST IF NOT EXPIRED JMP INIT:CON IC01 EQU $ SET INDICATION OF ACTIVITY RUNNING COPY =-1,A SET CHANNEL ACTIVE FLAG COPY A,DC:ACT(Y) COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DA(X),Q CONTROLLER DEVICE ADDRESS COPY =0,A SET NULL FOR OUTPUT XNX Q INSERT DEVICE ADDRESS IN INSTRUCTION SKELETON SELP A,0 ENABLE CONTROLLER INTERRUPTS JSK DEV:INIT INITIALIZE FOR NORMAL OPERATION JMP IC05 ERROR EXIT IF UNABLE TO INITIALIZE IMS DC:SIC(Y) TREAT STATUS RETURNED AS A STATUS INTERRUPT IC02 EQU $ LOOP FOR CHECKING CONNECTION ESTABLISHED COPY DC:EPT(Y),X BASE ADDRESS OF EPT COPY EP:TRM(X),A TERMINATION FLAG JNE A,IC05 OUT OF LOOP IF TERMINATION SIGNALLED COPY DC:RDR(Y),A REQUEST DEVICE RESET FLAG JNE A,IC05 ERROR RETURN IF RESET REQUESTED EXCH A,DC:SIC(Y) GET STATUS INTERRUPT COUNT AND SET NULL JEQ A,IC03 JUMP UNLESS STATUS INTERRUPT RECEIVED COPY DC:CCS(Y),A DEVICE STATUS RECEIVED TBIT DSF:DSR,A DATA  SET READY SIGNAL STATE JT OV,IC04 JUMP IF DATA SET READY SIGNAL HIGH IC03 EQU $ WAIT FOR ANOTHER SIGNAL BEFORE REPEATING LOOP ADD =EP:SEM,X SET ADDRESS OF ACTIVITY SEMAPHORE JSK R:WAIT WAIT FOR SIGNAL FROM INTERRUPT ROUTINE JMP IC02 IC04 EQU $ RETURN WITH CONNECTION ESTABLISHED COPY DC:DCF(Y),A DEVICE CONDITION FLAGS BITS:ON A,DCF:OPR SET FLAG FOR DEVICE OPERATIONAL COPY A,DC:DCF(Y) COPY K,X CURRENT STACK POINTER ADDRESS IMS 0(X) SET RETURN ADDRESS FOR SUCCESSFUL COMPLETION IC05 EQU $ ERROR RETURN WITH NO CONNECTION RSK RETURN TO CALLER * LPOOL TITL TERM:CON - TERMINATE CONNECTION AND DISABLE CHANNEL * * TERM:CON * * PROCEDURE TERMINATES THE CONNECTION, IF SPECIFIED AS A SWITCHED * CONNECTION, AND INITIALIZES THE CHANNEL TO A DISABLED STATE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS AN ERROR RETURN, * INDICATING THAT THE PROCEDURE WAS UNABLE TO SUCCESSFULLY TERMINATE * THE CONNECTION AND DISABLE THE CHANNEL; RETURN TO CALL+2 IS * NORMAL. * TERM:CON EQU $ COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DLS(X),A DEVICE AND LINE STATE FLAGS TBIT DLS:DED,A DEDICATED LINE FLAG JT OV,TC03 JUMP TO DISABLE IF DEDICATED LINE BITS:VAL A,SCS:NDTR INITIALIZE WITH DATA TERMINAL READY OFF JSK DEV:INIT JMP TC05 TAKE ERROR RETURN IF UNABLE TO INITIALIZE COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB COPY =INT:NDSR,A SET TIMEOUT INTERVAL FOR DATA SET READY OFF COPY A,TC:INT(X) JSK STRT:TMR START THE WATCHDOG TIMER RUNNING IMS DC:SIC(Y) TREAT STATUS RETURNED AS A STATUS INTERRUPT TC01 EQU $ LOOP FOR CHECKING CONNECTION TERMINATED COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB COPY TC:EXP(X),A TIMER EXPIRATION FLAG JLT A,TC05 OUT OF LOOP IF WAITING TOO LONG COPY DC:RDR(Y),A REQUEST DEVICE RESET FLAG JNE A,TC04 ERROR RETURN IF DEVICE RESET REQUESTED EXCH A,DC:SIC(Y) GET STATUS INTERRUPT COUNT AND SET NULL JEQ A,TC02 JUMP UNLESS STATUS INTERRUPT RECEIVED COPY DC:CCS(Y),A DEVICE STATUS RECEIVED TBIT DSF:DSR,A DATA SET READY SIGNAL STATE JT OV,TC02 JUMP IF DATA SET READY STILL HIGH COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB JSK CNCL:TMR CANCEL TIMER REQUEST JMP TC03 CLEAN UP AND DISABLE CHANNEL TC02 EQU $ WAIT FOR ANOTHER SIGNAL BEFORE REPEATING LOOP COPY DC:EPT(Y),X BASE ADDRESS OF EPT ADD =EP:SEM,X SET ADDRESS OF ACTIVITY SEMAPHORE JSK R:WAIT WAIT FOR SIGNAL FROM INTERRUPT ROUTINE JMP TC01 TC03 EQU $ DISABLE CHANNEL AND CLEAN UP FLAGS BITS:VAL A,SCS:DIS INITIALIZE CHANNEL TO DISABLED STATE JSK DEV:INIT JMP TC05 TAKE ERROR RETURN IF UNABLE TO INITIALIZE COPY K,X CURRENT STACK POINTER ADDRESS IMS 0(X) SET NORMAL RETURN ADDRESS SIN 2 PREVENT INTERRUPTS WHILE MODIFYING FLAGS COPY DC:RDR(Y),A REQUEST DEVICE RESET FLAG JNE A,TC05 JUMP IF RESET REQUESTED BY PAIRED ACTIVITY COPY A,DC:ACT(Y) RESET CHANNEL ACTIVE FLAG RSK RETURN TO CALLER TC04 EQU $ UNABLE TO TERMINATE CONNECTION RETURN COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB JSK CNCL:TMR CANCEL TIMER REQUEST IF STILL ACTIVE TC05 EQU $ ERROR RETURN FROM TIMER EXPIRATION RSK RETURN TO CALLER TITL DEV:STAT - PROCESS DEVICE STATUS * * DEV:STAT * * PROCEDURE PROCESSES THE STATUS INFORMATION PROVIDED BY  THE * CONTROLLER WHEN A STATUS INTERRUPT IS GENERATED. WHEN NECESSARY, * RETRYS OF REQUESTED RECEIVE AND TRANSMIT OPERATIONS ARE PERFORMED. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS AN ERROR RETURN, * INDICATING THAT AN UNRECOVERABLE ERROR HAS OCCURRED IN THE * OPERATION OF THE CONTROLLER; RETURN TO CALL+2 IS NORMAL. * DEV:STAT EQU $ COPY DC:CCS(Y),A CURRENT CONTROLLER STATUS BITS:OUT A,DSF:TUN,DSF:INT MASK OUT ERRORS REPORTED IN STATUS JEQ A,DS01 JUMP IF NO ERRORS BEING REPORTED COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY =CI:HDW,Q ASSUME TRANSMIT UNDERRUN ERROR TBIT DSF:TUN,A TRANSMIT UNDERRUN ERROR FLAG JT OV,$+2 JUMP IF ASSUMPTION CORRECT COPY =CI:MCS,Q ELSE SET MODEM CONTROL SIGNAL ERROR XNX Q INDEX INSTRUCTION FOR PROPER COUNTER IN CIB IMS 0(X) COUNT THE SELECTED TYPE OF ERROR NOP DS01 EQU $ SET FLAGS IN TABLE FOR OPERATIONS IN PROGRESS PAIRS: DSF:RIP#DSF:TIP,DCF:RIP#DCF:TIP CHECK FLAG PAIRS COPY DC:DCF(Y),A DEVICE CONDITION FLAGS BITS:OFF A,DCF:RIP,DCF:TIP RESET OPERATION IN PROGRESS FLAGS COPY DC:CCS(Y),Q STATUS REPORTED BY CONTROLLER BITS:OUT Q,DSF:RIP,DSF:TIP MASK OUT FLAGS FOR OPERATIONS IN PROGRESS SHIFT: Q,DCF:TIP-DSF:TIP POSITION TO MATCH FLAGS IN TABLE OR Q,A MERGE IN FLAGS FOR OPERATIONS IN PROGRESS COPY A,DC:DCF(Y) COPY DC:CCS(Y),Q STATUS REPORTED BY CONTROLLER TBIT DSF:DSR,Q DATA SET READY CONTROL SIGNAL JF OV,DS05 TAKE ERROR EXIT IF DATA SET READY LOW TBIT DCF:NOP,A NOP RESPONSE PENDING FLAG JF OV,DS04 JUMP IF NO RESPONSE PENDING COPY DC:CIP(Y),Q CONTROL OPERATION IN PROGRESS FLAG JNE Q,DS04 JUMP IF OPERATION NOT IN PROGRESS BITS:OFF A,DCF:NOP RESET NOP RESPONSE PENDING FLAG COPY A,DC:DCF(Y) COPY DC:RIP(Y),A RECEIVE OPERATION IN PROGRESS FLAG JEQ A,DS03 JUMP IF NO RECEIVE OPERATION IN PROGRESS SHIFT: A,DCF:ROR-DCF:RIP POSITION RECEIVE IN PROGRESS FLAG XOR DC:DCF(Y),A GET DIFFERENCE FROM RECEIVE OPERATION REQUESTED SHIFT: A,DCF:RVR-DCF:ROR POSITION RESULT TO VERIFICATION REQUIRED FLAG AND DC:DCF(Y),A JUMP UNLESS BOTH FLAGS SET TBIT DCF:RVR,A JF OV,DS03 COPY DC:RRC(Y),A RECEIVE OPERATION RETRY COUNT CLSN A,=RETRYS: OUT IF MAXIMUM NUMBER OF RETRYS ATTEMPTED RSK IMS DC:RRC(Y) INCREMENT COUNT OF RECEIVE OPERATION RETRYS COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY DC:DCF(Y),Q DEVICE CONDITION FLAGS TBIT DCF:ROR,Q RECEIVE OPERATION REQUESTED FLAG JT OV,DS02 JUMP IF PERFORMING RECEIVE OPERATION RETRY JSK ABRT:RCV ATTEMPT RETRY ABORTING THE RECEIVE OPERATION JMP DS03 DS02 EQU $ RETRY OF RECEIVE OPERATION COPY DC:RCB(Y),A BASE ADDRESS OF RECEIVE OPERATION CONTROL BLOCK JSK STRT:RCV ATTEMPT A RETRY OF THE RECEIVE OPERATION DS03 EQU $ CHECK FOR TRANSMIT RETRY REQUIRED COPY DC:TIP(Y),A TRANSMIT OPERATION IN PROGRESS FLAG JEQ A,DS04 JUMP IF NO TRANSMIT OPERATION IN PROGRESS COPY DC:DCF(Y),A DEVICE CONDITION FLAGS  SHIFT: A,DCF:TOR-DCF:TIP POSITION TRANSMIT IN PROGRESS FLAG XOR DC:DCF(Y),A GET DIFFERENCE FROM TRANSMIT OPERATION REQUESTED SHIFT: A,DCF:TVR-DCF:TOR POSITION RESULT TO VERIFICATION REQUIRED FLAG AND DC:DCF(Y),A JUMP UNLESS BOTH FLAGS SET TBIT DCF:TVR,A JF OV,DS04 COPY DC:TRC(Y),A TRANSMIT OPERATION RETRY COUNT CLSN A,=RETRYS: OUT IF MAXIMUM NUMBER OF RETRYS ATTEMPTED RSK   IMS DC:TRC(Y) INCREMENT COUNT OF TRANSMIT OPERATION RETRYS COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY DC:TCB(Y),A BASE ADDRESS OF TRANSMIT OPERATION CONTROL BLOCK JSK STRT:XMT ATTEMPT A RETRY OF THE TRANSMIT OPERATION DS04 EQU $ NORMAL RETURN TO CALLER  COPY K,X CURRENT STACK POINTER ADDRESS IMS 0(X) SET RETURN ADDRESS TO CALL PLUS TWO DS05 EQU $ ERROR RETURN TO CALLER RSK  RETURN TO CALLER * LPOOL TITL DEV:RSET - RESET SYNCHRONOUS COMMUNICATION CONTROLLER DEVICE * * DEV:RSET * * PROCEDURE PERFORMS A RESET OPERATION ON THE CONTROLLER BEING USED, * COORDINATING THE ACTION WITH THE HANDLER FOR THE OTHER CHANNEL IF * THE LATTER IS ACTIVE, AND CLEANS UP FOR TERMINATION OF CHANNEL * OPERATION. * * CALL PARAMETERS: *  NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS AN ERROR RETURN, * INDICATING THAT THE PROCEDURE WAS UNABLE TO SUCCESSFULLY COMPLETE * A RESET OPERATION; RETURN TO CALL+2 IS NORMAL. * DEV:RSET EQU $ COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:PCC(X),X BASE ADDRESS OF PAIRED CHANNEL CIB JEQ X,DR01 JUMP IF PAIRED CHANNEL UNUSED COPY CI:DCT(X),X BASE ADDRESS OF PAIRED CHANNEL DCT SIN 5 PREVENT INTERRUPTION WHILE COORDINATING RESET COPY DC:ACT(X),A PAIRED CHANNEL ACTIVE FLAG JEQ A,DR01 JUST DO RESET IF PAIRED CHANNEL INACTIVE COPY DC:RDR(Y),A REQUEST DEVICE RESET FLAG JNE A,DR01 PERFORM RESET IF REQUESTED BY PAIRED CHANNEL COPY =-1,A SET REQUEST DEVICE RESET FLAG FOR PAIRED CHANNEL COPY A,DC:RDR(X) JMP DR06 TAKE NORMAL RETURN TO CALLER DR01 EQU $ PERFORM RESET OF DEVICE COPY =-1,A SET WAITING FOR COMPLETION OF RESET FLAG COPY A,DC:WRC(Y) COPY =0,A INITIALIZE NUMBER OF RETRY ATTEMPTS COPY A,DC:CRC(Y) DR02 EQU $ ATTEMPT RETRY OF RESET OPERATION COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DA(X),Q DEVICE ADDRESS OF CONTROLLER XNX Q OUTPUT RESET COMMAND TO THE CONTROLLER SELP A,1 COPY =0,A INITIALIZE TIMEOUT COUNT FOR RESET OPERATION COPY A,DC:INT(Y) DR03 EQU $ INITIATE TIMEOUT FOR CHECKING RESET OPERATION COPY DC:INT(Y),A COUNT OF TIMEOUTS WHICH HAVE OCCURRED CLSN A,=INT:RESU COMPARE AGAINST MAXIMUM TIME ALLOWED FOR RESET JMP DR07 TAKE ERROR RETURN IF MAXIMUM DELAY EXCEEDED COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB JSK STRT:TMR START THE TIMEOUT INTERVAL IMS DC:INT(Y) COUNT ANOTHER TIMEOUT DR04 EQU $ WAIT FOR COMPLETION OF RESET COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DA(X),Q DEVICE ADDRESS OF CONTROLLER XNX Q TEST IF CONTROLLER NOW BUSY SST 0  JMP DR05 TAKE NORMAL RETURN IF RESET COMPLETE COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB COPY TC:EXP(X),A TIMER EXPIRATION SIGNAL JLT A,DR03 START TIMEOUT AGAIN IF EXPIRED COPY DC:EPT(Y),X BASE ADDRESS OF EPT ADD =EP:SEM,X SET ADDRESS OF ACTIVITY SEMAPHORE JSK R:WAIT WAIT FOR SIGNAL BEFORE REPEATING CHECKS JMP DR04 DR05 EQU $ NORMAL COMPLETION OF RESET OPERATION COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB JSK CNCL:TMR CANCEL TIMEOUT REQUEST IF ACTIVE COPY DC:INT(Y),A COUNT OF TIMEOUT INTERVALS SINCE RESET ISSUED SUB =INT:RESL,A COMPUTE DIFFERENCE FROM MINIMUM NUMBER JGE A,DR06 JUMP IF RESET TOOK LONG ENOUGH COPY DC:CRC(Y),A COUNT OF TIMES RESET WAS ATTEMPTED CLSN A,=RETRYS: COMPARE AGAINST MAXIMUM NUMBER OF ATTEMPTS JMP DR07  ERROR RETURN IF RETRYS EXHAUSTED IMS DC:CRC(Y) COUNT ANOTHER RETRY ATTEMPT JMP DR01 ATTEMPT RESET OF DEVICE AGAIN DR06 EQU $ NORMAL RETURN WITH DEVICE RESET COPY K,X CURRENT STACK POINTER VALUE IMS 0(X) INCREMENT RETURN ADDRESS FOR NORMAL RETURN DR07 EQU $ TIMER EXPIRATION WHILE WAITING FOR COMPLETION COPY =0,A SET NULL VALUE TO USE SIN 2 PREVENT INTERRUPTION WHILE CLEANING UP COPY A,DC:ACT(Y) RESET CHANNEL ACTIVE FLAG COPY A,DC:RDR(Y) RESET REQUEST DEVICE RESET FLAG COPY A,DC:WRC(Y) RESET WAITING FOR RESET FLAG RSK RETURN TO CALLER TITL SIG:WAIT - SIGNAL DRIVER ACTIVITIES WAITING FOR COMPLETIONS * * SIG:WAIT * * PROCEDURE SETS THE RECEIVE AND TRANSMIT OPERATION IN PROGRESS * FLAGS TO INDICATE COMPLETION, AND SIGNALS THE SPECIFIED COMPLETION * SEMAPHORES, IF OPERATIONS ARE CURRENTLY IN PROGRESS. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * SIG:WAIT EQU $ COPY DC:DCF(Y),A DEVICE CONDITION FLAGS TBIT DCF:ROR,A RECEIVE OPERATION REQUESTED FLAG JF OV,SW01 JUMP UNLESS RECEIVE OPERATION OUTSTANDING COPY DC:RIP(Y),A RECEIVE IN PROGRESS FLAG JEQ A,SW01 JUMP IF OPERATION COMPLETED IMS DC:RIP(Y) SIGNAL COMPLETION OF OPERATION NOP COPY DC:RSA(Y),X RECEIVE COMPLETION SEMAPHORE ADDRESS JSK R:SIG SIGNAL RECEIVE DRIVER ACTIVITY SW01 EQU $ CHECK TRANSMIT OPERATION AND SIGNAL COPY DC:DCF(Y),A DEVICE CONDITION FLAGS TBIT DCF:TOR,A TRANSMIT OPERATION REQUESTED FLAG JF OV,SW02 JUMP UNLESS TRANSMIT OPERATION OUTSTANDING COPY DC:TIP(Y),A TRANSMIT IN PROGRESS FLAG JEQ A,SW02 JUMP IF OPERATION COMPLETED IMS DC:TIP(Y) SIGNAL COMPLETION OF OPERATION NOP COPY DC:TSA(Y),X TRANSMIT COMPLETION SEMAPHORE ADDRESS JSK R:SIG SIGNAL TRANSMIT DRIVER ACTIVITY SW02 EQU $ RETURN TO CALLER RSK * LPOOL TITL DEVC:CTL - DEVICE CONTROL TASK MAIN PROGRAM * * DEVC:CTL * * MAIN PROGRAM PERFORMS GENERAL HOUSEKEEPING DUTIES FOR USAGE OF THE * SYNCHRONOUS COMMUNICATIONS CONTROLLER, INCLUDING WATCHDOG TIMEOUTS * OF RECEIVE AND TRANSMIT OPERATIONS AND INITIALIZATION OF THE * CHANNEL. * * START PARAMETERS: * A - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * DEVC:CTL EQU $ COPY A,X COPY BASE ADDRESS OF CIB COPY CI:DCT(X),Y SET BASE REGISTER FOR DCT JSK ALOC:EPT ALLOCATE EPT FOR DEVICE CONTROL ACTIVITY JEQ X,DC01 JUMP IF NO MEMORY AVAILABLE COPY X,DC:EPT(Y) SAVE BASE ADDRESS OF EPT COPY =INT:NRSP,A SET TIMEOUT FOR NO RESPONSE COPY X,Q COPY BASE ADDRESS OF DEVICE CONTROL EPT ADD =EP:SEM,Q SET ADDRESS OF ACTIVITY SEMAPHORE JSK INIT:TMR ALLOCATE AND INITIALIZE TIMER CONTROL BLOCK JNE X,DC02 JUMP IF TCB SUCCESSFULLY ALLOCATED COPY DC:EPT(Y),X DEALLOCATE EPT BEFORE GENERATING EVENT JSK RELS:EPT DC01 EQU $ MEMORY NOT AVAILABLE FOR TABLES JMP DC13 TERMINATE ACTIVITY DC02 EQU $ SAVE ADDRESS OF TCB AND INITIALIZE COPY X,DC:WDT(Y) SAVE ADDRESS OF ALLOCATED TCB JSK INIT:TBL INITIALIZE TABLES COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY =E:DEVOPR,A SET EVENT CODE FOR COMPONENT ACTIVATION COPY =0,Q SET NULL LCB BASE ADDRESS COPY CI:LCP(X),X BASE ADDRESS OF LINE CONTROL ACTIVITY EPT JSK INI:EVNT SEND DEVICE CONTROL OPERATIONAL EVENT JSK INIT:CON INITIALIZE CHANNEL AND ESTABLISH OPERATION JMP DC09 TERMINATE ACTIVITY WITHOUT CONNECTION ESTABLISHED COPY =E:LINCON,A SET EVENT  CODE FOR LINE CONNECTED COPY =0,Q SET NULL LCB BASE ADDRESS COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:LCP(X),X BASE ADDRESS OF LINE CONTROL ACTIVITY EPT JSK INI:EVNT SEND COMMUNICATIONS LINE CONNECTED EVENT DC03 EQU $ MAIN LOOP FOR WATCHDOG TIMER PROCESSING COPY DC:EPT(Y),X BASE ADDRESS OF EPT COPY EP:TRM(X),A TERMINATION FLAG JNE A,DC09 JUMP IF TERMINATION OF ACTIVITY REQUESTED COPY DC:RDR(Y),A REQUEST DEVICE RESET FLAG JNE A,DC08 JUMP IF DEVICE RESET REQUESTED COPY =0,A GET COUNT OF STATUS INTERRUPTS AND SET NULL EXCH A,DC:SIC(Y) JNE A,DC06 JUMP IF STATUS INTERRUPT RECEIVED COPY DC:DCF(Y),Q DEVICE CONDITION FLAGS TBIT DCF:WTA,Q WATCHDOG TIMER ACTIVE FLAG JF OV,DC07 JUMP UNLESS TIMER ACTIVE COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB COPY TC:EXP(X),A TIMER EXPIRATION FLAG JGE A,DC07 JUMP UNLESS TIMER EXPIRED BITS:OFF Q,DCF:WTA TURN OFF WATCHDOG TIMER ACTIVE FLAG COPY Q,DC:DCF(Y) BITS:OUT Q,DCF:ROR,DCF:TOR MASK OUT OPERATION REQUESTED FLAGS SHIFT: Q,DCF:TVR-DCF:TOR POSITION TO MATCH VERIFICATION REQUIRED FLAGS OR DC:DCF(Y),Q MERGE IN FLAGS FOR VERIFICATION REQUIRED COPY Q,DC:DCF(Y) SHIFT: Q,DCF:TIP-DCF:TVR POSITION TO MATCH IN PROGRESS FLAGS XOR DC:DCF(Y),Q MATCH VERIFICATION REQUIRED AGAINST IN PROGRESS BITS:OUT Q,DCF:RIP,DCF:TIP JUMP IF REQUESTED OPERATIONS IN PROGRESS JEQ Q,DC07 COPY DC:DCF(Y),Q DEVICE CONDITION FLAGS TBIT DCF:NOP,Q NOP RESPONSE PENDING FLAG JF OV,DC04 JUMP UNLESS NO RESPONSE TO NOP OPERATION COPY DC:CRC(Y),A CONTROL OPERATION RETRY COUNT CLSN A,=RETRYS: OUT IF MAXIMUM NUMBER OF RETRYS EXCEEDED JMP DC08 IMS DC:CRC(Y) COUNT ANOTHER RETRY ATTEMPT JMP DC05 TRY REQUESTING NOP AGAIN DC04 EQU $ FIRST TIME NOP TO VERIFY OPERATIONS IN PROGRESS BITS:ON Q,DCF:NOP SET FLAG FOR NOP RESPONSE PENDING COPY Q,DC:DCF(Y) COPY =0,A INITIALIZE COUNT OF CONTROL OPERATION RETRYS COPY A,DC:CRC(Y) COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DLS(X),A DEVICE AND LINE STATE FLAGS BITS:OUT A,DLS:CHN MASK OUT CHANNEL SELECTION FLAG SHIFT: A,SCS:CHN-DLS:CHN POSITION FOR REQUEST CONTROL BLOCK OR =SCC:NOP,A SET NOP COMMAND CODE COPY A,DC:SCS(Y) SAVE SYNCHRONOUS CONTROLLER SELECTION WORD DC05 EQU $ GIVE NOP OPERATION TO CONTROLLER COPY =-1,A SET FLAG FOR CONTROL OPERATION IN PROGRESS COPY A,DC:CIP(Y) COPY Y,A SET ADDRESS OF CONTROL BLOCK ADD =DC:SCS,A COPY DC:CIB(Y),X BASE ADDRESS OF CIB JSK STRT:OPR START OPERATION AND WATCHDOG TIMER JMP DC07 DC06 EQU $ STATUS INTERRUPT PROCESSING JSK DEV:STAT PROCESS NEW DEVICE STATUS JMP DC08 UNRECOVERABLE ERROR PROCESSING DC07 EQU $ WAIT FOR NEXT ACTIVATION COPY DC:EPT(Y),X BASE ADDRESS OF EPT ADD =EP:SEM,X SET ADDRESS OF ACTIVITY SEMAPHORE JSK R:WAIT WAIT FOR NEXT ACTIVATION JMP DC03 DC08 EQU $ UNRECOVERABLE ERROR IN DEVICE OPERATION COPY DC:DCF(Y),A DEVICE CONDITION FLAGS BITS:OFF A,DCF:OPR RESET FLAG FOR DEVICE OPERATIONAL COPY A,DC:DCF(Y) COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB JSK CNCL:TMR CANCEL THE TIMER IF IT WAS RUNNING JSK DEV:RSET ASSURE RESET OF CONTROLLER NOP IGNORE IF UNABLE TO RESET JSK SIG:WAIT SIGNAL DRIVER ACTIVITIES WAITING FOR COMPLETIONS JMP DC10 DC09 EQU $ DISABLE CHANNEL TO PREVENT INTERRUPTS JSK TERM:CON TERMINATE LINE CONNECTION JMP DC08 DO A RESET IF UNABLE TO TERMINATE DC10 EQU $ REPORT LINE DISCONNECTED TO LINE CON TROL COPY =E:LINDCN,A SET LINE DISCONNECTED EVENT CODE COPY =0,Q SET NULL LCB ADDRESS COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:LCP(X),X BASE ADDRESS OF LINE CONTROL ACTIVITY EPT JSK INI:EVNT SEND LINE DISCONNECTED EVENT DC11 EQU $ WAIT FOR TERMINATION SIGNAL COPY DC:EPT(Y),X BASE ADDRESS OF EPT COPY EP:TRM(X),A TERMINATION SIGNAL JNE A,DC12 OUT OF LOOP WHEN TERMINATION REQUESTED ADD =EP:SEM,X SET ADDRESS OF ACTIVITY SEMAPHORE JSK R:WAIT WAIT FOR SIGNAL BEFORE REPEATING CHECK JMP DC11 DC12 EQU $ RELEASE MEMORY USED FOR TABLES COPY DC:WDT(Y),X BASE ADDRESS OF WATCHDOG TIMER TCB JSK TERM:TMR RELEASE MEMORY USED TO SYSTEM COPY =0,A SET NULL ADDRESS OF EPT COPY A,DC:EPT(Y) COPY DC:CIB(Y),X GET ADDRESS AND SET NULL IN CIB EXCH A,CI:DCP(X) COPY A,X BASE ADDRESS OF EPT JSK RELS:EPT RELEASE MEMORY USED TO SYSTEM DC13 EQU $ REPORT TERMINATION TO LINE CONTROL ACTIVITY COPY =E:DEVTRM,A SET EVENT CODE FOR DEVICE TERMINATION COPY =0,Q SET NULL LCB ADDRESS COPY DC:CIB(Y),X BASE ADDRESS OF CIB COPY CI:LCP(X),X SET ADDRESS OF LINE CONTROL ACTIVITY EPT JSK INI:EVNT SEND EVENT FOR DEVICE TERMINATION R:END TERMINATE THE ACTIVITY SPACE 2 END TITL SYNCHRONOUS HANDLER DEVICE PROCEDURES (93438-15/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:SIG EXTR STRT:TMR EXTR CNCL:TMR * * EXTERNAL DEFINITIONS * NAM STRT:RCV NAM STRT:XMT NAM STRT:OPR NAM ABRT:RCV NAM TERM:RCV NAM TERM:XMT NAM TERM:OPR * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:D NAM G:D ENDC TITL STRT:RCV - START RECEIVE OPERATION * * STRT:RCV * * PROCEDURE SAVES THE ADDRESS OF THE OPERATION CONTROL BLOCK AND * SETS THE FLAG FOR RECEIVE OPERATION IN PROGRESS IN THE DEVICE * CONTROL TABLE, AND STARTS THE OPERATION GOING BY GIVING THE * ADDRESS OF THE CONTROL BLOCK TO THE CONTROLLER. * *  CALL PARAMETERS: * A - ADDRESS OF RECEIVE OPERATION CONTROL BLOCK * X - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * STRT:RCV EQU $ COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY A,DC:RCB(X) SAVE ADDRESS OF OPERATION CONTROL BLOCK COPY =0,Q RESET RECEIVE OPERATION RETRY COUNT COPY Q,DC:RRC(X) COPY =-1,Q SET RECEIVE OPERATION IN PROGRESS FLAG COPY Q,DC:RIP(X) COPY DC:DCF(X),Q DEVICE CONDITION FLAGS TBIT DCF:OPR,Q LINE OPERATIONAL FLAG  JF OV,SR01 JUMP IF LINE NOT OPERATIONAL BITS:ON Q,DCF:ROR SET RECEIVE OPERATION REQUESTED FLAG COPY Q,DC:DCF(X) COPY DC:CIB(X),X BASE ADDRESS OF CIB JMP STRT:OPR SR01 EQU $ RECEIVE OPERATION WITH LINE NOT OPERATIONAL COPY =0,Q CLEAR RECEIVE OPERATION IN PROGRESS FLAG COPY Q,DC:RIP(X) RSK RETURN TO CALLER TITL STRT:XMT - START TRANSMIT OPERATION * * STRT:XMT * * PROCEDURE SAVES THE ADDRESS OF THE OPERATION CONTROL BLOCK AND * SETS THE TRANSMIT OPERATION IN PROGRESS FLAG IN THE DEVICE CONTROL * TABLE, AND STARTS THE OPERATION GOING BY GIVING THE ADDRESS OF THE * CONTROL BLOCK TO THE CONTROLLER. * * CALL PARAMETERS: * A - ADDRESS OF TRANSMIT OPERATION CONTROL BLOCK * X - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * STRT:XMT EQU $ COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY  A,DC:TCB(X) SAVE ADDRESS OF OPERATION CONTROL BLOCK COPY =0,Q RESET TRANSMIT OPERATION RETRY COUNT COPY Q,DC:TRC(X) COPY =-1,Q SET TRANSMIT OPERATION IN PROGRESS FLAG COPY Q,DC:TIP(X) COPY DC:DCF(X),Q DEVICE CONDITION FLAGS TBIT DCF:OPR,Q LINE OPERATIONAL FLAG JF OV,SX01 JUMP IF LINE NOT OPERATIONAL BITS:ON Q,DCF:TOR SET TRANSMIT OPERATION REQUESTED FLAG COPY Q,DC:DCF(X) COPY DC:CIB(X),X BASE ADDRESS OF CIB JMP STRT:OPR SX01 EQU $ TRANSMIT OPERATION WITH LINE NOT OPERATIONAL COPY =0,Q RESET TRANSMIT OPERATION IN PROGRESS FLAG COPY Q,DC:TIP(X) RSK RETURN TO CALLER TITL STRT:OPR - START CONTROLLER OPERATION * * STRT:OPR * * PROCEDURE STARTS A SYNCHRONOUS COMMUNICATIONS CONTROLLER OPERATION * GOING BY GIVING THE ADDRESS OF THE OPERATION CONTROL BLOCK TO THE * CONTROLLER, PROVIDED THAT THE CONTROLLER IS NOT BUSY WHEN THE * PROCEDURE IS EXECUTED. * * CALL PARAMETERS: * A - ADDRESS OF OPERATION CONTROL BLOCK * X - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * STRT:OPR EQU $ COPY CI:DA(X),Q SYNCHRONOUS COMMUNICATIONS CONTROLLER DEVICE ADDRESS SIN 4 PREVENT ANY INTERFERENCE WHILE TESTING CONTROLLER XNX Q TEST IF CONTROLLER NOW BUSY SST 0 JMP SO01 PERFORM OPERATION IF CONTROLLER NOT BUSY JMP SO02 SO01 EQU $ OUTPUT CONTROL BLOCK ADDRESS TO CONTROLLER XNX Q OUTPUT ADDRESS OF CONTROL BLOCK TO CONTROLLER SELP A,1 SO02 EQU $ START WATCHDOG TIMEOUT IF NOT ACTIVE COPY CI:DCT(X),X BASE ADDRESS OF DCT  COPY DC:DCF(X),Q DEVICE CONDITION FLAGS TBIT DCF:WTA,Q WATCHDOG TIMER ACTIVE FLAG JT OV,SO03 JUMP IF TIMER ACTIVE BITS:ON Q,DCF:WTA SET WATCHDOG TIMER ACTIVE FLAG COPY Q,DC:DCF(X) COPY DC:WDT(X),X SET ADDRESS OF WATCHDOG TIMER TCB JSK STRT:TMR START THE WATCHDOG TIMER SO03 EQU $ RETURN TO CALLER RSK TITL ABRT:RCV - ABORT RECEIVE OPERATION * * ABRT:RCV * * PROCEDURE ABORTS THE CURRENT RECEIVE OPERATION. * * CALL PARAMETERS: * X - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * *  RETURN PARAMETERS: * A,Q,X - DESTROYED * ABRT:RCV EQU $ COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY DC:DCF(X),A DEVICE CONDITION FLAGS TBIT DCF:OPR,A DEVICE OPERATIVE FLAG JF OV,AR01 JUMP IF DEVICE INOPERATIVE BITS:OFF A,DCF:ROR TURN OFF RECEIVE OPERATION REQUESTED FLAG BITS:ON A,DCF:RAR TURN ON RECEIVE ABORT REQUESTED FLAG COPY A,DC:DCF(X) COPY DC:CIB(X),X BASE ADDRESS OF CIB COPY CI:DLS(X),A DEVICE AND LINE STATE FLAGS BITS:EXT A,DLS:CHN EXTRACT CHANNEL SELECTION BIT ADD =1,A INCREMENT TO FORM ADDRESS FOR ABORT PROCEDURE JMP STRT:OPR INITIATE RECEIVE OPERATION ABORT AR01 EQU $ SET OPERATION COMPLETE IF DEVICE INOPERATIVE COPY =0,Q SET RECEIVE OPERATION COMPLETE COPY Q,DC:RIP(X) RSK RETURN TO CALLER TITL TERM:RCV - TERMINATION FOR RECEIVE OPERATION * * TERM:RCV * * PROCEDURE CLEANS UP AFTER THE TERMINATION OF A RECEIVE OPERATION, * DEACTIVATING THE WATCHDOG TIMER IF NO OTHER OPERATIONS ARE NOW IN * PROGRESS. * * CALL PARAMETERS: * X - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,X - DESTROYED * Q - ZERO IF DEVICE FAILURE TERMINATION, OTHERWISE STATUS RETURNED * TERM:RCV EQU $ COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY DC:DCF(X),A DEVICE CONDITION FLAGS   BITS:OFF A,DCF:RAR,DCF:ROR,DCF:RVR,DCF:RIP TURN OFF ALL RECEIVE FLAGS COPY A,DC:DCF(X) TBIT DCF:OPR,A DEVICE OPERATIONAL FLAG JF OV,TR01 JUMP IF DEVICE INOPERATIVE COPY DC:RCS(X),Q RECEIVE OPERATION COMPLETION STATUS COPY DC:CIB(X),X BASE ADDRESS OF CIB JMP TERM:OPR CHECK IF WATCHDOG TIMER SHOULD BE TERMINATED TR01 EQU $ DEVICE INOPERATIVE RETURN COPY =0,Q SET CODE FOR DEVICE FAILURE TERMINATION RSK RETURN TO CALLER TITL TERM:XMT - TERMINATION FOR TRANSMIT OPERATION * * TERM:XMT * *  PROCEDURE CLEANS UP AFTER THE TERMINATION OF A TRANSMIT OPERATION, * DEACTIVATING THE WATCHDOG TIMER IF NO OTHER OPERATIONS ARE NOW IN * PROGRESS. * * CALL PARAMETERS: * X - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,X - DESTROYED * Q - ZERO IF DEVICE FAILURE TERMINATION, OTHERWISE STATUS RETURNED * TERM:XMT EQU $ COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY DC:DCF(X),A DEVICE CONDITION FLAGS BITS:OFF A,DCF:TOR,DCF:TVR,DCF:TIP TURN OFF ALL TRANSMIT FLAGS COPY A,DC:DCF(X) TBIT DCF:OPR,A DEVICE OPERATIONAL FLAG JF OV,TX01 JUMP IF DEVICE INOPERATIVE COPY DC:TCS(X),Q TRANSMIT OPERATION COMPLETION STATUS COPY DC:CIB(X),X BASE ADDRESS OF CIB JMP TERM:OPR CHECK IF WATCHDOG TIMER SHOULD BE TERMINATED TX01 EQU $ DEVICE INOPERATIVE RETURN COPY =0,Q SET DEVICE FAILURE TERMINATION INDICATION RSK RETURN TO CALLER TITL TERM:OPR - TERMINATION FOR CONTROLLER OPERATION * * TERM:OPR * * PROCEDURE CLEANS UP AFTER THE TERMINATION OF A CONTROLLER * OPERATION, DEACTIVATING THE WATCHDOG TIMER IF NO OTHER OPERATIONS * ARE NOW IN PROGRESS. * * CALL PARAMETERS: * X - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,X - DESTROYED *  Q - UNCHANGED * TERM:OPR EQU $ COPY CI:DCT(X),X BASE ADDRESS OF DCT COPY DC:DCF(X),A DEVICE CONDITION FLAGS BITS:OUT A,DCF:RAR,DCF:ROR,DCF:TOR MASK OUT OPERATION FLAGS JNE A,TO01 JUMP IF OTHER OPERATIONS REQUESTED COPY DC:DCF(X),A DEVICE CONDITION FLAGS BITS:OFF A,DCF:WTA TURN OFF WATCHDOG TIMER ACTIVE FLAG COPY A,DC:DCF(X) COPY DC:WDT(X),X BASE ADDRESS OF WATCHDOG TIMER TCB JSK CNCL:TMR CANCEL THE WATCHDOG TIMER REQUEST TO01 EQU $ RETURN TO CALLER RSK SPACE 2 END TITL SYNCHRONOUS HANDLER INTERRUPT ROUTINES (93438-15/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:SSIG EXTR R:RE12 * * EXTERNAL DEFINITIONS * NAM SC:EOBR NAM SC:EOBT NAM SC:EOBS * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL TITL SC:EOBR - RECEIVE OPERATION COMPLETION INTERRUPT ROUTINE * * SC:EOBR * * ROUTINE INCREMENTS THE RECEIVE OPERATION IN PROGRESS FLAG. IF THE * FLAG WAS PREVIOUSLY MINUS ONE, INDICATING THAT AN OPERATION WAS IN * PROGRESS, THE ASSOCIATED COMPLETION SEMAPHORE IS SIGNALLED. * * ENTERED WITH: * X - BASE ADDRESS OF DEVICE CONTROL TABLE * SC:EOBR EQU $ COPY DC:CIB(X),X BASE ADDRESS OF CIB COPY CI:DA(X),A DEVICE ADDRESS FOR SYNCHRONOUS CONTROLLER XNX A MERGE DEVICE ADDRESS INTO INSTRUCTION IN 0,A DO AN INPUT TO CLEAR BUS INTERFACE CHIP (SCOUT) COPY CI:DCT(X),X BASE ADDRESS OF DCT IMS DC:RIP(X) INCREMENT THE RECEIVE IN PROGRESS FLAG JMP R:RE12 IMMEDIATE RETURN IF OPERATION NOT IN PROGRESS COPY DC:R SA(X),X ADDRESS OF COMPLETION SEMAPHORE JSK R:SSIG SIGNAL SEMAPHORE TO INFORM OF COMPLETION JMP R:RE12 TITL SC:EOBT - TRANSMIT OPERATION COMPLETION INTERRUPT ROUTINE * * SC:EOBT * * ROUTINE INCREMENTS THE TRANSMIT OPERATION IN PROGRESS FLAG. IF * FLAG WAS PREVIOUSLY MINUS ONE, INDICATING THAT AN OPERATION WAS IN * WAS IN PROGRESS, THE ASSOCIATED COMPLETION SEMAPHORE IS SIGNALLED. * * ENTERED WITH: * X - BASE ADDRESS OF DEVICE CONTROL TABLE * SC:EOBT EQU $ COPY DC:CIB(X),X BASE ADDRESS OF CIB COPY CI:DA(X),A DEVICE ADDRESS FOR SYNCHRONOUS CONTROLLER XNX A MERGE DEVICE ADDRESS INTO INSTRUCTION IN 0,A DO AN INPUT TO CLEAR BUS INTERFACE CHIP (SCOUT) COPY CI:DCT(X),X BASE ADDRESS OF DCT IMS DC:TIP(X) INCREMENT THE TRANSMIT IN PROGRESS FLAG JMP R:RE12 IMMEDIATE RETURN IF OPERATION NOT IN PROGRESS COPY DC:TSA(X),X ADDRESS OF COMPLETION SEMAPHORE JSK R:SSIG SIGNAL SEMAPHORE TO INFORM OF COMPLETION JMP R:RE12 TITL SC:EOBS - STATUS INTERRUPT ROUTINE * * SC:EOBS * * ROUTINE INCREMENTS THE COUNT OF STATUS INTERRUPTS RECEIVED AND * CHECKS THE STATUS SUPPLIED BY THE CONTROLLER TO DETERMINE IF THE * INTERRUPT IS FOR THE COMPLETION OF AN INITIALIZE OR NOP OPERATION, * OR A GENUINE STATUS INTERRUPT. IF IT IS A COMPLETION INTERRUPT, * IT IS HANDLED IN THE SAME MANNER AS THE RECEIVE AND TRANSMIT * COMPLETION INTERRUPTS. IF IT IS A STATUS INTERRUPT, THE CONTROL * COMPLETION SEMAPHORE IS UNCONDITIONALLY SIGNALLED. * SC:EOBS EQU $ COPY DC:CIB(X),X BASE ADDRESS OF CIB COPY CI:DA(X),A DEVICE ADDRESS FOR SYNCHRONOUS CONTROLLER XNX A MERGE DEVICE ADDRESS INTO INSTRUCTION IN 0,A DO AN INPUT TO CLEAR BUS INTERFACE CHIP (SCOUT) COPY CI:DCT(X),X BASE ADDRESS OF DCT IMS DC:SIC(X) COUNT STATUS INTERRUPT RECEIVED NOP COPY DC:CCS(X),A STATUS SUPPLIED BY CONTROLLER TBIT DSF:CPL,A OPERATION COMPLETE FLAG JF OV,SS01 JUMP IF NOT CONTROL OPERATION COMPLETION INTERRUPT IMS DC:CIP(X) INCREMENT CONTROL OPERATION IN PROGRESS FLAG JMP R:RE12 IMMEDIATE RETURN IF NO OPERATION IN PROGRESS SS01 EQU $ SIGNAL CONTROL COMPLETION SEMAPHORE COPY DC:CSA(X),X CONTROL OPERATION COMPLETION SEMAPHORE ADDRESS JSK R:SSIG SIGNAL SEMAPHORE TO START CONTROL ACTIVITY JMP R:RE12 SPACE 2 END D D D D D D D D D D D D D D D D D D  TITL SYNCHRONOUS HANDLER SHARED PROCEDURES (93438-16/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:SIG EXTR R:WAIT * * EXTERNAL DEFINITIONS * IFT DEBUG: NAM VAL:EPT NAM VAL:LCB ENDC NAM GEN:EVNT NAM SND:EVNT NAM INI:EVNT NAM PRO:EVNT NAM RLS:EVNT NAM DIS:EVNT NAM ALOC:EPT NAM RELS:EPT NAM ALOC:LCB NAM RELS:LCB NAM GET:REQ NAM PUT:REQ NAM DEL:REQ NAM FND:REQ NAM RET:REQ NAM RET:REQQ NAM WAIT:FLG NAM TERM:ACT * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:C NAM G:C ENDC TITL VAL:EPT - VALIDATE AN EVENT PROCESSOR TABLE ADDRESS * * VAL:EPT * * DEBUG PROCEDURE VALIDATES AN EVENT PROCESSOR TABLE ADDRESS BY * SEARCHING THE LIST OF EVENT PROCESSOR TABLES MAINTAINED IN DEBUG * MODE. * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT PROCESSOR TABLE * Y - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A - DESTROYED * Q,X - UNCHAN GED * Y - ADDRESS OF PRIOR EVENT PROCESSOR TABLE IN LIST, ZERO IF HEAD * OF LIST * * RETURN IS ONLY TAKEN IF THE EVENT PROCESSOR TABLE ADDRESS IS * VALID; OTHERWISE, THE PROCEDURE EXITS DIRECTLY TO DEBUG. * IFT DEBUG: VAL:EPT EQU $ JEQ X,VE02 TAKE DEBUG EXIT IF NULL ADDRESS COPY CI:AEP(Y),Y BASE ADDRESS OF FIRST EPT ON LIST JEQ Y,VE02 JUMP IF LIST IS NULL CSN Y,X JUMP IF SPECIFIED EPT IS HEAD OF LIST JMP VE03 VE01 EQU $ COMPARISON LOOP FOR SEARCHING THE LIST COPY EP:NXT(Y),A NEXT POINTER FROM CURRENT EPT IN LIST CSN A,X RETURN TO CALLER IF NEXT IS SPECIFIED EPT RSK COPY A,Y NEXT POINTER TO INDEX REGISTER JNE A,VE01 LOOP UNLESS AT END OF LIST VE02 EQU $ TAKE EXIT TO DEBUG ERR:D ENTER DEBUG VE03 EQU $ RETURN TO CALLER WITH HEAD OF LIST INDICATION COPY =0,Y SET INDICATION FOR HEAD OF LIST RSK RETURN TO CALLER ENDC TITL VAL:LCB - VALIDATE LINK CONTROL BLOCK ADDRESS * * VAL:LCB * * DEBUG PROCEDURE VALIDATES THE SPECIFIED LINK CONTROL BLOCK ADDRESS * BY SEARCHING THE LIST OF LINK CONTROL BLOCKS MAINTAINED IN DEBUG * MODE. * * CALL PARAMETERS: * X - BASE ADDRESS OF LINK CONTROL BLOCK * Y - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A - DESTROYED * Q,X - UNCHANGED * Y - ADDRESS OF PRIOR LINK CONTROL BLOCK IN LIST, ZERO IF * SPECIFIED LINK CONTROL BLOCK IS HEAD OF LIST * * RETURN IS ONLY TAKEN IF THE LINK CONTROL BLOCK ADDRESS IS VALID; * OTHERWISE, THE PROCEDURE EXITS DIRECTLY TO DEBUG. * IFT DEBUG: VAL:LCB EQU $ JEQ X,VL02 EXIT TO DEBUG IF NULL LCB ADDRESS COPY CI:APL(Y),Y BASE ADDRESS OF FIRST LCB ON LIST JEQ Y,VL02 EXIT TO DEBUG IF NULL LIST CSN X,Y JUMP IF SPECIFIED LCB IS FIRST ON LIST JMP VL03 VL01 EQU $ SEARCH LOOP FOR THE ACTIVE LCB LIST COPY LC:NXT(Y),A BASE ADDRESS OF NEXT LCB ON LIST CSN A,X RETURN TO CALLER IF SPECIFIED LCB IS NEXT RSK COPY A,Y BASE ADDRESS OF NEXT LCB TO INDEX JNE A,VL01 LOOP UNLESS AT END OF LIST VL02 EQU $ TAKE ERROR EXIT TO DEBUG ERR:D ENTER DEBUG VL03 EQU $ RETURN SPECIFING FIRST LCB ON LIST COPY =0,Y SET INDICATION FOR LCB IS FIRST ON LIST RSK RETURN TO CALLER ENDC TITL ALOC:EIB - ALLOCATE AN EVENT INFORMATION BLOCK * * ALOC:EIB * *  PROCEDURE ALLOCATES AN EVENT INFORMATION BLOCK OFF THE AVAILABLE * LIST AND INITIALIZES IT. A NULL ADDRESS IS RETURNED IF THE * AVAILABLE LIST IS EMPTY. * * CALL PARAMETERS: * A - EVENT TYPE CODE TO USE * Q - LINK CONTROL BLOCK ADDRESS TO USE * Y - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Y - DESTROYED *  Q - UNCHANGED * X - ADDRESS OF EVENT INFORMATION BLOCK ALLOCATED * ALOC:EIB EQU $ SIN 8 DISALLOW INTERRUPTS WHILE USING AVAILABLE LIST COPY CI:AEC(Y),X GET COUNT AVAILABLE IFF DEBUG: JEQ X,AE01 JUMP IF NONE ENDC IFT DEBUG: JEQ X,AE02 JUMP IF NONE ENDC SUB =1,X DECREMENT COUNT AVAILABLE COPY X,CI:AEC(Y) COPY *CI:ALH(Y),X GET NEXT AFTER FIRST ON LIST JNE X,$+2 JUMP UNLESS ONLY ONE BLOCK PRESENT COPY X,CI:ALT(Y) SET NULL TAIL POINTER FOR LIST EXCH X,CI:ALH(Y) SET AS NEW HEAD AND GET OLD COPY A,EI:ECI(X) INITIALIZE EVENT TYPE CODE COPY Q,EI:LCB(X) INITIALIZE LCB POINTER COPY =0,A INITIALIZE REMAINDER OF BLOCK  COPY A,EI:NXT(X) COPY A,EI:BIB(X) COPY A,EI:HDL(X) IFT DEBUG: JEQ Q,AE01 JUMP IF NULL LCB ADDRESS EXCH Q,X VERIFY NON-NULL LCB ADDRESS JSK VAL:LCB EXCH Q,X SWAP BACK REGISTERS FOR RETURN TO CALLER ENDC AE01 EQU $ / RSK RETURN TO CALLER  IFT DEBUG: AE02 EQU $ / ERR:D TAKE ERROR EXIT TO DEBUG ENDC TITL RELS:EIB - RELEASE AN EVENT INFORMATION BLOCK * *  RELS:EIB * * PROCEDURE RELEASES AN EVENT INFORMATION BLOCK, ADDING THE BLOCK * TO THE AVAILABLE LIST AND INCREMENTING THE COUNT AVAILABLE. * * CALL PARAMETERS: * X - ADDRESS OF EVENT INFORMATION BLOCK TO RELEASE * Y - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * Q,Y,X - UNCHANGED * A - DESTROYED * RELS:EIB EQU $ COPY =0,A SET NULL LINKAGE FROM THIS BLOCK COPY A,EI:NXT(X) COPY X,A SWAP BASE ADDRESS OF BLOCK AND NULL SIN 4 DISALLOW INTERRUPTS WHILE USING AVAILABLE LIST EXCH CI:ALT(Y),X SWAP ADDRESS FOR FORMER LAST ON LIST JNE X,RS01 JUMP IF ANY WERE PRESENT ON LIST COPY A,CI:ALH(Y) SET ADDED BLOCK AS HEAD OF LIST JMP RS02 RS01 EQU $ / COPY A,EI:NXT(X) SET NEXT POINTER TO ADDED BLOCK RS02 EQU $ / IMS CI:AEC(Y) INCREMENT COUNT AVAILABLE ON LIST RSK RSK TITL SEND:EIB - SEND EVENT INFORMATION BLOCK * *  SEND:EIB * * PROCEDURE ADDS THE SPECIFIED EVENT INFORMATION BLOCK TO THE QUEUE * OF EVENT INFORMATION BLOCKS IN THE SPECIFIED EVENT PROCESSOR * TABLE. IF THE QUEUE WAS PREVIOUSLY EMPTY, THE SEMAPHORE IN THE * EVENT PROCESSOR TABLE IS SIGNALLED TO START UP THE ASSOCIATED * ACTIVITY. * * CALL PARAMETERS: * Q - BASE ADDRESS OF EVENT INFORMATION BLOCK * X - BASE ADDRESS OF EVENT PROCESSOR TABLE * Y - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - DESTROYED * SEND:EIB EQU $ IFT DEBUG: JSK VAL:EPT VALIDATE SPECIFIED EPT ADDRESS ENDC COPY Q,Y BASE ADDRESS OF EIB TO INDEX COPY =0,A SET NULL LINKAGE FROM ADDED EVENT COPY A,EI:NXT(Y) SIN 2 DISALLOW INTERRUPTS WHILE MODIFYING QUEUE EXCH Y,EP:EQT(X) SET ADDED EVENT AS NEW TAIL OF QUEUE IFT DEBUG: JNE Y,SE01 JUMP UNLESS FIRST ON QUEUE ENDC IFF DEBUG: JNE Y,SE01 JUMP UNLESS FIRST ON QUEUE ENDC COPY Q,EP:EQH(X) SET ADDED EVENT AS NEW HEAD OF QUEUE ADD =EP:SEM,X FORM ADDRESS OF SEMAPHORE WORD IN EPT JSK R:SIG SIGNAL EVENT PROCESSOR SEMAPHORE RSK RETURN TO CALLER IFT DEBUG: SE01 EQU $ ADDING TO END OF NON-EMPTY QUEUE ENDC IFF DEBUG: SE01 EQU $ ADDING TO END OF NON-EMPTY QUEUE ENDC COPY Q,EI:NXT(Y) SET LINKAGE FROM FORMER END OF QUEUE RSK RETURN TO CALLER TITL RECV:EIB - RECEIVE AN EVENT INFORMATION BLOCK * * RECV:EIB * * PROCEDURE REMOVES THE FIRST EVENT INFORMATION BLOCK FROM THE QUEUE * OF EVENT INFORMATION BLOCKS IN THE SPECIFIED EVENT PROCESSOR * TABLE. A NULL ADDRESS IS RETURNED IF THE QUEUE IS EMPTY. * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT PROCESSOR TABLE * Y - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Y - DESTROYED * Q - UNCHANGED * X - ADDRESS OF EVENT INFORMATION BLOCK REMOVED FROM QUEUE * RECV:EIB EQU $ IFT DEBUG: JSK VAL:EPT VALIDATE EPT ADDRESS SUPPLIED ENDC SIN 5 DISALLOW INTERRUPTS WHILE MODIFYING QUEUE COPY EP:EQH(X),Y ADDRESS  OF FIRST EIB IN QUEUE JEQ Y,RE01 JUMP IF QUEUE IS ALREADY EMPTY COPY EI:NXT(Y),A ADDRESS OF NEXT AFTER EIB BEING REMOVED COPY A,EP:EQH(X) SET AS NEW HEAD OF QUEUE JNE A,RE01 JUMP UNLESS QUEUE NOW EMPTY COPY A,EP:EQT(X) SET NULL POINTER FOR TAIL OF EMPTY QUEUE RE01 EQU $ / COPY Y,X BASE ADDRESS OF EIB TO CORRECT REGISTER RSK RETURN TO CALLER * LPOOL TITL GEN:EVNT - ALLOCATE AND INITIALIZE EVENT INFORMATION BLOCK * * GEN:EVNT * * PROCEDURE ALLOCATES AN EVENT INFORMATION BLOCK OFF THE AVAILABLE * LIST AND INITIALIZES IT TO THE SPECIFIED EVENT TYPE. A NULL * ADDRESS IS RETURNED IF THE AVAILABLE LIST IS EMPTY. * * CALL PARAMETERS: * A - EVENT TYPE CODE TO USE * Q - LINK CONTROL BLOCK ADDRESS TO USE * Y - ADDRESS OF ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * X - ADDRESS OF EVENT INFORMATION BLOCK ALLOCATED * A,Q,Y - UNCHANGED * GEN:EVNT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY 0(Y),Y BASE ADDRESS OF CIB JSK ALOC:EIB ALLOCATE AND INITIALIZE THE EIB COPY K,Y GET CURRENT STACK POINTER VALUE COPY X,STK:X(Y) SAVE SPECIFIED X VALUE POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL SND:EVNT - SEND EVENT TO EVENT PROCESSOR * *  SND:EVNT * * PROCEDURE ADDS THE SPECIFIED EVENT INFORMATION BLOCK TO THE QUEUE * OF EVENT INFORMATION BLOCKS IN THE SPECIFIED EVENT PROCESSOR * TABLE. THE EVENT PROCESSOR IS SIGNALLED IF THE QUEUE WAS * PREVIOUSLY EMPTY. * * CALL PARAMETERS: * Q - BASE ADDRESS OF EVENT INFORMATION BLOCK * X - BASE ADDRESS OF EVENT PROCESSOR TABLE * Y - ADDRESS OF ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * SND:EVNT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY 0(Y),Y BASE ADDRESS OF CIB JSK SEND:EIB SEND THE EVENT POP RESTORE USER REGISTERS RSK RETURN TO CALLER TITL INI:EVNT - GENERATE AND SEND EVENT * * INI:EVNT * * PROCEDURE ALLOCATES AN EVENT INFORMATION BLOCK, INITIALIZES IT TO * THE SPECIFIED EVENT TYPE, AND SENDS IT TO THE SPECIFIED EVENT * PROCESSOR TABLE. IF NO EVENT INFORMATION BLOCKS ARE PRESENT ON * THE AVAILABLE LIST, THE PROCEDURE SIMPLY FAILS WITHOUT NOTIFYING * THE CALLER. * * CALL PARAMETERS: * A - EVENT TYPE CODE TO USE * Q - LINK CONTROL BLOCK TO USE *  X - BASE ADDRESS OF EVENT PROCESSOR TABLE * Y - ADDRESS OF ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * INI:EVNT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY 0(Y),Y BASE ADDRESS OF CIB JSK ALOC:EIB ALLOCATE AND INITIALIZE THE EIB JEQ X,IN01 JUST RETURN IF NONE AVAILABLE COPY X,Q COPY EIB BASE ADDRESS TO CORRECT REGISTER COPY K,Y GET CURRENT STACK POINTER VALUE COPY STK:X(Y),X LOAD SAVED EPT BASE ADDRESS COPY *STK:Y(Y),Y GET BASE ADDRESS OF CIB JSK SEND:EIB SEND THE GENERATED EVENT IN01 EQU $ / POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL PRO:EVNT - GENERATE AND SEND PROTOCOL EVENT * * PRO:EVNT * * PROCEDURE ALLOCATES AN EVENT INFORMATION BLOCK, INITIALIZES IT TO * THE SPECIFIED EVENT TYPE, AND SENDS IT TO THE PROTOCOL HANDLER * ACTIVITY ASSOCIATED WI TH THE SPECIFIED LINK CONTROL BLOCK. IF NO * EVENT INFORMATION BLOCKS ARE AVAILABLE, THE PROCEDURE SIMPLY FAILS * WITHOUT NOTIFYING THE CALLER. * * CALL PARAMETERS: * A - EVENT TYPE CODE TO USE * Q - BASE ADDRESS OF LINK CONTROL BLOCK * Y - ADDRESS OF ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * PRO:EVNT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY 0(Y),Y BASE ADDRESS OF CIB JSK ALOC:EIB ALLOCATE AND INITIALIZE THE EIB JEQ X,PE01 JUST RETURN IF NONE AVAILABLE EXCH X,Q SWAP EIB AND LCB ADDRESSES COPY LC:EPT(X),X SET BASE ADDRESS OF EPT COPY K,Y CURRENT STACK POINTER VALUE COPY *STK:Y(Y),Y GET BASE ADDRESS OF CIB JSK SEND:EIB SEND THE GENERATED EVENT PE01 EQU $ / POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL RLS:EVNT - RELEASE CURRENT EVENT INFORMATION BLOCK * * RLS:EVNT * * PROCEDURE REMOVES THE FIRST EVENT INFORMATION BLOCK FROM THE QUEUE * OF EVENT INFORMATION BLOCKS IN THE SPECIFIED EVENT PROCESSOR TABLE * AND RELEASES IT FOR OTHER USAGE. IF THE QUEUE IS EMPTY, THE * PROCEDURE SIMPLY FAILS WITH NO NOTIFICATION TO THE USER. * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT PROCESSOR TABLE * Y - ADDRESS OF ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * RLS:EVNT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY 0(Y),Y BASE ADDRESS OF CIB JSK RECV:EIB REMOVE FIRST EIB FROM QUEUE JEQ X,RL01 JUMP IF NONE PRESENT ON QUEUE COPY K,Y GET CURRENT STACK POINTER VALUE COPY *STK:Y(Y),Y BASE ADDRESS OF CIB JSK RELS:EIB RELEASE EIB FOR OTHER USAGE RL01 EQU $ / POP RESTORE CALLING REGISTERS RSK TITL DIS:EVNT - DISCARD EVENT INFORMATION BLOCK * * DIS:EVNT * * PROCEDURE RETURNS THE SPECIFIED EVENT INFORMATION BLOCK TO THE * AVAILABLE LIST. * * CALL PARAMETERS: * X - ADDRESS OF EVENT INFORMATION BLOCK * Y - ADDRESS OF ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * DIS:EVNT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY 0(Y),Y BASE ADDRESS OF CIB JSK RELS:EIB RETURN THE EIB TO THE AVAILABLE LIST POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL ALOC:EPT - ALLOCATE AND INITIALIZE EVENT PROCESSOR TABLE * * ALOC:EPT * * PROCEDURE ALLOCATES AND INITIALIZES AN EVENT PROCESSOR TABLE. * * CALL PARAMETERS: * Y - ADDRESS OF ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,Y - UNCHANGED * X - BASE ADDRESS OF EVENT PROCESSOR TABLE IF NONZERO, ZERO IF * UNABLE TO ALLOCATE * ALOC:EPT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK R:ABUF SIZE:EPT ALLOCATE EPT FROM ENVIRONMENT MEMORY POOL JEQ X,AP01 JUMP IF NO MEMORY AVAILABLE COPY =0,A INITIALIZE BODY OF EVENT PROCESSOR TABLE COPY A,EP:TRM(X) COPY A,EP:SEM(X) COPY A,EP:EQH(X) COPY A,EP:EQT(X) IFF DEBUG: COPY A,EP:NXT(X) ENDC IFT DEBUG: COPY 0(Y),Y BASE ADDRESS OF CIB SIN 2 BLOCK OUT INTERRUPTS WHILE ADDING TO LIST COPY CI:AEP(Y),A HEAD OF ACTIVE EVENT PROCESSOR TABLE LIST COPY X,CI:AEP(Y) SET NEW EPT AS HEAD OF LIST COPY A,EP:NXT(X) LINK FROM NEW EPT TO FORMER HEAD OF LIST ENDC AP01 EQU $ R ETURN ALLOCATED EPT ADDRESS TO CALLER COPY K,Y SAVE ALLOCATED EPT ADDRESS ON STACK COPY X,STK:X(Y) POP RESTORE MODIFIED CALLING REGISTERS RSK RETURN TO CALLER TITL RELS:EPT - RELEASE EVENT PROCESSOR TABLE * * RELS:EPT * * PROCEDURE RETURNS THE MEMORY USED FOR AN EVENT PROCESSOR TABLE TO * THE ENVIRONMENT MEMORY POOL. * * CALL PARAMETERS: *  X - BASE ADDRESS OF EVENT PROCESSOR TABLE * Y - ADDRESS OF ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * RELS:EPT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK IFT DEBUG: COPY 0(Y),Y BASE ADDRESS OF CIB JSK VAL:EPT VALIDATE EPT ADDRESS IN CALL COPY EP:NXT(X),A BASE ADDRESS OF NEXT EPT IN LIST JNE Y,RP01 JUMP IF EPT BEING RELEASED WAS NOT FIRST COPY K,Y GET CIB ADDRESS FROM STACK COPY *STK:Y(Y),Y COPY A,CI:AEP(Y) SET NEXT EPT IN LIST AS NEW HEAD JMP RP02 RP01 EQU $ DELETE EPT FROM LIST WHEN NOT HEAD COPY A,EP:NXT(Y) LINK PRIOR EPT IN LIST TO NEXT RP02 EQU $ CONTINUE WITH NORMAL EXECUTION ENDC R:RBUF 0(X) RETURN MEMORY USED FOR EPT TO POOL POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER TITL ALOC:LCB - ALLOCATE AND INITIALIZE LINK CONTROL BLOCK * * ALOC:LCB * * PROCEDURE ALLOCATES AND INITIALIZES A LINK CONTROL BLOCK, ADDING * IT TO THE LIST OF ACTIVE LINK CONTROL BLOCKS IF OPERATING IN DEBUG * MODE. * * CALL PARAMETERS: * A - BASE ADDRESS OF ASSOCIATED DEVICE INFORMATION BLOCK * Y - ADDRESS OF ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,Y - UNCHANGED * X - BASE ADDRESS OF LINK CONTROL BLOCK IF NONZERO, ZERO IF UNABLE * TO ALLOCATE * ALOC:LCB EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK  R:ABUF SIZE:LCB ALLOCATE LCB FROM EVNIRONMENT MEMORY POOL JEQ X,AC01 JUMP IF NO MEMORY AVAILABLE COPY A,LC:DIB(X) SET BASE ADDRESS OF DIB COPY =0,Q INITIALIZE BODY OF LINK CONTROL BLOCK COPY Q,LC:EPT(X) COPY Q,LC:LAF(X) COPY Q,LC:RRC(X) COPY Q,LC:RRH(X) COPY Q,LC:RRT(X) COPY Q,LC:TOC(X) COPY Q,LC:TCH(X) COPY Q,LC:TCT(X) IFF DEBUG: COPY Q,LC:NXT(X) ENDC IFT DEBUG: COPY 0(Y),Y BASE ADDRESS OF CIB SIN 2 BLOCK OUT INTERRUPTS WHILE ADDING TO LIST COPY CI:APL(Y),Q HEAD OF ACTIVE LINK CONTROL BLOCK LIST COPY X,CI:APL(Y) SET NEW LCB AS HEAD OF LIST COPY Q,LC:NXT(X) LINK FROM NEW LCB TO FORMER HEAD OF LIST ENDC EXCH X,A SWAP REGISTERS TO GET DIB IN INDEX COPY A,DI:LCB(X) SET BASE ADDRESS OF LCB COPY DI:ADR(X),Q PROTOCOL LINK ADDRESSES COPY A,X GET BASE ADDRESS OF LCB BACK TO INDEX COPY Q,LC:ADR(X) SET PROTOCOL LINK ADDRESSES AC01 EQU $ RETURN ALLOCATED LCB ADDRESS TO CALLER COPY K,Y SAVE ALLOCATED LCB ADDRESS ON STACK COPY X,STK:X(Y) POP RESTORE MODIFIED CALLING REGISTERS RSK  RETURN TO CALLER TITL RELS:LCB - RELEASE LINK CONTROL BLOCK * * RELS:LCB * * PROCEDURE RETURNS THE MEMORY USED FOR A LINK CONTROL BLOCK TO THE * ENVIRONMENT MEMORY POOL. * * CALL PARAMETERS: * X - BASE ADDRESS OF LINK CONTROL BLOCK * Y - ADDRESS OF ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * RELS:LCB EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK IFT DEBUG: COPY 0(Y),Y BASE ADDRESS OF CIB JSK VAL:LCB VALIDA TE LCB ADDRESS IN CALL COPY LC:NXT(X),A BASE ADDRESS OF NEXT LCB IN LIST JNE Y,RC01 JUMP IF LCB BEING RELEASED WAS NOT FIRST COPY K,Y GET CIB ADDRESS FROM STACK COPY *STK:Y(Y),Y COPY A,CI:APL(Y) SET NEXT LCB IN LIST AS NEW HEAD JMP RC02 RC01 EQU $ DELETE LCB FROM LIST WHEN NOT HEAD COPY A,EP:NXT(Y) LINK PRIOR LCB IN LIST TO NEXT RC02 EQU $ CONTINUE WITH NORMAL EXECUTION ENDC COPY LC:DIB(X),A BASE ADDRESS OF ASSOCIATED DIB EXCH A,X SWAP TO INDEX REGISTER COPY =0,Q SET NULL LINK CONTROL BLOCK ADDRESS COPY Q,DI:LCB(X) COPY A,X BASE ADDRESS OF LCB BACK TO INDEX R:RBUF 0(X) RETURN MEMORY USED FOR LCB TO POOL POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER * LPOOL TITL GET:REQ - GET CONTROL BLOCK FROM QUEUE * * GET:REQ * * PROCEDURE REMOVES THE FIRST CONTROL BLOCK FROM THE SPECIFIED * QUEUE, AND RETURNS THE ADDRESS OF THE BLOCK REMOVED. * A NULL ADDRESS IS RETURNED IF THE SPECIFIED QUEUE IS EMPTY. * * CALL PARAMETERS: * X - BASE ADDRESS OF POINTER BLOCK FOR QUEUE * * RETURN PARAMETERS: * A - BASE ADDRESS OF CONTROL BLOCK REMOVED FROM QUEUE * Q,X,Y - UNCHANGED * GET:REQ EQU $ PUSH STATUS: SAVE CALLER REGISTERS ON STACK COPY X,Y ADDRESS OF QUEUE POINTER BLOCK SIN 5 DISALLOW INTERRUPTS WHILE MODIFYING QUEUE COPY 0(Y),X GET HEAD POINTER CONTENTS FOR QUEUE JEQ X,GT01 JUMP IF QUEUE ALREADY EMPTY COPY =0,A GET NEXT POINTER FROM FIRST ON QUEUE EXCH BI:NXT(X),A COPY A,0(Y) SAVE AS NEW HEAD OF QUEUE JNE A,GT01 JUMP UNLESS QUEUE NOW EMPTY COPY A,1(Y) SET TAIL POINTER TO NULL ALSO GT01 EQU $ / COPY K,Y CURRENT STACK POINTER VALUE COPY X,STK:A(Y) PLUG VALUE TO BE RETURNED IN A POP RESTORE USER REGISTERS RSK RETURN TO CALLER TITL PUT:REQ - PUT CONTROL BLOCK IN QUEUE * * PUT:REQ * * PROCEDURE ADDS THE SPECIFIED CONTROL BLOCK TO THE SPECIFIED QUEUE. * * CALL PARAMETERS: *  A - BASE ADDRESS OF CONTROL BLOCK * X - BASE ADDRESS OF POINTER BLOCK FOR QUEUE * * RETURN PARAMETERS: * A - ZERO IF QUEUE WAS EMPTY, UNCHANGED OTHERWISE * Q,X,Y - UNCHANGED * PUT:REQ EQU $ PUSH STATUS: SAVE CALLER REGISTERS ON STACK COPY A,Y BASE ADDRESS OF CONTROL BLOCK BEING ADDED COPY =0,Q SET NULL LINKAGE FROM NEW CONTROL BLOCK IN QUEUE COPY Q,BI:NXT(Y) SIN 2 DISALLOW INTERRUPTS WHILE MODIFYING QUEUE EXCH Y,1(X) SET NEW CONTROL BLOCK AS TAIL OF QUEUE JEQ Y,PT01 JUMP IF QUEUE PREVIOUSLY EMPTY COPY A,BI:NXT(Y) LINK FORMER LAST TO ADDED CONTROL BLOCK POP RESTORE CALLING REGISTERS RSK  RETURN TO CALLER PT01 EQU $ / COPY A,0(X) SET NEW CONTROL BLOCK AS HEAD OF QUEUE POP RESTORE CALLING REGISTERS COPY =0,A SET INDICATOR FOR QUEUE PREVIOUSLY EMPTY RSK RETURN TO CALLER TITL DEL:REQ - DELETE CONTROL BLOCK FROM QUEUE * * DEL:REQ * * PROCEDURE DELETES THE SPECIFIED CONTROL BLOCK FROM THE SPECIFIED * LOCATION IN THE SPECIFIED QUEUE. * * CALL PARAMETERS: * A - ZERO IF BLOCK AT HEAD OF QUEUE, BASE ADDRESS OF PRIOR BLOCK * OTHERWISE *  Q - BASE ADDRESS OF QUEUE POINTER BLOCK * X - BASE ADDRESS OF CONTROL BLOCK * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * DEL:REQ EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY Q,Y BASE ADDRESS OF QUEUE POINTER BLOCK JNE A,  DR01 JUMP IF DELETING FROM MIDDLE OF QUEUE EXCH BI:NXT(X),A LINKAGE TO NEXT FROM BLOCK BEING DELETED COPY A,0(Y) SET NEXT IN QUEUE AS NEW HEAD JNE A,DR02 JUMP UNLESS NO NEXT COPY A,1(Y) SET NULL TAIL POINTER FOR QUEUE JMP DR02 DR01 EQU $ / COPY =0,Q LINKAGE TO NEXT FROM BLOCK BEING DELETED EXCH BI:NXT(X),Q COPY A,X SWAP PRIOR AND NEXT ADDRESSES COPY Q,BI:NXT(X) SET PRIOR LINKAGE TO NEXT IN QUEUE JNE Q,DR02 JUMP UNLESS DELETED FROM END OF QUEUE COPY A,1(Y) SET NULL TAIL POINTER FOR QUEUE DR02 EQU $ / POP RESTORE ALL ENTERING REGISTERS RSK RETURN TO CALLER TITL FND:REQ - FIND CONTROL BLOCK IN QUEUE * *  FND:REQ * * PROCEDURE FINDS THE SPECIFIED CONTROL BLOCK IN THE SPECIFIED * QUEUE. * * CALL PARAMETERS: *  A - BASE ADDRESS OF CONTROL BLOCK * X - BASE ADDRESS OF POINTER BLOCK FOR QUEUE * * RETURN PARAMETERS: * A - ZERO IF UNABLE TO FIND, OTHERWISE UNCHANGED * X - ZERO IF FOUND BLOCK AT THE HEAD OF QUEUE, OTHERWISE ADDRESS * OF PRIOR CONTROL BLOCK * Q,Y - UNCHANGED * FND:REQ EQU $ PUSH STATUS: SAVE ENTERING REGISTER ON STACK COPY K,Y CURRENT STACK POINTER VALUE COPY 0(X),X GET HEAD POINTER CONTENTS FOR QUEUE CSN X,A CHECK FOR RIGHT CONTROL BLOCK JMP FD03 FOUND IN THE HEAD OF QUEUE JEQ X,FD02 JUMP IF QUEUE EMPTY FD01 EQU $ LOOP FOR SEARCH COPY BI:NXT(X),Q GET NEXT CONTROL BLOCK CSN A,Q CHECK FOR RIGHT CONTROL BLOCK JMP FD04 JUMP IF FOUND COPY Q,X BASE ADDRESS OF CONTROL BLOCK JNE X,FD01 JUMP IF NOT THE LAST CONTROL BLOCK FD02 EQU $ UNABLE TO FIND COPY =0,A SET RETURN VALUE FOR NOT FOUND COPY A,STK:A(Y) JMP FD05 FD03 EQU $ FOUND IN THE LIST HEAD OF QUEUE COPY =0,X FD04 EQU $ STORE BASE ADDRESS OF THE PREVIOUS CONTROL BLOCK COPY X,STK:X(Y) FD05 EQU $ RESTORE CALLING REGISTERS POP RSK RETURN TO CALLER TITL RET:REQ - RETURN COMPLETED REQUEST TO USER * * RET:REQ * * PROCEDURE PERFORMS COMPLETION PROCESSING FOR A USER REQUEST. THE * SPECIFIED TERMINATION CODE IS ENTERED IN THE REQUEST CONTROL *  BLOCK, AND IF A COMPLETION QUEUE ADDRESS IS SPECIFIED THE CONTROL * BLOCK IS ADDED TO THE QUEUE. * * CALL PARAMETERS: * Q - TERMINATION CODE * X - BASE ADDRESS OF BUFFER INFORMATION OR CONTROL REQUEST BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * RET:REQ EQU $ COPY BI:ORF(X),A FLAG WORD FROM BIB BITS:OFF A,ORF:TRM CLEAR THE TERMINATION CODE FIELD SHIFT: Q,ORF:TRMB POSITION VALUE FOR FIELD OR Q,A MERGE IN SPECIFIED TERMINATION CODE JEQ Q,RR01 JUMP IF NORMAL TERMINATION BITS:ON A,ORF:ERR SET ERROR TERMINATION FLAG RR01 EQU $ / COPY A,BI:ORF(X) SAVE MODIFIED FLAG WORD COPY X,A BASE ADDRESS OF BIB COPY BI:QPB(X),X COMPLETION QUEUE POINTER BLOCK ADDRESS JEQ X,RR02 JUMP IF NO COMPLETION QUEUE GIVEN JSK PUT:REQ ADD TO QUEUE WITH PRIORITY PROTECTION JNE A,RR02 JUMP UNLESS FIRST ITEM PUT ON QUEUE COPY 2(X),X COMPLETION QUEUE SEMAPHORE ADDRESS JEQ X,RR02 JUMP IF NO COMPLETION SEMAPHORE SPECIFIED JSK R:SIG SIGNAL COMPLETION SEMAPHORE RR02 EQU $ / RSK RETURN TO CALLER TITL RET:REQQ - RETURN ALL REQUESTS IN QUEUE TO USER * * RET:REQQ * * PROCEDURE RETURNS ALL BUFFER INFORMATION OR CONTROL REQUEST BLOCKS * IN A QUEUE TO THE USER, WITH THE SPECIFIED TERMINATION CODE. * * CALL PARAMETERS: * !  Q - TERMINATION CODE * X - ADDRESS OF POINTER BLOCK FOR QUEUE * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * RET:REQQ EQU $ PUSH STATUS: SAVE ALL ENTERING REGISTERS RQ01 EQU $ / COPY K,Y CURRENT STACK POINTER VALUE COPY *STK:X(Y),X BASE ADDRESS OF FIRST BIB ON QUEUE JEQ X,RQ03 JUMP IF QUEUE EMPTY COPY BI:NXT(X),A NEXT BIB BASE ADDRESS IN QUEUE COPY A,*STK:X(Y) SET AS NEW HEAD OF QUEUE JNE A,RQ02 JUMP UNLESS QUEUE NOW EMPTY COPY STK:X(Y),Y ADDRESS OF POINTER BLOCK COPY A,1(Y) SET NULL ADDRESS FOR TAIL OF QUEUE COPY K,Y CURRENT STACK POINTER VALUE RQ02 EQU $ / COPY STK:Q(Y),Q SET TERMINATION CODE TO BE USED COPY STK:Y(Y),Y RESTORE SCRATCHPAD BASE ADDRESS JSK RET:REQ RETURN REQUEST REMOVED FROM QUEUE JMP RQ01 LOOP FOR ALL IN QUEUE RQ03 EQU $ / POP RESTORE ALL ENTERING REGISTERS RSK RETURN TO CALLER TITL WAIT:FLG - WAIT FOR FLAG SET * * WAIT:FLG * * PROCEDURE WAITS FOR A SPECIFIED LOCATION TO BECOME NONZERO. ALSO * CHECKS FOR TERMINATION OF THE CALLING ACTIVITY BEING REQUESTED. * * CALL PARAMETERS: * A - ADDRESS OF THE LOCATION TO WAIT ON * X - BASE ADDRESS OF EVENT PROCESSOR TABLE FOR THIS ACTIVITY * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 INDICATES THAT * TERMINATION OF THE CALLING ACTIVITY HAS BEEN REQUESTED; RETURN TO * CALL+2 IS THE NORMAL TERMINATION. * WAIT:FLG EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK WA01 EQU $ WAIT LOOP FOR WORD NONZERO COPY K,Y CURRENT STACK POINTER VALUE COPY *STK:A(Y),A OUT OF LOOP IF WORD NONZERO JNE A,WA02 COPY STK:X(Y),X BASE ADDRESS OF EVENT PROCESSOR TABLE COPY EP:TRM(X),A TERMINATION SIGNAL FOR CALLING ACTIVITY JNE A,WA03 OUT IF TERMINATION OF CALLER REQUESTED ADD =EP:SEM,X SET ADDRESS OF CALLING ACTIVITY SEMAPHORE JSK R:WAIT WAIT FOR SIGNAL BEFORE REPEATING CHECKS JMP WA01 WA02 EQU $ NORMAL RETURN WITH WORD NONZERO IMS STK:NUM(Y) INCREMENT RETURN ADDRESS ON STACK NOP WA03 EQU $ CALLER TERMINATION REQUESTED RETURN POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER TITL TERM:ACT - FLAG TERMINATION OF ACTIVITY AND SIGNAL * * TERM:ACT * * PROCEDURE SETS THE TERMINATION FLAG FOR AN ACTIVITY AND THEN * SIGNALS THAT ACTIVITY'S SEMAPHORE TO ALERT IT TO THE TERMINATION. * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT PROCESSOR TABLE *  Y - ADDRESS OF ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * TERM:ACT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK IFT DEBUG: COPY 0(Y),Y BASE ADDRESS OF CIB JSK VAL:EPT VALIDATE EPT ADDRESS SUPPLIED ENDC COPY =-1,A SET TERMINATION FLAG FOR ACTIVITY COPY A,EP:TRM(X) ADD =EP:SEM,X SET ADDRESS OF ACTIVITY SEMAPHORE JSK R:SIG SIGNAL ACTIVITY TO ALERT TO TERMINATION POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER SPACE 2 END R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R R RIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII" IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIe830112133344830112133344830112134053e6l830112133344830112133344830112133344e830112133344830112133344830112133344e# 830112133344830112133344830112133344830112133344830112133344830112133344e@$~830112133623830112133638830112133812eD$6'830112133639830112133646830112133819e`G$830112133647830112133703830112133836 e6$j830112133704830112133716830112133848 e$/v830112133717830112133723830112133854$  e03$d/830112133724830112133736830112133906 ec$ 830112133737830112133738830112133908 ee!$@}830112133739830112133747830112133917e $i830112133748830112133752830112133921e$830112133753830112133754830112133923e$?830112133756830112133757830112133925% & ' ( ) * . RECVCTL ASMXMITCTL ASMDEVCCTL ASM COMSUBS ASM TIMER ASM TEST ASM TESTTBL ASM SYNCD MACSYNCS MACGENLIB JCLGENTST JCL+  TITL SYNCHRONOUS HANDLER TIMER SUBROUTINES (93438-17/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:GPR EXTR R:SPRI EXTR R:SIG EXTR CT:HEAD EXTR CT:TAIL EXTR CT:PRIOR EXTR CT:USAGE EXTR CT:BEGIN EXTR FND:REQ EXTR DEL:REQ * * EXTERNAL DEFINITIONS * NAM INIT:TMR NAM STRT:TMR NAM CNCL:TMR NAM TERM:TMR NAM TMR:BGNU NAM TMR:ENDU * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:H NAM G:H ENDC TITL INIT:TMR - ALLOCATE AND INITIALIZE TIMER CONTROL BLOCK * * INIT:TMR * * PROCEDURE ALLOCATES AND INITIALIZES A TIMER CONTROL BLOCK WITH THE * SPECIFIED PARAMETERS. * * CALL PARAMETERS: * A - TIMEOUT INTERVAL IN CLOCK TICKS * Q - ADDRESS OF SEMAPHORE TO BE SIGNALLED * * RETURN PARAMETERS: * A,Q,Y - UNCHANGED * X - ADDRESS OF TIMER CONTROL BLOCK IF SUCCESSFUL, ZERO OTHERWISE * INIT:TMR EQU $ PUSH STATUS: SAVE ENTERING REGISTERS R:ABUF SIZE:TCB ALLOCATE A TCB FOR THE TIMER COPY K,Y CURRENT STACK POINTER VALUE COPY X,STK:X(Y) SAVE BASE ADDRESS OF ALLOCATED TCB JEQ X,IT01 JUMP IF NO MEMORY AVAILABLE FOR TCB COPY Q,TC:SEM(X) SET ADDRESS OF SEMAPHORE TO BE SIGNALLED COPY A,TC:INT(X) SET TIMER INTERVAL COPY =0,Q INITIALIZE POINTERS AND DELTA TIME COPY Q,TC:NXT(X) COPY Q,TC:LST(X) COPY Q,TC:TIC(X) COPY Q,TC:TYP(X) COPY =EXP:INA,Q TIMER IS INACTIVE COPY Q,TC:EXP(X) IT01 EQU $ RETURN TO CALLER POP RESTORE MODIFIED CALLING REGISTERS RSK RETURN TO CALLER TITL STRT:TMR - START TIMEOUT RUNNING * * STRT:TMR * * PROCEDURE ENTERS THE SPECIFIED TIMER CONTROL BLOCK IN THE LIST OF * ACTIVE TIMER CONTROL BLOCKS. * * CALL PARAMETERS: * X - BASE ADDRESS OF TIMER CONTROL BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * STRT:TMR EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY TC:NXT(X),A MAKE SURE NEXT POINTER IS NULL JNE A,$+2 COPY TC:LST(X),A MAKE SURE LAST POINTER IS NULL JNE A,ST06 COPY CT:HEAD,A ADDRESS OF FIRST ON TIMER LIST CSN A,X CHECK IF THIS IS FIRST ON LIST JMP ST06 COPY TC:EXP(X),A MAKE SURE CURRENT TIMER IS NOT RUNNING  JEQ A,ST06 COPY =EXP:RUN,A RESET TIMER EXPIRED FLAG COPY A,TC:EXP(X) JSK R:GPR GET PRESENT PRIORITY LEVEL COPY A,Y SAVE ENTERING PRIORITY COPY CT:PRIOR,X SET ACTIVITY PRIORITY TO THAT OF TIMER JSK R:SPRI COPY K,X GET BASE ADDRESS OF TCB FROM STACK  COPY STK:X(X),X COPY TC:INT(X),Q TIMER INTERVAL IN 50 MS UNITS COPY CT:HEAD,X TCB LIST HEAD JEQ X,ST04 JUMP IF TIMER ACTIVITY CURRENTLY INACTIVE ST01 EQU $ LOOP FOR FINDING INSERT POSITION SUB TC:TIC(X),Q SUBTRACT DELTA TIME UNITS FOR TCB JLE Q,ST02 OUT OF LOOP IF PAST TIME FOR THIS TCB COPY TC:NXT(X),X BASE ADDRESS OF NEXT TCB IN LIST JNE X,ST01 LOOP UNLESS AT END OF LIST  COPY K,X GET BASE ADDRESS OF TCB FROM STACK COPY STK:X(X),X COPY Q,TC:TIC(X) SAVE DELTA TICKS FROM LAST ON LIST COPY =0,Q SET NO NEXT ON LIST COPY Q,TC:NXT(X) COPY CT:TAIL,A SET BACK LINK TO FORMER LAST ON LIST COPY A,TC:LST(X) COPY X,CT:TAIL SET A, DDED TCB AS LAST ON LIST EXCH A,X SET FORWARD LINK FROM FORMER LAST ON LIST COPY A,TC:NXT(X) JMP ST05 RETURN TO CALLER ST02 EQU $ INSERT TCB INTO THE TIMER LIST COPY TC:TIC(X),A DELTA TICKS VALUE FROM LIST ADD Q,A SET DELTA TICKS FOR INSERT TCB NEG Q SET DELTA TICKS FOR TCB FOLLOWING INSERT COPY Q,TC:TIC(X) COPY X,Q SAVE BASE ADDRESS OF TCB FOLLOWING INSERT COPY K,X GET BASE ADDRESS OF INSERT TCB FROM STACK COPY STK:X(X),X COPY A,TC:TIC(X) SET DELTA TICKS VALUE FOR INSERT TCB COPY Q,TC:NXT(X) SET FORWARD LINK FROM INSERT TCB EXCH X,Q GET BACKWARD LINK FROM FOLLOWING TCB COPY TC:LST(X),A COPY Q,TC:LST(X) SET BACKWARD LINK TO INSERTED TCB EXCH X,Q SET BACKWARD LINK FROM INSERTED TCB COPY A,TC:LST(X) JEQ A,ST03 JUMP IF INSERTING AT HEAD OF LIST EXCH X,A SET FORWARD LINK FROM PRIOR TCB COPY A,TC:NXT(X) JMP ST05 RESTORE PRIORITY AND RETURN ST03 EQU $ INSERTING AT HEAD OF TIMER LIST COPY X,CT:HEAD SET INSERTED TCB AS HEAD OF LIST JMP ST05 RESTORE PRIORITY AND RETURN ST04 EQU $ INSERTING ON PREVIOUSLY EMPTY LIST COPY K,X GET ADDRESS OF INSERT TCB FROM STACK COPY STK:X(X),X COPY =0,A SET NULL FORWARD AND BACKWARD LINKS COPY A,TC:NXT(X) COPY A,TC:LST(X) COPY Q,TC:TIC(X) SET DELTA TICK COUNT TO FULL VALUE COPY X,CT:HEAD SET THIS TCB AS BOTH HEAD AND TAIL OF LIST COPY X,CT:TAIL ST05 EQU $ RESTORE CALLING PRIORITY AND RETURN COPY Y,X SET PRIORITY BACK TO LEVEL WHEN ENTERED JSK R:SPRI POP RESTORE ALL CALLING REGISTERS RSK RETURN TO CALLER ST06 EQU $ STARTING A TIMER WHICH IS ALREADY ACTIVE ERR:D EXIT TO DEBUG IF PRESENT POP RESTORE ALL CALLING REGISTERS RSK RETURN TO CALLER * LPOOL TITL CNCL:TMR - CANCEL ACTIVE TIMEOUT * * CNCL:TMR * * PROCEDURE REMOVES THE SPECIFIED TIMER CONTROL BLOCK FROM THE LIST * OF ACTIVE TIMER CONTROL BLOCKS. * * CALL PARAMETERS: * X - BASE ADDRESS OF TIMER CONTROL BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * CNCL:TMR EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK JSK R:GPR GET PRESENT PRIORITY LEVEL COPY A,Y SAVE ENTERING PRIORITY COPY CT:PRIOR,X SET ACTIVITY PRIORITY TO THAT OF TIMER JSK R:SPRI COPY K,X GET BASE ADDRESS OF TCB FROM STACK COPY STK:X(X),X COPY =EXP:INA,A RESET TIMER EXPIRED FLAG EXCH TC:EXP(X),A GET CURRENT TIMER EXPIRED FLAG AND SET INACTIVE JNE A,CT05 JUMP IF TIMER IS NOT RUNNING EXCH TC:NXT(X),A GET FORWARD LINK AND SET TO NULL COPY =0,Q GET BACKWARD LINK AND SET TO NULL EXCH TC:LST(X),Q COPY TC:TIC(X),X DELTA TICK VALUE FOR TIMER BEING CANCELED JEQ A,CT03 JUMP IF TIMER WAS LAST ON LIST EXCH A,X UNLINK TIMER AS PRIOR OF NEXT COPY Q,TC:LST(X) ADD TC:TIC(X),A CORRECT DELTA TICK VALUE OF NEXT ON LIST COPY A,TC:TIC(X) COPY X,A COPY ADDRESS OF NEXT AFTER DELETED TIMER JNE Q,CT01 JUMP UNLESS DELETED TIMER WAS FIRST ON LIST COPY A,CT:HEAD SET NEXT AFTER DELETED AS NEW HEAD JMP CT02 CT01 EQU $ UNLINK TIMER FROM PREDECESSOR IN LIST COPY Q,X COPY ADDRESS OF PREDECESSOR IN LIST COPY A,TC:NXT(X) UNLINK TIMER AS NEXT OF PRIOR CT02 EQU $ RESTORE CALLING PRIORITY AND RETURN COPY Y,X SET PRIORITY BACK TO LEVEL WHEN ENTERED JSK R:SPRI POP RESTORE ALL CALLING REGISTERS RSK RETURN TO CALLER CT03 EQU $ TIMER BEING DELETED HAS NO NEXT JEQ Q,CT04 JUMP IF ALSO NO PRIOR COPY Q,CT:- TAIL SET PRIOR AS NEW TAIL OF LIST JMP CT01 UNLINK FROM PREDECESSOR IN LIST CT04 EQU $ TIMER HAS NO PRIOR AND NO NEXT COPY K,X GET BASE ADDRESS OF TCB FROM STACK COPY STK:X(X),A CSK A,CT:HEAD JUST EXIT IF TIMER WAS NOT ON LIST JMP CT02 JMP CT02 COPY Q,CT:HEAD SET TIMER LIST EMPTY COPY Q,CT:TAIL JMP CT02 CT05 EQU $ TIMER IS NOT RUNNING JGT A,CT02 JUMP IF TIMER IS INACTIVE  COPY TC:TYP(X),A CHECK TYPE OF TIMEOUT REQUEST JEQ A,CT02 JUMP IF STANDARD TIMEOUT REQUEST COPY X,A BASE ADDRESS OF TIMER CONTROL BLOCK COPY TC:SEM(X),X BASE ADDRESS OF QUEUE POINTER BLOCK JSK FND:REQ FIND TCB IN THE SPECIFIED QUEUE JEQ A,CT02 JUMP IF UNABLE TO FIND EXCH A,X SET PRIOR TCB ADDRESS AND CURRENT TCB ADDRESS COPY TC:SEM(X),Q BASE ADDRESS OF QUEUE POINTER BLOCK JSK DEL:REQ DELETE TCB FROM THE SPECIFIED QUEUE JMP CT02 TITL TERM:TMR - DEALLOCATE TIMER CONTROL BLOCK * * TERM:TMR * *  PROCEDURE DEALLOCATES THE SPECIFIED TIMER CONTROL BLOCK AND * RETURNS THE MEMORY USED TO THE AVAILABLE MEMORY POOL. * * CALL PARAMETERS: * X - BASE ADDRESS OF TIMER CONTROL BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * TERM:TMR EQU $ PUSH STATUS: SAVE ALL ENTERING REGISTERS R:RBUF 0(X) RETURN TCB MEMORY TO SYSTEM POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL TMR:BGNU - BEGIN USAGE OF COMMUNICATIONS TIMER * * TMR:BGNU * * PROCEDURE INCREMENTS THE USAGE COUNT OF THE COMMUNICATIONS TIMER * TASK, AND STARTS AN ACTIVITY OF THE TASK IF NONE WAS PREVIOUSLY * ACTIVE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * TMR:BGNU EQU $  PUSH STATUS: SAVE ENTERING REGISTERS ON STACK JSK R:GPR GET PRESENT PRIORITY LEVEL COPY A,Y SAVE ENTERING PRIORITY COPY CT:PRIOR,X SET ACTIVITY PRIORITY TO THAT OF TIMER JSK R:SPRI IMS CT:USAGE COUNT ANOTHER USAGE OF THE COMMUNICATIONS TIMER JMP TB01 JUMP IF TIMER ACTIVITY RUNNING R:BGIN CT:BEGIN START A COMMUNICATIONS TIMER ACTIVITY TB01 EQU $ RESTORE PRIORITY AND REGISTERS AND RETURN COPY Y,X RESTORE ENTERING PRIORITY OF ACTIVITY JSK R:SPRI POP RESTORE ALL CALLING REGISTERS RSK  RETURN TO CALLER TITL TMR:ENDU - END USAGE OF COMMUNICATIONS TIMER * * TMR:ENDU * * PROCEDURE DECREMENTS THE USAGE COUNT FOR THE COMMUNICATIONS TIMER * ACTIVITY. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * TMR:ENDU EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK SIN 2 BLOCK OUT INTERRUPTS WHILE DECREMENTING USAGE COPY CT:USAGE,A DECREMENT THE COMMUNICATIONS TIMER USAGE COUNT SUB =1,A COPY A,CT:USAGE POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER SPACE 2 END TITL SYNCHRONOUS HANDLER TIMER TASK (93438-17/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:SIG EXTR R:WAIT EXTR PUT:DREQ * * EXTERNAL DEFINITIONS *  NAM CT:USAGE NAM CT:HEAD NAM CT:TAIL NAM CT:PRIOR NAM CT:BEGIN TITL COMMUNICATIONS TIMER GLOBAL VARIABLES * * GLOBAL VARIABLES * TABLE: REL SHARABLE TABLE: SYSTEM CT:USAGE WORD -1 USAGE WORD FOR THE COMMUNICATIONS TIMER TASK CT:HEAD WORD 0 HEAD OF TCB LIST CT:TAIL WORD 0 TAIL OF TCB LIST CT:PRIOR WORD :7E00 PRIORITY OF COMMUNICATIONS TIMER ACTIVITY CT:PRM WORD 0 START O. F PARAMETER BLOCK FOR RTX CALL WORD 0 IDENTIFIER WORD (UNUSED) WORD CT:SEM ADDRESS OF SEMAPHORE TO BE SIGNALLED WORD 6 NUMBER OF TICKS TO WAIT SPACE 2 * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:F NAM G:F ENDC SPACE 2 * * TASK SEMAPHORE DEFINITION * SDB:A CT:SEM,0 SEMAPHORE FOR TIMER ACTIVITY SPACE 2 * * COMMUNICATIONS TIMER TASK DEFINITIONS BLOCK * TDB:A TDB:TMR,COM:TMR,,,20,,1 SPACE 2 * * COMMUNICATIONS TIMER TASK BEGIN BLOCK * BGIN:A CT:BEGIN,TDB:TMR,:7E00 TITL COM:TMR - COMMUNICATIONS TIMER TASK MAIN PROGRAM * * COM:TMR * * MAIN PROGRAM CYCLES ON A SYSTEM TIMEOUT, PROCESSING THE LIST OF * TIMER CONTROL BLOCKS FOR COMMUNICATIONS TIMEOUTS. * * START PARAMETERS: *  NONE * COM:TMR EQU $ IMS CT:USAGE INCREMENT USAGE COUNT TO ZERO BASE NOP CT01 EQU $ MAIN LOOP FOR SYSTEM TIMEOUTS R:ITIC CT:PRM INITIATE SYSTEM TIMER REQUEST COPY CT:HEAD,Y BASE ADDRESS OF FIRST TCB ON LIST JEQ Y,CT06 JUMP IF NONE PRESENT COPY TC:TIC(Y),A NUMBER OF TICKS REMAINING FOR TIMER SUB =1,A CORRECT COUNT REMAINING FOR NEXT TIME COPY A,TC:TIC(Y) JNE A,CT06 JUMP UNLESS TIMER EXPIRED CT02 EQU $ LOOP FOR REMOVING EXPIRED TIMERS FROM LIST COPY =EXP:EXP,A SET EXPIRATION SIGNAL FOR TIMER COPY A,TC:EXP(Y) COPY TC:SEM(Y),X SIGNAL SPECIFIED SEMAPHORE COMMENT OR BASE ADDRESS OF TIMEOUT QUEUE COPY TC:TYP(Y),A CHECK TYPE OF TIMEOUT REQUEST JEQ A,CT03 JUMP IF STANDARD TIMEOUT REQUEST COPY Y,A BASE ADDRESS OF TCB COPY TC:NXT(Y),Q SAVE NEXT BASE ADDRESS OF TCB JSK PUT:DREQ PUT TCB TO TIMEOUT QUEUE COPY Q,A RESTORE NEXT TCB JMP CT04 CT03 EQU $ JSK R:SIG COPY =0,A GET NEXT IN LIST AND SET NULL EXCH TC:NXT(Y),A CT04 EQU $ JEQ A,CT05 JUMP IF LIST IS NOW NULL COPY A,Y BASE ADDRESS OF NEW FIRST IN LIST COPY =0,Q SET NULL PRIOR POINTER IN NEW HEAD COPY Q,TC:LST(Y) COPY TC:TIC(Y),A DELTA TICK COUNT FROM LAST TIMER JEQ A,CT02 LOOP TO REMOVE IF ALSO EXPIRED COPY Y,CT:HEAD SET NEW HEAD OF TIMER LIST JMP CT06 WAIT FOR NEXT SIGNAL CT05 EQU $ SET NULL LIST COPY A,CT:HEAD SET LIST POINTERS NULL COPY A,CT:TAIL CT06 EQU $ WAIT FOR SIGNAL FROM TIMER COPY =CT:SEM,X WAIT FOR A SIGNAL BEFORE REPEAT JSK R:WAIT COPY CT:USAGE,A TEST USAGE COUNT JNE A,CT01 LOOP IF COMMUNICATIONS TIMER STILL IN USE COPY =-1,A SET COMMUNICATIONS TIMER TASK INACTIVE COPY A,CT:USAGE R:END TERMINATE THE ACTIVITY SPACE 2 END D D D D D IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII TITL SYNCHRONOUS HANDLER TEST PROGRAM (93438-18/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS LOAD DEBUG4 EXTR R:SIG EXTR R:WAIT EXTR PUT:DREQ EXTR GET:DREQ EXTR PUT:CREQ EXTR D:SC00,D:SC10 EXTR D:SC01,D:SC11 TASK REL SHARABLE TASK G:0 NAM G:0 TITL INTERNAL EQUATES AND STRATCHPAD DEFINITIONS * * REQUEST CONTROL BLOCK EQUATES * RC:BYTES EQU :100 NUMBER OF BYTES OF DATA SPACE AVAILABLE RC:WORDS EQU RC:BYTES/2 NUMBER OF WORDS OF DATA SPACE AVAILABLE RC:NXT EQU BI:NXT NEXT POINTER EQUATE RC:QPB EQU BI:QPB COMPLETION QUEUE POINTER BLOCK RC:ORF EQU BI:ORF OPERATION FLAGS RC:BUF EQU BI:BUF BUFFER ADDRESS RC:BCT EQU BI:BCT REQUEST COUNT RC:ACT EQU BI:ACT ACTUAL COUNT RC:HDR EQU BI:HDR HEADER DATA RC:BDY EQU RC:HDR+2 BODY DATA RC:CRC EQU CR:CRC CON/ TROL REQUEST CODE RC:DIB EQU CR:DIB DEVICE INFORMATION BLOCK ADDRESS SIZE:RCB EQU SIZE:BIB+RC:WORDS OVERALL SIZE OF REQUEST CONTROL BLOCK SPACE 2 * * DEFINITIONS FOR OFFSETS ON STACK TO REGISTERS SAVED ON ENTRY * STATUS: EQU :40 STATUS TO PLUG AFTER A PUSH STK:L EQU 0 L REGISTER OFFSET STK:S EQU 1 S REGISTER OFFSET STK:A EQU 2 A REGISTER OFFSET STK:Q EQU 3 Q REGISTER OFFSET STK:X EQU 4 X REGISTER OFFSET STK:Y EQU 5 Y REGISTER OFFSET STK:NUM EQU 6 NUMBER OF WORDS STORED ON STACK SPACE 2 * * SCRATCHPAD EQUATES * TP:DIB EQU 0 BASE ADDRESS OF DIB BEING USED TP:CIB EQU TP:DIB+1 BASE ADDRESS OF CIB BEING USED TP:RCH EQU TP:CIB+1 RECEIVE COMPLETION QUEUE HEAD POINTER TP:RCT EQU TP:RCH+1 RECEIVE COMPLETION QUEUE TAIL POINTER TP:RSA EQU TP:RCT+1 RECEIVE COMPLETION QUEUE SEMAPHORE ADDRESS TP:XCH EQU TP:RSA+1 TRANSMIT COMPLETION QUEUE HEAD POINTER TP:XCT EQU TP:XCH+1 TRANSMIT COMPLETION QUEUE TAIL POINTER TP:XSA EQU TP:XCT+1 TRANSMIT COMPLETION QUEUE SEMAPHORE ADDRESS TP:CCH EQU TP:XSA+1 CONTROL COMPLETION QUEUE HEAD POINTER TP:CCT EQU TP:CCH+1 CONTROL COMPLETION QUEUE TAIL POINTER TP:CSA EQU TP:CCT+1 CONTROL COMPLETION QUEUE SEMAPHORE ADDRESS TP:XPN EQU TP:CSA+1 TRANSMIT PASS NUMBER FOR DATA TRANSFER TESTING TP:RPN EQU TP:XPN+1 RECEIVE PASS NUMBER FOR DATA TRANSFER TESTING TP:XNO EQU TP:RPN+1 TRANSMIT NUMBER OF REQUESTS OUTSTANDING TP:RNO EQU TP:XNO+1 RECEIVE NUMBER OF REQUESTS OUTSTANDING TP:CNO EQU TP:RNO+1 CONTROL NUMBER OF REQUESTS OUTSTANDING TP:ARH EQU TP:CNO+1 AVAILABLE REQUEST CONTROL BLOCK LIST HEAD TP:ART EQU TP:ARH+1 AVAILABLE REQUEST CONTROL BLOCK LIST TAIL TP:SEM EQU TP:ART+1 TEST ACTIVITY SEMAPHORE TP:ENB EQU TP:SEM+1 DISPLAY ENABLE FLAG TP:CLK EQU TP:ENB+1 CLOCK REQUEST CONTROL BLOCK START TP:IDN EQU TP:CLK+1 IDENTIFIER FOR CLOCK REQUEST TP:ADR EQU TP:IDN+1 ADDRESS OF SEMAPHORE TO SIGNAL TP:TIH EQU TP:ADR+1 TIME INTERVAL HIGH WORD TP:TIL EQU TP:TIH+1 TIME INTERVAL LOW WORD SIZE:TPT EQU TP:TIL+1 SIZE OF THE SCRATCHPAD AREA SPACE 2 * * OPERATIONAL PARAMETER EQUATES * RCB:CNT EQU 16 NUMBER OF REQUEST CONTROL BLOCKS TO ALLOCATE NUM:XMIT EQU 5 NUMBER OF TRANSMIT REQUESTS TO HAVE OUTSTANDING NUM:RECV EQU 5 NUMBER OF RECEIVE REQUESTS TO HAVE OUTSTANDING NUM:PASS EQU :200 NUMBER OF PASSES TO MAKE SPACE 2 * * DEFINITIONS FOR STATUS REGISTER EQUATES * CY: EQU 0 CARRY BIT OV: EQU 1 OVERFLOW BIT BM: EQU 2 BYTE MODE BIT TITL SYSTEM SERVICE PARAMETER BLOCKS AND TABLES * * INITIALIZATION BLOCK DEFINITION * INIT:A 0,0,0,0,ECB,TDBI,:2000,1024 * * INITIALIZATION TASK DEFINITION BLOCK * TDB:A TDBI,INIT,1,0,:20 * * INITIALIZATION TASK SEMAPHORE DEFINITION * SDB:A SEMA,0 * * INITIALIZATION TASK TIMEOUT DEFINITIONS *  WALL:A TIME1,0,SEMA,0,8 WALL:A TIME2,0,SEMA,0,40 * * TEST TASK DEFINITION BLOCK * TDB:A TDBT,BEGIN,SIZE:TPT,0,:100,0,16 * * TEST TASK ACTIVITY BEGIN BLOCK * BGIN:A BGN:TEST,TDBT,:2000 * * UNIT ASSIGNMENT TABLE DEFINITION * UAT:AA UAT UAT:EE 'L0',D:SC00 SYNCHRONOUS CONTROLLER LINE ZERO UAT:EE 'L1',D:SC10 SYNCHRONOUS CONTROLLER LINE ONE UAT:ZZ * * ENVIRONMENT CONTROL BLOCK DEFINITION * ECB:A ECB,UAT TITL INITIALIZATION TASK * * INITIALIZATION TASK FOR TESTING OF THE SYNCHRONOUS COMMUNICATIONS * HANDLER PACKAGE. * INIT EQU $ COPY =0,A INITIALIZE LOOP COUNTER VALUE COPY A,0(Y) COPY =0,Q SET FLAG FOR 0 NO DISPLAY COPY =D:SC00,X SET ADDRESS OF DEVICE INFORMATION BLOCK TO USE R:BGIN BGN:TEST START FIRST ACTIVITY OF TEST TASK COPY =-1,Q SET FLAG FOR DISPLAY COPY =D:SC10,X SET ADDRESS OF DEVICE INFORMATION BLOCK TO USE R:BGIN BGN:TEST START SECOND ACTIVITY OF TEST TASK R:WAIT SEMA WAIT FOR BOTH ACTIVITIES TO COMPLETE TEST R:WAIT SEMA COPY =0,Q SET FLAG FOR NO DISPLAY COPY =D:SC01,X SET ADDRESS OF DEVICE INFORMATION BLOCK TO USE R:BGIN BGN:TEST START FIRST ACTIVITY OF TEST TASK COPY =-1,Q SET FLAG FOR DISPLAY COPY =D:SC11,X SET ADDRESS OF DEVICE INFORMATION BLOCK TO USE R:BGIN BGN:TEST START SECOND ACTIVITY OF TEST TASK R:WAIT SEMA WAIT FOR BOTH ACTIVITIES TO COMPLETE TEST R:WAIT SEMA R:IWAL TIME1 WAIT FOR TWO SECONDS TO FINISH DISPLAY R:WAIT SEMA IMS 0(Y) INCREMENT COUNT OF TEST SETS PERFORMED NOP COPY 0(Y),A OUTPUT PASS COUNT TO CONSOLE DATA SELP A,4 R:IWAL TIME2 WAIT FOR TEN SECONDS WHILE DISPLAYING COUNT R:WAIT SEMA JMP INIT LOOP TO CONTINUE RUNNING TESTS TITL INIT:SRC - INITIALIZE SCRATCHPAD AREA * * INIT:SCR * * PROCEDURE INITIALIZES THE SCRATCHPAD AREA ALLOCATED TO THE * ACTIVITY. * * CALL PARAMETERS: * Q - ZERO IF NO DISPLAY OF RECEIVE PASS NUMBER, NONZERO IF DISPLAY * X - BASE ADDRESS OF DEVICE INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * INIT:SCR EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY X,TP:DIB(Y) SAVE BASE ADDRESS OF DIB COPY Q,TP:ENB(Y) SAVE DISPLAY ENABLED FLAG COPY DI:CIB(X),A SAVE BASE ADDRESS OF CIB COPY A,TP:CIB(Y) COPY =0,A SET NULL VALUE FOR INITIALIZATION COPY A,TP:RCH(Y) INITIALIZE THE RECEIVE COMPLETION QUEUE POINTERS COPY A,TP:RCT(Y) COPY A,TP:XCH(Y) INITIALIZE THE TRANSMIT COMPLETION QUEUE POINTERS COPY A,TP:XCT(Y) COPY A,TP:CCH(Y) INITIALIZE THE CONTROL COMPLETION QUEUE POINTERS COPY A,TP:CCT(Y) COPY A,TP:XPN(Y) INITIALIZE THE PASS NUMBERS COPY A,TP:RPN(Y) COPY A,TP:XNO(Y) INITIALIZE THE NUMBER OF REQUESTS OUTSTANDING COPY A,TP:RNO(Y) COPY A,TP:CNO(Y) COPY A,TP:ARH(Y) INITIALIZE THE AVAILABLE REQUEST CONTROL BLOCK LIST COPY A,TP:ART(Y) COPY A,TP:SEM(Y) INITIALIZE THE ACTIVITY SEMAPHORE COPY A,TP:CLK(Y) INITIALIZE THE CLOCK REQUEST CONTROL BLOCK COPY A,TP:IDN(Y) COPY A,TP:TIH(Y) COPY =8,A SET FOR EIGHT QUARTER SECONDS COPY A,TP:TIL(Y) COPY Y,A COMPUTE ADDRESS OF SEMAPHORE WORD ADD =TP:SEM,A COPY A,TP:RSA(Y) SET COMPLETION QUEUE SEMAPHORE ADDRESSES COPY A,TP:XSA(Y) COPY A,TP:CSA(Y) COPY A,TP:ADR(Y) POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL ALOC:RCB - ALLOCATE REQUEST CONTROL BLOCK * * ALOC:RCB * * PROCEDURE ALLOCATES A REQUEST CONTROL BLOCK FROM THE LIST OF * AVAILABLE REQUEST CONTROL BLOCKS. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A - BASE ADDRESS OF ALLOCATED REQUEST CONTROL BLOCK IF ANY * AVAILABLE, ZERO OTHERWISE * Q,X - UNCHANGED * ALOC:RCB EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY TP:ARH(Y),X AVAILABLE REQUEST CONTROL BLOCK LIST HEAD JEQ X,AR01 JUMP IF NONE AVAILABLE COPY RC:NXT(X),A BASE ADDRESS OF NEXT IN LIST COPY A,TP:ARH(Y) SET AS NEW HEAD OF AVAILABLE LIST JNE A,AR01 JUMP IF NOT END OF LIST COPY A,TP:ART(Y) SET NULL TAIL POINTER FOR LIST AR01 EQU $ RETURN ADDRESS OF ALLOCATED BLOCK TO C1 ALLER COPY K,Y CURRENT STACK POINTER ADDRESS COPY X,STK:A(Y) SAVE FOR RETURN IN A REGISTER POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL RELS:RCB - RELEASE REQUEST CONTROL BLOCK * * RELS:RCB * * PROCEDURE RELEASES A REQUEST CONTROL BLOCK, RETURNING IT TO THE * LIST OF AVAILABLE REQUEST CONTROL BLOCKS. * * CALL PARAMETERS: * A - BASE ADDRESS OF REQUEST CONTROL BLOCK * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * RELS:RCB EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY A,X BASE ADDRESS OF REQUEST CONTROL BLOCK COPY =0,Q SET NULL LINKAGE FROM BLOCK BEING RELEASED COPY Q,RC:NXT(X) EXCH X,TP:ART(Y) SWAP ADDRESS FOR FORMER LAST ON QUEUE JNE X,RR01 JUMP UNLESS LIST WAS PREVIOUSLY EMPTY COPY A,TP:ARH(Y) SET ADDRESS OF RELEASED REQUEST AS HEAD OF LIST JMP RR02 RR01 EQU $ LINK REQUEST CONTROL BLOCK TO FORMER LAST ON LIST COPY A,RC:NXT(X) SET LINKAGE FROM LAST TO ADDED BLOCK RR02 EQU $ RESTORE CALLING REGISTERS AND RETURN POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL INIT:RCB - INITIALIZE POLL OF REQUEST CONTROL BLOCKS * * INIT:RCB * * PROCEDURE ALLOCATES THE INITIAL SET OF REQUEST CONTROL BLOCKS FOR * USE IN THE HANDLER TESTING, AND LINKS THEM ON THE LIST OF * AVAILABLE REQUEST CONTROL BLOCKS. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: *  A,Q,X - UNCHANGED * INIT:RCB EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY =RCB:CNT,Q NUMBER OF REQUEST CONTROL BLOCKS TO ALLOCATE IR01 EQU $ LOOP FOR ALLOCATE OF REQUEST CONTROL BLOCKS R:ABUF SIZE:RCB ALLOCATE REQUEST CONTROL BLOCK FROM EMP JNE X,$+2 JUMP UNLESS OUT OF MEMORY JST *0 EXIT TO DEBUG IF OUT OF MEMORY COPY X,A COPY ADDRESS TO EXPECTED REGISTER JSK RELS:RCB ADD TO LIST OF AVAILABLE REQUEST CONTROL BLOCKS SUB =1,Q DECREMENT COUNT TO BE ALLOCATED JGT Q,IR01 LOOP FOR COUNT SPECIFIED POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER TITL TERM:RCB - RETURN ALL REQUEST CONTROL BLOCKS TO SYSTEM * * TERM:RCB * * PROCEDURE RETURNS ALL REQUEST CONTROL BLOCKS TO THE ENVIRONMENT * MEMORY POOL. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * TERM:RCB EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK TR01 EQU $ LOOP FOR RETURNING REQUESTS TO EMP JSK ALOC:RCB ALLOCATE A BLOCK FROM THE AVAILABLE LIST JEQ A,TR02 JUMP IF AT END OF LIST COPY A,X COPY TO EXPECTED REGISTER R:RBUF 0(X) RETURN MEMORY USED FOR BLOCK TO SYSTEM JMP TR01 TR02 EQU $ RESTORE REGISTERS AND RETURN POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER * LPOOL TITL DO:XMIT - GENERATE TRANSMIT REQUEST AND GIVE TO HANDLER * * DO:XMIT * * PROCEDURE ALLOCATES A REQUEST CONTROL BLOCK AND INITIALIZES IT FOR * A TRANSMIT OPERATION, FILLING THE BUFFER WITH THE APPROPRIATE DATA * PATTERN FOR THE TRANSMIT PASS NUMBER, AND QUEUES THE REQUEST FOR * TRANSMISSION. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * DO:XMIT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK JSK ALOC:RCB ALLOCATE REQUEST CONTROL BLOCK TO USE JNE A,$+2 JUMP IF REQUEST CONTROL BLOCK AVAILABLE JST *0 EXIT TO DEBUG IF NONE AVAILABLE COPY A,X COPY ADDRESS O2 F ALLOCATED CONTROL BLOCK COPY Y,Q COMPUTE ADDRESS OF COMPLETION QUEUE ADD =TP:XCH,Q COPY Q,RC:QPB(X) SAVE AS ADDRESS OF COMPLETION QUEUE FOR REQUEST COPY =3%ORF:EHLB,Q SET EXPECTED HEADER LENGTH IN REQUEST FLAGS COPY Q,RC:ORF(X) COPY X,Q COMPUTE ADDRESS OF DATA BUFFER FOLLOWING CONTROL BLOCK ADD =RC:BDY,Q COPY Q,RC:BUF(X) SAVE AS ADDRESS OF BODY BUFFER COPY TP:XPN(Y),Q TRANSMIT PASS NUMBER COPY Q,RC:HDR(X) SAVE AS HEADER DATA TO BE TRANSMITTED COPY Q,RC:HDR+1(X) AND =:FF,Q MASK OFF ONE BYTE OF PASS NUMBER COPY Q,RC:BCT(X) USE AS LENGTH OF BODY BUFFER COPY =0,A INITIALIZE ACTUAL BYTE COUNT FOR OPERATION COPY A,RC:ACT(X) COPY Q,A FORM DOUBLE COPY OF BYTE FROM PASS NUMBER SHIFT A,LO,8 OR A,Q COPY X,Y COPY ADDRESS OF REQUEST CONTROL BLOCK COPY =RC:WORDS-1,X SET INITIAL INDEX FOR FILLING BUFFER COPY Q,RC:BDY(X,Y) SAVE A WORD OF TRANSMIT DATA JNED X,$-1 LOOP FOR ALL WORDS IN BUFFER COPY Y,A COPY ADDRESS OF REQUEST CONTROL BLOCK COPY K,Y CURRENT STACK POINTER ADDRESS COPY STK:Y(Y),Y BASE ADDRESS OF SCRATCHPAD AREA COPY TP:DIB(Y),X BASE ADDRESS OF DIB ADD =DI:WQH,X SET ADDRESS OF QUEUE POINTER BLOCK JSK PUT:DREQ GIVE THE TRANSMIT REQUEST TO THE HANDLER IMS TP:XPN(Y) INCREMENT PASS NUMBER FOR NEXT TIME THROUGH NOP IMS TP:XNO(Y) COUNT ANOTHER TRANSMIT REQUEST OUTSTANDING POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL DO:RECV - GENERATE RECEIVE REQUEST AND GIVE TO HANDLER * * DO:RECV * * PROCEDURE ALLOCATES A REQUEST CONTROL BLOCK AND INITIALIZES IT FOR * A RECEIVE OPERATION, ZEROING OUT THE DATA BUFFER, AND QUEUES THE * REQUEST FOR RECEIVE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * DO:RECV EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK JSK ALOC:RCB ALLOCATE REQUEST CONTROL BLOCK TO USE JNE A,$+2 JUMP IF REQUEST CONTROL BLOCK AVAILABLE JST *0 EXIT TO DEBUG IF NONE AVAILABLE COPY A,X COPY ADDRESS OF ALLOCATED CONTROL BLOCK COPY Y,Q COMPUTE ADDRESS OF COMPLETION QUEUE ADD =TP:RCH,Q  COPY Q,RC:QPB(X) SAVE AS ADDRESS OF COMPLETION QUEUE FOR REQUEST COPY =3%ORF:EHLB,Q SET EXPECTED HEADER LENGTH IN REQUEST FLAGS COPY Q,RC:ORF(X) COPY X,Q COMPUTE ADDRESS OF DATA BUFFER AT END OF BLOCK ADD =RC:BDY,Q COPY Q,RC:BUF(X) SAVE AS ADDRESS OF BODY BUFFER COPY =RC:BYTES-1,Q SET LENGTH OF BUFFER TO MAXIMUM MINUS ONE COPY Q,RC:BCT(X) COPY =0,Q INITIALIZE ACTUAL BYTE COUNT COPY Q,RC:ACT(X) COPY Q,RC:HDR(X) INITIALIZE HEADER DATA COPY Q,RC:HDR+1(X) COPY X,Y COPY BASE ADDRESS OF REQUEST CONTROL BLOCK COPY =RC:WORDS-1,X SET INITIAL INDEX VALUE FOR BUFFER INITIALIZATION COPY Q,RC:BDY(X,Y) SET A WORD OF THE BUFFER TO ZEROES JNED X,$-1 LOOP FOR ALL WORDS OF BUFFER COPY K,Y CURRENT STACK POINTER ADDRESS COPY STK:Y(Y),Y RESTORE BASE ADDRESS OF SCRATCHPAD AREA COPY TP:DIB(Y),X BASE ADDRESS OF DIB ADD =DI:RQH,X SET ADDRESS OF QUEUE POINTER BLOCK JSK PUT:DREQ GIVE THE RECEIVE OPERATION TO THE HANDLER IMS TP:RNO(Y) COUNT A RECEIVE REQUEST OUTSTANDING NOP POP RESTORE CALLING REGISTERS  RSK RETURN TO CALLER TITL DO:CTRL - GENERATE CONTROL REQUEST AND GIVE TO HANDLER * * DO:CTRL * * PROCEDURE ALLOCATES A REQUEST CONTROL BLOCK, INITIALIZES IT FOR A * CONTROL OPERATION, AND QUEUES THE REQUEST FOR PROCESSING BY THE * 3  HANDLER. * * CALL PARAMETERS: * Q - CONTROL REQUEST TYPE CODE * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * DO:CTRL EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK JSK ALOC:RCB ALLOCATE REQUEST CONTROL BLOCK TO USE JNE A,$+2 JUMP IF REQUEST CONTROL BLOCK AVAILABLE JST *0 EXIT TO DEBUG IF NONE AVAILABLE COPY A,X COPY ADDRESS OF ALLOCATED CONTROL BLOCK COPY Q,RC:CRC(X) SAVE CONTROL REQUEST CODE IN BLOCK COPY Y,Q COMPUTE ADDRESS OF COMPLETION QUEUE ADD =TP:CCH,Q COPY Q,RC:QPB(X) SAVE AS ADDRESS OF COMPLETION QUEUE FOR REQUEST COPY =0,Q SET NULL OPERATION REQUEST FLAGS COPY Q,RC:ORF(X) COPY TP:DIB(Y),Q SET ADDRESS OF DIB FOR REQUEST COPY Q,RC:DIB(X) COPY TP:CIB(Y),X SET BASE ADDRESS OF CIB JSK PUT:CREQ ENTER REQUEST ON THE CONTROL REQUEST QUEUE IMS TP:CNO(Y) COUNT A CONTROL REQUEST OUTSTANDING NOP POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER * LPOOL TITL XMIT:DON - PROCESS COMPLETED TRANSMIT REQUESTS * * XMIT:DON * * PROCEDURE PERFORMS COMPLETION PROCESSING FOR TRANSMIT REQUESTS * RETURNED BY THE HANDLER, CHECKING THE TERMINATION CODE RETURNED * AND RELEASING THE REQUEST CONTROL BLOCK FOR OTHER USAGE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: *  A,Q,X - UNCHANGED * XMIT:DON EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK XD01 EQU $ LOOP FOR REMOVING REQUESTS FROM THE TERMINATION QUEUE COPY Y,X SET ADDRESS OF QUEUE POINTER BLOCK ADD =TP:XCH,X JSK GET:DREQ REMOVE A REQUEST FROM THE COMPLETION QUEUE JEQ A,XD04 JUMP IF COMPLETION QUEUE EMPTY COPY A,X BASE ADDRESS OF REQUEST REMOVED COPY RC:ORF(X),Q OPERATION REQUEST FLAGS RETURNED TBIT ORF:ERR,Q TEST ERROR FLAG RETURNED JT OV,XD02 JUMP IF ERROR TERMINATION INDICATED SHIFT Q,RO,ORF:TRMB RIGHT-JUSTIFY TERMINATION CODE AND =ORF:TRMM,Q MASK THE TERMINATION CODE FIELD CLSN Q,=TRM:NORM CHECK FOR NORMAL TERMINATION CODE JMP XD03 XD02 EQU $ ERROR TERMINATION OF REQUEST JST *0 ERROR EXIT TO DEBUG XD03 EQU $ RELEASE REQUEST CONTROL BLOCK FOR OTHER USAGE JSK RELS:RCB RELEASE THE CONTROL BLOCK COPY TP:XNO(Y),A NUMBER OF TRANSMIT REQUEST OUTSTANDING SUB =1,A DECREMENT COUNT OUTSTANDING COPY A,TP:XNO(Y) JMP XD01 LOOP FOR ALL ON QUEUE XD04 EQU $ COMPLETION QUEUE EMPTY POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL RECV:DON - PROCESS COMPLETED RECEIVE REQUESTS * * RECV:DON * * PROCEDURE PERFORMS COMPLETION PROCESSING FOR RECEIVE REQUESTS * RETURNED BY THE HANDLER, VERIFYING THAT THE DATA MATCHES WHAT WAS * EXPECTED FOR THE CURRENT PASS, CHECKING THE TERMINATION CODE * RETURNED, AND RELEASING THE REQUEST CONTROL BLOCK FOR OTHER USAGE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * RECV:DON EQU $  PUSH STATUS: SAVE ENTERING REGISTERS ON STACK RD01 EQU $ LOOP FOR REMOVING COMPLETED REQUESTS FROM QUEUE COPY Y,X SET ADDRESS OF QUEUE POINTER BLOCK ADD =TP:RCH,X JSK GET:DREQ REMOVE A REQUEST FROM THE COMPLETION QUEUE JEQ A,RD09 JUMP IF COMPLETION QUEUE EMPTY COPY A,X COPY BASE ADDRESS OF REQUEST REMOVED COPY TP:RPN(Y),Q CURRENT RECEIVE PASS NUMBER COPY TP:ENB(Y),A DISPLAY ENABLE FLAG JEQ A,$+2 JUMP IF DISPLAY DISABLED SELP Q,4 OUTPUT RECEIVE PASS NUMBER TO CONSOLE DATA COPY X,A COPY BASE ADDRES4 S OF REQUEST REMOVED CSK Q,=NUM:PASS COMPARE WITH MAXIMUM PASS NUMBER JMP RD03 VERIFY DATA FOR LESS THAN MAXIMUM JST *0 EXIT TO DEBUG IF GREATER THAN MAXIMUM COPY RC:ORF(X),Q OPERATION REQUEST FLAGS RETURNED TBIT ORF:ERR,Q TEST ERROR FLAG RETURNED JF OV,RD02 JUMP IF ERROR FLAG NOT SET SHIFT Q,RO,ORF:TRMB RIGHT-JUSTIFY TERMINATION CODE AND =ORF:TRMM,Q MASK THE TERMINATION CODE FIELD CLSN Q,=TRM:INOP CHECK FOR LINK INOPERATIVE TERMINATION CODE JMP RD08 RELEASE REQUEST CONTROL BLOCK IF CORRECT RD02 EQU $ ERROR EXIT TO DEBUG FOR ABORTED REQUESTS JST *0 ENTER DEBUG FOR ERROR CONDITION RD03 EQU $ VERIFY NORMAL RECEIVE REQUEST COMPLETION COPY RC:ORF(X),Q OPERATION REQUEST FLAGS RETURNED TBIT ORF:ERR,Q TEST ERROR FLAG RETURNED JT OV,RD04 JUMP IF ERROR FLAG SET SHIFT Q,RO,ORF:TRMB RIGHT-JUSTIFY TERMINATION CODE AND =ORF:TRMM,Q MASK THE TERMINATION CODE FIELD SUB =TRM:NORM,Q CHECK FOR NORMAL COMPLETION OF OPERATION JNE Q,RD04 ERROR IF ANY OTHER TERMINATION COPY RC:ORF(X),Q OPERAITON REQUEST FLAGS RETURNED IFT ORF:AHLB SHIFT Q,RO,ORF:AHLB RIGHT-JUSTIFY ACTUAL HEADER LENGTH ENDC AND =ORF:AHLM,Q MASK THE ACTUAL HEADER LENGTH FIELD SUB =3,Q CHECK FOR CORRECT LENGTH OF HEADER JNE Q,RD04 ERROR IF INCORRECT HEADER LENGTH COPY RC:HDR(X),Q FIRST WORD OF HEADER DATA RECEIVED XOR TP:RPN(Y),Q COMPARE WITH PASS NUMBER COUNTER JNE Q,RD04 ERROR IF FIRST WORD NOT THE PASS NUMBER COPY RC:HDR+1(X),Q SECOND WORD OF HEADER DATA RECEIVED XOR TP:RPN(Y),Q COMPARE WITH PASS NUMBER COUNTER AND =:FF00,Q IGNORE CONTENTS OF LOW-ORDER BYTE JEQ Q,RD05 JUMP IF CORRECT VALUE IN BYTE RD04 EQU $ ERROR IN NORMAL RECEIVE REQUEST JST *0 EXIT TO DEBUG FOR ERROR IN NORMAL REQUEST RD05 EQU $ VERIFY CONTENTS OF BODY BUFFER RECEIVED COPY TP:RPN(Y),Q CURRENT RECEIVE PASS NUMBER AND =:FF,Q MASK OUT THE LOW-ORDER BYTE CSK Q,RC:ACT(X) COMPARE WITH ACTUAL LENGTH OF DATA JST *0 EXIT TO DEBUG IF INCORRECT DATA LENGTH JST *0 COPY A,Y SET BASE ADDRESS OF REQUEST CONTROL BLOCK COPY Q,X SET OFFSET OF LAST DATA BYTE SUB =1,X JLT X,RD07 JUMP IF NO BODY BUFFER DATA RD06 EQU $ LOOP FOR CHECKING CONTENTS OF BODY BUFFER SBIT BM:,S ENTER BYTE MODE CSKB Q,RC:BDY(X,Y) CHECK A BYTE OF THE RECEIVED DATA JST *0 EXIT TO DEBUG IF INVALID DATA JST *0 RBIT BM:,S EXIT BYTE MODE JNED X,RD06 LOOP FOR ALL BYTES IN BUFFER RD07 EQU $ CHECKING OF BODY BUFFER DATA COMPLETED COPY K,Y CURRENT STACK POINTER ADDRESS COPY STK:Y(Y),Y RESTORE SCRATCHPAD BASE ADDRESS RD08 EQU $ RELEASE CONTROL BLOCK FOR OTHER USAGE JSK RELS:RCB RELEASE THE CONTROL BLOCK COPY TP:RNO(Y),A NUMBER OF RECEIVE REQUESTS OUTSTANDING SUB =1,A DECREMENT COUNT OUTSTANDING COPY A,TP:RNO(Y) COPY TP:RPN(Y),A CURRENT RECEIVE PASS NUMBER CSK A,=NUM:PASS COMPARE WITH MAXIMUM PASS NUMBER IMS TP:RPN(Y) INCREMENT THE PASS NUMBER IF LESS THAN MAXIMUM NOP JMP RD01 LOOP FOR ALL ON QUEUE RD09 EQU $ COMPLETION QUEUE EMPTY POP RESTORE CALLING REGISTERS RSK  RETURN TO CALLER TITL CTRL:DON - PROCESS COMPLETED CONTROL REQUESTS * * CTRL:DON * * PROCEDURE PERFORMS COMPLETION PROCESSING FOR CONTROL REQUEST * RETURNED BY THE HANDLER, CHECKING THE TERMINATION CODE RETURNED * AND RELEASING THE REQUEST CONTROL BLOCK FOR OTHER USAGE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - UN5 CHANGED * CTRL:DON EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK CD01 EQU $ LOOP FOR REMOVING COMPLETED REQUESTS FROM QUEUE COPY Y,X SET ADDRESS OF QUEUE POINTER BLOCK ADD =TP:CCH,X JSK GET:DREQ REMOVE A REQUEST FROM THE COMPLETION QUEUE JEQ A,CD04 JUMP IF COMPLETION QUEUE EMPTY COPY A,X BASE ADDRESS OF REQUEST REMOVED COPY RC:ORF(X),Q OPERATION REQUEST FLAGS RETURNED  TBIT ORF:ERR,Q TEST ERROR FLAG RETURNED JT OV,CD02 JUMP IF ERROR TERMINATION INDICATED IFT ORF:TRMB SHIFT Q,RO,ORF:TRMB RIGHT-JUSTIFY TERMINATION CODE ENDC AND =ORF:TRMM,Q MASK THE TERMINATION CODE FIELD CLSN Q,=TRM:NORM CHECK FOR NORMAL TERMINATION CODE JMP CD03 CD02 EQU $ ERROR TERMINATION OF REQUEST JST *0 ERROR EXIT TO DEBUG CD03 EQU $ RELEASE REQUEST CONTROL BLOCK FOR OTHER USAGE JSK RELS:RCB RELEASE THE CONTROL BLOCK COPY TP:CNO(Y),A NUMBER OF CONTROL REQUESTS OUTSTANDING SUB =1,A DECREMENT COUNT OUTSTANDING COPY A,TP:CNO(Y) JMP CD01 LOOP FOR ALL ON QUEUE CD04 EQU $ COMPLETION QUEUE EMPTY POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER * LPOOL TITL BEGIN - TEST TASK MAIN PROGRAM CODE * * BEGIN * * TEST TASK MAIN PROGRAM FIRST GENERATES A CONTROL REQUEST TO THE * SYNCHRONOUS COMMUNICATIONS HANDLER TO INITIATE PROTOCOL LINK * OPERATION, AND WAITS FOR COMPLETION. IT THEN TRANSMITS AND * RECEIVES A SEQUENCE OF INFORMATION FRAMES, AFTER WHICH IT * GENERATES A CONTROL REQUEST TO TERMINATE PROTOCOL LINK OPERATION * AND WAITS FOR COMPLETION. ANY ERRORS RESULT IN AN IMMEDIATE * EXIT TO DEBUG. * * START PARAMETERS: * Q - ZERO IF NO DISPLAY OF RECEIVE PASS NUMBER, NONZERO IF DISPLAY * X - BASE ADDRESS OF DEVICE INFORMATION BLOCK TO BE USED * BEGIN EQU $ JSK INIT:SCR INITIALIZE THE SCRATCHPAD AREA JSK INIT:RCB INITIALIZE THE POOL OF REQUEST CONTROL BLOCKS COPY =CRC:INF,Q SET REQUEST CODE FOR INFORMATION TRANSFER JSK DO:CTRL ENTER CONTROL REQUEST TO HANDLER TT01 EQU $ LOOP FOR WAITING ON COMPLETION OF LINK SETUP COPY Y,X SET ADDRESS OF ACTIVITY SEMAPHORE ADD =TP:SEM,X JSK R:WAIT WAIT FOR A SIGNAL BEFORE CHECKING COMPLETION JSK CTRL:DON CHECK CONTROL REQUEST COMPLETION QUEUE COPY TP:CNO(Y),A NUMBER OF CONTROL REQUESTS OUTSTANDING JNE A,TT01 LOOP UNLESS REQUEST COMPLETED R:IWAL TP:CLK(Y) SET FOR CLOCK SIGNAL IN TEN SECONDS COPY Y,X SET ADDRESS OF ACTIVITY SEMAPHORE ADD =TP:SEM,X JSK R:WAIT WAIT FOR SIGNAL BEFORE CONTINUING TT02 EQU $ LOOP FOR PERFORMING DATA TRANSFER TEST JSK XMIT:DON PROCESS COMPLETED TRANSMIT REQUESTS JSK RECV:DON PROCESS COMPLETED RECEIVE REQUESTS TT03 EQU $ GENERATE NEW RECEIVE REQUESTS IF REQUIRED COPY TP:RNO(Y),A NUMBER OF RECEIVE REQUESTS OUTSTANDING SUB =NUM:RECV,A COMPARE WITH NUMBER NORMALLY KEPT OUTSTANDING JGE A,TT04 JUMP IF SUFFICIENT NUMBER OUTSTANDING COPY TP:RPN(Y),A CURRENT RECEIVE PASS NUMBER SUB =NUM:PASS,A COMPARE WITH MAXIMUM PASS NUMBER JGE A,TT04 JUMP IF ALL REQUIRED RECEIVE REQUESTS GENERATED JSK DO:RECV GENERATE ANOTHER RECEIVE REQUEST JMP TT03 LOOP TO REPEAT CHECK TT04 EQU $ GENERATE NEW TRANSMIT REQUESTS IF REQUIRED COPY TP:XNO(Y),A NUMBER OF TRANSMIT REQUESTS OUTSTANDING SUB =NUM:XMIT,A COMPARE WITH NUMBER NORMALLY KEPT OUTSTANDING JGE A,TT05 JUMP IF SUFFICIENT NUMBER OUTSTANDING COPY TP:XPN(Y),A CURRENT TRANSMIT PASS NUMBER SUB =6 NUM:PASS,A COMPARE WITH MAXIMUM PASS NUMBER JGE A,TT05 JUMP IF ALL REQUIRED TRANSMIT REQUESTS GENERATED JSK DO:XMIT GENERATE ANOTHER TRANSMIT REQUEST JMP TT04 LOOP TO REPEAT CHECK TT05 EQU $ CHECK FOR COMPLETION OF TEST SEQUENCE COPY TP:XPN(Y),A CURRENT TRANSMIT PASS NUMBER SUB =NUM:PASS,A COMPARE WITH MAXIMUM PASS NUMBER JLT A,TT06 JUMP IF NOT YET DONE TRANSMITTING COPY TP:RPN(Y),A CURRENT RECEIVE PASS NUMBER SUB =NUM:PASS,A COMPARE WITH MAXIMUM PASS NUMBER JLT A,TT06 JUMP IF NOT YET DONE RECEIVING COPY TP:XNO(Y),A NUMBER OF TRANSMIT REQUESTS OUTSTANDING JEQ A,TT07 OUT OF LOOP IF ALL TRANSMIT REQUESTS RETURNED TT06 EQU $ WAIT FOR A SIGNAL AND REPEAT LOOP COPY Y,X SET ADDRESS OF ACTIVITY SEMPHORE ADD =TP:SEM,X JSK R:WAIT WAIT FOR A SIGNAL BEFORE REPEATING LOOP JMP TT02 TT07 EQU $ TERMINATE OPERATION OF PROTOCOL LINK COPY =CRC:TERM,Q SET REQUEST CODE FOR LINK TERMINATION JSK DO:CTRL ENTER CONTROL REQUEST TO HANDLER TT08 EQU $ LOOP FOR WAITING ON COMPLETION OF LINK TERMINATION JSK CTRL:DON CHECK CONTROL REQUEST COMPLETION QUEUE COPY TP:CNO(Y),A NUMBER OF CONTROL REQUESTS OUTSTANDING JEQ A,TT09 OUT OF LOOP WHEN REQUEST COMPLETED COPY Y,X SET ADDRESS OF ACTIVITY SEMAPHORE ADD =TP:SEM,X JSK R:WAIT WAIT FOR A SIGNAL BEFORE REPEATING LOOP JMP TT08 TT09 EQU $ DEALLOCATE REQUEST CONTROL BLOCKS AND TERMINATE JSK RECV:DON PERFORM COMPLETION PROCESSING FOR EXTRA RECEIVES JSK TERM:RCB DEALLOCATE ALL REQUEST CONTROL BLOCKS R:SIG SEMA SIGNAL COMPLETION OF TEST TO INITIALIZATION ACTIVITY R:END  TERMINATE ACTIVITY EXECUTION SPACE 2 END IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII TITL SYNCHRONOUS COMMUNICATIONS HANDLER TEST PROGRAM (93438-19/A030) TITL INPUT/OUTPUT CONTROL BLOCK DEFINITIONS CIB:SC SC00,:68,0,96,C:SC1,DL,MA,PP,TS,BP=:7A00,ML=10,INT DIB:SC SC00,COM,SA=1,DA=2,BT=25,INT DIB:SC SC01,PRI,SA=1,DA=2,BT=25,INT CIB:SC SC10,:68,1,96,C:SC0,DL,MA,PP,TS,BP=:7A00,ML=10,INT DIB:SC SC10,COM,SA=2,DA=1,BT=25,INT DIB:SC SC11,SEC,SA=2,DA=1,BT=25,INT PIB:SC PRI,AP,NP,NN,EN,RI=20,PI=40,IR=4,CR=4 PIB:SC SEC,AS,NS,NN,EN,RI=20,PI=40,IR=4,CR=4 PIB:SC COM,AC,NN,EN,RI=20,PI=40,IR=4,CR=4 END IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII TITL SYNCHRONOUS HANDLER INTERNAL DEFINITIONS (93438-93/A030) TITL GLOBAL EQUATE DEFINITIONS * * ACTIVITY STACK SIZE EQUATES * STACK:LC EQU :30 LINE CONTROL ACTIVITY STACK:LS EQU :30 LINE STATISTICS ACTIVITY STACK:PH EQU :40 PROTOCOL HANDLER ACTIVI7 TY STACK:DC EQU :30 DEVICE CONTROL ACTIVITY STACK:RC EQU :30 RECEIVE CONTROL ACTIVITY STACK:RD EQU :30 RECEIVE DRIVER ACTIVITY STACK:XC EQU :30 TRANSMIT CONTROL ACTIVITY STACK:XD EQU :30 TRANSMIT DRIVER ACTIVITY STACK:XP EQU :30 TRANSMIT PRIORITY ACTIVITY STACK:TM EQU :30 TIMER ACTIVITY SPACE 2 * * EQUATES FOR SYNCHRONOUS COMMUNICATIONS CONTROLLER OPERATION CODES * SCC:NOP EQU 0 NULL OPERATION SCC:TOP EQU 1 TRANSMIT OPERATION SCC:ROP EQU 2 RECEIVE OPERATION SCC:IOP EQU 3 INITIALIZE OPERATION SPACE 2 * * EQUATES FOR ASSEMBLY-TIME DEFINED TIMEOUT INTERVALS * INT:NDSR EQU 20 ONE SECOND WAIT FOR DATA SET READY TO DROP INT:RESL EQU 10 ONE-HALF SECOND MINIMUM BUSY INTERVAL ON RESET INT:RESU EQU 40 TWO SECOND MAXIMUM BUSY INTERVAL ON RESET INT:NRSP EQU 10 ONE-HALF SECOND NO RESPONSE TIMEOUT SPACE 2 * * EQUATES FOR FRAME HANDLING * AVAL:FRM EQU 12 NUMBER OF EVENT INFORMATION BLOCKS FOR FRAMES SPACE 2 * * EQUATES FOR LINE CONTROL STATES * STA:INIT EQU 0 INITIALIZATION STATE STA:WDCA EQU 1 WAITING FOR DEVICE COMPONENT ACTIVATION STATE STA:WRCA EQU 2 WAITING FOR RECEIVE COMPONENT ACTIVATION STATE STA:WTCA EQU 3 WAITING FOR TRANSMIT COMPONENT ACTIVATION STATE STA:WCLC EQU 4 WAITING FOR COMMUNICATIONS LINE CONNECTION STATE STA:OP EQU 5 OPERATIONAL STATE STA:INOP EQU 6 INOPERATIONAL STATE STA:WTCT EQU 7 WAITING FOR TRANSMIT COMPONENT TERMINATION STATE STA:WRCT EQU 8 WAITING FOR RECEIVE COMPONENT TERMINATION STATE STA:WDCT EQU 9 WAITING FOR DEVICE COMPONENT TERMINATION STATE TITL EQUATES FOR VALUES OF FIELDS * * EQUATES FOR EVENT TYPE CODES * E:RCVFRM EQU 0 RECEIVE FRAME E:XMTFRM EQU 1 TRANSMIT FRAME E:REQRCV EQU 2 REQUEST RECEIVE CONTROL E:REQXMT EQU 3 REQUEST TRANSMIT CONTROL E:RCVGRN EQU 4 RECEIVE CONTROL GRANTED E:XMTGRN EQU 5 TRANSMIT CONTROL GRANTED E:RELRCV EQU 6 RELEASE RECEIVE CONTROL E:RELXMT EQU 7 RELEASE TRANSMIT CONTROL E:RCVREL EQU 8 RECEIVE CONTROL RELEASED E:XMTREL EQU 9 TRANSMIT CONTROL RELEASED E:ASRFLO EQU 10 ASSERT FLOW CONTROL E:RELFLO EQU 11 RELEASE FLOW CONTROL E:ENTDSC EQU 12 ENTER DISCONNECTED MODE REQUESTED E:ENTINP EQU 13 ENTER INITIALIZATION PRIMARY MODE REQUESTED E:ENTINF EQU 14 ENTER INFORMATION TRANSFER MODE REQUESTED E:TRMPRO EQU 15 TERMINATE PROTOCOL OPERATION REQUESTED E:LINCON EQU 16 COMMUNICATIONS LINE CONNECTED E:LINDCN EQU 17 COMMUNICATIONS LINE DISCONNECTED E:PROTRM EQU 18 PROTOCOL COMPONENT TERMINATION E:RCVTRM EQU 19 RECEIVE COMPONENT TERMINATION E:XMTTRM EQU 20 TRANSMIT COMPONENT TERMINATION E:DEVTRM EQU 21 DEVICE COMPONENT TERMINATION E:PROOPR EQU 22 PROTOCOL COMPONENT OPERATIONAL E:RCVOPR EQU 23 RECEIVE COMPONENT OPERATIONAL E:XMTOPR EQU 24 TRANSMIT COMPONENT OPERATIONAL E:DEVOPR EQU 25 DEVICE COMPONENT OPERATIONAL E:PRODSC EQU 26 PROTOCOL ENTERED DISCONNECTED MODE E:PROINP EQU 27 PROTOCOL ENTERED INITIALIZATION PRIMARY MODE E:PROINF EQU 28 PROTOCOL ENTERED INFORMATION TRANSFER MODE TITL EVENT INFORMATION BLOCK OFFSET DEFINITIONS * *  EIB OFFSET EQUATES * EI:NXT EQU 0 NEXT POINTER EI:ECI EQU EI:NXT+1 EVENT CONTROL INFORMATION EI:LCB EQU EI:ECI+1 LINK CONTROL BLOCK ADDRESS EI:BIB EQU EI:LCB+1 BUFFER INFORMATION BLOCK ADDRESS EI:HDL EQU EI:BIB+1 HEADER LENGTH EI:FRM EQU EI:HDL+1 PROTOCOL FRAME HEADER SIZE:EIB EQU EI:FRM+4 EVENT INFORMATION BLOCK SIZE TITL EVENT PROCESSOR TABLE OFFSET DEFINITIONS * * EPT OFFS8 ET EQUATES * EP:NXT EQU 0 NEXT POINTER EP:TRM EQU EP:NXT+1 TERMINATION SIGNAL EP:SEM EQU EP:TRM+1 EVENT PROCESSOR SEMAPHORE EP:EQH EQU EP:SEM+1 EVENT QUEUE HEAD POINTER EP:EQT EQU EP:EQH+1 EVENT QUEUE TAIL POINTER SIZE:EPT EQU EP:EQT+1 EVENT PROCESSOR TABLE SIZE TITL DEVICE CONTROL TABLE OFFSET DEFINITIONS * * DCT OFFSET EQUATES * DC:CIB EQU 0 CONTROLLER INFORMATION BLOCK ADDRESS DC:RIP EQU DC:CIB+1 RECEIVE IN PROGRESS FLAG DC:RSA EQU DC:RIP+1 RECEIVE COMPLETION SEMAPHORE ADDRESS DC:RRC EQU DC:RSA+1 RECEIVE OPERATION RETRY COUNT DC:RCB EQU DC:RRC+1 RECEIVE REQUEST CONTROL BLOCK ADDRESS DC:TIP EQU DC:RCB+1 TRANSMIT IN PROGRESS FLAG DC:TSA EQU DC:TIP+1 TRANSMIT COMPLETION SEMAPHORE ADDRESS DC:TRC EQU DC:TSA+1 TRANSMIT OPERATION RETRY COUNT DC:TCB EQU DC:TRC+1 TRANSMIT REQUEST CONTROL BLOCK ADDRESS DC:CIP EQU DC:TCB+1 CONTROL OPERATION IN PROGRESS FLAG DC:CSA EQU DC:CIP+1 CONTROL COMPLETION SEMAPHORE ADDRESS DC:CRC EQU DC:CSA+1 CONTROL OPERATION RETRY COUNT DC:SIC EQU DC:CRC+1 STATUS INTERRUPT COUNT DC:ACT EQU DC:SIC+1 DEVICE CONTROL ACTIVE FLAG DC:WRC EQU DC:ACT+1 WAITING FOR RESET COMPLETION FLAG DC:RDR EQU DC:WRC+1 REQUEST DEVICE RESET FLAG DC:INT EQU DC:RDR+1 TIMEOUT INTERVAL COUNT FOR RESET DC:DCF EQU DC:INT+1 DEVICE CONDITION FLAGS DC:EPT EQU DC:DCF+1 EVENT PROCESSOR TABLE ADDRESS DC:IDT EQU DC:EPT+1 IDLE LINE DISCONNECT TIMEOUT INTERVAL DC:WDT EQU DC:IDT+1 WATCHDOG TIMER CONTROL BLOCK ADDRESS DC:SCS EQU DC:WDT+1 SYNCHRONOUS CONTROLLER SELECTION WORD DC:TRM EQU DC:SCS+1 TERMINATION TABLE ADDRESS DC:REG EQU DC:TRM+2 REGISTER DATA FOR INITIALIZE DC:RCS EQU DC:REG+2 RECEIVE COMPLETION STATUS DC:RBC EQU DC:RCS+1 RECEIVE BYTE COUNT DC:RCI EQU DC:RBC+1 RECEIVE COMPLETION INTERRUPT LOCATION DC:TCS EQU DC:RCI+2 TRANSMIT COMPLETION STATUS DC:TBC EQU DC:TCS+1 TRANSMIT BYTE COUNT DC:TCI EQU DC:TBC+1 TRANSMIT COMPLETION INTERRUPT LOCATION DC:CCS EQU DC:TCI+2 GENERAL STATUS DC:SCI EQU DC:CCS+2 STATUS COMPLETION INTERRUPT LOCATION TITL LINK CONTROL BLOCK OFFSET DEFINITIONS * * LCB OFFSET EQUATES * LC:NXT EQU 0 NEXT POINTER LC:DIB EQU LC:NXT+1 DEVICE INFORMATION BLOCK ADDRESS LC:ADR EQU LC:DIB+1 PROTOCOL LINK ADDRESSES LC:EPT EQU LC:ADR+1 PROTOCOL HANDLER EPT ADDRESS LC:LAF EQU LC:EPT+1 LINE ACCESS FLAGS LC:RRC EQU LC:LAF+1 READY FOR RECEIVE COUNT LC:RRH EQU LC:RRC+1 READY FOR RECEIVE LIST HEAD POINTER LC:RRT EQU LC:RRH+1 READY FOR RECEIVE LIST TAIL POINTER LC:TOC EQU LC:RRT+1 TRANSMIT OUTSTANDING COUNT LC:TCH EQU LC:TOC+1 TRANSMIT COMPLETE LIST HEAD POINTER LC:TCT EQU LC:TCH+1 TRANSMIT COMPLETE LIST TAIL POINTER SIZE:LCB EQU LC:TCT+1 LINK CONTROL BLOCK SIZE TITL PROTOCOL STATE TABLE OFFSET DEFINITIONS * * PST OFFSET EQUATES * PS:CIB EQU 0 CONTROLLER INFORMATION BLOCK ADDRESS PS:LCB EQU PS:CIB+1 LINK CONTROL BLOCK ADDRESS PS:EPT EQU PS:LCB+1 EVENT PROCESSOR TABLE ADDRESS PS:POF EQU PS:EPT+1 PROTOCOL OPTIONS FLAGS PS:LOF EQU PS:POF+1 LINK OPTIONS FLAGS PS:PMF EQU PS:LOF+1 PROTOCOL MODE FLAGS PS:PCF EQU PS:PMF+1 PROTOCOL CONDITION FLAGS PS:MCF EQU PS:PCF+1 MODE CONDITION FLAGS PS:PIF EQU PS:MCF+1 PROTOCOL INFORMATION TRANSFER FLAGS PS:NTF EQU PS:PIF+1 MAXIMUM NUMBER OF TRANSMIT FRAMES OUTSTANDING PS:RWB EQU PS:NTF+1 RECEIVE WINDOW BASE PS:TWB EQU PS:RWB+1 TRANSMIT WINDOW BASE PS:LTS EQU PS:TWB+1 LOWEST TRANSMIT SEQUENCE PS:RHS EQU PS:LTS+1 RECEIVE HIGH SEQUENCE PS:NT9 S EQU PS:RHS+1 NEXT TRANSMIT SEQUENCE PS:NTA EQU PS:NTS+1 NEXT TRANSMIT ASSIGNMENT PS:HTS EQU PS:NTA+1 HIGHEST TRANSMIT SEQUENCE PS:AHS EQU PS:HTS+1 ACCEPTED HIGH SEQUENCE PS:LPS EQU PS:AHS+1 HIGHEST IN POLL SEQUENCE PS:LFS EQU PS:LPS+1 HIGHEST IN FINAL SEQUENCE PS:RTY EQU PS:LFS+1 TRANSMISSION RETRY COUNT PS:TAH EQU PS:RTY+1 TRANSMIT ACKNOWLEDGEMENT QUEUE HEAD POINTER PS:TAT EQU PS:TAH+1 TRANSMIT ACKNOWLEDGEMENT QUEUE TAIL POINTER PS:RWH EQU PS:TAT+1 RECEIVE WAITING QUEUE HEAD POINTER PS:RWT EQU PS:RWH+1 RECEIVE WAITING QUEUE TAIL POINTER PS:TWH EQU PS:RWT+1 TRANSMIT WAITING QUEUE HEAD POINTER PS:TWT EQU PS:TWH+1 TRANSMIT WAITING QUEUE TAIL POINTER PS:TPH EQU PS:TWT+1 TRANSMIT PENDING QUEUE HEAD POINTER PS:TPT EQU PS:TPH+1 TRANSMIT PENDING QUEUE TAIL POINTER PS:RTB EQU PS:TPT+1 RESPONSE TIMER CONTROL BLOCK ADDRESS PS:PTB EQU PS:RTB+1 POLL TIMER CONTROL BLOCK ADDRESS PS:FRF EQU PS:PTB+1 FRAME REJECT FRAME PS:FRC EQU PS:FRF+1 FRAME REJECT CAUSE SIZE:PST EQU PS:FRC+1 PROTOCOL STATE TABLE SIZE TITL RECEIVE STATE TABLE OFFSET DEFINITIONS * * RST OFFSET EQUATES * RS:CIB EQU 0 CONTROLLER INFORMATION BLOCK ADDRESS RS:CET EQU RS:CIB+1 RECEIVE CONTROL EPT ADDRESS RS:DET EQU RS:CET+1 RECEIVE DRIVER EPT ADDRESS RS:LCB EQU RS:DET+1 RECEIVE CONTROL LINK LCB ADDRESS RS:RCF EQU RS:LCB+1 RECEIVE CONDITION FLAGS RS:EIB EQU RS:RCF+1 CURRENT EVENT INFORMATION BLOCK ADDRESS RS:TCB EQU RS:EIB+1 BUFFER AVAILABLE TIMER CONTROL BLOCK RS:SCS EQU RS:TCB+1 SYNCHRONOUS CONTROLLER SELECTION WORD RS:HBA EQU RS:SCS+1 HEADER BUFFER ADDRESS RS:HBC EQU RS:HBA+1 HEADER BYTE COUNT RS:BBA EQU RS:HBC+1 BODY BUFFER ADDRESS RS:BBC EQU RS:BBA+1 BODY BYTE COUNT SIZE:RST EQU RS:BBC+1 RECEIVE STATE TABLE SIZE TITL TRANSMIT STATE TABLE OFFSET DEFINITIONS * * TST OFFSET EQUATES * TS:CIB EQU 0 CONTROLLER INFORMATION BLOCK ADDRESS TS:CET EQU TS:CIB+1 TRANSMIT CONTROL EPT ADDRESS TS:DET EQU TS:CET+1 TRANSMIT DRIVER EPT ADDRESS TS:LCB EQU TS:DET+1 TRANSMIT CONTROL LINK LCB ADDRESS TS:TCF EQU TS:LCB+1 TRANSMIT CONDITION FLAGS TS:EIB EQU TS:TCF+1 CURRENT EVENT INFORMATION BLOCK ADDRESS TS:SCS EQU TS:EIB+1 SYNCHRONOUS CONTROLLER SELECTION WORD TS:HBA EQU TS:SCS+1 HEADER BUFFER ADDRESS TS:HBC EQU TS:HBA+1 HEADER BYTE COUNT TS:BBA EQU TS:HBC+1 BODY BUFFER ADDRESS TS:BBC EQU TS:BBA+1 BODY BYTE COUNT SIZE:TST EQU TS:BBC+1 TRANSMIT STATE TABLE SIZE TITL CONTROL STATE TABLE OFFSET DEFINITIONS * * CST OFFSET EQUATES * CS:CIB EQU 0 CONTROLLER INFORMATION BLOCK ADDRESS CS:CET EQU CS:CIB+1 LINE CONTROL EPT ADDRESS CS:SET EQU CS:CET+1 LINE STATISTICS EPT ADDRESS CS:CCF EQU CS:SET+1 CONTROL CONDITION FLAGS CS:STA EQU CS:CCF+1 LINE CONTROL STATE CS:PRH EQU CS:STA+1 PENDING REQUEST QUEUE HEAD CS:PRT EQU CS:PRH+1 PENDING REQUEST QUEUE TAIL CS:WRH EQU CS:PRT+1 WAITING REQUEST QUEUE HEAD CS:WRT EQU CS:WRH+1 WAITING REQUEST QUEUE TAIL CS:TCB EQU CS:WRT+1 STATISTICS TIMER CONTROL BLOCK ADDRESS CS:AIR EQU CS:TCB+1 PRIOR INTERVAL RECEIVE TOTAL UTILIZATION CS:AIT EQU CS:AIR+1 PRIOR INTERVAL TRANSMIT TOTAL UTILIZATION CS:UIR EQU CS:AIT+1 PRIOR INTERVAL RECEIVE DATA UTILIZATION CS:UIT EQU CS:UIR+1 PRIOR INTERVAL TRANSMIT DATA UTILIZATION SIZE:CST EQU CS:UIT+1 CONTROL STATE TABLE SIZE TITL FLAG WORD BIT AND FIELD DEFINITIONS * * EVENT CONTROL INFORMATION (EIB) * WORD:BGN ECI:OVR FLAG: BUFFER OVERRUN FLAG ECI:PFF FL: AG: POLL/FINAL FRAME FLAG ECI:TCF FLAG: TERMINATING LINE CONTROL FLAG ECI:PSF FLAG: PRIMARY STATION FUNCTION FLAG ECI:SSF FLAG: SECONDARY STATION FUNCTION FLAG ECI:TYP FIELD: 5 EVENT TYPE CODE ** MUST BE FIRST FIELD ** ECI:TRM FIELD: 4 OPTIONAL TERMINATION CODE FIELD WORD:END SPACE 2 * * DEVICE CONDITION FLAGS (DCT) * WORD:BGN DCF:OPR FLAG: LINE OPERATIONAL FLAG DCF:WTA FLAG: WATCHDOG TIMER ACTIVE FLAG DCF:NOP FLAG: NOP RESPONSE PENDING FLAG DCF:RAR FLAG: RECEIVE ABORT REQUESTED FLAG DCF:ROR FLAG: RECEIVE OPERATION REQUESTED FLAG DCF:TOR FLAG:  TRANSMIT OPERATION REQUESTED FLAG DCF:RVR FLAG: RECEIVE OPERATION VERIFICATION REQUIRED FLAG DCF:TVR FLAG:  TRANSMIT OPERATION VERIFICATION REQUIRED FLAG DCF:RIP FLAG: RECEIVE OPERATION IN PROGRESS FLAG DCF:TIP FLAG:  TRANSMIT OPERATION IN PROGRESS FLAG WORD:END SPACE 2 * * LINE ACCESS FLAGS (LCB) * WORD:BGN LAF:UBF FLAG: RECEIVE USE BUFFERS FLAG LAF:ECF FLAG: EXTENDED CONTROL FIELD FORMAT FLAG LAF:RBU FLAG: RECEIVE BUFFER UNAVAILABLE FLAG WORD:END SPACE 2 * * PROTOCOL MODE FLAGS (PST) * WORD:BGN PMF:CFF FLAG: EXTENDED CONTROL FIELD FORMAT FLAG PMF:PSF FLAG: PRIMARY STATION FUNCTION OPERATING FLAG PMF:SSF FLAG: SECONDARY STATION FUNCTION OPERATING FLAG PMF:ROP FLAG: ASYNCHRONOUS RESPONSE OPPORTUNITY FLAG PMF:RCR FLAG: REQUESTING RECEIVE CONTROL FLAG PMF:TCR FLAG: REQUESTING TRANSMIT CONTROL FLAG PMF:RCY FLAG: YIELDING RECEIVE CONTROL FLAG PMF:TCY FLAG: YIELDING TRANSMIT CONTROL FLAG PMF:RCH FLAG: RECEIVE CONTROL HELD FLAG PMF:TCH FLAG: TRANSMIT CONTROL HELD FLAG PMF:CLS FIELD: 3 CURRENT LINK STATE PMF:RLS FIELD: 3 REQUESTED LINK STATE WORD:END SPACE 2 * * PROTOCOL CONDITION FLAGS (PST) * WORD:BGN PCF:RTA FLAG: RESPONSE TIMER ACTIVATED FLAG PCF:TFO FLAG: TRANSMIT FINAL OUTSTANDING FLAG PCF:TPO FLAG: TRANSMIT POLL OUTSTANDING FLAG PCF:FPT FLAG: FORCED POLL FRAME TRANSMISSION FLAG PCF:PFT FLAG:  POLL FRAME TRANSMITTED FLAG PCF:FRT FLAG: FRAME REJECT RESPONSE TRANSMITTED FLAG PCF:FRC FLAG: FRAME REJECT CONDITION ESTABLISHED FLAG PCF:FRR FLAG: FRAME REJECT CONDITION REPORTED FLAG PCF:FRP FLAG: FRAME REJECT PENDING FLAG PCF:SRP FLAG: SPECIFIC RESPONSE PENDING FLAG PCF:SRT FIELD: 6 SPECIFIC RESPONSE PENDING WORD:END SPACE 2 * *  MODE CONDITION FLAGS (PST) * WORD:BGN MCF:MSR FLAG: MODE SETTING REQUIRED FLAG MCF:MSO FLAG: MODE SETTING COMMAND OUTSTANDING FLAG MCF:RSO FLAG: RESET COMMAND OUTSTANDING FLAG MCF:DSO FLAG: DISCONNECT COMMAND OUTSTANDING FLAG MCF:MRO FLAG: MODE SETTING RESPONSE OUTSTANDING FLAG MCF:MSS FLAG: MODE SETTING COMMAND RECEIVED FLAG MCF:SUS FLAG: MODE SETTING SUSPENDED FLAG MCF:RDR FLAG: REQUEST DISCONNECT RECEIVED FLAG MCF:ESN FLAG:  EXTENDED CONTROL FIELD FORMAT FLAG MCF:ASY FLAG: SETTING ASYNCHRONOUS RESPONSE OPPORTUNITY FLAG WORD:END SPACE 2 * * PROTOCOL INFORMATION TRANSFER FLAGS (PST) * WORD:BGN PIF:NRS FLAG: NEW RECEIVE STATUS TYPE PIF:NRV FLAG: ;  NEW RECEIVE STATUS VALUE FLAG PIF:ESR FLAG: EXCEPTIONAL RESPONSE REPORTED FLAG PIF:PRE FLAG: RECEIVE DATA TRANSFER ENABLED PIF:PTE FLAG: TRANSMIT DATA TRANSFER ENABLED FLAG PIF:IFR FLAG: INFORMATION FRAMES RECEIVED FLAG PIF:IFT FLAG: INFORMATION FRAMES TRANSMITTED FLAG PIF:IDR FLAG: POSSIBLE RECEIVE DATA LOSS FLAG PIF:IDT FLAG: POSSIBLE TRANSMIT DATA LOSS FLAG PIF:FCR FLAG: FLOW CONTROL REQUESTED FLAG WORD:END SPACE 2 * * FRAME REJECT CAUSE (PST) * WORD:BGN FRC:W FLAG: UNIMPLEMENTED CONTROL FIELD FLAG FRC:X FLAG: UNPERMITTED INFORMATION FIELD FLAG FRC:Y FLAG: INFORMATION FIELD TOO LONG FOR FRAME FLAG FRC:Z FLAG: INVALID N(R) VALUE IN RECEIVED FRAME FRC:C EQU 0 REJECT CAUSED BY A COMMAND FRAME FLAG WORD:END SPACE 2 * * RECEIVE CONDITION FLAGS (RST) * WORD:BGN RCF:TRC FLAG: TERMINATING RECEIVE CONTROL FLAG RCF:RCG FLAG: RECEIVE CONTROL GRANTED FLAG RCF:WFB FLAG:  WAITING FOR RECEIVE BUFFER FLAG RCF:AIP FLAG: ABORT IN PROGRESS FLAG RCF:ARC FIELD: 4 NUMBER OF RETRY ATTEMPTS REMAINING FOR ABORT WORD:END SPACE 2 * * TRANSMIT CONDITION FLAGS (TST) * WORD:BGN TCF:TCG FLAG: TRANSMIT CONTROL GRANTED FLAG WORD:END SPACE 2 * * SYNCHRONOUS CONTROLLER SELECT (RST, TST, DCT) * WORD:BGN H: SET 7 START NUMBERING OF BITS AT SEVEN SCS:CHN FLAG: CHANNEL A/B SELECTION FLAG SCS:NMA FLAG: DO NOT SCAN FOR ADDRESS MATCH FLAG SCS:NRTS FLAG: DO NOT LEAVE RTS HIGH FLAG SCS:NDTR FLAG: DO NOT TURN ON DTR FLAG SCS:DIS FLAG: DISABLE STATUS INTERRUPTS FLAG SCS:OPR FIELD: 2 CONTROLLER OPERATION CODE WORD:END SPACE 2 * * DEVICE STATUS FLAGS (DCT) * WORD:BGN DSF:CPL FLAG: OPERATION COMPLETE FLAG DSF:RIP FLAG: RECEIVE COMMAND IN PROGRESS FLAG DSF:TIP FLAG: TRANSMIT COMMAND IN PROGRESS FLAG DSF:TST FLAG: TEST MODE SIGNAL STATE DSF:CTS FLAG: CLEAR TO SEND SIGNAL STATE DSF:DCD FLAG: DATA CARRIER DETECT SIGNAL STATE DSF:RI FLAG: RING INDICATOR SIGNAL STATE DSF:DSR FLAG: DATA SET READY SIGNAL STATE DSF:CRC FLAG: RECEIVE CRC ERROR FLAG DSF:ROV FLAG: RECEIVE OVERRUN ERROR FLAG DSF:ABO FLAG: RECEIVE ABORT ERROR FLAG DSF:TUN FLAG: TRANSMIT UNDERRUN ERROR FLAG DSF:DMA FLAG: DMA ERROR FLAG DSF:INT FLAG: INTERFACE ERROR FLAG DSF:XXX FLAG: RESERVED FOR FUTURE USAGE DSF:RDP FLAG: RECEIVE DATA PRESENT FLAG WORD:END SPACE 2 * * CONTROL CONDITION FLAGS (CST) * WORD:BGN CCF:DOP FLAG: DEVICE COMPONENT OPERATIONAL FLAG CCF:ROP FLAG: RECEIVE COMPONENT OPERATIONAL FLAG CCF:TOP FLAG: TRANSMIT COMPONENT OPERATIONAL FLAG CCF:CON FLAG: COMMUNICATIONS LINE CONNECTED FLAG CCF:ABO FLAG: ABORT INITIALIZATION FLAG WORD:END END M MIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII<  TITL SYNCHRONOUS HANDLER SYSTEM DEFINITIONS (93438-94/A030) TITL GLOBAL EQUATE DEFINITIONS * * DEFINITIONS FOR EQUATES USED THROUGHOUT THE DRIVER * STATUS: EQU :40 STATUS TO PLUG AFTER A PUSH DEBUG: EQU 0 DEBUG ASSEMBLY SWITCH FOR GENERATED CODE XMIT:LIM EQU 4 MAXIMUM NUMBER OF TRANSMIT FRAMES OUTSTANDING RETRYS: EQU 3 NUMBER OF OPERATION RETRYS TO MAKE SPACE 2 * * DEFINITIONS FOR STATUS REGISTER EQUATES * CY: EQU 0 CARRY BIT OV: EQU 1 OVERFLOW BIT BM: EQU 2 BYTE MODE BIT SPACE 2 * * DEFINITIONS FOR OFFSETS ON STACK TO REGISTERS SAVED ON ENTRY * STK:L EQU 0 L REGISTER OFFSET STK:S EQU 1 S REGISTER OFFSET STK:A EQU 2 A REGISTER OFFSET STK:Q EQU 3 Q REGISTER OFFSET STK:X EQU 4 X REGISTER OFFSET STK:Y EQU 5 Y REGISTER OFFSET STK:NUM EQU 6 NUMBER OF WORDS STORED ON STACK TITL TIMER CONTROL BLOCK OFFSET DEFINITIONS * * TCB OFFSET EQUATES * TC:NXT EQU 0 NEXT POINTER TC:LST EQU TC:NXT+1 LAST POINTER TC:TIC EQU TC:LST+1 DELTA TIME FROM PREDECESSOR TC:INT EQU TC:TIC+1 TIMER INTERVAL TC:TYP EQU TC:INT+1 TYPE OF TIMER CONTROL BLOCK TC:SEM EQU TC:TYP+1 ADDRESS OF SEMAPHORE TO SIGNAL OR TIMEOUT QUEUE POINTER TC:EXP EQU TC:SEM+1 TIMER EXPIRATION SIGNAL SIZE:TCB EQU TC:EXP+1 TIMER CONTROL BLOCK SIZE SPACE 2 * * EQUATES FOR TIMER EXPIRATION SIGNAL STATES * EXP:INA EQU 1 TIMER IS INACTIVE EXP:RUN EQU 0 TIMER IS RUNNING EXP:EXP EQU -1 TIMER IS EXPIRED TITL BIT AND FIELD MANIPULATION MACROS DEFINITIONS * * BITS MACROS * BITS:OFF - CLEARS SELECTED FLAGS AND FIELDS FROM THE REGISTER * BITS:ON - SETS SELECTED FLAGS AND FIELDS WITH SPECIFIED FIELD * VALUES (ALL ONES USED IF NO VALUE) IN REGISTER *  BITS:NOT - COMPLEMENTS SELECTED FLAGS AND FIELDS IN THE REGISTER * BITS:OUT - CLEARS ALL BUT SELECTED FLAGS AND FIELDS FROM THE * REGISTER * BITS:EXT - MASKS AND RIGHT-JUSTIFIES SELECTED FLAG OR FIELD IN THE * REGISTER * BITS:VAL - FORMS SKELETON OF WORD WITH SPECIFIED FIELD VALUES * (ALL ONES USED IF NO VALUE) IN REGISTER * BITS:LBL - EQUATES SYMBOL GIVEN AS FIRST ARGUMENT TO A WORD * SKELETON WITH THE SPECIFIED FIELD VALUES * BITS:WRD - GENERATES DATA WORD WITH SPECIFIED FIELD VALUES (THE * FIRST ARGUMENT FIELD IS IGNORED) * BITS:OFF MACRO +1 BITS:ON MACENT +2 BITS:NOT MACENT +3 BITS:OUT MACENT -1 BITS:EXT MACENT -2 BITS:LBL MACENT -3 BITS:WRD MACENT -4 BITS:VAL MACENT 0 M: SET 0 B: SET 0 E: SET 0 IFT #(0)=0 E: SET -1 ENDC IFT #(0)=2 E: SET -1 ENDC IFT #(0)<-2 E: SET -1 ENDC IFT #(0)=-2 IFT #(?)>2 NOTE E,'ONLY TWO PARAMETERS ALLOWED FOR EXTRACT VARIATION' ENDC FORM:M #(2) IFT B:<>0 SHIFT #(1),RO,B: ENDC AND =M:%-B:,#(1) ENDC IFT #(0)<>-2 IFT #(?)>1 FORM:M #(2) IFT #(?)>2 FORM:M #(3) IFT #(?)>3 FORM:M #(4) IFT #(?)>4 FORM:M #(5) IFT #(?)>5 FORM:M #(6) IFT #(?)>6 FORM:M #(7) IFT #(?)>7 FORM:M #(8) IFT #(?)>8 FORM:M #(9)  IFT #(?)>9 FORM:M #(10) IFT #(?)>10 FORM:M #(11) ENDC ENDC ENDC ENDC ENDC ENDC ENDC ENDC ENDC ENDC IFT #(0)>0 IFT M:-1&M:=0 NUM:BIT B:,M: IFT #(0)=1 RBIT B:,#(1) ENDC IFT #(0)=2 SBIT B:,#(1) ENDC IFT #(0)=3 CBIT B:,#(1) ENDC ENDC IFF M:-1&M:=0 IFT #(0)=1 AND =-M:-1,#(1) ENDC IFT #(0)=2 OR =M:,#(1) ENDC IFT #(0)=3 XOR =M:,#(1) ENDC ENDC ENDC I= FT #(0)=-1 AND =M:,#(1) ENDC IFT #(0)=0 COPY =M:,#(1) ENDC IFT #(0)=-3 #(1) EQU M: ENDC IFT #(0)=-4 WORD M: ENDC ENDC ENDM SPACE 2 * * FORM:M MACRO * USED BY THE BITS MACROS FOR GENERATION OF MASKS. * FORM:M MACRO E:: SET 0 T:: SET #(1,?) IFT #(1,'=') E:: SET -1 Z:: SET T:: T:: SET #(1,'=')-1 A:: SET T::+2 V:: SET #(1,A::,Z::) ENDC IFT E::&\E: NOTE E,'NO VALUES ALLOWED FOR THIS VARIATION' ENDC IFF E::&\E: S:: SYMATT #(1,1,T::) IFF S::&:80<>0 B: SET #(1,1,T::) IFF E:: V:: SET 1  ENDC M: SET V::%B:;M: ENDC IFT S::&:80<>0 S:: SYMATT #(1,1,T::)B IFT S::&:80<>0 NOTE E,'UNDEFINED MACRO PARAMETER' ENDC IFF S::&:80<>0 S:: SYMATT #(1,1,T::)M IFT S::&:80<>0 NOTE E,'UNDEFINED MACRO PARAMETER' ENDC IFF S::&:80<>0 B: SET #(1,1,T::)B IFF E:: V:: SET #(1,1,T::)M ENDC M: SET V::%B:;M: ENDC ENDC ENDC ENDC ENDM SPACE 2 * * NUM:BIT MACRO * USED BY THE BITS MACROS FOR CALCULATING THE NUMBER OF A BIT VALUE. * NUM:BIT MACRO #(1) SET 0 IFT #(2)&:FF00 #(2) SET #(2)%-8 #(1) SET 8 ENDC IFT #(2)&:F0 #(2) SET #(2)%-4 #(1) SET #(1)+4 ENDC IFT #(2)&:C #(2) SET #(2)%-2 #(1) SET #(1)+2 ENDC #(1) SET #(2)%-1+#(1) ENDM TITL BIT PAIR VERIFICATION MACRO DEFINITION * * PAIRS: * * MACRO VERIFIES THAT THE ARGUMENT FLAG PAIRS ARE IN THE SAME * RELATIVE POSITIONS, GENERATING AN ASSEMBLY ERROR IF NOT. EACH * ARGUMENT IS ONE PAIR OF FLAGS, SEPARATED BY A '#' CHARACTER. * UP TO FOUR PAIRS OF FLAGS CAN BE SPECIFIED IN ONE MACRO CALL. * PAIRS: MACRO IFT #?>0 CHK:PAIR #(1),1 IFT #?>1 CHK:PAIR #(2),2 IFT #?>2 CHK:PAIR #(3),3 IFT #?>3 CHK:PAIR #(4),4 ENDC ENDC ENDC ENDC ENDM SPACE 2 * * CHK:PAIR * * INTERNAL MACRO USED BY THE PAIR CHECKING MACRO TO CALCULATE THE * SPACING BETWEEN A SINGLE PAIR OF FLAGS AND GENERATE AN ASSEMBLY * ERROR IF THE SPACING DIFFERS FROM THAT PREVIOUSLY DETERMINED. * CHK:PAIR MACRO N:: SET #(1,?) B:: SET #(1,'#') IFF B:: NOTE E,NO.SEPARATOR.IN.PARAMETER.#(2).>#(1)< ENDC IFT B:: I:: SET B::-1 J:: SET B::+1 S:: SET #(1,1,I::)-#(1,J::,N::) IFT #(2)=1 F:: SET S:: ENDC IFF #(2)=1 IFF F::=S:: NOTE E,WRONG.SEPARATION.FOR.PAIR.#(2).>#(1)< ENDC ENDC ENDC ENDM TITL GENERAL PURPOSE SHIFT MACRO DEFINITIONS * * SHIFT:, ROTATE: * * MACROS GENERATE A SHIFT OR ROTATE INSTRUCTION (RESPECTIVELY) FOR * THE REGISTER SPECIFIED BY THE FIRST PARAMETER AND THE NUMBER OF * BITS SPECIFIED BY THE SECOND PARAMETER. POSITIVE VALUES OF THE * SECOND PARAMETER ARE TREATED AS POSITIONING BITS TO THE LEFT, *  NEGATIVE VALUES TO THE RIGHT. * SHIFT: MACRO V: SET #(2) IFT V:>0 SHIFT #(1),LO,V: ENDC IFT V:<0 SHIFT #(1),RO,-V: ENDC ENDM ROTATE: MACRO V: SET #(2) IFT V:>0 ROTATE #(1),L,V: ENDC IFT V:<0 ROTATE #(1),L,16+V: ENDC ENDM TITL ERROR CONDITION MACRO DEFINITION * * ERR:D * * MACRO GENERATES A ENTRY TO DEBUG IF THE DEBUG OPTION IS ACTIVE. * OTHERWISE, A JUMP TO THE LOCATION SPECIFIED BY THE ARGUMENT TO THE * MACRO CALL IS GENERATED, IF AN ARGUMENT IS PRESENT. * ERR:D MACRO IFT DEBUG: JST *0 ENTER DEBUG4 ENDC IFF DEBUG: IFT #?>0 JMP #(1) NORMAL BRANCH ENDC ENDC ENDM END . . . . . . . . . . . .IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII>  GENLIB - USER LINK LIBRARY GENERATION 84-93438-70 (A030) A UF=SD/SYNC/RELEASE/ A UM=SD/RTX_MAC/ MACRO USER(D=UM/GEN+UM/RTX+UM/IOS+UM/IOSD+SYNC(P=57,L=)+SYNCD+SYNCS, P=57,L=) MACRO LINECTL(D=UM/GEN+UM/RTX+UM/IOS+UM/IOSD+SYNC+SYNCD+SYNCS(P=57,L=), P=57,L=) MACRO PROTOCOL(D=UM/GEN+UM/RTX+UM/IOS+SYNC+SYNCD+SYNCS+PROTOCOL(P=57, L=),P=57,L=) MACRO RECVCTL(D=UM/GEN+UM/RTX+UM/IOS+SYNC+SYNCD(P=57,L=)+SYNCS,P=57, L=) MACRO XMITCTL(D=UM/GEN+UM/RTX+UM/IOS+SYNC+SYNCD+SYNCS,P=57,L=) MACRO DEVCCTL(D=UM/GEN+UM/RTX+UM/IOS+UM/IOSD+SYNC+SYNCD+SYNCS,P=57,L=) MACRO COMSUBS(D=UM/GEN+UM/RTX+UM/IOS+SYNC+SYNCD+SYNCS,P=57,L=) MACRO TIMER(D=UM/GEN+UM/RTX+UM/IOS+SYNC+SYNCD+SYNCS,P=57,L=) CO SYNC.LIB(OV)=USER.OBJ+LINECTL.OBJ+PROTOCOL.OBJ+RECVCTL.OBJ+XMITCTL.OBJ+ DEVCCTL.OBJ+COMSUBS.OBJ+TIMER.OBJ IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII GENTST - TEST PROGRAM GENERATION - 84-93438-71 (A030) A UF=SD/SYNC/RELEASE/ A UL=SD/RTX_LBR/ A UM=SD/RTX_MAC/ MACRO TEST(D=UM/GEN+UM/RTX+UM/IOS+UM/IOSD+SYNC,P=57,L=LP) MACRO TESTTBL(D=UM/GEN+UM/IOS+UM/IOSD+SYNC+SYNCM,P=57,L=LP) DE TEST.MAP CR TEST.MAP A LO=TEST.MAP LINK TEST(ABS=200)+TESTTBL+SYNC.LIB+UL/RTX.LIB H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H HIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII? IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII@ IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIA IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIB IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIC IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIID IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIE IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIF IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIG IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIH IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJ IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIK IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIL IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIOS4 MA283011213334440830112133344 830112133344KF43803 VOLSYNCHRONOUS COMMUNICATIONS HANDLER SOURCE DISKETTE II (A030)