.TIME40
;**************************************
;* DVRXRUB *
;* INTERFACE BETWEEN HARDWARE AND IMP*
;* DATE: 03.AUG.81 *
;**************************************
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
ADDERR, 340
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 ***************
.=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
.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
; 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
MAXLN = 4
SUB = 5
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=10. ;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
.END