*DECK CALLCVL 
USETEXT COMCBEG 
USETEXT COMMCOM 
USETEXT COMRNET 
    PROC CALLCVL (CVLCST);
# TITLE   CALLCVL - CALL CVL    # 
  
      BEGIN  # CALLCVL #
  
# 
**    CALLCVL - CALL CVL
* 
*     THIS PROCEDURE CALLS CVL TO OBTAIN NAD MAINTENANCE ACCESS.
* 
*     PROC CALLCVL(CVLCST)
* 
*     ENTRY   - DLCVLR   = FALSE, IF REQUESTING MAINTENANCE ACCESS. 
*                        = TRUE, IF RELEASING MAINTENANCE ACCESS. 
*               <NAD$ENTRY> = FWA OF NAD ENTRY IN NDT.
*               <PTH$ENTRY> = FWA OF PATH ENTRY IN NDT. 
*               <RMT$ENTRY> = FWA OF REMOTE NAD ENTRY IN NDT. 
* 
*     EXIT    - DLCVLR   = TRUE, IF MAINTENANCE ACCESS OBTAINED.
*                           (NAD$ESTORD = NAD EST ORDINAL)
*                        = FALSE, IF MAINTENANCE ACCESS RELEASED
*                                    OR DENIED. 
*               CVLCST   = 0, IF NO ERROR 
*                        = 1, IF NAD IN USE 
*                        = 2, IF OTHER ERROR. 
* 
*     PROCESS - SET UP CVL PARAMETER BLOCK
*               CALL CVL TO OBTAIN OR RELEASE MAINTENANCE ACCESS
*               IF NAD ACCESS GRANTED/RELEASED (NO ERROR) 
*                 SET DLCVLR = TRUE/FALSE (OBTAINED/RELEASED) 
*                 SET CVLCST = 0
*                 SET NAD$ESTORD = NAD EST ORDINAL
*               ELSE
*                 SET DLCVLR = FALSE
*                 IF NAD ACCESS DENIED (IN USE) 
*                   SET CVLCST = 1
*                   SEND B-DISPLAY MESSAGE
*                 ELSE (OTHER CVL ERROR)
*                   SET CVLCST = 2
*                   SEND DAYFILE MESSAGE
# 
  
      ITEM CVLCST     I;             # CVL CODE/STATUS #
  
  
# 
****  PROC CALLCVL - XREF LIST BEGIN
# 
  
      XREF  # CALLCVL XREF #
        BEGIN 
        PROC CALLSYS;              # CALL SYSTEM VIA RA+1 # 
        PROC DBGNAME;              # DEBUG - DAYFILE MESSAGE #
        FUNC HEXCHF     C(10);     # VALUE TO HEX DISPLAY # 
        FUNC OCTCHF     C(10);     # VALUE TO OCTAL DISPLAY # 
        END 
  
# 
****  PROC CALLCVL - XREF LIST END
# 
  
# 
*     CVL RELATED DEFINITIONS 
# 
      DEF CVLPBLEN   #10 #;  # LENGTH OF CVL PARAMETER BLOCK #
  
      DEF CVLRC      # 1 #;  # RESPONSE CODE #
      DEF CVLES      # 2 #;  # EST ORDINAL #
      DEF CVLCH      # 3 #;  # CHANNEL NUMBER # 
      DEF CVLEQ      # 4 #;  # EQUIPMENT NUMBER # 
      DEF CVLUN      # 5 #;  # UNIT NUMBER #
      DEF CVLDC      # 6 #;  # DEVICE CODE #
      DEF CVLFC      # 7 #;  # FUNCTION CODE #
      DEF CVLAC      # 8 #;  # ACCESS CODE #
      DEF CVLLT      # 9 #;  # LOCAL TCU #
      DEF CVLND      #10 #;  # NAD ADDR # 
  
      DEF DC$LNAD    #O"300"#;  # LOCAL NAD DEVICE CODE # 
      DEF DC$RNAD    #O"301"#;  # REMOTE NAD DEVICE CODE #
      DEF FC$DEDACC  #O"201"#;  # DEDICATED ACCESS FUNCTION # 
      DEF FC$RELACC  #O"010"#;  # RELEASE ACCESS FUNCTION # 
      DEF FC$SHRACC  #O"000"#;  # SHARED ACCESS FUNCTION #
      DEF RC$LOCRES  #O"00"#;   # LOCAL NAD RESERVED #
      DEF RC$NONAD   #O"04"#;   # NO LOCAL NAD FOUND #
      DEF RC$LOCUSE  #O"06"#;   # LOCAL NAD IN USE #
      DEF RC$REMUSE  #O"16"#;      # REMOTE NAD IN USE #
      DEF RC$INDET   #O"34"#;   # REMOTE NAD INDETERMINATE (OK) # 
  
# 
*     CVL PARAMETER BLOCK 
# 
  
      ARRAY [1:CVLPBLEN] S(1);     # CVL PARAMETER BLOCK #
        BEGIN 
        ITEM CVL$PBLOCK U(00,00,60);
        END 
  
      BASED ARRAY CVL$PB [1:CVLPBLEN] S(1);  # CVL PARAM BLOCK #
        BEGIN 
        ITEM CVL$PBWD   U(00,00,60);  # WORD #
        ITEM CVL$PBDAB1 B(00,05,01);  # DEDICATED ACCESS #
        ITEM CVL$PBDAB2 B(00,06,01);  # DEDICATED ACCESS #
        ITEM CVL$PBDAB3 B(00,07,01);  # DEDICATED ACCESS #
        ITEM CVL$PBDAB4 B(00,08,01);  # DEDICATED ACCESS #
        ITEM CVL$PBDINW B(00,11,01);  # DATA-IN-WORD #
        ITEM CVL$PBDCB3 U(00,36,12);  # DEVICE CODE, BYTE 3 # 
        ITEM CVL$PBDMN  C(00,36,02);  # DEVICE MNEMONIC # 
        ITEM CVL$PBRNAC U(00,44,16);  # ACCESS CODE # 
        ITEM CVL$PBRESP U(00,48,06);  # RESPONSE CODE # 
        ITEM CVL$PBESTO U(00,48,12);  # EST ORDINAL # 
        ITEM CVL$PBCHAN U(00,48,12);  # CHANNEL NUMBER #
        ITEM CVL$PBDCB4 U(00,48,12);  # DEVICE CODE, BYTE 4 # 
        ITEM CVL$PBFUNC U(00,48,12);  # FUNCTION CODE # 
        ITEM CVL$PBRNAD U(00,52,08);  # REMOTE NAD ADDR # 
        ITEM CVL$PBBFSZ U(00,54,02);  # BUFFER SIZE INDEX # 
        ITEM CVL$PBTCU  U(00,56,04);  # LOCAL TCU ENABLES # 
        ITEM CVL$PBCOMP B(00,59,01);  # COMPLETE FLAG # 
        END 
  
# 
*     CVL CALL BLOCK
# 
  
      ARRAY CVL$CALL [0:0] S(1);
        BEGIN 
        ITEM CVL$CNAME  C(00,00,03) = ["CVL"];
        ITEM CVL$CRCL   B(00,19,01) = [TRUE]; 
        ITEM CVL$CFC    U(00,36,06) = [1];
        ITEM CVL$CPBLK  U(00,42,18);
        END 
# 
*     CVL DAYFILE MESSAGES
# 
      ARRAY [1:2] S(6);            # CVL DAYFILE MESSAGES # 
        BEGIN 
        ITEM CVLERRMSG  C(00,00,50) = 
          [" MHF, WAITING FOR ACCESS TO NAD,      CH=XX, ND=YY",
           " MHF, NAD MAINTENANCE ACCESS DENIED,  CH=XX, ND=YY"]; 
        ITEM CVLERRMSGC C(04,06,02);  # LOCAL NAD CHANNEL # 
        ITEM CVLERRMSGL U(04,18,42);  # ZERO IF LOCAL NAD # 
        ITEM CVLERRMSGR C(04,18,05);  # ND= IF REMOTE NAD # 
        ITEM CVLERRMSGA C(04,48,02);  # REMOTE NAD ADDR # 
        ITEM CVLERRMSGT C(05,00,60) = [2(0)];  # TERMINATOR # 
        END 
  
  
      ITEM I          I;           # SCRATCH #
  
CONTROL EJECT;
  
      $BEGIN
      DBGNAME ("CALLCVL");         # DEBUG MESSAGE #
      $END
  
      CVLCST = 0;                  # CLEAR RETURN PARAMETER # 
  
      P<CVL$PB> = LOC(CVL$PBLOCK[1]); 
      CVL$CPBLK = LOC(CVL$PBLOCK[1]);  # PARAMETER BLOCK ADDRESS #
      FOR I = CVLRC STEP 1 UNTIL CVLND
      DO
        BEGIN 
        CVL$PBWD[I] = 0;           # CLEAR PARAMETER BLOCK #
        END 
  
      CVL$PBESTO[CVLES] = NAD$ESTORD;  # EST ORDINAL #
      CVL$PBCHAN[CVLCH] = NAD$CHAN;    # CHANNEL NUMBER # 
      CVL$PBDCB3[CVLEQ] = DC$LNAD;     # NAD DEVICE CODE #
      CVL$PBDCB4[CVLDC] = DC$LNAD;     # NAD DEVICE CODE #
  
      IF DLCVLR                    # IF RELEASING ACCESS #
      THEN
        BEGIN 
        CVL$PBFUNC[CVLFC] = FC$RELACC;  # FUNCTION CODE # 
        END 
  
      ELSE
        BEGIN 
        IF DLRMTNAD                # IF REMOTE NAD ACCESS # 
        THEN
          BEGIN 
          CVLCST = 1; 
          CVL$PBFUNC[CVLFC] = FC$SHRACC;  # SHARED ACCESS FUNCTION #
          CVL$PBRNAC[CVLAC] = PTH$ACCESS;  # ACCESS CODE #
          CVL$PBDINW[CVLAC] = TRUE;  # ACCESS CODE GIVEN #
          CVL$PBTCU[CVLLT] = PTH$LTE;  # LOCAL TRUNK ENABLES #
          CVL$PBBFSZ[CVLLT] = 1;  # BUFFER SIZE INDEX # 
          CVL$PBDCB3[CVLND] = DC$RNAD;  # DEVICE CODE # 
          CVL$PBDCB4[CVLDC] = DC$RNAD;  # DEVICE CODE # 
          CVL$PBDAB3[CVLND] = TRUE;     # DEDICATED ACCESS #
          CVL$PBRNAD[CVLND] = RMT$NAD;  # NAD ADDRESS # 
          END 
  
        ELSE
          BEGIN 
          CVL$PBDAB3[CVLEQ] = TRUE;  # DEDICATED ACCESS # 
          CVL$PBFUNC[CVLFC] = FC$DEDACC;  # FUNCTION CODE # 
          END 
        END 
  
      FOR I = CVLES STEP 1 UNTIL CVLND
      DO
        BEGIN 
        CVL$PBDINW[I] = (CVL$PBWD[I] NE 0);  # DATA-IN-WORD # 
        END 
      CVL$PBDINW[CVLCH] = TRUE;    # IN CASE CHANNEL 0 #
  
  
      CALLSYS (CVL$CALL);          # CALL CVL # 
  
      IF (CVL$PBRESP[CVLRC] EQ 0   # IF LOCAL ACCESS GRANTED #
           AND CVLCST EQ 0) 
        OR (CVL$PBRESP[CVLRC] EQ RC$INDET  # OR REMOTE ACCESS # 
             AND CVLCST EQ 1) 
      THEN
        BEGIN 
        DLCVLR = NOT DLCVLR;       # TOGGLE CVL RESERVED FLAG # 
        CVLCST = 0; 
  
        IF DLCVLR                  # IF ACCESS GRANTED #
          AND NAD$ESTORD EQ 0      # AND EST ORDINAL CLEAR #
        THEN
          BEGIN 
          NAD$ESTORD = CVL$PBESTO[CVLES];  # SAVE EST ORDINAL # 
          END 
        END 
  
      ELSE
        BEGIN 
        DLCVLR = FALSE;            # CLEAR CVL RESERVED FLAG #
  
        IF CVL$PBRESP[CVLRC] EQ RC$LOCUSE    # IF NAD IN USE #
          OR CVL$PBRESP[CVLRC] EQ RC$REMUSE 
        THEN
          BEGIN 
          CVLCST = 1;              # NAD IN USE # 
          MSG$DSPLAY = MSG$BDIS;   # B-DISPLAY MESSAGE #
          END 
  
        ELSE
          BEGIN 
          CVLCST = 2;              # OTHER ERROR #
          MSG$DSPLAY = MSG$DAYF;   # DAYFILE MESSAGE #
          END 
  
        CVLERRMSGC[CVLCST] = OCTCHF (NAD$CHAN,2);  # LOCAL NAD CHAN # 
        CVLERRMSGL[CVLCST] = 0; 
  
        IF DLRMTNAD                # IF REMOTE NAD #
        THEN
          BEGIN 
          CVLERRMSGR[CVLCST] = ", ND="; 
          CVLERRMSGA[CVLCST] = HEXCHF (RMT$NAD,2);  # NAD ADDR #
          END 
  
        MSG$BUFADR = LOC(CVLERRMSG[CVLCST]);
        MSG$STATUS = 0; 
        CALLSYS (MSGCALL);         # SEND MESSAGE # 
        MSG$DSPLAY = MSG$DAYF;     # RESET MESSAGE DESTINATION #
        END 
      END 
  
    TERM
