IMD 1.16: 1/09/2008 12:21:33 84-93438-02 a030 f43802 synchronous communications handler source diskette #1 8feb83    @0{)vvЀЀsQpk)p " }fA __M@IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIOS4 MA283011016043140830110160431 830110160431JF43802 VOLSYNCHRONOUS COMMUNICATIONS HANDLER SOURCE DISKETTE I (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 IOS4 INTERFACE PROCEDURES (93438-10/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR I:EMEM EXTR I:ECTT EXTR I:RET EXTR R:GPR EXTR R:SPRI EXTR R:WAIT EXTR PUT:DREQ EXTR PUT:CREQ * * EXTERNAL DEFINITIONS * NAM SC:RD NAM SC:WRT NAM SC:FUN * * REL AREA DEFINITION * SHARABLE IOS: ROMMABLE IOS: SYSTEM IOS: REL TITL TEMPORARY INFORMATION BLOCK OFFSET DEFINITIONS * * TIB OFFSET EQUATES * TI:PTR EQU 18 TEMPORARY POINTER LOCATION TI:SEM EQU TI:PTR+1 INTERNAL FORMAT SEMAPHORE FOR INTERFACE TI:CQH EQU TI:SEM+1 HEAD OF COMPLETION QUEUE TI:CQT EQU TI:CQH+1 TAIL OF COMPLETION QUEUE TI:CQS EQU TI:CQT+1 COMPLETION QUEUE SEMAPHORE ADDRESS TI:BIB EQU TI:CQS+1 START OF BUFFER INFORMATION BLOCK CONSTRUCTED * TI:BNX EQU TI:BIB+BI:NXT NEXT POINTER TI:BCQ EQU TI:BIB+BI:QPB COMPLETION QUEUE POINTER BLOCK TI:BOF EQU TI:BIB+BI:ORF OPERATION REQUEST FLAGS TI:BBA EQU TI:BIB+BI:BUF BUFFER ADDRESS TI:BRC EQU TI:BIB+BI:BCT REQUEST COUNT TI:BAC EQU TI:BIB+BI:ACT ACTUAL COUNT * TI:BCR EQU TI:BIB+CR:CRC CONTROL REQUEST CODE TI:BDB EQU TI:BIB+CR:DIB DEVICE INFORMATION BLOCK * TITL INIT:TIB - INITIALIZE TEMPORARY INFORMATION BLOCK * * INIT:TIB * * PROCEDURE INITIALIZES THE TEMPORARY INFORMATION BLOCK  ALLOCATED BY * IOS4, VALIDATES THE BUFFER PARAMETERS SPECIFIED, AND CHECKS THAT * THE DEVICE INFORMATION BLOCK IS IN AN OPEN STATE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A - ZERO IF NO ERRORS FOUND, ERROR TERMINATION CODE OTHERWISE * Q,X - DESTROYED * INIT:TIB EQU $ JSK R:GPR GET CURRENT ACTIVITY PRIORITY COPY A,TI:PRI(Y) SAVE ENTERING PRIORITY LEVEL COPY TI:CIB(Y),X BASE ADDRESS OF CIB COPY CI:PRI(X),X PRIORITY LEVEL OF IOS4 INTERFACE JSK R:SPRI SET PRIORITY OF ACTIVITY TO DRIVER LEVEL COPY =0,A COPY A,TI:SEM(Y) INITIALIZE COMPLETION SEMAPHORE COPY A,TI:CQH(Y) INITIALIZE COMPLETION QUEUE COPY A,TI:CQT(Y) COPY Y,Q SET ADDRESS OF COMPLETION SEMAPHORE ADD =TI:SEM,Q COPY Q,TI:CQS(Y) COPY A,TI:BNX(Y) INITIALIZE NEXT POINTER FOR BIB COPY Y,Q SET ADDRESS OF COMPLETION QUEUE ADD =TI:CQH,Q COPY Q,TI:BCQ(Y) COPY A,TI:BOF(Y) INITIALIZE OPERATION REQUEST FLAGS COPY TI:BUF(Y),X BUFFER ADDRESS SPECIFIED COPY TI:BCT(Y),A REQUESTED BYTE COUNT JEQ A,$+3 JUMP IF NO BUFFER FOR OPERATION JSK I:EMEM VERIFY THAT SPECIFIED MEMORY EXISTS JLT A,IT01 JUMP IF NONEXISTANT MEMORY SPECIFIED COPY TI:DIB(Y),X BASE ADDRESS OF DIB COPY DI:FLG(X),A FLAG WORD TBIT DIF:OP,A DEVICE OPEN FLAG COPY =-NOPEN:,A ASSUME DEVICE NOT OPEN JF OV,IT01 TAKE ERROR RETURN IF CORRECT ASSUMPTION COPY =0,A SET NORMAL COMPLETION CODE IT01 EQU $ RETURN TO CALLER RSK TITL INIT:BIB - INITIALIZE BUFFER INFORMATION BLOCK * * INIT:BIB * * PROCEDURE COMPLETES THE INITIALIZATION OF THE BUFFER INFORMATION * BLOCK FOR A USER READ OR WRITE REQUEST. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A - ZERO IF NO ERROR, ERROR TERMINATION CODE OTHERWISE * Q,X - UNCHANGED * INIT:BIB EQU $ COPY TI:BUF(Y),A COPY USER BUFFER ADDRESS TO BIB COPY A,TI:BBA(Y) COPY TI:BCT(Y),A COPY USER BYTE COUNT REQUESTED TO BIB COPY A,TI:BRC(Y)  JEQ A,IB01 JUMP IF ZERO LENGTH BUFFER SPECIFIED COPY =0,A INITIALIZE ACTUAL COUNT VALUE COPY A,TI:BAC(Y) RSK RETURN TO CALLER IB01 EQU $ ZERO LENGTH BUFFER SPECIFIED FOR OPERATION COPY =-ILLOP:,A SET ILLEGAL OPERATION TERMINATION CODE RSK  RETURN TO CALLER WITH ERROR CODE TITL WAIT:FOR - WAIT FOR THE COMPLETION OF AN OPERATION * * WAIT:FOR * * PROCEDURE WAITS FOR THE TERMINATION OF A REQUEST GIVEN TO THE * HANDLER, AND CONVERTS THE TERMINATION CODE TO AN IOS4 EQUIVALENT * VALUE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A - TERMINATION CODE FOR REQUEST *  Q,X - DESTROYED * WAIT:FOR EQU $ COPY TI:CQH(Y),A COMPLETION QUEUE HEAD POINTER JNE A,WF01 JUMP IF OPERATION COMPLETED COPY TI:CQS(Y),X COMPLETION QUEUE SEMAPHORE ADDRESS JSK R:WAIT WAIT FOR A SIGNAL BEFORE REPEATING CHECKS WF01 EQU $ CONVERT THE TERMINATION CODE COPY TI:BOF(Y),A OPERATION REQUEST FLAGS IFT ORF:TRMB SHIFT A,RO,ORF:TRMB RIGHT-JUSTIFY TERMINATION CODE RETURNED ENDC AND =ORF:TRMM,A MASK OUT TERMINATION CODE RETURNED XNX A USE TERMINATION CODE AS INDEX INTO TABLE COPY TERM:TBL,A LOAD IOS4 EQUIVALENT CODE FOR RETURN RSK RETURN TO CALLER * TERM:TBL EQU $ WORD NORML: TRM:NORM WORD -NOLIN: TRM:LINE WORD NORDY: TRM:INOP WORD RESET: TRM:REST WORD -RTYTH: TRM:RETH WORD -ILLOP: TRM:INVF WORD -ILLOP: TRM:INVR WORD -ILLOP:  TRM:CONF WORD -NOMEM: TRM:MEMO WORD -TMANY: TRM:MANY WORD -ABORT: TRM:ABRT WORD NORDY: TRM:TEMP TITL TERM:OP - OPERATION TERMINATION COMMON EXIT * * TERM:OP * * PROCEDURE PROCESSES THE COMPLETION OF AN OPERATION, RETURNING THE * SPECIFIED ERROR CODE TO THE USER. CALLING OF THIS PROCEDURE IS * DONE BY A JUMP, SINCE NO RETURN TO THE CALLER IS TAKEN. * * CALL PARAMETERS: * A - NEGATIVE OF ERROR CODE VALUE * TERM:OP EQU $ JSK I:ECTT SAVE TERMINATION CODE FOR RETURN TO USER COPY TI:PRI(Y),X SAVED PRIORITY LEVEL OF ENTERING ACTIVITY JSK R:SPRI RESTORE USER PRIORITY LEVEL JMP I:RET RETURN TO USER THROUGH IOS4 TITL READ REQUEST PROCESSING * * SC:RD * * PROCEDURE PERFORMS READ OPERATIONS, QUEUEING A REQUEST FOR INPUT * TO THE HANDLER AND RETURNING TO THE CALLER WHEN PROCESSING OF THE * REQUEST IS COMPLETED. * SC:RD EQU $ JSK INIT:TIB INITIALIZE TIB AND VALIDATE BUFFER PARAMETERS JNE A,TERM:OP TERMINATE OPERATION ON ANY ERROR CONDITION JSK INIT:BIB INITIALIZE BIB GENERATED WITHIN TIB AREA COPY Y,A SET ADDRESS OF GENERATED BIB ADD =TI:BIB,A COPY TI:DIB(Y),X SET ADDRESS OF QUEUE CONTROL BLOCK ADD =DI:RQH,X JSK PUT:DREQ ENTER READ REQUEST TO HANDLER JSK WAIT:FOR WAIT FOR COMPLETION OF OPERATION COPY TI:BAC(Y),Q ACTUAL COUNT READ COPY Q,TI:ACT(Y) SAVE FOR RETURN IN IOB JMP TERM:OP RETURN TERMINATION CODE TO CALLER TITL WRITE REQUEST PROCESSING * * SC:WRT * * PROCEDURE PERFORMS WRITE OPERATIONS, QUEUEING A REQUEST FOR INPUT * TO THE HANDLER AND RETURNING TO THE CALLER WHEN PROCESSING OF THE * REQUEST IS COMPLETED. * SC:WRT EQU $ JSK INIT:TIB INITIALIZE TIB AND VALIDATE BUFFER PARAMETERS JNE A,TERM:OP TERMINATE OPERATIONS ON ANY ERROR CONDITION JSK INIT:BIB INITIALIZE BIB GENERATED WITHIN TIB AREA COPY Y,A SET ADDRESS OF GENERATED BIB ADD =TI:BIB,A COPY TI:DIB(Y),X SET ADDRESS OF QUEUE CONTROL BLOCK ADD =DI:WQH,X JSK PUT:DREQ ENTER WRITE REQUEST TO HANDLER JSK WAIT:FOR WAIT FOR COMPLETION OF OPERATION COPY TI:BAC(Y),Q ACTUAL COUNT READ COPY Q,TI:ACT(Y) SAVE FOR RETURN IN IOB JMP TERM:OP RETURN TERMINATION CODE TO USER * LPOOL TITL FUNCTION REQUEST PROCESSING * * SC:FUN * * PROCEDURE PERFORMS FUNCTION OPERATIONS, EITHER PROCESSING A * REQUEST DIRECTLY (ERROR TABLE REQUESTS) OR QUEUEING IT FOR INPUT * TO THE HANDLER AND RETURNING TO THE CALLER WHEN PROCESSING OF THE * REQUEST IS COMPLETED. * SC:FUN EQU $ JSK INIT:TIB INITIALIZE TIB AND VALIDATE BUFFER PARAMETERS JEQ A,SF02 JUMP UNLESS ERROR CONDITION COPY A,Q COPY ERROR CODE RETURNED ADD =NOPEN:,Q CHECK IF ERROR IS DEVICE NOT OPEN JNE Q,TERM:OP TAKE IMMEDIATE ERROR TERMINATION IF NOT COPY TI:FC(Y),Q FUNCTION CODE WORD FROM IOB AND =:F,Q MASK OUT FUNCTION MODIFIER FIELD SUB =OP:,Q CHECK FOR AN OPEN FUNCTION CALL JNE Q,TERM:OP TAKE ERROR TERMINATION IF NOT COPY =CRC:INF,A SET REQUEST CODE FOR INFORMATION TRANSFER COPY A,TI:BCR(Y) COPY TI:DIB(Y),A SET BASE ADDRESS OF DIB COPY A,TI:BDB(Y) COPY Y,A SET ADDRESS OF GENERATED CRB ADD =TI:BIB,A COPY TI:CIB(Y),X SET BASE ADDRESS OF CIB JSK PUT:CREQ ENTER CONTROL REQUEST TO HANDLER JSK WAIT:FOR WAIT FOR COMPLETION OF OPERATION JNE A,SF01 TAKE ERROR TERMINATION IF UNSUCCESSFUL COPY TI:DIB(Y),X BASE ADDRESS OF DIB COPY DI:FLG(X),Q FLAG WORD SBIT DIF :OP,Q SET DEVICE OPEN FLAG COPY Q,DI:FLG(X) SF01 EQU $ TERMINATE OPERATION AND RETURN TO USER JMP TERM:OP SF02 EQU $ NORMAL OPERATION PROCESSING WITH DEVICE OPEN COPY TI:FC(Y),A FUNCTION CODE WORD FROM IOB AND =:F,A MASK OUT FUNCTION MODIFIER FIELD CLSN A,=OP: CHECK FOR AN OPEN FUNCTION CALL JMP SF04 CLSN A,=CL: CHECK FOR A CLOSE FUNCTION CALL JMP SF05 CLSN A,=ET: CHECK FOR A READ STATISTICS TABLE CALL JMP SF06 CLSN A,=EC: CHECK FOR A CLEAR STATISTICS TABLE CALL JMP SF07 SF03 EQU $ ILLEGAL OPERATION TERMINATION PROCESSING COPY =-ILLOP:,A SET ILLEGAL OPERATION TERMINATION CODE JMP TERM:OP TERMINATE OPERATION AND RETURN TO USER SF04 EQU $ OPEN FUNCTION ON PREVIOUSLY OPENED LINE COPY =-FILEO:,A SET FILE ALREADY OPEN TERMINATION CODE JMP TERM:OP TERMINATE OPERATION AND RETURN TO USER SF05 EQU $ CLOSE FUNCTION CALL PROCESSING COPY =CRC:TERM,A SET REQUEST CODE FOR TERMINATING OPERATION COPY A,TI:BCR(Y) COPY TI:DIB(Y),A SET BASE ADDRESS OF DIB COPY A,TI:BDB(Y) COPY Y,A SET ADDRESS OF GENERATED CRB ADD =TI:BIB,A COPY TI:CIB(Y),X SET BASE ADDRESS OF CIB JSK PUT:CREQ ENTER CONTROL REQUEST TO HANDLER JSK WAIT:FOR WAIT FOR COMPLETION OF OPERATION JNE A,SF01 TAKE ERROR TERMINATION IF UNSUCCESSFUL COPY TI:DIB(Y),X BASE ADDRESS OF DIB COPY DI:FLG(X),Q FLAG WORD RBIT DIF:OP,Q RESET DEVICE OPEN FLAG COPY Q,DI:FLG(X) JMP TERM:OP RETURN TERMINATION CODE TO USER SF06 EQU $ READ STATISTICS TABLE CALL PROCESSING COPY TI:BRC(Y),X REQUESTED BYTE COUNT FOR OPERATION SHIFT X,RO,1 CONVERT TO WORD COUNT JEQ X,SF03 ERROR IF ZERO WORD READ REQUESTED COPY TI:CIB(Y),Q BASE ADDRESS OF CIB ADD =CI:FCS,Q SET STARTING ADDRESS OF STATISTICS TABLE COPY Q,TI:PTR(Y) COPY *TI:PTR(X,Y),A LOAD A WORD OF THE STATISTICS TABLE COPY A,*TI:BBA(X,Y) STORE INTO USER BUFFER JNED X,$-2 LOOP FOR REQUESTED NUMBER OF WORDS COPY =NORML:,A SET NORMAL TERMINATION CODE JMP TERM:OP RETURN TERMINATION CODE TO USER SF07 EQU $ CLEAR STATISTICS TABLE CALL PROCESSING COPY TI:CIB(Y),Q BASE ADDRESS OF CIB ADD =CI:FCS,Q SET STARTING ADDRESS OF STATISTICS TABLE COPY Q,TI:PTR(Y) COPY =0,A SET NULL VALUE TO STORE INTO TABLE COPY =CI:UFT-CI:FCS,X SET INDEX FROM START OF TABLE TO END COPY A,*TI:PTR(X,Y) SET A WORD OF THE TABLE TO ZERO JNED X,$-1 LOOP FOR ALL WORDS IN TABLE COPY =NORML:,A SET NORMAL TERMINATION CODE JMP TERM:OP RETURN TERMINATION CODE TO USER SPACE 2 END TITL SYNCHRONOUS HANDLER INTERNAL INTERFACE (84-93438-10/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:SIG EXTR R:GPR EXTR R:SPRI EXTR B:LINEC * * EXTERNAL DEFINITIONS * NAM PUT:DREQ NAM GET:DREQ NAM PUT:CREQ * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL TITL PUT:DREQ - ENTER REQUEST ON QUEUE * * PUT:DREQ * * PROCEDURE ENTERS A REQUEST CONTROL BLOCK ON THE SPECIFIED QUEUE. * IF THE QUEUE WAS PREVIOUSLY EMPTY, THE SEMAPHORE ASSOCIATED WITH *  THE QUEUE IS SIGNALLED. * * CALL PARAMETERS: * A - BASE ADDRESS OF REQUEST CONTROL BLOCK * X - BASE ADDRESS OF QUEUE POINTER BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * PUT:DREQ EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY A,Y BASE ADDRESS OF REQUEST CONTROL BLOCK COPY =0,Q SET NULL LINKAGE FROM BLOCK BEING ADDED COPY Q,BI:NXT(Y ) SIN 2 DISALLOW INTERRUPTS WHILE MODIFYING QUEUE EXCH Y,1(X) SET NEW REQUEST AS TAIL OF QUEUE JEQ Y,PD01 JUMP IF QUEUE PREVIOUSLY EMPTY COPY A,BI:NXT(Y) LINK FORMER LAST TO ADDED REQUEST CONTROL BLOCK JMP PD02 PD01 EQU $ ADDING TO AN EMPTY QUEUE COPY A,0(X) SET ADDED REQUEST AS HEAD OF QUEUE COPY 2(X),X ADDRESS OF SEMAPHORE TO BE SIGNALLED JEQ X,PD02 JUMP IF NO SEMAPHORE ASSOCIATED WITH QUEUE JSK R:SIG SIGNAL THE ACTIVITY PROCESSING THE QUEUE PD02 EQU $ RESTORE REGISTERS AND RETURN POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL GET:DREQ - REMOVE REQUEST FROM QUEUE * * GET:DREQ * * PROCEDURE REMOVES THE FIRST REQUEST CONTROL BLOCK FROM THE * SPECIFIED QUEUE AND RETURNS THE ADDRESS TO THE CALLER. * * CALL PARAMETERS: * X - BASE ADDRESS OF QUEUE POINTER BLOCK * * RETURN PARAMETERS: * A - BASE ADDRESS OF REQUEST CONTROL BLOCK IF QUEUE NONEMPTY, ZERO * OTHERWISE * Q,X,Y - UNCHANGED * GET:DREQ EQU $ PUSH STATUS: SAVE ENTERING 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,GD01 JUMP IF QUEUE ALREADY EMPTY COPY BI:NXT(X),A GET NEXT POINTER FROM FIRST ON QUEUE  COPY A,0(Y) SAVE AS NEW HEAD OF QUEUE JNE A,GD01 JUMP UNLESS QUEUE NOW EMPTY COPY A,1(Y) SET TAIL POINTER TO NULL ALSO GD01 EQU $ RETURN WITH ADDRESS OF BLOCK REMOVED COPY K,Y CURRENT STACK POINTER VALUE COPY X,STK:A(Y) PLUG VALUE TO BE RETURNED IN A  POP RESTORE MODIFIED CALLING REGISTERS RSK RETURN TO CALLER TITL PUT:CREQ - ENTER CONTROL REQUEST ON QUEUE * * PUT:CREQ * * PROCEDURE ENTERS A REQUEST CONTROL BLOCK ON THE CONTROLLER * INFORMATION BLOCK CONTROL REQUEST QUEUE, THEN STARTS AN ACTIVITY * OF THE LINE CONTROL ACTIVITY IF ONE WAS NOT PREVIOUSLY RUNNING. * * CALL PARAMETERS: *  A - BASE ADDRESS OF CONTROL REQUEST BLOCK * X - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X,Y - UNCHANGED * PUT:CREQ EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK JSK R:GPR GET PRESENT PRIORITY LEVEL OF CALLER COPY A,Y SAVE ENTERING PRIORITY LEVEL COPY K,X CURRENT STACK POINTER ADDRESS COPY STK:X(X),X RESTORE BASE ADDRESS OF CIB COPY CI:BPL(X),X BASE PRIORITY LEVEL FOR LINE JSK R:SPRI SET PRIORITY TO THAT OF LINE CONTROL ACTIVITY COPY Y,A COPY ENTERING PRIORITY LEVEL COPY K,Y CURRENT STACK POINTER ADDRESS COPY STK:X(Y),X RESTORE BASE ADDRESS OF CIB COPY STK:A(Y),Y GET BASE ADDRESS OF CONTROL REQUEST BLOCK COPY =0,Q SET NULL LINKAGE FROM BLOCK BEING ADDED COPY Q,CR:NXT(Y) COPY Y,Q SAVE A COPY OF THE BLOCK ADDRESS EXCH Y,CI:CRT(X) SET NEW REQUEST AS TAIL OF QUEUE JEQ Y,PC01 JUMP IF QUEUE PREVIOUSLY EMPTY COPY Q,CR:NXT(Y) LINK FORMER LAST TO ADDED CONTROL REQUEST BLOCK JMP PC02 PC01 EQU $ ADDING TO AN EMPTY QUEUE COPY Q,CI:CRH(X) SET NEW REQUEST AS HEAD OF QUEUE COPY CI:LMS(X),X ADDRESS OF SEMAPHORE TO BE SIGNALLED JEQ X,PC02 JUMP IF NO SEMAPHORE ASSOCIATED WITH QUEUE JSK R:SIG SIGNAL THE LINE CONTROL ACTIVITY PC02 EQU $ CHECK FOR LINE CONTROL ACTIVITY RUNNING COPY K,Y CURRENT STACK POINTER ADDRESS COPY STK:X(Y),X RESTORE BASE ADDRESS OF CIB COPY CI:DLS(X),Q DEVICE AND LINE STATE FLAGS TBIT DLS:LCA,Q LI NE CONTROL ACTIVE FLAG JT OV,PC03 JUMP IF LINE CONTROL ACTIVITY RUNNING SBIT DLS:LCA,Q SET FLAG FOR LINE CONTROL ACTIVITY RUNNING COPY Q,CI:DLS(X) R:BGIN B:LINEC START A LINE CONTROL ACTIVITY PC03 EQU $ RESTORE NORMAL PRIORITY AND RETURN COPY A,X ENTERING PRIORITY LEVEL FOR ACTIVITY JSK R:SPRI RESTORE NORMAL PRIORITY FOR CALLER POP RESTORE CALLING REGISTERS RSK  RETURN TO CALLER SPACE 2 END C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C CIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII TITL SYNCHRONOUS HANDLER LINE CONTROL TASK (93438-11/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:WAIT EXTR R:SPRI EXTR RLS:EVNT EXTR GET:REQ EXTR PUT:REQ EXTR RET:REQ EXTR RET:REQQ EXTR ALOC:EPT EXTR RELS:EPT EXTR RELS:LCB EXTR TERM:ACT EXTR TMR:BGNU EXTR TMR:ENDU EXTR CHK:QUE EXTR REQ:EXU EXTR MODE:SET EXTR CHK:WAIT EXTR CND:EVNT EXTR B:DEVCC EXTR B:XMITC EXTR B:RECVC SEXT B:LINES * * EXTERNAL DEFINITIONS * NAM B:LINEC * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:1 NAM G:1 ENDC TITL LINE CONTROL STATE TABLES * * EVENT VERIFICATION TABLE GENERATION MACRO * VALID: MACRO M: SET 0 IFT #?>0 V: SET #(1)-E:LINCON BIT NUMBER WITHIN WORD TO SET M: SET 1%V:;M: SET BIT IN MASK IFT #?>1 V: SET #(2)-E:LINCON M: SET 1%V:;M: IFT #?>2 V: SET #(3)-E:LINCON M: SET 1%V:;M: IFT #?>3 V: SET #(4)-E:LINCON M: SET 1%V:;M: IFT #?>4 V: SET #(5)-E:LINCON M: SET 1%V:;M: IFT #?>5 V: SET #(6)-E:LINCON M: SET 1%V:;M: IFT #?>6 V: SET #(7)-E:LINCON M: SET 1%V:;M: IFT #?>7 V: SET #(8)-E:LINCON M: SET 1%V:;M: ENDC ENDC ENDC ENDC ENDC ENDC ENDC ENDC WORD M: GENERATE MASK WORD ENDM SPACE 2 * * EVENT VERIFICATION TABLE * VAL:EVNT EQU $ VALID: VALID: E:DEVTRM,E:DEVOPR VALID: E:LINCON,E:LINDCN,E:RCVTRM,E:RCVOPR VALID: E:LINCON,E:LINDCN,E:XMTTRM,E:XMTOPR VALID: E:LINCON,E:LINDCN VALID: E:LINDCN,E:PROTRM,E:PROOPR,E:PRODSC,E:PROINP,E:PROINF VALID: E:LINDCN,E:PROTRM,E:PROOPR,E:PRODSC,E:PROINP,E:PROINF VALID: E:LINCON,E:LINDCN,E:XMTTRM VALID: E:LINCON,E:LINDCN,E:RCVTRM VALID: E:LINCON,E:LINDCN,E:DEVTRM TITL SYSTEM REQUEST CONTROL BLOCKS FOR THE LINE CONTROL TASK * * LINE CONTROL TASK DEFINITION BLOCK * TDB:A C:LINEC,LINE:CTL,SIZE:CST,,STACK:LC,,4096 * * LINE CONTROL TASK BEGIN BLOCK * BGIN:A B:LINEC,C:LINEC,:7EFF TITL INIT:TBL - INITIALIZE HANDLER TABLES * * INIT:TBL * * PROCEDURE INITIALIZES THE CONTROLLER INFORMATION BLOCK AND CONTROL * STATE TABLE. * * CALL PARAMETERS: * X - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * INIT:TBL EQU $ COPY X,CS:CIB(Y) SAVE BASE ADDRESS OF CIB COPY =0,A COPY A,CS:CET(Y) SET NULL LINE CONTROL ACTIVITY EPT ADDRESS COPY A,CS:SET(Y) SET NULL STATISTICS ACTIVITY EPT ADDRESS COPY A,CS:TCB(Y) SET NULL STATISTICS ACTIVITY TCB ADDRESS COPY A,CS:CCF(Y) SET ALL CONTROL CONDITION FLAGS OFF COPY A,CS:PRH(Y) SET NULL PENDING REQUEST QUEUE POINTERS COPY A,CS:PRT(Y) COPY A,CS:WRH(Y)  SET NULL WAITING REQUEST QUEUE POINTERS COPY A,CS:WRT(Y) COPY A,CI:FCS(X) INITIALIZE FRAME CHECK SEQUENCE ERROR COUNT COPY A,CI:RXM(X) INITIALIZE RETRANSMISSION COUNT COPY A,CI:OVR(X) INITIALIZE RECEIVE OVERRUN ERROR COUNT COPY A,CI:MCS(X) INITIALIZE MODEM CONTROL SIGNAL ERROR COUNT COPY A,CI:HDW(X) INITIALIZE CONTROLLER ERROR COUNT COPY A,CI:AFR(X) INITIALIZE RECEIVE SIDE TOTAL UTILIZATION COPY A,CI:AFT(X) INITIALIZE TRANSMIT SIDE TOTAL UTILIZATION COPY A,CI:UFR(X) INITIALIZE RECEIVE SIDE DATA UTILIZATION COPY A,CI:UFT(X) INITIALIZE TRANSMIT SIDE DATA UTILIZATION COPY A,CI:PIB(X) SET NULL ACTIVE PIB ADDRESS COPY A,CI:ADR(X) SET NULL ACTIVE STATION ADDRESS COPY A,CI:LCP(X) SET NULL LINE CONTROL EPT ADDRESS COPY A,CI:DCP(X) SET NULL DEVICE CONTROL EPT ADDRESS COPY A,CI:RCP(X) SET NULL RECEIVE CONTROL EPT ADDRESS COPY A,CI:RDP(X) SET NULL RECEIVE DRIVER EPT ADDRESS COPY A,CI:TCP(X) SET NULL TRANSMIT CONTROL EPT ADDRESS COPY A,CI:TDP(X) SET NULL TRANSMIT DRIVER EPT ADDRESS COPY A,CI:LCA(X) INITIALIZE COUNT OF PROTOCOL LINKS ACTIVE COPY A,CI:APL(X) SET NULL ACTIVE PROTOCOL LINK LIST POINTER COPY A,CI:AEP(X) SET NULL ACTIVE EVENT PROCESSOR LIST RSK RETURN TO CALLER TITL INIT:MEM - INITIALIZE EVENT INFORMATION BLOCK MEMORY POOL * *  INIT:MEM * * PROCEDURE ALLOCATES A BLOCK OF MEMORY SUFFICIENT FOR THE REQUIRED * NUMBER OF EVENT INFORMATION BLOCKS, BREAKS THE MEMORY BLOCK UP, * CHAINS THE INDIVIDUAL EVENT INFORMATION BLOCKS ON THE AVAILABLE * LIST IN THE CONTROLLER INFORMATION BLOCK. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS AN ERROR RETURN, * INDICATING THAT SUFFICIENT MEMORY WAS NOT AVAILABLE; RETURN TO * CALL+2 IS NORMAL. * INIT:MEM EQU $ COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:MLA(X),Q MAXIMUM NUMBER OF PROTOCOL LINKS ACTIVE SHIFT Q,LO,1 MULTIPLY BY THREE FOR THRESHOLD COUNT ADD CI:MLA(X),Q COPY Q,CI:AET(X) SAVE AVAILABLE BLOCK THRESHOLD VALUE ADD =AVAL:FRM,Q COMPUTE TOTAL NUMBER OF BLOCKS TO ALLOCATE COPY Q,CI:AEC(X) SET COUNT ASSUMING SPACE AVAILABLE COPY =0,A SET UP FOR MULTIPLICATION MUL =SIZE:EIB,AQ COMPUTE NUMBER OF WORDS OF MEMORY REQUIRED COPY Q,X ALLOCATE BLOCK OF REQUIRED SIZE R:ABUF 0(X) JEQ X,IM02 JUMP IF NO MEMORY AVAILABLE COPY X,A SAVE BASE ADDRESS OF BLOCK ALLOCATED COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY A,CI:ESB(X) SAVE BASE ADDRESS OF EVENT SPACE COPY A,CI:ALH(X) SAVE ADDRESS OF FIRST EIB ON AVAILABLE LIST COPY CI:AEC(X),Q NUMBER OF EIB'S ALLOCATED SUB =2,Q SUBTRACT ONE FOR LOOP BIAS AND ONE FOR LAST IM01 EQU $ LOOP FOR ADDING AN EIB TO THE LIST COPY A,X COPY ADDRESS OF LAST EIB ADD =SIZE:EIB,A SET ADDRESS OF NEXT EIB IN LIST COPY A,EI:NXT(X) SET POINTER IN LAST EIB TO NEXT JNED Q,IM01 LOOP UNTIL AT LAST EIB COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY A,CI:ALT(X) SAVE ADDRESS OF LAST EIB ON AVAILABLE LIST COPY A,X COPY ADDRESS OF LAST EIB COPY =0,A SET NULL LINKAGE FROM LAST ON LIST COPY A,EI:NXT(X) COPY K,X CURRENT STACK POINTER VALUE IMS 0(X) SET RETURN ADDRESS FOR SUCCESSFUL COMPLETION RSK RETURN TO CALLER IM02 EQU $ UNABLE TO ALLOCATE MEMORY REQUIRED COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY =0,A COPY A,CI:ALH(X) SET NULL AVAILABLE L IST START COPY A,CI:ALT(X) SET NULL AVAILABLE LIST TAIL COPY A,CI:AEC(X) SET ZERO BLOCKS AVAILABLE ON LIST RSK TAKE ERROR RETURN TO CALLER TITL REQ:PROC - PROCESS CONTROL REQUEST * * REQ:PROC * * PROCEDURE PERFORMS PROCESSING OF A USER CONTROL REQUEST. IF THE * CURRENT LINE CONTROL STATE DOES NOT ALLOW FOR IMMEDIATE PROCESSING * OF THE REQUEST, IT IS ADDED TO THE PENDING REQUEST QUEUE. ONCE * PROCESSING OF A REQUEST IS STARTED BY THIS PROCEDURE, THE REQUEST * IS ADDED TO THE WAITING REQUEST QUEUE UNTIL NOTIFICATION OF THE * COMPLETION OF THE REQUEST IS RECEIVED. * * CALL PARAMETERS: * A - BASE ADDRESS OF CONTROL REQUEST BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * REQ:PROC EQU $ COPY CS:STA(Y),Q LINE CONTROL STATE CLSN Q,=STA:OP SCAN ONLY WAITING LIST IF LINE OPERATIONAL JMP RP01 COPY A,X COPY BASE ADDRESS OF CONTROL REQUEST COPY Y,Q SET ADDRESS OF PENDING QUEUE CONTROL BLOCK ADD =CS:PRH,Q JSK CHK:QUE CHECK REQUEST AGAINST THOSE IN PENDING QUEUE JMP RP03 COPY CR:CRC(X),Q CONTROL REQUEST CODE CLSN Q,=CRC:ABRT CHECK FOR AN ABORT REQUEST JMP RP02 COPY Y,X SET ADDRESS OF PENDING QUEUE CONTROL BLCOK ADD =CS:PRH,X JSK PUT:REQ ADD THIS REQUEST TO QUEUE OF PENDING REQUESTS JNE A,RP04 JUMP UNLESS REQUEST IS FIRST ON QUEUE COPY CS:STA(Y),A LINE CONTROL STATE SUB =STA:INIT,A CHECK IF IN INITIALIZATION STATE JNE A,RP04 JUMP IF IN ANY OTHER STATE COPY CS:PRH(Y),X BASE ADDRESS OF CONTROL REQUEST CRB COPY CR:DIB(X),X BASE ADDRESS OF ASSOCIATED DIB COPY DI:ADR(X),A STATION ADDRESSES COPY DI:PIB(X),Q BASE ADDRESS OF PIB USED COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY Q,CI:PIB(X) SET ADDRESS OF ACTIVE PIB AND =:FF,A MASK LOCAL STATION ADDRESS COPY A,CI:ADR(X) SET ADDRESS OF ACTIVE STATION RSK RETURN TO CALLER RP01 EQU $ CHECK REQUEST AGAINST WAITING QUEUE COPY A,X COPY BASE ADDRESS OF CONTROL REQUEST COPY Y,Q SET ADDRESS OF WAITING QUEUE CONTROL BLOCK ADD =CS:WRH,Q JSK CHK:QUE CHECK REQUEST AGAINST WAITING QUEUE JMP RP03 JUST RETURN WITH ERROR CODE PRESENT COPY CR:CRC(X),Q CONTROL REQUEST CODE CLSN Q,=CRC:ABRT JUST TERMINATE IF ABORT OPERATION JMP RP02 JSK REQ:EXU EXECUTE USER CONTROL REQUEST JMP RP03 JUST RETURN WITH ERROR CODE PRESENT COPY Y,X SET ADDRESS OF WAITING QUEUE POINTER BLOCK ADD =CS:WRH,X JSK PUT:REQ ADD THIS CONTROL REQUEST TO WAITING QUEUE RSK RETURN TO CALLER RP02 EQU $ TERMINATE REQUEST WITH NORMAL COMPLETION CODE COPY =TRM:NORM,Q SET TERMINATION CODE FOR NORMAL COMPLETION RP03 EQU $ TERMINATE REQUEST WITH SPECIFIED CODE JSK RET:REQ TERMINATE REQUEST AND RETURN TO USER RP04 EQU $ RETURN TO CALLER RSK TITL EVN:PROC - PROCESS RECEIVED EVENT * * EVN:PROC * * PROCEDURE PROCESSES A RECEIVED EVENT, CHECKING THAT THE TYPE OF *  EVENT RECEIVED IS VALID IN THE CURRENT LINE CONTROL STATE AND * PERFORMING WHATEVER ACTIONS ARE APPROPRIATE FOR THE EVENT. * * CALL PARAMETERS: * A - EVENT TYPE CODE * X - BASE ADDRESS OF EVENT INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS AN ERROR RETURN, * INDICATING THAT THE EVENT RECEIVED IS NOT VALID IN THE CURRENT * LINE CONTROL STATE; RETURN TO CALL+2 IS NORMAL. * EVN:PROC EQU $ PUSH  STATUS: SAVE ENTERING REGISTERS ON STACK CSK A,=E:LINCON VALIDATE EVENT TYPE CODE LOWER LIMIT JMP EP01 ERROR RETURN IF INVALID FOR ALL STATES NOP COPY =E:PROINF,Q SET MAXIMUM EVENT TYPE CODE VALUE CSK Q,A VALIDATE EVENT TYPE CODE UPPER LIMIT JMP EP01 ERROR RETURN IF INVALID FOR ALL STATES NOP COPY =VAL:EVNT,X SET BASE ADDRESS OF VALIDATION TABLE COPY *CS:STA(X,Y),Q MASK FOR VALID EVENT TYPE CODES SUB =E:LINCON,A CONVERT EVENT TO RANGE STARTING AT ZERO SHIFT A,LO,4 POSITION IN SHIFT INSTRUCTION SKELETON XNX A INDEX SHIFT BY CONVERTED EVENT TYPE CODE SHIFT Q,RO,1 ENABLING BIT FOR EVENT TO OVERFLOW JF OV,EP01 TAKE ERROR RETURN IF NOT ENABLED COPY K,X CURRENT STACK POINTER ADDRESS COPY STK:X(X),X BASE ADDRESS OF EIB SHIFT A,RO,4 RESTORE POSITION OF CONVERTED TYPE CODE XNX A USE AS INDEX FOR FANOUT JSK *FAN:OUT INVOKE APPROPRIATE PROCEDURE FOR PROCESSING COPY K,X CURRENT STACK POINTER ADDRESS IMS STK:NUM(X) INCREMENT RETURN ADDRESS FOR NORMAL RETURN EP01 EQU $ ERROR RETURN TO CALLER POP  RESTORE ENTERING REGISTERS RSK RETURN TO CALLER SPACE 2 * * FANOUT TABLE FOR RECEIVED EVENT PROCESSING * FAN:OUT EQU $ WORD PRC:CLC COMMUNICATIONS LINE CONNECTED WORD PRC:CLD COMMUNICATIONS LINE DISCONNECTED WORD PRC:PROT PROTOCOL COMPONENT TERMINATION WORD PRC:RCVT RECEIVE COMPONENT TERMINATION WORD PRC:XMTT TRANSMIT COMPONENT TERMINATION WORD PRC:DEVT DEVICE COMPONENT TERMINATION WORD PRC:PROO PROTOCOL COMPONENT OPERATIONAL WORD PRC:RCVO RECEIVE COMPONENT OPERATIONAL WORD PRC:XMTO TRANSMIT COMPONENT OPERATIONAL WORD PRC:DEVO DEVICE COMPONENT OPERATIONAL WORD PRC:DISC PROTOCOL ENTRY TO DISCONNECTED MODE WORD PRC:INP PROTOCOL ENTRY TO INITIALIZATION PRIMARY MODE WORD PRC:INF PROTOCOL ENTRY TO INFORMATION TRANSFER MODE SPACE 2 * LPOOL TITL PROCEDURES FOR PROCESSING CHANGES OF STATE * * INITIALIZATION STATE ENTRY * ENT:INIT EQU $ COPY =STA:INIT,A SET LINE CONTROL STATE CODE COPY A,CS:STA(Y) SET NEW LINE CONTROL STATE COPY CS:CCF(Y),A CONTROL CONDITION FLAGS BITS:OFF A,CCF:DOP,CCF:ROP,CCF:TOP,CCF:CON,CCF:ABO RESET FLAGS USED COPY A,CS:CCF(Y) RSK RETURN TO CALLER SPACE 2 * * WAITING FOR DEVICE COMPONENT ACTIVATION STATE ENTRY * ENT:WDCA EQU $ COPY =STA:WDCA,A SET NEW LINE CONTROL STATE COPY A,CS:STA(Y)  COPY CS:CIB(Y),A BASE ADDRESS OF CIB R:BGIN B:DEVCC START A DEVICE CONTROL ACTIVITY RSK RETURN TO CALLER SPACE 2 * * WAITING FOR RECEIVE COMPONENT ACTIVATION STATE ENTRY * ENT:WRCA EQU $ COPY =STA:WRCA,A SET NEW LINE CONTROL STATE COPY A,CS:STA(Y) COPY CS:CIB(Y),A BASE ADDRESS OF CIB R:BGIN B:RECVC START A RECEIVE CONTROL ACTIVITY RSK RETURN TO CALLER SPACE 2 * * WAITING FOR TRANSMIT COMPONENT ACTIVATION STATE ENTRY * ENT:WTCA EQU $ COPY =STA:WTCA,A SET NEW LINE CONTROL STATE COPY A,CS:STA(Y) COPY CS:CIB(Y),A BASE ADDRESS OF CIB R:BGIN B:XMITC START A TRANSMIT CONTROL ACTIVITY RSK RETURN TO CALLER SPACE 2 * * WAITING FOR COMMUNICATIONS LINE CONNECTION STATE ENTRY * ENT:WCLC EQU $ COPY =STA:WCLC,A SET NEW LINE CONTROL STATE COPY A,CS:STA(Y) RSK RETURN TO CALLER SPACE 2 * * OPERATIONAL STATE ENTRY * ENT:OP EQU $ COPY =STA:OP,A SET NEW LINE CONTROL STATE COPY A,CS:STA(Y) EO01 EQU $ LOOP FOR PROCESSING PENDING REQUESTS COPY Y,X SET ADDRESS   OF PENDING QUEUE CONTROL BLOCK ADD =CS:PRH,X JSK GET:REQ GET A CONTROL REQUEST FROM THE QUEUE JNE A,$+2 CONTINUE IF QUEUE NOT EMPTY RSK RETURN TO CALLER JSK REQ:PROC PROCESS CONTROL REQUEST JMP EO01 SPACE 2 * * INOPERATIONAL STATE ENTRY * ENT:INOP EQU $ COPY =STA:INOP,A SET NEW LINE CONTROL STATE COPY A,CS:STA(Y) COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:APL(X),A BASE ADDRESS OF FIRST LCB ON LIST JEQ A,EI05 JUMP IF NONE PRESENT ON LIST EI01 EQU $ LOOP FOR TERMINATING ACTIVE PROTOCOL HANDLERS COPY A,X BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB COPY DI:PLS(X),Q PROTOCOL LINK STATUS TBIT PLS:PSF,Q PRIMARY STATION FUNCTION ACTIVE FLAG JF OV,EI02 JUMP IF PRIMARY STATION FUNCTION INACTIVE BITS:EXT Q,PLS:PSS EXTRACT PRIMARY STATION FUNCTION PROTOCOL STATE CLSN Q,=PST:INIT CHECK FOR INITIALIZATION STATE JMP EI04 WAIT UNTIL INITIALIZATION COMPLETES SUB =PST:TERM,Q CHECK FOR TERMINATION STATE JEQ Q,EI04 WAIT UNTIL TERMINATION COMPLETES JMP EI03 SIGNAL TERMINATION TO PROTOCOL HANDLER EI02 EQU $ REQUEST SECONDARY STATION FUNCTION TERMINATION TBIT PLS:SSF,Q SECONDARY STATION FUNCTION ACTIVE FLAG JF OV,EI04 JUMP IF SECONDARY STATION FUNCTION INACTIVE BITS:EXT Q,PLS:SSS EXTRACT SECONDARY STATION FUNCTION PROTOCOL STATE CLSN Q,=PST:INIT CHECK FOR INITIALIZATION STATE JMP EI04 WAIT UNTIL INITIALIZATION COMPLETES CLSN Q,=PST:TERM CHECK FOR TERMINATION STATE JMP EI04 WAIT UNTIL TERMINATION COMPLETES EI03 EQU $ SIGNAL TERMINATION TO PROTOCOL HANDLER ACTIVITY COPY A,X BASE ADDRESS OF LCB COPY LC:EPT(X),X BASE ADDRESS OF PROTOCOL HANDLER ACTIVITY EPT JSK TERM:ACT FLAG PROTOCOL HANDLER TERMINATION AND SIGNAL EI04 EQU $ REPEAT LOOP FOR ALL ACTIVE LINK CONTROL BLOCKS COPY A,X BASE ADDRESS OF LCB COPY LC:NXT(X),A BASE ADDRESS OF NEXT ACTIVE LCB JNE A,EI01 LOOP IF NOT AT END OF LIST EI05 EQU $ TERMINATE ALL WAITING CONTROL REQUESTS COPY Y,X SET ADDRESS OF WAITING QUEUE CONTROL BLOCK ADD =CS:WRH,X JSK RET:REQQ TERMINATE ALL WAITING CONTROL REQUESTS RSK SPACE 2 * * WAITING FOR TRANSMIT COMPONENT TERMINATION STATE ENTRY * ENT:WTCT EQU $ COPY =STA:WTCT,A SET NEW LINE CONTROL STATE COPY A,CS:STA(Y) COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:TCP(X),X BASE ADDRESS OF TRANSMIT CONTROL EPT JSK TERM:ACT SIGNAL TERMINATION OF ACTIVITY RSK RETURN TO CALLER SPACE 2 * * WAITING FOR RECEIVE COMPONENT TERMINATION STATE ENTRY * ENT:WRCT EQU $ COPY =STA:WRCT,A SET NEW LINE CONTROL STATE COPY A,CS:STA(Y) COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:RCP(X),X BASE ADDRESS OF RECEIVE CONTROL EPT JSK TERM:ACT SIGNAL TERMINATION OF ACTIVITY RSK RETURN TO CALLER SPACE 2 * * WAITING FOR DEVICE COMPONENT TERMINATION STATE ENTRY * ENT:WDCT EQU $ COPY =STA:WDCT,A SET NEW LINE CONTROL STATE COPY A,CS:STA(Y) COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DCP(X),X BASE ADDRESS OF DEVICE CONTROL EPT JSK TERM:ACT SIGNAL TERMINATION OF ACTIVITY RSK RETURN TO CALLER * LPOOL TITL PROCEDURES FOR PROCESSING OF RECEIVED EVENTS * * COMMUNICATIONS LINE CONNECTED EVENT * PRC:CLC EQU $ COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DLS(X),A DEVICE AND LINE STATE FLAGS BITS:ON A,DLS:CON SET FLAG FOR CONNECTED COPY A,CI:DLS(X) COPY CS:CCF(Y),A CONTROL CONDITION FLAGS BITS:ON A,CCF:CON SET COMMUNICATIO  NS LINE CONNECTED FLAG COPY A,CS:CCF(Y) COPY CS:STA(Y),A LINE CONTROL STATE CODE CLSN A,=STA:WCLC CHECK IF WAITING FOR CONNECTION STATE JSK ENT:OP ENTER THE OPERATIONAL STATE RSK RETURN TO CALLER SPACE 2 * * COMMUNICATIONS LINE DISCONNECTED EVENT * PRC:CLD EQU $ COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DLS(X),A DEVICE AND LINE STATE FLAGS BITS:OFF A,DLS:CON TURN OFF CONNECTED LINE FLAG COPY A,CI:DLS(X) COPY CS:CCF(Y),A CONTROL CONDITION FLAGS BITS:OFF A,CCF:CON RESET COMMUNICATIONS LINE CONNECTED FLAG BITS:ON A,CCF:ABO SET ABORT INITIALIZATION FLAG COPY A,CS:CCF(Y) COPY CS:STA(Y),A LINE CONTROL STATE CODE CLSN A,=STA:OP CHECK IF OPERATIONAL STATE JMP ENT:INOP ENTER INOPERATIONAL STATE IF SO RSK JUST RETURN TO CALLER OTHERWISE SPACE 2 * * RECEIVE COMPONENT OPERATIONAL EVENT * PRC:RCVO EQU $ COPY CS:CCF(Y),A CONTROL CONDITION FLAGS BITS:ON A,CCF:ROP SET RECEIVE COMPONENT OPERATIONAL FLAG COPY A,CS:CCF(Y) TBIT CCF:ABO,A ABORT INITIALIZATION FLAG JT OV,$+2 JUMP IF ABORTING INITIALIZATION JMP ENT:WTCA ENTER WAITING FOR TRANSMIT ACTIVATION STATE JMP ENT:WRCT ENTER WAITING FOR RECEIVE TERMINATION STATE SPACE 2 * * TRANSMIT COMPONENT OPERATIONAL EVENT * PRC:XMTO EQU $ COPY CS:CCF(Y),A CONTROL CONDITION FLAGS BITS:ON A,CCF:TOP SET TRANSMIT COMPONENT OPERATIONAL FLAG COPY A,CS:CCF(Y) TBIT CCF:ABO,A ABORT INITIALIZATION FLAG JF OV,$+2 JUMP UNLESS ABORTING INITIALIZATION JMP ENT:WTCT ENTER WAITING FOR TRANSMIT TERMINATION STATE TBIT CCF:CON,A COMMUNICATIONS LINE CONNECTED FLAG JF OV,$+2 JUMP IF LINE NOT YET CONNECTED JMP ENT:OP ENTER OPERATIONAL STATE JMP ENT:WCLC ENTER WAITING FOR LINE CONNECTION STATE SPACE 2 * * DEVICE COMPONENT OPERATIONAL EVENT * PRC:DEVO EQU $ COPY CS:CCF(Y),A CONTROL CONDITION FLAGS BITS:ON A,CCF:DOP SET DEVICE COMPONENT OPERATIONAL FLAG COPY A,CS:CCF(Y) JMP ENT:WRCA ENTER WAITING FOR RECEIVE ACTIVATION STATE SPACE 2 * * PROTOCOL COMPONENT OPERATIONAL EVENT * PRC:PROO EQU $ COPY CS:STA(Y),A LINE CONTROL STATE CLSN A,=STA:INOP CHECK FOR INOPERATIONAL STATE JMP PP01 TERMINATE PROTOCOL COMPONENT OPERATION IF SO COPY =PST:DISC,A SET CODE FOR PROTOCOL IN DISCONNECTED STATE JSK MODE:SET SET NEW PROTOCOL STATE RSK JUST RETURN IF STATION FUNCTION STATES DIFFER COPY EI:LCB(X),X BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB JSK CHK:WAIT CHECK WAITING REQUESTS AND TERMINATE IF COMPLETE JEQ X,PP02 JUST RETURN IF NONE NOW WAITING COPY CR:CRC(X),Q CONTROL REQUEST CODE CLSN Q,=CRC:INP CHECK IF INITIALIZATION PRIMARY STATE REQUEST COPY =E:ENTINP,A SET EVENT CODE FOR INITIALIZATION PRIMARY STATE CLSN Q,=CRC:INF CHECK IF INFORMATION TRANSFER STATE REQUEST COPY =E:ENTINF,A SET EVENT CODE FOR INFORMATION TRANSFER STATE COPY CR:DIB(X),X BASE ADDRESS OF DIB JSK CND:EVNT GENERATE EVENT TO REQUEST CHANGE OF STATE ERR:D $+1 TAKE ERROR EXIT TO DEBUG IF PRESENT RSK RETURN TO CALLER PP01 EQU $ TERMINATE OPERATION OF PROTOCOL HANDLER ACTIVITY COPY EI:ECI(X),A EVENT CONTROL INFORMATION COPY EI:LCB(X),X BASE ADDRESS OF LCB COPY LC:EPT(X),Q BASE ADDRESS OF PROTOCOL HANDLER ACTIVITY EPT JSK TERM:ACT TERMINATE THE PROTOCOL HANDLER ACTIVITY PP02 EQU $ JUST EXIT RSK RETURN TO CALLER SPACE 2 * * PROTOCOL ENTERED DISCONNECTED MODE EVENT * PRC:D  ISC EQU $ COPY =PST:DISC,A SET CODE FOR DISCONNECTED MODE JSK MODE:SET SET NEW STATION STATE IN DIB RSK JUST RETURN IF STATIONS INCONSISTENT COPY EI:LCB(X),X BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB JSK CHK:WAIT TERMINATE WAITING REQUEST IF STATE MATCHES RSK RETURN TO CALLER SPACE 2 * * PROTOCOL ENTERED INITIALIZATION PRIMARY MODE EVENT * PRC:INP EQU $ COPY =PST:INP,A SET CODE FOR INITIALIZATION PRIMARY MODE JSK MODE:SET SET NEW STATION STATE IN DIB RSK  JUST RETURN IF STATIONS INCONSISTENT COPY EI:LCB(X),X BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB JSK CHK:WAIT TERMINATE WAITING REQUEST IF STATE MATCHES RSK RETURN TO CALLER SPACE 2 * * PROTOCOL ENTERED INFORMATION TRANSFER MODE EVENT * PRC:INF EQU $ COPY =PST:INF,A SET CODE FOR INFORMATION TRANSFER MODE JSK MODE:SET SET NEW STATION STATE IN DIB RSK JUST RETURN IF STATIONS INCONSISTENT COPY EI:LCB(X),X BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB JSK CHK:WAIT TERMINATE WAITING REQUEST IF STATE MATCHES RSK RETURN TO CALLER SPACE 2 * * PROTOCOL COMPONENT TERMINATION EVENT * PRC:PROT EQU $ COPY =PST:IDLE,A SET CODE FOR PROCESSING IDLE STATE JSK MODE:SET SET NEW STATION STATE IN DIB  RSK JUST RETURN IF STATIONS INCONSISTENT COPY EI:LCB(X),X BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB COPY X,Q SAVE A COPY JSK CHK:WAIT TERMINATE WAITING REQUEST IF STATE MATCHES COPY Q,X BASE ADDRESS OF DIB COPY Q,A SAVE ANOTHER COPY ADD =DI:RQH,X SET ADDRESS OF READ QUEUE POINTERS COPY =TRM:INOP,Q SET TERMINATION CODE FOR LINK INOPERATIVE JSK RET:REQQ RETURN ALL READ REQUESTS TO USER COPY A,X BASE ADDRESS OF DIB ADD =DI:WQH,X SET ADDRESS OF WRITE QUEUE POINTERS JSK RET:REQQ RETURN ALL WRITE REQUESTS TO USER COPY A,X BASE ADDRESS OF DIB COPY DI:LCB(X),X BASE ADDRESS OF LCB JSK RELS:LCB RETURN MEMORY USED FOR LCB TO SYSTEM COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:LCA(X),A NUMBER OF PROTOCOL LINKS CURRENTLY ACTIVE SUB =1,A DECREMENT COUNT OF LINKS ACTIVE COPY A,CI:LCA(X) RSK RETURN TO CALLER SPACE 2 * * TRANSMIT COMPONENT TERMINATION EVENT * PRC:XMTT EQU $ COPY CS:CCF(Y),A CONTROL CONDITION FLAGS BITS:OFF A,CCF:TOP RESET TRANSMIT COMPONENT OPERATIONAL FLAG COPY A,CS:CCF(Y) JMP ENT:WRCT ENTER WAITING FOR RECEIVE TERMINATION STATE SPACE 2 * * RECEIVE COMPONENT TERMINATION EVENT * PRC:RCVT EQU $ COPY CS:CCF(Y),A CONTROL CONDITION FLAGS BITS:OFF A,CCF:ROP RESET RECEIVE COMPONENT OPERATIONAL FLAG COPY A,CS:CCF(Y) TBIT CCF:DOP,A DEVICE COMPONENT OPERATIONAL FLAG JF OV,$+2 JUMP IF DEVICE COMPONENT INOPERATIVE JMP ENT:WDCT ENTER WAITING FOR DEVICE TERMINATION STATE JMP ENT:INIT ENTER INITIALIZATION STATE SPACE 2 * * DEVICE COMPONENT TERMINATION EVENT * PRC:DEVT EQU $ COPY CS:CCF(Y),A CONTROL CONDITION FLAGS BITS:OFF A,CCF:DOP RESET DEVICE COMPONENT OPERATIONAL FLAG COPY A,CS:CCF(Y) COPY CS:STA(Y),A LINE CONTROL STATE CLSN A,=STA:WDCT CHECK IF WAITING FOR DEVICE TERMINATION JMP ENT:INIT ENTER INITIALIZATION STATE RSK RETURN TO CALLER * LPOOL TITL LINE:CTL - LINE CONTROL TASK MAIN PROGRAM * * LINE:CTL * * MAIN PROGRAM PROCESSES USER CONTROL REQUESTS TO INITIATE AND * TERMINATE PROCESSING, AND TO CHANGE THE PROTO  COL STATE, OF THE * PROTOCOL LINKS USING A PARTICULAR COMMUNICATIONS LINE. INITIATES * AND TERMINATES ALL OTHER ACTIVITIES IN THE DRIVER, EITHER DIRECTLY * OR INDIRECTLY. * * START PARAMETERS: * X - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * Y - BASE ADDRESS OF CONTROL STATE TABLE * LINE:CTL EQU $ JSK INIT:TBL INITIALIZE TABLES FOR OPERATION COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:BPL(X),X BASE PRIORITY LEVEL FOR LINE JSK R:SPRI SET PRIORITY LEVEL TO SPECIFIED VALUE JSK ALOC:EPT ALLOCATE AND INITIALIZE EPT FOR ACTIVITY JEQ X,LC08 JUMP IF UNABLE TO ALLOCATE EPT COPY X,CS:CET(Y) SAVE BASE ADDRESS OF EPT COPY X,A ALSO SAVE ADDRESS IN CIB COPY CS:CIB(Y),X COPY A,CI:LCP(X) ADD =EP:SEM,A COMPUTE ADDRESS OF ACTIVITY SEMAPHORE COPY A,CI:LMS(X) SAVE AS LINE MASTER SEMAPHORE ADDRESS JSK INIT:MEM ALLOCATE MEMORY AND INITIALIZE EIB LIST JMP LC07 JUMP IF UNABLE TO ALLOCATE EIB MEMORY JSK TMR:BGNU BEGIN USAGE OF COMMUNICATIONS TIMER JSK ENT:INIT ENTER INITIALIZATION LINE CONTROL STATE LC01 EQU $ MAIN LOOP OF LINE CONTROL TASK COPY CS:CET(Y),X BASE ADDRESS OF EPT COPY EP:EQH(X),X BASE ADDRESS OF FIRST EIB ON QUEUE JEQ X,LC02 JUMP IF NO EVENTS PRESENT ON QUEUE COPY EI:ECI(X),A EVENT CONTROL INFORMATION BITS:EXT A,ECI:TYP EXTRACT EVENT TYPE CODE FIELD JSK EVN:PROC PROCESS RECEIVED EVENT ERR:D $+1 BAD EVENT CODE EXITS TO DEBUG COPY CS:CET(Y),X BASE ADDRESS OF EPT JSK RLS:EVNT RELEASE FIRST EVENT ON QUEUE JMP LC01 LOOP TO CHECK FOR OTHER EVENTS PRESENT ON QUEUE LC02 EQU $ PROCESS USER CONTROL REQUESTS COPY CS:CIB(Y),X BASE ADDRESS OF CIB ADD =CI:CRH,X SET ADDRESS OF POINTER BLOCK FOR QUEUE JSK GET:REQ GET FIRST CONTROL REQUEST FROM QUEUE JEQ A,LC03 JUMP IF NO REQUESTS PRESENT JSK REQ:PROC PROCESS CONTROL REQUEST JMP LC02 LC03 EQU $ CHECK FOR IDLE TERMINATION COPY CS:STA(Y),A LINE CONTROL STATE SUB =STA:INIT,A JUMP UNLESS IN INITIALIZATION STATE JNE A,LC04 COPY CS:PRH(Y),A BASE ADDRESS OF FIRST PENDING REQUEST JEQ A,LC06 EXIT LOOP AND TERMINATE IF NONE PENDING JSK ENT:WDCA BEGIN ACTIVATION STATE SEQUENCE LC04 EQU $ CHECK FOR LINE OPERATIONAL BUT INACTIVE COPY CS:STA(Y),A LINE CONTROL STATE SUB =STA:OP,A JUMP UNLESS IN OPERATIONAL STATE JNE A,LC05 COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:LCA(X),A NUMBER OF PROTOCOL LINKS NOW ACTIVE JNE A,LC05 JUMP IF ANY LINKS ARE ACTIVE COPY CS:PRH(Y),A HEAD OF PENDING REQUEST QUEUE JNE A,LC05 JUMP IF ANY REQUESTS ARE PENDING COPY CS:WRH(Y),A HEAD OF WAITING REQUEST QUEUE JNE A,LC05 JUMP IF ANY REQUESTS ARE WAITING JSK ENT:WTCT BEGIN SHUT DOWN WITH TRANSMIT COMPONENT LC05 EQU $ WAIT FOR A SIGNAL BEFORE REPEATING LOOP COPY CS:CET(Y),X BASE ADDRESS OF ACTIVITY EPT ADD =EP:SEM,X SET ADDRESS OF ACTIVITY SEMAPHORE JSK R:WAIT WAIT FOR A SIGNAL JMP LC01 LC06 EQU $ CLEAN UP FOR TERMINATION OF ACTIVITY JSK TMR:ENDU END USAGE OF COMMUNICATIONS TIMER COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:ESB(X),X EVENT SPACE BASE ADDRESS R:RBUF 0(X) RELEASE ALLOCATED MEMORY BACK TO POOL LC07 EQU $ UNABLE TO ALLOCATE EVENT SPACE MEMORY COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY =0,A SET NULL LINE MASTER SEMAPHORE ADDRESS COPY A,CI:LMS(X) COPY CS:CET(Y),X BASE ADDRESS OF ACTIVITY EPT JSK RELS:EPT RELEASE MEMORY USED LC08 EQU $ UNABLE TO ALLOCATE MEMORY FOR EPT COPY CS:CI  B(Y),X BASE ADDRESS OF CIB COPY CI:DLS(X),A DEVICE AND LINE STATE FLAGS BITS:OFF A,DLS:LCA TURN OFF THE LINE CONTROL ACTIVE FLAG COPY A,CI:DLS(X) R:END TERMINATE LINE CONTROL ACTIVITY SPACE 2 END TITL SYNCHRONOUS HANDLER LINE CONTROL PROCESSING (93438-11/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR INI:EVNT EXTR PRO:EVNT EXTR DEL:REQ EXTR RET:REQ EXTR ALOC:LCB EXTR RELS:LCB EXTR B:PROTO * * EXTERNAL DEFINITIONS * NAM CHK:QUE NAM REQ:EXU NAM MODE:SET NAM CHK:WAIT NAM CND:EVNT * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:2 NAM G:2 ENDC TITL ACT:PROT - ACTIVATE PROTOCOL HANDLER ACTIVITIES * * ACT:PROT * * PROCEDURE BEGINS PROTOCOL PROCESSING FOR THE PROTOCOL LINK * ASSOCIATED WITH A SPECIFIED DEVICE INFORMATION BLOCK. * * CALL PARAMETERS: * X - BASE ADDRESS OF DEVICE INFORMATION BLOCK * * RETURN PARAMETERS: * A,X - DESTROYED * Q - TERMINATION CODE IF ERROR RETURN TAKEN, DESTROYED OTHERWISE * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS AN ERROR RETURN * INDICATING THAT OPERATION OF THE PROTOCOL LINK COULD NOT BE * INITIATED; RETURN TO CALL+2 IS NORMAL. * ACT:PROT EQU $ COPY DI:PLS(X),A PROTOCOL LINK STATE BITS:OFF A,PLS:PSF,PLS:SSF,PLS:SYM,PLS:PSS,PLS:SSS INITIALIZE FIELDS COPY A,DI:PLS(X) COPY X,A COPY BASE ADDRESS OF DIB JSK ALOC:LCB ALLOCATE AND INITIALIZE AN LCB TO USE JEQ X,AP05 JUMP IF UNABLE TO ALLOCATE COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:DLS(X),Q DEVICE AND LINE STATE FLAGS COPY A,X COPY BASE ADDRESS OF DIB COPY DI:PIB(X),X BASE ADDRESS OF PIB COPY PI:LOF(X),X LINK OPTIONS FLAGS EXCH A,X SWAP BACK REGISTERS TO SET UP PARAMETERS TBIT DLS:DED,Q DEDICATED LINE FLAG JF OV,$+2 JUMP IF SWITCHED CONNECTION LINE BITS:ON A,LOF:DED SET DEDICATED LINE FLAG TBIT DLS:MTP,Q MULTIPOINT LINE FLAG JF OV,$+2 JUMP IF POINT-TO-POINT LINE BITS:ON A,LOF:MTP SET MULTIPOINT LINE FLAG TBIT DLS:TWS,Q TWO-WAY SIMULTANEOUS LINE FLAG JF OV,$+2 JUMP IF TWO WAY ALTERNATE LINE BITS:ON A,LOF:TWS SET TWO WAY SIMULTANEOUS LINE FLAG COPY A,Q COPY LINK OPTIONS FLAGS TBIT LOF:AC,A ASYNCHRONOUS COMBINED STATION OPERATION ENABLE JT OV,AP01 JUMP IF ASYNCHRONOUS COMBINED OPERATION PERMITTED BITS:OUT Q,LOF:AP,LOF:NP PRIMARY STATION OPERATION ENABLES JNE Q,AP02 JUMP IF PRIMARY STATION OPERATION PERMITTED COPY A,Q LINK OPTIONS FLAGS BITS:OUT Q,LOF:AS,LOF:NS SECONDARY STATION OPERATION ENABLES JEQ Q,AP06 ERROR IF NO OPERATIONAL MODES PERMITTED BITS:VAL Q,PLS:SSF,PLS:SSS=PST:INIT SET SECONDARY STATION MODE JMP AP03 SAVE STATION TYPE FLAGS IN DIB AP01 EQU $ ASYNCHRONOUS COMBINED OPERATION PERMITTED BITS:OUT Q,LOF:AP,LOF:NP,LOF:AS,LOF:NS ALL OTHER OPERATION ENABLES JNE Q,AP06 ERROR IF CONFLICTING OPERATION MODES PERMITTED BITS:VAL Q,PLS:PSF,PLS:SSF,PLS:PSS=PST:INIT,PLS:SSS=PST:INIT JMP AP03 SAVE STATION TYPE FLAGS IN DIB AP02 EQU $ PRIMARY STATION OPERATION PERMITTED COPY A,Q LINK OPTIONS FLAGS BITS:OUT Q,LOF:AS,LOF:NS SECONDARY STATION OPERATION ENABLES JNE Q,AP06 ERROR IF CONFLICTING OPERATION MODES PERMITTED BITS:VAL Q,PLS:PSF,PLS:PSS=PST:INIT SET PRIMARY STATION MODE AP03 EQU $ SAVE STATION TYPE FLAGS IN DIB OR DI:PLS(X),Q MERGE STATION TYPE FLAGS INTO PROTOCOL LINK STATUS COPY  Q,DI:PLS(X) COPY DI:LCB(X),X BASE ADDRESS OF LCB COPY CS:CIB(Y),Q BASE ADDRESS OF CIB R:BGIN B:PROTO START UP A PROTOCOL HANDLER ACTIVITY AP04 EQU $ TAKE NORMAL RETURN TO CALLER COPY K,X CURRENT STACK POINTER ADDRESS IMS 0(X) SET RETURN ADDRESS FOR NORMAL RETURN RSK RETURN TO CALLER AP05 EQU $ UNABLE TO ALLOCATE LINK CONTROL BLOCK COPY =TRM:MEMO,Q SET MEMORY UNAVAILABLE TERMINATION CODE RSK RETURN TO CALLER AP06 EQU $ CONFLICTING OPERATIONAL MODES PERMITTED COPY =0,A LOAD BASE ADDRESS OF LCB AND SET NULL EXCH A,DI:LCB(X) COPY A,X COPY ADDRESS TO CORRECT REGISTER JSK RELS:LCB RETURN MEMORY USED FOR LCB TO SYSTEM COPY =TRM:INVR,Q SET INVALID REQUEST TERMINATION CODE RSK RETURN TO CALLER * LPOOL TITL CND:EVNT - GENERATE PROTOCOL EVENT IF REQUIRED * * CND:EVNT * * PROCEDURE GENERATES AN EVENT FOR THE APPROPRIATE PROTOCOL HANDLER *  ACTIVITY, REQUESTING A PROTOCOL MODE CHANGE, IF THE PROTOCOL MODE * REQUIRED DIFFERS FROM THAT CURRENTLY ACTIVE. * * CALL PARAMETERS: * A - EVENT TYPE CODE * X - BASE ADDRESS OF DEVICE INFORMATION BLOCK * * RETURN PARAMETERS: *  A,Q,X - UNCHANGED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 INDICATES THAT THE * REQUESTED PROTOCOL MODE WAS ALREADY ACTIVE; RETURN TO CALL+2 IS * TAKEN OTHERWISE. * CND:EVNT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY DI:PLS(X),Q PROTOCOL LINK STATUS TBIT PLS:PSF,Q PRIMARY STATION FUNCTION FLAG JT OV,$+2 JUMP IF PRIMARY STATION FUNCTION SELECTED SHIFT: Q,PLS:PSSB-PLS:SSSB POSITION SECONDARY STATION FUNCTION FIELD BITS:EXT Q,PLS:PSS EXTRACT APPROPRIATE STATION FUNCTION FIELD CLSN Q,=PST:DISC JUMP IF STATION IN DISCONNECTED PROTOCOL STATE JMP CE01 CLSN Q,=PST:INF JUMP IF STATION IN INFORMATION TRANSFER STATE JMP CE02 CLSN Q,=PST:INP JUMP IF STATION IN INITIALIZATION PRIMARY STATE JMP CE03 ERR:D CE05 EXIT TO DEBUG OR TAKE NON-EVENT RETURN CE01 EQU $ STATION IN DISCONNECTED PROTOCOL STATE CLSN A,=E:ENTDSC CHECK IF DISCONNECTED MODE REQUESTED JMP CE05 TAKE RETURN FOR NO EVENT REQUIRED JMP CE04 GENERATE EVENT REQUESTING CHANGE OF STATE CE02 EQU $ STATION IN INFORMATION TRANSFER PROTOCOL STATE CLSN A,=E:ENTINF CHECK IF INFORMATION TRANSFER MODE REQUESTED JMP CE05 TAKE RETURN FOR NO EVENT REQUIRED JMP CE04 GENERATE EVENT REQUESTING CHANGE OF STATE CE03 EQU $ STATION IN INITIALIZATION PRIMARY PROTOCOL STATE CLSN A,=E:ENTINP CHECK IF INITIALIZATION PRIMARY MODE REQUESTED JMP CE05 TAKE RETURN FOR NO EVENT REQUIRED CE04 EQU $ EVENT REQUIRED FOR CHANGE OF PROTOCOL STATE COPY DI:LCB(X),Q BASE ADDRESS OF LCB JSK PRO:EVNT GENERATE EVENT FOR THE PROTOCOL HANDLER ACTIVITY COPY K,X CURRENT STACK POINTER ADDRESS IMS STK:NUM(X) SET RETURN ADDRESS FOR EVENT GENERATED CE05 EQU $ PROTOCOL ALREADY IN REQUESTED STATE POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER TITL REQ:EXU - EXECUTE CONTROL REQUEST * * REQ:EXU * * PROCEDURE CHECKS THAT THE CORRESPONDING PROTOCOL LINK IS IN THE * PROPER STATE FOR EXECUTING A CONTROL REQUEST, THEN INITIATES THE * APPROPRIATE ACTION FOR THE CONTROL REQUEST. * * CALL PARAMETERS: * X - BASE ADDRESS OF CONTROL REQUEST BLOCK * * RETURN PARAMETERS: * A,X - UNCHANGED * Q - TERMINATION CODE IF TERMINA TION RETURN TAKEN, UNCHANGED * OTHERWISE * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS A TERMINATION * RETURN, INDICATING THAT PROCESSING OF THE CONTROL REQUEST HAS * BEEN COMPLETED; RETURN TO CALL+2 INDICATES THAT PROCESSING OF THE * REQUEST IS IN PROGRESS. * REQ:EXU EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY CR:CRC(X),A CONTROL REQUEST CODE CSK A,=CRC:TERM CHECK UPPER LIMIT ON CONTROL REQUEST CODE JMP $+2 JUMP IF WITHIN LEGAL RANGE JMP RE06 ERROR IF ABOVE MAXIMUM VALUE JLT A,$-1 ERROR IF CONTROL REQUEST CODE NEGATIVE COPY CR:DIB(X),X BASE ADDRESS OF ASSOCIATED DIB COPY DI:PLS(X),Q PROTOCOL LINK STATUS BITS:OUT Q,PLS:PSS,PLS:SSS MASK OUT STATION STATE FIELDS JNE Q,RE01 JUMP IF EITHER FUNCTION NOT IN IDLE STATE COPY =TRM:NORM,Q SET NORMAL TERMINATION CODE CLSN A,=CRC:TERM CHECK IF TERMINATE CONTROL REQUEST JMP RE08 TAKE REQUEST COMPLETED RETURN IF SO COPY X,A COPY BASE ADDRESS OF DIB COPY CS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:LCA(X),Q NUMBER OF PROTOCOL LINKS CURRENTLY ACTIVE SUB CI:MLA(X),Q COMPARE WITH MAXIMUM NUMBER ALLOWED JLT Q,$+2 JUMP IF ANOTHER LINK CAN BE ACTIVATED JMP RE04 TERMINATE REQUEST IF MAXIMUM ALREADY ACTIVE COPY A,X RESTORE BASE ADDRESS OF DIB JSK ACT:PROT ACTIVATE PROTOCOL HANDLER ACTIVITIES JMP RE08 REQUEST TERMINATION IF NO MEMORY AVAILABLE COPY CS:CIB(Y),X BASE ADDRESS OF CIB IMS CI:LCA(X) INCREMENT COUNT OF PROTOCOL LINKS ACTIVE NOP JMP RE03 TAKE NORMAL RETURN TO CALLER RE01 EQU $ PROTOCOL HANDLER ACTIVITIES OPERATING BITS:EXT Q,PLS:SSS EXTRACT SECONDARY STATION STATE CLSN Q,=PST:INIT TEMPORARY ERROR IF INITIALIZATION STATE JMP RE05 CLSN Q,=PST:TERM TEMPORARY ERROR IF TERMINATING STATE JMP RE05 COPY DI:PLS(X),Q PROTOCOL LINK STATUS BITS:EXT Q,PLS:PSS EXTRACT PRIMARY STATION STATE FIELD CLSN Q,=PST:INIT TEMPORARY ERROR IF INITIALIZATION STATE JMP RE05 CLSN Q,=PST:TERM TEMPORARY ERROR IF TERMINATING STATE JMP RE05 COPY A,Q COPY CONTROL REQUEST CODE CLSN Q,=CRC:TERM CHECK FOR TERMINATION REQUESTED COPY =E:TRMPRO,A SET EVENT CODE FOR PROTOCOL TERMINATION CLSN Q,=CRC:DISC CHECK FOR DISCONNECTED MODE REQUESTED COPY =E:ENTDSC,A SET EVENT CODE FOR DISCONNECTED MODE CLSN Q,=CRC:INF CHECK FOR INFORMATION TRANSFER MODE REQUESTED COPY =E:ENTINF,A SET EVENT CODE FOR INFORMATION TRANSFER MODE SUB =CRC:INP,Q CHECK FOR INITIALIZATION PRIMARY MODE REQUESTED JNE Q,RE02 JUMP IF ANY OTHER MODE COPY DI:PLS(X),A PROTOCOL LINK STATUS TBIT PLS:PSF,A PRIMARY STATION FUNCTION PRESENT FLAG JF OV,RE06 INVALID REQUEST IF NO PRIMARY STATION FUNCTION COPY =E:ENTINP,A SET EVENT CODE FOR INITIALIZATION PRIMARY MODE RE02 EQU $ SEND EVENT TO PROTOCOL HANDLER ACTIVITY JSK CND:EVNT GENERATE EVENT IF REQUIRED FOR ACTIVE FUNCTION JMP RE07 TAKE RETURN FOR REQUEST COMPLETED RE03 EQU $ NORMAL RETURN TO CALLER COPY K,X CURRENT STACK POINTER ADDRESS IMS STK:NUM(X) SET RETURN ADDRESS FOR EXECUTION BEGUN POP  RESTORE CALLING REGISTERS RSK RETURN TO CALLER RE04 EQU $ MAXIMUM NUMBER OF PROTOCOL LINKS ALREADY ACTIVE COPY =TRM:MANY,Q SET TOO MANY PROTOCOL LINKS TERMINATION CODE JMP RE08 TAKE ERROR RETURN WITH TERMINATION CODE RE05 EQU $ TEMPORARILY UNABLE TO ACCEPT REQUEST COPY =TRM:TEMP,Q SET TEMPORARILY INVALID REQUEST TERMINATION CODE JMP RE08 TAKE ERROR RETURN WIT H TERMINATION CODE RE06 EQU $ INVALID CONTROL REQUEST CODE COPY =TRM:INVR,Q SET INVALID REQUEST TERMINATION CODE JMP RE08 TAKE ERROR RETURN WITH TERMINATION CODE RE07 EQU $ PROCESSING OF REQUEST COMPLETED COPY =TRM:NORM,Q SET NORMAL TERMINATION CODE RE08 EQU $ RETURN WITH TERMINATION CODE SUPPLIED COPY K,X CURRENT STACK POINTER ADDRESS COPY Q,STK:Q(X) SAVE TERMINATION CODE FOR RETURN TO CALLER POP RESTORE MODIFIED CALLING REGISTERS RSK RETURN TO CALLER * LPOOL TITL SCAN:DIB - SCAN CONTROL REQUEST BLOCK LIST * * SCAN:DIB * * PROCEDURE SCANS A LIST OF CONTROL REQUEST BLOCKS TO FIND A CONTROL * REQUEST BLOCK WHICH SPECIFIES A GIVEN DEVICE INFORMATION BLOCK. * * CALL PARAMETERS: * Q - BASE ADDRESS OF DEVICE INFORMATION BLOCK * X - BASE ADDRESS OF LIST POINTER BLOCK * * RETURN PARAMETERS: * A - ZERO IF BLOCK FOUND AT HEAD OF LIST, ADDRESS OF PRIOR BLOCK * OTHERWISE * Q - UNCHANGED * X - ZERO IF NO MATCHING BLOCK FOUND, ADDRESS OF MATCHING BLOCK * OTHERWISE * SCAN:DIB EQU $ COPY =0,A SET INDICATION FOR HEAD OF LIST COPY 0(X),X BASE ADDRESS OF FIRST CRB IN LIST JEQ X,SD02 JUMP IF LIST IS EMPTY CSK Q,CR:DIB(X) CHECK FOR MATCH ON DIB ADDRESS JMP SD01 JUMP INTO LOOP IF NO MATCH JMP SD01 JMP SD02 TAKE MATCH FOUND RETURN TO CALLER SD01 EQU $ LOOP FOR SCANNING THE CONTROL REQUEST BLOCK LIST COPY X,A COPY BASE ADDRESS OF CURRENT BLOCK COPY CR:NXT(X),X BASE ADDRESS OF NEXT CRB IN LIST JEQ X,SD02 FAILURE RETURN TO CALLER IF AT END CSK Q,CR:DIB(X) CHECK FOR MATCH ON DIB ADDRESS JMP SD01 LOOP IF DIB DOES NOT MATCH JMP SD01 SD02 EQU $ MATCH FOUND OR END OF LIST EXIT RSK RETURN TO CALLER TITL CHK:QUE - CHECK REQUEST AGAINST QUEUE OF PRIOR REQUESTS * * CHK:QUE * * PROCEDURE CHECKS A CONTROL REQUEST AGAINST A QUEUE OF PRIOR * CONTROL REQUESTS, SCANNING TO FIND A MATCH ON THE DIB ADDRESS. * IF A MATCH IS FOUND, THE CONTROL REQUEST CODE FOR THE NEW REQUEST * IS CHECKED, AND THE REQUEST IS PROCESSED IF IT IS AN ABORT * REQUEST. * * CALL PARAMETERS: * Q - BASE ADDRESS OF PRIOR REQUEST QUEUE POINTER BLOCK * X - BASE ADDRESS OF CONTROL REQUEST BLOCK * * RETURN PARAMETERS: * A,X - UNCHANGED * Q - TERMINATION CODE IF TERMINATION RETURN TAKEN, UNCHANGED * OTHERWISE * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS AN ERROR OR REQUEST * TERMINATION RETURN, INDICATING THAT THE CONTROL REQUEST SHOULD BE * TERMINATED; RETURN TO CALL+2 IS NORMAL. * CHK:QUE EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY CR:CRC(X),A CONTROL REQUEST CODE COPY CR:DIB(X),X BASE ADDRESS OF ASSOCIATED DIB EXCH Q,X GET PARAMETERS TO PROPER REGISTERS CLSN A,=CRC:ABRT CHECK FOR ABORT PRIOR REQUEST JMP CQ01 JUMP TO PROCESS ABORT SEPARATELY JSK SCAN:DIB CHECK FOR MATCHING DIB ON QUEUE JEQ X,CQ03 JUMP IF NO MATCHING REQUEST FOUND COPY =TRM:CONF,Q SET ERROR CODE FOR CONFLICTING REQUEST JMP CQ02 TAKE ERROR RETURN TO CALLER CQ01 EQU $ SCAN QUEUE FOR REQUEST TO BE ABORTED JSK SCAN:DIB CHECK FOR MATCHING DIB ON QUEUE JEQ X,CQ03 JUMP IF NO MATCHING REQUEST FOUND COPY X,Q COPY ADDRESS OF REQUEST BEING ABORTED COPY K,X CURRENT STACK POINTER ADDRESS COPY STK:X(X),X BASE ADDRESS OF QUEUE POINTER BLOCK EXCH  Q,X SWAP TO GET IN PROPER REGISTERS JSK DEL:REQ DELETE THE REQUEST FROM THE QUEUE COPY =TRM:ABRT,Q SET TERMINATION CODE FOR REQUEST ABORTED JSK RET:REQ RETURN REQUEST CONTROL BLOCK TO USER COPY =TRM:NORM,Q SET TERMINATION CODE FOR NORMAL COMPLETION CQ02 EQU $ ERROR OR REQUEST TERMINATION RETURN TO CALLER COPY K,X CURRENT STACK POINTER ADDRESS COPY Q,STK:Q(X) SAVE TERMINATION CODE TO BE RETURNED POP RESTORE MODIFIED CALLING REGISTERS RSK RETURN TO CALLER CQ03 EQU $ NO OTHER REQUESTS FOR SAME DIB FOUND COPY K,X CURRENT STACK POINTER ADDRESS IMS STK:NUM(X) SET RETURN ADDRESS FOR NO MATCH FOUND POP  RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL MODE:SET - SET NEW PROTOCOL MODE * * MODE:SET * * PROCEDURE CHANGES THE PROTOCOL MODE RECORDED IN THE DEVICE * INFORMATION BLOCK TO THAT SPECIFIED BY A RECEIVED EVENT. ALSO *  CHECKS THE ACTIVE STATION FUNCTIONS TO DETERMINE IF BOTH ARE NOW * IN THE SAME STATE. * * CALL PARAMETERS: * A - NEW PROTOCOL MODE CODE * X - BASE ADDRESS OF EVENT INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 INDICATES THAT THE TWO * STATION FUNCTIONS OF THE PROTOCOL LINK ARE IN DIFFERENT MODES; * RETURN TO CALL+2 INDICATES THAT EITHER ONLY ONE STATION FUNCTION * IS PRESENT OR THAT BOTH ARE IN THE SAME MODE. * MODE:SET EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY EI:ECI(X),Q EVENT CONTROL INFORMATION  COPY EI:LCB(X),X BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB TBIT ECI:PSF,Q PRIMARY STATION FUNCTION FLAG JF OV,MS01 JUMP IF NOT PRIMARY STATION FUNCTION TBIT ECI:SSF,Q SECONDARY STATION FUNCTION FLAG JF OV,MS02 JUMP IF ONLY PRIMARY STATION FUNCTION SHIFT: A,PLS:PSSB POSITION NEW PROTOCOL MODE FOR PRIMARY COPY A,Q POSITION A COPY OF THE MODE FOR SECONDARY SHIFT: Q,PLS:SSSB-PLS:PSSB OR Q,A MERGE TWO COPIES OF PROTOCOL MODE COPY DI:PLS(X),Q PROTOCOL LINK STATUS BITS:OFF Q,PLS:PSS,PLS:SSS MASK OFF PROTOCOL MODE FIELDS JMP MS03 MS01 EQU $ SECONDARY STATION FUNCTION ONLY SHIFT: A,PLS:SSSB POSITION NEW PROTOCOL MODE FOR SECONDARY COPY DI:PLS(X),Q PROTOCOL LINK STATUS BITS:OFF Q,PLS:SSS MASK OFF SECONDARY STATION STATE FIELD JMP MS03 MS02 EQU $ PRIMARY STATION FUNCTION ONLY SHIFT: A,PLS:PSSB POSITION NEW PROTOCOL MODE FOR PRIMARY COPY DI:PLS(X),Q PROTOCOL LINK STATUS BITS:OFF Q,PLS:PSS MASK OFF PRIMARY STATION STATE FIELD MS03 EQU $ SAVE UPDATED STATUS AND CHECK FUNCTIONS OR A,Q MERGE NEW PROTOCOL MODE INTO STATUS COPY Q,DI:PLS(X) TBIT PLS:PSF,Q PRIMARY STATION FUNCTION PRESENT FLAG JF OV,MS04 JUMP IF PRIMARY STATION FUNCTION ABSENT TBIT PLS:SSF,Q SECONDARY STATION FUNCTION PRESENT FLAG JF OV,MS04 JUMP IF SECONDARY STATION FUNCTION ABSENT SHIFT: Q,PLS:SSSB-PLS:PSSB POSITION PRIMARY STATION STATE FIELD XOR DI:PLS(X),Q MATCH AGAINST SECONDARY STATION STATE BITS:OUT Q,PLS:SSS JNE Q,MS05 JUMP IF FUNCTIONS NOT IN THE SAME STATE MS04 EQU $ TAKE RETURN TO STATION MODES CONSISTENT COPY K,X CURRENT STACK POINTER ADDRESS IMS STK:NUM(X) SET RETURN ADDRESS FOR CONSISTENT MODES MS05 EQU $ TAKE RETURN FOR STATION MODES DIFFERENT POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER * LPOOL TITL CHK:WAIT - CHECK CONTROL  REQUESTS WAITING FOR PROTOCOL MODE CHANGE * * CHK:WAIT * * PROCEDURE SEARCHES THE LIST OF WAITING CONTROL REQUESTS TO * DETERMINE IF A PROTOCOL MODE CHANGE HAS RESULTED IN THE COMPLETION * OF A WAITING REQUEST. IF SO, THE REQUEST IS DELETED FROM THE * WAITING LIST AND RETURNED TO THE USER WITH A NORMAL TERMINATION * CODE. * * CALL PARAMETERS: *  A - PROTOCOL LINK STATION STATE * X - BASE ADDRESS OF DEVICE INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q - UNCHANGED * X - ZERO IF NO CONTROL REQUEST WAITING OR REQUEST TERMINATED, * BASE ADDRESS OF CONTROL REQUEST BLOCK OTHERWISE. * CHK:WAIT EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY X,Q COPY BASE ADDRESS OF DIB COPY Y,X SET BASE ADDRESS OF WAITING LIST POINTER BLOCK ADD =CS:WRH,X JSK SCAN:DIB CHECK FOR MATCHING CONTROL REQUEST WAITING JEQ X,CW03 JUMP IF NO MATCHING REQUEST COPY X,Q SAVE BASE ADDRESS OF CRB COPY K,X CURRENT STACK POINTER ADDRESS COPY Q,STK:X(X) SAVE BASE ADDRESS OF CRB ON STACK COPY STK:A(X),X GET PROTOCOL LINK STATION STATE COPY =-1,Q SET AN INVALID CONTROL REQUEST CODE CLSN X,=PST:DISC CHECK FOR ENTERED DISCONNECTED STATE COPY =CRC:DISC,Q SET DISCONNECTED MODE REQUESTED CODE CLSN X,=PST:INP CHECK FOR ENTERED INITIALIZATION PRIMARY STATE COPY =CRC:INP,Q SET INITIALIZATION PRIMARY MODE REQUESTED CODE CLSN X,=PST:INF CHECK FOR ENTERED INFORMATION TRANSFER STATE COPY =CRC:INF,Q SET INFORMATION TRANSFER STATE REQUESTED CODE SUB =PST:IDLE,X CHECK FOR PROTOCOL OPERATION TERMINATED JNE X,CW01 JUST CHECK FOR MATCH IF ANYTHING ELSE COPY K,X CURRENT STACK POINTER ADDRESS COPY STK:X(X),X BASE ADDRESS OF CRB COPY CR:CRC(X),Q CONTROL REQUEST CODE CLSN Q,=CRC:TERM CHECK FOR PROTOCOL TERMINATION REQUESTED JMP CW02 JUST DO A NORMAL TERMINATION IF SO COPY Y,Q SET BASE ADDRESS OF LIST POINTER BLOCK ADD =CS:WRH,Q JSK DEL:REQ DELETE ABORTED REQUEST FROM QUEUE COPY =TRM:INOP,Q SET LINK INOPERATIVE TERMINATION CODE JSK RET:REQ RETURN REQUEST CONTROL BLOCK TO USER JMP CW03 CW01 EQU $ CHECK FOR NORMAL CONTROL REQUEST COMPLETION COPY K,X CURRENT STACK POINTER ADDRESS COPY STK:X(X),X BASE ADDRESS OF CRB XOR CR:CRC(X),Q COMPARE REQUEST CODE WITH ACTION COMPLETED JNE Q,CW04 JUST EXIT IF NO MATCH CW02 EQU $ TERMINATE CONTROL REQUEST NORMALLY COPY Y,Q SET BASE ADDRESS OF LIST POINTER BLOCK ADD =CS:WRH,Q JSK DEL:REQ DELETE COMPLETED REQUEST FROM THE LIST COPY =TRM:NORM,Q SET NORMAL TERMINATION CODE JSK RET:REQ RETURN REQUEST CONTROL BLOCK TO USER CW03 EQU $ SET NULL CONTROL REQUEST BLOCK ADDRESS FOR RETURN COPY K,X CURRENT STACK POINTER ADDRESS COPY =0,Q SET NULL BASE ADDRESS OF CRB COPY Q,STK:X(X) CW04 EQU $ RESTORE REGISTERS AND RETURN POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER SPACE 2 END O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O OIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIITS:EXT A,PMF:CLS EXTRACT THE CURRENT LINK STATE FIELD CLSN A,=PST:INF CHECK FOR INFORMATION TRANSFER STATE JMP RQ01 SUB =PST:INP,A CHECK FOR INITIALIZATION PRIMARY STATE JNE A,RQ02 NO BUFFERS NECESSARY IF ANY OTHER STATE RQ01 EQU $ SET USE BUFFERS LIN E ACCESS CONTROL FLAG BITS:ON Q,LAF:UBF SET FLAG TO USE RECEIVE BUFFERS COPY Q,LC:LAF(X) RQ02 EQU $ SET CONTROL FIELD FORMAT LINE ACCESS CONTROL FLAGS COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:CFF,A EXTENDED CONTROL FIELD FORMAT FLAG JF OV,RQ03 JUMP IF USING NORMAL CONTROL FIELD FORMAT BITS:ON Q,LAF:ECF SET EXTENDED CONTROL FIELD FORMAT FLAG COPY Q,LC:LAF(X) RQ03 EQU $ GENERATE EVENT REQUESTING ALLOCATION OF CONTROL PAIRS: PMF:PSF#PMF:SSF,ECI:PSF#ECI:SSF CHECK FLAG PAIRS COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:OUT A,PMF:PSF,PMF:SSF MASK OUT STATION FUNCTION FLAGS SHIFT: A,ECI:SSF-PMF:SSF POSITION FOR EVENT CONTROL INFORMATION OR =E:REQRCV,A SET EVENT TYPE CODE FOR REQUEST RECEIVE CONTROL COPY PS:LCB(Y),Q BASE ADDRESS OF LCB COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:RCP(X),X BASE ADDRESS OF RECEIVE CONTROL ACTIVITY EPT JSK INI:EVNT SET EVENT TO REQUEST ALLOCATION OF RECEIVE CONTROL RQ04 EQU $ RETURN WITHOUT REQUESTING CONTROL ALLOCATION RSK RETURN TO CALLER TITL REQ:XMIT - REQUEST TRANSMIT CONTROL OF LINE * * REQ:XMIT * * PROCEDURE GENERATES AN EVENT FOR THE TRANSMIT CONTROL ACTIVITY * REQUESTING TRANSMIT CONTROL OF THE COMMUNICATIONS LINE, AND SETS * THE FLAG FOR TRANSMIT CONTROL REQUESTED. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * REQ:XMIT EQU $ COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:OUT A,PMF:TCR,PMF:TCH,PMF:TCY CHECK TRANSMIT CONTROL RELATED FLAGS JNE A,XQ01 JUMP IF ANY TRANSMIT CONTROL ACTION IN PROGRESS COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:ON A,PMF:TCR SET FLAG FOR REQUESTING TRANSMIT CONTROL COPY A,PS:PMF(Y) BITS:OUT A,PMF:PSF,PMF:SSF MASK OUT STATION FUNCTION FLAGS SHIFT: A,ECI:SSF-PMF:SSF POSITION TO MATCH FLAGS IN EVENT INFORMATION OR =E:REQXMT,A SET EVENT TYPE CODE FOR REQUEST TRANSMIT CONTROL COPY PS:LCB(Y),Q BASE ADDRESS OF LCB COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:TCP(X),X BASE ADDRESS OF TRANSMIT CONTROL ACTIVITY EPT JSK INI:EVNT SET EVENT TO REQUEST ALLOCATION OF TRANSMIT CONTROL XQ01 EQU $ JUST RETURN WITHOUT REQUESTING CONTROL ALLOCATION RSK RETURN TO CALLER TITL PRC:WRIT - PROCESS NEW USER WRITE REQUESTS * * PRC:WRIT * * PROCEDURE REMOVES USER WRITE REQUESTS FROM THE INPUT QUEUE IN THE * DEVICE INFORMATION BLOCK, ASSIGNS SEQUENCE NUMBERS FOR NORMAL * TRANSMISSIONS, AND QUEUES THE REQUESTS INTERNALLY ON THE TRANSMIT * PENDING QUEUE TO AWAIT TRANSMISSION. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * PRC:WRIT EQU $ COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:PIB(X),X BASE ADDRESS OF ACTIVE PIB COPY PI:WDW(X),Q WINDOW SIZE SPECIFIED IN PIB JNE Q,PW01 JUMP IF ACTUAL WINDOW VALUE SPECIFIED COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS TBIT PMF:CFF,Q EXTENDED CONTROL FIELD FORMAT FLAG COPY =8-2,Q ASSUME NORMAL FORMAT CONTROL FIELD JF OV,PW01 USE VALUE LOADED IF CORRECT COPY =128-2,Q SET VALUE FOR EXTENDED CONTROL FIELD PW01 EQU $ CHECK IF INPUT FRAMES CAN BE ACCEPTED MOD:A +PS:NTA,-PS:LTS COMPUTE OFFSET OF NEXT FROM LOWEST CURRENT SUB Q,A SUBTRACT NUMBER OF TRANSMIT FRAMES PERMITTED JGE A,PW07 JUMP IF NO MORE INPUT FRAMES CAN BE ACCEPTED COPY PS:LCB(Y),X BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB ADD =DI:WQH,X SET ADDRE SS OF INPUT QUEUE POINTER BLOCK JSK GET:REQ REMOVE FIRST REQUEST FROM INPUT QUEUE JEQ A,PW08 JUMP IF INPUT QUEUE EMPTY COPY A,X BASE ADDRESS OF WRITE REQUEST BIB COPY =0,Q SET ACTUAL WRITE COUNT TO ZERO COPY Q,BI:ACT(X) COPY BI:ORF(X),Q OPERATION REQUEST FLAGS BITS:OFF Q,ORF:ERR,ORF:AHL,ORF:TRM CLEAR FIELDS TO BE RETURNED COPY Q,BI:ORF(X) BITS:EXT Q,ORF:EHL EXTRACT USER HEADER LENGTH FIELD SUB =4,Q COMPARE WITH MAXIMUM USER HEADER LENGTH JLE Q,PW02 JUMP IF VALID HEADER LENGTH COPY =TRM:INVR,Q SET INVALID REQUEST TERMINATION CODE JSK RET:REQ RETURN REQUEST TO USER JMP PRC:WRIT LOOP FOR NEXT QUEUED WRITE REQUEST PW02 EQU $ VALID WRITE REQUEST FROM USER COPY BI:ORF(X),Q OPERATION REQUEST FLAGS TBIT ORF:NSI,Q NON-SEQUENTIAL INFORMATION FLAG JT OV,PW04 JUMP UNLESS A SEQUENCED REQUEST COPY PS:NTA(Y),Q NEXT TRANSMIT SEQUENCE NUMBER TO ASSIGN COPY Q,BI:SEQ(X) ASSIGN IT TO THIS REQUEST MOD:Q ,+=1 INCREMENT SEQUENCE NUMBER FOR NEXT REQUEST COPY Q,PS:NTA(Y) COPY =0,Q SET NULL NEXT POINTER FROM REQUEST COPY Q,BI:NXT(X) EXCH X,PS:TPT(Y) SET AS TAIL OF QUEUE AND GET PRIOR JEQ X,PW03 JUMP IF ADDING TO EMPTY QUEUE COPY A,BI:NXT(X) SET FORMER TAIL LINKAGE TO ADDED REQUEST JMP PRC:WRIT LOOP FOR ALL QUEUED WRITE REQUESTS PW03 EQU $ ADDING TO EMPTY TRANSMIT PENDING QUEUE COPY A,PS:TPH(Y) SET ADDED REQUEST AS HEAD OF QUEUE JMP PW05 CHECK FOR HOLDING CONTROL OF LINE PW04 EQU $ NON-SEQUENTIAL WRITE REQUEST INPUT EXCH A,PS:TPH(Y) SET THIS REQUEST AS NEW HEAD AND GET FORMER COPY A,BI:NXT(X) SET AS NEXT LINKAGE IN REQUEST BEING ADDED JNE A,PRC:WRIT LOOP UNLESS QUEUE WAS EMPTY COPY X,PS:TPT(Y) SET REQUEST BEING ADDED AS TAIL OF QUEUE PW05 EQU $ CHECK CONTROL FOR FIRST REQUEST ON QUEUE COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:PSF,A PRIMARY STATION FUNCTION FLAG JF OV,PRC:WRIT LOOP IF SECONDARY FUNCTION ONLY COPY PS:LOF(Y),Q LINK OPTIONS FLAGS TBIT LOF:MTP,Q MULTIPOINT LINE FLAG JF OV,PRC:WRIT LOOP IF POINT-TO-POINT LINE TBIT PMF:RCH,A CHECK IF HOLDING RECEIVE CONTROL OF LINE JT OV,PW06 JUMP TO CHECK TRANSMIT CONTROL IF SO JSK REQ:RECV REQUEST ALLOCATION OF RECEIVE CONTROL JMP PRC:WRIT LOOP FOR ALL QUEUED REQUESTS PW06 EQU $ CHECK FOR TRANSMIT CONTROL OF LINE HELD TBIT PMF:TCH,A CHECK IF HOLDING TRANSMIT CONTROL OF LINE JT OV,PRC:WRIT LOOP FOR NEXT REQUEST IF SO JSK REQ:XMIT REQUEST ALLOCATION OF TRANSMIT CONTROL JMP PRC:WRIT LOOP FOR ALL QUEUED REQUESTS PW07 EQU $ UNABLE TO ACCEPT MORE INPUT TRANSMIT FRAMES COPY PS:LCB(Y),X BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB COPY =0,A SET NULL SEMAPHORE ADDRESS TO DISABLE SIGNALLING COPY A,DI:WQS(X) RSK RETURN TO CALLER PW08 EQU $ ENABLE SIGNALLING FOR NEW TRANSMIT REQUESTS COPY PS:EPT(Y),A BASE ADDRESS OF EPT ADD =EP:SEM,A SET ADDRESS OF ACTIVITY SEMAPHORE COPY A,2(X) SET ADDRESS OF SEMAPHORE TO SIGNAL FOR QUEUE RSK * LPOOL TITL CHK:TERM - CHECK FOR PROTOCOL LINK TERMINATION * * CHK:TERM * * PROCEDURE CHECKS TO DETERMINE IF THE PROTOCOL LINK IS NOW IN THE * DISCONNECTED LINK STATE AND TERMINATION HAS BEEN REQUESTED. IF * BOTH CONDITIONS ARE TRUE, RECEIVE CONTROL IS RELEASED AND TRANSMIT * CONTROL IS RELEASED IF THERE IS NO SPECIFIC RESPONSE PENDING. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A - MINUS IF READY TO  TERMINATE, ZERO IF NOT TERMINATING, PLUS IF * TERMINATING BUT STILL NEED TO TRANSMIT * Q,X - DESTROYED * CHK:TERM EQU $ COPY PS:EPT(Y),X BASE ADDRESS OF EPT COPY EP:TRM(X),A TERMINATION FLAG FOR ACTIVITY JNE A,CT03 JUMP IF FORCED TERMINATION COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:EXT A,PMF:RLS EXTRACT THE REQUESTED LINK STATE FIELD SUB =PST:TERM,A CHECK IF LINK TERMINATION REQUESTED JNE A,CT02 JUMP IF TERMINATION NOT REQUESTED COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS BITS:EXT Q,PMF:CLS EXTRACT THE CURRENT LINK STATE FIELD SUB =PST:DISC,Q CHECK IF NOW IN DISCONNECTED STATE JNE Q,CT02 JUMP IF NOT IN DISCONNECTED STATE JSK REL:RECV RELEASE RECEIVE CONTROL OF LINE COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS TBIT PCF:SRP,A SPECIFIC RESPONSE PENDING FLAG JT OV,CT01 JUMP IF STILL NEED TO TRANSMIT RESPONSE JSK REL:XMIT RELEASE TRANSMIT CONTROL OF LINE COPY =-1,A RETURN CODE FOR READY TO TERMINATE RSK CT01 EQU $ RETURN CODE FOR STILL NEED TO TRANSMIT COPY =+1,A SET CODE FOR TRANSMIT REQUIRED RSK RETURN TO CALLER CT02 EQU $ RETURN CODE FOR NOT TERMINATING COPY =0,A SET CODE FOR NO TERMINATION RSK  RETURN TO CALLER CT03 EQU $ FORCED TERMINATION REQUESTED JSK REL:RECV RELEASE RECEIVE CONTROL OF LINE JSK REL:XMIT RELEASE TRANSMIT CONTROL OF LINE COPY =-1,A RETURN CODE FOR READY TO TERMINATE RSK TITL RECV:REL - RECEIVE CONTROL OF LINE RELEASED * * RECV:REL * * PROCEDURE PERFORMS PROCESSING FOR THE RELEASE OF RECEIVE CONTROL * OF THE COMMUNICATIONS LINE, INCLUDING INITIATING A NEW REQUEST FOR * RECEIVE CONTROL IF APPROPRIATE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * RECV:REL EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:OFF A,PMF:RCY,PMF:RCH TURN OFF FLAGS FOR YIELDING CONTROL AND HELD COPY A,PS:PMF(Y) TBIT PMF:PSF,A PRIMARY STATION FUNCTION OPERATING FLAG JF OV,RL01 JUMP IF SECONDARY STATION FUNCTION ONLY COPY PS:LOF(Y),Q LINK OPTIONS FLAGS TBIT LOF:MTP,Q MULTIPOINT LINE FLAG JF OV,RL01 REQUEST CONTROL IF NOT MULTIPOINT PRIMARY COPY PS:PTB(Y),A POLL TIMER CONTROL BLOCK ADDRESS JNE A,RL02 DO NOT REQUEST CONTROL IF POLL TIMER PRESENT COPY PS:MCF(Y),A MODE CONDITION FLAGS TBIT MCF:MSR,A MODE SETTING REQUIRED FLAG JT OV,RL01 REQUEST CONTROL IF DOING MODE SETTING COPY PS:TWH(Y),A CHECK ALL TRANSMIT FRAME QUEUES OR PS:TAH(Y),A OR PS:TPH(Y),A JEQ A,RL02 DO NOT REQUEST CONTROL IF NOTHING TO TRANSMIT RL01 EQU $ CHECK IF CONTINUING PROTOCOL OPERATION JSK CHK:TERM CHECK FOR TERMINATION IN PROGRESS JNE A,RL02 DO NOT REQUEST CONTROL AGAIN IF SO JSK REQ:RECV REQUEST RECEIVE CONTROL BACK AGAIN RL02 EQU $ EXIT WITHOUT REQUESTING RENEWAL OF RECEIVE CONTROL POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL XMIT:REL - TRANSMIT CONTROL OF LINE RELEASED * * XMIT:REL * * PROCEDURE PERFORMS PROCESSING FOR THE RELEASE OF TRANSMIT CONTROL * OF THE COMMUNICATIONS LINE, INCLUDING INITIATING A NEW REQUEST FOR * TRANSMIT CONTROL IF APPROPRIATE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * XMIT:REL EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:OFF A,PMF:TCY,PMF:TCH TURN  OFF FLAGS FOR YIELDING CONTROL AND HELD COPY A,PS:PMF(Y) TBIT PMF:PSF,A PRIMARY STATION FUNCTION OPERATING FLAG JF OV,XL01 JUMP IF SECONDARY STATION FUNCTION ONLY COPY PS:LOF(Y),Q LINK OPTIONS FLAGS TBIT LOF:MTP,Q MULTIPOINT LINE FLAG JT OV,XL02 DO NOT REQUEST CONTROL IF MULTIPOINT PRIMARY XL01 EQU $ CHECK IF CONTINUING PROTOCOL OPERATION JSK CHK:TERM CHECK FOR TERMINATING PROTOCOL OPERATION JLT A,XL02 DO NOT REQUEST CONTROL IF READY TO TERMINATE JSK REQ:XMIT REQUEST TRANSMIT CONTROL BACK AGAIN XL02 EQU $ EXIT WITHOUT REQUESTING RENEWAL OF TRANSMIT CONTROL POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER * LPOOL TITL PRO:RPRT - REPORT CHANGE OF PROTOCOL LINK STATE * * PRO:RPRT * * PROCEDURE GENERATES AN EVENT FOR THE LINE CONTROL ACTIVITY WITH * THE SPECIFIED EVENT TYPE CODE AND THE APPROPRIATE STATION FUNCTION * FLAGS. * * CALL PARAMETERS: * A - EVENT TYPE CODE TO USE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * PRO:RPRT EQU $ PAIRS: PMF:PSF#PMF:SSF,ECI:PSF#ECI:SSF CHECK FLAG PAIRS COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS BITS:OUT Q,PMF:PSF,PMF:SSF MASK OUT THE STATION FUNCTION FLAGS SHIFT: Q,ECI:SSF-PMF:SSF POSITION FLAGS CORRECTLY FOR EVENT CONTROL OR Q,A MERGE FLAGS IN WITH TYPE CODE COPY PS:LCB(Y),Q SET BASE ADDRESS OF LCB COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:LCP(X),X SET BASE ADDRESS OF LINE CONTROL EPT JSK INI:EVNT SET EVENT REPORTING PROTOCOL STATE CHANGE RSK RETURN TO CALLER TITL CHK:MODE - CHECK FOR MODE SETTING ACTION REQUIRED * * CHK:MODE * * PROCEDURE CHECKS IF MODE SETTING ACTION IS REQUIRED AFTER A CHANGE * IN CURRENT OR REQUESTED LINK STATE. IF THE REQUESTED MODE IS THE * SAME AS THE CURRENT STATE, MODE SETTING ACTION IS SUSPENDED; IF * DIFFERENT, MODE SETTING ACTION IS INITIATED. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: *  A,Q,X - DESTROYED * CHK:MODE EQU $ COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS COPY Q,A GET A SECOND COPY BITS:EXT Q,PMF:CLS EXTRACT CURRENT LINK STATE BITS:EXT A,PMF:RLS EXTRACT REQUESTED LINK STATE CSN A,Q CHECK IF ALREADY IN REQUESTED LINK STATE JMP CM01 JUMP TO TURN OFF MODE SETTING IF SO SUB =PST:TERM,A CHECK IF PROTOCOL TERMINATION REQUESTED JNE A,CM03 JUST INITIATE MODE SETTING IF NOT SUB =PST:DISC,Q CHECK IF NOW IN DISCONNECTED STATE JNE Q,CM03 INITIATE MODE SETTING OPERATION IF NOT JSK CHK:TERM RELEASE CONTROL OF LINE IF POSSIBLE JMP CM02 TURN OFF MODE SETTING OPERATION CM01 EQU $ CHECK IF MODE SETTING CAN BE TURNED OFF COPY PS:MCF(Y),A MODE CONDITION FLAGS TBIT MCF:RDR,A REQUEST DISCONNECT RECEIVED FLAG JT OV,CM04 JUST RETURN TO CONTINUE DISCONNECT IF SET COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS TBIT PCF:FRR,A FRAME REJECT RECEIVED FLAG JT OV,CM04 JUST RETURN TO CONTINUE RESET IF SET SUB =PST:DISC,Q CHECK IF NOW IN DISCONNECTED STATE JNE Q,CM02 JUST FORCE OFF MODE SETTING IF NOT COPY PS:LOF(Y),A LINK OPTIONS FLAGS TBIT LOF:MTP,A MULTIPOINT LINE FLAG JF OV,CM02 JUMP IF A POINT-TO-POINT LINE COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:PSF,A PRIMARY STATION FUNCTION FLAG JF OV,CM02 JUMP IF SECONDARY STATION FUNCTION ONLY COPY PS:PTB(Y),X POLL TIMER CONTROL BLOCK ADDRESS JEQ X,CM02 JUMP IF NO POLL TIMER PRESENT JSK CNCL:TMR CANCEL THE POLL TIMER CM02  EQU $ FORCE OFF MODE SETTING OPERATION COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:OFF A,MCF:MSR RESET MODE SETTING REQUIRED FLAG COPY A,PS:MCF(Y) RSK RETURN TO CALLER CM03 EQU $ BEGIN MODE SETTING OPERATION COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:ON A,MCF:MSR SET FLAG FOR MODE SETTING REQUIRED BITS:OFF A,MCF:ESN,MCF:ASY,MCF:SUS TURN OFF FLAGS FOR MODE BEING SET COPY PS:LOF(Y),Q LINK OPTIONS FLAGS TBIT LOF:ESN,Q EXTENDED SEQUENCE NUMBERING ENABLED FLAG JF OV,$+2 JUMP IF ONLY NORMAL SEQUENCE NUMBERING BITS:ON A,MCF:ESN SET FLAG FOR SETTING EXTENDED SEQUENCE NUMBERING BITS:OUT Q,LOF:AS,LOF:AP,LOF:AC MASK OUT ASYNCHRONOUS ENABLES FLAGS JEQ Q,$+2 JUMP IF ONLY NORMAL MODES PERMITTED BITS:ON A,MCF:ASY SET FLAG FOR SETTING ASYNCHRONOUS OPERATION COPY A,PS:MCF(Y) SAVE UPDATED MODE CONDITION FLAGS COPY =0,A INITIALIZE RETRY COUNTER FOR MODE SETTING COPY A,PS:RTY(Y) COPY PS:LOF(Y),A LINK OPTIONS FLAGS TBIT LOF:MTP,A MULTIPOINT LINE FLAG JF OV,CM04 JUMP IF A POINT-TO-POINT LINE COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:PSF,A PRIMARY STATION FUNCTION FLAG JF OV,CM04 JUMP IF SECONDARY STATION FUNCTION JSK REQ:RECV REQUEST RECEIVE CONTROL OF LINE COPY PS:PTB(Y),X POLL TIMER CONTROL BLOCK JEQ X,CM04 JUMP IF NO POLL TIMER PRESENT JSK CNCL:TMR CANCEL THE POLL TIMER IF ALREADY RUNNING JSK STRT:TMR START THE POLL TIMER RUNNING CM04 EQU $ RETURN WITHOUT AFFECTING THE MODE SETTING RSK RETURN TO CALLER TITL SET:REQS - SET REQUESTED LINK STATE * * SET:REQS * * PROCEDURE SETS THE REQUESTED LINK STATE TO A SPECIFIED VALUE. IF * THE NEW REQUESTED LINK STATE DIFFERS FROM THE OLD, APPROPRIATE *  MODE SETTING ACTION IS INITIATED. * * CALL PARAMETERS: * A - VALUE MASK FOR REQUESTED LINK STATE FIELD * * RETURN PARAMETERS: * A,Q,X - DESTROYED * SET:REQS EQU $ COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS BITS:OUT Q,PMF:RLS MASK OUT REQUESTED LINK STATE FIELD CSN A,Q CHECK IF NEW REQUESTED STATE SAME AS OLD RSK JUST RETURN TO CALLER IF SO CLSN Q,=PST:TERM%PMF:RLSB CHECK IF OLD REQUESTED STATE TERMINATION RSK JUST RETURN TO CALLER IF SO XOR PS:PMF(Y),Q RESET REQUESTED LINK STATE FIELD OR A,Q SAVE NEW REQUESTED LINK STATE COPY Q,PS:PMF(Y) JMP CHK:MODE EXIT THROUGH MODE CHECKING TITL SET:CURS - SET CURRENT LINK STATE * * SET:CURS * * PROCEDURE SETS THE CURRENT LINK STATE TO A SPECIFIED VALUE. IF *  THE NEW STATE DIFFERS FROM THE OLD, AN EVENT REPORTING THE STATE * CHANGE IS GENERATED FOR THE LINE CONTROL ACTIVITY AND CONTROL OF * THE LINE IS TEMPORARILY RELEASED TO ALLOW CHANGES IN OPERATIONAL * PARAMETERS. MODE SETTING ACTION IS ALSO INITIATED IF THE NEW * CURRENT LINK STATE DIFFERS FROM THE REQUESTED LINK STATE. * SETTING ACTION IS INITIATED. * *  CALL PARAMETERS: * A - VALUE MASK FOR CURRENT LINK STATE FIELD * * RETURN PARAMETERS: * A,Q,X - DESTROYED * SET:CURS EQU $ COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS BITS:OUT Q,PMF:CLS MASK OUT CURRENT LINK STATE FIELD CSN A,Q CHECK IF NEW CURRENT STATE SAME AS OLD RSK JUST RETURN TO CALLER IF SO FRC:CURS EQU $ ALTERNATE ENTRY TO FORCE STATE ENTRY COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS BITS:OFF Q,PMF:CLS MASK OFF CURRENT LINK STATE FIELD OR A,Q SAVE NEW CURRENT LINK STATE COPY  Q,PS:PMF(Y) SHIFT: A,-PMF:CLSB RIGHT JUSTIFY NEW LINK STATE XNX A USE VALUE AS INDEX INTO TABLE COPY TBL:RPRT,A LOAD EVENT TYPE CODE FOR REPORTING CHANGE JSK PRO:RPRT GENERATE EVENT TO REPORT CHANGE OF STATE JSK REL:RECV RELEASE RECEIVE CONTROL OF LINE JSK REL:XMIT RELEASE TRANSMIT CONTROL OF LINE JSK RST:RECV RESET RECEIVE SIDE OPERATION JSK RST:XMIT RESET TRANSMIT SIDE OPERATION JMP CHK:MODE EXIT THROUGH PROCEDURE TO CHECK MODE * TBL:RPRT EQU $ TABLE FOR CONVERTING STATE CODE TO EVENT TYPE WORD 0 IDLE PROTOCOL STATE WORD E:PROOPR PROTOCOL INITIALIZATION STATE WORD E:PRODSC DISCONNECTED PROTOCOL STATE WORD E:PROINP INITIALIZATION PRIMARY STATE WORD E:PROINF INFORMATION TRANSFER STATE WORD E:PROTRM PROTOCOL TERMINATION STATE TITL STRT:RSP - START RESPONSE TIMER RUNNING * * STRT:RSP * * PROCEDURE STARTS THE RESPONSE TIMER RUNNING IF IT IS NOT CURRENTLY *  RUNNING. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,X - DESTROYED * Q - UNCHANGED * STRT:RSP EQU $ COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS TBIT PCF:RTA,A RESPONSE TIMER ACTIVATED FLAG JT OV,ST01 JUMP IF RESPONSE TIMER PREVIOUSLY ACTIVATED BITS:ON A,PCF:RTA SET RESPONSE TIMER ACTIVATED FLAG COPY A,PS:PCF(Y) COPY PS:RTB(Y),X BASE ADDRESS OF RESPONSE TIMER TCB JSK STRT:TMR START THE TIMEOUT INTERVAL ST01 EQU $ RETURN TO CALLER RSK SPACE 2 END T T T T T T T TIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII TITL SYNCHRONOUS HANDLER PROTOCOL MACROS (93438-92/A030) TITL PROTOCOL EQUATE DEFINITIONS * * SUPERVISORY FORMAT FRAME TYPE CODES * SUP:RR EQU :01 RECEIVE READY FRAME SUP:RNR EQU :05 RECEIVE NOT READY FRAME SUP:REJ EQU :09 REJECT FRAME SUP:SREJ EQU :0D SELECTIVE REJECT FRAME SPACE 2 * * UNNUMBERED FORMAT COMMAND FRAME TYPE CODES * UNC:SNRM EQU :83 SET NORMAL RESPONSE MODE FRAME UNC:SARM EQU :0F SET ASYNCHRONOUS RESPONSE MODE FRAME UNC:SABM EQU :2F SET ASYNCHRONOUS BALANCED MODE FRAME UNC:SNRE EQU :CF SET NORMAL RESPONSE MODE EXTENDED FRAME UNC:SARE EQU :4F SET ASYNCHRONOUS RESPONSE MODE EXTENDED FRAME UNC:SABE EQU :6F SET ASYNCHRONOUS BALANCED MODE EXTENDED FRAME UNC:SIM EQU :07 SET INITIALIZATION MODE FRAME UNC:DISC EQU :43 SET DISCONNECTED MODE FRAME UNC:UI EQU :03 UNNUMBERED INFORMATION FRAME UNC:UP EQU :23 UNNUMBERED POLL FRAME UNC:RSET EQU :8F RESET FRAME UNC:XID EQU :AF EXCHANGE IDENTIFICATION FRAME SPACE 2 * * UNNUMBERED FORMAT RESPONSE FRAME TYPE CODES * UNR:UA EQU :63 UNNUMBERED ACKNOWLEDGE FRAME UNR:DM EQU :0F DISCONNECT MODE FRAME UNR:RIM EQU :07 REQUEST DISCONNECT MODE FRAME UNR:UI EQU :03 UNNUMBERED INFORMATION FRAME UNR:FRMR EQU :87 FRAME REJECT FRAME UNR:XID EQU :AF EXCHANGE IDENTIFICATION FRAME UNR:RD EQU :43 REQUEST DISCONNECT FRAME TITL MODULO ARITHMETIC MACRO * * MOD MACRO * * MACRO GENERATES CODE TO SUM THE SPECIFIED SEQUENCE NUMBER VALUES * USING MODULO 256 ARITHMETIC. THE LAST CHARACTER OF THE MACRO NAME * SPECIFIES THE REGISTER (A OR Q) TO BE USED FOR THE SUM. IF THE * FIRST PARAMETER IS NULL, THE CURRENT VALUE IN THE SPECIFIED * REGISTER IS THE INITIAL VALUE FOR THE SUM; OTHERWISE, THE CURRENT * VALUE IN THE REGISTER IS DISCARDED. PARAMETERS CONSIST OF A * LEADING PLUS OR MINUS  SIGN, FOLLOWED EITHER BY A REGISTER NAME * (OTHER THAN THAT SPECIFIED BY THE MACRO NAME), A LITERAL VALUE * (EQUALS SIGN FOLLOWED BY VALUE), OR THE SYMBOLIC NAME FOR A * LOCATION IN THE SCRATCHPAD (PROTOCOL STATE TABLE). * MOD:A MACRO A MOD:Q MACENT Q I: SET #(1,?)=0 IFT #(?)>5 NOTE E,'TOO MANY PARAMETERS - ONLY FIRST FIVE USED' ENDC IFT #(1,?)<>0 IFF #(1,'+');#(1,'-')=1 NOTE E,'INVALID PARAMETER ONE' ENDC IFT #(1,'+')=1 PLUS:#(0) #(1) ENDC ENDC IFT #(?)>1 IFF #(2,'+');#(2,'-')=1 NOTE E,'INVALID PARAMETER TWO' ENDC IFT #(2,'+')=1 PLUS:#(0) #(2) ENDC IFT #(?)>2 IFF #(3,'+');#(3,'-')=1 NOTE E,'INVALID PARAMETER THREE' ENDC IFT #(3,'+')=1 PLUS:#(0) #(3) ENDC IFT #(?)>3 IFF #(4,'+');#(4,'-')=1 NOTE E,'INVALID PARAMETER FOUR' ENDC IFT #(4,'+')=1 PLUS:#(0) #(4) ENDC IFT #(?)>4 IFF #(5,'+');#(5,'-')=1 NOTE E,'INVALID PARAMETER FIVE' ENDC IFT #(5,'+')=1 PLUS:#(0) #(5) ENDC ENDC ENDC ENDC ENDC IFF I: COPY =0,#(0) ENDC IFT #(1,'-')=1 MINUS:#(0) #(1) ENDC IFT #(2,'-')=1 MINUS:#(0) #(2) ENDC IFT #(3,'-')=1 MINUS:#(0) #(3) ENDC IFT #(4,'-')=1 MINUS:#(0) #(4) ENDC IFT #(5,'-')=1 MINUS:#(0) #(5) ENDC AND =:FF,#(0) ENDM SPACE 2 * * PLUS MACRO * * USED BY THE MOD MACRO TO PERFORM THE ACTUAL ADDITION OF A VALUE. * PLUS:A MACRO A PLUS:Q MACENT Q N: SET #(1,?) R: SET #(1,?)=2 IFT R: R: SET 0 IFT #(1,'A')=2 R: SET 1 IFT #(0,'A') NOTE E,'ILLEGAL USAGE OF ACCUMULATION REGISTER A' ENDC ENDC IFT #(1,'Q')=2 R: SET 1 IFT #(0,'Q') NOTE E,'ILLEGAL USAGE OF ACCUMULATION REGISTER Q' ENDC ENDC R: SET R:;#(1,'X') R: SET R:;#(1,'Y') IFT R: IFT I: ADD #(1,2,2),#(0) ENDC IFF I: I: SET 1 COPY #(1,2,2),#(0) ENDC ENDC ENDC IFF R: IFT #(1,'=')=2 IFT I: ADD #(1,2,N:),#(0) ENDC IFF I: I: SET 1 COPY #(1,2,N:),#(0) ENDC ENDC IFF #(1,'=')=2 IFT I: ADD #(1,2,N:)(Y),#(0) ENDC IFF I: I: SET 1 COPY #(1,2,N:)(Y),#(0) ENDC ENDC ENDC ENDM SPACE 2 * * MINUS MACRO * * USED BY THE MOD MACRO TO PERFORM THE ACTUAL SUBTRACTION OF A VALUE. * MINUS:A MACRO A MINUS:Q MACENT Q N: SET #(1,?) R: SET #(1,?)=2 IFT R: R: SET 0 IFT #(1,'A')=2 R: SET 1 IFT #(0,'A') NOTE E,'ILLEGAL USAGE OF ACCUMULATION REGISTER A' ENDC ENDC IFT #(1,'Q')=2 R: SET 1 IFT #(0,'Q') NOTE E,'ILLEGAL USAGE OF ACCUMULATION REGISTER Q' ENDC ENDC R: SET R:;#(1,'X') R: SET R:;#(1,'Y') IFT R: SUB #(1,2,2),#(0) ENDC ENDC IFF R: IFT #(1,'=')=2 SUB #(1,2,N:),#(0) ENDC IFF #(1,'=')=2 SUB #(1,2,N:)(Y),#(0) ENDC ENDC ENDM TITL ADD REQUEST TO QUEUE MACRO * *  ADD:REQ MACRO * * MACRO GENERATES CODE TO ADD A BUFFER INFORMATION BLOCK AT THE END * OF A SCRATCHPAD (PROTOCOL STATE TABLE) QUEUE. THE BASE ADDRESS OF * THE BUFFER INFORMATION BLOCK MUST BE IN X WHEN THIS MACRO IS * INVOKED. THE TWO PARAMETERS ARE THE SYMBOLIC NAME FOR THE OFFSETS * OF THE HEAD AND TAIL POINTERS, RESPECTIVELY. * ADD:REQ MACRO IFT #(?)<>2 NOTE E,'WRONG NUMBER OF PARAMETERS GIVEN' ENDC IFT #(?)=2 COPY =0,A COPY A,BI:NXT(X) COPY X,A EXCH X,#(2)(Y) JEQ X,$+3 COPY A,BI:NXT(X) JMP $+2 COPY A,#(1)(Y) ENDC ENDM TITL DELETE REQUEST FROM QUEUE MACRO * * DEL:REQ MACRO * * MACRO GENERATES CODE TO DELETE THE FIRST BUFFER INFORMATION BLOCK * FROM THE START OF A SCRATCHPAD (PROTOCOL STATE TABLE) Q UEUE. THE * FIRST TWO PARAMETERS ARE THE SYMBOLIC NAMES FOR THE OFFSETS OF THE * HEAD AND TAIL POINTERS, RESPECTIVELY; THE THIRD PARAMETER (IF * PRESENT) IS THE ADDRESS TO JUMP TO IF THE QUEUE IS EMPTY. THE * ADDRESS OF THE BUFFER INFORMATION BLOCK DELETED IS IN X AFTER THIS * MACRO IS INVOKED. THE A AND X REGISTERS ARE USED BY THIS MACRO. * DEL:REQ MACRO IFT #(?)<2 NOTE E,'REQUIRED PARAMETERS MISSING' ENDC IFF #(?)<2 IFT #(?)>3 NOTE E,'TOO MANY PARAMETERS GIVEN' ENDC IFF #(?)>3 COPY #(1)(Y),X IFT #(3,?) JEQ X,#(3) ENDC IFF #(3,?) JEQ X,$+5 ENDC COPY BI:NXT(X),A COPY A,#(1)(Y) JNE A,$+2  COPY A,#(2)(Y) ENDC ENDC ENDM 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 S S S S S S S S S S S S S S SIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII! IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII" IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII# IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII?e830110160431830110160431830110163207e&L830110160431830110160431830110160431$ e 830110160431830110160431830110160431e830110160431830110160431830110160431830110160431830110160431830110160431e:830110162908830110162916830110163045e"Y830110162917830110162936830110163105e{$ q830110162937830110163033830110163201 e % 830110163034830110163038830110163205& ' ( ) . USER ASMLINECTL ASMPROTOCOL ASM PROTOCOL MAC TITL SYNCHRONOUS HANDLER PROTOCOL TASK (93438-12/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR R:WAIT EXTR R:SIG EXTR RLS:EVNT EXTR ALOC:EPT EXTR RELS:EPT EXTR INIT:TMR EXTR STRT:TMR EXTR CNCL:TMR EXTR TERM:TMR EXTR GEN:XMIT EXTR PROC:RFE EXTR XMIT:CPL EXTR PRC:WRIT EXTR PRO:RPRT EXTR REL:RECV EXTR REL:XMIT EXTR RECV:REL EXTR XMIT:REL EXTR REQ:RECV EXTR REQ:XMIT EXTR ABRT:ALL EXTR SET:REQS EXTR SET:CURS EXTR CHK:TERM EXTR STRT:RSP * * EXTE* RNAL DEFINITIONS * NAM B:PROTO * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:9 NAM G:9 ENDC TITL SYSTEM REQUEST CONTROL BLOCKS FOR THE PROTOCOL HANDLER TASK * * PROTOCOL HANDLER TASK DEFINITION BLOCK * TDB:A C:PROTO,PROT:HAN,SIZE:PST,,STACK:PH,,4096 * * PROTOCOL HANDLER TASK BEGIN BLOCK * BGIN:A B:PROTO,C:PROTO,:8000 TITL INIT:TBL - INITIALIZE PROTOCOL STATE TABLE * * INIT:TBL * * PROCEDURE PERFORMS INITIALIZATION OF THE PROTOCOL STATE TABLE. * * CALL PARAMETERS: * A - LINK OPTIONS FLAGS TO BE USED * Q - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * X - BASE ADDRESS OF LINK CONTROL BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * INIT:TBL EQU $ COPY A,PS:LOF(Y) SAVE LINK OPTIONS FLAGS TO BE USED COPY Q,PS:CIB(Y) SAVE BASE ADDRESS OF CIB COPY X,PS:LCB(Y) SAVE BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB COPY DI:NTF(X),Q COPY MAXIMUM NUMBER OF TRANSMIT FRAMES COPY Q,PS:NTF(Y) COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:PIB(X),X BASE ADDRESS OF ACTIVE PIB COPY PI:POF(X),Q COPY PROTOCOL OPTIONS FLAGS COPY Q,PS:POF(Y) BITS:OUT A,LOF:NSN MASK OUT NORMAL SEQUENCE NUMBERING ENABLE BITS:NOT A,LOF:NSN COMPLEMENT THE FLAG SHIFT: A,PMF:CFF-LOF:NSN POSITION TO MATCH EXTENDED CONTROL FIELD FLAG COPY PS:LOF(Y),Q LINK OPTIONS FLAGS BITS:OUT Q,LOF:NP,LOF:AP,LOF:AC MASK OUT PRIMARY AND COMBINED FLAGS JEQ Q,IT01 JUMP IF PRIMARY STATION FUNCTION NOT ENABLED BITS:ON A,PMF:PSF SET FLAG FOR PRIMARY STATION FUNCTION OPERATING IT01 EQU $ SET SECONDARY STATION FUNCTION OPERATING IF ENABLED COPY PS:LOF(Y),Q LINK OPTIONS FLAGS  BITS:OUT Q,LOF:NS,LOF:AS,LOF:AC MASK OUT SECONDARY AND COMBINED FLAGS JEQ Q,IT02 JUMP IF SECONDARY STATION FUNCTION NOT ENABLED BITS:ON A,PMF:SSF SET FLAG FOR SECONDARY STATION FUNCTION OPERATING IT02 EQU $ SET ASYNCHRONOUS RESPONSE OPPORTUNITY IF FORCED COPY PS:LOF(Y),Q LINK OPTIONS FLAGS BITS:OUT Q,LOF:NS,LOF:NP MASK OUT NORMAL RESPONSE MODE FLAGS JNE Q,IT03 JUMP IF ANY NORMAL RESPONSE MODE FUNCTION ENABLED BITS:ON A,PMF:ROP SET FLAG FOR ASYNCHRONOUS RESPONSE OPPORTUNITY IT03 EQU $ SAVE PROTOCOL MODE FLAGS BITS:ON A,PMF:CLS=PST:DISC,PMF:RLS=PST:DISC SET DISCONNECTED STATE COPY A,PS:PMF(Y) SAVE ACCUMULATED PROTOCOL MODE FLAGS BITS:VAL A,PCF:TFO SET TRANSMIT FINAL OUTSTANDING FLAG VALUE COPY A,PS:PCF(Y) USE FOR PROTOCOL CONDITION FLAGS COPY =0,A SET NULL FLAGS VALUE COPY A,PS:MCF(Y) INITIALIZE ALL MODE CONDITION FLAGS OFF COPY A,PS:PIF(Y) INITIALIZE ALL PROTOCOL INFORMATION TRANSFER FLAGS OFF COPY A,PS:EPT(Y) SET NULL EPT BASE ADDRESS COPY =:FF,Q SET HIGHEST FRAME SEQUENCE NUMBER VALUE COPY A,PS:RWB(Y) SET ZERO RECEIVE WINDOW BASE COPY A,PS:TWB(Y) SET ZERO TRANSMIT WINDOW BASE COPY A,PS:LTS(Y) SET ZERO LOWEST TRANSMIT SEQUENCE COPY A,PS:NTS(Y) SET ZERO NEXT TRANSMIT SEQUENCE COPY A,PS:NTA(Y) SET ZERO NEXT TRANSMIT ASSIGNMENT COPY Q,PS:HTS(Y) SET MINUS ONE HIGHEST TRANSMIT SEQUENCE COPY Q,PS:AHS(Y) SET MINUS ONE ACCEPTED HIGH SEQUENCE COPY Q,PS:RHS(Y) SET MINUS ONE RECEIVE HIGH SEQUENCE COPY Q,PS:LPS(Y) SET MINUS ONE HIGHEST IN POLL SEQUENCE COPY Q,PS:LFS(Y) SET MINUS ONE HIGHEST IN FINAL SEQUENCE COPY A,PS:RTY(Y) INITIALIZE CONTROL RETRY COUNT COPY A,PS:TAH(Y) INITIALIZE TRANSMIT ACKNOWLEDGEMENT QUEUE EMPTY + COPY A,PS:TAT(Y) COPY A,PS:RWH(Y) INITIALIZE RECEIVE WAITING QUEUE EMPTY COPY A,PS:RWT(Y) COPY A,PS:TWH(Y) INITIALIZE TRANSMIT WAITING QUEUE EMPTY COPY A,PS:TWT(Y) COPY A,PS:TPH(Y) INITIALIZE TRANSMIT PENDING QUEUE EMPTY COPY A,PS:TPT(Y) COPY A,PS:RTB(Y) SET NULL RESPONSE TCB ADDRESS COPY A,PS:PTB(Y) SET NULL POLL TCB ADDRESS RSK RETURN TO CALLER TITL ALOC:ALL - ALLOCATE AND INITIALIZE CONTROL BLOCKS USED * * ALOC:ALL * * PROCEDURE ALLOCATES AND INITIALIZES THE CONTROL BLOCKS AND TABLES * REQUIRED FOR PROTOCOL HANDLER OPERATION, THE EVENT PROCESSOR TABLE * AND TIMER CONTROL BLOCKS. * * 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 ALLOCATE THE REQUIRED * CONTROL BLOCKS; RETURN TO CALL+1 IS NORMAL. * ALOC:ALL EQU $ JSK ALOC:EPT ALLOCATE EPT FOR PROTOCOL HANDLER ACTIVITY JEQ X,AA05 JUMP IF UNABLE TO ALLOCATE EPT COPY X,PS:EPT(Y) SAVE ADDRESS OF ALLOCATED EPT COPY PS:LOF(Y),A LINK OPTIONS FLAGS BITS:OUT A,LOF:AS,LOF:NP,LOF:AP,LOF:AC CHECK OTHER THAN NORMAL SECONDARY JEQ A,AA01 NO TIMER IF FORCED NORMAL RESPONSE MODE SECONDARY COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:PIB(X),X BASE ADDRESS OF ACTIVE PIB COPY PI:RFI(X),A RESPONSE TIMEOUT INTERVAL JEQ A,AA01 JUMP IF NO RESPONSE TIMEOUT COPY PS:EPT(Y),Q BASE ADDRESS OF EPT ADD =EP:SEM,Q SET ADDRESS OF ACTIVITY SEMAPHORE JSK INIT:TMR ALLOCATE AND INITIALIZE RESPONSE TIMER CONTROL BLOCK JEQ X,AA04 JUMP IF UNABLE TO ALLOCATE TCB COPY X,PS:RTB(Y) SAVE ADDRESS OF ALLOCATED TCB AA01 EQU $ CHECK FOR POLL TIMEOUT REQUIRED COPY PS:LOF(Y),A LINK OPTIONS FLAGS BITS:OUT A,LOF:AP,LOF:NP CHECK FOR ANY PRIMARY STATION MODE JEQ A,AA02 JUMP IF NO PRIMARY STATION MODE PERMITTED COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:PIB(X),X BASE ADDRESS OF ACTIVE PIB COPY PI:PSI(X),A POLLING TIMEOUT INTERVAL JEQ A,AA02 JUMP IF NO POLLING TIMEOUT COPY PS:EPT(Y),Q BASE ADDRESS OF EPT ADD =EP:SEM,Q SET ADDRESS OF ACTIVITY SEMAPHORE JSK INIT:TMR ALLOCATE AND INITIALIZE POLLING TIMER CONTROL BLOCK JEQ X,AA03 JUMP IF UNABLE TO ALLOCATE TCB COPY X,PS:PTB(Y) SAVE ADDRESS OF ALLOCATED TCB AA02 EQU $ SET POINTERS IN LINK CONTROL BLOCK COPY PS:EPT(Y),A BASE ADDRESS OF EPT COPY PS:LCB(Y),X BASE ADDRESS OF LCB COPY A,LC:EPT(X) SET ADDRESS OF PROTOCOL HANDLER EPT COPY K,X CURRENT STACK POINTER ADDRESS IMS 0(X) SET RETURN ADDRESS FOR SUCCESSFUL ALLOCATION RSK RETURN TO CALLER AA03 EQU $ UNABLE TO ALLOCATE POLLING TIMER CONTROL BLOCK COPY PS:RTB(Y),X BASE ADDRESS OF RESPONSE TIMER TCB JEQ X,AA04 JUMP IF NO RESPONSE TIMER PRESENT JSK TERM:TMR DEALLOCATE TIMER CONTROL BLOCK AA04 EQU $ UNABLE TO ALLOCATE RESPONSE TIMER CONTROL BLOCK COPY PS:EPT(Y),X BASE ADDRESS OF ACTIVITY EPT JSK RELS:EPT DEALLOCATE EVENT PROCESSOR TABLE AA05 EQU $ UNABLE TO ALLOCATE EVENT PROCESSOR TABLE RSK UNABLE TO ALLOCATE RETURN TO CALLER * LPOOL TITL RESP:EXP - PROCESS RESPONSE TIMEOUT EXPIRATION * * RESP:EXP * * PROCEDURE RESETS THE TRANSMIT POLL OUTSTANDING FLAG, INCREMENTS * THE RETRY COUNT, AND EITHER RETRYS THE APPROPRIATE OPERATION OR * ABORTS IT. * * CALL PARAMETERS: * NONE * * RETURN PARAMETE, RS: * A,Q,X - DESTROYED * RESP:EXP EQU $ COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:PSF,A PRIMARY STATION FUNCTION FLAG JF OV,RE01 JUMP IF SECONDARY STATION FUNCTION ONLY COPY PS:LOF(Y),A LINK OPTIONS FLAGS TBIT LOF:MTP,A MULTIPOINT LINE FLAG  JF OV,RE01 JUMP IF POINT-TO-POINT LINE JSK REL:RECV RELEASE RECEIVE CONTROL OF LINE RE01 EQU $ CLEAN UP FLAGS AFTER TIMEOUT COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:OFF A,PCF:RTA,PCF:TPO RESET TIMER ACTIVE AND POLL OUTSTANDING FLAGS COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS TBIT PMF:PSF,Q PRIMARY STATION FUNCTION FLAG JF OV,$+2 JUMP IF SECONDARY STATION FUNCTION ONLY BITS:ON A,PCF:FPT SET FLAG FOR FORCED POLL FRAME TRANSMISSION COPY A,PS:PCF(Y) SAVE BACK MODIFIED FLAGS IMS PS:RTY(Y) COUNT A TRANSMISSION RETRY COPY PS:RTY(Y),Q NUMBER OF RETRY ATTEMPTS MADE COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:PIB(X),X BASE ADDRESS OF ACTIVE PIB COPY PS:MCF(Y),A MODE CONDITION FLAGS TBIT MCF:MSR,A CHECK FOR MODE SETTING IN PROGRESS JT OV,RE05 JUMP IF RESPONSE TIMEOUT ON MODE SETTING COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS BITS:ON A,PIF:NRV SET NEW RECEIVE STATUS VALUE FLAG COPY A,PS:PIF(Y) COPY PI:IFT(X),A MAXIMUM NUMBER OF INFORMATION FRAME RETRYS JEQ A,RE02 SKIP CHECK IF NO MAXIMUM SPECIFIED SUB A,Q COMPARE WITH NUMBER OF THIS RETRY JLE Q,RE02 CONTINUE IF RETRY LIMIT NOT EXCEEDED BITS:VAL A,PMF:CLS=PST:DISC SET PROTOCOL STATE TO DISCONNECTED JSK SET:CURS RSK RETURN TO CALLER RE02 EQU $ RETRY INFORMATION FRAME TRANSMISSION COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:PSF,A PRIMARY STATION FUNCTION FLAG JT OV,RE06 JUMP IF PRIMARY STATION FUNCTION OPERATING COPY PS:TPH(Y),A TRANSMIT PENDING QUEUE HEAD POINTER JNE A,RE06 JUMP IF FRAMES READY FOR TRANSMISSION COPY PS:TWT(Y),X ADDRESS OF LAST FRAME WAITING JEQ X,RE04 JUMP IF NO FRAMES WAITING FOR ACKNOWLEDGE COPY BI:SEQ(X),A SEQUENCE NUMBER OF LAST REQUEST ON QUEUE XOR PS:HTS(Y),A COMPARE WITH HIGHEST TRANSMIT SEQUENCE JNE A,RE04 JUST RESTART TIMER IF NOT THE SAME COPY =0,X SET NULL ADDRESS FOR CURRENT REQUEST COPY PS:TWT(Y),A SET NEXT TO HEAD OF QUEUE RE03 EQU $ SCAN TRANSMIT WAITING QUEUE FOR LAST COPY X,Q SAVE ADDRESS OF PREDECESSOR IN QUEUE COPY A,X SET ADDRESS OF THIS REQUEST COPY BI:NXT(X),A ADDRESS OF NEXT REQUEST IN QUEUE JNE A,RE03 LOOP UNTIL END OF QUEUE FOUND COPY X,PS:TPH(Y) ADD REQUEST TO THE TRANSMIT PENDING QUEUE COPY X,PS:TPT(Y) COPY Q,X ADDRESS OF NEXT TO LAST IN WAITING QUEUE COPY Q,PS:TWT(Y) SET AS NEW LAST IN QUEUE JNE Q,$+3 JUMP UNLESS WAITING QUEUE NOW EMPTY COPY Q,PS:TWH(Y) SET NULL HEAD OF WAITING QUEUE RSK RETURN TO CALLER COPY Q,BI:NXT(X) SET NULL LINKAGE FROM NEW LAST IN QUEUE RSK RETURN TO CALLER RE04 EQU $ RESTART TIMER WHEN UNABLE TO RETRANSMIT JSK STRT:RSP START THE RESPONSE TIMER RUNNING AGAIN RSK RETURN TO CALLER RE05 EQU $ RESPONSE TIMEOUT ON MODE SETTING TBIT MCF:MSS,A MODE SETTING COMMAND RECEIVED FLAG JT OV,$+2 JUMP IF COMMAND FROM OTHER STATION SEEN BITS:OFF A,MCF:SUS RESET FLAG FOR MODE SETTING SUSPENDED BITS:OFF A,MCF:MSO,MCF:RSO,MCF:DSO,MCF:MRO,MCF:MSS CLEAR FLAGS COPY A,PS:MCF(Y) COPY PI:CRT(X),A MAXIMUM NUMBER OF COMMAND FRAME RETRYS JEQ A,RE06 SKIP CHECK IF NO MAXIMUM SPECIFIED SUB A,Q COMPARE WITH NUMBER OF THIS RETRY JLE Q,RE- 06 CONTINUE IF RETRY LIMIT NOT EXCEEDED BITS:VAL A,PMF:RLS=PST:TERM SET PROTOCOL LINK TERMINATION REQUESTED JSK SET:REQS BITS:VAL A,PMF:CLS=PST:DISC SET CURRENT LINK STATE TO DISCONNECTED JSK SET:CURS RE06 EQU $ RETURN TO CALLER RSK TITL POLL:EXP - PROCESS POLL TIMEOUT EXPIRATION * * POLL:EXP * * PROCEDURE SETS FLAGS TO TRANSMIT EITHER A MODE SETTING COMMAND, IF *  ONE IS REQUIRED, OR A SUPERVISORY COMMAND REPORTING THE CURRENT * STATUS. THE POLL TIMER IS ALSO RESTARTED. * * CALL PARAMETERS: * X - BASE ADDRESS OF POLL TIMER CONTROL BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * POLL:EXP EQU $ JSK STRT:TMR RESTART THE POLL TIMER COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS TBIT PCF:PFT,A POLL FRAME TRANSMITTED FLAG JT OV,$+2 JUMP IF POLL TRANSMITTED IN TIMEOUT BITS:ON A,PCF:FPT SET FORCE POLL FRAME TRANSMISSION FLAG BITS:OFF A,PCF:PFT RESET POLL FRAME TRANSMITTED FLAG COPY A,PS:PCF(Y) COPY PS:MCF(Y),A MODE CONDITION FLAGS TBIT MCF:MSR,A MODE SETTING REQUIRED FLAG JT OV,PL01 JUMP IF ALREADY PERFORMING MODE SETTING COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS TBIT PCF:FRR,A FRAME REJECT CONDITION REPORTED FLAG JT OV,PL01 JUMP IF FRAME REJECT REPORTED COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS BITS:ON A,PIF:NRV SET FLAG FOR NEW RECEIVE STATUS VALUE COPY A,PS:PIF(Y) PL01 EQU $ CHECK FOR MULTIPOINT PRIMARY STATION COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:PSF,A PRIMARY STATION FUNCTION OPERATING FLAG JF OV,PL02 JUMP IF SECONDARY STATION FUNCTION ONLY COPY PS:LOF(Y),A LINK OPTIONS FLAGS TBIT LOF:MTP,A MULTIPOINT LINE FLAG JF OV,PL02 JUMP IF A POINT TO POINT LINE JSK REQ:RECV REQUEST RECEIVE CONTROL FOR MULTIPOINT PRIMARY PL02 EQU $ RETURN TO CALLER RSK * LPOOL TITL PRC:EVNT - PROCESS RECEIVED EVENTS * * PRC:EVNT * * PROCEDURE PERFORMS PROCESSING FOR RECEIVED EVENTS. ALL EVENTS * PRESENT ON THE QUEUE ARE PROCESSED BEFORE A RETURN IS MADE. * * CALL PARAMETERS: * X - BASE ADDRESS OF FIRST EVENT INFORMATION BLOCK IN QUEUE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * PRC:EVNT EQU $ COPY EI:ECI(X),A EVENT CONTROL INFORMATION BITS:EXT A,ECI:TYP EXTRACT TYPE CODE FIELD COPY =E:TRMPRO,Q SET MAXIMUM EVENT CODE VALID FOR PROTOCOL CSK Q,A COMPARE EVENT CODE RECEIVED WITH MAXIMUM VALID ERR:D PE01 ERROR IF EVENT TYPE INVALID FOR PROTOCOL HANDLER NOP XNX A USE EVENT TYPE CODE AS OFFSET INTO TABLE JSK *FAN:OUT INVOKE APPROPRIATE PROCEDURE FOR PROCESSING PE01 EQU $ INVALID EVENT TYPE CODE FOR PROTOCOL HANDLER COPY PS:EPT(Y),X BASE ADDRESS OF EPT JSK RLS:EVNT RELEASE FIRST EVENT FROM QUEUE COPY EP:EQH(X),X BASE ADDRESS OF NEXT EVENT ON QUEUE JNE X,PRC:EVNT LOOP TO PROCESS IF ANOTHER IS PRESENT RSK RETURN TO CALLER SPACE 2 * * TABLE OF PROCEDURE ADDRESSES FOR EVENT PROCESSING * FAN:OUT EQU $ WORD PROC:RFE RECEIVE FRAME EVENT (EXTERNAL) WORD PROC:BAD TRANSMIT FRAME EVENT WORD PROC:BAD REQUEST RECEIVE CONTROL WORD PROC:BAD REQUEST TRANSMIT CONTROL WORD PROC:RCG RECEIVE CONTROL GRANTED WORD PROC:TCG TRANSMIT CONTROL GRANTED WORD PROC:BAD RELEASE RECEIVE CONTROL WORD PROC:BAD RELEASE TRANSMIT CONTROL WORD PROC:RCR RECEIVE CONTROL RELEASED WORD PROC:TCR TRANSMIT CONTROL RELEASED WORD PROC:AFC ASSERT FLOW CONTROL WORD PROC:RFC RELEASE FLOW C. ONTROL WORD PROC:DMR ENTER DISCONNECTED MODE REQUESTED WORD PROC:IPR ENTER INITIALIZATION PRIMARY MODE REQUESTED WORD PROC:ITR ENTER INFORMATION TRANSFER MODE REQUESTED WORD PROC:TRM TERMINATE PROTOCOL HANDLING REQUESTED TITL PROCEDURES USED FOR PROCESSING RECEIVED EVENTS * * INVALID EVENT * PROC:BAD EQU $ ERR:D ERROR EXIT TO DEBUG IF DEBUGGING RSK RETURN TO CALLER SPACE 2 * * RECEIVE CONTROL GRANTED EVENT * PROC:RCG EQU $ COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:OFF A,PMF:RCR TURN OFF REQUESTING RECEIVE CONTROL FLAG BITS:ON A,PMF:RCH TURN ON RECEIVE CONTROL HELD FLAG COPY A,PS:PMF(Y) JSK CHK:TERM CHECK FOR TERMINATION REQUESTED JNE A,PR01 JUMP IF TERMINATING CONTROL COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:PSF,A PRIMARY STATION FUNCTION FLAG JF OV,PR01 JUMP IF SECONDARY STATION FUNCTION ONLY COPY PS:LOF(Y),A LINK OPTIONS FLAGS TBIT LOF:MTP,A MULTIPOINT LINE FLAG JF OV,PR01 JUMP IF A POINT TO POINT LINE JSK REQ:XMIT REQUEST TRANSMIT CONTROL FOR MULTIPOINT PRIMARY PR01 EQU $ RETURN TO CALLER RSK SPACE 2 * * TRANSMIT CONTROL GRANTED EVENT * PROC:TCG EQU $ COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:OFF A,PMF:TCR TURN OFF REQUESTING TRANSMIT CONTROL FLAG BITS:ON A,PMF:TCH TURN ON TRANSMIT CONTROL HELD FLAG COPY A,PS:PMF(Y) JSK CHK:TERM CHECK FOR TERMINATION REQUESTED RSK RETURN TO CALLER SPACE 2 * * RECEIVE CONTROL RELEASED EVENT * PROC:RCR EQU $ JSK RECV:REL PROCESS RELEASE OF RECEIVE CONTROL OF LINE RSK RETURN TO CALLER SPACE 2 * * TRANSMIT CONTROL RELEASED EVENT * PROC:TCR EQU $ JSK XMIT:REL PROCESS RELEASE OF TRANSMIT CONTROL OF LINE RSK  RETURN TO CALLER SPACE 2 * * ASSERT FLOW CONTROL EVENT * PROC:AFC EQU $ COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS BITS:ON A,PIF:FCR SET FLOW CONTROL REQUESTED FLAG TBIT PIF:PRE,A RECEIVE DATA TRANSFER ENABLED FLAG JF OV,$+2 JUMP IF DATA TRANSFER DISABLED BITS:ON A,PIF:NRS SET NEW RECEIVE STATUS TYPE FLAG COPY A,PS:PIF(Y) SAVE UPDATED FLAGS RSK RETURN TO CALLER SPACE 2 * * RELEASE FLOW CONTROL EVENT * PROC:RFC EQU $ COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS BITS:OFF A,PIF:FCR CLEAR FLOW CONTROL REQUESTED FLAG TBIT PIF:PRE,A RECEIVE DATA TRANSFER ENABLED FLAG JT OV,$+2 JUMP IF DATA TRANSFER ENABLED BITS:ON A,PIF:NRS SET NEW RECEIVE STATUS TYPE FLAG COPY A,PS:PIF(Y) SAVE UPDATED FLAGS RSK RETURN TO CALLER SPACE 2 * * ENTER DISCONNECTED MODE REQUESTED * PROC:DMR EQU $ BITS:VAL A,PMF:RLS=PST:DISC SET REQUESTED LINK STATE DISCONNECTED JSK SET:REQS SAVE AND CHECK FOR PROTOCOL CHANGE RSK RETURN TO CALLER SPACE 2 * * ENTER INITIALIZATION PRIMARY MODE REQUESTED * PROC:IPR EQU $ BITS:VAL A,PMF:RLS=PST:INP SET REQUESTED LINK STATE INITIALIZATION JSK SET:REQS SAVE AND CHECK FOR PROTOCOL CHANGE RSK RETURN TO CALLER SPACE 2 * * ENTER INFORMATION TRANSFER MODE REQUESTED * PROC:ITR EQU $ BITS:VAL A,PMF:RLS=PST:INF SET REQUESTED LINK STATE INFORMATION JSK SET:REQS SAVE AND CHECK FOR PROTOCOL CHANGE RSK RETURN TO CALLER SPACE 2 * * TERMINATE PROTOCOL PROCESSING REQUESTED * PROC:TRM EQU $ BITS:VAL A,PMF:RLS=PST:TERM SET REQUESTED LINK STATE TERMINATION JSK SET:REQS SAVE AND CHECK FOR PROTOCOL CHANGE RSK RETURN TO CALLER */  LPOOL TITL PROT:HAN - PROTOCOL HANDLER TASK MAIN PROGRAM * * PROT:HAN * * MAIN PROGRAM PROCESSES EVENTS GRANTING RECEIVE AND TRANSMIT * CONTROL, REQUESTING A CHANGE OF PROTOCOL STATE, RELEASING RECEIVE * AND TRANSMIT CONTROL, AS WELL AS EVENTS FOR RECEIVED FRAMES. ALSO * PROCESSES TIMEOUTS, USER READ REQUESTS, AND TRANSMIT FRAMES * RETURNED AFTER TRANSMISSION. * * START PARAMETERS: * A - LINK OPTIONS FLAGS TO BE USED * Q - BASE ADDRESS OF CONTROLLER INFORMATION BLOCK * X - BASE ADDRESS OF LINK CONTROL BLOCK * Y - BASE ADDRESS OF PROTOCOL STATE TABLE * PROT:HAN EQU $ JSK INIT:TBL INITIALIZE PROTOCOL STATE TABLE JSK ALOC:ALL ALLOCATE AND INITIALIZE OTHER REQUIRED TABLES JMP PH08 REPORT TERMINATION IF UNABLE TO ALLOCATE COPY =E:PROOPR,A SET EVENT CODE FOR PROTOCOL OPERATIONAL JSK PRO:RPRT REPORT CHANGE OF STATE TO LINE CONTROL ACTIVITY COPY PS:LOF(Y),A LINK OPTIONS FLAGS TBIT LOF:MTP,A MULTIPOINT LINE FLAG JT OV,PH01 JUMP UNLESS POINT-TO-POINT LINE JSK REQ:RECV REQUEST RECEIVE CONTROL OF LINE JSK REQ:XMIT REQUEST TRANSMIT CONTROL OF LINE PH01 EQU $ MAIN LOOP FOR PROTOCOL HANDLER OPERATION COPY PS:EPT(Y),X BASE ADDRESS OF EPT COPY EP:EQH(X),X BASE ADDRESS OF FIRST EVENT ON QUEUE JEQ X,$+2 JUMP IF EVENT QUEUE EMPTY JSK PRC:EVNT PROCESS EVENT ARRIVALS COPY PS:LCB(Y),X BASE ADDRESS OF LCB COPY LC:TCH(X),A TRANSMIT COMPLETE QUEUE HEAD JEQ A,$+2 JUMP IF TRANSMIT COMPLETE QUEUE EMPTY JSK XMIT:CPL PROCESS REQUESTS FOR TRANSMITTED FRAMES COPY PS:EPT(Y),X BASE ADDRESS OF EPT COPY EP:TRM(X),A TERMINATION FLAG JEQ A,PH02 JUMP UNLESS TERMINATION SIGNALLED JSK REL:RECV RELEASE RECEIVE CONTROL OF LINE JSK REL:XMIT RELEASE TRANSMIT CONTROL OF LINE JMP PH05 CHECK IF READY TO TERMINATE OPERATION PH02 EQU $ PROCESS RESPONSE TIMER EXPIRATION COPY PS:RTB(Y),X BASE ADDRESS OF RESPONSE TCB JEQ X,PH03 JUMP IF NO RESPONSE TIMER  COPY TC:EXP(X),A TIMER EXPIRATION FLAG JGE A,PH03 JUMP UNLESS RESPONSE TIMER EXPIRED COPY =EXP:INA,A SET TIMER TO INACTIVE STATE COPY A,TC:EXP(X) JSK RESP:EXP PROCESS RESPONSE TIMER EXPIRATION PH03 EQU $ PROCESS POLL TIMER EXPIRATION COPY PS:PTB(Y),X BASE ADDRESS OF POLL TCB JEQ X,PH04 JUMP IF NO POLL TIMER COPY TC:EXP(X),A TIMER EXPIRATION FLAG JGE A,PH04 JUMP UNLESS POLL TIMER EXPIRED COPY =EXP:INA,A SET TIMER TO INACTIVE STATE COPY A,TC:EXP(X) JSK POLL:EXP PROCESS POLL TIMER EXPIRATION PH04 EQU $ PROCESS USER WRITE REQUESTS COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:EXT A,PMF:CLS EXTRACT THE CURRENT LINK STATE SUB =PST:DISC,A CHECK IF IN DISCONNECTED STATE JEQ A,$+2 JUMP IF CURRENTLY DISCONNECTED JSK PRC:WRIT PROCESS WRITE REQUESTS FROM USER JSK GEN:XMIT GENERATE TRANSMIT FRAMES IF REQUIRED COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS TBIT PCF:SRP,A SPECIFIC RESPONSE PENDING FLAG JT OV,PH06 SKIP TERMINATION CHECKS UNTIL RESPONSE SENT PH05 EQU $ CHECK FOR TERMINATION OF PROTOCOL OPERATION COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:OUT A,PMF:RCH,PMF:TCH,PMF:RCR,PMF:TCR MASK LINE CONTROL FLAGS JNE A,PH06 JUMP IF HOLDING ANY CONTROL OF COMMUNICATIONS LINE COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:EXT A,PMF:RLS EXTRACT REQUESTED LINK STATE FIELD CLSN A,=PST:TERM CHECK IF PROTOCOL TERMINATION REQUESTED JMP PH07 TERMINATE OPERATION IF SO PH06 EQU $ WAIT FOR SIGNAL BE0 FORE REPEATING LOOP COPY PS:EPT(Y),X BASE ADDRESS OF EPT ADD =EP:SEM,X SET ADDRESS OF ACTIVITY SEMAPHORE JSK R:WAIT WAIT FOR A SIGNAL JMP PH01 REPEAT MAIN PROGRAM LOOP PH07 EQU $ DEALLOCATE POLL TIMER CONTROL BLOCK IF USED COPY =TRM:INOP,Q SET LINK INOPERATIVE TERMINATION CODE JSK ABRT:ALL TERMINATE ALL OUTSTANDING REQUESTS COPY PS:PTB(Y),X BASE ADDRESS OF POLL TIMER TCB JEQ X,$+3 JUMP IF POLL TIMER NOT PRESENT JSK CNCL:TMR CANCEL POLL TIMER IF ACTIVE JSK TERM:TMR DEALLOCATE TIMER CONTROL BLOCK COPY PS:RTB(Y),X BASE ADDRESS OF RESPONSE TIMER TCB JEQ X,$+3 JUMP IF RESPONSE TIMER NOT PRESENT JSK CNCL:TMR CANCEL RESPONSE TIMER IF ACTIVE JSK TERM:TMR DEALLOCATE TIMER CONTROL BLOCK COPY PS:LCB(Y),X BASE ADDRESS OF LCB COPY =0,A SET NULL EPT BASE ADDRESS COPY A,LC:EPT(X) COPY PS:EPT(Y),X BASE ADDRESS OF ACTIVITY EPT JSK RELS:EPT DEALLOCATE EVENT PROCESSOR TABLE PH08 EQU $ REPORT TERMINATION AND END EXECUTION COPY =E:PROTRM,A SET EVENT CODE FOR PROTOCOL TERMINATION JSK PRO:RPRT REPORT CHANGE OF STATE TO LINE CONTROL ACTIVITY R:END TERMINATE EXECUTION OF ACTIVITY SPACE 2 END TITL SYNCHRONOUS HANDLER PROTOCOL RECEIVE FRAME (93438-12/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR ACPT:SEL EXTR ACPT:SEQ EXTR PUT:REQ EXTR PROC:ACK EXTR RESC:ONE EXTR RESC:ALL EXTR RET:REQ EXTR RST:RECV EXTR RECV:REL EXTR END:FINL EXTR END:POLL EXTR CHK:MODE EXTR SET:CURS EXTR FRC:CURS EXTR R:SIG * * EXTERNAL DEFINITIONS * NAM PROC:RFE * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:B NAM G:B ENDC TITL DECOD:NR - EXTRACT RECEIVE FRAME NR AND COMPUTE OFFSET FROM BASE * * DECOD:NR * * PROCEDURE EXTRACTS THE NR VALUE FROM A RECEIVED FRAME AND COMPUTES * THE OFFSET OF THE NR VALUE FROM THE TRANSMIT WINDOW BASE SEQUENCE * NUMBER. THE NR VALUE IS ALSO VALIDATED TO ASSURE THAT IT REFERS * A FRAME WHICH HAS PREVIOUSLY BEEN TRANSMITTED (OR IS NEXT TO BE * TRANSMITTED) AND HAS NOT PREVIOUSLY BEEN ACKNOWLEDGED. * * CALL PARAMETERS: * X - BASE ADDRESS OF RECEIVE FRAME EVENT INFORMATION BLOCK * * RETURN PARAMETERS: * A - DESTROYED * Q - MINUS ONE IF INVALID VALUE, NR OFFSET OTHERWISE * X - UNCHANGED * DECOD:NR EQU $ COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS TBIT PMF:CFF,Q EXTENDED CONTROL FIELD FORMAT FLAG JT OV,DR01 JUMP IF USING EXTENDED CONTROL FIELD FORMAT COPY EI:FRM(X),Q FIRST WORD OF RECEIVED FRAME SHIFT Q,RO,5 RIGHT-JUSTIFY THE NR FIELD SUB PS:TWB(Y),Q FIND DIFFERENCE OF NR FROM TRANSMIT WINDOW BASE AND =7,Q MODULO EIGHT JMP DR02 DR01 EQU $ / COPY EI:FRM+1(X),Q SECOND WORD OF RECEIVED FRAME SHIFT Q,RO,9 RIGHT-JUSTIFY THE NR FIELD SUB PS:TWB(Y),Q FIND DIFFERENCE OF NR FROM TRANSMIT WINDOW BASE AND =127,Q MODULO ONE TWENTY-EIGHT DR02 EQU $ / MOD:A +=1,+PS:HTS,-PS:TWB COMPUTE VALID NR OFFSET RANGE SUB Q,A CHECK DIFFERENCE WITH OFFSET FOUND JGE A,$+2 JUMP IF OFFSET FOUND IN VALID RANGE COPY =-1,Q SET RETURN VALUE FOR INVALID NR RSK RETURN TO CALLER TITL DECOD:NS - EXTRACT RECEIVE FRAME NS AND COMPUTE OFFSET FROM BASE * * DECOD:NS * * PROCEDURE EXTRACTS THE NS VALUE FROM A RECEIVED INFORMATION FRAME * AND COMPUTES THE OFFSET OF THE NS VALUE FROM THE RECEIVE WINDOW * B1 ASE SEQUENCE NUMBER. AN NS VALUE MORE THAN TWO GREATER THAN THE * RECEIVE HIGH SEQUENCE NUMBER IS TREATED AS INVALID. * *  CALL PARAMETERS: * X - BASE ADDRESS OF RECEIVE FRAME EVENT INFORMATION BLOCK * * RETURN PARAMETERS: * A - DESTROYED * Q - MINUS ONE IF OUTSIDE WINDOW, NS OFFSET OTHERWISE * X - UNCHANGED * DECOD:NS EQU $ COPY EI:FRM(X),Q FIRST WORD OF RECEIVED FRAME SHIFT Q,RO,1 RIGHT-JUSTIFY THE NS FIELD COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:CFF,A EXTENDED CONTROL FIELD FORMAT FLAG JT OV,DS01 JUMP IF USING EXTENDED CONTROL FIELD FORMAT SUB PS:RWB(Y),Q FIND DIFFERENCE OF NS FROM RECEIVE WINDOW BASE AND =7,Q MODULO EIGHT JMP DS02 DS01 EQU $ POSITION AND MASK EXTENDED FORMAT NS VALUE SUB PS:RWB(Y),Q FIND DIFFERENCE OF NS FROM RECEIVE WINDOW BASE AND =127,Q MODULO ONE TWENTY-EIGHT DS02 EQU $ CHECK VALIDITY OF RECEIVE FRAME NS VALUE MOD:A +=1,+PS:RHS,-PS:RWB COMPUTE RECEIVE HIGH SEQUENCE PLUS ONE OFFSET JEQ A,DS04 JUMP IF NO FRAMES ABOVE BASE PREVIOUSLY SEEN SUB Q,A COMPARE OFFSET OF FRAME WITH NEXT OUT OF ORDER JEQ A,DS05 JUMP IF NEXT OUT OF ORDER FRAME JGT A,DS06 JUMP IF IN WINDOW BUT BELOW HIGH SEQUENCE DS03 EQU $ RETURN WITH CODE FOR INVALID SEQUENCE NUMBER COPY =-1,Q SET RETURN VALUE FOR OUTSIDE RANGE RSK RETURN TO CALLER DS04 EQU $ CHECK FOR FIRST OUT OF ORDER FRAME COPY Q,A COPY OFFSET OF THIS RECEIVE FRAME IN WINDOW SHIFT A,RO,1 CHECK IF OFFSET ZERO OR ONE JNE A,DS03 REJECT AS INVALID NUMBER IF OFFSET GREATER DS05 EQU $ SET NEW RECEIVE HIGH SEQUENCE VALUE MOD:A +Q,+PS:RWB COMPUTE SEQUENCE NUMBER OF FRAME COPY A,PS:RHS(Y) SAVE AS NEW RECEIVE HIGH SEQUENCE DS06 EQU $ RETURN WITH FRAME IN WINDOW BUT NOT HIGHEST RSK RETURN TO CALLER WITH OFFSET * LPOOL TITL SET:FRMR - ESTABLISH FRAME REJECT CONDITION * * SET:FRMR * * PROCEDURE SETS UP THE INFORMATION FIELD OF A FRAME REJECT FRAME IN *  THE PROTOCOL STATE TABLE BUFFER, AND EITHER ESTABLISHES A FRAME * REJECT CONDITION (IF A SECONDARY OR COMBINED STATION) OR SETS UP * REINITIALIZATION OF THE LINK (PRIMARY STATION). * * CALL PARAMETERS: * A - MASK FOR CONDITIONS CAUSING FRAME REJECT * X - BASE ADDRESS OF EVENT INFORMATION BLOCK FOR RECEIVED FRAME * * RETURN PARAMETERS: * A - DESTROYED * X - UNCHANGED * SET:FRMR EQU $ COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS BITS:EXT Q,PMF:CLS EXTRACT THE CURRENT LINK STATE FIELD CLSN Q,=PST:DISC CHECK IF CURRENTLY IN DISCONNECTED STATE JMP SF01 IGNORE INVALID FRAME IF SO COPY A,PS:FRC(Y) SAVE MASK FOR CONDITIONS CAUSING FRAME REJECT COPY EI:FRM(X),A COPY OVER FIRST TWO WORDS OF FRAME COPY A,PS:FRF(Y) COPY EI:FRM+1(X),A COPY A,PS:FRF+1(Y) COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:ON A,PCF:FRC SET FRAME REJECT CONDITION ESTABLISHED FLAG COPY A,PS:PCF(Y) COPY EI:ECI(X),A EVENT CONTROL INFORMATION TBIT ECI:PSF,A PRIMARY STATION FUNCTION FLAG JF OV,SF01 JUMP IF A COMMAND FRAME CAUSING PROBLEM COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:ON A,MCF:MSR SET FLAG FOR MODE SETTING REQUIRED COPY A,PS:MCF(Y) SF01 EQU $ IGNORE INVALID RECEIVED FRAME RSK RETURN TO CALLER TITL PROC:INF - PROCESS RECEIVED INFORMATION FRAME * * PROC:INF * * PROCEDURE VALIDATES THE RECEIVED INFORMATION FRAME, PROCESSES THE * ACKNOWLE2 DGEMENT SEQUENCE NUMBER, AND DISPOSES OF THE RECEIVED * FRAME (EITHER DISCARDED, QUEUED FOR EVENTUAL RETURN TO USER, OR *  IMMEDIATELY RETURNED TO USER). * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT INFORMATION BLOCK FOR RECEIVED FRAME * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * PROC:INF EQU $ PUSH STATUS: SAVE CALLING REGISTERS ON STACK PAIRS: ECI:PSF#ECI:SSF,POF:ICO#POF:IRO CHECK FLAG PAIRS COPY EI:ECI(X),A EVENT CONTROL INFORMATION BITS:OUT A,ECI:PSF,ECI:SSF MASK OUT STATION FUNCTION FLAGS SHIFT: A,POF:IRO-ECI:SSF POSITION TO MATCH EXCLUSION FLAGS AND PS:POF(Y),A MATCH STATION FUNCTION AGAINST EXCLUSION JEQ A,PI01 JUMP IF CORRECT STATION FUNCTION BITS:VAL A,FRC:W,FRC:X SET INVALID CONTROL FIELD AND INFORMATION FIELD JSK SET:FRMR ESTABLISH FRAME REJECT CONDITION JMP PI05 PI01 EQU $ FRAME IS OF CORRECT TYPE FOR INFORMATION TRANSFER COPY EI:ECI(X),Q CONTROL INFORMATION FROM FRAME EIB TBIT ECI:OVR,Q BUFFER OVERRUN FLAG JF OV,PI02 JUMP UNLESS FRAME OVERRAN BUFFER COPY EI:BIB(X),A BASE ADDRESS OF BIB ASSOCIATED WITH FRAME JEQ A,PI02 JUMP UNLESS USER BUFFER WAS INCLUDED BITS:VAL A,FRC:Y SET INFORMATION FRAME TOO LONG CONDITION JSK SET:FRMR ESTABLISH FRAME REJECT JMP PI05 PI02 EQU $ INFORMATION FIELD OF FRAME IS NOT TOO LONG JSK DECOD:NR COMPUTE ACKNOWLEDGEMENT OFFSET AND VALIDATE JGT Q,PI03 JUMP IF VALID NR OFFSET ABOVE WINDOW BASE JEQ Q,PI04 JUMP IF NR VALUE AT WINDOW BASE BITS:VAL A,FRC:Z SET INVALID NR VALUE CONDITION JSK SET:FRMR ESTABLISH FRAME REJECT  JMP PI05 PI03 EQU $ NR VALUE IN FRAME IS VALID AND NEW JSK PROC:ACK PROCESS RECEIVED ACKNOWLEDGEMENT PI04 EQU $ NR VALUE IN FRAME IS VALID AND OLD JSK DECOD:NS COMPUTE RECEIVE FRAME SEQUENCE OFFSET AND VALIDATE JLT Q,PI05 JUMP IF AMBIGUOUS OR OUTSIDE RANGE COPY EI:BIB(X),X BASE ADDRESS OF BIB USED FOR RECEIVE FRAME JEQ X,PI05 JUMP IF NO BIB USED MOD:Q ,+PS:RWB FORM ACTUAL SEQUENCE NUMBER OF FRAME COPY Q,BI:SEQ(X) ENTER SEQUENCE NUMBER IN BIB COPY PS:POF(Y),A PROTOCOL OPTION FLAGS BITS:EXT A,POF:SREJ EXTRACT SELECTIVE REJECT ENABLE BIT XNX A USE AS INDEX FOR PROCEDURE SELECTION JSK *ACP:TABL PERFORM ACCEPTANCE PROCESSING FOR FRAME JMP PI05 DISCARD UNACCEPTED RECEIVED FRAME COPY K,X CURRENT STACK POINTER ADDRESS COPY STK:X(X),X BASE ADDRESS OF EIB FOR RECEIVE FRAME COPY =0,A SET NULL BIB ADDRESS FOR FRAME COPY A,EI:BIB(X) PI05 EQU $ RESTORE REGISTERS AND EXIT POP  RESTORE ALL CALLING REGISTERS RSK RETURN TO CALLER * ACP:TABL EQU $ ACCEPTANCE PROCESSING PROCEDURE TABLE WORD ACPT:SEQ SEQUENTIAL ACCEPTANCE PROCEDURE WORD ACPT:SEL SELECTIVE ACCEPTANCE PROCEDURE * LPOOL TITL PROC:SUP - PROCESS RECEIVED SUPERVISORY FRAME * * PROC:SUP * * PROCEDURE VALIDATES THE RECEIVED SUPERVISORY FRAME AND PROCESSES * THE ACKNOWLEDGEMENT INFORMATION CONTAINED IN THE FRAME. * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT INFORMATION BLOCK FOR RECEIVED FRAME * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * PROC:SUP EQU $ PUSH STATUS: SAVE CALLING REGISTERS ON STACK COPY X,Q SAVE BASE ADDRESS OF EIB COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:PIB(X),X BASE ADDRESS OF PIB COPY PI:VSC(X),X VALID SUPERVISORY FRAME CODES MASK EXCH X,Q SWAP BACK REGISTERS COPY EI:FRM(X),A FIRST WORD OF FRAME AND =:C,A MASK SUPER3 VISORY FRAME CODE SHIFT A,LO,2 POSITION FRAME CODE IN SHIFT SKELETON XNX A USE FRAME CODE AS INDEX FOR BIT SELECTION SHIFT Q,RO,1 MASK BIT FOR FRAME CODE TO OVERFLOW JT OV,PS01 JUMP IF VALID SUPERVISORY FRAME CODE BITS:VAL A,FRC:W SET INVALID/UNIMPLEMENTED CONTROL FIELD JSK SET:FRMR ESTABLISH FRAME REJECT CONDITION JMP PS05 PS01 EQU $ VALID SUPERVISORY FRAME CODE COPY EI:HDL(X),Q FRAME HEADER LENGTH CSK Q,=3 VALIDATE LENGTH OF FRAME HEADER JMP $+2 NORMAL FORMAT FRAME HEADER JMP PS02 REJECT FRAME IF LONGER THAN EXTENDED COPY EI:BIB(X),Q BASE ADDRESS OF BIB JNE Q,PS02 REJECT FRAME IF A BIB IS PRESENT JSK DECOD:NR COMPUTE ACKNOWLEDGEMENT OFFSET AND VALIDATE JGT Q,PS03 JUMP IF VALID NR ABOVE WINDOW BASE JEQ Q,PS04 JUMP IF VALID NR AT WINDOW BASE  BITS:VAL A,FRC:Z SET INVALID NR VALUE CONDITION JSK SET:FRMR ESTABLISH FRAME REJECT JMP PS05 PS02 EQU $ RECEIVED FRAME TOO LONG FOR SUPERVISORY FORMAT BITS:VAL A,FRC:W,FRC:X SET ILLEGAL INFORMATION FIELD JSK SET:FRMR ESTABLISH FRAME REJECT CONDITION JMP PS05 PS03 EQU $ RECEIVE FRAME NR ABOVE WINDOW BASE JSK PROC:ACK PROCESS RECEIVED ACKNOWLEDGEMENT PS04 EQU $ RECEIVE FRAME NR AT WINDOW BASE COPY EI:FRM(X),Q FIRST WORD OF RECEIVED FRAME COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS SBIT PIF:PTE,A ASSUME TRANSMIT INFORMATION TRANSFER ENABLED AND =:F,Q MASK SUPERVISORY FRAME CODE FIELD CLSN =SUP:RNR,Q CHECK FOR RECEIVE NOT READY CODE RBIT PIF:PTE,A RESET TRANSMIT INFORMATION TRANSFER ENABLED COPY A,PS:PIF(Y) SAVE MODE FLAGS WITH CORRECT STATE SET CLSN =SUP:REJ,Q CHECK FOR REJECT CODE JSK RESC:ALL SCHEDULE RETRANSMISSION OF ALL WAITING FRAMES CLSN =SUP:SREJ,Q CHECK FOR SELECTIVE REJECT CODE JSK RESC:ONE SCHEDULE RETRANSMISSION OF FIRST WAITING FRAME PS05 EQU $ RESTORE REGISTERS AND EXIT POP RESTORE ALL CALLING REGISTERS RSK RETURN TO CALLER TITL UNN:INFO - UNNUMBERED INFORMATION FRAME PROCESSING * * UNN:INFO * * PROCEDURE ACCEPTS A RECEIVED UNNUMBERED INFORMATION FRAME, AND * RETURNS THE ASSOCIATED READ REQUEST COMPLETED, IF SUFFICIENT * RECEIVE BUFFERS ARE AVAILABLE. * * CALL PARAMETERS: * X - BASE ADDRESS OF RECEIVE FRAME EVENT INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * UNN:INFO EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY PS:LCB(Y),X BASE ADDRESS OF LCB COPY LC:RRC(X),Q COUNT OF READY FOR RECEIVE REQUESTS JNE Q,UI01 JUMP IF OTHER BUFFERS ARE AVAILABLE COPY LC:DIB(X),X BASE ADDRESS OF DIB COPY DI:RQH(X),Q ADDRESS OF FIRST BIB ON QUEUE JEQ Q,UI02 JUMP IF NO OTHER BUFFERS AVAILABLE UI01 EQU $ ABLE TO ACCEPT UNNUMBERED INFORMATION FRAME COPY K,X CURRENT STACK POINTER ADDRESS COPY STK:X(X),X BASE ADDRESS OF RECEIVE FRAME EIB COPY =0,A GET BASE ADDRESS OF BIB AND SET NULL EXCH A,EI:BIB(X) JEQ A,UI02 JUMP IF NO BIB USED FOR FRAME COPY A,X BASE ADDRESS OF BIB COPY BI:ORF(X),A OPERATION REQUEST FLAGS BITS:ON A,ORF:NSI SET NON-SEQUENTIAL INFORMATION FLAG COPY A,BI:ORF(X) COPY =TRM:NORM,Q SET NORMAL TERMINATION CODE JSK RET:REQ RETURN REQUEST TO THE USER UI02 EQU $ RESTORE CALLING REGISTERS AND RETURN POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER TITL SET:RESP - SET UP TO TRANSMIT SPECIFIC UNNUMBERED RESPONSE * * SET:RESP * * PROCEDURE SETS UP TO TRANSMIT A4  SPECIFIED UNNUMBERED RESPONSE * FRAME, PROVIDED THE TRANSMISSION OF SOME OTHER SPECIFIC UNNUMBERED * RESPONSE FRAME IS NOT PENDING. * * CALL PARAMETERS: * Q - SPECIFIC UNNUMBERED RESPONSE FRAME TYPE CODE * * RETURN PARAMETERS: *  A - DESTROYED * Q,X - UNCHANGED * SET:RESP EQU $ COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS TBIT PCF:SRP,A SPECIFIC RESPONSE PENDING FLAG JT OV,SR01 JUMP IF SPECIFIC RESPONSE ALREADY PENDING BITS:OFF A,PCF:SRT MASK OFF THE SPECIFIC RESPONSE TYPE CODE BITS:ON A,PCF:SRP SET SPECIFIC RESPONSE PENDING FLAG OR Q,A MERGE IN SPECIFIC RESPONSE TYPE CODE COPY A,PS:PCF(Y) SR01 EQU $ RETURN TO CALLER RSK * LPOOL TITL INFO:CMD - ENTRY TO INFORMATION TRANSFER STATE COMMANDED * * INFO:CMD * *  PROCEDURE CHECKS THE ALLOWABILITY OF A REQUESTED MODE CHANGE, * PERFORMS THE CHANGE TO THE COMMANDED MODE IF ALLOWABLE, AND SETS * UP TO TRANSMIT THE APPROPRIATE RESPONSE. * * CALL PARAMETERS: * A - FLAGS FOR MODE AND CONTROL FIELD TYPE COMMANDED * * RETURN PARAMETERS: * A,Q,X - DESTROYED * INFO:CMD EQU $ COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS BITS:EXT Q,PMF:RLS EXTRACT THE REQUESTED LINK STATE FIELD XOR =PST:INF,Q CHECK FOR INFORMATION TRANSFER STATE REQUESTED JNE Q,IC03 REJECT MODE SETTING COMMAND IF NOT COPY A,Q COPY FLAGS FOR MODE COMMANDED AND PS:LOF(Y),Q MASK AGAINST PERMITTED MODES OF OPERATION XOR A,Q CHECK IF COMMANDED MODE IS PERMITTED JNE Q,IC03 REJECT MODE SETTING COMMAND IF IMPERMISSIBLE MODE COPY PS:MCF(Y),Q MODE CONDITION FLAGS TBIT MCF:MSO,Q MODE SETTING COMMAND OUTSTANDING FLAG JF OV,IC02 JUMP IF NONE ARE OUTSTANDING COPY PS:MCF(Y),Q MODE CONDITION FLAGS BITS:ON Q,MCF:MSS SET MODE SETTING COMMAND RECEIVED FLAG COPY Q,PS:MCF(Y) SHIFT: Q,LOF:ESN-MCF:ESN POSITION EXTENDED SEQUENCE NUMBERING FLAG XOR A,Q MATCH AGAINST CONTROL FIELD FORMAT COMMANDED TBIT LOF:ESN,Q CHECK IF FLAGS MATCH JF OV,IC01 ACCEPT MODE SETTING COMMAND IF SAME FORMAT COPY PS:MCF(Y),Q MODE CONDITION FLAGS TBIT MCF:ESN,Q SETTING EXTENDED SEQUENCE NUMBERING FLAG JT OV,IC03 JUMP IF NORMAL FORMAT COMMANDED BITS:ON Q,MCF:SUS SET FLAG FOR MODE SETTING SUSPENDED COPY Q,PS:MCF(Y) JMP IC03 REJECT MODE SETTING COMMAND IC01 EQU $ MODE SETTING COMMAND RECEIVED SAME AS SENT COPY PS:MCF(Y),Q MODE CONDITION FLAGS BITS:OFF Q,MCF:MSO,MCF:RSO TURN OFF FLAGS FOR MODE SETTING OUTSTANDING COPY Q,PS:MCF(Y) IC02 EQU $ ACCEPT MODE SETTING COMMAND BITS:VAL Q,PMF:CLS=PST:DISC INITIALIZE STATE TO FORCE CHANGE TBIT LOF:ESN,A EXTENDED CONTROL FIELD COMMANDED FLAG JF OV,$+2 JUMP IF NORMAL CONTROL FIELD COMMANDED BITS:ON Q,PMF:CFF SET EXTENDED CONTROL FIELD FORMAT FLAG BITS:OUT A,LOF:AS,LOF:AC MASK ASYNCHRONOUS MODES OF OPERATION JEQ A,$+2 JUMP IF USING NORMAL RESPONSE MODE BITS:ON Q,PMF:ROP TURN ON ASYNCHRONOUS RESPONSE OPPORTUNITY FLAG COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:OFF A,PMF:CFF,PMF:ROP,PMF:CLS RESET MODE FLAGS AND STATE OR Q,A MERGE IN NEW OPERATIONAL MODE FLAGS COPY A,PS:PMF(Y) BITS:VAL A,PMF:CLS=PST:INF SET INFORMATION TRANSFER STATE ACTIVE JSK SET:CURS BITS:VAL Q,PCF:SRT=UNR:UA%-2 SET UNNUMBERED ACKNOWLEDGE RESPONSE TYPE CODE JSK SET:RESP SET UP TO TRANSMIT THE RESPONSE RSK RETURN TO CALLER IC03 EQU $ MODE SETTING COMMAND REJECTED BITS:VAL A,PMF:CLS=PST:DISC SET 5 DISCONNECTED PROTOCOL STATE JSK SET:CURS BITS:VAL Q,PCF:SRT=UNR:DM%-2 SET DISCONNECTED MODE RESPONSE TYPE CODE JSK SET:RESP SET UP TO TRANSMIT RESPONSE FRAME RSK RETURN TO CALLER * LPOOL TITL PROC:UNC - PROCESS RECEIVED UNNUMBERED COMMAND FRAME * * PROC:UNC * * PROCEDURE VALIDATES THE RECEIVED UNNUMBERED COMMAND FRAME AND * PROCESSES IT, SETTING UP FOR TRANSMISSION OF THE APPROPRIATE * RESPONSE FRAME, IF ANY IS REQUIRED. * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT INFORMATION BLOCK FOR RECEIVED FRAME * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * PROC:UNC EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY EI:FRM(X),A FIRST WORD OF FRAME COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:PIB(X),X BASE ADDRESS OF ACTIVE PIB COPY PI:VUC(X),Q ASSUME UNNUMBERED TYPE CODE IN FIRST SIXTEEN TBIT 7,A MOST-SIGNIFICANT BIT OF TYPE CODE JF OV,$+2 JUMP IF TYPE CODE IN FIRST SIXTEEN COPY PI:VUC+1(X),Q LOAD MASKS FOR SECOND SIXTEEN TYPE CODES COPY A,X COPY SHIFTED CONTROL FIELD OF FRAME AND =:60,A MASK BITS TWO AND THREE OF TYPE CODE AND =:C,X MASK BITS ZERO AND ONE OF FRAME CODE  SHIFT X,LO,1 POSITION LOW-ORDER BITS OF TYPE CODE OR X,A MERGE COMPACTED UNNUMBERED FRAME CODE SHIFT A,LO,1 POSITION FRAME TYPE CODE IN SHIFT SKELETON COPY K,X CURRENT STACK POINTER ADDRESS COPY STK:X(X),X BASE ADDRESS OF FRAME EIB XNX A USE FRAME CODE AS INDEX FOR BIT SELECTION SHIFT Q,RO,1 MASK BIT FOR FRAME CODE TO OVERFLOW JT OV,UC01 JUMP IF VALID UNNUMBERED COMMAND CODE BITS:VAL A,FRC:W SET INVALID/UNIMPLEMENTED CONTROL FIELD JSK SET:FRMR ESTABLISH FRAME REJECT CONDITION JMP UC08 UC01 EQU $ VALID UNNUMBERED COMMAND CODE IN FRAME COPY EI:FRM(X),Q FIRST WORD OF FRAME AND =:EF,Q MASK OUT UNNUMBERED FRAME CODE CLSN Q,=UNC:XID CHECK FOR EXCHANGE IDENTIFICATION COMMAND JMP UC03 JUST PROCESS THE COMMAND IF SO CLSN Q,=UNC:UI CHECK FOR UNNUMBERED INFORMATION FRAME JMP UC04 JUST PROCESS THE COMMAND IF SO COPY EI:HDL(X),A FRAME HEADER LENGTH SUB =3,A COMPARE LENGTH OF FRAME HEADER WITH MAXIMUM JGT A,UC02 REJECT FRAME IF TOO LONG COPY EI:BIB(X),A BASE ADDRESS OF BIB FOR FRAME JEQ A,UC05 JUMP IF NO BIB PRESENT UC02 EQU $ FRAME IS TOO LONG FOR UNNUMBERED COMMAND BITS:VAL A,FRC:W,FRC:X SET INVALID INFORMATION FIELD JSK SET:FRMR ESTABLISH FRAME REJECT CONDITION JMP UC08 UC03 EQU $ EXCHANGE IDENTIFICATION COMMAND PROCESSING BITS:VAL Q,PCF:SRT=UNR:XID%-2 SET EXCHANGE IDENTIFICATION RESPONSE TYPE CODE JSK SET:RESP SET UP FOR TRANSMISSION OF RESPONSE FRAME JMP UC08 UC04 EQU $ UNNUMBERED INFORMATION COMMAND PROCESSING JSK UNN:INFO PROCESS UNNUMBERED INFORMATION FRAME JMP UC08 UC05 EQU $ FRAME IS VALID COMMAND CODE AND VALID LENGTH CLSN Q,=UNC:DISC PROCESS DISCONNECT COMMAND JMP UC06 CLSN Q,=UNC:RSET PROCESS RESET COMMAND JMP UC07 COPY =0,A SET NULL INITIAL FLAGS CLSN Q,=UNC:SNRM CHECK SET NORMAL MODE COMMAND BITS:VAL A,LOF:NSN,LOF:NS SET FLAGS FOR NORMAL SECONDARY CLSN Q,=UNC:SARM CHECK SET ASYNCHRONOUS MODE COMMAND BITS:VAL A,LOF:NSN,LOF:AS SET FLAGS FOR ASYNCHRONOUS SECONDARY CLSN Q,=UNC:SABM CHECK SET BALANCED MODE COMMAND BITS:VAL A,LOF:NSN,LOF:AC SET FLAGS FOR ASYNCHRONOUS COMBINED CLSN Q,=UNC:SNRE CHECK SET NORMAL MODE EXTENDED COMMAND BITS:VAL A,LOF:ESN,LOF:NS SET FLAGS FOR NORMAL EXTENDED SECONDARY CLSN6  Q,=UNC:SARE CHECK SET ASYNCHRONOUS MODE EXTENDED COMMAND BITS:VAL A,LOF:ESN,LOF:AS SET FLAGS FOR ASYNCHRONOUS EXTENDED SECONDARY CLSN Q,=UNC:SABE CHECK SET BALANCED MODE EXTENDED COMMAND BITS:VAL A,LOF:ESN,LOF:AC SET FLAGS FOR ASYNCHRONOUS EXTENDED COMBINED JEQ A,UC08 JUMP IF NOT A MODE SETTING COMMAND JSK INFO:CMD PROCESS MODE SETTING COMMAND JMP UC08 UC06 EQU $ DISCONNECT COMMAND PROCESSING BITS:VAL Q,PCF:SRT=UNR:UA%-2 SET UNNUMBERED ACKNOWLEDGE RESPONSE TYPE CODE JSK SET:RESP SET UP TO TRANSMIT RESPONSE FRAME BITS:VAL A,PMF:CLS=PST:DISC SET CURRENT LINK STATE TO DISCONNECTED JSK SET:CURS JMP UC08 UC07 EQU $ RESET COMMAND PROCESSING JSK RST:RECV RESET RECEIVE SIDE OF PROTOCOL LINK BITS:VAL Q,PCF:SRT=UNR:UA%-2 SET UNNUMBERED ACKNOWLEDGE RESPONSE TYPE CODE JSK SET:RESP SET UP FOR RESPONSE FRAME TRANSMISSION UC08 EQU $ RESTORE REGISTERS AND RETURN POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER * LPOOL TITL DISC:RSP - REMOTE STATION REPORTING DISCONNECTED STATE * * DISC:RSP * * PROCEDURE PROCESSES A DISCONNECT MODE RESPONSE. IF RECEIVED IN * RESPONSE TO AN INITIAL MODE SETTING COMMAND, ANOTHER MODE IS * SELECTED FOR THE NEXT ATTEMPT. IF RECEIVED WHILE THE PROTOCOL * LINK IS IN THE INFORMATION TRANSFER STATE, THE LINK STATE IS * CHANGED TO DISCONNECTED AND THE CHANGE IS REPORTED TO THE LINE * CONTROL ACTIVITY. OTHERWISE, THE RESPONSE IS IGNORED. * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT INFORMATION BLOCK FOR RECEIVED FRAME * * RETURN PARAMETERS: * A,Q,X - DESTROYED * DISC:RSP EQU $ COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:EXT A,PMF:CLS EXTRACT CURRENT LINK STATE FIELD CLSN A,=PST:DISC CHECK IF ALREADY IN DISCONNECTED LINK STATE JMP DP01 JUMP TO CHECK FOR MODE SETTING COMMAND RESPONSE BITS:VAL A,PMF:CLS=PST:DISC SET DISCONNECTED CURRENT LINK STATE JSK SET:CURS RSK RETURN TO CALLER DP01 EQU $ DISCONNECTED MODE RESPONSE WHILE DISCONNECTED COPY EI:ECI(X),A EVENT CONTROL INFORMATION TBIT ECI:PFF,A POLL/FINAL FRAME FLAG JF OV,DP03 IGNORE RESPONSE IF FINAL FLAG NOT SET COPY PS:MCF(Y),Q MODE CONDITION FLAGS TBIT MCF:MSO,Q MODE SETTING COMMAND OUTSTANDING FLAG JF OV,DP03 IGNORE RESPONSE IF NOT ATTEMPTING MODE SETTING BITS:OFF A,ECI:PFF FORCE OFF POLL FINAL FLAG COPY A,EI:ECI(X) RESTORE EVENT INFORMATION WORD BITS:ON Q,MCF:SUS FLAG MODE SETTING SUSPENDED UNTIL TIMEOUT BITS:OFF Q,MCF:MSO,MCF:RSO,MCF:DSO TURN OFF MODE SETTING FLAGS COPY Q,PS:MCF(Y) COPY PS:LOF(Y),A LINK OPTIONS FLAGS BITS:OUT A,LOF:ESN,LOF:NSN MASK OUT SEQUENCE NUMBERING FLAGS BITS:NOT A,LOF:ESN,LOF:NSN COMPLEMENT SEQUENCE NUMBERING FLAGS JNE A,DP02 JUMP IF ONLY ONE CONTROL FIELD FORMAT PERMITTED COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:NOT A,MCF:ESN COMPLEMENT THE EXTENDED SEQUENCE NUMBERING FLAG COPY A,PS:MCF(Y) TBIT MCF:ESN,A COMPLEMENTED EXTENDED SEQUENCE NUMBERING FLAG JF OV,DP03 JUMP IF PREVIOUSLY WAS EXTENDED CONTROL FIELD DP02 EQU $ CHECK IF ABLE TO TRY DIFFERENT RESPONSE MODE COPY PS:LOF(Y),A LINK OPTIONS FLAGS TBIT LOF:NP,A NORMAL PRIMARY STATION ENABLE FLAG JF OV,DP03 JUMP IF ONLY ASYNCHRONOUS RESPONSE MODE PERMITTED BITS:OUT A,LOF:AP ASYNCHRONOUS PRIMARY STATION ENABLE FLAG JF OV,DP03 JUMP IF ONLY NORMAL RESPONSE MODE PERMITTED COPY PS:MCF(Y),A MODE COND7 ITION FLAGS BITS:NOT A,MCF:ASY COMPLEMENT ASYNCHRONOUS RESPONSE OPPORTUNITY FLAG COPY A,PS:MCF(Y) DP03 EQU $ RETURN TO CALLER  RSK TITL INFO:RSP - ENTRY TO INFORMATION TRANSFER STATE ACKNOWLEDGED * * INFO:RSP * * PROCEDURE PROCESSES A RECEIVED ACKNOWLEDGEMENT RESPONSE TO A * TRANSMITTED MODE SETTING OR RESET COMMAND. THE MOST RECENTLY * COMMANDED MODE OF OPERATION IS ENTERED AND THE PROTOCOL LINK * STATE IS SET TO INFORMATION TRANSFER. * * CALL PARAMETERS: * X - BASE ADDRESS OF RECEIVED FRAME EIB * * RETURN PARAMETERS: * A,Q,X - DESTROYED * INFO:RSP EQU $ COPY PS:MCF(Y),A MODE CONDITION FLAGS TBIT MCF:RSO,A CHECK FOR A RESET COMMAND TRANSMITTED JT OV,IR01 PROCESS RESPONSE TO RESET COMMAND TBIT MCF:DSO,A CHECK FOR A DISCONNECT COMMAND TRANSMITTED JT OV,IR02 PROCESS RESPONSE TO DISCONNECT COMMAND TBIT MCF:MSO,A CHECK FOR ACTUAL MODE SETTING COMMAND JF OV,IR03 IGNORE RESPONSE IF NO COMMAND OUTSTANDING COPY EI:ECI(X),A EVENT CONTROL INFORMATION TBIT ECI:PFF,A POLL/FINAL FRAME FLAG JF OV,IR03 IGNORE RESPONSE IF FINAL FLAG NOT SET COPY PS:MCF(Y),A MODE CONDITION FLAGS COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS BITS:OFF Q,PMF:CFF,PMF:ROP ASSUME NORMAL RESPONSE AND FORMAT TBIT MCF:ESN,A EXTENDED CONTROL FIELD FORMAT FLAG JF OV,$+2 JUMP IF CORRECT ASSUMPTION MADE BITS:ON Q,PMF:CFF SET EXTENDED CONTROL FIELD FORMAT FLAG TBIT MCF:ASY,A ASYNCHRONOUS RESPONSE OPPORTUNITY FLAG JF OV,$+2 JUMP IF CORRECT ASSUMPTION MADE BITS:ON Q,PMF:ROP SET ASYNCHRONOUS RESPONSE OPPORTUNITY FLAG COPY Q,PS:PMF(Y) BITS:VAL A,PMF:CLS=PST:INF SET CURRENT STATE TO INFORMATION TRANSFER JSK FRC:CURS RSK  RETURN TO CALLER IR01 EQU $ RESET COMMAND COMPLETION PROCESSING JSK RST:RECV RESET RECEIVE SIDE OF PROTOCOL LINK JSK CHK:MODE CHECK IF MODE SETTING STILL REQUIRED RSK RETURN TO CALLER IR02 EQU $ DISCONNECT COMMAND COMPLETION PROCESSING BITS:VAL A,PMF:CLS=PST:DISC SET CURRENT STATE TO DISCONNECTED JSK FRC:CURS IR03 EQU $ RETURN TO CALLER RSK * LPOOL TITL PROC:UNR - PROCESS RECEIVED UNNUMBERED RESPONSE FRAME * * PROC:UNR * * PROCEDURE VALIDATES THE RECEIVED UNNUMBERED RESPONSE FRAME AND * PROCESSES IT. IF THE RECEIVED UNNUMBERED RESPONSE FRAME IS AN * UNNUMBERED ACKNOWLEDGEMENT AND A MODE SETTING COMMAND HAS BEEN * TRANSMITTED, THE NEW MODE IS ENTERED BY THIS PROCEDURE. * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT INFORMATION BLOCK FOR RECEIVED FRAME * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * PROC:UNR EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY EI:FRM(X),A FIRST WORD OF FRAME COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:PIB(X),X BASE ADDRESS OF ACTIVE PIB COPY PI:VUC+2(X),Q ASSUME UNNUMBERED RESPONSE CODE IN FIRST SIXTEEN TBIT 7,A MOST-SIGNIFICANT BIT OF TYPE CODE JF OV,$+2 JUMP IF CODE IN FIRST SIXTEEN COPY PI:VUC+3(X),Q LOAD MASK FOR VALID CODES IN SECOND SIXTEEN COPY A,X COPY CONTROL FIELD OF FRAME AND =:60,A MASK BITS THREE AND FOUR OF TYPE CODE AND =:C,X MASK BITS ZERO AND ONE OF TYPE CODE SHIFT X,LO,1 POSITION LOW-ORDER BITS OF TYPE CODE OR X,A MERGE THE TWO PORTIONS OF FRAME TYPE CODE SHIFT A,LO,1 POSITION FRAME TYPE CODE IN SHIFT SKELETON COPY K,X CURRENT STACK POINTER ADDRESS COPY STK:X(X),X BASE ADDRESS OF FRAME EIB XNX A USE 8 FRAME CODE AS INDEX FOR BIT SELECTION SHIFT Q,RO,1 MASK BIT FOR FRAME CODE TO OVERFLOW JT OV,UR01 JUMP IF A VALID UNNUMBERED RESPONSE CODE BITS:VAL A,FRC:W SET INVALID/UNIMPLEMENTED CONTROL FIELD JSK SET:FRMR ESTABLISH FRAME REJECT CONDITION JMP UR08 UR01 EQU $ VALID UNNUMBERED RESPONSE CODE IN FRAME COPY EI:FRM(X),Q FIRST WORD OF FRAME AND =:EF,Q MASK UNNUMBERED FRAME TYPE CODE CLSN Q,=UNR:UI CHECK FOR UNNUMBERED INFORMATION FRAME JMP UR03 JUST PROCESS THE RESPONSE IF SO CLSN Q,=UNR:XID CHECK FOR EXCHANGE IDENTIFICATION RESPONSE JMP UR08 IGNORE THE RESPONSE IF SO COPY EI:HDL(X),A FRAME HEADER LENGTH SUB =3,A CHECK LENGTH OF FRAME HEADER AGAINST MAXIMUM JGT A,UR02 JUMP IF FRAME TOO LONG FOR UNNUMBERED RESPONSE COPY EI:BIB(X),A BASE ADDRESS OF BIB JEQ A,UR04 JUMP IF NO BIB IS PRESENT UR02 EQU $ FRAME TOO LONG FOR UNNUMBERED RESPONSE BITS:VAL A,FRC:W,FRC:X SET UNPERMITTED INFORMATION FIELD PRESENT JSK SET:FRMR ESTABLISH FRAME REJECT CONDITION JMP UR08 UR03 EQU $ UNNUMBERED INFORMATION RESPONSE PROCESSING JSK UNN:INFO PROCESS UNNUMBERED INFORMATION FRAME JMP UR08 UR04 EQU $ VALID TYPE CODE AND VALID LENGTH FOR FRAME  CLSN Q,=UNR:UA PROCESS UNNUMBERED ACKNOWLEDGE RESPONSE JMP UR05 CLSN Q,=UNR:DM PROCESS DISCONNECTED MODE RESPONSE JMP UR06 CLSN Q,=UNR:FRMR PROCESS FRAME REJECT RESPONSE JMP UR07 XOR =UNR:RD,Q CHECK FOR REQUEST DISCONNECT RESPONSE JNE Q,UR08 IGNORE RESPONSE IF ANYTHING ELSE COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:ON A,MCF:RDR,MCF:MSR SET FLAGS TO PERFORM DISCONNECT COPY A,PS:MCF(Y) JMP UR08 UR05 EQU $ UNNUMBERED ACKNOWLEDGE RESPONSE PROCESSING JSK INFO:RSP PROCESS MODE SETTING RESPONSE JMP UR08 UR06 EQU $ DISCONNECT MODE RESPONSE PROCESSING JSK DISC:RSP PROCESS RECEIVED RESPONSE FOR IN DISCONNECTED MODE JMP UR08 UR07 EQU $ FRAME REJECT RESPONSE PROCESSING COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:ON A,PCF:FRR SET FRAME REJECT CONDITION REPORTED FLAG COPY A,PS:PCF(Y) COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:ON A,MCF:MSR SET FLAG FOR MODE SETTING REQUIRED COPY A,PS:MCF(Y) UR08 EQU $ RESTORE REGISTERS AND RETURN POP RESTORE ENTERING REGISTERS RSK RETURN TO CALLER TITL PROC:RFE - PROCESS RECEIVE FRAME EVENT * * PROC:RFE * * PROCEDURE VALIDATES A RECEIVE FRAME EVENT, PERFORMS APPROPRIATE * PROCESSING FOR THE TYPE OF FRAME RECEIVED, AND HANDLES POLL/FINAL * CYCLE COMPLETION. * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT INFORMATION BLOCK FOR RECEIVED FRAME * * RETURN PARAMETERS: * A,Q,X - DESTROYED * PROC:RFE EQU $ COPY EI:ECI(X),A EVENT CONTROL INFORMATION TBIT ECI:TCF,A TERMINATING LINE CONTROL FLAG JF OV,$+2 JUMP IF NOT TERMINATING CONTROL JSK RECV:REL PROCESS RELEASE OF RECEIVE CONTROL COPY EI:FRM(X),A FIRST WORD OF FRAME SHIFT A,RO,1 SHIFT OFF FIRST BIT OF CONTROL FIELD JT OV,PR01 JUMP UNLESS AN INFORMATION FRAME JSK PROC:INF PROCESS RECEIVED INFORMATION FRAME JMP PR04 PR01 EQU $ RECEIVED FRAME IS NOT AN INFORMATION FRAME SHIFT A,RO,1 SHIFT OFF SECOND BIT OF CONTROL FIELD JT OV,PR02 JUMP IF NOT A SUPERVISORY FRAME JSK PROC:SUP PROCESS RECEIVED SUPERVISORY FRAME JMP PR04 PR02 EQU $ RECEIVED UNNUMBERED FRAME COPY EI:ECI(X),Q EVENT CONTROL INFORMATION TBIT ECI:PSF,Q PRIMARY STATION FUNCTION FLAG JT OV,PR03 JUMP IF A RESPONSE FRAME 9  JSK PROC:UNC PROCESS UNNUMBERED COMMAND FRAME JMP PR04 PR03 EQU $ RECEIVED UNNUMBERED RESPONSE FRAME JSK PROC:UNR PROCESS UNNUMBERED RESPONSE FRAME PR04 EQU $ RELEASE THE REQUEST ASSOCIATED WITH FRAME COPY =0,A EXCH A,EI:BIB(X) LOAD ADDRESS OF BIB AND SET NULL JEQ A,PR05 JUMP IF NO BIB ADDRESS PRESENT COPY X,Q SAVE BASE ADDRESS OF EIB COPY PS:LCB(Y),X BASE ADDRESS OF LCB ADD =LC:RRH,X SET BASE ADDRESS OF POINTER BLOCK JSK PUT:REQ ADD REQUEST TO THE READY FOR RECEIVE QUEUE COPY PS:LCB(Y),X BASE ADDRESS OF LCB IMS LC:RRC(X) COUNT ANOTHER REQUEST PRESENT IN QUEUE NOP COPY LC:DIB(X),X BASE ADDRESS OF DIB COPY DI:RQS(X),X ADDRESS OF SEMAPHORE TO SIGNAL FOR BUFFER AVAILABLE JEQ X,$+2 JUMP IF NO SEMAPHORE ADDRESS GIVEN JSK R:SIG SIGNAL RECEIVE DRIVER FOR BUFFER AVAILABLE COPY Q,X RESTORE BASE ADDRESS OF EIB PR05 EQU $ POLL/FINAL FRAME PROCESSING COPY EI:ECI(X),Q EVENT CONTROL INFORMATION TBIT ECI:PFF,Q POLL/FINAL FRAME FLAG JF OV,PR07 JUMP IF NOT A POLL/FINAL FRAME COPY EI:FRM(X),A FIRST WORD OF RECEIVED FRAME AND =:3,A MASK OFF FORMAT SELECTION BITS SUB =:3,A CHECK FOR UNNUMBERED FORMAT FRAME TBIT ECI:PSF,Q PRIMARY STATION FUNCTION FLAG JT OV,PR06 JUMP IF A RESPONSE FRAME JSK END:FINL PERFORM END OF FINAL CYCLE PROCESSING COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:OFF A,PCF:TFO TURN OFF FLAG FOR FINAL FRAME TRANSMITTED COPY A,PS:PCF(Y) RSK RETURN TO CALLER PR06 EQU $ FINAL FLAG IN FRAME TERMINATING POLL CYCLE JSK END:POLL PERFORM END OF POLL CYCLE PROCESSING COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:OFF A,PCF:TPO TURN OFF FLAG FOR POLL FRAME TRANSMITTED COPY A,PS:PCF(Y) PR07 EQU $ RETURN TO CALLER RSK SPACE 2 END TITL SYNCHRONOUS HANDLER PROTOCOL TRANSMIT FRAME (93438-12/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * * EXTERNAL REFERENCES * EXTR GEN:EVNT EXTR SND:EVNT EXTR WRT:ACK EXTR CHK:TERM EXTR SET:CURS EXTR STRT:RSP * * EXTERNAL DEFINITIONS * NAM GEN:XMIT * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:A NAM G:A ENDC TITL PLUG:BYT - PLUG DATA BYTE IN FRAME BEING GENERATES * * PLUG:BYT * * PROCEDURE ENTERS A BYTE OF DATA INTO A TRANSMIT FRAME, AND * INCREMENTS THE COUNT OF BYTES PRESENT. * * CALL PARAMETERS: * A - DATA BYTE * X - BASE ADDRESS OF TRANSMIT FRAME EIB * * RETURN PARAMETERS: * A,X - UNCHANGED * Q - DESTROYED * PLUG:BYT EQU $ COPY EI:HDL(X),Q CURRENT LENGTH OF HEADER EXCH X,Y GET BASE ADDRESS INTO WORD INDEX EXCH Q,X AND CURRENT LENGTH INTO BYTE INDEX SBIT BM:,S ENTER BYTE MODE COPYB A,EI:FRM(X,Y) SAVE DATA BYTE IN GENERATED FRAME RBIT BM:,S EXIT BYTE MODE EXCH X,Q RESTORE EVERYTHING TO PROPER REGISTER EXCH Y,X IMS EI:HDL(X) COUNT ANOTHER CHARACTER IN FRAME RSK RETURN TO CALLER RSK TITL PLUG:STR - PLUG DATA STRING IN FRAME BEING GENERATED * * PLUG:STR * * PROCEDURE ENTERS A STRING OF DATA BYTES INTO A TRANSMIT FRAME, AND * UPDATES THE COUNT OF BYTES PRESENT. * * CALL PARAMETERS: * A - NUMBER OF BYTES IN STRING * Q - WORD ADDRESS OF STRING * X - BASE ADDRESS OF TRANSMIT FRAME EIB * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * PLUG:STR EQU $ PUSH STATUS: SAVE ALL ENTERING REGISTERS ON STACK COPY =0,Q INITIALIZE OFFSET FROM:  START OF STRING COPY K,X CURRENT STACK POINTER VALUE PG01 EQU $ LOOP FOR COPYING THE STRING INTO HEADER COPY STK:Q(X),Y BASE ADDRESS OF SOURCE STRING SBIT BM:,S ENTER BYTE MODE XNX Q INDEX BY BYTE NUMBER IN STRING COPYB 0(Y),A LOAD BYTE FROM SOURCE STRING RBIT BM:,S EXIT BYTE MODE COPY STK:X(X),Y BASE ADDRESS OF TRANSMIT FRAME EIB COPY EI:HDL(Y),X NUMBER OF BYTES OF HEADER IMS EI:HDL(Y) INCREMENT FOR NEXT TIME THROUGH SBIT BM:,S ENTER BYTE MODE COPYB A,EI:FRM(X,Y) SAVE DATA BYTE IN FRAME HEADER  RBIT BM:,S EXIT BYTE MODE COPY K,X CURRENT STACK POINTER VALUE ADD =1,Q INCREMENT THE BYTE OFFSET CSK Q,STK:A(X) COMPARE COUNT TRANSFERRED WITH TOTAL JMP PG01 LOOP UNLESS AT END OF STRING NOP POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL NEW:UXXX - GENERATE UNNUMBERED FRAME EVENT INFORMATION BLOCK * * NEW:UXXX * * PROCEDURE ALLOCATES AND INITIALIZES THE EVENT INFORMATION BLOCK * FOR AN UNNUMBERED FORMAT TRANSMIT FRAME. THE TWO ENTRY POINTS * DISTINGUISH BETWEEN COMMAND AND RESPONSE FRAMES. THE FRAME IS * GENERATED WITH THE POLL/FINAL FLAG SET, IF POSSIBLE. * * CALL PARAMETERS: * A - LENGTH OF CONTROL FIELD TO BE GENERATED (ZERO IF TO COMPUTE) * Q - UNNUMBERED TYPE CODE * * RETURN PARAMETERS: * A,Q - UNCHANGED * X - BASE ADDRESS OF EVENT INFORMATION BLOCK * NEW:UCMD EQU $ BITS:VAL X,ECI:PSF,ECI:TYP=E:XMTFRM SET TEMPLATE FOR TRANSMIT COMMAND JMP NU01 NEW:URSP EQU $ BITS:VAL X,ECI:SSF,ECI:TYP=E:XMTFRM SET TEMPLATE FOR TRANSMIT RESPONSE NU01 EQU $ BEGINNING OF ACTUAL PROCEDURE PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY X,A EVENT CONTROL INFORMATION TEMPLATE COPY PS:LCB(Y),Q BASE ADDRESS OF LCB JSK GEN:EVNT ALLOCATE AND INITIALIZE EIB COPY X,A BASE ADDRESS OF ALLOCATED EIB COPY K,X CURRENT STACK POINTER ADDRESS COPY STK:Q(X),Q UNNUMBERED TYPE CODE COPY A,STK:X(X) SAVE BASE ADDRESS OF EIB FOR RETURN COPY STK:A(X),A LENGTH OF FRAME TO BE GENERATED COPY STK:X(X),X RESTORE BASE ADDRESS OF ALLOCATED EIB COPY Q,EI:FRM(X) SAVE TYPE CODE IN FRAME TO TRANSMIT COPY =0,Q ZERO OUT EXTRA BYTE IN CASE EXTENDED FORMAT COPY Q,EI:FRM+1(X)  JNE A,NU02 JUMP IF LENGTH OF FRAME SPECIFIED COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:EXT A,PMF:CFF EXTRACT EXTENDED CONTROL FIELD FORMAT FLAG ADD =2,A ADD TWO FOR LENGTH OF NORMAL CONTROL FIELD NU02 EQU $ PLUG LENGTH AND CHECK POLL/FINAL COPY A,EI:HDL(X) SAVE LENGTH OF CONTROL HEADER PAIRS: ECI:PSF#ECI:SSF,PCF:TFO#PCF:TPO CHECK MATCHUP OF FLAG PAIRS COPY EI:ECI(X),A EVENT CONTROL INFORMATION COMP A COMPLEMENT TO INVERT FLAGS BITS:OUT A,ECI:PSF,ECI:SSF MASK OUT THE STATION FUNCTION FLAGS SHIFT: A,PCF:TPO-ECI:SSF POSITION TO MATCH POLL/FINAL OUTSTANDING FLAGS COPY PS:PCF(Y),Q PROTOCOL CONDITION FLAGS XOR A,Q SET POLL/FINAL OUTSTANDING FLAG IF RESET AND Q,A MASK FLAG AFFECTED TO CHECK STATE JEQ A,NU03 JUMP IF POLL/FINAL ALREADY OUTSTANDING COPY Q,PS:PCF(Y) SAVE PROTOCOL CONDITION FLAGS COPY EI:ECI(X),A EVENT CONTROL INFORMATION BITS:ON A,ECI:PFF SET THE POLL/FINAL FRAME FLAG COPY A,EI:ECI(X) COPY EI:FRM(X),A FIRST WORD OF FRAME SBIT 4,A SET NORMAL FORMAT POLL/FINAL FLAG COPY A,EI:FRM(X) COPY EI:HDL(X),A LENGTH OF CONTROL HEADER GENERATED CLSN A,=2 CHECK IF NORMAL FORMAT CONTROL FIELD JMP NU03 COPY =:0100,A SECO; ND WORD OF DATA FOR POLL/FINAL SET COPY A,EI:FRM+1(X) NU03 EQU $ RESTORE REGISTERS AND RETURN POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL NEW:SFRM - GENERATE SUPERVISORY FRAME EVENT INFORMATION BLOCK * * NEW:SFRM * *  PROCEDURE ALLOCATES AND INITIALIZES THE EVENT INFORMATION BLOCK * FOR A SUPERVISORY FORMAT TRANSMIT FRAME. * * CALL PARAMETERS: * Q - SUPERVISORY TYPE CODE * * RETURN PARAMETERS: * A,Q - UNCHANGED * X - BASE ADDRESS OF EVENT INFORMATION BLOCK * NEW:SFRM EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY =E:XMTFRM,A SET TRANSMIT FRAME EVENT TYPE CODE COPY PS:LCB(Y),Q SET LCB BASE ADDRESS JSK GEN:EVNT ALLOCATE AND INITIALIZE EIB COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:EXT A,PMF:CFF EXTRACT EXTENDED CONTROL FIELD FORMAT FLAG ADD =2,A ADD TWO FOR LENGTH OF NORMAL CONTROL FIELD COPY A,EI:HDL(X) SAVE LENGTH OF CONTROL HEADER TBIT 0,A EXTENDED CONTROL FIELD FORMAT FLAG COPY PS:RWB(Y),A RECEIVE WINDOW BASE SEQUENCE NUMBER COPY K,Y CURRENT STACK POINTER ADDRESS COPY STK:Q(Y),Q SUPERVISORY FRAME TYPE CODE FROM CALL JF OV,NS01 JUMP IF NORMAL CONTROL FIELD FORMAT COPY Q,EI:FRM(X) SAVE SUPERVISORY FRAME TYPE CODE IN FRAME AND =127,A RECEIVE WINDOW BASE MODULO ONE TWENTY-EIGHT SHIFT A,LO,9 POSITION TO HIGH-ORDER BYTE COPY A,EI:FRM+1(X) SAVE NR VALUE IN FRAME JMP NS02 GO TO RETURN TO USER NS01 EQU $ NORMAL CONTROL FIELD FORMAT NR GENERATION AND =7,A RECEIVE WINDOW BASE MODULO EIGHT SHIFT A,LO,5 POSITION RECEIVE WINDOW BASE SEQUENCE OR A,Q MERGE IN WITH SUPERVISORY FRAME TYPE CODE COPY Q,EI:FRM(X) SAVE IN FRAME NS02 EQU $ RETURN ADDRESS OF EIB FOR FRAME COPY K,Y CURRENT STACK POINTER ADDRESS COPY X,STK:X(Y) PLUG EIB BASE ADDRESS TO BE RETURNED POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER TITL NEW:IFRM - GENERATE INFORMATION FRAME EVENT INFORMATION BLOCK * *  NEW:IFRM * * PROCEDURE ALLOCATES AND INITIALIZES THE EVENT INFORMATION BLOCK * FOR A TRANSMIT INFORMATION FRAME. * * CALL PARAMETERS: * X - BASE ADDRESS OF BUFFER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q - UNCHANGED * X - BASE ADDRESS OF EVENT INFORMATION BLOCK * NEW:IFRM EQU $ PUSH STATUS: SAVE ENTERING REGISTERS ON STACK COPY =E:XMTFRM,A SET TRANSMIT FRAME EVENT TYPE CODE COPY PS:LCB(Y),Q SET LCB BASE ADDRESS JSK GEN:EVNT ALLOCATE AND INITIALIZE EVENT COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:EXT A,PMF:CFF EXTRACT EXTENDED CONTROL FIELD FORMAT FLAG ADD =2,A ADD TWO FOR LENGTH OF NORMAL CONTROL FIELD COPY A,EI:HDL(X) SAVE LENGTH OF CONTROL HEADER COPY PS:RWB(Y),A RECEIVE WINDOW BASE SEQUENCE NUMBER COPY K,Y CURRENT STACK POINTER ADDRESS COPY STK:X(Y),Y BASE ADDRESS OF BIB COPY Y,EI:BIB(X) SAVE BIB ADDRESS IN EIB COPY BI:ORF(Y),Q OPERATION REQUEST FLAGS TBIT ORF:NSI,Q NON-SEQUENTIAL INFORMATION FLAG JT OV,NI02 JUMP IF AN UNNUMBERED INFORMATION FRAME COPY EI:HDL(X),Q HEADER LENGTH COMPUTED FOR CONTROL FIELD CLSN Q,=2 COMPARE WITH NORMAL CONTROL FIELD LENGTH JMP NI01 JUMP IF USING NORMAL FORMAT COPY BI:SEQ(Y),Q SEQUENCE NUMBER TO USE FOR FRAME AND =127,Q SEQUENCE NUMBER MODULO ONE TWENTY-EIGHT SHIFT Q,LO,1 POSITION NS VALUE FOR FRAME COPY Q,EI:FRM(X) SAVE FIRST BYTE OF CONTROL FIELD IN FRAME SHIFT A,LO,9 POSITION NR V< ALUE FOR FRAME COPY A,EI:FRM+1(X) SAVE SECOND BYTE OF CONTROL FIELD IN FRAME JMP NI03 GO TO COPY USER HEADER INTO FRAME NI01 EQU $ NORMAL CONTROL FIELD FORMAT INFORMATION FRAME COPY BI:SEQ(Y),Q SEQUENCE NUMBER TO USE FOR FRAME AND =7,Q USE MODULO EIGHT ON SEQUENCE NUMBERS AND =7,A SHIFT A,LO,4 POSITION NR VALUE OR A,Q MERGE INTO CONTROL FIELD BYTE SHIFT Q,LO,1 FINISH POSITIONING OF VALUES COPY Q,EI:FRM(X) SAVE CONTROL FIELD BYTE IN FRAME JMP NI03 FINISH SET UP OF FRAME NI02 EQU $ UNNUMBERED INFORMATION FRAME COPY =UNC:UI,A SET TYPE CODE FOR UNNUMBERED INFORMATION FRAME COPY A,EI:FRM(X) COPY A,EI:FRM+1(X) SET THIRD BYTE TO ZERO IN CASE EXTENDED NI03 EQU $ COPY USER HEADER INTO FRAME COPY BI:ORF(Y),A OPERATION REQUEST FLAGS COPY K,Y CURRENT STACK POINTER ADDRESS COPY STK:X(Y),Q BASE ADDRESS OF BIB COPY X,STK:X(Y) PLUG EIB BASE ADDRESS TO BE RETURNED ADD =BI:HDR,Q SET WORD ADDRESS OF USER HEADER BITS:EXT A,ORF:EHL EXTRACT USER HEADER LENGTH FIELD JEQ A,NI04 JUMP IF NO USER HEADER GIVEN COPY STK:Y(Y),Y RESTORE SCRATCHPAD (PST) BASE ADDRESS JSK PLUG:STR ENTER USER HEADER IN STRING NI04 EQU $ RETURN TO CALLER POP  RESTORE ENTERING REGISTERS RSK RETURN TO CALLER * LPOOL TITL SEND:FRM - PREPARE AND SEND TRANSMIT FRAME EVENT * * SEND:FRM * * PROCEDURE SENDS A TRANSMIT FRAME EVENT TO THE TRANSMIT DRIVER * ACTIVITY. WHEN APPROPRIATE, TRANSMIT CONTROL OF THE * COMMUNICATIONS LINE IS YIELDED AFTER THE EVENT HAS BEEN SENT. * * CALL PARAMETERS: * X - BASE ADDRESS OF EVENT INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * * SEND:FRM EQU $ COPY EI:ECI(X),A EVENT CONTROL INFORMATION TBIT ECI:PFF,A POLL/FINAL FRAME FLAG JF OV,SF02 JUMP IF POLL/FINAL FLAG RESET IN FRAME TBIT ECI:PSF,A PRIMARY STATION FUNCTION FLAG JF OV,SF01 JUMP IF RESPONSE FRAME TRANSMISSION COPY PS:HTS(Y),Q HIGHEST TRANSMIT SEQUENCE NUMBER COPY Q,PS:LPS(Y) SET AS HIGHEST IN POLL SEQUENCE COPY PS:LOF(Y),Q LINK OPTIONS FLAGS TBIT LOF:MTP,Q MULTIPOINT LINE FLAG JF OV,SF02 JUMP IF POINT TO POINT LINE BITS:ON A,ECI:TCF SET FLAG FOR TERMINATING LINE CONTROL COPY A,EI:ECI(X) SAVE MODIFIED EVENT CONTROL INFORMATION JMP SF02 SEND THE FRAME TO TRANSMIT DRIVER SF01 EQU $ SENDING A RESPONSE FRAME WITH FINAL SET COPY PS:HTS(Y),Q HIGHEST TRANSMIT SEQUENCE NUMBER COPY Q,PS:LFS(Y) SET AS HIGHEST IN FINAL SEQUENCE SF02 EQU $ SEND FRAME EVENT TO TRANSMIT DRIVER COPY X,Q SAVE BASE ADDRESS OF EIB COPY PS:LCB(Y),X BASE ADDRESS OF LCB TBIT ECI:PSF,A PRIMARY STATION FUNCTION FLAG COPY LC:ADR(X),A LOCAL AND REMOTE STATION ADDRESSES JT OV,$+2 USE REMOTE ADDRESS IF COMMAND FRAME SHIFT A,LO,8 POSITION LOCAL STATION ADDRESS AND =:FF00,A MASK STATION ADDRESS BEING USED COPY Q,X COPY BACK BASE ADDRESS OF EIB OR EI:FRM(X),A MERGE STATION ADDRESS INTO FRAME COPY A,EI:FRM(X) COPY EI:ECI(X),A EVENT CONTROL INFORMATION FOR LATER USAGE COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:TDP(X),X BASE ADDRESS OF TRANSMIT DRIVER EPT JSK SND:EVNT SEND THE TRANSMIT FRAME EIB TO DRIVER COPY PS:LCB(Y),X BASE ADDRESS OF LCB IMS LC:TOC(X) INCREMENT COUNT OF TRANSMIT FRAMES OUTSTANDING NOP TBIT ECI:PFF,A POLL/FINAL FRAME FLAG JF OV,SF04 JUMP IF POLL/FINAL FLAG RESET IN FRAME TBIT ECI:SSF,A SECONDARY STATION FUNCTION FLAG JF OV,SF03 JUMP = IF PRIMARY STATION FUNCTION COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:ON A,PCF:TFO SET FLAG FOR TRANSMITTED FINAL COPY A,PS:PCF(Y) RSK RETURN TO CALLER SF03 EQU $ COMMAND FRAME TRANSMISSION WITH POLL COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:ON A,PCF:TPO,PCF:PFT SET FLAGS FOR POLL FRAME TRANSMITTED BITS:OFF A,PCF:FPT TURN OFF FLAG FOR FORCED POLL TRANSMISSION COPY A,PS:PCF(Y) JSK STRT:RSP START THE RESPONSE TIMER RUNNING SF04 EQU $ RETURN TO CALLER RSK * LPOOL TITL SEND:INF - SEND INFORMATION TRANSFER RELATED FRAME * * SEND:INF * * PROCEDURE DETERMINES THE TYPE OF TRANSMISSION TO BE PERFORMED FOR * A SUPERVISORY OR INFORMATION TRANSFER FORMAT FRAME AND SENDS THE * TRANSMIT FRAME EVENT. * * CALL PARAMETERS: * A - EVENT CONTROL INFORMATION SKELETON FOR FRAME * X - BASE ADDRESS OF EVENT INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * SEND:INF EQU $ COPY PS:PCF(Y),Q PROTOCOL CONDITION FLAGS TBIT ECI:SSF,A SECONDARY STATION FUNCTION FLAG JF OV,SI01 JUMP IF RESPONSE TRANSMISSION PROHIBITED TBIT PCF:TFO,Q TRANSMIT FINAL OUTSTANDING FLAG JF OV,SI04 JUMP IF NEED TO TRANSMIT FINAL FLAG TBIT ECI:PSF,A PRIMARY STATION FUNCTION FLAG JT OV,SI01 JUMP IF COMMAND TRANSMISSION PERMITTED COPY EI:FRM(X),Q FIRST WORD OF FRAME TO BE TRANSMITTED TBIT 0,Q CHECK TYPE OF FRAME JT OV,SI09 JUST DO TRANSMISSION IF SUPERVISORY FORMAT COPY A,EI:ECI(X) SAVE EVENT CONTROL INFORMATION JSK SEND:FRM PREPARE AND SEND TRANSMIT FRAME EVENT JSK STRT:RSP START THE RESPONSE TIMER RUNNING RSK RETURN TO CALLER SI01 EQU $ TRANSMIT AS A COMMAND FRAME BITS:OFF A,ECI:SSF FORCE TRANSMISSION AS A COMMAND FRAME TBIT PCF:TPO,Q TRANSMIT POLL OUTSTANDING FLAG JT OV,SI09 JUST DO THE TRANSMISSION IF POLL ALREADY SENT COPY PS:PIF(Y),Q PROTOCOL INFORMATION TRANSFER FLAGS TBIT PIF:PRE,Q RECEIVE DATA TRANSFER ENABLED FLAG JT OV,SI02 JUMP IF RECEIVE DATA TRANSFER ENABLED COPY EI:FRM(X),Q FIRST WORD OF FRAME TO BE TRANSMITTED TBIT 0,Q CHECK TYPE OF FRAME JF OV,SI09 TRANSMIT WITHOUT POLL IF INFORMATION FRAME SI02 EQU $ CHECK IF FRAME CAN BE SENT WITH POLL COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS TBIT PMF:ROP,Q ASYNCHRONOUS RESPONSE OPPORTUNITY FLAG JT OV,SI03 CHECK IF POLL NECESSARY FOR ASYNCHRONOUS COPY PS:TPH(Y),Q TRANSMIT PENDING QUEUE HEAD POINTER JNE Q,SI09 TRANSMIT WITHOUT POLL IF MORE INFORMATION FRAMES COPY PS:PIF(Y),Q PROTOCOL INFORMATION TRANSFER FLAGS TBIT PIF:NRS,Q NEW RECEIVE STATUS TYPE FLAG JT OV,SI09 TRANSMIT WITHOUT POLL IF STATUS NEEDS UPDATING JMP SI06 OTHERWISE TRANSMIT WITH POLL SI03 EQU $ CHECK IF POLL FRAME REQUIRED FOR ASYNCHRONOUS MOD:Q +=1,+PS:HTS,-PS:TWB CHECK IF UNACKNOWLEDGED FRAMES OUTSTANDING JNE Q,SI06 TRANSMIT WITH POLL FLAG IF SO COPY PS:PCF(Y),Q PROTOCOL CONDITION FLAGS TBIT PCF:FPT,Q FORCED POLL FRAME TRANSMISSION FLAG JT OV,SI06 SEND FRAME WITH POLL IF SET JMP SI09 OTHERWISE TRANSMIT WITHOUT POLL SI04 EQU $ DETERMINE TYPE OF TRANSMISSION FOR RESPONSE FRAME BITS:OFF A,ECI:PSF FORCE TRANSMISSION AS A RESPONSE FRAME COPY PS:PIF(Y),Q PROTOCOL INFORMATION TRANSFER FLAGS TBIT PIF:PRE,Q RECEIVE DATA TRANSFER ENABLED FLAG JT OV,SI05 JUMP IF RECEIVE DATA TRANSFER ENABLED COPY EI:FRM(X),Q FIRST WORD OF FRAME TO BE TRANSMITTED TBIT 0,Q CHECK TYPE OF FRAME JF OV,SI> 09 TRANSMIT WITHOUT FINAL IF INFORMATION FRAME SI05 EQU $ CHECK IF FRAME CAN BE SENT WITH FINAL COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS TBIT PMF:ROP,Q ASYNCHRONOUS RESPONSE OPPORTUNITY FLAG JT OV,SI06 TRANSMIT WITH FINAL IF ASYNCHRONOUS OPERATION COPY PS:TPH(Y),Q TRANSMIT PENDING QUEUE HEAD POINTER JNE Q,SI09 TRANSMIT WITHOUT POLL IF MORE INFORMATION FRAMES COPY PS:PIF(Y),Q PROTOCOL INFORMATION TRANSFER FLAGS TBIT PIF:NRS,Q NEW RECEIVE STATUS TYPE FLAG JT OV,SI09 TRANSMIT WITHOUT FINAL IF STATUS NEEDS UPDATING SI06 EQU $ TRANSMIT FRAME WITH POLL/FINAL BIT SET BITS:ON A,ECI:PFF SET POLL/FINAL FRAME FLAG COPY EI:FRM(X),Q FIRST WORD OF FRAME TBIT 0,Q CHECK TYPE OF FRAME JT OV,SI07 JUMP IF A SUPERVISORY FRAME COPY PS:PIF(Y),Q PROTOCOL INFORMATION TRANSFER FLAGS BITS:ON Q,PIF:PRE SET FLAG FOR RECEIVE DATA TRANSFER ENABLED COPY Q,PS:PIF(Y) SI07 EQU $ SET POLL/FINAL BIT IN FRAME COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS TBIT PMF:CFF,Q CONTROL FIELD FORMAT FLAG JT OV,SI08 JUMP IF USING EXTENDED CONTROL FIELD FORMAT COPY EI:FRM(X),Q FIRST WORD OF FRAME SBIT 4,Q SET NORMAL FORMAT POLL/FINAL FLAG COPY Q,EI:FRM(X) SAVE MODIFIED WORD BACK IN FRAME JMP SI09 SI08 EQU $ SET POLL/FINAL BIT IN EXTENDED FORMAT FRAME COPY EI:FRM+1(X),Q SECOND WORD OF FRAME SBIT 8,Q SET EXTENDED FORMAT POLL/FINAL FLAG COPY Q,EI:FRM+1(X) SAVE MODIFIED WORD BACK IN FRAME SI09 EQU $ SET UP AND SEND THE FRAME  COPY A,EI:ECI(X) SAVE EVENT CONTROL INFORMATION JSK SEND:FRM PREPARE AND SEND TRANSMIT FRAME EVENT RSK RETURN TO CALLER TITL GEN:FRMR - GENERATE FRAME REJECT RESPONSE FRAME * * GEN:FRMR * * PROCEDURE GENERATES AND TRANSMITS A FRAME REJECT RESPONSE FRAME, * IF NONE HAS PREVIOUSLY BEEN TRANSMITTED OR A RECEIVE POLL IS * OUTSTANDING. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * GEN:FRMR EQU $ COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS TBIT PCF:FRT,A CHECK FOR FRAME REJECT RESPONSE TRANSMITTED JF OV,GF01 JUMP IF NONE HAS BEEN TRANSMITTED YET TBIT PCF:TFO,A TRANSMIT FINAL FRAME OUTSTANDING FLAG JT OV,GF04 JUMP IF NO RECEIVE POLL OUTSTANDING GF01 EQU $ GENERATE FRAME REJECT RESPONSE FRAME COPY =0,A USE NORMAL CONTROL FIELD FOR CURRENT MODE COPY =UNR:FRMR,Q SET FRAME REJECT FRAME CODE JSK NEW:URSP ALLOCATE AND INITIALIZE EIB FOR RESPONSE FRAME COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:EXT A,PMF:CFF EXTRACT EXTENDED CONTROL FIELD FORMAT FLAG ADD =1,A ADD ONE FOR BASIC CONTROL FIELD COPY Y,Q BASE ADDRESS OF PST ADD =PS:FRF,Q ADDRESS OF REJECT FRAME CONTROL FIELD JSK PLUG:STR PLUG REJECT FRAME CONTROL FIELD IN FRAME COPY PS:HTS(Y),A HIGHEST TRANSMIT SEQUENCE NUMBER ADD =1,A INCREMENT TO WHAT NEXT WOULD BE COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS TBIT PMF:CFF,Q EXTENDED CONTROL FIELD FORMAT FLAG JT OV,GF02 JUMP IF USING EXTENDED FORMAT SHIFT A,LO,4 POSITION SEND VARIABLE VALUE COPY PS:FRC(Y),Q FRAME REJECT CAUSE INFORMATION TBIT FRC:C,Q CAUSED BY COMMAND FRAME FLAG JF OV,$+2 JUMP UNLESS REJECT FRAME WAS A COMMAND OR =8,A SET FLAG FOR CAUSED BY COMMAND COPY PS:RWB(Y),Q RECEIVE WINDOW BASE SEQUENCE NUMBER AND =7,Q USE MODULO EIGHT ON RECEIVE VARIABLE VALUE OR Q,A MERGE INTO FRAME REJECT INFORMATION JSK PLUG:BYT PLUG FRAME REJECT INFORMATION IN FRAME JMP GF03 GF02 EQU $ FRAME REJECT WITH EXTENDED ? CONTROL FIELD AND =127,A USE MODULO ONE TWENTY-EIGHT ON SEND VARIABLE VALUE JSK PLUG:BYT PLUG SEND VARIABLE VALUE COPY PS:RWB(Y),A RECEIVE WINDOW BASE SEQUENCE NUMBER SHIFT A,LO,1 POSITION RECEIVE VARIABLE VALUE COPY PS:FRC(Y),Q FRAME REJECT CAUSE FLAGS TBIT FRC:C,Q REJECT FRAME A COMMAND FLAG SHIFT A,LO,1 POSITION RECEIVE VARIABLE AND GET COMMAND FLAG JSK PLUG:BYT PLUG FRAME REJECT INFORMATION IN FRAME GF03 EQU $ INSERT CAUSE FIELD AND TRANSMIT FRAME COPY PS:FRC(Y),A FRAME REJECT CAUSE FLAGS SHIFT A,RO,8 POSITION TO LOWER BYTE JSK PLUG:BYT PLUG CAUSE FLAGS IN GENERATED FRAME JSK SEND:FRM SEND GENERATED FRAME TO TRANSMIT DRIVER COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:ON A,PCF:FRT SET FRAME REJECT TRANSMITTED FLAG COPY A,PS:PCF(Y) GF04 EQU $ RETURN WITHOUT TRANSMITTING FRAME REJECT RESPONSE RSK RETURN TO CALLER * LPOOL TITL GEN:UNNR - GENERATE UNNUMBERED RESPONSE FRAME * * GEN:UNNR * * PROCEDURE GENERATES THE APPROPRIATE UNNUMBERED RESPONSE FRAME AND * SENDS IT TO THE TRANSMIT DRIVER ACTIVITY. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * GEN:UNNR EQU $ COPY PS:PCF(Y),Q PROTOCOL CONDITION FLAGS TBIT PCF:SRP,Q SPECIFIC RESPONSE PENDING FLAG JF OV,GR02 CHECK FOR FRAME REJECT PENDING IF NOT BITS:OFF Q,PCF:SRP TURN OFF THE SPECIFIC RESPONSE PENDING FLAG COPY Q,PS:PCF(Y) BITS:OUT Q,PCF:SRT MASK OUT TYPE OF SPECIFIC RESPONSE SHIFT: Q,2-PCF:SRTB POSITION TYPE VALUE FOR ACTUAL CODE OR =3,Q SET LOW-ORDER BITS FOR UNNUMBERED RESPONSE COPY =0,A SET TO USE COMPUTED CONTROL FIELD LENGTH JSK NEW:URSP ALLOCATE AND INITIALIZE EIB FOR RESPONSE FRAME COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:EXT A,PCF:SRT EXTRACT TYPE OF SPECIFIC RESPONSE SUB =UNR:XID%-2,A CHECK FOR EXCHANGE IDENTIFICATION RESPONSE JNE A,GR01 JUMP IF NOT EXCHANGE IDENTIFICATION COPY X,Q ADDRESS OF EIB FOR FRAME COPY PS:LCB(Y),X BASE ADDRESS OF LCB COPY LC:DIB(X),X BASE ADDRESS OF DIB COPY DI:PLS(X),A PROTOCOL LINK STATUS WORD BITS:EXT A,PLS:IDL EXTRACT LENGTH OF IDENTIFICATION SEQUENCE EXCH Q,X SWAP BACK REGISTERS CONTAINING ADDRESSES ADD =DI:IDS,Q SET ADDRESS OF IDENTIFICATION SEQUENCE JSK PLUG:STR PLUG IDENTIFICATION SEQUENCE IN FRAME GR01 EQU $ TRANSMIT SPECIFIC RESPONSE PENDING JSK SEND:FRM SEND GENERATED FRAME TO THE TRANSMIT DRIVER JSK CHK:TERM CHECK FOR TERMINATING PROTOCOL OPERATION RSK RETURN TO CALLER GR02 EQU $ CHECK FOR FRAME REJECT PENDING TRANSMISSION TBIT PCF:FRP,Q FRAME REJECT PENDING FLAG JF OV,GR03 JUMP IF NOT TO DO MODE SETTING BITS:OFF Q,PCF:FRP TURN OFF FRAME REJECT PENDING FLAG COPY Q,PS:PCF(Y) JSK GEN:FRMR GENERATE AND TRANSMIT FRAME REJECT RESPONSE RSK RETURN TO CALLER GR03 EQU $ NEITHER FRAME REJECT NOR SPECIFIC RESPONSE COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:EXT A,PMF:CLS EXTRACT CURRENT LINK STATE FIELD COPY =UNR:DM,Q SET DISCONNECTED MODE FRAME CODE CLSN A,=PST:DISC CHECK IF NOW IN DISCONNECTED STATE JMP GR04 SEND DISCONNECTED MODE RESPONSE IF SO COPY PS:POF(Y),A PROTOCOL OPTIONS FLAGS TBIT POF:RD,A REQUEST DISCONNECT ENABLED FLAG COPY =UNR:RD,Q ASSUME REQUEST DISCONNECT VALID JT OV,GR04 GENERATE REQUEST DISCONNECT FRAME IF SO COPY =0,A SET TO USE COMPUTED CONTROL FIELD LENGTH JSK NEW:URSP ALLOCATE AND INITIALIZE EIB FOR RESPONSE @ FRAME JSK SEND:FRM SEND THE FRAME TO THE TRANSMIT DRIVER BITS:VAL A,PMF:CLS=PST:DISC SET CURRENT MODE TO DISCONNECTED JSK SET:CURS RSK RETURN TO CALLER GR04 EQU $ GENERATE AND TRANSMIT UNNUMBERED RESPONSE COPY =0,A SET TO USE COMPUTED CONTROL FIELD LENGTH JSK NEW:URSP ALLOCATE AND INITIALIZE EIB FOR RESPONSE FRAME JSK SEND:FRM SEND THE FRAME TO THE TRANSMIT DRIVER JSK STRT:RSP START THE RESPONSE TIMER RUNNING COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:ON A,MCF:MRO SET MODE SETTING RESPONSE OUTSTANDING FLAG COPY A,PS:MCF(Y) RSK RETURN TO CALLER * LPOOL TITL GEN:UNNC - GENERATE UNNUMBERED COMMAND FRAME * * GEN:UNNC * * PROCEDURE GENERATES THE APPROPRIATE UNNUMBERED COMMAND FRAME AND * SENDS IT TO THE TRANSMIT DRIVER ACTIVITY. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * GEN:UNNC EQU $ COPY PS:PMF(Y),A PROTOCOL MODE FLAGS SHIFT: A,PMF:CLSB-PMF:RLSB POSITION REQUESTED LINK STATE FIELD XOR PS:PMF(Y),A MATCH AGAINST CURRENT LINK STATE BITS:OUT A,PMF:CLS JNE A,GC01 JUMP IF REQUESTED STATE DIFFERS FROM CURRENT COPY PS:PCF(Y),Q PROTOCOL CONDITION FLAGS TBIT PCF:FRC,Q FRAME REJECT ESTABLISHED FLAG JT OV,GC01 PERFORM MODE SETTING OPERATION IF SET TBIT PCF:FRR,Q FRAME REJECT REPORTED FLAG JF OV,GC02 JUMP IF NO FRAME REJECT REPORTED COPY PS:POF(Y),Q PROTOCOL OPTIONS FLAGS TBIT POF:MRO,Q MODE RESET ONLY ENABLED FLAG JT OV,GC01 PERFORM MODE RESET IF SET COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:ON A,MCF:RSO SET RESET COMMAND OUTSTANDING FLAG COPY A,PS:MCF(Y) COPY =0,A SET TO USE COMPUTED CONTROL FIELD LENGTH COPY =UNC:RSET,Q SET TYPE CODE FOR RESET COMMAND JMP GC03 SEND FRAME FOR TRANSMISSION AND RETURN GC01 EQU $ MODE SETTING COMMAND TRANSMISSION REQUIRED COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:EXT A,PMF:RLS EXTRACT REQUESTED LINK STATE SUB =PST:INF,A CHECK FOR INFORMATION TRANSFER STATE REQUESTED JNE A,GC02 ANYTHING ELSE GOES THROUGH DISCONNECTED STATE COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:NOT A,MCF:ASY GET COMPLEMENT OF ASYNCHRONOUS RESPONSE FLAG BITS:EXT A,MCF:ASY EXTRACT ASYNCHRONOUS RESPONSE OPPORTUNITY FLAG COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS TBIT PMF:SSF,Q SECONDARY STATION FUNCTION OPERATING FLAG ROTATE A,LO,1 INCLUDE AS SECOND BIT OF INDEX COPY PS:MCF(Y),Q MODE CONDITION FLAGS TBIT MCF:ESN,Q EXTENDED SEQUENCE NUMBERING ENABLED FLAG ROTATE A,LO,1 INCLUDE AS THIRD BIT OF INDEX XNX A INDEX INTO TABLE COPY MODETABL,Q LOAD APPROPRIATE UNNUMBERED COMMAND TYPE CODE COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:ON A,MCF:MSO SET MODE SETTING COMMAND OUTSTANDING FLAG COPY A,PS:MCF(Y) COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:EXT A,MCF:ESN EXTRACT EXTENDED SEQUENCE NUMBERING FLAG ADD =2,A ADD TWO FOR TOTAL CONTROL FIELD LENGTH JMP GC03 GO TO SEND FRAME AND RETURN GC02 EQU $ DISCONNECTED MODE DESIRED COPY =UNC:DISC,Q SET TYPE CODE FOR DISCONNECT COMMAND COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:ON A,MCF:DSO SET DISCONNECT COMMAND OUTSTANDING FLAG BITS:OFF A,MCF:RDR RESET REQUEST DISCONNECT RECEIVED FLAG COPY A,PS:MCF(Y) COPY =0,A SET TO USE COMPUTED CONTROL FIELD LENGTH GC03 EQU $ GENERATE FRAME EVENT AND QUEUE FOR TRANSMISSION JSK NEW:UCMD ALLOCATE AND INITIALIZE EIB FOR COMMAND FRAME JSK SEND:FRM PASS FRAME ON TO TRANSMIT DRIVER RSA K RETURN TO CALLER * MODETABL EQU $ TABLE OF UNNUMBERED COMMAND FRAME TYPE CODES WORD UNC:SARM ASYNCHRONOUS RESPONSE MODE, NORMAL FORMAT WORD UNC:SARE ASYNCHRONOUS RESPONSE MODE, EXTENDED FORMAT WORD UNC:SABM ASYNCHRONOUS BALANCED MODE, NORMAL FORMAT WORD UNC:SABE ASYNCHRONOUS BALANCED MODE, EXTENDED FORMAT WORD UNC:SNRM NORMAL RESPONSE MODE, NORMAL FORMAT WORD UNC:SNRE NORMAL RESPONSE MODE, EXTENDED FORMAT * LPOOL TITL GEN:SUPR - GENERATE SUPERVISORY FRAMES * * GEN:SUPR * * PROCEDURE GENERATES THE APPROPRIATE SUPERVISORY FRAME AND SENDS IT * TO THE TRANSMIT DRIVER ACTIVITY. * * CALL PARMETERS: *  NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * GEN:SUPR EQU $ COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS TBIT PIF:FCR,A RECEIVE BUFFERS UNAVAILABLE FLAG JT OV,GS03 GENERATE RECEIVE NOT READY IF NOT AVAILABLE TBIT PIF:ESR,A EXCEPTIONAL STATUS REPORTED FLAG JT OV,GS04 JUST SEND READY IF EXCEPTION REPORTED MOD:Q +=1,+PS:AHS COMPUTE ACCEPTED HIGH SEQUENCE PLUS ONE SUB PS:RWB(Y),Q COMPARE WITH RECEIVE WINDOW BASE SEQUENCE JEQ Q,GS01 JUMP UNLESS OUT OF ORDER RECEIVE CONDITION COPY =SUP:SREJ,Q ASSUME SELECTIVE REJECT ENABLED JMP GS02 GENERATE SELECTIVE REJECT FRAME GS01 EQU $ NO OUT OF ORDER FRAMES ACCEPTED MOD:Q +=1,+PS:RHS,-PS:RWB CHECK RECEIVE HIGH SEQUENCE OFFSET JEQ Q,GS04 JUMP IF NO OUT OF ORDER FRAMES SEEN COPY PS:POF(Y),Q PROTOCOL OPTIONS FLAGS TBIT POF:REJ,Q REJECT ENABLED FLAG JF OV,GS04 JUMP IF TRANSMISSION NOT ALLOWED COPY =SUP:REJ,Q ASSUME REJECT TRANSMISSION PERMITTED GS02 EQU $ SET EXCEPTIONAL STATUS REPORTED FLAG BITS:ON A,PIF:ESR SET EXCEPTIONAL STATUS REPORTED FLAG COPY A,PS:PIF(Y) JMP GS05 GO TO GENERATE AND SEND REJECT GS03 EQU $ RECEIVE NOT READY FRAME SELECTION BITS:OFF A,PIF:NRS,PIF:NRV,PIF:PRE RESET FLAGS FOR STATUS AND RECEIVE COPY A,PS:PIF(Y) COPY =SUP:RNR,Q SET TYPE CODE FOR RECEIVE NOT READY JMP GS06 GO TO GENERATE AND SEND RECEIVE NOT READY GS04 EQU $ RECEIVE READY FRAME SELECTION COPY =SUP:RR,Q SET TYPE CODE FOR RECEIVE READY GS05 EQU $ UPDATE FLAGS FOR ANY EXCEPT RECEIVE NOT READY COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS  BITS:OFF A,PIF:NRS,PIF:NRV RESET FLAGS FOR NEW RECEIVE STATUS BITS:ON A,PIF:PRE SET FLAG FOR RECEIVE DATA TRANSFER ENABLED COPY A,PS:PIF(Y) GS06 EQU $ GENERATE AND SEND THE SUPERVISORY FRAME JSK NEW:SFRM GENERATE FRAME WITH SPECIFIED TYPE CODE PAIRS: PMF:PSF#PMF:SSF,ECI:PSF#ECI:SSF CHECK FLAG PAIRS COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:OUT A,PMF:PSF,PMF:SSF MASK OUT STATION FUNCTION FLAGS SHIFT: A,ECI:SSF-PMF:SSF POSITION FOR EVENT CONTROL INFORMATION BITS:ON A,ECI:TYP=E:XMTFRM SET EVENT TYPE CODE FOR TRANSMIT FRAME JSK SEND:INF SEND FRAME EVENT TO TRANSMIT DRIVER RSK RETURN TO CALLER TITL GEN:INFO - GENERATE INFORMATION TRANSFER FRAMES * * GEN:INFO * * PROCEDURE GENERATES INFORMATION TRANSFER RELATED FRAMES AND SENDS *  THEM TO THE TRANSMIT DRIVER ACTIVITY. BOTH ACTUAL INFORMATION * TRANSFER FRAMES AND SUPERVISORY FRAMES ARE GENERATED, WITH THE * ORDER OF GENERATION DEPENDENT ON THE PROTOCOL OPTIONS IN USE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 WHEN A FRAME HAS BEEN * GENERAB TED AND MORE FRAMES MAY BE READY TO SEND; RETURN TO CALL+2 * WHEN ALL FRAMES READY FOR TRANSMISSION HAVE BEEN SENT. * GEN:INFO EQU $ COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:ROP,A ASYNCHRONOUS RESPONSE OPPORTUNITY FLAG JF OV,GI02 JUMP IF NORMAL RESPONSE OPPORTUNITY OPERATION COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS TBIT PIF:NRS,A NEW RECEIVE STATUS TYPE FLAG JT OV,GI01 GENERATE SUPERVISORY FRAME IF NEW TYPE COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS TBIT PCF:TFO,A TRANSMIT FINAL OUTSTANDING FLAG JT OV,GI02 JUMP IF TRANSMIT FINAL OUTSTANDING COPY PS:POF(Y),Q PROTOCOL OPTIONS FLAGS TBIT POF:ICO,Q INFORMATION TRANSFER BY COMMANDS ONLY FLAG JF OV,GI02 JUMP IF INFORMATION FRAME CAN BE A RESPONSE GI01 EQU $ GENERATE SUPERVISORY FRAME TO REPORT CONDITION JSK GEN:SUPR GENERATE SUPERVISORY FRAME TO REPORT NEW STATUS TYPE RSK RETURN TO CALLER FOR OUTSTANDING CHECK GI02 EQU $ CHECK IF ABLE TO TRANSMIT INFORMATION FRAMES COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS TBIT PIF:PTE,A TRANSMIT DATA TRANSFER ENABLED FLAG JF OV,GI07 JUMP IF TRANSMIT DISABLED GI03 EQU $ LOOP FOR GENERATING TRANSMIT INFORMATION FRAMES COPY PS:TPH(Y),X ADDRESS OF FIRST REQUEST ON PENDING QUEUE JEQ X,GI07 JUMP IF PENDING QUEUE EMPTY COPY BI:ORF(X),A OPERATION REQUEST FLAGS TBIT ORF:NSI,A NON-SEQUENTIAL INFORMATION FLAG JT OV,GI06 JUST SEND THE FRAME IF NON-SEQUENTIAL COPY BI:SEQ(X),Q SEQUENCE NUMBER ASSIGNED TO REQUEST MOD:Q ,-PS:LTS COMPUTE DIFFERENCE OF THIS FRAME FROM LOW MOD:A +PS:NTS,-PS:LTS COMPUTE DIFFERENCE OF NEXT TO SEND FROM LOW SUB Q,A CHECK IF VALID TO SEND THIS FRAME JLT A,GI09 RETURN TO CALLER IF UNABLE TO SEND FRAME JNE A,GI04 JUMP UNLESS THIS IS NEXT IN ORDER FRAME TO SEND MOD:A +=1,+PS:NTS INCREMENT THE NEXT TO SEND SEQUENCE COPY A,PS:NTS(Y) MOD:A +=1,+PS:HTS,-PS:LTS COMPUTE DIFFERENCE OF TRANSMIT HIGH FROM LOW SUB Q,A COMPARE THE TWO OFFSETS JGT A,GI05 JUMP IF THIS FRAME NOT A NEW HIGH COPY BI:SEQ(X),Q SET NEW HIGH TRANSMIT SEQUENCE TO THIS FRAME COPY Q,PS:HTS(Y) JMP GI05 DO THE TRANSMISSION GI04 EQU $ CHECK IF FRAME HAS ALREADY BEEN ACKNOWLEDGED MOD:A +PS:TWB,-PS:LTS COMPUTE OFFSET OF BASE FROM LOW TRANSMIT SEQUENCE SUB Q,A CHECK IF FRAME ALREADY ACKNOWLEDGED JLE A,GI05 DO THE FRAME TRANSMISSION IF NOT COPY BI:NXT(X),A LINK TO NEXT REQUEST ON QUEUE COPY A,PS:TPH(Y) SAVE AS NEW HEAD OF QUEUE JNE A,$+2 JUMP UNLESS QUEUE NOW EMPTY COPY A,PS:TPT(Y) SET NULL TAIL POINTER FOR QUEUE JSK WRT:ACK PROCESS ACKNOWLEDGED FRAME JMP GI03 LOOP TO CHECK PENDING QUEUE AGAIN GI05 EQU $ TRANSMITTING AN INFORMATION FRAME COPY PS:PIF(Y),Q PROTOCOL INFORMATION TRANSFER FLAGS BITS:OFF Q,PIF:NRV TURN OFF NEW RECEIVE VALUE FLAG COPY Q,PS:PIF(Y) GI06 EQU $ REMOVE REQUEST FROM QUEUE AND TRANSMIT COPY BI:NXT(X),A LINK TO NEXT REQUEST ON QUEUE COPY A,PS:TPH(Y) SAVE AS NEW HEAD OF QUEUE JNE A,$+2 JUMP UNLESS QUEUE NOW EMPTY COPY A,PS:TPT(Y) SET NULL TAIL POINTER FOR QUEUE JSK NEW:IFRM ALLOCATE AND INITIALIZE EIB FOR INFORMATION FRAME PAIRS: POF:ICO#POF:IRO,PMF:PSF#PMF:SSF,ECI:PSF#ECI:SSF CHECK FLAG PAIRS COPY PS:POF(Y),A PROTOCOL OPTIONS FLAGS BITS:OUT A,POF:ICO,POF:IRO MASK OUT TRANSMISSION RESTRICTIONS JNE A,$+2 JUMP IF INFORMATION FRAME TRANSMISSION RESTRICTED BITS:VAL A,POF:ICO,POF:IRO SET MASK FOR BOTH TYPES ALLOWED SC HIFT: A,PMF:SSF-POF:IRO POSITION TO MATCH STATION FUNCTION FLAGS AND PS:PMF(Y),A GENERATE MASK FOR TRANSMISSION TYPES ALLOWED SHIFT: A,ECI:SSF-PMF:SSF POSITION FOR EVENT CONTROL INFORMATION FLAGS BITS:ON A,ECI:TYP=E:XMTFRM SET EVENT TYPE FOR TRANSMIT FRAME JSK SEND:INF SEND FRAME EVENT TO TRANSMIT DRIVER RSK RETURN TO CALLER FOR CHECKS GI07 EQU $ CHECK SUPERVISORY WHEN ALL INFORMATION SENT COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS BITS:OUT A,PIF:NRS,PIF:NRV MASK NEW RECEIVE STATUS FLAGS JNE A,GI08 GENERATE SUPERVISORY FRAME IF STATUS TO REPORT COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS TBIT PCF:TFO,A TRANSMIT FINAL OUTSTANDING FLAG JF OV,GI08 GENERATE FRAME IF NEED TO SEND FINAL TBIT PCF:FPT,A FORCED POLL FRAME TRANSMISSION FLAG JF OV,GI09 JUST RETURN UNLESS POLL FRAME REQUIRED GI08 EQU $ GENERATE A SUPERVISORY FRAME TO FINISH UP JSK GEN:SUPR GENERATE AND SEND SUPERVISORY FRAME FOR STATUS GI09 EQU $ TAKE RETURN FOR NO MORE FRAMES TO SEND COPY K,X CURRENT STACK POINTER ADDRESS IMS 0(X) INCREMENT RETURN ADDRESS RSK TAKE INCREMENTED RETURN TO CALLER * LPOOL TITL GEN:XMIT - GENERATE TRANSMIT FRAMES * * GEN:XMIT * * PROCEDURE GENERATES TRANSMIT FRAMES AND SENDS THEM TO THE TRANSMIT * DRIVER ACTIVITY, IF TRANSMIT CONTROL HAS PREVIOUSLY BEEN OBTAINED * AND ANY FRAMES NEED TO BE TRANSMITTED. ALSO RELEASES TRANSMIT * CONTROL FOR A PRIMARY STATION ON A MULTIPOINT LINE, WHEN NO FRAMES * NEED TO BE TRANSMITTED. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * GEN:XMIT EQU $ COPY PS:PMF(Y),Q PROTOCOL MODE FLAGS TBIT PMF:TCH,Q TRANSMIT CONTROL HELD FLAG JF OV,GX04 JUMP IF NOT HOLDING TRANSMIT CONTROL OF LINE TBIT PMF:TCY,Q YIELDING TRANSMIT CONTROL FLAG JT OV,GX04 JUMP IF YIELDING CONTROL GX01 EQU $ CHECK OUTSTANDING FRAME LIMIT COPY PS:LCB(Y),X BASE ADDRESS OF LCB COPY LC:TOC(X),A TRANSMIT OUTSTANDING COUNT SUB PS:NTF(Y),A COMPARE WITH TRANSMIT OUTSTANDING LIMIT JGE A,GX04 JUMP IF ALREADY REACHED LIMIT COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:OUT A,PCF:SRP,PCF:FRP CHECK FOR RESPONSE REQUIRED JNE A,GX02 JUMP IF SO TO GENERATE COPY PS:MCF(Y),A MODE CONDITION FLAGS TBIT MCF:MSR,A MODE SETTING REQUIRED FLAG JF OV,GX03 JUMP IF NO MODE SETTING TBIT MCF:SUS,A MODE SETTING SUSPENDED FLAG JT OV,GX03 JUMP IF MODE SETTTING SUSPENDED BITS:OUT A,MCF:MSO,MCF:RSO,MCF:DSO,MCF:MRO CHECK MODE FRAMES OUTSTANDING JNE A,GX03 JUMP IF ANY ALREADY SENT COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:PSF,A PRIMARY STATION FUNCTION FLAG JF OV,GX02 JUMP IF SECONDARY STATION FUNCTION ONLY COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS TBIT PCF:TPO,A TRANSMIT POLL OUTSTANDING FLAG JT OV,GX03 SKIP GENERATION IF UNABLE TO TRANSMIT WITH POLL JSK GEN:UNNC GENERATE UNNUMBERED COMMAND FRAME JMP GX01 LOOP TO CHECK FRAME LIMIT GX02 EQU $ GENERATE UNNUMBERED RESPONSE FRAME JSK GEN:UNNR GENERATE APPROPRIATE RESPONSE JMP GX01 LOOP TO CHECK FRAME LIMIT GX03 EQU $ CHECK INFORMATION FRAME GENERATION COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:EXT A,PMF:CLS EXTRACT THE CURRENT LINK STATE CLSN A,=PST:DISC CHECK IF IN DISCONNECTED STATE JMP GX04 JUST RETURN IF SO JSK GEN:INFO GENERATE INFORMATION TRANSFER FRAME JMP GX01 LOOP TO CHECK FRAME LIMIT GX04 EQU $ RETURN TO CALLER D  RSK SPACE 2 END TITL SYNCHRONOUS HANDLER PROTOCOL PROCEDURES (93438-12/A030) TITL EXTERNAL REFERENCES AND DEFINITIONS * *  EXTERNAL REFERENCES * EXTR INI:EVNT EXTR GET:REQ EXTR PUT:REQ EXTR RET:REQ EXTR RET:REQQ EXTR STRT:TMR EXTR CNCL:TMR  EXTR R:SIG * * EXTERNAL DEFINITIONS * NAM ABRT:ALL NAM PUT:RORD NAM WRT:ACK NAM PROC:ACK NAM ACPT:SEL NAM ACPT:SEQ NAM XMIT:CPL NAM PRC:WRIT NAM RESC:ONE NAM RESC:ALL NAM END:POLL NAM END:FINL NAM REL:RECV NAM REL:XMIT NAM RST:RECV NAM RST:XMIT NAM REQ:RECV NAM REQ:XMIT NAM CHK:TERM NAM RECV:REL NAM XMIT:REL NAM PRO:RPRT NAM CHK:MODE NAM SET:REQS NAM SET:CURS NAM FRC:CURS NAM STRT:RSP * * REL AREA DEFINITION * SHARABLE SYNC: ROMMABLE SYNC: SYSTEM SYNC: REL IFT DEBUG: G:E NAM G:E ENDC TITL ABRT:ALL - ABORT AND RETURN ALL USER REQUESTS * * ABRT:ALL * * PROCEDURE RETURNS ALL USER READ AND WRITE REQUESTS, INCLUDING * THOSE ON THE RECEIVE READY QUEUE IN THE LINK CONTROL BLOCK, TO THE * USER WITH THE SPECIFIED TERMINATION CODE. * * CALL PARAMETERS: * Q - TERMINATION CODE TO BE USED * * RETURN PARAMETERS: * A,Q - UNCHANGED * X - DESTROYED * ABRT:ALL EQU $ COPY Y,X FORM ADDRESS OF TRANSMIT AVAILABLE QUEUE POINTERS ADD =PS:TAH,X JSK RET:REQQ RETURN ALL REQUESTS ON QUEUE COPY Y,X FORM ADDRESS OF TRANSMIT WAITING QUEUE POINTERS ADD =PS:TWH,X JSK RET:REQQ RETURN ALL REQUESTS ON QUEUE COPY Y,X FORM ADDRESS OF TRANSMIT PENDING QUEUE POINTERS ADD =PS:TPH,X JSK RET:REQQ RETURN ALL REQUESTS ON QUEUE COPY Y,X FORM ADDRESS OF RECEIVE WAITING QUEUE POINTERS ADD =PS:RWH,X JSK RET:REQQ RETURN ALL REQUESTS ON QUEUE COPY PS:LCB(Y),X FORM ADDRESS OF RECEIVE READY QUEUE POINTERS ADD =LC:RRH,X JSK RET:REQQ RETURN ALL REQUESTS ON QUEUE  RSK RETURN TO CALLER TITL PUT:RORD - ADD REQUEST TO QUEUE IN SEQUENCE NUMBER ORDER * * PUT:RORD * * PROCEDURE ADDS A BUFFER INFORMATION BLOCK TO A QUEUE OF BUFFER * INFORMATION BLOCKS, INSERTING IT AT THE PROPER LOCATION IN * SEQUENCE NUMBER ORDER. ORDERING IS DETERMINED BY OFFSET OF THE * SEQUENCE NUMBERS FROM A SPECIFIED BASE VALUE. * * CALL PARAMETERS: * A - BASE SEQUENCE NUMBER VALUE * Q - OFFSET IN SCRATCHPAD (PST) TO QUEUE POINTER BLOCK * X - BASE ADDRESS OF BUFFER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * PUT:RORD EQU $ PUSH STATUS: SAVE ALL ENTERING REGISTERS XNX Q OFFSET TO QUEUE POINTER BLOCK COPY 0(Y),A BASE ADDRESS OF HEAD OF QUEUE BIB JNE A,PO01 JUMP UNLESS QUEUE EMPTY COPY A,BI:NXT(X) SET NULL NEXT LINKAGE FROM BIB XNX Q SET THIS BIB AS HEAD OF QUEUE COPY X,0(Y) XNX Q SET THIS BIB AS TAIL OF QUEUE COPY X,1(Y) COPY =STK:NUM,A POINT PAST SAVED REGISTERS ADD A,K RSK RETURN TO CALLER PO01 EQU $ / COPY BI:SEQ(X),Q SEQUENCE NUMBER ASSIGNED TO REQUEST COPY K,Y CURRENT STACK POINTER VALUE MOD:Q ,-STK:A FIND OFFSET FROM BASE SEQUENCE NUMBER COPY A,X BASE ADDRESS OF FIRST BIB IN QUEUE COPY =0,A SET NULL PRIOR BIB ADDRESS COPY A,STK:L(Y) PO02 EQU $ / COPY BI:SEQ(X),A SEQUENCE NUMBER ASSIGNED TO REQUEST IN QUEUE MOD:A ,-STK:A FIND OFFSET FROM BASE SEQUENCE NUMBER SUB Q,A COMPARE WITH OFFSET OF REQUEST TO INSERT JGT A,PO03 JUMP IF INSERT LOCATION IN QUEUE FOUND COPY X,STK:L(Y) SAVE THIS BIBE  ADDRESS AS PRIOR COPY BI:NXT(X),X BASE ADDRESS OF NEXT BIB IN QUEUE JNE X,PO02 LOOP UNLESS END OF QUEUE COPY STK:Q(Y),X OFFSET TO QUEUE POINTER BLOCK IN SCRATCHPAD ADD STK:Y(Y),X FORM ADDRESS OF POINTER BLOCK COPY STK:X(Y),A BASE ADDRESS OF BIB TO INSERT COPY A,1(X) SET AS TAIL OF QUEUE PO03 EQU $ / COPY STK:X(Y),A BASE ADDRESS OF BIB BEING INSERTED COPY STK:L(Y),X BASE ADDRESS OF PRIOR BIB IN QUEUE JEQ X,PO04 JUMP IF INSERTING AT HEAD OF QUEUE EXCH A,*STK:L(Y) LINK PRIOR TO INSERTED, GET LINKAGE JMP PO05 PO04 EQU $ / COPY STK:Q(Y),X OFFSET TO QUEUE POINTER BLOCK IN SCRATCHPAD EXCH A,*STK:Y(X,Y) SET INSERTED BIB AS NEW HEAD OF QUEUE PO05 EQU $ / COPY A,*STK:X(Y) LINK INSERTED BIB TO NEXT IN QUEUE COPY STK:Y(Y),A SCRATCHPAD (PST) BASE ADDRESS  ADD =STK:NUM,Y OFFSET PAST REGISTERS STORED ON STACK COPY Y,K COPY A,Y RESTORE SCRATCHPAD (PST) BASE ADDRESS RSK RETURN TO CALLER TITL WRT:ACK - TRANSMITTED AND ACKNOWLEDGED WRITE REQUEST PROCESSING * * WRT:ACK * * PROCEDURE PERFORMS COMPLETION PROCESSING FOR A WRITE REQUEST * WHICH HAS BEEN TRANSMITTED AND ACKNOWLEDGED, EITHER QUEUEING IT * FOR THE RETURN OF PRIOR SEQUENCE NUMBERED REQUESTS OR RETURNING * IT TO THE USER (POSSIBLY WITH PREVIOUSLY QUEUED REQUESTS). * *  CALL PARAMETERS: * X - BASE ADDRESS OF BUFFER INFORMATION BLOCK * * RETURN PARAMETERS: * A,Q,X - DESTROYED * WRT:ACK EQU $ COPY BI:BCT(X),Q GET REQUESTED WRITE BYTE COUNT COPY Q,BI:ACT(X) PUT IT IN ACTUAL COUNT COPY X,Q SAVE BASE ADDRESS OF BIB COPY BI:ORF(X),A OPERATOR REQUEST FLAGS BITS:EXT A,ORF:AHL EXTRACT ACTUAL HEADER LENGTH ADD BI:ACT(X),A ADD LENGTH OF MAIN DATA PORTION COPY PS:CIB(Y),X BASE ADDRESS OF CIB ADD CI:URT(X),A INCLUDE IN COUNT OF DATA CHARACTERS TRANSMITTED COPY A,CI:URT(X) COPY Q,X RESTORE BASE ADDRESS OF BIB COPY BI:SEQ(X),A SEQUENCE NUMBER ASSIGNED TO REQUEST CSK A,PS:LTS(Y) CHECK IF THIS IS NEXT TO RETURN JMP WA02 ADD TO ACKNOWLEDGEMENT QUEUE IF NOT JMP WA02 WA01 EQU $ / COPY =TRM:NORM,Q SET TERMINATION CODE FOR REQUEST JSK RET:REQ RETURN REQUEST TO USER MOD:A +=1,+PS:LTS INCREMENT LOWEST TRANSMIT SEQUENCE NUMBER COPY A,PS:LTS(Y) COPY PS:TAH(Y),X BASE ADDRESS OF NEXT BIB ON QUEUE JEQ X,$+2 RETURN IF QUEUE EMPTY CSK A,BI:SEQ(X) CHECK SEQUENCE AGAINST NEXT TO RETURN RSK RETURN TO CALLER IF NOT EQUAL RSK COPY BI:NXT(X),A BASE ADDRESS OF NEXT BIB IN QUEUE COPY A,PS:TAH(Y) SET NEXT AS NEW HEAD OF QUEUE JNE A,WA01 LOOP TO RETURN IF NOT LAST COPY A,PS:TAT(Y) SET NULL TAIL POINTER WHEN QUEUE EMPTY JMP WA01 WA02 EQU $ / COPY PS:LTS(Y),A SET BASE SEQUENCE NUMBER FOR OFFSET COMPUTATION COPY =PS:TAH,Q SET OFFSET TO QUEUE POINTER BLOCK JSK PUT:RORD INSERT BIB IN SEQUENCE NUMBER ORDER RSK RETURN TO CALLER * LPOOL TITL PROC:ACK - PROCESS RECEIVED TRANSMIT ACKNOWLEDGEMENT VALUE * * PROC:ACK * * PROCEDURE PROCESSES A RECEIVED ACKNOWLEDGEMENT VALUE WHICH IS * ABOVE THE CURRENT TRANSMIT WINDOW BASE. WRITE REQUESTS ASSOCIATED * WITH ACKNOWLEDGED FRAMES ARE RETURNED TO THE USER. * * CALL PARAMETERS: * Q - RECEIVED ACKNOWLEDGEMENT OFFSET FROM BASE * * RETURN PARAMETERS: * A,Q,X - UNCHANGED * PROC:ACK EQU $ PUSH STATUS: SAVE CALLING REGISTERS ON STACK COPY =0,A RESET THE RETRY COUNTER COPY A,PS:RF TY(Y) PA01 EQU $ LOOP FOR REMOVING REQUESTS FROM WAITING QUEUE COPY PS:TWH(Y),X BASE ADDRESS OF FIRST ON WAITING QUEUE JEQ X,PA02 JUMP IF QUEUE IS EMPTY COPY BI:SEQ(X),A SEQUENCE NUMBER ASSIGNED TO REQUEST MOD:A ,-PS:TWB COMPUTE OFFSET FROM TRANSMIT WINDOW BASE SUB Q,A COMPARE ACKNOWLEDGEMENT OFFSET WITH THIS ONE JGE A,PA02 JUMP IF THIS FRAME HAS NOT BEEN ACKNOWLEDGED COPY BI:NXT(X),A BASE ADDRESS OF NEXT BIB IN QUEUE COPY A,PS:TWH(Y) SET AS NEW HEAD OF QUEUE JNE A,$+2 JUMP UNLESS QUEUE NOW EMPTY COPY A,PS:TWT(Y) SET NULL TAIL OF QUEUE JSK WRT:ACK PERFORM COMPLETION PROCESSING FOR REQUEST COPY K,Y CURRENT STACK POINTER VALUE COPY STK:Q(Y),Q RESTORE ACKNOWLEDGEMENT OFFSET VALUE COPY STK:Y(Y),Y RESTORE SCRATCHPAD (PST) BASE ADDRESS JMP PA01 LOOP FOR ALL ACKNOWLEDGED REQUESTS PA02 EQU $ CHECK VALUE OF HIGHEST IN POLL SEQUENCE MOD:A +=1,+PS:LPS,-PS:TWB COMPUTE HIGHEST IN POLL FROM BASE SUB Q,A COMPARE WITH OFFSET OF ACKNOWLEDGEMENT JGT A,PA03 JUMP IF HIGHEST IN POLL SEQUENCE STILL HIGHER MOD:A -=1,+Q,+PS:TWB SET HIGHEST IN POLL ABOVE NEW WINDOW BASE COPY A,PS:LPS(Y) PA03 EQU $ CHECK VALUE OF HIGHEST IN FINAL SEQUENCE MOD:A +=1,+PS:LFS,-PS:TWB COMPUTE HIGHEST IN FINAL FROM BASE SUB Q,A COMPARE WITH OFFSET OF ACKNOWLEDGEMENT JGT A,PA04 JUMP IF HIGHEST IN FINAL SEQUENCE STILL HIGHER MOD:A -=1,+Q,+PS:TWB SET HIGHEST IN FINAL ABOVE NEW WINDOW BASE COPY A,PS:LFS(Y) PA04 EQU $ UPDATE NEXT TO SEND IF BELOW NEW TRANSMIT BASE MOD:A +PS:NTS,-PS:TWB COMPUTE NEXT TO SEND FROM BASE SUB Q,A COMPARE WITH OFFSET OF ACKNOWLEDGEMENT JGE A,PA05 JUMP IF NEXT TO SEND STILL HIGHER MOD:A +Q,+PS:TWB SET NEXT TO SEND TO NEW WINDOW BASE COPY A,PS:NTS(Y) PA05 EQU $ UPDATE TRANSMIT WINDOW BASE VALUE MOD:Q ,+PS:TWB COMPUTE ACKNOWLEDGEMENT SEQUENCE NUMBER COPY Q,PS:TWB(Y) SAVE AS TRANSMIT WINDOW BASE POP RESTORE CALLING REGISTERS RSK TITL ACPT:SEL - SELECTIVE ACCEPTANCE PROCESSING FOR RECEIVED FRAME * * ACPT:SEL * * PROCEDURE DETERMINES WHETHER OR NOT TO ACCEPT A RECEIVED FRAME * WHEN REORDERING OF RECEIVED FRAMES IS POSSIBLE. IF ACCEPTED, THE * RECEIVED FRAME IS EITHER DIRECTLY RETURNED TO THE USER OR QUEUED * FOR EVENTUAL RETURN. * * CALL PARAMETERS: * X - BASE ADDRESS OF BUFFER INFORMATION BLOCK * * RETURN PARAMETERS: * A,X,Q - UNCHANGED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS A FRAME NOT * ACCEPTED RETURN; RETURN TO CALL+1 IS A FRAME ACCEPTED RETURN. * ACPT:SEL EQU $ PUSH STATUS: SAVE CALLING REGISTERS ON STACK COPY BI:SEQ(X),A SEQUENCE NUMBER OF RECEIVED FRAME MOD:A ,-PS:RWB COMPUTE OFFSET FROM WINDOW BASE JNE A,AL02 JUMP UNLESS RECEIVE WINDOW BASE FRAME COPY X,Q SAVE BASE ADDRESS OF BIB COPY BI:ORF(X),A OPERATION REQUEST FLAGS BITS:EXT A,ORF:AHL EXTRACT ACTUAL HEADER LENGTH ADD BI:ACT(X),A ADD LENGTH OF MAIN DATA PORTION COPY PS:CIB(Y),X BASE ADDRESS OF CIB ADD CI:URR(X),A INCLUDE IN DATA CHARACTERS RECEIVED COUNT COPY A,CI:URR(X) COPY Q,X RESTORE BASE ADDRESS OF BIB COPY =TRM:NORM,Q SET NORMAL TERMINATION CODE JSK RET:REQ RETURN RECEIVED FRAME TO USER MOD:A +=1,+PS:AHS UPDATE RECEIVE WINDOW BASE COPY A,PS:RWB(Y) COPY PS:RWH(Y),A BASE ADDRESS OF FIRST BIB ON WAITING QUEUE JEQ A,AL01 JUMP IF RECEIVE WAITING QUEUE EMPTY COPY Y,X FORM ADDRESS OF WAITING QUEUE POINTER BLG OCK ADD =PS:RWH,X COPY =TRM:NORM,Q SET NORMAL TERMINATION CODE JSK RET:REQQ RETURN ALL REQUESTS ON WAITING QUEUE TO USER COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS BITS:ON A,PIF:NRS SET FLAG FOR NEW RECEIVE STATUS TYPE COPY A,PS:PIF(Y) JMP AL08 TAKE FRAME ACCEPTED RETURN AL01 EQU $ UPDATE RECEIVE SEQUENCE NUMBERS COPY PS:RWB(Y),A RECEIVE WINDOW BASE COPY A,PS:AHS(Y) SET AS NEW ACCEPTED HIGH SEQUENCE JMP AL08 TAKE FRAME ACCEPTED RETURN AL02 EQU $ FRAME NOT THE RECEIVE WINDOW BASE COPY PS:LCB(Y),X BASE ADDRESS OF LCB COPY LC:RRC(X),Q COUNT OF READY FOR RECEIVE BUFFERS JNE Q,AL03 JUMP IF RECEIVE BUFFERS AVAILABLE COPY LC:DIB(X),X BASE ADDRESS OF DIB COPY DI:RQH(X),Q HEAD OF READ REQUEST QUEUE JEQ Q,AL05 REJECT FRAME IF NO EXTRA BUFFERS AVAILABLE AL03 EQU $ EXTRA BUFFERS AVAILABLE FOR ACCEPTING FRAME COPY PS:RWH(Y),Q FIRST REQUEST ON WAITING QUEUE JEQ Q,AL04 JUMP IF RECEIVE WAITING QUEUE EMPTY MOD:Q +PS:AHS,-PS:RWB COMPUTE ACCEPTED HIGH SEQUENCE OFFSET FROM BASE SUB Q,A FIND OFFSET OF FRAME FROM LAST ACCEPTED AL04 EQU $ CHECK IF RECEIVE FRAME SEQUENCE NEXT TO ACCEPT CLSN A,=1 CHECK IF NEXT FRAME TO BE ACCEPTED JMP AL06 ACCEPT OUT OF ORDER FRAME AL05 EQU $ RETURN FOR FRAME NOT ACCEPTED POP RESTORE CALLING REGISTERS RSK  TAKE FAILURE RETURN TO CALLER AL06 EQU $ ACCEPT OUT OF ORDER RECEIVE FRAME COPY K,X CURRENT STACK POINTER ADDRESS COPY STK:X(X),X RESTORE BASE ADDRESS OF RECEIVE FRAME REQUEST COPY BI:SEQ(X),A SET NEW ACCEPTED HIGH SEQUENCE NUMBER COPY A,PS:AHS(Y) COPY =0,A SET NULL NEXT POINTER FOR REQUEST COPY A,BI:NXT(X) COPY X,A COPY BASE ADDRESS OF THIS REQUEST EXCH X,PS:RWT(Y) SET THIS REQUEST AS NEW LAST AND GET OLD JEQ X,AL07 JUMP IF QUEUE WAS EMPTY COPY A,BI:NXT(X) LINK FORMER END OF QUEUE TO THIS REQUEST JMP AL08 AL07 EQU $ ADDING REQUEST TO PREVIOUSLY EMPTY QUEUE COPY A,PS:RWH(Y) SET THIS REQUEST AS HEAD OF QUEUE COPY PS:PIF(Y),Q PROTOCOL INFORMATION TRANSFER FLAGS BITS:ON Q,PIF:NRS SET NEW RECEIVE STATUS TYPE FLAG COPY Q,PS:PIF(Y) AL08 EQU $ ACCEPTED FRAME RETURN COPY A,X BASE ADDRESS OF BIB COPY BI:ORF(X),A OPERATION REQUEST FLAGS BITS:EXT A,ORF:AHL EXTRACT ACTUAL HEADER LENGTH ADD BI:ACT(X),A ADD IN LENGTH OF MAIN DATA PORTION COPY PS:CIB(Y),X BASE ADDRESS OF CIB ADD CI:URR(X),A INCLUDE IN DATA CHARACTER RECEIVED COUNT COPY A,CI:URR(X) COPY K,X CURRENT STACK POINTER ADDRESS IMS STK:NUM(X) SET RETURN ADDRESS FOR FRAME ACCEPTED POP RESTORE CALLING REGISTERS RSK RETURN TO CALLER * LPOOL TITL ACPT:SEQ - SEQUENTIAL ACCEPTANCE PROCESSING FOR RECEIVE FRAME * * ACPT:SEQ * * PROCEDURE DETERMINES WHETHER OR NOT TO ACCEPT A RECEIVED FRAME * WHEN NO REORDERING OF RECEIVED FRAMES IS POSSIBLE. IF ACCEPTED, * THE RECEIVED FRAME IS IMMEDIATELY RETURNED TO THE USER. * * CALL PARAMETERS: * X - BASE ADDRESS OF BUFFER INFORMATION BLOCK * * RETURN PARAMETERS: * A,X,Q - UNCHANGED * * TWO RETURNS ARE PROVIDED: RETURN TO CALL+1 IS A FRAME NOT * ACCEPTED RETURN; RETURN TO CALL+1 IS A FRAME ACCEPTED RETURN. * ACPT:SEQ EQU $ PUSH STATUS: SAVE ALL ENTERING REGISTERS COPY BI:SEQ(X),A SEQUENCE NUMBER OF RECEIVED FRAME MOD:A ,-PS:RWB COMPUTE OFFSET FROM RECEIVE WINDOW BASE JNE A,AQ01 REJECT FRAME IF NOT RECEIVE WINDOW BASE COPY BI:ORF(X),H A OPERATION REQUEST FLAGS BITS:EXT A,ORF:AHL EXTRACT THE ACTUAL HEADER LENGTH ADD BI:ACT(X),A ADD IN LENGTH OF MAIN DATA PORTION COPY X,Q SAVE BASE ADDRESS OF BIB COPY PS:CIB(Y),X BASE ADDRESS OF CIB ADD CI:URR(X),A INCLUDE FRAME IN RECEIVE DATA CHARACTER COUNT COPY A,CI:URR(X) COPY Q,X RESTORE BASE ADDRESS OF BIB COPY =TRM:NORM,Q SET NORMAL TERMINATION CODE JSK RET:REQ RETURN RECEIVED FRAME TO USER COPY PS:RWB(Y),A RECEIVE WINDOW BASE COPY A,PS:AHS(Y) SET AS ACCEPTED HIGH SEQUENCE MOD:A ,+=1 INCREMENT RECEIVE WINDOW BASE SEQUENCE COPY A,PS:RWB(Y) COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS BITS:ON A,PIF:NRV SET NEW RECEIVE STATUS VALUE FLAG COPY A,PS:PIF(Y) COPY K,X CURRENT STACK POINTER ADDRESS IMS STK:NUM(X) SET RETURN ADDRESS FOR FRAME ACCEPTED AQ01 EQU $ RETURN FOR FRAME NOT ACCEPTED POP RESTORE ALL CALLING REGISTERS RSK RETURN TO CALLER WITHOUT ACCEPTANCE TITL XMIT:CPL - PROCESS TRANSMIT COMPLETE REQUESTS * * XMIT:CPL * * PROCEDURE REMOVES WRITE REQUESTS FROM THE TRANSMIT COMPLETE * QUEUE IN THE LINK CONTROL BLOCK, AND EITHER RETURNS THEM TO THE * USER OR ADDS THEM TO THE TRANSMIT ACKNOWLEDGEMENT QUEUE, THE * TRANSMIT WAITING QUEUE, OR THE TRANSMIT PENDING QUEUE. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * XMIT:CPL EQU $ COPY PS:LCB(Y),X BASE ADDRESS OF LCB  ADD =LC:TCH,X COMPUTE BASE ADDRESS OF POINTER BLOCK JSK GET:REQ REMOVE FIRST REQUEST FROM COMPLETION QUEUE JEQ A,XC04 OUT OF LOOP IF NONE PRESENT ON QUEUE COPY A,X BASE ADDRESS OF REQUEST COPY BI:ORF(X),A OPERATION REQUEST FLAGS TBIT ORF:NSI,A NON-SEQUENTIAL INFORMATION FLAG JT OV,XC03 JUMP IF NOT SEQUENCE NUMBERED COPY BI:SEQ(X),A SEQUENCE NUMBER ASSIGNED TO FRAME MOD:A ,-PS:LTS COMPUTE OFFSET FROM LOWEST TRANSMIT SEQUENCE MOD:Q +PS:TWB,-PS:LTS COMPUTE OFFSET OF TRANSMIT WINDOW BASE SUB A,Q JUMP IF FRAME IS STILL IN THE TRANSMIT WINDOW JLE Q,XC01 JSK WRT:ACK PERFORM COMPLETION PROCESSING FOR REQUEST JMP XMIT:CPL LOOP TO PROCESS NEXT REQUEST ON QUEUE XC01 EQU $ TRANSMITTED FRAME NOT YET ACKNOWLEDGED MOD:Q +PS:NTS,-PS:LTS COMPUTE OFFSET OF NEXT TO TRANSMIT SUB A,Q GET DIFFERENCE TO DECIDE WHICH QUEUE TO USE COPY PS:LTS(Y),A SET BASE SEQUENCE TO LOWEST TRANSMIT JGT Q,XC02 JUMP IF RETRANSMISSION NOT REQUIRED COPY =PS:TPH,Q SET OFFSET OF PENDING QUEUE POINTER BLOCK JSK PUT:RORD ADD REQUEST TO PENDING QUEUE IN SEQUENCE ORDER JMP XMIT:CPL LOOP TO PROCESS NEXT REQUEST ON QUEUE XC02 EQU $ TRANSMITTED FRAME TO WAIT FOR ACKNOWLEDGEMENT COPY =PS:TWH,Q SET OFFSET OF WAITING QUEUE POINTER BLOCK JSK PUT:RORD ADD REQUEST TO WAITING QUEUE IN ORDER JMP XMIT:CPL LOOP TO PROCESS NEXT REQUEST ON QUEUE XC03 EQU $ NON-SEQUENTIAL INFORMATION FRAME COPY =TRM:NORM,Q SET TERMINATION CODE FOR REQUEST JSK RET:REQ RETURN IT TO THE USER JMP XMIT:CPL LOOP TO PROCESS NEXT REQUEST ON QUEUE XC04 EQU $ RETURN TO CALLER RSK * LPOOL TITL RESC:ONE - SCHEDULE SINGLE FRAME RETRANSMISSION * * RESC:ONE * * PROCEDURE SCHEDULES THE RETRANSMISSION OF THE FIRST INFORMATION * FRAME IN THE TRANSMIT WINDOW. * * CALLING PARAMETERS: * NONE * * RETURN PARAMETERS: * A,X - DESTROYED * Q - UNCHANGED * RESC:ONE EQU $ COPY PS:TWH(Y),X BASE ADDRESS OF TRANSMIT WAITING HEADI  BIB JEQ X,RST:HSEQ JUMP IF QUEUE IS EMPTY COPY BI:SEQ(X),A SEQUENCE NUMBER ASSIGNED TO TRANSMIT FRAME SUB PS:TWB(Y),A COMPARE WITH TRANSMIT WINDOW BASE SEQUENCE JNE A,RST:HSEQ JUMP UNLESS TRANSMIT WINDOW BASE FRAME COPY BI:NXT(X),A BASE ADDRESS OF NEXT BIB IN WAITING QUEUE COPY A,PS:TWH(Y) SET AS NEW HEAD OF WAITING QUEUE JNE A,$+2 JUMP UNLESS QUEUE NOW EMPTY COPY A,PS:TWT(Y) SET NULL TAIL OF WAITING QUEUE COPY PS:TPH(Y),A BASE ADDRESS OF TRANSMIT PENDING HEAD BIB COPY A,BI:NXT(Y) LINK THIS BIB TO FORMER HEAD OF QUEUE COPY X,PS:TPH(Y) SET THIS BIB AS NEW HEAD OF QUEUE JNE A,RST:HSEQ JUMP UNLESS QUEUE WAS EMPTY COPY X,PS:TPT(Y) SET ADDED BIB AS TAIL OF QUEUE * * COMMON EXIT FOR RESC:ONE AND RESC:ALL, RESETS THE HIGHEST IN * POLL AND FINAL SEQUENCES. * RST:HSEQ EQU $ RESET LOWEST IN POLL/FINAL SEQUENCE MOD:A -=1,+PS:TWB SET TRANSMIT WINDOW BASE MINUS ONE COPY A,PS:LPS(Y) RESET HIGHEST IN POLL SEQUENCE COPY A,PS:LFS(Y) RESET HIGHEST IN FINAL SEQUENCE RSK RETURN TO CALLER TITL RESC:ALL - SCHEDULE RETRANSMISSION OF ALL WAITING FRAMES * * RESC:ALL * * PROCEDURE SCHEDULES THE RETRANSMISSION OF ALL FRAMES IN THE * TRANSMIT WINDOW. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,X - DESTROYED *  Q - UNCHANGED * RESC:ALL EQU $ COPY PS:TWB(Y),A TRANSMIT WINDOW BASE SEQUENCE NUMBER SUB PS:NTS(Y),A COMPARE WITH NEXT TRANSMIT SEQUENCE JEQ A,RST:HSEQ JUMP IF NEXT TRANSMIT IS WINDOW BASE COPY PS:TWB(Y),A SET NEXT TRANSMIT SEQUENCE TO WINDOW BASE COPY A,PS:NTS(Y) COPY PS:TWH(Y),A BASE ADDRESS OF TRANSMIT WAITING HEAD BIB JEQ A,RST:HSEQ JUMP IF TRANSMIT WAITING QUEUE EMPTY EXCH A,PS:TPH(Y) SET AS FIRST ON TRANSMIT PENDING QUEUE COPY PS:TWT(Y),X BASE ADDRESS OF TRANSMIT WAITING TAIL BIB COPY A,BI:NXT(X) LINK TO FORMER HEAD OF PENDING QUEUE JNE A,$+2 JUMP UNLESS PENDING QUEUE WAS EMPTY COPY X,PS:TPT(Y) SET TAIL OF WAITING AS TAIL OF PENDING COPY =0,A NULL OUT POINTERS FOR TRANSMIT WAITING QUEUE COPY A,PS:TWH(Y) COPY A,PS:TWT(Y) JMP RST:HSEQ EXIT WITH RESETTING OF HIGH SEQUENCES TITL END:POLL - END OF POLL CYCLE PROCESSING * * END:POLL * * PROCEDURE PERFORMS PROCESSING FOR THE END OF A POLL CYCLE. IF A * MODE SETTING OPERATION HAS BEEN INITIATED, AND HAS NOT BEEN * TERMINATED BY THE END OF THE POLL CYCLE, THE APPROPRIATE MODE * SETTING COMMAND IS AGAIN TRANSMITTED. IF FRAMES TRANSMITTED PRIOR * TO THE BEGINNING OF THE POLL CYCLE ARE STILL UNACKNOWLEDGED AT THE * END OF THE CYCLE, THEY ARE RETRANSMITTED. * *  CALL PARAMETERS: * A - NONZERO IF TO IMPLEMENT CHECKPOINT RETRANSMISSION, ZERO * OTHERWISE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * END:POLL EQU $ COPY PS:PCF(Y),Q PROTOCOL CONDITION FLAGS TBIT PCF:TPO,Q TRANSMIT POLL OUTSTANDING FLAG JF OV,EP01 JUMP IF NO POLL OUTSTANDING BITS:OFF Q,PCF:TPO TURN OFF TRANSMIT POLL OUTSTANDING FLAG COPY Q,PS:PCF(Y) COPY PS:MCF(Y),Q MODE CONDITION FLAGS BITS:OFF Q,MCF:MSO,MCF:RSO,MCF:DSO TURN OFF MODE SETTING COMMAND FLAGS COPY Q,PS:MCF(Y) JEQ A,EP01 JUMP IF NOT TO RETRANSMIT FRAMES MOD:A +=1,+PS:LPS,-PS:TWB COMPUTE LAST IN POLL OFFSET JEQ A,EP01 JUMP IF ALL FRAMES IN SEQUENCE ACKNOWLEDGED JSK RESC:ALL SCHEDULE RETRANSMISSION OF ALL FRAMES IN WINDOW EP01 EQU $ CANCEL RESPONSE TIMJ ER IF ACTIVE COPY PS:RTB(Y),X BASE ADDRESS OF RESPONSE TIMER CONTROL BLOCK JEQ X,EP02 JUMP IF NO RESPONSE TIMER PRESENT COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:OFF A,PCF:RTA RESET RESPONSE TIMER ACTIVE FLAG COPY A,PS:PCF(Y) JSK CNCL:TMR CANCEL THE RESPONSE TIMER IF ACTIVE EP02 EQU $ RETURN TO CALLER RSK TITL END:FINL - END OF FINAL CYCLE PROCESSING * * END:FINL * * PROCEDURE PERFORMS PROCESSING FOR THE END OF A FINAL CYCLE. ALL * INFORMATION FRAMES WHICH HAD BEEN TRANSMITTED PRIOR TO THE * COMPLETION OF THE LAST FINAL CYCLE AND HAVE NOT YET BEEN * ACKNOWLEDGED ARE RETRANSMITTED. * * CALL PARAMETERS: * A - NONZERO IF TO IMPLEMENT CHECKPOINT RETRANSMISSION, ZERO * OTHERWISE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * END:FINL EQU $ COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:PSF,A PRIMARY STATION FUNCTION ACTIVE FLAG JT OV,EF02 JUST IGNORE COMPLETELY IF PRIMARY ACTIVE COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:OFF A,MCF:MRO RESET THE MODE SETTING RESPONSE OUTSTANDING FLAG COPY A,PS:MCF(Y) MOD:A +=1,+PS:LFS,-PS:TWB COMPUTE LAST IN FINAL OFFSET JEQ A,EF01 JUMP IF ALL FRAMES IN SEQUENCE ACKNOWLEDGED JSK RESC:ALL SCHEDULE RETRANSMISSION OF ALL UNACKNOWLEDGED FRAMES EF01 EQU $ CANCEL RESPONSE TIMER IF ACTIVE COPY PS:RTB(Y),X BASE ADDRESS OF RESPONSE TIMER CONTROL BLOCK JEQ X,EF02 JUMP IF NO RESPONSE TIMER PRESENT COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:OFF A,PCF:RTA RESET RESPONSE TIMER ACTIVE FLAG COPY A,PS:PCF(Y) JSK CNCL:TMR CANCEL THE RESPONSE TIMER IF ACTIVE EF02 EQU $ RETURN TO CALLER RSK TITL REL:RECV - RELEASE RECEIVE CONTROL OF LINE IF ACTIVE * * REL:RECV * * PROCEDURE RELEASES RECEIVE CONTROL OF THE COMMUNICATIONS LINE IF * RECEIVE CONTROL IS HELD AND IS NOT ALREADY BEING RELEASED. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * REL:RECV EQU $ COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:RCY,A YIELDING RECEIVE CONTROL FLAG JT OV,RR01 JUMP IF IN PROCESS OF RELEASING CONTROL TBIT PMF:RCH,A RECEIVE CONTROL HELD FLAG JF OV,RR01 JUMP IF NOT HOLDING RECEIVE CONTROL BITS:ON A,PMF:RCY SET FLAG FOR YIELDING RECEIVE CONTROL COPY A,PS:PMF(Y) PAIRS: PMF:PSF#PMF:SSF,ECI:PSF#ECI:SSF CHECK FLAG PAIRS BITS:OUT A,PMF:PSF,PMF:SSF MASK OUT STATION FUNCTION FLAGS SHIFT: A,ECI:SSF-PMF:SSF POSITION TO MATCH FLAGS FOR EVENT OR =E:RELRCV,A SET EVENT CODE FOR RELEASING RECEIVE CONTROL COPY PS:LCB(Y),Q SET BASE ADDRESS OF LCB COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:RDP(X),X SET BASE ADDRESS OF RECEIVE DRIVER EPT JSK INI:EVNT SET EVENT RELEASING RECEIVE CONTROL OF LINE RR01 EQU $ RETURN TO CALLER RSK TITL REL:XMIT - RELEASE TRANSMIT CONTROL OF LINE IF ACTIVE * * REL:XMIT * * PROCEDURE RELEASES TRANSMIT CONTROL OF THE COMMUNICATIONS LINE IF * TRANSMIT CONTROL IS HELD AND IS NOT ALREADY BEING RELEASED. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * REL:XMIT EQU $ COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:TCY,A YIELDING TRANSMIT CONTROL FLAG JT OV,RX01 JUMP IF IN PROCESS OF RELEASING CONTROL TBIT PMF:TCH,A TRANSMIT CONTROL HELD FLAG JF OV,RX01 JUMP IF NOT HOLDING TRANSMIT CONTROL BITS:ON A,PMF:TCY SET FLAG FOR YIELDING TRANSMIT CONTROL COPY A,K PS:PMF(Y) PAIRS: PMF:PSF#PMF:SSF,ECI:PSF#ECI:SSF CHECK FLAG PAIRS BITS:OUT A,PMF:PSF,PMF:SSF MASK OUT STATION FUNCTION FLAGS SHIFT: A,ECI:SSF-PMF:SSF POSITION TO MATCH FLAGS FOR EVENT OR =E:RELXMT,A SET EVENT CODE FOR RELEASING TRANSMIT CONTROL COPY PS:LCB(Y),Q SET BASE ADDRESS OF LCB COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:TDP(X),X SET BASE ADDRESS OF TRANSMIT DRIVER EPT JSK INI:EVNT SET EVENT RELEASING TRANSMIT CONTROL OF LINE RX01 EQU $ RETURN TO CALLER RSK * LPOOL TITL RST:RECV - RESET RECEIVE SIDE OF PROTOCOL LINK * * RST:RECV * * PROCEDURE INITIALIZES ALL INTERNAL FLAGS AND PARAMETERS FOR THE * OPERATION OF THE RECEIVE PORTION OF THE PROTOCOL LINK. * * CALL PARAMETERS: * NONE * * RETURN PARAMETERS: * A,Q,X - DESTROYED * RST:RECV EQU $ COPY PS:MCF(Y),A MODE CONDITION FLAGS BITS:OFF A,MCF:RDR RESET REQUEST DISCONNECT RECEIVED FLAG COPY A,PS:MCF(Y) COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:OFF A,PCF:FRC FORCE RECEIVE-RELATED FLAGS OFF COPY A,PS:PCF(Y) COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS TBIT PIF:IFR,A INFORMATION FRAMES RECEIVED FLAG BITS:OFF A,PIF:NRS,PIF:NRV,PIF:IDR,PIF:IFR FORCE OFF RECEIVE FLAGS JF OV,$+2 JUMP IF NO INFORMATION FRAMES HAD BEEN RECEIVED BITS:ON A,PIF:IDR SET POSSIBLE RECEIVE DATA LOSS FLAG BITS:ON A,PIF:PRE SET RECEIVE DATA TRANSFER ENABLED FLAG COPY A,PS:PIF(Y) COPY =0,A COPY A,PS:RWB(Y) INITIALIZE RECEIVE WINDOW BASE COPY =:FF,A COPY A,PS:AHS(Y) INITIALIZE ACCEPTED HIGH SEQUENCE COPY A,PS:RHS(Y) INITIALIZE RECEIVE HIGH SEQUENCE SR01 EQU $ LOOP FOR RETURNING REQUESTS TO THE AVAILABLE LIST DEL:REQ PS:RWH,PS:RWT,SR02 GET NEXT REQUEST FROM QUEUE IF PRESENT COPY X,A COPY BASE ADDRESS OF REQUEST COPY PS:LCB(Y),X BASE ADDRESS OF LCB IMS LC:RRC(X) INCREMENT THE COUNT OF REQUESTS ON QUEUE ADD =LC:RRH,X SET ADDRESS OF READY QUEUE POINTER BLOCK JSK PUT:REQ ADD THE REQUEST TO THE READY FOR RECEIVE QUEUE JNE A,SR01 LOOP UNLESS QUEUE WAS EMPTY COPY PS:PMF(Y),A PROTOCOL MODE FLAGS TBIT PMF:RCH,A RECEIVE CONTROL HELD FLAG JF OV,SR01 LOOP IF NOT HOLDING RECEIVE CONTROL TBIT PMF:RCY,A YIELDING RECEIVE CONTROL FLAG JT OV,SR01 LOOP IF RELEASING RECEIVE CONTROL COPY PS:CIB(Y),X BASE ADDRESS OF CIB COPY CI:RDP(X),X BASE ADDRESS OF RECEIVE DRIVER EPT ADD =EP:SEM,X SET ADDRESS OF SEMAPHORE WORD JSK R:SIG SIGNAL RECEIVE DRIVER TO RESUME EXECUTION JMP SR01 SR02 EQU $ RETURN TO CALLER RSK TITL RST:XMIT - RESET TRANSMIT SIDE OF PROTOCOL LINK * * RST:XMIT * * PROCEDURE INITIALIZES ALL INTERNAL FLAGS AND PARAMETERS FOR THE * OPERATION OF THE TRANSMIT PORTION OF THE PROTOCOL LINK. * * CALL PARAMETERS: * NONE * *  RETURN PARAMETERS: * A,Q,X - DESTROYED * RST:XMIT EQU $ COPY PS:PCF(Y),A PROTOCOL CONDITION FLAGS BITS:OFF A,PCF:FRR RESET FRAME REJECT CONDITION REPORTED FLAG COPY A,PS:PCF(Y) COPY PS:PIF(Y),A PROTOCOL INFORMATION TRANSFER FLAGS TBIT PIF:IFT,A INFORMATION FRAMES TRANSMITTED FLAG BITS:OFF A,PIF:IDT,PIF:IFT FORCE OFF DATA LOSS AND FRAMES TRANSMITTED JF OV,$+2 JUMP IF NO INFORMATION FRAMES HAD BEEN TRANSMITTED BITS:ON A,PIF:IDT SET POSSIBLE TRANSMIT DATA LOSS FLAG BITS:ON A,PIF:PTE SET TRANSMIT DATA TRANSFER ENABLED FLAG COPY A,PS:PIF(Y) COPY =0,A COPY A,PS:TWB(Y) INITIALIZE TRANSMIT WINDOW BASE COPY A,PS:LTS(YL ) INITIALIZE LOWEST TRANSMIT SEQUENCE COPY A,PS:NTS(Y) INITIALIZE NEXT TRANSMIT SEQUENCE COPY A,PS:NTA(Y) INITIALIZE NEXT TRANSMIT ASSIGNMENT COPY =:FF,A COPY A,PS:HTS(Y) INITIALIZE HIGHEST TRANSMIT SEQUENCE COPY A,PS:LPS(Y) INITIALIZE HIGHEST IN POLL SEQUENCE COPY A,PS:LFS(Y) INITIALIZE HIGHEST IN FINAL SEQUENCE COPY PS:TWH(Y),A BASE ADDRESS OF FIRST REQUEST ON WAITING QUEUE JEQ A,SX02 JUMP IF TRANSMIT WAITING QUEUE EMPTY COPY =0,Q COPY Q,PS:TWH(Y) SET NULL HEAD POINTER FOR TRANSMIT WAITING QUEUE EXCH Q,PS:TWT(Y) GET TAIL POINTER AND SET NULL COPY PS:TPH(Y),X BASE ADDRESS OF FIRST REQUEST ON TRANSMIT PENDING JEQ X,SX01 JUMP IF TRANSMIT PENDING QUEUE EMPTY COPY A,PS:TPH(Y) SET PENDING HEAD TO FIRST FROM WAITING QUEUE EXCH Q,X SWAP FORMER HEAD AND LAST FROM WAITING QUEUE COPY Q,BI:NXT(X) LINK LAST FROM WAITING QUEUE TO FORMER HEAD JMP SX02 SX01 EQU $ MERGING WAITING INTO EMPTY PENDING QUEUE COPY A,PS:TPH(Y) SET PENDING QUEUE POINTERS TO WAITING QUEUE COPY Q,PS:TPT(Y) SX02 EQU $ PERFORM RESEQUENCING OF TRANSMIT PENDING REQUESTS COPY PS:TPH(Y),X BASE ADDRESS OF FIRST TRANSMIT PENDING REQUEST JEQ X,SX05 JUMP IF TRANSMIT PENDING QUEUE EMPTY SX03 EQU $ LOOP FOR RESEQUENCING TRANSMIT PENDING REQUESTS COPY BI:ORF(X),A OPERATION REQUEST FLAGS TBIT ORF:NSI,A NON-SEQUENTIAL INFORMATION FLAG JT OV,SX04 JUMP UNLESS SEQUENTIAL INFORMATION FRAME COPY PS:NTA(Y),A NEXT TRANSMIT ASSIGNMENT COPY A,BI:SEQ(X) SET AS SEQUENCE NUMBER FOR REQUEST FRAME MOD:A ,+=1 INCREMENT SEQUENCE NUMBER FOR NEXT ASSIGNMENT COPY A,PS:NTA(Y) SX04 EQU $ GET ADDRESS OF NEXT REQUEST IN PENDING QUEUE COPY BI:NXT(X),X BASE ADDRESS OF NEXT REQUEST IN QUEUE JNE X,SX03 LOOP IF NOT AT END OF QUEUE SX05 EQU $ RETURN TO CALLER RSK * LPOOL TITL REQ:RECV - REQUEST RECEIVE CONTROL OF LINE * * REQ:RECV * * PROCEDURE GENERATES AN EVENT FOR THE RECEIVE CONTROL ACTIVITY * REQUESTING RECEIVE CONTROL OF THE COMMUNICATIONS LINE, AND SETS * THE FLAG FOR RECEIVE CONTROL REQUESTED. * * CALL PARAMETERS: * NONE * *  RETURN PARAMETERS: * A,Q,X - DESTROYED * REQ:RECV EQU $ COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:OUT A,PMF:RCR,PMF:RCH,PMF:RCY CHECK RECEIVE CONTROL RELATED FLAGS JNE A,RQ04 JUMP IF ANY RECEIVE CONTROL ACTION IN PROGRESS COPY PS:PMF(Y),A PROTOCOL MODE FLAGS BITS:ON A,PMF:RCR SET FLAG FOR REQUESTING RECEIVE CONTROL COPY A,PS:PMF(Y) COPY PS:LCB(Y),X BASE ADDRESS OF LCB COPY LC:LAF(X),Q LINE ACCESS FLAGS BITS:OFF Q,LAF:UBF,LAF:ECF RESET FLAG CONTROLING RECEIVE OPERATION COPY Q,LC:LAF(X) BIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIOS4 MA283011016043140830110160431 830110160431JF43802 VOLSYNCHRONOUS COMMUNICATIONS HANDLER SOURCE DISKETTE I (A030)