;**************************************
;*         XBM01                      *
;*  INTERFACE BETWEEN HARDWARE AND IMP*
;* AND LOW LEVEL DUP11 HANDLER        *
;*  DATE:  23.FEB.80                  *
;**************************************
 
PS=177776; PROCESSOR STATUS WORD
 
IDLEST=-1; SUPERVISOR IDLE FLAG
 
INTVAL=40; DEDICATED LOCATION FOR INTERRUPT NUMBER
ALARMF=44; DITTO - FOR CLOCK
PSECT=46; DITTO - CURRENT PSECT
LASTPS = 54
INTINF=56
 
UPAR=177640
UPDR=177600
 
UPAR0=40; INDEC INTO PSECT
UPDR0=UPAR0+2; DITTO
UR0=14
UR4=UR0+10; ALL DITTO
UPC=UR0+14
UPS=UR0+16
USP=UR0+20
UTRP=UR0+22
 
 
.=0
0,0
ADDERR, 340
.+2,0
BPTINT,340
.+2,0; 20,22
.+2,0; 24,26; POWER
SVC,340; EMT HANDLER
.+2,0
.+2,0
.+2,0
.+2,0; 50,52
.+2,0; 54,56
 
.=40
INT6BA; FOR USE IN SBLD ONLY

.=60
KBINT,340,TTINT,340
.=70; PR AND PP INT
PRINT,340
LPINT,340

.=100
TIMINT,340
TIMINT,340; ALLOW FOR BOTH CLOCKS
 

.=120;   GRAPH PLOTTER INT
GPINT, 340

.=140;  DUMP ADDRESS
JMP DUMP

.=200; LP (REAL) INT
LPINT,340

.=220; DISC INT
DKINT, 340

.=224; TU16 INT
TU16IT,340
.=230; CR INT
CRINT,340

.=250; SEGMENTATION TRAP
SEGTRP, 340

.=270; BIG DISC INT
RP4INT, 340

.=300; PL11 #1 (TELETYPE), VEC=175610
KB2INT,340
TT2INT,340
;  PL11 #2 (TEXTTRONIC), VEC = 175620
KB3INT,340
TT3INT,340

;  NB:  THIS IS PART OF THE DUP CODE ***************
.=330
UBRIS, 340
UBTIS, 340
UBRIS, 340
UBTIS, 340
.=360
UBRIS, 340
UBTIS, 340
; ********* END

.=60100;    CODE TO TRAP TOP OF REAL STORE
CLR @#60110
RTI
;
.PAGE
.=1300; LEAVING ROOM FOR SUP STACK
RUN:
MOV PSECT, R3;  GET CURRENT PSECT
BEQ IDLE;   GO INTO IDLE LOOP
MOV R3, R0; PSECT POINTER TO R0
ADD #USP, R0; POINT R0 AT USER SP
CMP LASTPS,R3; SAME AS LAST TIME?
BEQ NOSER; YES, SO DONT RESTORE SEG REGS
MOV R3,LASTPS; MAKE IT TRUE NOW
MOV #UPAR,R1; POINT R1 AT USER SEG REGISTER PAR 0
MOV #UPDR,R2; R2 AT PDR 0
MOV #8.,R5; 8 REGISTERS
ADD #UPAR0,R3; POINT R3 AT REGS IN PSECT
LOOP: MOV (R3)+,(R1)+; SHIFT PAR(N)
MOV (R3),(R2)+; PDR(N)
ADD #10-2,R3; POINT AT NEXT BLOCK
077505;   SOB R5,LOOP; BRACH BACK TILL FINISHED
 
 MOV #030340,PS; SET PREVIOUS MODE=USER
MOV (R0),-(SP); PLANT ON STACK
.WORD 6606;  MTPI R6 - SET R16
NOSER: MOV -(R0), -(SP); PLANT PS ON STACK
MOV -(R0), -(SP); AND PC
MOV -(R0), R5
MOV -(R0),R4
MOV -(R0),R3
MOV -(R0), R2
MOV -(R0), R1
MOV -(R0),R0; RESTORE ALL HIS REGISTERS
.WORD  6;  RTT; AND EXIT TO HIM

IDLE:; IDLE LOOP
   CLR PS
WAIT
BR IDLE

 
DPTAB: DPR1TB;  NORMAL BRUN = 0
SAVER4: 0
SAVER5: 0;      MAIN SUPERVISOR PLANTS VALUES HERE

SVC:
JSR R5,SAVE; SAVE THE REGS
MOV UPC-UTRP(R4), R4; PUT HIS PC ON THE STACK
.WORD 6544; MFPI -(R4); GET THE WORD BEFORE THE PC (EMT CODE)
MOVB (SP)+,R1; GET THE CODE (BYTE) INTO R1
EXIT: MOV SAVER4, R4
MOV SAVER5, R5; AND RESTORE R5
EXIT2: RTS PC
 
SAVE:
MOV R4,-(SP)
MOV LASTPS,R4; PSECT ADDR
ADD #UR0,R4; POINT AT USER REGS
MOV R0,(R4)+
MOV R1,(R4)+
MOV R2,(R4)+
MOV R3,(R4)+
MOV (SP)+,(R4)+; R4
MOV (SP)+,(R4)+; R5
MOV (SP)+,(R4)+; PC
MOV (SP)+,(R4)+; PS
.WORD 6506; MFPI R6 - GET USER R6
MOV (SP)+,(R4)+; AND SAVE
MOV R5,PC; AND RETURN
 
INT:  TST PSECT;   IS THERE AN ACTIVE TASK?
     BNE NORMAL; YES, SO SAVE ITS REGISTERS
ADD #4, SP; DUMP PC&PS
MOV #-1,R1; SET INT CODE=-1
BR EXIT2; AND EXIT
 
NORMAL: JSR R5,SAVE; SAVE THE CONTEXT
MOV #-1,R1; SET SERVICE=INTERRUPT
BR EXIT; AND RETURN
 
; *********************************************************
; DEVICE INTERRUPTS
 
KBINT: MOV #-2,INTVAL
BR INT
 
TTINT: MOV #-1,INTVAL
BR INT
 
TIMINT:
CLR INTVAL; INT VALUE=0
BR INT
 
DKINT: MOV #-3, INTVAL
BR INT

SEGTRP: MOV #1, @#52
ERR2: BIT #030000,PS;  PREVIOUS = USER?
BNE ERR3; YES, SO LET THE ERROR THROUGH
HALT; NO, SO WERE IN SUPER STATE (KERNEL HAD IT)
ERR3: MOV #-4,INTVAL
BR INT

ADDERR: MOV #2, @#52
BR ERR2
TU16IT: MOV #-5, INTVAL
BR INT

INT2: BR INT;  IN CASE ITS NEEDED LATER
INT6BA:
; NB: ALL INTS BENEATH MAY BE OVERWRITTEN BY SBLD *************

TXINT: MOV #-6, INTVAL
BR INT

RXINT: MOV #-7, INTVAL
BR INT

RP4INT: MOV #-10, INTVAL
BR INT

LPINT: MOV #-11, INTVAL
BR INT
 
BPTINT: MOV #-12,INTVAL
MOV @SP, INTINF; PASS PC THROUGH
BR INT
KB2INT: MOV #-13,INTVAL
BR INT

TT2INT: MOV #-14, INTVAL
BR INT

KB3INT: MOV #-15, INTVAL
BR INT

TT3INT: MOV #-16, INTVAL
BR INT
MOV #-17, INTVAL
BR INT
CRINT: MOV #-20,INTVAL
BR INT
PRINT: MOV #-21,INTVAL
BR INT
GPINT:   MOV   #-22, INTVAL;      GRAPH PLOTTER
        BR   INT

DTINT:   MOV   #-23, INTVAL
        BR INT
X1INT:   MOV   #-24, INTVAL
        BR INT

X2INT:   MOV   #-25, INTVAL
        BR INT
MOV #-26,INTVAL
BR INT
MOV #-27,INTVAL
BR INT
MOV #-30,INTVAL
BR INT
MOV #-31,INTVAL
BR INT2
MOV #-32,INTVAL
BR INT2
MOV #-33,INTVAL
BR INT2
MOV #-34,INTVAL
BR INT2
MOV #-35,INTVAL
BR INT2
MOV #-36,INTVAL
BR INT2

DUMP: MOV #177412, R1;  DUMPER FOR AN RK05
MOV #14124, (R1); DISC ADDRESS
CLR -(R1); CORE ADDRESS=0
MOV #1000002, -(R1); WC = MAX
MOV #3, -(R1); WRITE+GO
DLOOP: TSTB (R1)
BPL DLOOP
MOV #3,(R1); WRITE+GO AGAIN
DLOOP2: TSTB (R1)
BPL DLOOP2
BIT #20000,@#777402
BNE DUMP; NO, SO GO AGAIN
MOV #7, @#777566; BELL ON TT
HALT

;  FILE 'DVRUB'
.PAGE
;********************* DUP11/XBM01 HANDLER **************************
; ELEMENT DVRUB IN NSILIB
;
;REG DEFS
         UBRCS=0
         UBRDB=2
         UBPSR=2
         UBTCS=4
         UBTDB=6
;
;BIT DEFS
         UBRSET=400                     ;RESET FLAGS IN TCS
         UBDSR=1000
         UBDTR=2
         UBRTS=4
         UBCTS=20000
         UBDCD=10000
         UBRXEN=20
         UBTXEN=20
         UBDLEN=40                      ;DATA LATE INT ENB IN UBTCS
         UBTSOM=400
         UBTEOM=1000
;
;USEFUL CHARS
         UBSYN=26
         UBSTX=2
         UBMARK=377
         COUNT=5000

      SOH = 1
      EOT = 4
      ENQ = 5
      ETX = 3
;
; BLOCK SPEC
        ;  PT = 0
        STATE =2
        S1 = 3
        MXLEN = 4
        P1 = 6
        MODE = 10
        SEG = 12
        COU= 14
        VEC  =  16

; USEFUL ADDRESSES
        INTENB = 100
        KPAR6 = 772354
        KPDR6 = 772314
        DPRNO = -31.;                ??????????????????
        DPTNO = DPRNO-1;  = -32.

; TABLES
DPR1TB: 0,0,0,0,0,0,0, 0
DPT1TB: 0,0,0,0,0,0,0, 0
OVERRN: 0
;
;** INIT SEQ. **
;
;UBINIT:  BIS   #UBRSET,UBTCS(R0)        ;RESET DVEICE
;         MOV   #UBPARM,UBPSR(R0)        ;SET OP. MODE
;;CONNECT TO MODEM
;         MOV   #COUNT,R1
;         MOV   #DSRM,R2
;         BIS   #UBDTR,(R0)              ;SET DTR
;UBIN01:  BIT   #UBDSR,(R0)              ;WAIT FOR MODEM
;         BNE   UBIN04
;         DEC   R1
;         BNE   UBIN01
;         JMP   RPERR
;UBIN04:  MOV   #COUNT,R1
;         MOV   #CTSM,R2
;;SET UP MODEM TX
;         BIS   #UBRTS,(R0)              ;SET RTS
;UBIN02:  BIT   #UBCTS,(R0)              ;WAIT FOR CTS
;         BNE   UBIN05
;         DEC   R1
;         BNE   UBIN02
;         JMP   RPERR
;UBIN05:  MOV   #COUNT,R1
;         MOV   #CARM,R2
;;SET UP MODEM RX
;UBIN03:  BIT   #UBDCD,(R0)              ;CARRIER?
;         BNE   UBIN06
;         DEC   R1
;         BNE   UBIN03
;         JMP   RPERR
;;ENABLE RX TO SYNC
;UBIN06:  BIS   #100+UBRXEN,(R0)         ;RX ENABLE + INTS
;;LEAVE THE TX IDLE
;         RTS   PC
;
;
;** RX START SEQ. **
;
;UBRSS:   BIC   #UBRXEN,(R1)             ;DISABLE & RE-ENABLE RX
;         BIS   #UBRXEN,(R1)
;         CLRB  STATE(R0)                ;RESET STATE
;         JMP   DSPNXT
;
;** RX INT SEQ. **
;
UBRIS:   
        MOV   R0, -(SP)
        MOV  R1, -(SP)
        MOV R2, -(SP)
        MOV #DPR1TB, R0
        MOV VEC(R0), R1;    GET INTERFACE ADDRESS
RXCOMM:
         MOV   UBRDB(R1),-(SP)          ;SAVE I/P CHAR
         BMI   UBRWRR                   ;ERROR
         BIC   #177400,(SP)
         MOVB  STATE(R0),R2             ;RWITCH ON STATE
         ASL   R2
         MOV   UBRWIT(R2),R2
         RTS   R2
UBRWIT:  .WORD UBRW00                   ;LOOKING FOR EOT (1) OR SOH(2)
         .WORD UBRW10                   ;    "    "  DATA(1) OR ENQ(0)
         .WORD UBRW20                   ;    "    "  DATA (2) OR STX(3)
         .WORD UBRW30                   ;    "    "  TEXT(3) OR ENQ(4)
         .WORD UBRW40                   ;    "    "  BCC (0)
;
;SYN SEEN
UBRW00: CMP #UBSYN, R2
      BEQ UBRWEX; YES, SO CARRY ON
TST (R0); IS THERE A BLOCK ENABLED?
BNE UBRW03; YES, SO CARRY ON
INC OVERRN; NO, SO COUNT OVERRUN ERROR
BR UBRW02; AND CLEAR DOWN
UBRW03:
      JSR PC,UBSTC; STORE THE CHAR
      CMP #SOH, R2
      BNE UBRW01; NO, TRY EOT
      INCB STATE(R0);                   YES, LOOK FOR CAD & STX
      CLR P1(R0)
      BR UBRWXX;                        STATE -> 2
UBRW01: CMP #EOT, R2
      BEQ UBRWXX;                       EOT, SO GO TO STATE = 1
 DEC (R0); REMOVE THE WRONG CHAR AGAIN
UBRW02:  CLRB  STATE(R0)                ;ELSE IDLE AGAIN
        BIC  #UBRXEN,(R1)
        BIS #UBRXEN,(R1)
        BR UBRWEX
;
; LOOKING FOR DATA AFTER EOT
UBRW10:  JSR PC,UBSTC;                  STORE CHAR
      CMP #ENQ, R2;                     ; IS IT ENQ?
      BNE UBRWEX;                       NO, CARRY ON
      BR UBRWOK;                        GOT IT ALL, REPLY TO HIGHER

;LOOKING FOR CAD-CAD-STX
UBRW20: JSR PC,UBSTC;                   STORE IT
      JSR PC,UBCRC
      CMP #UBSTX, R2;                   ACTUAL START OF TEXT?
      BNE UBRWEX;                       NO, CARRY ON
      BR UBRWXX;                        YES, GO TO NEXT STATE

;STX SEEN, DATA THEN ENQ
UBRW30:   CMP R2,#UBSYN;                  IGNORE SYNS IN DATA
      BEQ UBRWEX                        ; YES, SO JUST IGNORE
        JSR PC, UBSTC;                  STORE DATA&ETX
      JSR PC,UBCRC
      CMP #ETX, R2;                     EN DOFTEXT
      BEQ UBRWXX;                       END OF SEQUENCE
      BR UBRWEX;                        CARRY ON IN DATA

;NOW CHECK BCC
UBRW40: MOV R2, -(SP);                  STORE IT AWAY
      MOV P1(R0), R2;                   GET 'OUR' BCC
      BIC #177600, R2          ; ONLY BOTTOM 6 BITS OF BCC
      BISB PARTAB(R2), R2;               ADD CORRECT PARITY
      CMP R2, (SP)+;                    AND CHECK WITH RECD BCC
      BEQ UBRWOK;                       OK, SO REPLY
      MOV #-3, MODE(R0);                 CKSM ERROR
      BR UBRW61
;
UBRWOK:         CLR   MODE(R0)                    ;FLAG TRANSFER OK
UBRW61:  MOV   (R1),P1(R0)              ;SAVE DEVICE STATUS
         CLR SEG(R0);  CLEAR OUT ADDRESS
         CLRB  STATE(R0)                ;RESET STATE
        BIC #UBRXEN!100,(R1)
       BIS #UBRXEN,(R1)
         MOV #DPRNO, INTVAL
DOINT:   MOV  (SP)+, R2
        MOV (SP)+, R1
        MOV (SP)+, R0
         JMP  INT;      CALCULATE BYTE COUNT?
;
;RWITCH EXIT
UBRWXX:  INCB  STATE(R0)                ;NEXT STATE
UBRWEX:  JMP   DSPNXT
;
;ERROR EXIT
UBRWRR:  TST   (SP)+                    ;ENTRY WITH CHAR ON STACK
         TST   (R0)               ;MAY BE ON FRAME START (WAS BUFPTR(R0))
         BEQ   UBRWEX                   ;SO IGNORE IT
  MOV   #177777,MODE(R0)                 ;SET ERROR FLAG
         BR    UBRW61                   ;AND EXIT
;
UBSTC:   
         MOV SEG(R0), KPAR6;           SET UP KERNEL SEG 6
         MOV #77406, KPDR6;            ?????????????????????
      BIC #177600, R2                   ; CLEAR PARITY BIT
         MOVB R2, @0(R0);               PLANT CHAR
         INC (R0);     BUMP POINTER
      DEC MXLEN(R0)                     ; CHECK OVERALL LENGTH
      BNE UBSTC1                        ; ITS OK
      MOV #-1,MODE(R0)                  ; OVERRUN, ERROR = -1
      TST (SP)+            ; DUMP RA
      BR UBRW61                         ; SIGNAL UP A LEVEL
UBSTC1:         RTS   PC
;
;
;
;
;** TX START SEQ. **
;
         UBSYNS=5                       ;NUMBER OF LEADING SYNS
         UBPADS=10                      ;NUMBER OF LEADING PADS
;
;UBTSS:   MOVB  #1,STATE(R0)             ;EXPECT INT
;         BIS   #UBTXEN+INTENB,UBTCS(R1)
;         MOV   #UBMARK+UBTSOM,R2
;         MOV   #UBPADS-1,P1(R0)         ;PAD COUNTER
;         JMP   UBTWEX
;
;** TX INT. SEQ. **
;
; DATA LATE IGNORED AS PROTOCOL WILL RECOVER.
;
UBTIS:   
         MOV  R0, -(SP)
         MOV  R1, -(SP)
         MOV R2, -(SP)
       MOV #DPT1TB, R0
TXCOMM:
        MOV   VEC(R0), R1;         GET VECTOR ADDRESS
         MOVB  STATE(R0),R2
         ASL   R2
         JMP   @UBTSW(R2)
UBTSW:   .WORD DSPNXT                   ;UNWANTED INT
         .WORD UBTWX0                   ;START OF FRAME PADS
         .WORD UBTW00                   ;START OF FRAME SYNS
      .WORD UBTW30                      ; 1ST CHAR, SOH(5) OR (4)
      .WORD UBTW40                      ; 2ND CHAR OF ACK (0)
      .WORD UBTW50                      ; TAD (6)
      .WORD UBTW60                      ; STX(7)
      .WORD UBTW70                      ; TEXT (8)
      .WORD UBTW80                      ; ETX (NOT IN TEXT) (9)
      .WORD UBTW90                      ; BCC (A)
      .WORD UBTWA0                      ; TO IDLE STATE
      .WORD UBTWB0                       ; LOOP BACK TESTING STATE
;
;LEADING MARK
UBTWX0:  MOV   #UBMARK+UBTSOM,R2
         DEC   P1(R0)
         BNE   UBTWEX                   ;STAY WITH PADS
         MOV   #UBSYNS,P1(R0)           ;ON TO SYNS
         BR    UBTWXX
;
;LEADING SYNS
UBTW00:  MOV   #UBSYN+UBTSOM,R2
         DEC   P1(R0)
         BEQ   UBTWXX                   ;GO TO SEND DLE
         BR    UBTWEX
; 1ST CHAR
UBTW30: JSR PC,LDC                      ; GET IT FROM BUFFER
      CMP R2,#SOH                       ; TEXT RESPONSE?
 BEQ UBTW31; YES, SO -> 5
 CMP R2, #EOT  ; LOOP BACK TEST?
      BNE UBTWXX                        ; NO, SO STATE->4
 MOV #11.,STATE(R0); LOOP BACK TEST STATE
 BR UBTWEX

UBTW31:      MOVB #5,STATE(R0)                 ; YES, SO STATE ->5
      BR UBTWEX

;2ND CHAR OF SIMPLE ACK
UBTW40: JSR PC, LDC                     ; GET FROM BUFFER
UBTW41:      MOVB #10.,STATE(R0)               ; GO TO IDLE
      BR UBTWEX                         ; AND SEND IT (NO BCC)

; TAD
UBTW50: JSR PC,LDC                      ; GET IT
      JSR PC,UBCRC
      BR UBTWXX                         ; SEND IT (NO BCC YET)

; STX
UBTW60: JSR PC,LDC                      ; GET STX FROM BUFFER
      JSR PC, UBCRC
      BR UBTWXX                         ; SEND IT (NO BCC YET)

; TEXT
UBTW70: JSR PC,LDC                      ; GET CHAR
      BGT UBTW71  ; NOT END OF BLOCK
      INCB STATE(R0)                  ; END OF BLOCK, SO SEND BCC
UBTW71:      JSR PC,UBCRC                      ; ADD CHAR TO BCC
      BR UBTWEX                         ; AND GET NEXT

; SEND BCC
UBTW80: MOV #ETX+200, R2                    ; SEND ETX - NOT IN TEXT
      JSR PC,UBCRC
      BR UBTWXX

UBTW90: MOVB P1(R0), R2                 ; GET BCC
      BIC #177600, R2        ; ENSURE PARITY IS CLEAR
      BISB PARTAB(R2), R2               ; ADD PARITY
      BR UBTWXX                         ; GO TO 'GO TO IDLE'


;TO IDLE
UBTWA0:  MOV   (R1),P1(R0)              ;SAVE STATUS
         MOV   #UBTEOM,UBTDB(R1)        ;SET EOM AND CLEAR SOM
         BIC   #UBTXEN+INTENB,UBTCS(R1)
         CLRB  STATE(R0)
         CLR   MODE(R0)                    ;FLAG NO ERRORS
        MOV   #DPTNO, INTVAL
        JMP DOINT

; LOOP BACK TEST STATE, PROCESS CHARS UNTIL END
UBTWB0: JSR PC,LDC ; GET CHAR
 BEQ UBTW41 ; END , SO GO TO STATE 10
 BR UBTWEX ; OTHERWISE JUST CONTINUE

;NEXT STATE EXIT
UBTWXX:  INCB  STATE(R0)
UBTWEX:  MOV   R2,UBTDB(R1)
         BR   DSPNXT

;   LOAD CHAR ROUTINE
LDC:       MOV SEG(R0), KPAR6
           MOV #77406, KPDR6;           FULL SEG FOR NOW
           MOV (R0), R2;              GET CHAR AND BUMP POINTER
           MOVB (R2), R2
         BIC #177600,R2               ; ENSURE TOP BYTE AND PAR BIT CLEAR
         BISB PARTAB(R2), R2            ; ADD PARITY TO CHAR
           INC (R0); BUMP POINTERT
           DEC COU(R0);           SENDS '=' ON EXIT WHEN FINISHED
           RTS  PC;                   LAST CHAR??
;
;
;** CRC ROUTINE **
;
UBCRC:
         .WORD 074260, 6          ;XOR R2,P1(R0)
         RTS PC
;   COMMON RETURN SEQUENCE

DSPNXT:
      MOV   (SP)+, R2
      MOV  (SP)+, R1
      MOV (SP)+, R0
      .WORD 6;  RTT - RETURN TO LAST ACTIVITY

PARTAB:
.BYTE 200,  0,  0,200,  0,200,200,  0
.BYTE   0,200,200,  0,200,  0,  0,200
.BYTE   0,200,200,  0,200,  0,  0,200
.BYTE 200,  0,  0,200,  0,200,200,  0
.BYTE   0,200,200,  0,200,  0,  0,200
.BYTE 200,  0,  0,200,  0,200,200,  0
.BYTE 200,  0,  0,200,  0,200,200,  0
.BYTE   0,200,200,  0,200,  0,  0,200
.BYTE   0,200,200,  0,200,  0,  0,200
.BYTE 200,  0,  0,200,  0,200,200,  0
.BYTE 200,  0,  0,200,  0,200,200,  0
.BYTE   0,200,200,  0,200,  0,  0,200
.BYTE 200,  0,  0,200,  0,200,200,  0
.BYTE   0,200,200,  0,200,  0,  0,200
.BYTE   0,200,200,  0,200,  0,  0,200
.BYTE 200,  0,  0,200,  0,200,200,  0


;
;     ERROR REPORTING TO TTY
;
;RPERR:   MOVB  (R2)+,R1                 ;GET CHARACTER
;         BNE   RPERR1
;         HALT                           ;END OF MESSAGE
;         JMP   START                    ;RESTART
;RPERR1:  TSTB 177564                   ;TTY READY
;         BEQ   RPERR1
;         MOVB  R1,177566                ;PRINT CHAR
;         BR    RPERR
;;
;DSRM: .ASCII   /MODEM: DSR NOT UP/
;      .BYTE 15,12,0
;      .EVEN
;CTSM: .ASCII   /MODEM: CTS NOT UP/
;      .BYTE 15,12,0
;      .EVEN
;CARM: .ASCII/MODEM: CARRIER NOT UP/
;      .BYTE 15,12,0
;      .EVEN
    .END