;**************************************
;*         SYS_DXXXXX                 *
;*  INTERFACE BETWEEN HARDWARE AND IMP*
;*  DATE:  06.MAR.82                  *
;**************************************
;
; * PREP OPTIONS
; R - RK05 DUMPER
; F - FILESTORE SYSTEM
; N - NODES - EXTENDED INTERRUPTS
; X - RX02 DUMPER
; B - BISYNCH PSEUDO DMA
; H - DUP11 HDLC PSEUDO DMA
; V - LSI HDLC PSEUDO DMA (NB:DPV11 HARDWARE)
;
; NOTE: In order to assemble, the CLEAN option in prep MUST be used
;
#IF N
; FOR SUP40 AND BEYOND - 100 INTERRUPTS - AND EXPANDED DUMP
; AUTOMATIC POWER UP ADDED
#FI
 
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
PXPT=56; POINTS TO RECORD P2 & PXP IN KERNAL
 
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
ADDERR, 340;     SUPPOSE IT OUGHT TO BE DIFFERENT !!!!!!
BPTINT,340
.+2,0; 20,22
PWERUP, 340;  POWER UP CODE
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

.=160; RL01 INTERRUPT
DKINT, 340

.=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

.=260; SI DISC INTERRUPT
DKINT, 340
DKINT, 340;   264 = FLOPPY DISC INTERRUPT

.=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

#IF B
.=340
UBRIS, 340
UBTIS, 340;   NB: THESE SHOULD NOW BE SET IN THE CONFIG FILE, NOT HERE!
.=360
UBRIS, 340
UBTIS, 340
#FI

.=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

 
#IF N
DPTAB: 0;  NORMAL BRUN = 0
#FI
#IF (B!H!V)
DPTAB: DPR1TB
#FI
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, IE USER TASK ERROR
JMP DUMP; NO, SO WERE IN SUPER STATE (KERNAL ERROR) - SO DUMP IT
ERR3: MOV #-4,INTVAL
BR INT

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

SPEC:
   MOV PSECT,R0
   MOV 2(R0),-(SP); PICKUP TASK ID
   MOV PXPT,R0;  GET POINTER TO RECORD P2 IN KERNAL
   MOV (SP)+,6(R0); SAVE TASK ID IN P_C
   MOV 2(SP),4(R0); SAVE TH EPC IN P_B
   MOV (SP)+, R0; RESTORE R0
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 R0,-(SP); SAVE R0 FOR TEMP USE
BR SPEC
.WORD 240; PADDING, SO SAME LENGTH
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 INT2
MOV #-27,INTVAL
BR INT2
MOV #-30,INTVAL
BR INT2
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
INTX:BR INT2
#IF (B!H!V)
JMP UBRIS; -31. - SPECIALLY LINKED TO SYNCHRONOUS LINE HANDLER
.WORD 0,0; PADDING
JMP UBTIS; -32. - DITTO
#FI
#IF (H!V)
JMP UBR2IS; -33 - DUP #2 INPUT HANDLER
.WORD 0,0
JMP UBT2IS; -34 -        OUTPUT
.WORD 0,0
JMP UBR3IS; -35. - DUP #3 INPUT HANDLER
.WORD 0,0
JMP UBT3IS; -36. -        OUTPUT
.WORD 0,0
#FI
#IF N
MOV #-37,INTVAL
BR INT2
MOV #-40,INTVAL
BR INT2
MOV #-41,INTVAL
BR INT2
MOV #-42,INTVAL
BR INT2
MOV #-43,INTVAL
BR INT2
MOV #-44,INTVAL
BR INT2
MOV #-45,INTVAL
BR INTX
MOV #-46,INTVAL
BR INTX
MOV #-47,INTVAL
BR INTX
MOV #-50,INTVAL
BR INTX
MOV #-51,INTVAL
BR INTX
MOV #-52,INTVAL
BR INTX
MOV #-53,INTVAL
BR INTX
MOV #-54,INTVAL
BR INTX
MOV #-55,INTVAL
BR INTX
MOV #-56,INTVAL
BR INTX
MOV #-57,INTVAL
BR INTX
MOV #-60,INTVAL
BR INTX
MOV #-49.,INTVAL
BR INTX
MOV #-50.,INTVAL
BR INTX
MOV #-51.,INTVAL
BR INTX
MOV #-52.,INTVAL
BR INTX
MOV #-53.,INTVAL
BR INTX
MOV #-54.,INTVAL
BR INTX
MOV #-55.,INTVAL
BR INTX
MOV #-56.,INTVAL
BR INTX
MOV #-57.,INTVAL
BR INTX
MOV #-58.,INTVAL
BR INTX
MOV #-59.,INTVAL
BR INTX
MOV #-60.,INTVAL
BR INTX
MOV #-61.,INTVAL
INTY:BR INTX
MOV #-62.,INTVAL
BR INTY
MOV #-63.,INTVAL
BR INTY
MOV #-64.,INTVAL
BR INTY
MOV #-65.,INTVAL
BR INTY
MOV #-66.,INTVAL
BR INTY
MOV #-67.,INTVAL
BR INTY
MOV #-68.,INTVAL
BR INTY
MOV #-69.,INTVAL
BR INTY
MOV #-70.,INTVAL
BR INTY
MOV #-71.,INTVAL
BR INTY
MOV #-72.,INTVAL
BR INTY
MOV #-73.,INTVAL
BR INTY
MOV #-74.,INTVAL
BR INTY
MOV #-75.,INTVAL
BR INTY
MOV #-76.,INTVAL
BR INTY
MOV #-77.,INTVAL
BR INTY
MOV #-78.,INTVAL
BR INTY
MOV #-79.,INTVAL
BR INTY
MOV #-80.,INTVAL
BR INTY
MOV #-81.,INTVAL
BR INTY
MOV #-82.,INTVAL
BR INTY
MOV #-83.,INTVAL
BR INTY
MOV #-84.,INTVAL
BR INTY
MOV #-85.,INTVAL
BR INTY
#FI

#IF R
SWR = 777570
PSTR: MOVB (R1)+, R0; GET NEXT SYMBOL FROM STRING
PSYM: TSTB @#777564; TT OUT READY?
BPL PSYM; NO, SO LOOP
MOV R0,@#777566; OUTPUT CHAR
BNE PSTR; R0 IS NON-ZERO, SO MORE TOGO
RTS PC


DUMPD: .ASCII /*** DUMP TAKEN ***/
.BYTE 0
.EVEN

DUMP: MOV R5,@#34
MOV SP,@#36
      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 #DUMPD,R1
JSR PC,PSTR

TST SWR;   RELOAD IF ADDRESS LOOKS OK
BLT PWERUP
HALT;   HALT IF DUMP ADDFRESS SET

; END OF DUMPER - INTO AUTO RELOAD
PWERUP:  MOV SWR,PC; GET ADDRESS IN SWITCHES - AND GO TO IT
#FI
;
#IF X
.PAGE
;
;   RXO2 DEIMOS SYSTEM DUMPER
;
;   DUMPS ALL OF STORE (64K WORDS) TO UNIT 1
;   STARTING AT SECTOR 1 OF TRACK 0. SECTORS INTERLEAVED.
;
SECMAP:   .BYTE 1,3,5,7,9.,11.,13.,15.,17.,19.,21.,23.,25.
         .BYTE   2,4,6,8.,10.,12.,14.,16.,18.,20.,22.,24.,26.
CONTW:   .WORD   421
;
;   R0   POINTS AT DEVICE
;   R1   TRACK
;   R2   SECTOR
;   R3   STORE ADDR
;   R4   ALSO USED.
;
DUMP:   MOV   #177170,R0   ;DEV ADDR
         MOV #20.,R1;     1ST BLOCK = 260 (DEC)
         CLR   R2
         CLR   R3            ;TRACK,SECTOR+STORE
;
;   LOOP STARTS HERE
;
LOOP1:   BIT   #40,(R0)   ;READY?
         BEQ   LOOP1
      MOV   CONTW,R4
         MOV   R4,(R0)   ;UNIT+ADDR EXT+FILL BUFFER
L1:   TSTB   (R0)   ;WAIT FOR TRDONE
      BPL   L1
      MOV   #128.,2(R0)   ;WORD COUNT
L2:   TSTB   (R0)   ;WAIT FOR TRDONE
      BPL   L2
      MOV   R3,2(R0)   ;STORE ADDRESS
L3:   BIT   #40,(R0)   ;WAIT FOR DONE
      BEQ   L3
;
;   NOW DO WRITE
;
      MOV   CONTW,R4
      BIS   #4,R4   ;WRITE COMMAND
      MOV   R4,(R0)
L4:   TSTB   (R0)
      BPL   L4
      MOVB   SECMAP(R2),2(R0)   ;SECTOR
L5:   TSTB   (R0)
      BPL   L5
      MOV   R1,2(R0)   ;TRACK
L6:   BIT   #40,(R0)   ;WAIT FOR DONE
      BEQ   L6
;
;   UPDATE SECTOR,TRACK AND ADDRESS
;
      INC   R2   ;SECTOR
      CMP   R2,#26.   ;END OF TRACK?
      BNE   L7
      CLR   R2   ;YES
      INC   R1
L7:   ADD   #256.,R3
      BCS   L8   ;END OF 32K
      JMP   LOOP1
L8:   BIT   #10000,CONTW   ;FINISHED?
      BEQ   L9
      HALT
L9:   CLR   R3
      BIS   #10000,CONTW
      JMP   LOOP1
.PAGE
#FI
;
#IF F
;
;PROGRAM TO DUMP ENTIRE STORE
;TO DISC CYLINDER 106..
; SET SWITCH REGISTER TO CONTAIN
;    CONTROLLER*4 + PORT
;  S.HAYES    JUNE 1981
;
;
SWR=177570
;
DUMP:MOV #TBL,R2
DGO2:MOV @#SWR,R4
 MOV R4,R1
 ASH R4,#3
 BIC #177637,R4
 ADD #176640,R4 ;CONTROLLER ADDRESS
 MOV #1,24(R4) ;REQUEST GRANT
LP1:TSTB 24(R4)
 BPL LP1 ;WAIT FOR GRANT
 BIC #177774,R1
 ASH R1,#10. ;PORT<<10
 ADD #106.,R1 ;BASE CYL
 MOV R1,4(R4) ;PORT<<10+CYL
 MOV (R2)+,6(R4) ;HEADSECT
 MOV #0,10(R4) ;BA
 MOV #100000,2(R4) ;+VE WORD COUNT..64 KBYTES
 MOV (R2)+,(R4) ;GO..READ+EM
LP3:TSTB (R4)
 BPL LP3
 TST (R2)
 BPL DGO2
 HALT ;DONE
TBL:.WORD 0,3
 .WORD 200,23
 .WORD 400,43
 .WORD 600,63
 .WORD -1
#FI
#IF ~r
PWERUP: 0
#FI
#IF B
.PAGE
;********************* DUP11/BISYNC 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
         UBPARM=101062                  ;MODE:BYTE MODE, NO CRC
         UBTSOM=400
         UBTEOM=1000
;
;USEFUL CHARS
         UBSYN=62
         UBDLE=20
         UBSTX=2
         UBETB=46
         UBMARK=377
         COUNT=5000
;
; BLOCK SPEC
        ;  PT = 0
        STATE =2
        S1 = 3
        MAXLN = 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
;
;** 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 UBRW10                   ;LOOKING FOR DLE
         .WORD UBRW20                   ;    "    "  STX
         .WORD UBRW30                   ;    "    "  DATA
         .WORD UBRW40                   ;    "    "  DLE OR ETB
         .WORD UBRW50                   ;    "    "  1ST CRC BYTE
         .WORD UBRW60                   ;    "    "  2ND  "    "
;
;SYN SEEN
UBRW10:  CMP   #UBDLE,R2                ;DLE?
         BEQ   UBRWXX                   ;YES, EXPECT STX
         CMP   #UBSYN,R2                ;ANOTHER SYN?
         BEQ   UBRWEX                   ;WAIT FOR DLE
UBRW12:  CLRB  STATE(R0)                ;ELSE IDLE AGAIN
        BIC  #UBRXEN,(R1)
        BIS #UBRXEN,(R1)
        BR UBRWEX
;
;SYN-DLE SEEN
UBRW20:  CMP   #UBSTX,R2                ;STX
         BNE   UBRW12                   ;NO, ERROR
        TST SEG(R0);  BUFFER PRESENT?
         BEQ   UBRW12                   ;NO BUFFER, IGNORE FRAME
         CLR   P1(R0)                   ;CLEAR CRC ACC
         CLR   MODE(R0)                 ;CLEAR COUNTER FOR UBSTC
         BR    UBRWXX                   ;EXPECT DATA
;
;SYN-DLE-STX SEEN
UBRW30:  CMP   #UBDLE,R2                ;STUFFED DLE?
         BEQ   UBRWXX                   ;YES, EXPECT DLE OR ETB
UBRW32:  JSR   PC,UBSTC                 ;SAVE THE CHAR
         JSR   PC,UBCRC                   ;ACCUMULATE CRC
         BR    UBRWEX                   ;EXPECT MORE DATA
;
;DLE SEEN IN DATA
UBRW40:  CMP   #UBDLE,R2                ;STUFFED DLE?
         BNE   UBRW41                   ;NO
         DECB  STATE(R0)                ;BACK TO NORMAL DATA MODE
         BR    UBRW32                   ;PUT IN BUFFER
UBRW41:  CMP   #UBETB,R2                ;ETB?
         BNE   UBRW12                   ;NO, ERROR
         JSR   PC,UBCRC
         BR    UBRWXX                   ;EXPECT CRC
;
;DLE-ETB SEEN
UBRW50:  CMPB  R2,P1(R0)                ;LSB CRC OK?
         BNE   UBRWER                   ;NO, ERROR
         BR    UBRWXX                   ;EXPECT 2ND BYTE
;
;1ST CRC BYTE SEEN
UBRW60:  CMPB  R2,P1+1(R0)              ;2ND CRC BYTE OK?
         BNE   UBRWER                   ;NO, ERROR
         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
         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
UBRWER:  MOV   #177777,MODE(R0)                 ;SET ERROR FLAG
         BR    UBRW61                   ;AND EXIT
;
UBSTC:   
         MOV SEG(R0), KPAR6;           SET UP KERNEL SEG 6
         MOV #77406, KPDR6;            ?????????????????????
         MOVB R2, @0(R0);               PLANT CHAR
         INC (R0);     BUMP POINTER
        DEC MAXLN(R0);   OVER LENGTH?
        BNE UBSTC1;    NO, SO OK
        TST (SP)+;    YES, SO ERROR
        MOV #-2,MODE(R0)
        BR UBRW61

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 UBTW10                   ;LEADING DLE
         .WORD UBTW20                   ;STX
         .WORD UBTW30                   ;DATA
         .WORD UBTW40                   ;STUFF DLE
         .WORD UBTW50                   ;ETB
         .WORD UBTW60                   ;CRC1
         .WORD UBTW70                   ;CRC2
         .WORD UBTW90                   ;TO IDLE 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
;LEADING DLE
UBTW10:  MOV   #UBDLE,R2
         CLR   P1(R0)                   ;CLEAR CRC ACC
         BR    UBTWXX
;STX
UBTW20:  MOV   #UBSTX,R2
         BR    UBTWXX
;DATA
UBTW30:  JSR   PC,LDC
         BLT   UBTW31; NB: NOT SAME AS SCOTT
         JSR   PC,UBCRC
         CMP   #UBDLE,R2                ;IF DLE STUFF ANOTHER
         BNE   UBTWEX
         BR    UBTWXX
UBTW31:  MOV   #UBDLE,R2                ;TRAILING DLE
         INCB  STATE(R0)
         BR    UBTWXX
;STUFF DLE
UBTW40:  MOV   #UBDLE,R2
         DECB  STATE(R0)
         BR    UBTWEX
;ETB
UBTW50:  MOV   #UBETB,R2
         JSR   PC,UBCRC
         BR UBTWXX
;CRC1
UBTW60:  MOVB  P1(R0),R2
         BIC   #177400,R2
         BR    UBTWXX
;CRC2
UBTW70:  MOVB  P1+1(R0),R2
         BIC   #177400,R2
         BR    UBTWXX
;TO IDLE
UBTW90:  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
;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 #177400, R2
           INC (R0); BUMP POINTERT
           DEC COU(R0);           SENDS '=' ON EXIT WHEN FINISHED
           RTS  PC;                   LAST CHAR??
;
;
;** CRC ROUTINE **
;
UBCRC:   MOV   R1,-(SP)
         MOV   R2,-(SP)
         MOV   P1(R0),R1                ;GET CRC
         BIC   R1,R2
         BICB  (SP),R1
         BISB  R2,R1
         MOV   #120001,R2
         MOV   #10,-(SP)
UBCRC1:  DEC   (SP)
         BLT   UBCRC2
         CLC
         ROR   R1
         BCC   UBCRC1
         MOV   R2,-(SP)
         BIC   R1,(SP)
         BIC   R2,R1
         BIS   (SP)+,R1
         BR    UBCRC1
UBCRC2:  MOV   R1,P1(R0)
         TST   (SP)+
         MOV   (SP)+,R2
         MOV   (SP)+,R1
         RTS   PC
;   COMMON RETURN SEQUENCE

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

;
;     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
#FI
#IF (H!V)
.PAGE
;
; BLOCK SPEC
        ;  PT = 0
        STATE =2
        S1 = 3
        MAXLN = 4
        P1 = 6
        MODE = 10
        SEG = 12
        COU= 14
        VEC  =  16
      INTNO = 20

; USEFUL ADDRESSES
        INTENB = 100
        KPAR6 = 772354
        KPDR6 = 772314

;****************** DUP 11 HANDLER *********************
;  ELEMENT DVRUP IN NSILIB (WAS DUP113)
;
; THIS VERSION PUTS THE FIRST 2 BYTES OF THE FRAME IN THE BUFFER'S
;PARAMETER BLOCK.  THESE ARE NOT INCLUDED IN THE MESSAGE LENGTH.
;THE LENGTH COUNT MAY BE ZERO IF EITHER THE LENGTH REALY IS ZERO OR
;IF IT IS 256 BYTES.  IN THE LATTER CASE THE POINTERS WILL BE NON-ZERO.
;
;** REGISTER DEFINITIONS **
      DUPRCS=0
      DUPRDB=2
      DUPPSR=2
      DUPTCS=4
      DUPTDB=6
;** BIT DEFINITIONS **
         TSOM=400
         TEOM=1000
         RSOM=400
         REOM=1000
         TXDONE=200
         RXDONE=200
         DUPSND=20
         RCVEN=20
         DUPDSR=1000
         DUPDTR=2
         DUPDRS=400
         DUPRTS=4
         DUPCTS=20000
         DUPDCD=10000
         COUNT=5000
;
;** INTERFRAME FLAG COUNT **
      IFLAGS=0                          ;OK WITH DQS11E'S SILO
;

; TABLES
DPR1TB: 0,0,0,0,0,0,0, 0,-31.
DPT1TB: 0,0,0,0,0,0,0, 0,-32.
DPR2TB: 0, 0, 0, 0, 0, 0, 0, 0, -33.
DPT2TB: 0, 0, 0, 0, 0, 0, 0, 0, -34.
DPR3TB: 0,0,0,0,0,0,0,0, -35.
DPT3TB: 0,0,0,0,0,0,0,0, -36.
OVERRUN: 0;       OVERRUN FLAG (ALL LINES)
;
;** TX MECHANISM **
;AT INITIALISATION SEND AND TSOM ARE SET.  SO LONG AS DATA IS NOT
;LOADED INTO THE TX BUFFER THE I/F WILL TRANSMIT IDLE FLAGS.
;INTERRUPTS ARE DISABLED TO REDUCE PROCESSOR LOAD.  TO TRANSMIT
;DATA, TSOM IS CLEARED AND INTERRUPTS ENABLED.  AN INTERRUPT WILL
;OCCUR WHEN TRANSMISSION OF THE CURRENT FLAG HAS BEEN COMPLETED.
;THE FIRST DATA BYTE IS LOADED, INTERRUPTS REMAIN ENABLED AND
;THE REST OF THE MESSAGE IS SENT.  ON INTERRUPT AFTER
;THE LAST CHAR THE TEOM BIT IS SET TO TRANSMIT THE CRC.  ON INT
;AFTER TEOM, TEOM IS CLEARED AND TSOM SET.  FLAGS WIIL THEN BE IDLED
;WITH INTERRUPTS UNTIL THE INTER-FRAME REQUIREMENT IS
;SATISFIED WHEN INTERRUPTS ARE DISABLED LEAVING THE UNIT
;IDLING FLAGS.
;
;  TX STATES
;     0 = INTER FRAME IDLE,INTS DISABLED, TSOM SET
;     1 = AWAITING COMPLETION OF CURRENT FLAG,TEOM CLEAR
;     2 = SECOND CHARACTER TRANSMISSION
;     3 = MESSAGE TRANSMISSION, NOT LAST BYTE, TEOM CLEAR
;     4 = CRC BEING TRANSMITTED, TEOM SET
;     5 = INTERFRAME FLAGS, TEOM SET
;     6 = CLEARING AFTER DATA LATE ERROR
;     7 = CLEARING (2)
;
;** TX INTERRUPT SEQUENCE **
;
UBTIS: MOV R0, -(SP)
 MOV #DPT1TB, R0
 BR DUPTIS

UBT2IS: MOV R0, -(SP)
 MOV #DPT2TB, R0
 BR DUPTIS
UBT3IS: MOV R0, -(SP)
 MOV #DPT3TB, R0

DUPTIS:
 MOV R1, -(SP)
 MOV R2, -(SP)
 MOV VEC(R0), R1;  PICK UP VECTOR ADDRESS
         MOVB  STATE(R0),R2             ;GET STATE
         ASL   R2                       ;SWITCH ON IT
         JMP   @DUPTSW(R2)
DUPTSW:  .WORD DUPT00                   ;UNWANTED INT
         .WORD DUPT10                   ;1ST AND 2ND CHARS
         .WORD DUPT10                   ;    -DITTO-
         .WORD DUPT20                   ;SUBS. CHARS
         .WORD DUPT30                   ;CRC DONE
         .WORD DUPT40                   ;INTER-FRAME FLAGS
         .WORD DUPT50                   ;CLEARING
         .WORD DUPT60                   ;CLEARING (2)
;
; IRRELEVANT INTERRUPT,  SET TEOM AGAIN TO GET ANOTHER.
DUPT00:  MOV   #TEOM,DUPTDB(R1)         ;CLEAR TSOM AND SET TEOM
         BR    DUPTEX
;
;1ST AND 2ND CHARS, BOTH MUST BE PRESENT.
DUPT10:  JSR   PC,LDC                   ;GET CHAR
         BLT   DUPT21                   ;** SHOULD BE ERROR **!!
         MOV   R2,DUPTDB(R1)            ;OUTPUT CHAR
         INCB  STATE(R0)                ;NEXT STATE
         BR    DUPTX1
;
;SUBSEQUENT CHARS
DUPT20:  JSR   PC,LDC                   ;GET CHAR
         BLT   DUPT21                   ;NO MORE (TCP, BEQ IS NO MORE)
         MOVB  R2,DUPTDB(R1)            ;SEND CHAR
         BR    DUPTX1
DUPT21:  BIS   #TEOM,DUPTDB(R1)         ;SET TEOM TO TRANSMIT CRC
         INCB  STATE(R0)                ;NEXT STATE
         MOVB  #IFLAGS,P1(R0)           ;SET INTER-FRAME FLAG COUNT
         BR    DUPTX2
;
;CRC DONE
DUPT30:  BIS   #TEOM,DUPTDB(R1)         ;SET TEOM TO GET NEXT INT.
         INCB  STATE(R0)                ;NEXT STATE
         BR    DUPTEX
;
;FIRST FLAG SENT WITH CRC.  IDLE FLAGS WITH TEOM.
DUPT40:  BIS   #TEOM,DUPTDB(R1)         ;TO GET INT.
         DECB  P1(R0)                   ;COUNT FLAG
         BLT   DUPT41                   ;LAST ONE
         BR    DUPTEX
DUPT41:  CLRB  STATE(R0)                ;RESET STATE
         MOV   (R1),P1(R0)              ;SAVE STATUS
 CLR MODE(R0)
 MOV INTNO(R0), INTVAL
 JMP DOINT
;
; THIS CODE DEALS WITH HANDLING DATA LATE ERRORS
;
DUPER1:  .WORD 0                        ;COUNT OF DATA LATE FAULTS
DUPER2:  .WORD 0                        ;COUNT OF DATA LATE FAULTS AT EOM
;
DUPTX2:  TST   DUPTCS(R1)
         BPL   DUPTEX                   ;OK
         INC   DUPER2                   ;COUNT FAULTS
DUPTX4:                                 ;DATA LATE
         MOV   #0,DUPTDB(R1)            ;CLEAR DONE
         BIC   #DUPSND,DUPTCS(R1)       ;CLEAR SEND REQ.
         MOVB  #6,STATE(R0)             ;CLEARING FLAG
         BR    DUPTEX
;
DUPT50:
         BIS   #DUPSND,DUPTCS(R1)       ;ASSERT SEND
         MOV   #TSOM,DUPTDB(R1)         ;SET TSOM
         MOVB  #7,STATE(R0)             ;CLEARING 2
         BR    DUPTEX
;
DUPT60:
         MOV   #TEOM,DUPTDB(R1)         ;CLEAR TSOM, SET TEOM
         BR    DUPT41
;
DUPTX1:
         TST   DUPTCS(R1)
         BPL   DUPTEX                   ;OK
         INC   DUPER1                   ;COUNT FAULTS
         BR    DUPTX4                   ;DEAL WITH DATA LATE ERROR
;
;
;NORMAL EXIT
DUPTEX:  JMP   DSPNXT
;
;
;
;
;** RECEIVER INTERRUPT SEQUENCE **********************
;
UBRIS: MOV R0, -(SP)
 MOV #DPR1TB, R0
 BR DUPRIS

UBR2IS: MOV R0, -(SP)
 MOV #DPR2TB, R0
 BR DUPRIS
UBR3IS: MOV R0, -(SP)
 MOV #DPR3TB, R0

DUPRIS:
 MOV R1, -(SP)
 MOV R2, -(SP)
 MOV VEC(R0), R1;    PICKUP DEVICE ADDRESS
         MOV   DUPRDB(R1),-(SP)         ;SAVE THE CHAR
         MOVB  STATE(R0),R2             ;SWITCH ON STATE
         ASL   R2
         MOV   DUPRSW(R2),R2
         RTS   R2
DUPRSW:  .WORD DUPR10                   ;1ST CHAR
         .WORD DUPR20                   ;2ND CHAR
         .WORD DUPR30                   ;3RD CHAR
         .WORD DUPR40                   ;4TH CHAR
         .WORD DUPR50                   ;5TH AND SUBSEQUENT CHARS
;
;1ST CHAR
DUPR10:  TST SEG(R0);  BUFFER PRESENT?
         BNE   DUPR11                   ;GOT ONE
         INC OVERRUN;           FAULT COUNT
         BIC   #RCVEN,(R1)              ;RESET RECEIVER TO ABORT FRAME
         BIS   #RCVEN,(R1)
         JMP   DSPNXT
;
DUPR20:                                 ;2ND CHAR
DUPR11:  JSR   PC,DUPCHK                ;CHECK FOR EOM & ERROR (EXIT IF EITHER)
         JSR   PC,STC                ;SAVE GOOD CHAR IN PARAM BLOCK
         BR    DUPRXX                   ;TAKE NEW STATE AND EXIT
;
;3RD CHAR
DUPR30:  CLR   P1(R0)                   ;CLEAR 2-BYTE SHIFT REG
         JSR   PC,DUPCHK
         MOVB  R2,P1+1(R0)              ;SAVE CHAR
         BR    DUPRXX
;
;4TH CHAR
DUPR40:  JSR   PC,DUPCHK
         MOVB  R2,P1(R0)
;NEXT STATE EXIT
DUPRXX:  INCB  STATE(R0)                ;NEXT STATE
         JMP   DSPNXT
;
;5TH AND SUBSEQUENT CHARS
DUPR50:  MOV   R2,-(SP)                 ;SAVE THE CHAR
         BMI   DUPRER                   ;ERROR FLAG SET
         BIT   #REOM,R2                 ;EOM?
         BNE   DUPR51                   ;YES
         MOVB  P1+1(R0),R2              ;GET CHAR FROM SHIFT REG
         JSR   PC,STC                   ;SAVE IN NIBBLE BUFFER
         BLE DUPR54                     ;OVER MAX LENGTH OF BLOCK
         SWAB  P1(R0)                   ;SAVE THE LATEST CHAR
         MOVB  (SP)+,P1(R0)             
         JMP   DSPNXT
;
DUPR54:  ; EXCEEDED MAX LEN OF BLOCK, ERROR = -2
MOV #-2,(SP); CODE ABOVE HAS ITEM ON STACK, SO OVERWRITE
BR UBRW53; AND TAKE EXIT
;
;END OF MESSAGE
DUPR51:  CLR   (SP)                     ;FLAG NO ERROR
DUPR52:  MOV   (R1),P1(R0)              ;SAVE MODEM STATUS
 MOV (SP)+,MODE(R0);  SEND BACK FLAG
         CLRB  STATE(R0)                ;RESET STATE
   CLR  SEG(R0);       NO I/P BLOCK NOW
         MOV INTNO(R0), INTVAL
DOINT:MOV (SP)+,R2
 MOV (SP)+, R1
 MOV (SP)+, R0
 JMP INT
;
;ERROR HANDLER
DUPRER:  MOV   #-1,(SP)                  ;FLAG ERROR
UBRW53:         BIC   #INTENB+RCVEN,(R1)       ;DISABLE RX
         BR    DUPR52                   ;AND EXIT NORMALLY
;
;
;ROUTINE TO CHECK FOR ERROR OR SHORT FRAME. EXITS DIRECT TO ERROR
;SEQUENCE IF EITHER FOUND.
DUPCHK:  BIT   #100000+REOM,R2          ;ERROR OR EOM?
         BEQ   DUPCH1                   ;NO
         BR    DUPRER                   ;EXIT LEAVING WORD ON STACK
DUPCH1:  RTS   PC                       ;NO ERROR, EXIT NORMALLY
;
;
STC:   
         MOV SEG(R0), KPAR6;           SET UP KERNEL SEG 6
         MOV #77406, KPDR6;            ?????????????????????
         MOVB R2, @0(R0);               PLANT CHAR
         INC (R0);     BUMP POINTER
        DEC MAXLN(R0);   OVER LENGTH?
         RTS   PC; WITH MAXLN CONDITION CODE SET
;
;   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 #177400, R2
           INC (R0); BUMP POINTERT
           DEC COU(R0);           SENDS '=' ON EXIT WHEN FINISHED
           RTS  PC;                   LAST CHAR??
;
; COMMON RETURN SEQUENCE  -  NO INTERRUPT NOTIFIED
DSPNXT: MOV (SP)+, R2
 MOV (SP)+, R1
 MOV (SP)+, R0
 .WORD 6 ; RTT - RETURN TO LAST ACTIVITY
;
;END OF DUP11 HANDLER
#FI
.END