;**************************************
;*         BRUN10                     *
;*  INTERFACE BETWEEN HARDWARE AND IMP*
;*  DATE:  23.NOV.79                  *
;**************************************
 
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

.=344; DQS11E INT
TXINT, 340
RXINT, 340
.=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

 
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/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
        PROCESS = 4
        SUB = 5
        P1 = 6
        MODE = 10
        SEG = 12
        SA = 14

; USEFUL ADDRESSES
        INTENB = 100
        KPAR6 = 772354
        KPDR6 = 772334
        DPRNO = -16;                ??????????????????
        DPR1VE = 760010
        DPT1VE = 760014
; TABLES
DPR1TB: 0,0,0,0,0,0,0
DPT1TB: 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 #DPR1VE, R1
        MOV #DPR1TB, R0
         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
         BR    UBRSS                    ;RESET TO FIX RX FAULT??
;
;SYN-DLE SEEN
UBRW20:  CMP   #UBSTX,R2                ;STX
         BNE   UBRW12                   ;NO, ERROR
        TST @R0
         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   -(SP)                    ;FLAG RANSFER OK
UBRW61:  MOV   (R1),P1(R0)              ;SAVE DEVICE STATUS
         CLRB  STATE(R0)                ;RESET STATE
         MOV #DPRNO, INTVAL
         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   #1,-(SP)                 ;SET ERROR FLAG
         BR    UBRW61                   ;AND EXIT
;
UBSTC:   
         MOV SEG(R0), KPAR6;           SET UP KERNEL SEG 6
         MOV #777, KPDR6;            ?????????????????????
         MOVB R2, (R0)+;               PLANT CHAR
         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 #DPT1VE, R1
       MOV #DPT1TB, R0
         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
         BEQ   UBTW31
         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   -(SP)                    ;FLAG NO ERRORS
         JMP   SENDOUT
;NEXT STATE EXIT
UBTWXX:  INCB  STATE(R0)
UBTWEX:  MOV   R2,UBTDB(R1)
         JMP   DSPNXT

;   LOAD CHAR ROUTINE
LDC:       MOV SEG(R0), KPAR6
           MOV #7777, KPDR6;           ????????????????????
           MOV (R0)+, R2;              GET CHAR AND BUMP POINTER
           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
      JMP INT

;
;     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