*COMDECK PMDEAD 
_$H+,R-,E+? 
CONST 
_ 
***      NPU COMMANDS 
? 
      MNCOBL   = $0058;                     _OUTPUT BUFFER LENGTH      ?
      MNCICS   = $0050;                     _INPUT COUPLER STATUS      ?
      MNCIOW   = $0060;                     _INPUT ORDER WORD          ?
      MNCONS   = $0048;                     _OUTPUT NPU STATUS         ?
      MNCOMA   = $006C;                     _OUTPUT MEMORY ADDRESS     ?
      MNCIMA   = $0010;                     _INPUT MEMORY ADDRESS      ?
      MNCINS   = $0040;                     _INPUT NPU STATUS          ?
_ 
***      PPU ORDER WORD CODE
? 
      MOWOSM   = $0100;                     _OUTPUT SERVICE MESSAGE    ?
      MOWOHD   = $0200;                     _OUTPUT HIGH PRIO. DATA    ?
      MOWOLD   = $0300;                     _OUTPUT LOW PRIO. DATA     ?
      MOWNRY   = $0400;                     _NOT READY FOR INPUT       ?
      MOWRGS   = $0504;                     _REGULATION CHANGE NS      ?
      MOWRGN   = $0502;                     _REGULATION CHANGE NO NS   ?
      MOWIAK   = $0600;                     _INIT ACKNOWLEDGEMENT      ?
_ 
***      NPU STATUS CODE
? 
      MNSIGN   = $0000;                     _ IGNORE                   ?
      MNSIDL   = $0001;                     _ IDLE                     ?
      MNSRYO   = $0002;                     _ READY FOR OUTPUT         ?
      MNSNRO   = $0003;                     _ NOT READY FOR OUTPUT     ?
      MNSIAS   = $0004;                     _ INPUT AVAILABLE SAMALL   ?
      MNSIAL   = $0005;                     _ INPUT AVAILABLE LARGE    ?
      MN1PIA   = $0406;                     _ 1 PRU INPUT AVAILABLE    ?
      MN2PIA   = $0806;                     _2 PRU INPUT AVAILABLE     ?
      MN3PIA   = $0C06;                     _3 OR MORE PRU-S AVAILABLE ?
      MNSINI   = $0007;                     _INITIALIZE                ?
      MNSINC   = $0008;                     _INITIALIZATION COMPLETE   ?
_ 
* * *     PAGE MODE VALUES
? 
      B0PM0    = 0;                         _PAGE MODE 0               ?
      B0PM1    = 1;                         _PAGE MODE 1               ?
      B0APM    = 2;                         _ABSOLUTE PAGE MODE        ?
_ 
* * *   PROCTECT LOCATIONS. 
? 
    BSPBEGIN = $114;
    BSPEND   = $137;
_ 
* * *    PAGE REGISTER VALUES 
? 
      S0SPRN   = $02;                       _START PAGE REG NUMBER     ?
      S0EPRN   = $04;                       _END PAGE REG NUMBER       ?
_ 
* * *    SERVICE MESSAGE RESPONSE FIELDS
? 
      S0NORML  = $01;                       _T = NORMAL RESPONSE       ?
      S0ABNML  = $02;                       _T = ABNORMAL RESPONSE     ?
      S0BADADDR= 1;                         _BAD LOAD/DUMP ADDRESS     ?
      S0CSERR  = 2;                         _CHECKSUM ERROR            ?
      S0MMERR  = 3;                         _NOT 8K MM SYSTEM          ?
      S0BCERR = 4;                          _BATCH COUNT ERROR         ?
_ 
* * *     SERVICE MESSAGE COMMAND TYPES 
? 
      S0DUMP   = 0;                         _DUMP COMMAND              ?
      S0LOAD   = 1;                         _LOAD COMMAND              ?
      S0START  = 2;                         _START COMMAND             ?
      S0NRSTART= 4;                         _START/NO RETURN COMMAND   ?
_ 
* * *     COUPLER BUFFER VALUES 
? 
      B1FCD    = $04;                       _BUFFER FCD                ?
      B1LCD    = $FD;                       _BUFFER LCD                ?
_ 
* * *    INTERRUPT MASKS
? 
      I0RTCIM  = $0100;                     _REAL TIME CLOCK MASK      ?
      I0C1RIM  = $0140;                     _COUPLER 1 + RTC MASK      ?
      I0C1RAA  = $0040;                     _COUPLER 1 MASK.           ?
      I0C2RIM  = $0120;                     _COUPLER 2 + RTC MASK      ?
      I0C2RAA  = $0020;                     _ COUPLER 2 MASK.          ?
      I0OLRIM  = $3100;                     _ODD + LF + RTC MASK       ?
      I0OLRAA  = $3000;                     _ ODD + IL MASK.           ?
      I0ODIAA  = $1000;                     _ ODD MASK.                ?
_ 
* * *    TIMER VALUES 
? 
      MTNSCLK  = 600;                       _NS INACTIVE CLOCK = 60 SEC?
      MTPPDCLK = 100;                       _PPU DEAD CLOCK = 10 SEC   ?
      MTLFICLK = 250;                       _LFI CLOCK 25/SEC          ?
      MTLRRCLK = 40;
      MTDSRCLK = 50;                        _DSR CLOCK = 5 SEC         ?
      MTPPKCLK = 10;                        _PPU KAT CLOCK = 1 SEC     ?
      MTIRCLK  = 5;                         _INPUT REJ CLOCK = 0.5 SEC ?
      MTODDCLK  = 4;                         _ ODD CLOCK = 0.4 SEC   ?
      T2TTEND  = 8;                         _END OF TIMER TABLE        ?
_ 
* * *    TIMER TABLE ENTRIES
? 
      MTNSINACT= 1;                         _NS INACTIVE TIMER         ?
      MTPPUDED = 2;                         _PPU DEAD TIMER            ?
      MTLRRT   = 3;                         _LOAD RESPONSE TIMER       ?
      MTDSR    = 4;                         _MODEM DSR TIMER           ?
      MTPPUKA  = 5;                         _PPU KEEP ALIVE TIMER      ?
      MTIREJT  = 6;                         _INPUT REJECT TIMER        ?
      MTODD    = 7;                         _ODD INTERRUPT TIMER       ?
      MTLFI    = 8;                         _LFI INTERRUPTS TIMER      ?
_ 
* * *     MLIA COMMAND BYTES
? 
      MLRESET  = $0519;                     _RESET MLIA                ?
      MLIDLE   = $0529;                     _IDLE MLIA                 ?
      MLLOOP   = $0578;                     _SET LOOP PARAMETERS       ?
      MLCIBA   = $050A;                     _SET CIB ADDRESS           ?
      MLCIBL   = $051A;                     _CIB LENGTH                ?
      MLSTART  = $0539;                     _START NORMAL MLIA MODE    ?
      MLDATA   = $0508;                     _DATA COMMAND              ?
      MLODD    = $0500;                     _ODD REQUEST               ?
      MLLFP    = $0560;                     _READ LINE FRAME POSITION  ?
      MLSTATUS = $0576;                     _READ MLIA STATUS          ?
      MLRSTLFP = $0578;                     _RESET LFP                 ?
_ 
* * *    MLIA COMMAND PARAMETERS
? 
      MLPARA   = $8808;                     _IDLES/NULLS               ?
      MLCIBC   = $F0FF;                     _CIB LENGTH                ?
_ 
* * *     CLA COMMANDS
? 
      C1ISON   = $0020;                     _ISON                      ?
      C1CLEAR  = $0000;                     _CLEAR                     ?
      C1CONFG  = $8A60;                     _CONFIGURE                 ?
      C1OON    = $8B27;                     _OUTPUT ON                 ?
      C1OOFF   = $8A20;                     _CLEAR OON                 ?
      C1OLAST  = $8B2F;                     _SEND LAST CHARACTER       ?
_ 
* * * MISCELLANEOUS CONSTANTS 
? 
      C1CIB    = $100;                      _LENGTH OF CIB             ?
      B0RIML   =  2;                        _ MAX RIM RETRIES IS 2     ?
      B0HDR    = 22;                        _HEADER SIZE               ?
      S0LRBC   = 16;                        _LOAD RESPONSE BYTE CT     ?
      S0STRBC  = 12;                        _START SM RESPONST CT      ?
      S0DRBC   = 14;                        _ DUMP SM RESONSE HEADER   ?
      S0UARBC  = 2;                         _UA RESPONSE BYTE COUNT    ?
      MPBFLN   = 127;                       _BUFFER LENGTH             ?
      B1DMTA   = $60B;                      _DEADMAN TIMER ADDRESS     ?
      S0PROTECT= $08;                       _8 PROTECTED MEMORY LOCS   ?
_ 
* * *     HDLC PARAMETERS 
? 
      B0RIM    = 7;                         _RIM FRAME                 ?
      B0SIM    = $17;                       _SIM FRAME                 ?
      B0UAON   = $73;                       _UA RESPONSE F-BIT ON      ?
      B0UI     = 3;                         _UI FRAME                  ?
_$J+? 
TYPE
      B04BITS  = 0..15; 
      SVLDAR   = ARRAY [0..1] OF INTEGER; 
      B0REGS   = ARRAY [0..9] OF INTEGER;   _ ODD REGISTER SAVE AREA   ?
      B0REGT   = ARRAY [0..9] OF INTEGER;   _ RTC REGISTER SAVE AREA   ?
      B0REGL   = ARRAY [0..9] OF INTEGER;   _ LF REGISTERS SAVE AREA   ?
      B08BITS  = 0..255;
      ELEMENTS = (BIT0,BIT1,BIT2,BIT3,BIT4,BIT5,BIT6,BIT7,BIT8, 
                  BIT9,BIT10,BIT11,BIT12,BIT13,BIT14,BIT15);
      SETWORD  = SET OF ELEMENTS; 
_ 
* * *     CSR STORAGE 
? 
      MPPAR     = PACKED RECORD 
                  CASE BII       : INTEGER OF 
                  0 : ( MINT     : INTEGER ); 
                  1 : ( MSET     : SETWORD ); 
                  2 : ( MB15TO12 : B04BITS ;
                        MBOW     : B04BITS ;
                        MBLN     : B08BITS ); 
                  3 : ( MPTR     : 'INTEGER); 
                  END;
   PGINT = PACKED RECORD
     CASE PINT:INTEGER OF 
      0 :(INT : INTEGER); 
      1 :(PAGE : 0..31; 
          DISP : 0..2047);
     END; 
_ 
* * *    COUPLER STATES 
? 
      MSTATE   = (MSTCDN,                   _COUPLER-DOWN              ?
                  MSTWNR,                   _W-F-NSWR                  ?
                  MSTPOW,                   _PROCESS-OW                ?
                  MSTWOW,                   _W-F-OWL                   ?
                  MSTWLD,                   _W-F-LOAD/DUMP             ?
                  MSTLWN,                   _LOADING-W-F-NSWR          ?
                  MSTWOP,                   _W-F-OUTPUT                ?
                  MSTPOP,                   _PROCESS-OUTPUT            ?
                  MSTWIP,                   _W-F-INPUT                 ?
                  MSTIPO,                   _INPUT-PROCESS             ?
                  MSTIWN,                   _INPUT-W-F-NSWR            ?
                  MSTLPO);                  _LOADING-PROCESS-OW        ?
_ 
* * *     MEMORY ADDRESS POINTER
? 
      B0ADDR   = PACKED RECORD
                 CASE B4I : INTEGER OF
                 0:(S0INTARY:'ARRAY         _MEMORY MOVE POINTER TYPE  ?
                              [1..105] OF 
                              INTEGER); 
                 1:(S0XRV   : 0..31;        _PAGE REGISTER VALUE       ?
                    S0XPD   : 0..2047);     _PAGE DISPLACEMENT         ?
                 2:(S0INT   : INTEGER);     _INTEGER VALUE             ?
                 END; 
_ 
* * *     COUPLER/TRUNK BUFFER DESCRIPTION
? 
      BDBUFF   = PACKED RECORD
                 CASE BD1     : INTEGER OF
                 0:(BDA       : CHAR;       _HDLC A FIELD              ?
                    BDC       : CHAR;       _HDLC C FIELD              ?
                    BDL       : CHAR;       _LENGTH FIELD              ?
                    BDF       : CHAR);      _FLAG BYTE                 ?
                 1:(BDLCD     : 0..255;     _BUFFER LCD FIELD          ?
                    BDFCD     : 0..255;     _BUFFER FCD FIELD          ?
                    BDF3      : BOOLEAN;    _LAST BUFFER FLAG          ?
                    BDFLAGS   : 0..32767);  _FLAGS FIELD               ?
                 2:(BDSKIP    : PACKED ARRAY_SKIP OVER HDLC            ?
                                [1..4]      _  FIELDS AND BUFFER       ?
                                OF CHAR;    _    LCD/FCD FIELDS        ?
                    BDDN      : CHAR;       _SM DN FIELD               ?
                    BDSN      : CHAR;       _SM SN FIELD               ?
                    BDCN      : CHAR;       _SM CN FIELD               ?
                    BDPRIO    : BOOLEAN;    _SM PRIORITY BIT           ?
                    BDBSN     : 0..7;       _SM BSN FIELD              ?
                    BDCMD     : 0..15;      _SM COMMAND FIELD          ?
                    BDPFC     : CHAR;       _SM PRIMARY FUNC CODE      ?
                    BDTFIELD  : 0..3;       _SM T FIELD                ?
                    BDSFC     : 0..31;      _SECONDARY FUNC CODE       ?
                    BDPORT    : CHAR;       _PORT                      ?
                    BDSUBP    : CHAR;       _SUBPORT                   ?
                    BDTYPE    : 0..255;     _TYPE                      ?
                    BDLSN     : CHAR;       _LOAD SEQUENCE NUMBER      ?
                    BDRC      : 0..255;     _REASON CODE               ?
                    BDRJSPD   : 0..63;      _FILLER                    ?
                    BDSRVU    : 0..3;       _HIGH-ORDER PAGE REG. VALUE?
                    BDSRVL    : 0..31;      _LOW-ORDER PAGE REG. VALUE ?
                    BDSPD     : 0..2047);   _START PAGE DISPLACEMENT   ?
                 3:(BDPAD3    : ARRAY       _SKIP OVER DEFINED FIELDS  ?
                                [1..9]
                                OF
                                INTEGER;
                    CASE BDLD    : INTEGER OF 
                    0:(BDBC      : 0..255;  _BATCH COUNT               ?
                       BDPAD4    : CHAR;    _UNUSED BYTE               ?
                       BDCSUM    : INTEGER; _CHECKSUM                  ?
                       BDLDAT    : ARRAY    _LOAD                      ?
                                   [1..105] _  DATA                    ?
                                   OF       _    AREA                  ?
                                   INTEGER);
                    1:(BDPAD6    : CHAR;    _UNUSED BYTE               ?
                       BDRJEPD   : 0..63;   _ FILLER                   ?
                       BDERVU    : 0..3;    _HIGH-ORDER PAGE REG. VALUE?
                       BDERVL    : 0..31;   _LOW-ORDER PAGE REG. VALUE ?
                       BDEPD     : 0..2047);_END PAGE DISPLACEMENT     ?
                    2:(BDDATA    : ARRAY
                                   [1..105] _    DUMP                  ?
                                   OF       _      DATA                ?
                                   INTEGER)); 
                    END;_CASE?
_ 
* * * TIMER TABLE 
? 
      MTTABTMR = ARRAY [1 .. T2TTEND]      _TIMER TABLE             ? 
                 OF INTEGER;
_ 
* * * TIMER TABLE DISPATCH ADDRESS FOR EXPIRED TIMERS 
? 
      MTTMRDSP = ARRAY [1..T2TTEND]         _TIMER DISPATCH TABLE      ?
                 OF INTEGER;
_$J+? 
VAR 
_ 
***  B U F F E R   A R E A    *** 
? 
       CQCIB     : ARRAY
                 [0..$FF] 
                 OF INTEGER;
       MPBUFF    : BDBUFF;
_ 
* * *    COUPLER VARIABLES
? 
      MPCMD    : INTEGER;                   _NPU COMMAND               ?
      MPSTAT   : MSTATE;                    _COUPLER STATE             ?
      MPPARM   : MPPAR;                     _PARAMETER FOR COUPLER CMDS?
      MPPSBIT  : MPPAR;                     _PARAMETER FOR STATUS BITS ?
      MPSTUS   : SETWORD;                   _STATUS BITS               ?
      MCPCON   : INTEGER;                   _COUPLER CONNECTION/PORT NO?
      MMBADR   : 'BDBUFF;                   _COUPLER MAR VALUE         ?
      MPPINT   : INTEGER;                   _COUPLER COMMAND PARAMETER ?
      LPS0PD   : INTEGER; 
      ACTINT   : INTEGER;                   _ HIGHER PRI/INT MASK BITS ?
      SVLOC    : 'SVLDAR; 
      SVPAGE   : PGINT;         _FOR SAM PROTECT AREA  ?
_ 
* * *    SAM VARIABLES
? 
      BSPROTECT: ARRAY [BSPBEGIN..BSPEND]   _ARRAY OF PROTECTED        ?
                        OF INTEGER; 
      J1CORE   : INTEGER;                   _MAX MEMORY LIMIT          ?
      J2CORE   : INTEGER; 
      QTOPSK   : INTEGER; 
      BSSAVE   : B0REGS;
      BSREGS   : 'B0REGS; 
      BSSAV1   : B0REGT;                    _ SAVE INT/REGISTERS.      ?
      BSREGT   : 'B0REGT; 
      BSSAV2   : B0REGL;                    _ L F  SAVE REGS. AREA     ?
      BSREGL   : 'B0REGL; 
      MPFF     : BOOLEAN;                   _LOOP FLAG                 ?
      C0INDEX  : INTEGER;                   _INDEX                     ?
      COTWICE  : INTEGER;         _ SEND RIM TWICE   ?
      M0TRUNK  : INTEGER;                   _TRUNK CONNECTION NO.      ?
      MPRPFG   : BOOLEAN;                   _RESPONSE FLAG             ?
      MTTMRTAB : MTTABTMR;                  _TIMER TABLE               ?
      MTDISP   : MTTMRDSP;                  _TIMER DISPATCH TABLE      ?
      B1COPFLG : BOOLEAN;                   _FLAG FOR PMSVMH           ?
      B0PN     : INTEGER;                   _INITIALIZE PAGE FILE      ?
      S0ADDR   : B0ADDR;
      S0CMD    : INTEGER;                   _PMSVMH VARIABLE           ?
      S0RESP   : BOOLEAN;                   _SM RESPONSE FLAG          ?
      S0ARSP   : BOOLEAN;                   _SM ABNORMAL RESP FLAG     ?
      S0SVRC   : 0..255;                    _SAVED RESPONSE CODE       ?
      S0SVRV   : 0..255;                    _SAVED REG VALUE           ?
      S0SVPD   : 0..2047;                   _SAVED PAGE DISPLACEMENT   ?
      S0RBC    : INTEGER;                   _RESPONSE BYTE COUNT       ?
      S0DNTEMP : CHAR;                      _TEMP LOC FOR DN FIELD     ?
      S0LENGTH : INTEGER;                   _LENGTH OF MEMORY MOVE     ?
      S0BCNT   : INTEGER;                   _ INITIALIZE BATCH COUNT   ?
      S0CKSUM  : INTEGER;                   _CHECKSUM                  ?
      S0DP     : INTEGER;                   _PAGE DISPLACEMENT         ?
      S0PL     : INTEGER;                   _LOAD/DUMP VARIABLE        ?
      B0PROTECT: BOOLEAN;                   _PROTECTED MEMORY FLAG     ?
      S0LMT    : INTEGER;                   _LOAD/DUMP VARIABLE        ?
      S0SRV    : 0..127;                    _START PAGE VALUE          ?
      S0SPD    : 0..2047;                   _START PAGE DISPLACEMENT   ?
_ 
* * *    HDLC TRUNK VARIABLES 
? 
      B0WAIT   : BOOLEAN;                   _WAIT IN EFFECT            ?
      B0LINE   : BOOLEAN;                   _LINE OPERATIONAL(DSR LINE)?
      B4RETRY  : INTEGER;                   _RETRY COUNT               ?
      B0ERROR  : (B0OK,                     _NO ERRORS                 ?
                  B0TO,                     _TIME OUT                  ?
                  B0FE,                     _FRAME ERROR               ?
                  B0CK,                     _CHECKSUM ERROR            ?
                  B0NSTO,                   _NS TIME OUT               ?
                  B0LRTO,                   _LOAD RESPONSE TIME OUT    ?
                  B0PPTO,                   _PPU TIME OUT              ?
                  B0DE,                     _DUMP ERROR                ?
                  B0RDY,                    _SIM RECEIVED              ?
                  B0MMER);                  _NOT 8K MM SYSTEM          ?
      B2CLA    : INTEGER;                   _TEMP CLA ADDRESS          ?
      CQCIBA   : INTEGER;                   _CIB ADDRESS               ?
      B1ODD    : INTEGER;                   _TEMP ODD ADDRESS          ?
      L1SLFP   : INTEGER;                   _START LINE FRAME POSITION ?
      B1STATUS : INTEGER;                   _TEMP STATUS               ?
_ 
* * *     OUTPUT OPERATION CONTROL VARIABLES
? 
      O1LENGTH : INTEGER;                   _OUTPUT LENGTH             ?
      O1ACTIVE : BOOLEAN;                   _OUTPUT ACTIVE FLAG        ?
      O1COUNT  : INTEGER;                   _OUTPUT COUNT              ?
      O1BUFF   : 'PACKED ARRAY              _OUTPUT                    ?
                 [1..240]                   _  BUFFER                  ?
                 OF CHAR; 
      O1CLA    : INTEGER;                   _OUTPUT CLA ADDRESS        ?
_ 
* * *     INPUT OPERATION CONTROL VARIABLES 
? 
      I1LENGTH : INTEGER;                   _INPUT LENGTH              ?
      I1COUNT  : INTEGER;                   _CURRENT INPUT COUNT       ?
      I1ACTIVE : BOOLEAN;                   _INPUT ACTIVE FLAG         ?
      I1BUFF   : 'PACKED ARRAY              _INPUT                     ?
                 [1..240]                   _  BUFFER                  ?
                 OF CHAR; 
      I1MSG    : BOOLEAN;                   _READ LF IN PROGRESS       ?
_$J+? 
VALUE 
      SVLOC      = 4; 
      QTOPSK   = 1; 
      MTTMRTAB = (0,0,0,0,0,0,0);           _TIMER TABLE = 0           ?
      S0ARSP   = FALSE; 
      S0RESP   = FALSE; 
      I1MSG    = FALSE; 
      O1ACTIVE = FALSE; 
      I1ACTIVE = FALSE; 
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                                  PIWAIT                              *
*                                                                      *
*                                DELAY LOOP                            *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  EXECUTE A FIXED NUMBER OF INSTRUCTIONS                  *
*                                                                      *
** INPUT -     NUMBER OF PASSES THRU THE DELAY LOOP                    *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMINIT                                                  *
*                                                                      *
** OUTPUT -    NONE                                                    *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              NONE                                                    *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PIWAIT(W1TIME:INTEGER); 
VAR 
      W1COUNT  : INTEGER; 
  
BEGIN 
  W1COUNT := 1; 
  REPEAT
    W1COUNT := W1COUNT + W1COUNT; 
    W1TIME  := W1TIME - 1;
  UNTIL W1TIME @ 0; 
  
  REPEAT
    W1COUNT := W1COUNT - 5; 
  UNTIL W1COUNT @ 0;
END;  _PIWAIT?
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                                PMWAIT                                *
*                                                                      *
*                           WAIT FOR EXTERNAL EVENT                    *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  WAIT FOR EXTERNAL EVENT TO CLEAR THE WAIT FLAG          *
*                                                                      *
** INPUT -     B0WAIT                                                  *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMOUTPUT                                                *
*              PMINPUT                                                 *
*                                                                      *
** OUTPUT -    B0WAIT                                                  *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              NONE                                                    *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMWAIT; 
BEGIN 
  EINT; 
  REPEAT
    PMDMT;                             _RESET DEAD MAN TIMER           ?
  UNTIL NOT B0WAIT; 
  IINT; 
END; _PMWAIT? 
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                               PMOUTPUT                               *
*                                                                      *
*                     TRANSMIT MESSAGE TO NEIGHBOR NPU                 *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  THE CLA IS FUNCTIONED TO START THE OUTPUT AND           *
*              THE ODD TIMER IS STARTED.  THE WAIT CONDITION           *
*              IS CLEARED IF THE OUTPUT IS DELIVERED OR THE            *
*              ODD TIMER EXPIRES.                                      *
*                                                                      *
** INPUT -     MPBUFF - BUFFER CONTAINING MESSAGE                      *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMTMON                                                  *
*                                                                      *
** OUTPUT -    MESSAGE SENT ACCROSS TRUNK                              *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              PMWAIT - WAIT FOR COMPLETION                            *
*              PMSUPR                                                  *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMOUTPUT; 
  
BEGIN 
  O1LENGTH := ORD(MPBUFF.BDL);         _MAKES THE LENGTH A FULL WORD   ?
  IF O1LENGTH < 0                      _IS THE LENGTH FIELD NEGATIVE   ?
  THEN                                 _THEN                           ?
    O1LENGTH := O1LENGTH - $FF00;      _MASK THE HIGHER ORDER BITS     ?
  O1LENGTH := O1LENGTH + 2;            _LENGTH OF TRANSMISSION         ?
  O1COUNT  := 1;                       _NEXT CHARACTER TO TRANSMIT     ?
  B0WAIT   := TRUE;                    _SET WAIT FLAG                  ?
  O1ACTIVE := TRUE;                    _OUTPUT IS ACTIVE               ?
  O1CLA    := M0TRUNK;
  ADDR(MPBUFF,O1BUFF);
  PMSUPR(M0TRUNK,C1OON);               _START OUTPUT                   ?
  MTTMRTAB[MTODD]:= MTODDCLK; 
  PMWAIT;                              _WAIT FOR COMPLETION            ?
END; _PMOUTPUT? 
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                                PMINPUT                               *
*                                                                      *
*                           MONITOR INPUT PROCESS                      *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  WAIT FOR AND MONITOR INPUT PROCESS                      *
*                                                                      *
** INPUT -     MPBUFF - INPUT BUFFER                                   *
*              M0TRUNK - CLA ADDRESS                                   *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMTMON                                                  *
*                                                                      *
** OUTPUT -    MPBUFF - CONTAINS INPUT MESSAGE                         *
*                                                                      *
** EXTERNAL SUBROUTINES - 
*              PMWAIT - WAIT FOR COMPLETION                            *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMINPUT;
BEGIN 
  I1LENGTH := 240;
  I1COUNT  := 0;
  B0WAIT   := TRUE; 
  I1ACTIVE := TRUE; 
  ADDR(MPBUFF,I1BUFF);
  PMWAIT; 
  IINT; 
  MTTMRTAB[MTLFI] := 0;                     _CLEAR LFI TIMER           ?
  EINT; 
END; _PMINPUT?
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                               PMSTATUS                               *
*                                                                      *
*                         PROCESS CLA STATUS                           *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  PROCESS THE SDLC CLA STATUS WORD                        *
*                                                                      *
** INPUT -     S1SW1 - STATUS WORD 1                                   *
*              S1SW2 - STATUS WORD 2                                   *
*              I1ACTIVE - INPUT ACTIVE FLAG                            *
*              O1ACTIVE - OUTPUT ACTIVE FLAG                           *
*              I1MSG - READ LF IN PROGRESS                             *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMLFI                                                   *
*                                                                      *
** OUTPUT -    I1ACTIVE                                                *
*              O1ACTIVE                                                *
*              I1MSG                                                   *
*              B0WAIT - WAIT FLAG                                      *
*              B0ERROR - ERROR CONDITION                               *
*              B0LINE - LINE CONDITION (DSR SIGNAL)                    *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              PMFAIL - FAIL ROUTINE                                   *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMSTATUS(S1SW1,S1SW2:INTEGER);
  
TYPE
      S0SNAME  = (SWRC3,                    _RECEIVE COUNT 3           ?
                  SWRC2,                    _RECEIVE COUNT 2           ?
                  SWRC1,                    _RECEIVE COUNT 1           ?
                  SWLCR,                    _LAST CHAR RECEIVED        ?
                  SWNCNA,                   _NEXT CHARACTER NOT AVAIL  ?
                  SWABT,                    _ABORT                     ?
                  SWDTO,                    _DATA TRANSFER OVERRUN     ?
                  SWFCSE,                   _FRAME CHECK SEQ ERR       ?
                  SWOLE,                    _OUTPUT LOOP ERROR         ?
                  SWILE,                    _INPUT LOOP ERROR          ?
                  SWRES1,                   _RESERVED                  ?
                  SWSQD,                    _SIGNAL QUALITY DETECTOR   ?
                  SWRI,                     _RING INDICATOR            ?
                  SWDCD,                    _DATA CARRIER DETECT       ?
                  SWDSR,                    _DATA SET READY            ?
                  SWCTS);                   _CLEAR TO SEND             ?
      S0STATUS = SET OF S0SNAME;
      S0STYPE  = PACKED RECORD              _STATUS WORD TYPE          ?
                 CASE STYPE:INTEGER OF
                 1:(SASET:S0STATUS);
                 2:(SAINT:INTEGER); 
                 3:(SAR1 :0..255; 
                    SAR2 :0..31;
                    SACHL:0..7);
                 END; 
VAR 
      SASTATUS : S0STYPE; 
BEGIN 
  SASTATUS.SAINT := S1SW1 * $100 + S1SW2;   _COMBINE STATUS WORDS      ?
                                            _  S1SW1 * $100 DOES A     ?
                                            _  LEFT SHIFT OF 8  PLACES ?
_ 
* * *    CHECK IF INPUT STATUS
? 
  IF I1ACTIVE                          _IF INPUT ACTIVE                ?
  THEN
    BEGIN 
    IF SWLCR IN SASTATUS.SASET         _IF LAST CHARACTER              ?
    THEN
      IF I1MSG                         _IF READ LF IN PROGRESS         ?
      THEN
        I1MSG := FALSE                 _TURN FLAG OFF                  ?
      ELSE
        BEGIN 
        MPBUFF.BDL := CHR(I1COUNT);    _SET THE INPUT MESSAGE LENGTH   ?
        B0WAIT := FALSE;               _CLEAR WAIT CONDITION TO ALLOW  ?
        I1ACTIVE := FALSE;             _  MESSAGE TO BE PROCESSED      ?
        B0ERROR := B0OK;               _INPUT OK                       ?
        IF SASTATUS.SACHL " 7          _IF CHARACTER LENGTH IS NOT 7   ?
        THEN                           _  THEN                         ?
          B0ERROR := B0FE              _FRAME LENGTH ERROR             ?
        ELSE                           _  ELSE                         ?
          IF SWFCSE IN SASTATUS.SASET  _IF FRAME CHECKSUM ERROR        ?
          THEN                         _  THEN DISCARD INPUT           ?
            B0ERROR := B0FE;
      END _IF I1MSG?
    ELSE                               _NOT LAST CHARACTER             ?
      BEGIN 
      LDREGS(BSREGL);                       _RESTORE REGISTERS         ?
       B0ERROR := B0FE;                _ SET B0ERROR TO FRAME ERR ? 
       B0WAIT := FALSE;                _ CLEAR B0WAIT FLAG        ? 
       I1MSG := FALSE;
       I1ACTIVE := FALSE; 
       B0LINE := SWDSR IN SASTATUS.SASET;  _ SET LINE FLAG        ? 
       IINT;                           _ DISABLE INTERRUPTS       ? 
       INST($E34);                     _ STATE INTERRUPT EXIT     ? 
    END; _IF SWLCF? 
    END                                _END IF INPUT ACTIVE            ?
  ELSE
    IF I1MSG &                         _IF READ LF IN PROGRESS         ?
      (SWLCR IN SASTATUS.SASET)        _AND THIS IS THE LAST CHARACTER ?
    THEN
      I1MSG := FALSE;                  _SET FLAG OFF                   ?
_ 
* * *    CHECK OUTPUT ACTIVE
? 
    IF O1ACTIVE                        _IF OUTPUT ACTIVE               ?
    THEN
      IF [] " (SASTATUS.SASET          _AND OUTPUT ERROR OLE,NCNA      ?
        & [SWOLE,SWNCNA])              _  THEN STOP OUTPUT             ?
      THEN
        BEGIN 
        O1ACTIVE := FALSE;
        B0WAIT   := FALSE;
        B0ERROR  := B0OK; 
  END; _IF I1ACTIVE?
_ 
* * *    CHECK FOR LINE ERRORS
? 
  B0LINE := SWDSR IN SASTATUS.SASET;   _IF DSR THEN LINE IS UP         ?
END; _PMSTATUS? 
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                                PMLFI                                 *
*                                                                      *
*                         PROCESS LINE FRAME INTERRUPT                 *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  THE LINE FRAME INTERRUPT IS PROCESSED TO                *
*              RETRIEVE DATA OR STATUS STORED INTO THE                 *
*              CIB BY THE MLIA.                                        *
*                                                                      *
** INPUT -     CQCIB - CIRCULAR INPUT BUFFER                           *
*              I1ACTIVE - INPUT ACTIVE FLAG                            *
*              O1ACTIVE - OUTPUT ACTIVE FLAG                           *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              ENTERED VIA INTERRUPT                                   *
*                                                                      *
** OUTPUT -    I1ACTIVE                                                *
*              O1ACTIVE                                                *
*              B0WAIT - WAIT CONDITION FLAG                            *
*              B0ERROR - ERROR CONDITION FLAG                          *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              PMINP - GET LAST LINE FRAME POSITION                    *
*              PMFAIL - FAIL ROUTINE                                   *
*              PMSTORE - STORE CHARACTER                               *
*              PMSTATUS - PROCESS CLA STATUS                           *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMLFI;
TYPE
      L0LF     = PACKED RECORD              _LINE FRAME TYPES          ?
                 CASE LIN:INTEGER OF
                 0:(LAINT  :ARRAY           _MOVE OVERLAY              ?
                            [0..3] OF 
                            INTEGER); 
                 1:(LAADRO,                 _ADDRESS OVERHEAD          ?
                    LACLA,                  _CLA ADDRESS               ?
                    LABT1O,                 _BYTE 1 OVERHEAD           ?
                    LABT1,                  _BYTE 1                    ?
                    LABT2O,                 _                          ?
                    LABT2,                  _BYTE 2                    ?
                    LABT3O,                 _BYTE 3                   ? 
                    LABT3   : 0..255);      _                         ? 
                 END; 
VAR 
      L1ELFP   : INTEGER;              _END LINE FRAME POSITION        ?
      LALF     : L0LF;
      L1FE     : INTEGER;              _FRAME ENTRY                    ?
      L1PROC   : BOOLEAN;              _FRAME PROCESSED                ?
      L1SL     : INTEGER;              _FRAME LENGTH                   ?
_$J+? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*              PMSTORE - PROCEDURE WITHIN PMLFI                        *
*                                                                     * 
*     STORE INPUT CHARACTER IN INPUT BUFFER                           * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMSTORE(I1CHR:CHAR);
  
BEGIN 
  IF I1ACTIVE                               _IF INPUT IS ACTIVE        ?
  THEN
    IF NOT I1MSG                       _IF READ LF NOT IN PROGRESS     ?
    THEN
      BEGIN 
      IF I1COUNT < I1LENGTH                 _BUFFER NOT OVERRUN        ?
      THEN
        BEGIN 
        IF I1COUNT = 2                 _MAKE ROOM FOR L AND F FIELDS   ?
        THEN
          I1COUNT := 4; 
        I1COUNT := I1COUNT + 1; 
        I1BUFF'[I1COUNT] := I1CHR;          _STORE CHARACTER           ?
        END; _IF I1COUNT? 
    END 
  ELSE                                 _INPUT NOT ACTIVE               ?
    I1MSG := TRUE;                     _SET READ LF IN PROGRESS        ?
END; _PMSTORE?
_$J+? 
BEGIN     _PROCEDURE PMLFI? 
  STREGS(BSREGL);                      _SAVE REGISTERS                 ?
  INST($C000,$1000,$0821);
  EINT; 
  
  PMINP(MLLFP,L1ELFP);                 _GET LAST LINE FRAME POSITION   ?
  
  WHILE L1SLFP " L1ELFP DO             _PROCESS ALL LINE FRAMES        ?
    BEGIN 
_ 
* * *    PICK UP THE LINE FRAME 
? 
    L1SL := 0;                         _MOVE LINE FRAME TO WORK AREA   ?
    REPEAT
      IF L1SL > 3                      _IF OUT OF ARRAY AREA           ?
      THEN                             _THEN                           ?
        BEGIN 
        LDREGS(BSREGL); 
        B0ERROR := B0FE;               _SET B0ERROR TO FRAME ERR  ? 
        B0WAIT  := FALSE;              _ CLEAR B0WAIT FLAG.       ? 
        IINT;                          _ DISABLE INTERRUPTS       ? 
        INST($E34);                    _ STATE INTERRUPT EXIT     ? 
        END;
      L1FE   := CQCIB[L1SLFP];         _FRAME ENTRY                    ?
      LALF.LAINT[L1SL] := L1FE; 
      L1SLFP := L1SLFP + 1;            _NEXT CIB ENTRY                 ?
      IF L1SLFP \ C1CIB                _RESET IF END OF CIB            ?
      THEN
        L1SLFP := 0;
      L1SL := L1SL + 1; 
    UNTIL L1FE < 0;                    _LAST LINE FRAME HAS HI ORDER   ?
                                       _ BIT ON                        ?
_ 
* * *    CHECK THE ADDRESS AND FORMAT 
? 
    L1PROC := FALSE;
    IF LALF.LACLA = M0TRUNK                 _IF CORRECT CLA ADDRESS    ?
    THEN
      BEGIN 
      CASE L1SL OF
        2:                                  _CHARACTER FRAME           ?
          IF (LALF.LABT1O = $CC) !
             (LALF.LABT1O = $8C)
          THEN
            BEGIN 
            PMSTORE(CHR(LALF.LABT1)); 
            L1PROC := TRUE; 
            END;
        3:                                  _STATUS FRAME              ?
          IF LALF.LABT1O = $0D         _IF CORRECT FORMAT              ?
          THEN
            IF (LALF.LABT2O = $CD) !
               (LALF.LABT2O = $8D)
            THEN
              BEGIN                    _PROCESS STATUS                 ?
              PMSTATUS(LALF.LABT1,LALF.LABT2);
              L1PROC := TRUE; 
              END;
        4:                                  _CHARACTER AND STATUS      ?
          IF (LALF.LABT1O = $0C) &          _IF CORRECT FORMAT THEN    ?
             (LALF.LABT2O = $0D)       _ PROCESS STATUS AND            ?
          THEN
            IF (LALF.LABT3O = $CD) !
               (LALF.LABT3O = $8D)
            THEN
              BEGIN 
              PMSTORE(CHR(LALF.LABT1));_STORE CHARACTER                ?
              PMSTATUS(LALF.LABT2,LALF.LABT3);
              L1PROC := TRUE; 
              END;
      END; _CASE L1SL?
    END; _IF LALF?
  
    IF NOT L1PROC                           _INCORRECT FRAME FORMAT    ?
    THEN                                    _  THEN SET ERROR          ?
      B0ERROR := B0FE;
  END; _WHILE L1SLFP " L1ELFP?
_ 
* * *    EXIT 
? 
  LDREGS(BSREGL);                    _ RESTORE INTERRUPS REGISTERS.   ? 
  IINT;                       _ DISABLE SYSTEM INTTERUPTS ? 
  INST($E34); 
END; _PMLFI?
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                              PMRETRY                                 *
*                                                                      *
*                         CHECK RETRY LIMIT                            *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  THIS ROUTINE CHECKS IF THE RETRY LIMIT HAS              *
*              BEEN EXCEEDED.  IF IT HAS, A FAILURE EXIT IS            *
*              GIVEN CONTROL.  IF THE RETRY LIMIT IS NOT               *
*              EXCEEDED, CONTROL IS RETURNED TO THE CALLING            *
*              PROCEDURE.                                              *
*                                                                      *
** INPUT -     NONE                                                    *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMTMON                                                  *
*                                                                      *
** OUTPUT -    RETRY COUNT UPDATED                                     *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              PMFAIL                                                  *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMRETRY;
BEGIN 
  IF B4RETRY > B0RIML                  _IF NEIGHBOR NOT RESPONDING     ?
  THEN
    PMFAIL;                            _THEN FAILURE                   ?
  B4RETRY := B4RETRY + 1;              _UPDATE RETRY COUNT             ?
END; _PMRETRY?
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*         PMNSTO,PMLRTO,PMPPDTO,PMDSRTO,PMPPDTO,PMIRTO,PMODDTO         *
*                                                                      *
*                          PMLFITO                                     *
*                                                                      *
*                       TIMER EXPIRATION ROUTINES                      *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
  
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  THESE ROUTINES ARE GIVEN CONTROL FROM PMTMRSRVC         *
*              VIA PBCALL. THESE ROUTINES ARE GIVEN CONTROL DUE        *
*              TO A PARTICULAR TIMER EXPIRATION.                       *
*                                                                      *
** INPUT -     MPSTAT                                                  *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMTMRSRVC VIA PBCALL                                    *
*                                                                      *
** OUTPUT -    MPSTAT                                                  *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              PMRDCS, PMWTNW                                          *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMNSTO;                           _NS INACTIVE TIME OUT      ?
BEGIN 
  B0ERROR := B0NSTO;
  B0WAIT  := FALSE; 
END; _PMNSTO? 
  
PROCEDURE PMLRTO;                           _LOAD RESPONSE TIME OUT    ?
BEGIN 
  B0ERROR := B0LRTO;
  B0WAIT  := FALSE; 
END; _PMLRTO? 
  
PROCEDURE PMPPDTO;                          _PPU DEAD TIME OUT         ?
BEGIN 
  B0ERROR := B0PPTO;
  B0WAIT  := FALSE; 
END; _PMPPDTO?
  
PROCEDURE PMDSRTO;                          _DSR TIME OUT              ?
BEGIN 
  B0WAIT := FALSE;                          _CLEAR WAIT CONDITION      ?
  B0ERROR := B0TO;                          _SET TIME OUT FLAG         ?
END; _PMDSRTO?
  
PROCEDURE PMPPKTO;                          _PPU KEEP ALIVE TIME OUT   ?
CONST 
  MCSNSR = BIT2;                            _PPU READ NSW              ?
BEGIN 
  MPCMD := MCPCON + MNCICS;                 _SET READ CSR COMMAND      ?
  PMRDCS(MPCMD,MPPSBIT);                    _READ CSR                  ?
  MPSTUS := MPPSBIT.MSET;                   _RETRIEVE STATUS           ?
  IF NOT(MCSNSR IN MPSTUS)
  THEN
    BEGIN 
    CASE MPSTAT OF                          _WHAT STATE                ?
      MSTWNR : _CASE MPSTAT?
        BEGIN 
        MPSTAT := MSTWOW;                   _NEW STATE = W-F-OWL       ?
        MTTMRTAB[MTPPUDED] := MTPPDCLK;     _START PPU DEAD TIMER      ?
        END;
      MSTWLD : _CASE MPSTAT?
        BEGIN 
        MTTMRTAB[MTPPUKA] := MTPPKCLK;      _START PPU KA TIMER        ?
        MPCMD := MCPCON + MNCONS;           _SET OUTPUT NSW            ?
        MPPARM.MINT := MNSIDL;              _SET IDLE NSW              ?
        PMWTNW(MPPARM,MPCMD);               _SEND IDLE TO COUPLER      ?
        MPSTAT := MSTLWN;                   _STATE = LOADING W-F-NSWR  ?
        MTTMRTAB[MTPPUDED] := MTPPDCLK; 
        END;
      MSTLWN : _CASE MPSTAT?
        BEGIN 
        MTTMRTAB[MTPPUKA] := MTPPKCLK;      _START PPU KEEP ALIVE TIMER?
        MPSTAT := MSTWLD                    _STATE = W-F-LOAD/DUMP     ?
        END;
      MSTIWN : _CASE MPSTAT?
        BEGIN 
        MPSTAT := MSTWIP;                   _STATE = W-F-INPUT         ?
        MTTMRTAB[MTPPUDED] := MTPPDCLK;     _START PPU DEAD TIMER      ?
        END;
    END; _CASE MPSTAT?
  END; _IF MCSNSR?
END; _PMPPKTO?
  
PROCEDURE PMIRTO;                           _INPUT REJECT TIME OUT     ?
BEGIN 
  MPPARM.MPTR := MMBADR;                    _SET BUFFER ADDRESS IN MAR ?
  MPCMD := MCPCON + MNCOMA;                 _BUILD COUPLER CMD         ?
  PMWTNW(MPPARM,MPCMD);                     _SEND INPUT AVAILABLE      ?
  MPCMD := MCPCON + MNCONS;               _OUTPUT NPU STATUS CMD.      ?
  MPPARM.MINT := MNSIAS;
  PMWTNW(MPPARM,MPCMD);                     _ FUNCTION INPUT AVAILABLE ?
  MPSTAT := MSTWIP;                         _ SET STATE = W-F-INPUT    ?
  MPPINT := 1;                              _ CLEAR UPLINE FLAG        ?
END; _PMIRTO? 
  
PROCEDURE PMODDTO;                          _ODD TIME OUT              ?
BEGIN 
  B0WAIT := FALSE;
  B0ERROR := B0TO;                          _SET TIME OUT FLAG         ?
END; _PMODDTO?
  
PROCEDURE PMLFITO;                          _LFI TIME OUT ROUTINE      ?
BEGIN 
   PMFAIL;                                  _TIMEOUT TRY NEXT ENTRY.   ?
END;  _PMLIFTO? 
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                               PMRSTMR                                *
*                                                                      *
*                            RESET ALL TIMERS                          *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  TURN OFF ALL TIMERS IN THE TIMER TABLE                  *
*                                                                      *
** INPUT -     NONE                                                    *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMINIT                                                  *
*                                                                      *
** OUTPUT -    TIMERS ARE RESET (TURNED OFF)                           *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              NONE                                                    *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMRSTMR;
VAR 
         T3INDX   : INTEGER;                _TIMER TABLE INDEX         ?
BEGIN 
  IINT;                                     _INHIBIT INTERRUPTS        ?
  FOR T3INDX := 1 TO T2TTEND DO 
    MTTMRTAB[T3INDX] := 0;                  _RESET TIMER               ?
  EINT; 
END; _PMRSTMR?
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                               PMSVMH                                 *
*                                                                      *
*                       PROCESS SERVICE MESSAGES                       *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  THIS ROUTINE PROCESSES LOAD, DUMP, AND START            *
*              SERVICE MESSAGES.  CONTROL IS PASSED TO THE             *
*              APPROPRIATE ROUTINE FOR EXECUTING THE LOAD,             *
*              DUMP, OR START COMMAND.  THIS ROUTINE GENERATES         *
*              SM RESPONSES WHEN A RESPONSE IS REQUIRED                *
*                                                                      *
** INPUT -     SERVICE MESSAGE IN MPBUFF                               *
*                                                                      *
** CALLING PROGRAMS                                                    *
*              PMIOHD                                                  *
*                                                                      *
** OUTPUT -    SERVICE MESSAGE RESPONSE IN MPBUFF IF REQUIRED          *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              PMLOAD                                                  *
*              PMDUMP                                                  *
*              PMSTRT                                                  *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMSVMH; 
VAR 
LOMEM : RECORD
      CASE BIT : INTEGER OF 
      0 : (INT : INTEGER);
      1 : (PTR : 'INTEGER); 
      END;
BEGIN 
  MTTMRTAB[MTNSINACT] := MTNSCLK;           _START NS INACTIVE TIMER   ?
  IF MPBUFF.BDCMD " 4 
  THEN
    B0WAIT := FALSE                         _TRY NEXT COUPLER/TRUNK    ?
  ELSE                                      _ BDCMD = 4                ?
    BEGIN 
    IF (MPBUFF.BDTYPE  = 0) ! (MPBUFF.BDTYPE  = 1) !
       (MPBUFF.BDTYPE  = 2) ! (MPBUFF.BDTYPE  = 4)
  THEN
    BEGIN 
    S0CMD := ORD(MPBUFF.BDTYPE ); 
    S0RESP := FALSE;                        _RESET SM RESPONSE FLAG    ?
    CASE S0CMD OF 
      S0DUMP:                               _DUMP SM                   ?
        PMDUMP; 
      S0LOAD:                               _LOAD SM                   ?
        PMLOAD; 
      S0START:  
        PMSTRT; 
      S0NRSTART:                            _START/NO RETURN SM        ?
        BEGIN 
         PMSCLI;
         PMCMD(MLRESET,0);                  _ RESET MLIA               ?
         PIWAIT($A);                        _ WAIT                     ?
        FOR LOMEM.INT := BSPBEGIN TO BSPEND DO
          LOMEM.PTR' := BSPROTECT[LOMEM.INT]; 
        PMSTRT; 
        END;
    END;_CASE S0CMD?
    IF S0RESP 
    THEN                                    _BUILD SM RESPONSE         ?
      BEGIN 
_ 
*** SWITCH DN/SN FIELDS OF SM 
? 
      S0DNTEMP := MPBUFF.BDDN;
      MPBUFF.BDDN := MPBUFF.BDSN; 
      MPBUFF.BDSN := S0DNTEMP;
      IF NOT S0ARSP 
      THEN                                  _BUILD NORMAL RESPONSE     ?
        BEGIN 
        MPBUFF.BDTFIELD := S0NORML;         _T = NORMAL RESP CODE      ?
        MPBUFF.BDRC := 0;                   _CLEAR REASON CODE         ?
        END 
      ELSE
        BEGIN                               _BUILD ABNORMAL RESPONSE   ?
        MPBUFF.BDTFIELD := S0ABNML;         _T = ABNORMAL RESP CODE    ?
        S0ARSP := FALSE;                    _RESET ABNORMAL RESP FLAG  ?
        END;
      IF B1COPFLG 
      THEN
        BEGIN                               _SET BUFFER LCD/FCD        ?
        MPBUFF.BDFCD := B1FCD;
        MPBUFF.BDLCD := S0RBC + B1FCD -1; 
        MPRPFG       := TRUE;               _ SET  RESPONSE FLAG       ?
        END 
      ELSE                                  _SET HDLC LENGTH FIELD     ?
        MPBUFF.BDL := CHR(S0RBC + 2);       _SET HDLC LENGTH FIELD     ?
      END  _IF S0RESP?
    ELSE   _ NOT S0RESP ? 
      MPBUFF.BDL := CHR(S0UARBC);           _SET HDLC LENGTH FIELD     ?
  END; _BDTYPE  TEST? 
  END;
END; _PMSVMH? 
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                               PMLOAD                                 *
*                                                                      *
*                     PROCESS LOAD SERVICE MESSAGE                     *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW - TRANSFER DATA IN A LOAD SM TO NPU MEMORY                 *
*                                                                      *
** INPUT -     MPBUFF (CONTAINS LOAD SM)
*                                                                      *
** CALLING PROGRAMS                                                    *
*              PMSVMH                                                  *
*                                                                      *
** OUTPUT -    B0ERROR                                                 *
*              S0ARSP                                                  *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              PBPUTPAGE                                               *
*              PBSTPMODE                                               *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMLOAD; 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  *
*                                                                      *
*          PROCFEDURE    L D P A G E                                   *
*                                                                      *
*                                                                      *
*                   IS A LOCAL PROCEDURE FOR PMLOAD                    *
*                   ITS FUNCTION IS TO SET THE CORRECT                 *
*                   PAGE REGISTER FOR LOADING THE CCP                  *
*                   NPU PROGRAM.                                       *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  *
? 
PROCEDURE LDPAGE(PGN0:INTEGER;PGVAL:INTEGER); 
_?
VAR 
  SVPTR :  INTEGER;               _ FRIST WORD ADDR. OF BUFF ?
  MAXPTR :  INTEGER;              _ SIZE OF BUFFER           ?
  SVPAGE : PGINT; 
_?
BEGIN 
IF (PGVAL = 8) ! (PGVAL = 9)      _ CHECK IF PAGE 8 OR 9     ?
THEN
  BEGIN                           _ GET NEW PAGE VALUE       ?
  IF SVPAGE.INT = 0               _ CHECK IF 1ST TIME        ?
  THEN
    BEGIN                         _ YES SET NEW PAGE PTR.    ?
    SVPTR  := SVLOC'[0];          _ GET FWA OF BUFFER.       ?
    MAXPTR := SVLOC'[1];          _ GET SIZE OF BUFFER       ?
    SVPAGE.INT := SVPTR + MAXPTR + $7FF;
    END; _ IF SVPAGE ?
_?
  PGVAL := PGVAL - 8 + SVPAGE.PAGE;   _SET PAGE VALUE     ? 
  END;  _ IF PGVAL  ? 
_?
PBPUTPAGE(PGN0,PGVAL);            _ GO SET PAGE VALUE     ? 
END;  _ LDPAGE  ? 
BEGIN 
PMSVMSG;
  WITH MPBUFF,S0ADDR DO 
    BEGIN 
    S0RBC := S0LRBC;
      S0SVRV := BDSRVU*32 + BDSRVL;         _ STARTING PAGE REG. VALUE ?
      IF S0SVRV > J1CORESIZE                _ADDRESS OUT OF RANGE TEST ?
      THEN
        BEGIN                               _BUILD ABNORMAL RESPONSE   ?
        BDRC   := S0BADADDR;                _SAVE REASON CODE          ?
        S0ARSP := TRUE;                     _SET ABNORMAL RESPONSE FLAG?
        S0RESP := TRUE;                     _SET SM RESPONSE FLAG      ?
        END 
      ELSE     _PROCESS LOAD                ? 
        BEGIN 
        LDPAGE(S0SPRN,S0SVRV);                _REQUEST PAGE SETTING   ? 
        LDPAGE(S0SPRN+1,S0SVRV+1);            _REQUEST PAGE SETTING   ? 
        IF B1COPFLG 
        THEN
          S0LENGTH := ((BDLCD-B0HDR)+1)/2   _USE LCD FOR MOVE LENGTH   ?
        ELSE
          BEGIN 
          S0LENGTH := ORD(BDL); 
          S0LENGTH := (S0LENGTH-B0HDR)/2;   _USE HDLC L FIELD FOR MOVE ?
          END; _IF B1COPFLG?
        PBSTPMODE(B0PM0);                   _SET PAGE MODE ZERO        ?
        S0XRV := S0SPRN;                     _START PAGE REGISTER      ?
        S0XPD := BDSPD;                      _START PAGE DISPLACEMENT  ?
        S0SRV := S0SPRN;                    _PAGE REGISTER             ?
        S0SPD := BDSPD;                     _START PAGE DISPLACEMENT   ?
        S0CKSUM := 0;                       _INITIALIZE CHECKSUM       ?
        S0BCNT := S0BCNT + 1;               _ UPDATE BATCH COUNT       ?
_ 
* * *     MOVE DATA TO MEMORY 
? 
        FOR S0DP := 1 TO S0LENGTH DO
          BEGIN 
          IF S0SVRV = 0                     _TEST FOR PAGE ZERO        ?
          THEN
            BEGIN 
            B0PROTECT := FALSE;             _RESET PROTECT FLAG        ?
            LPS0PD := (S0SPD + S0DP - 1); 
            IF (LPS0PD) @ BSPEND
            THEN
              IF LPS0PD \ BSPBEGIN
              THEN
                B0PROTECT := TRUE;           _TO BE PROTECTED         ? 
            IF B0PROTECT
            THEN
              BSPROTECT[LPS0PD] :=  BDLDAT[S0DP]
            ELSE
              S0INTARY'[S0DP] := BDLDAT[S0DP];
            END 
          ELSE
            S0INTARY'[S0DP] := BDLDAT[S0DP];
          S0CKSUM := S0CKSUM + BDLDAT[S0DP];_ACCUMULATE CHECKSUM       ?
          END; _FOR S0DP? 
        PBSTPMODE(B0APM);                   _SET ABSOLUTE PAGE MODE    ?
        B0ERROR := B0OK;
        S0RBC := S0LRBC;                    _LOAD SM RESPONSE BYTE CT  ?
        IF MPBUFF.BDBC " 0                  _IF BATCH COUNT " 0        ?
        THEN                                _BUILD RESPONSE            ?
          BEGIN 
          S0RESP := TRUE;                   _FLAG RESPONSCE .          ?
          IF MPBUFF.BDBC = S0BCNT 
          THEN
            BEGIN 
            S0BCNT := 0;                    _RESET BATCH COUNT        ? 
            END 
          ELSE
            BEGIN 
            BDRC := S0BCERR;                _SHOW RESON CODE ERROR.   ? 
            S0ARSP := TRUE;                 _FLAG  ABNORNAL RESP.     ? 
            MPBUFF.BDBC := S0BCNT;          _SHOW BATACH COUNT IN (SM)? 
            S0BCNT := 0;                    _ RESET  BATCH  COUNTER   ? 
            END; _IF = S0BCNT ? 
          END; _IF BDBC " 0 ? 
        IF (S0CKSUM + BDCSUM) " 0           _IF CKECKSUM ERROR         ?
        THEN
          BEGIN 
          BDRC   := S0CSERR;                _SAVE REASON CODE          ?
          S0ARSP := TRUE;                   _SET ABNORMAL FLAG         ?
          S0RESP := TRUE;                   _SET SM RESPONSE FLAG      ?
          END;
      END; _IF BDSRV > J1CORESIZE?
  END; _WITH MPBUFF?
END; _PMLOAD? 
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                               PMDUMP                                 *
*                                                                      *
*                      PROCESS DUMP SERVICE MESSAGE                    *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  TRANSFER REQUESTED MEMORY FRAGMENT TO THE               *
*              BUFFER AREA.                                            *
*                                                                      *
** INPUT -     MPBUFF - BUFFER CONTAINING DUMP SM                      *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMSVMH                                                  *
*                                                                      *
** OUTPUT -    MPBUFF - BUFFER CONTAINING DUMP DATA                    *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              PBPUTPAGE                                               *
*              PBSTPMODE                                               *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMDUMP; 
VAR 
      S0DERV   : 0..127;                    _ ENDING PAGE REG. VALUE   ?
BEGIN 
  WITH MPBUFF,S0ADDR DO 
    BEGIN 
    S0SVRV := BDSRVU*32 + BDSRVL;            _ BEGINNING PAGE NUMBER   ?
    S0DERV := BDERVU*32 + BDERVL;            _ ENDING PAGE NUMBER      ?
    PBPUTPAGE(S0SPRN,S0SVRV);                _ SET UP PAGE REGISTERS   ?
    PBPUTPAGE (S0SPRN+1,S0SVRV+1);
    S0LMT := (S0DERV-S0SVRV)*2048+BDEPD-BDSPD+1; _ LENGTH OF MOVE      ?
    PBSTPMODE(B0PM0);                       _SET PAGE MODE ZERO        ?
    IF (S0DERV > J1CORESIZE) ! (S0LMT < 0) ! (S0LMT > 105)
    THEN
      BEGIN                                 _BAD ADDRESS RANGE         ?
      BDRC   := S0BADADDR;                  _SET RESPONSE CODE         ?
      S0ARSP := TRUE;                       _SET ABNORMAL RESPONSE FLAG?
      END 
    ELSE
      BEGIN 
      S0XRV := S0SPRN;                      _START PAGE VALUE          ?
      S0XPD := BDSPD;                       _START PAGE DISPLACEMENT   ?
_ 
* * *     MOVE MEMORY TO BUFFER (MPBUFF)
? 
      FOR S0DP := 1 TO S0LMT DO 
      BEGIN 
      IF S0SVRV = 0 
      THEN
        BEGIN 
        B0PROTECT := FALSE; 
        LPS0PD := (S0XPD + S0DP - 1); 
        IF (LPS0PD) @ BSPEND
        THEN
          IF (LPS0PD) \ BSPBEGIN
          THEN
            B0PROTECT := TRUE;
        IF B0PROTECT
        THEN
          BDDATA[S0DP] := BSPROTECT[LPS0PD] 
        ELSE
          BDDATA[S0DP] := S0INTARY'[S0DP];
        END 
      ELSE
        BDDATA[S0DP] := S0INTARY'[S0DP];
      END;
      PBSTPMODE(B0APM);                     _SET ABSOLUTE PAGE MODE    ?
    END; _IF BDERV > J1CORESIZE?
    S0RBC := (S0LMT * 2) + S0DRBC;          _SM RESPONSE BYTE COUNT    ?
    S0RESP := TRUE; 
    B0ERROR := B0OK;
  END; _WITH MPBUFF?
END; _PMDUMP? 
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                               PMSTRT                                 *
*                                                                      *
*                     PROCESS START SERVICE MESSAGE                    *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  THE PROTECTED MEMORY AREA IS LOADED AND                 *
*              CONTROL PASSED TO THE LOADED PROGRAM.                   *
*                                                                      *
** INPUT -     BSPROTECT - SAVED LOAD DATA                             *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMSVMH                                                  *
*                                                                      *
** OUTPUT -    PROTECTED MEMORY IS LOADED                              *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              PMENTRY                                                 *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMSTRT; 
BEGIN 
  PMSVMSG;
  PMENTRY;                                  _GIVE CONTROL TO PROGRAM   ?
  S0RESP := TRUE; 
  S0RBC := S0STRBC;                         _START SM RESPONSE BYTE CT? 
  IF B0ERROR = B0MMER 
  THEN
    BEGIN 
    S0ARSP := TRUE;                         _SET ABNORMAL RES/FLAG.   ? 
    MPBUFF.BDRC  := S0MMERR;                _ SET RESON CODE TO 3     ? 
    END 
  ELSE
    B0ERROR  := B0OK;                       _ SET B0ERROR EQUAL TO 0  ? 
END; _PMSTRT ?
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                              PMPSOW                                 * 
*                                                                     * 
*                      PROCESS ORDER WORD                             * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW -  THIS ROUTINE READS ORDER WORD AND PROCESSES THE ORDER  * 
*              WORD COMMAND. ACTIONS ARE GOVERNED BY THE CURRENT      * 
*              COUPLER STATE                                           *
*                                                                     * 
** INPUT -     MPSTAT                                                 * 
*                                                                     * 
** CALLING PROGRAMS -                                                 * 
*              PMPCSR                                                 * 
*                                                                     * 
** OUTPUT -    MPSTAT,B0WAIT,TIMER TABLE MODIFIED                     * 
*                                                                     * 
** EXTERNAL SUBROUTINES -                                             * 
*              PMWTNW,PMRDCS                                          * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMPSOW; 
CONST 
_ 
***      PPU ORDER WORD CODE
? 
      ROWOSM   = 1;                         _OUTPUT SERVICE MESSAGE    ?
      ROWOHD   = 2;                         _OUTPUT HIGH PRIO. DATA    ?
      ROWOLD   = 3;                         _OUTPUT LOW PRIO. DATA     ?
      ROWNRY   = 4;                         _NOT READY FOR INPUT       ?
      ROWRGC   = 5;                         _REGULATION CHANGE         ?
      ROWIAK   = 6;                         _INIT ACKNOWLEDGEMENT      ?
      ROWHNS   = 8;                         _RGC AND NS                ?
      ROWNNS   = 4;                         _RGC AND NO NS             ?
BEGIN 
  CASE MPSTAT OF
    MSTPOW : _CASE MPSTAT?                  _STATE = PROCESS OW        ?
      BEGIN 
      IF MPPARM.MBOW = ROWIAK               _IF INIT-ACKNOWLEDGEMENT   ?
      THEN
        BEGIN 
        MPSTAT := MSTWLD;                   _SET STATE = W-F-LOAD/DUMP ?
        MTTMRTAB[MTPPUKA] := MTPPKCLK;      _START PPU KA TIMER        ?
        MTTMRTAB[MTNSINACT] := MTNSCLK;     _START NS INACTIVE TIMER   ?
        MTTMRTAB[MTLRRT] := 0;              _TURN OFF LRRT             ?
        MTTMRTAB[MTPPUDED] := MTPPDCLK;     _START PPU DEAD TIMER      ?
        END 
      ELSE
        BEGIN 
        IF (MPPARM.MBOW = ROWRGC) & (MPPARM.MBLN = ROWNNS)
                                            _REG-CHANGE-NO-NS          ?
        THEN
          BEGIN 
          MPSTAT := MSTCDN;                 _SET STATE = COUPLER-DOWN  ?
          B0WAIT := FALSE;                  _SET TIME OUT FLAG         ?
          END 
        ELSE
          IF (MPPARM.MBOW = ROWRGC) ! (MPPARM.MBOW = ROWOSM) !
             (MPPARM.MBOW = ROWOHD) ! (MPPARM.MBOW = ROWOLD) !
             (MPPARM.MBOW = ROWNRY) 
                                            _OTHER CONDITIONS          ?
          THEN
            BEGIN 
            MPSTAT := MSTWOW;               _SET STATE = W-F-OWL       ?
            MTTMRTAB[MTPPUDED] := MTPPDCLK; _RESTART PPD-DEAD TIMER    ?
            END; _IF OTHER CONDITIONS?
        END; _IF REG CHANGE AND NO NS?
      END; _MSTPOW? 
    MSTLPO :   _CASE MPSTAT?
      BEGIN 
      IF (MPPARM.MBOW = ROWRGC) & (MPPARM.MBLN = ROWNNS)
                                            _REG-CHANGE-NO-NS          ?
      THEN
        BEGIN 
        MPSTAT := MSTCDN;                   _SET STATE = COUPLER-DOWN  ?
        B0WAIT := FALSE;                    _SET TIME OUT FLAG         ?
        END 
      ELSE
        IF (MPPARM.MBOW = ROWRGC) & (MPPARM.MBLN = ROWHNS)
                                            _REG-CHANGE-NS             ?
        THEN
          BEGIN 
          MPSTAT := MSTWLD;                 _SET STATE = W-F-LOAD/DUMP ?
          MTTMRTAB[MTPPUDED] := MTPPDCLK;   _RESTART PPD-DEAD TIMER    ?
          END 
        ELSE
          IF (MPPARM.MBOW = ROWOSM) ! (MPPARM.MBOW = ROWOHD) !
             (MPPARM.MBOW = ROWOLD) 
                                            _OUTPUT DATA               ?
          THEN
            BEGIN 
            MPSTAT := MSTWOP;               _SET STATE = W-F-OUTPUT    ?
            MPBUFF.BDLCD := B1LCD;          _SET BUFFER LCD            ?
            MPBUFF.BDFCD := B1FCD;          _SET BUFFER FCD            ?
            MPCMD := MCPCON + MNCOMA;       _OUTPUT MAR                ?
            MPPARM.MPTR := MMBADR;          _SET UP MAR                ?
            PMWTNW(MPPARM,MPCMD);           _SEND NPU COMMAND          ?
            MPCMD := MCPCON + MNCONS;       _SET UP COMMAND            ?
            MPPARM.MINT := MNSRYO;
            PMWTNW(MPPARM,MPCMD);           _SEND CMD                  ?
            MTTMRTAB[MTPPUKA] := 0;         _ CLEAR IDLER TIMER        ?
            MTTMRTAB[MTPPUDED] := MTPPDCLK; _RESTART PPD-DEAD TIMER    ?
            END 
          ELSE
            B0WAIT := FALSE;                _SET TIME OUT FLAG         ?
      END; _MSTLPO? 
    MSTIPO     : _CASE MPSTAT?
      BEGIN 
      IF (MPPARM.MBOW = ROWRGC) & (MPPARM.MBLN = ROWNNS)
                                            _REG-CHANGE-NO-NS          ?
      THEN
        BEGIN 
        MPSTAT := MSTCDN;                   _SET STATE = COUPLER DOWN  ?
        B0WAIT := FALSE;                    _SET TIME OUT FLAG         ?
        END 
      ELSE
        IF (MPPARM.MBOW = ROWRGC) & (MPPARM.MBLN = ROWHNS)
                                            _REG-CHANGE-NS             ?
        THEN
          MPSTAT := MSTWIP                  _SET STATE = W-F-INPUT     ?
        ELSE
          IF (MPPARM.MBOW = ROWOSM) ! (MPPARM.MBOW = ROWOHD) !
                     (MPPARM.MBOW = ROWOLD) 
          THEN
            BEGIN 
            MPSTAT := MSTWIP;               _SET STATE = WAIT FOR INPUT?
            MTTMRTAB[MTPPUDED] := MTPPDCLK; _RESTART DEADMAN TIMER     ?
            MPCMD := MCPCON + MNCONS;       _SET OUTPUT NPU STATUS CMD ?
            MPPARM.MINT := MNSNRO ;         _NOT READY FOR OUTPUT      ?
            PMWTNW(MPPARM,MPCMD);           _ISSUE COMMAND             ?
            END 
          ELSE
            IF MPPARM.MBOW = ROWNRY         _NOT READY                 ?
            THEN
              BEGIN 
              MPSTAT := MSTWIP;             _SET STATE = W-F-INPUT     ?
              MTTMRTAB[MTPPUDED] := MTPPDCLK;_RESTART PPU DEAD TIMER   ?
              MPPINT := 2;                   _UPLINE DELAY .5 SEC      ?
              MTTMRTAB[MTIREJT] := MTIRCLK; _START INPUT REJ TIMER     ?
              END;
      END; _MSTIPO? 
   END; _CASE MPSTAT? 
END;_PMPSOW?
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                              PMIOHD                                 * 
*                                                                     * 
*                  I/O COMPLETE INTERRUPT HANDLER                     * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_I+,R-,G-?
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW -  THIS ROUTINE CALLS SERVICE MESSAGE HANDLER AND PRESENTS* 
*              RESPONSE TO COUPLER IF REQUIRED                        * 
*                                                                     * 
** INPUT -     MPSTAT                                                 * 
*                                                                     * 
** CALLING PROGRAMS -                                                 * 
*              PMPCSR                                                 * 
*                                                                     * 
** OUTPUT -    MPSTAT                                                 * 
*                                                                     * 
** EXTERNAL SUBROUTINES -                                             * 
*              PMSVMH                                                 * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMIOHD; 
BEGIN 
  MPSTAT := MSTPOP;                         _SET STATE = PROCESS-OUTPUT?
  B1COPFLG := TRUE;                         _SET COUPLER FLAG          ?
  PMSVMH;                                   _CALL SERVICE-MESSAGE      ?
  IF MPRPFG                                 _IF RESPONSE FLAG SET      ?
  THEN
    BEGIN 
    MPCMD := MCPCON + MNCOMA;               _SET OUTPUT MAR COMMAND    ?
    MPPARM.MPTR := MMBADR;                  _DEFINE MAR                ?
    PMWTNW(MPPARM,MPCMD);                   _ISSUE COMMAND             ?
    MPSTAT := MSTWIP;                       _SET STATE = W-F-INPUT     ?
    MPCMD := MCPCON + MNCONS;               _SET NPU CMD               ?
    MPPARM.MINT := MNSIAS;                  _INPUT AVAILABLE           ?
    PMWTNW(MPPARM,MPCMD);                   _SEND COMMAND TO COUPLER   ?
    MPRPFG := FALSE;                        _RESET RESPONSE FLAG       ?
    MPPINT := 1;                            _WAITING PIP INPUT DATA    ?
    END 
  ELSE
    MPSTAT := MSTWLD;                       _SET STATE = W-F-LOAD/DUMP ?
  MTTMRTAB[MTPPUDED] := MTPPDCLK;           _START PPU DEAD TIMER      ?
  MTTMRTAB[MTPPUKA] := MTPPKCLK;            _ SET IDLE TIMER           ?
END; _PMIOHD? 
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                               PMCMON                                * 
*                                                                     * 
*                       COUPLER SAM MONITOR                           * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW -  THIS ROUTINE ISSUES INITIALIZATION TO THE COUPLER      * 
*              THEN MONITORS THE COUPLER FOR AN INTERRUPT OR TIMEOUT  * 
*                                                                     * 
** INPUT -     MCPCON                                                 * 
*                                                                     * 
** CALLING PROGRAMS -                                                 * 
*              PMROUT                                                 * 
*                                                                     * 
** OUTPUT -    B0WAIT, INITIALIZE REQUEST SENT TO COUPLER             * 
*                                                                     * 
** EXTERNAL SUBROUTINES -                                             * 
*              PMWTNW PMRSTMR                                         * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ? 
PROCEDURE PMCMON; 
BEGIN 
  REPEAT
_?
  MPCMD := MCPCON + MNCONS;                 _SET OUTPUT NSW COMMAND    ?
  MPPARM.MINT := MNSINI;                    _SEND INITIALIZE           ?
  PMWTNW(MPPARM,MPCMD);                     _ISSUE INITIALIZE TO CUPLR ?
  MPSTAT := MSTWNR;                         _SET STATE = W-F-NSWR      ?
  B0WAIT := TRUE;                           _RESET TIMEOUT             ?
  MTTMRTAB[MTLRRT] := MTDSRCLK; 
  PMWAIT; 
  COTWICE := COTWICE + 1; 
_?
  UNTIL COTWICE > 2;
  PMRSTMR;                                  _RESET ALL TIMERS          ?
END;_PMCMON?
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                               PMTMON                                 *
*                                                                      *
*                             TRUNK SAM MONITOR                        *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  CONFIGURE THE CLA AND SEND A RIM FRAME TO               *
*              A POTENTIAL NEIGHBOR NPU. IF A SIM RESPONSE             *
*              IS RECEIVED THEN THE LOAD CONTINUES ACROSS              *
*              THE TRUNK, OTHERWISE THE LOAD IS TRIED ON               *
*              THE NEXT COUPLER OR TRUNK.                              *
*                                                                      *
** INPUT -     TRUNK (CLA) NUMBER IN M0TRUNK                           *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMROUT                                                  *
*                                                                      *
** OUTPUT -    RIM AND UA FRAMES SENT TO NEIGHBOR NPU                  *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              PMOUTPUT                                                *
*              PMINPUT                                                 *
*              PMSVMH                                                  *
*              PMRETRY                                                 *
*              PMSUPR                                                  *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMTMON; 
BEGIN 
  PMSUPR(M0TRUNK,C1CONFG);                  _CONFIGURE CLA             ?
_ 
* * *     WAIT FOR LINE OPERATIONAL OR TIME-OUT 
? 
  B0LINE := FALSE;                          _INITIALIZE FLAG           ?
  MTTMRTAB[MTDSR] := MTDSRCLK;              _START MODEM DSR TIMER     ?
  B0WAIT := TRUE; 
  WHILE NOT B0LINE & B0WAIT DO              _WAIT FOR LINE OPERATIONAL? 
    PMDMT;                                  _RESET DEAD MAN TIMER      ?
  IF B0LINE                                 _IF LINE OPERATIONAL RIM IT?
  THEN
    BEGIN 
    B4RETRY := 0;                           _INITIALIZE RETRY COUNTER  ?
    REPEAT
      B0ERROR := B0OK;                      _ SET FLAG B0ERROR OK ? 
      MPBUFF.BDC := CHR(B0RIM);             _BUILD RIM FRAME           ?
      MPBUFF.BDA := CHR(2); 
      MPBUFF.BDF := CHR(0); 
      MPBUFF.BDL := CHR(2); 
      PMOUTPUT;                             _SEND RIM TO NEIGHBOR      ?
      IF B0ERROR = B0OK                     _IF OUTPUT OF THEN WAIT    ?
      THEN     _  FOR SIM OR TIME-OUT       ? 
        BEGIN 
        MTTMRTAB[MTLRRT] := MTLRRCLK;       _START RESPONSE TIMER      ?
        PMINPUT;                            _GET REPLY                 ?
        IF (B0ERROR = B0OK) & 
           (MPBUFF.BDC = CHR(B0SIM))
        THEN
          B0ERROR := B0RDY
        ELSE
          PMRETRY;
        END 
      ELSE
        PMRETRY;                            _OUTPUT NOT OK             ?
    UNTIL B0ERROR = B0RDY;
    REPEAT
      IF (B0ERROR = B0OK) ! 
          (B0ERROR = B0RDY) 
      THEN
        BEGIN 
        IF MPBUFF.BDC = CHR(B0SIM)          _IF SIM FRAME              ?
        THEN                                _  THEN SEND UA RESPONSE   ?
          BEGIN 
          MTTMRTAB[MTDSR] := 0;             _ CLEAR MODEM DSR SWITCH   ?
          MTTMRTAB[MTLRRT] := 0;            _ CLEAR LOAD RESPONSE TIMER?
          MPBUFF.BDA := CHR(2);             _BUILD UA FRAME            ?
          MPBUFF.BDF := CHR(0); 
          MPBUFF.BDL := CHR(2); 
          MPBUFF.BDC := CHR(B0UAON);
          PMOUTPUT;                         _SEND FRAME                ?
          END 
        ELSE
          IF MPBUFF.BDC = CHR(B0UI)         _IF UI FRAME               ?
          THEN                              _  THEN PROCESS REQUEST    ?
            BEGIN 
            B4RETRY := 0;                   _REINITIALIZE RETRY COUNT ? 
            B1COPFLG := FALSE;
            PMSVMH;                         _PROCESS SM                ?
            IF (B0ERROR = B0OK) ! (B0ERROR = B0MMER)
            THEN
              BEGIN 
              MPBUFF.BDA := CHR(02);        _ SAMP I D  FOR LIP        ?
              MPBUFF.BDC := CHR(B0UAON);    _ UA RESPONSE TO LIP       ?
              MPBUFF.BDF := CHR($C0);        _ SAMP I D FOR LIP        ?
              PMOUTPUT;                     _SEND REPLY                ?
              IF B0ERROR  =  B0MMER         _ CHECK IF 8K MM           ?
              THEN
                BEGIN 
                INST($18FF);                _NOT 8K, HALT SYSTEM       ?
                END 
              ELSE
              END; _IF B0MMER  ?
            END; _IF B0UI?
        END; _IF B0OK ! B0RDY?
_ 
* * *     INPUT NEXT COMMAND
? 
  MTTMRTAB[MTLFI] := MTLFICLK;              _SET LFI INTERRUPR TIMER   ?
      PMINPUT;
    UNTIL FALSE;
    END; _IF B0LINE?
END; _PMTMON? 
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                              PMINIT                                 * 
*                                                                     * 
*                    SAM INTITIALIZATION MODULE                       * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
** OVERVIEW -  THIS ROUTINE INITIALIZES THE SAM BOOTSTRAP.  THE       * 
*              INTERRUPTS ARE LOADED, CASSETTE IS REWOUND, AND THE    * 
*              MLIA AND CLA-S ARE CLEARED AND INITIALIZED.  THIS      * 
*              ROUTINE GETS CONTROL ANY TIME THE SAM IS LOADED AND    * 
*              STARTED.                                               * 
*                                                                     * 
**INPUT -      NONE                                                   * 
*                                                                     * 
** CALLING PROGRAM -                                                  * 
*              NONE                                                   * 
*                                                                     * 
** OUTPUT -    NONE                                                   * 
*                                                                     * 
** EXTERNAL SUBROUTINE -                                              * 
*              PMROUT                                                 * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMINIT; 
VAR 
LOMEM : RECORD
      CASE BIT : INTEGER OF 
      0 : (INT : INTEGER);
      1 : (PTR : 'INTEGER); 
      END;
BEGIN 
  IINT;                                     _INHIBIT INTERRUPTS        ?
  CPBITS;                                   _SET PROTECT BITS          ?
  FOR B0PN := 0 TO 31 DO                    _INITIALIZE PAGE 0 REGS.   ?
    PBPUTPAGE (B0PN, B0PN); 
  PBSTPMODE (B0PM0);                        _*PILMT* REQUIRES PAGE 0   ?
  PILMT;                                    _CALCULATE MEMORY SIZE     ?
  PMLDMT;                                   _LOAD NPU DEADMAN TIMER    ?
                                            _  RESET CODE IN FIRMWARE  ?
  FOR LOMEM.INT := BSPBEGIN TO BSPEND DO
    BSPROTECT[LOMEM.INT] := LOMEM.PTR'; 
  PMINTRP;                                  _LOAD INTERRUPT VECTORS    ?
  PMMASK(I0RTCIM);                          _SET UP RTC INTERRUPT MASK ?
  PMREWIND;                                 _REWIND CASSETTE           ?
  ADDR(BSSAVE,BSREGS);                      _GET ADR OF REG SAVE AREA  ?
  BSREGS := BSREGS - 10;                    _ALIGN SAVE AREA           ?
  ADDR(BSSAV1,BSREGT);                      _GET ADR OF REG SAVE AREA  ?
  BSREGT := BSREGT - 10;                    _ ALIGN SAVE ADDRESS       ?
  ADDR(BSSAV2,BSREGL);                      _ LF SAVE REGISTERS AREA   ?
  BSREGL:= BSREGL - 10;                     _ LF INTERRUPTS SAVE AREA  ?
  S0BCNT := 0;                              _INITIALIZE BATCH COUNT    ?
_ 
* * *    CLEAR AND INITIALIZE MLIA
? 
  PMCMD(MLRESET,0);                         _RESET MLIA                ?
  PIWAIT($A);                               _WAIT                      ?
  PMCMD(MLIDLE,0);                          _IDLE MLIA                 ?
  PMCMD(MLLOOP,MLPARA);                     _SET IDLES/NULLS           ?
  ADDR(CQCIB,CQCIBA);                       _GET CIB ADDRESS           ?
  PMCMD(MLCIBA,CQCIBA);                     _SET CIB ADDRESS           ?
  PMCMD(MLCIBL,MLCIBC);                     _SET CIB LENGTH            ?
_ 
* * *    CLEAR ALL CLA-S
? 
  FOR B2CLA := 1 TO 255 DO
    BEGIN 
    PMSUPR(B2CLA,C1ISON);                   _SEND ISON                 ?
    PMSUPR(B2CLA,C1CLEAR);                  _CLEAR                     ?
  END; _FOR B2CLA?
_ 
* * *    CLEAR RESIDUE ODD AND MLIA STATUS
? 
  FOR B2CLA := 1 TO 512 DO
    PMINP(MLODD,B1ODD);                     _READ ODD TWICE ON EACH CLA?
  PMCMD(MLRSTLFP,MLPARA);                   _RESET LFP                 ?
  PMINP(MLLFP,L1SLFP);                      _READ LINE FRAME POSITION  ?
  PMINP(MLSTATUS,B1STATUS);                 _READ AND SAVE STATUS      ?
  PMINP(MLSTATUS,B1STATUS);                 _  TWICE                   ?
  PMSCLK;                                   _START REAL TIME CLOCK     ?
  EINT;                                     _ENABLE INTERRUPTS         ?
_ 
* * *    ISSUE LOAD REQUESTS
? 
  PMCMD(MLSTART,0);                         _ START MLIA               ?
  PIWAIT($A);                               _ WAIT                     ?
  PMROUT; 
END; _PMINIT? 
_$J+? 
_ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
*                                                                      *
*                                PMROUT                                *
*                                                                      *
*                        ROUTE LOAD REQUESTS                           *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
  
_ 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                      *
** OVERVIEW -  THIS ROUTINE ROUTES LOAD REQUESTS TO THE COUPLERS       *
*              AND TRUNKS.  THE FOLLOWING ROUTING IS USED:             *
*                FIRST ATTEMPT VIA COUPLER 1                           *
*                SECOND ATTEMPT VIA COUPLER 2                          *
*                THIRD ATTEMPT VIA TRUNK 1                             *
*                FOURTH ATTEMPT VIA TRUNK 2                            *
*                FIFTH ATTEMPT VIA TRUNK 3                             *
*                SIXTH ATTEMPT VIA TRUNK 4                             *
*              THIS ROUTING IS END AROUND AND CONTINUES UNTIL          *
*              A SUCCESSFUL LOAD IS COMPLETED.                         *
*                                                                      *
** INPUT -     NONE                                                    *
*                                                                      *
** CALLING PROGRAMS -                                                  *
*              PMINIT                                                  *
*                                                                      *
* 
** OUTPUT -    COUPLER ADDRESS FOR COUPLER LOAD REQUESTS               *
*              TRUNK NUMBER FOR TRUNK LOAD REQUESTS                    *
*                                                                      *
** EXTERNAL SUBROUTINES -                                              *
*              PMCMON                                                  *
*              PMTMON                                                  *
*                                                                      *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
? 
PROCEDURE PMROUT; 
BEGIN 
  MPFF := TRUE;                             _SET FF FLAG FOR INFINITIVE?
  SVPAGE.INT := 0;
  ADDR(MPBUFF,MMBADR);                      _SET UP MAR                ?
                                            _  LOOP                    ?
  REPEAT
     C0INDEX := 1;                          _ INITIALILIZE COUPLER     ?
     COTWICE := 1;
     MCPCON := $0600;                       _  FOR FIRST COUPLER       ?
     IINT;
     PMMASK(I0C1RIM);                       _MASK COUPLER 1 + RTC INTS ?
     ACTINT := 0; 
     EINT;
  
    REPEAT
      S0BCNT := 0;                          _INITIALIZE BATCH COUNT    ?
      PMCMON;                               _CALL COUPLER-SAM MONITOR  ?
      MCPCON := MCPCON + $0080;             _TRY NEXT COUPLER          ?
      C0INDEX := C0INDEX + 1;               _INCREMENT INDEX           ?
     COTWICE := 1;
      IINT; 
      PMMASK(I0C2RIM);                      _MASK COUPLER 2 + RTC INTS ?
      ACTINT := 0;
      EINT; 
    UNTIL C0INDEX > 2;                      _LOOP UNTIL BOTH COUPLERS  ?
                                            _  TRIED                   ?
    M0TRUNK := 1;                           _FOR FIRST TRUNK           ?
    IINT; 
    PMMASK(I0OLRIM);                        _ODD, LF, RTC INT MASK     ?
    ACTINT := I0ODIAA;
    REPEAT
    EINT; 
      S0BCNT := 0;                          _INITIALIZE BATCH COUNT    ?
      PMTMON;                               _CALL TRUNK MONITOR        ?
  
      M0TRUNK := M0TRUNK + 1;               _TRY NEXT TRUNK            ?
    UNTIL M0TRUNK > 4;                      _LOOP                      ?
  UNTIL MPFF = FALSE; 
END;_PMROUT?
BEGIN 
END.
