*DECK NS$N06
USETEXT CYB$NS
USETEXT DTSB$NS 
USETEXT ERR$NS
USETEXT NAT$NS
USETEXT NDF$NS
USETEXT SMB$NS
USETEXT SMD$NS
  
PROC NS$N06(ERRCODE);        # PROCESS NPU/DT/N (DUMP)                 #
  
# TITLE NS$N06 - PROCESS NPU/DT/N (DUMP).                              #
  
      BEGIN    # NS$N06 # 
# 
**    NS$N06 - PROCESS NPU/DT/N (DUMP). 
* 
*     J.C. LEE    1981
* 
*     THIS ROUTINE PROCESSES NPU/DT/N (DUMP). 
* 
* 
*     PROC NS$N06(ERRCODE)
* 
*     ENTRY:  
*       NONE. 
* 
*     EXIT: 
*       ERRCODE.
* 
*     METHOD: 
*       DECREMENT DUMP BATCH COUNT (DBC)
*       CALCULATE DUMP DATA HEX WORDS.
*       IF DUMP DATA WITHIN LIMIT AND DBC NOT YET EXHAUSTED:  
*         CLEAR RETRY COUNT.
*         FORMAT DUMP PACKET ENTRY. 
*         TRANSFER DUMP PACKET TO DUMP TSB. 
*         UPDATE DBC. 
*         IF DBC EQ 0 
*           IF DUMP DIRECTIVE COMPLETE
*             PROCESS NEXT DPCB DIRECTIVE.
*           ELSE
*             START DUMP DATA.
*             START LOCAL TIMER.
*       ELSE
*         SET ERRCODE TO "BAD DUMP RESPONSE FROM NPU".
* 
# 
  
      ITEM ERRCODE    U;     # ERRCODE                                 #
  
      $BEGIN
      XREF
        BEGIN 
        PROC NS$DBG;         # TRACE PROCEDURE CALL                    #
        END 
      $END
  
      XREF
        BEGIN 
        FUNC NS$FEC U;       # FORMAT ERROR CODE                       #
        PROC NS$SDB;         # SEND DUMP BATCH                         #
        PROC NS$SLT;         # START RESPONSE TIMER                    #
        PROC NS$XPD;         # PROCESS NEXT XPCB DIRECTIVE             #
        PROC TSBINFO;        # LOCATE TSB                              #
        PROC WRITEW;         # WRITEW DATA TRANSFER MACRO CALL         #
        END 
  
      ITEM CMWORDS    U;     # NUMBER OF CM WORDS IN NPU DUMP DATA     #
      ITEM DBC        U;     # DUMP BATCH COUNT                        #
      ITEM I          I;     # TEMPORARY VARIABLE                      #
      ITEM J          I;     # TEMPORARY VARIABLE                      #
      ITEM NPUWORDS   U;     # NUMBER OF NPU WORDS IN DUMP RESPONSE    #
      ITEM TSBFWA     U;     # FWA OF TSB                              #
      ITEM TSBSIZE    U;     # TSB SIZE                                #
  
      BASED ARRAY DSM$DATA [1:MAX$DPSIZE] S(1); 
        BEGIN                # DUMP DATA WORD FORMAT IN DUMP RESPONSE  #
        ITEM DSM$DATA1  U(00,20,40);   # DUMP DATA IN FIRST WORD       #
        ITEM DSM$DATA2  U(00,00,20);   # DUMP DATA IN NEXT WORD        #
        END 
  
      BASED ARRAY NDF$DPDATA [1:MAX$DPSIZE] S(1); 
        BEGIN                # DUMP PACKET DATA FORMAT                 #
        ITEM DPD$DATAWD U(00,00,60);
        ITEM DPD$DATA1  U(00,00,40);
        ITEM DPD$DATA2  U(00,40,20);
        END 
  
CONTROL EJECT;
  
      $BEGIN
      NS$DBG("N06");         # TRACE CALL                              #
      $END
  
      ERRCODE = 0;
      DBC = NAT$BC[0] - 1;             # DECREMENT DUMP BATCH COUNT    #
      NPUWORDS = (ABHTLC[0] - LNPUDTDN + 1) / 2; # DUMP DATA HEX WORDS #
  
      IF NPUWORDS LQ MAX$DPHWDS        # DUMP DATA WITHIN ALLOWED LIMIT#
        AND DBC GQ 0                   # DUMP BATCH NOT YET EXHAUSTED  #
      THEN                   # VALID DUMP RESPONSE                     #
        BEGIN 
        NAT$RETRYS[0] = 0;
# 
        FORMAT DUMP PACKET ENTRY
# 
        P<NDF$DPHDR> = LOC(ABH$WORD);  # FWA OF DUMP PACKET HEADER     #
        CMWORDS = (NPUWORDS*16 + (WL-1)) / WL;   # DUMP DATA CM WORDS  #
        DPH$WORD[0] = 0;
        DPH$WC[0] = CMWORDS + L$DPHDR; # CM WORD COUNT OF ENTRY        #
        DPH$NC[0] = NPUWORDS;          # HEX WORD COUNT OF ENTRY       #
        DPH$BA1[0] = NPUBA1[0];        # DUMP PACKET BEGINNING ADDRESS #
        DPH$BA2[0] = NPUBA2[0]; 
  
        P<NDF$DPDATA> = LOC(SMB$BUFFER); # FWA OF DUMP PACKET DATA     #
        P<DSM$DATA> = LOC(SMB$BUFFER) + (((2*LNPUDTDN+14)/15) - 1); 
        J = 1;
  
        FOR I=1 STEP 1 UNTIL CMWORDS
        DO
          BEGIN              # MOVE DUMP DATA FROM SM TO DUMP PACKET   #
          DPD$DATA1[I] = DSM$DATA1[J];
          J = J + 1;
          DPD$DATA2[I] = DSM$DATA2[J];
          END 
# 
        TRANSFER DUMP PACKET TO DUMP TSB
# 
        TSBINFO(TSBSIZE,TSBFWA,NAT$NDTSBN[0]);   # LOCATE DUMP TSB     #
        P<DTSB$FET> = TSBFWA + L$DTSBHDR;        # FWA OF FET          #
        WRITEW(DTSB$FET,NDF$DPHDR,L$DPHDR+CMWORDS); # TRANSFER PACKET  #
        NAT$BC[0] = DBC;               # UPDATE DUMP BATCH COUNT       #
  
        IF DBC EQ 0 
        THEN                           # WHOLE DUMP BATCH RECEIVED     #
          BEGIN 
          IF NAT$F$DP[0]
          THEN                         # DUMP DIRECTIVE COMPLETES      #
            BEGIN 
            NS$XPD(ERRCODE);           # PROCESS NEXT DPCB DIRECTIVE   #
            END 
  
          ELSE                         # MORE DATA TO DUMP             #
            BEGIN 
            NS$SDB;                    # SEND DUMP BATCH               #
            NS$SLT;                    # START RESPONSE TIMER          #
            END 
          END 
  
        END 
  
      ELSE                   # BAD DUMP RESPONSE FROM NPU              #
        BEGIN 
        ERRCODE = NS$FEC(EC"ERR$SM",SMEC"NSM$DMP"); 
        END 
  
      RETURN; 
      END   # NS$N06 #
      TERM