          EJECT
*         CTEXT CTP$DFT LOG PACKET TO CONSOLE.
*
*         THIS COMMON DECK CONTAINS THE CODE TO LOG AN MRB OR THE MRT
*         TO THE CONSOLE.  AT THIS TIME, ONLY S0/S0E USE THIS FEATURE.
 LTC      SPACE  4,10
**        LTC - LOG INFORMATION TO CONSOLE.
*
*         ENTRY  (*CELCW*) = MRB NUMBER TO BE LOGGED.
*                          = 77, IF MRT IS TO BE TRANSFERRED.
*
*                ON REENTRY:
*                (FNUM) = FILE NUMBER RETURNED BY CONSOLE ON *OPEN* CALL.
*                (FSIZ) = FILE SIZE RETURNED BY CONSOLE ON *OPEN* CALL.
*                (*CELCW*) = RESPONSE PENDING SET IF APPROPRIATE.
*                (*CELCW*) = PHASE:
*                            0 = OPEN CONSOLE FILE.
*                            1 = WRITE FIRST BLOCK TO CONSOLE FILE.
*                            2 = WRITE SECOND BLOCK TO CONSOLE FILE.
*                            3 = CLOSE CONSOLE FILE.
*                            4 = CLEAR LOGGING FLAG IN MRB AND CHECK FOR MORE.
*
*         EXIT   (*CELCW*) = 0, IF NO MORE LOGGING TO BE PERFORMED.
*                (*CELCW*) UPDATED, IF INTERMEDIATE PHASE.
*                (*CELCW*) = NEW MRB TO BE LOGGED, IF NECESSARY.
*
*         USES   T1, T2, T3.
*
*         CALLS  CCF, CRS, GLH, MMD, PFC, SCF, SMP, VCK, *PKT*.


          ROUTINE  LTC

          LDN    VER4        CHECK DFT VERSION
          RJM    VCK
          MJP    LTC7        IF BELOW DFT VERSION 4, IGNORE LOGGING
          LDN    0
          STM    RTP1        INITIALIZE SCRATCH
          LDML   CELCW       CHECK CONTROL WORD
          SHN    21-17
          PJP    LTC2        IF NO RESPONSE PENDING
          SHN    21-16-21+17
          PJN    LTC0        IF NOT TIMED OUT
          CALL   LPT         LOG PACKET TIMEOUT
          LDML   CELCW       GET MRB BEING PROCESSED
          LPN    77
          STD    T2
          LDM    LTCA+4      PREPARE FOR PHASE 4
          STD    T3
          LJM    0,T3        EXECUTE PHASE 4

 LTC0     RJM    CRS         CHECK RESPONSE STATUS
          ZJP    LTCX        IF NO RESPONSE PACKET AVAILABLE

*         RECEIVE RESPONSE PACKET.

          LDM    CELCW       CLEAR RESPONSE PENDING
          STM    CELCW
          LDN    0           CLEAR TIMER CONTROL WORD
          STM    PKTIM
          LDN    40          REQUEST = RECEIVE PACKET
          STM    CALB+0
          LDC    TOIP        BUFFER ADDRESS = *2AP* BUFFER (AT 2000)
          STML   CALB+2
          LDN    MX          GET CHANNEL 15 INTERLOCK
          RJM    SCF
          CALL   PFC         CALL *2AP*
          CCF    *,MX        RELEASE CHANNEL 15 INTERLOCK
          CALL   CER         CHECK FOR ERRORS
          LDM    CELCW       CHECK LOGGING PHASE
          SHN    -6
          NJN    LTC1        IF NOT FILE OPEN PHASE
          LDML   TOIP+1      SAVE FILE NUMBER RETURNED BY CONSOLE
          STML   FNUM
          LDML   TOIP+2      SAVE FILE SIZE RETURNED BY CONSOLE
          STML   FSIZ
 LTC1     LDC    100         ADVANCE TO NEXT PHASE
          RAM    CELCW
          LJM    LTCX        RETURN

*         PROCESS NEXT PHASE.

 LTC2     LDML   CELCW       UNPACK CONTROL WORD
          SHN    14
          STD    T1          (T1) = PHASE
          SHN    6
          LPN    77
          STD    T2          (T2) = MRB TO LOG
          LDD    T1          CHECK VALIDITY OF PHASE
          SBN    LTCAL
          PJP    LTC10       IF PHASE NOT DEFINED
          LDM    LTCA,T1     SET PHASE PROCESSOR
          STD    T3
          LJM    0,T3        EXECUTE PHASE

*         PHASE 0 - OPEN CONSOLE FILE.
*
*         WHEN LOGGING OF CORRECTED ERRORS IS SUPPORTED, CODE WILL BE REQUIRED
*         TO DETERMINE THE FILENAME BASED ON CORRECTED/UNCORRECTED STATUS.

 LTC3     LDN    PKFOF       FUNCTION = OPEN FILE
          STM    CALB+1
          LDN    1+1+2+12D   LENGTH = 16 (SOURCE ID, FUNCTION, MODE, NAME)
          STM    CALB+3
          LDN    PKOWR       MODE = WRITE
          STML   TOIPS0+1
          LDD    T2          DETERMINE CONSOLE FILENAME TO OPEN
          LMN    77
          NJN    LTC3.1      IF NOT MRT TRANSFER
          LDC    LTCD        CHANGE FILENAME TO *MRT.NVE*
          STM    LTCE
          AOM    L2AP        FORCE *2AP* (AND MRT-S) TO BE RELOADED
 LTC3.1   LDN    0           MOVE FILENAME TO PACKET BUFFER
          STD    T1
 LTC3.2   LDML   LTCB,T1     FILENAME = *DFT.UNC* (UNCORRECTED ERROR)
*         LDML   LTCC,T1     FILENAME = *DFT.COR* (CORRECTED ERROR - FUTURE)
*         LDML   LTCD,T1     FILENAME = *MRT.NVE* (MRT TRANSFER)
 LTCE     EQU    *-1         (ADDRESS OF FILENAME)
          STML   TOIPS0+2,T1
          AOD    T1
          LMN    12D/2
          NJN    LTC3.2      IF MORE TO BE MOVED
          LJM    LTC8        SEND PACKET

*         PHASE 1 - WRITE FIRST BLOCK OF DATA TO CONSOLE FILE.

 LTC4     LDN    PKFWT       FUNCTION = WRITE FILE
          STM    CALB+1
          LDML   FNUM        FILE NUMBER = (SAVED BY *OPEN* PHASE)
          STML   TOIPS0+1
          LDML   FSIZ        FILE SIZE = (SAVED BY *OPEN* PHASE)
          STML   TOIPS0+2
          LDD    T2          DETERMINE TYPE OF TRANSFER
          LMN    77
          NJN    LTC4.1      IF NOT MRT TRANSFER
          RJM    MMD         MOVE MRT DATA INTO PACKET BUFFER
          UJN    LTC4.2      CONTINUE

 LTC4.1   RJM    GLH         GENERATE LOGGING HEADER
          RJM    SMP         SET MRB PARAMETERS
          CRML   TOIPS0+3+10*4,T3  READ MRB INFORMATION INTO PACKET BUFFER
          LDN    10          INCLUDE HEADER LENGTH
          RAD    T3
 LTC4.2   LDD    T3          ADVANCE *FSIZ* FOR NEXT WRITE
          SHN    3
          STD    T3          SAVE DATA BYTE COUNT
          RAML   FSIZ
          LDD    T3          CALCULATE TOTAL PACKET LENGTH
          ADN    1+1+2+2     (SOURCE ID, FUNCTION, FNUM, FSIZ)
          STM    CALB+3
          LJM    LTC8        SEND PACKET

*         PHASE 2 - WRITE SECOND BLOCK OF DATA TO CONSOLE FILE.

 LTC5     LDN    PKFWT       FUNCTION = WRITE FILE
          STM    CALB+1
          LDML   FNUM        FILE NUMBER = (SAVED BY *OPEN* PHASE)
          STML   TOIPS0+1
          LDML   FSIZ        FILE SIZE = (*OPEN* SIZE + BLOCK ONE SIZE)
          STML   TOIPS0+2
          LDD    T2          DETERMINE TYPE OF TRANSFER
          LMN    77
          NJN    LTC5.1      IF NOT MRT TRANSFER
          RJM    MMD         MOVE MRT DATA INTO PACKET BUFFER
          UJN    LTC5.2      CONTINUE

 LTC5.1   RJM    SMP         SET MRB PARAMETERS
          CRML   TOIPS0+3,T3 READ MRB INFORMATION INTO PACKET BUFFER
 LTC5.2   LDD    T3          CALCULATE TOTAL PACKET LENGTH
          SHN    3
          ADN    1+1+2+2     (SOURCE ID, FUNCTION, FNUM, FSIZ)
          STM    CALB+3
          LJM    LTC8        SEND PACKET

*         PHASE 3 - CLOSE CONSOLE FILE.

 LTC6     LDN    PKFCF       FUNCTION = CLOSE FILE
          STM    CALB+1
          LDN    1+1+2       LENGTH = 4 (SOURCE ID, FUNCTION, FNUM)
          STM    CALB+3
          LDML   FNUM        FILE NUMBER = (SAVED BY *OPEN* PHASE)
          STML   TOIPS0+1
          UJN    LTC8        SEND PACKET

*         PHASE 4 - CLEAR LOGGING FLAG IN MRB AND EXIT.

 LTC7     LDN    0           CLEAR FILE NUMBER AND FILE SIZE
          STM    FNUM
          STM    FSIZ
          RJM    CCF         CLEAR CONSOLE LOGGING FLAG AND CHECK FOR MORE
          UJN    LTC9        RETURN

*         COMMON EXIT - SEND PACKET AND RETURN.

 LTC8     LDC    CELCW*0#400-TPKT*0#400+1*0#400+0*0#200+10000+PKRLE  SEND PACKET TO CONSOLE
          STML   RTP1
          CALL   PKT         PROCESS CONSOLE PACKETS VIA *2AP*
          LDC    0#8000      SET RESPONSE PENDING
          RAML   CELCW
 LTC9     LJM    LTCX        RETURN

*         DFT ANALYSIS - PACKET RESPONSE ERROR.
*         DFT FLAGS - LOGGING.

 LTC10    LDD    T2
          STM    LTCF+2      SAVE MRB BEING LOGGED
          LDD    T1
          STM    LTCF+3      SAVE OUT OF PHASE CONDITION
          LDN    BC
          RJM    CLR
          LDN    0
          STD    ET
          SETDAN (EPUN,DABP) BAD PHASE IN PACKET COMMUNICATION
          SETFLG (BC.FL)
          LRD    DP+1
          RJM    SPB         SET OS BOUNDS
          LDN    NRSP        NON REGISTER STATUS BUFFER
          RJM    IDA         INCREMENT DFT ADDRESS
          CRDL   W0
          LRD    W1
          LDDL   W0
          ADC    RR+NRSBL+1  BASE SIZE + HEADER WORD
          CWML   LTCF,ON     WRITE ERROR CODE TO SCRATCH SUPPORTIVE STATUS
          LDN    NRSBL
          STM    LLOG        LENGTH TO LOG
          LDC    DABP+TDFT
          STML   RTP1
          CALL   ERRH        LOG THE ERROR


 LTCA     BSS    0           PHASE PROCESSORS
          LOC    0
          CON    LTC3        PHASE 0 - OPEN CONSOLE FILE
          CON    LTC4        PHASE 1 - WRITE FIRST BLOCK TO CONSOLE FILE
          CON    LTC5        PHASE 2 - WRITE SECOND BLOCK TO CONSOLE FILE
          CON    LTC6        PHASE 3 - CLOSE CONSOLE FILE
          CON    LTC7        PHASE 4 - CLEAR LOGGING FLAG IN MRB

 LTCAL    BSS    0           MAXIMUM PHASE + 1
          LOC    *O

 LTCB     DATA   12HDFT.UNC       CONSOLE FILENAME (UNCORRECTED ERROR)
*LTCC     DATA   12HDFT.COR       CONSOLE FILENAME (CORRECTED ERROR - FUTURE)
 LTCD     DATA   12HMRT.NVE       CONSOLE FILENAME (MRT TRANSFER)
 LTCF     BSSZ   4
 CCF      SPACE  4,10
**        CCF - CLEAR CONSOLE LOGGING FLAG AND CHECK FOR MORE TO LOG.
*
*         ENTRY  (T2) = MRB NUMBER JUST SUCCESSFULLY LOGGED.
*                     = 77, IF MRT TRANSFER.
*
*         EXIT   CONSOLE LOGGING FLAG CLEARED FOR MRB JUST LOGGED.
*                (CELCW) = 0, IF NO MORE ERRORS TO LOG TO CONSOLE.
*                        = N, IF MRB(N) TO BE LOGGED TO CONSOLE.
*
*         USES   CM - CM+3, T2.
*
*         CALLS  IBW, SET.


 CCF      SUBR               ENTRY/EXIT
          LDD    T2          CHECK TRANSFER TYPE
          LMN    77
          NJN    CCF1        IF NOT MRT TRANSFER
*         LDN    0           CLEAR MRT UPDATED FLAG
          STM    MRTU
          UJN    CCF2        CONTINUE

*         CLEAR CONSOLE LOGGING FLAG FOR MRB JUST LOGGED.

 CCF1     LDN    CM          SET UP MASK FOR *RDCL* INSTRUCTION
          RJM    SET
          LMBC   (BC.CL)
          STDL   CM+BCFLG
          LDD    T2          CLEAR CONSOLE LOGGING FLAG IN BUFFER CONTROL WORD
          RJM    IBW
          RDCL   CM

*         SCAN BUFFER CONTROL WORDS FOR ANOTHER LOGGING CANDIDATE.
*         NOTE THAT SEQUENCE NUMBERS ARE NOT CHECKED.

 CCF2     LDN    VER5
          RJM    VCK         CHECK VERSION
          MJN    CCF2.5      IF VERSION 4
          LDN    1
          UJN    CCF2.6

 CCF2.5   LDN    3           START WITH FIRST GENERAL MRB
 CCF2.6   STD    T2
 CCF3     LDD    T2          READ BUFFER CONTROL WORD (T2)
          RJM    IBW
          CRDL   CM
          LDDL   CM+BCFLG    CHECK CONSOLE LOGGING FLAG
          LPBC   (BC.CL)
          NJN    CCF5        IF CONSOLE LOGGING FLAG SET
          AOD    T2          ADVANCE MRB INDEX
          LMM    NBUF
          NJN    CCF3        IF MORE MRB-S TO SCAN
*         LDN    0           SET NO MRB TO BE LOGGED
 CCF4     STM    CELCW       UPDATE CONSOLE LOGGING CONTROL WORD
          LJM    CCFX        RETURN

 CCF5     LDD    T2          SET THIS MRB TO BE LOGGED NEXT
          UJN    CCF4        UPDATE *CELCW* AND RETURN
 GLH      SPACE  4,10
**        GLH - GENERATE LOGGING HEADER.
*
*         ENTRY  (T2) = MRB NUMBER TO BE LOGGED.
*
*         EXIT   PACKET BUFFER CONTAINS THE FOLLOWING HEADER:
*
* HDR0    4/, 12/ DFTAC, 8/ DFTCV, 8/ DFTIFV, 16/ OFFSET TO MRS, 16/ DATA LENGTH
* HDR1    16/ RESERVED, 16/ SSDL, 32/ RESERVED
* HDR2    56/ DATE AND TIME, 8/ SEQ. NUMBER
* HDR3    32/ RESERVED, 32/ FAULT SYMPTOM CODE (CHARACTERS 1 - 4)
* HDR4    64/ FAULT SYMPTOM CODE (CHARACTERS 5 - 12)
* HDR5    64/ MAINFRAME ELEMENT STATUS
* HDR6    64/ MAINFRAME ELEMENT STATUS
* HDR7    64/ MAINFRAME ELEMENT STATUS
*
*         DFTAC = DFT ANALYSIS CODE.
*         DFTCV = DFT CODE VERSION.
*         DFTIFV = DFT INTERFACE VERSION.
*         SSDL = SUPPORTIVE STATUS DATA LENGTH.
*
*
*         USES   CM - CM+3, T3, T4, W0 - W0+3.
*
*         CALLS  IBW, IDA.


 GLH      SUBR               ENTRY/EXIT
          LDN    0           INITIALIZE HEADER WORDS TO ZERO
          STD    T3
 GLH1     LDN    0           CLEAR NEXT WORD OF HEADER
          STM    TOIPS0+3,T3
          AOD    T3
          LMN    10*4
          NJN    GLH1        IF MORE WORDS TO INITIALIZE

*         READ SUPPORTIVE STATUS BUFFER ENTRY (T2).

          LDN    SSBP        GET SUPPORTIVE STATUS BUFFER POINTER
          RJM    IDA
          CRDL   W0
          LRD    W0+1        READ SUPPORTIVE STATUS HEADER WORD
          LDD    W0
          ADC    RR
          CRDL   CM
          LDN    0           DETERMINE OFFSET TO DESIRED ENTRY = (T2) * SIZE
          STD    T4
          LDD    T2
          STD    T3
 GLH2     LDDL   CM+3        MULTIPLY (T2) * SIZE
          RADL   T4
          SOD    T3
          NJN    GLH2        IF MULTIPLICATION NOT COMPLETE
          AODL   W0          SKIP TABLE HEADER WORD
          ADDL   T4          OFFSET TO (T2) BUFFER ENTRY
          ADC    RR
          CRML   TOIPS0+3+1*4,CM+3
          LDD    T2          READ BUFFER CONTROL WORD (T2)
          RJM    IBW
          CRDL   CM

*         INITIALIZE HEADER WORD 0.

          LDD    CM+BCDA     SET DFT ANALYSIS CODE (WITHOUT PRIORITY)
          STM    TOIPS0+3+0*4+0
          LDC    CURNTV*0#100  SET DFT CODE VERSION
          ADM    VRSN        MERGE WITH DFT INTERFACE VERSION
          STML   TOIPS0+3+0*4+1
          LDN    10          STORE OFFSET TO REGISTER DATA (IN CM WORDS)
          STML   TOIPS0+3+0*4+2
          ADM    LBUF        SET LENGTH OF DATA INCLUDING HEADER SIZE
          STML   TOIPS0+3+0*4+3

*         COMPLETE INITIALIZATION OF HEADER WORD 1.

          LDN    0
          STM    TOIPS0+3+1*4+0
          STM    TOIPS0+3+1*4+2
          STM    TOIPS0+3+1*4+3

*         COMPLETE INITIALIZATION OF HEADER WORD 2.

          LDDL   CM+BCSEQ    EXTRACT SEQUENCE NUMBER
          SHN    -BC.SEQ
          STD    CM+BCSEQ
          LDML   TOIPS0+3+2*4+3  MERGE TIME AND SEQUENCE NUMBER
          LPC    0#FF00
          LMD    CM+BCSEQ
          STML   TOIPS0+3+2*4+3
          LJM    GLHX        RETURN
 MMD      SPACE  4,10
**        MMD - MOVE MRT DATA TO PACKET BUFFER.
*
*         ENTRY  (T1) = PHASE TO BE PROCESSED.
*
*         EXIT   (T3) = CM WORD COUNT.
*
*         USES   CM - CM+3, T2, T3.
*
*         NOTE   THIS CODE ASSUMES THAT MRT DATA TO BE MOVED IS 500 PP
*                WORDS (EQUIVALENT TO ONE SMALL SECTOR ON MAINFRAME DISK).


 MMD      SUBR               ENTRY/EXIT
          LDML   TOAPS0      SET OFFSET TO MRT DATA
          STDL   T2
          LDN    0
          STD    T3
          LDD    T1          CHECK PHASE
          LMN    1
          ZJN    MMD1        IF PHASE 1
          LDC    500/2       ADVANCE TRANSFER ADDRESS FOR PHASE 2 DATA
          RADL   T2
 MMD1     LDML   TOAPS0,T2   TRANSFER NEXT PP WORD
          STML   TOIPS0+3,T3
          AODL   T2
          AOD    T3
          LMC    500/2
          NJN    MMD1        IF MORE TO MOVE
          LDN    240/4       SET CM WORD COUNT EQUIVALENT
          STD    T3
          UJN    MMDX        RETURN
 SMP      SPACE  4,10
**        SMP - SET MRB PARAMETERS.
*
*         ENTRY  (T1) = PHASE TO BE PROCESSED.
*                (T2) = MRB TO BE PROCESSED.
*
*         EXIT   (A) = FWA OF MRB INFORMATION FOR THIS PHASE.
*                (T3) = CM WORD COUNT.
*
*         USES   CM - CM+3, T3, T4.
*
*         CALLS  IBW, IMB.


 SMP      SUBR               ENTRY/EXIT
          LDM    LBUF        SET MRB DATA SIZE
          STD    T4

*         THE FOLLOWING CODE ENSURES THAT AN ODD WORD COUNT IS HANDLED
*         WITHOUT LOSS OR DUPLICATION.  THE ODD WORD WILL BE WRITTEN IN
*         THE FIRST DATA BLOCK.

          LDD    T1          CHECK PHASE
          LPN    1           (A) = 1 IF PHASE 1, 0 IF PHASE 2
          ADD    T4          SET (POSSIBLY ROUNDED) TOTAL CM WORD COUNT
          SHN    -1
          STD    T3          (T3) = CM WORD COUNT FOR THIS PHASE

*         CALCULATE FWA OF MRB INFORMATION FOR THIS PHASE.

          LDD    T2          READ BUFFER CONTROL WORD (T2)
          RJM    IBW
          CRDL   CM
          LDD    T1          CHECK PHASE
          LMN    1
          ZJN    SMP1        IF PHASE 1, SET FOR READ OF FIRST HALF
          LDD    T4          SET OFFSET TO SECOND HALF
          SBD    T3
 SMP1     ADDL   CM+BCOFF    ADD OFFSET TO MRB INFORMATION
          RJM    IMB         CALCULATE CM ADDRESS
          UJN    SMPX        RETURN

*         END    CTP$DFT LOG PACKET TO CONSOLE
