; FILE 'DVTU58'
;**************************************
;* DVTU58 *
;* INTERFACE BETWEEN HARDWARE AND IMP*
;* DATE: 28.OCT.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
.=160; RL01 INTERRUPT
DKINT, 340; SAME AS RK05
.=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; TU58 ******** !!!!!!!! **********
UBRIS, 340; DUP11 ON 11/34 DEV MACHINE
UBTIS, 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: DPTB; 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
INTX: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
UBTCS=4
UBTDB=6
;
;
; BLOCK SPEC
; PT = 0
STATE =2
MAXLN = 4
P1 = 6
MODE = 10
SEG = 12
COU= 14
VEC = 16
; USEFUL ADDRESSES
INTENB = 100
KPAR6 = 772354
KPDR6 = 772314
DPRNO = -8.; ????????????
; TABLES
DPTB: 0,0,0,0,0,0,0, 776160
TU58A: .WORD 5002, 2, 0, 0, 0, 0, 0; FLAG/BC,COMM,UNIT,SEQ,BYTE COU,BLOCK,CKSM
TU58B: .WORD 0, 0, 0, 0, 0, 0, 0
;
UBRIS:
MOV R0, -(SP)
MOV R1, -(SP)
MOV R2, -(SP)
MOV #DPTB, R0
MOV VEC(R0), R1; GET INTERFACE ADDRESS
RXCOMM:
MOV UBRDB(R1),-(SP) ;SAVE I/P CHAR
BPL UBRIS1
MOV (SP)+, SEG(R0); REMEMBER THE BAD CHAR
MOV #177776,MODE(R0); ; OVERRUN ERROR
JMP UBEXIT
UBRIS1:
BIC #177400,(SP)
RXTX: MOVB STATE(R0),R2 ;RWITCH ON STATE
ASL R2
MOV UBRWIT(R2),R2
RTS R2
UBRWIT: .WORD DSPNXT
.WORD UBTW10; 1ST CHAR SENT BY HANDLER
.WORD UBTW20; ; INSEIDE WRITE COMMAND SEQUENCE
.WORD UBTW30; ; NOW SEND THE CRC
.WORD UBTW40; ; 2ND BYTE OF CRC
.WORD UBTW50; ; 1ST BYTE READ INSIDE READ COMMAND
.WORD UBTW60; ;2ND BYTE OF READ INSIDE READ SEQUENCE
.WORD UBTW70; ; DATA IN READ SEQUENCE
.WORD UBTW80; ; 1ST CRC BYTE IN READ SEQ
.WORD UBTW90; ; 2ND CRC BYTE
.WORD UBTWA0; ; 1ST BYTE IN WRITE SEQUENCE
.WORD UBTWB0;; NOW SEND THE '128' OF THE HEADER
.WORD UBTWC0; NOW THE DATA BYTES
.WORD UBTWD0 ; GET THE COMMAND PACKET (JUST REC'D THE LEN)
.WORD UBTWE0 ; INSIDE COMMAND PACKET SEQUENCE
;
UBTW10: MOVB #2,STATE(R0); GOING TO DROP THROUGH
MOV #TU58A+1, (R0); SET UP POINTER
UBTW20: ; INSEIDE WRITE COMMAND SEQUENCE
MOVB @0(R0), R2
JSR PC, CRC
INC (R0)
DEC COU(R0); AND STEP DOWN THE COUNT
BNE UBTWEX; STILL MORE
MOV MODE(R0),(R0); SET 'REAL' ADDRESS UP
BR UBTWXX; AND GO TO SEND CRC
UBTW30: ; NOW SEND THE CRC
MOV P1(R0), R2; GET LOW BYTE OF CRC
BR UBTWXX; SEND IT, AND STEP STATE
UBTW40: ; 2ND BYTE OF CRC
MOVB P1+1(R0), R2
; NOW SET UP THE INPUT SIDE FOR TU58 RESPONSE
BIS #100, (R1); UBRCS IS IMPLIED - INPUT INT ON
BIC #100, UBTCS(R1); OUTPUT INT OFF
CMP #2, TU58A+2; READ COMMAND ??
BNE WRITEC; NO, SO PREPARE FOR WRITE BLOCK
; DO A READ BLOCK SEQUENCE (AFTER RESPONSE)
MOVB #5, STATE(R0); STATE = 5
BR UBTWEX
WRITEC: ; SET UP WRITE BLOCK SEQUENCE
MOVB #10.,STATE(R0)
BR UBTWEX
UBTW50: ; 1ST BYTE READ INSIDE READ COMMAND
; EXPECT DATA =1, COMMAND = 2, JUNK = OTHER
CMP R2, #1; DATA?
BEQ UBRWXX; IN READ SEQ, SO GO TO RWXX
CMP R2, #2; COMMAND?, IE END OF TRANSFER
BNE UBERRX; NO, SO ERROR
MOVB #13., STATE(R0); COMMAND READ SEQUENCE STATE
BR UBRWEX
UBERRX: JMP UBERR
UBTW60: ;2ND BYTE OF READ INSIDE READ SEQUENCE
CMP R2, #128.; SHOULD ALLWAYS BE 128
BNE UBERRX
MOV R2, COU(R0); COUNT = 128
MOV #100001,P1(R0); CLEAR CHECKSUM
BR UBRWXX
UBTW70: ; DATA IN READ SEQUENCE
JSR PC, UBSTC
JSR PC, CRC
INC (R0); STEP POINTER
DEC COU(R0)
BNE UBRWEX
BR UBRWXX
UBTW80: ; 1ST CRC BYTE IN READ SEQ
CMPB R2,P1(R0); COMAPRE CRC BYTE
BNE UBERR
BR UBRWXX; GET NEXT IF OK
UBTW90: ; 2ND CRC BYTE
CMPB R2,P1+1(R0)
BNE UBERR
MOVB #5,STATE(R0); NEXT ACTION IS COMMAND/END PACKET FROM TU58
BR UBRWEX
UBRWXX: INCB STATE(R0) ;NEXT STATE
UBRWEX: JMP DSPNXT
;
UBTWXX: INCB STATE(R0)
UBTWEX: BIC #177400,R2
MOV R2,UBTDB(R1)
DSPNXT:
MOV (SP)+, R2
MOV (SP)+, R1
MOV (SP)+, R0
.WORD 6; RTT - RETURN TO LAST ACTIVITY
;
; NOW DO THE WRITE BLOCK SEQUENCE
UBTWA0: ; 1ST BYTE IN WRITE SEQUENCE
; EXPECT: K'20' = CONTINUE, 2 = COMMAND, OTHERWISE JUNK
CMP R2, #20; CONTINUE?
BEQ UBTWA1; GOT IT
CMP R2, #2; COMMAND PACKET
BNE UBERR
MOVB #13.,STATE(R0); GO TO RECEIVE COMMAND PACKET
BR UBRWEX; IN RECEIVE MODE STILL
UBTWA1: BIC #100,(R1); RECEIVE INTS OFF (UBRCS IMPLIED)
INCB STATE(R0); GO TO STATE 11
UBTWA2: TSTB UBTCS(R1)
BPL UBTWA2
MOV #1,UBTDB(R1); SEND IT NOW
BIS #100,UBTCS(R1); TRANSMITTER INT ON
BR DSPNXT
UBTWB0:; NOW SEND THE '128' OF THE HEADER
MOV #128.,R2
MOV #100001,P1(R0); SET CKSM
MOV R2, COU(R0); COUNT = 128
BR UBTWXX
UBTWC0:; NOW THE DATA BYTES
JSR PC, LDC
JSR PC,CRC
INC (R0); BUMP POINTER
DEC COU(R0); FINISHED?
BNE UBTWEX; NO, SO CARRY ON
MOVB #3,STATE(R0); SHARES CRC CODE WITH TRANSMIT COMMAND
BR UBTWEX
; RECEIVE COMMAND PACKET CODE
UBTWD0: ; GET THE COMMAND PACKET (JUST REC'D THE LEN)
CMP R2, #10.
BNE UBERR
MOV #TU58B,(R0)
MOV R2, COU(R0)
BR UBRWXX
UBTWE0: ; INSIDE COMMAND PACKET SEQUENCE
MOVB R2,@0(R0)
INC (R0)
DEC COU(R0)
BNE UBRWEX
; REPLY TO CALLER
BR UBIDLE
;ERROR EXIT
;
UBSTC:
MOV SEG(R0), KPAR6; SET UP KERNEL SEG 6
MOV #77406, KPDR6; ?????????????????????
MOVB R2, @0(R0); PLANT CHAR
; DEC MAXLN(R0); OVER LENGTH?
; BNE UBSTC1; NO, SO OK
; TST (SP)+; YES, SO ERROR
; MOV #-3,MODE(R0)
; BR UBEXIT
UBSTC1:
RTS PC
;
;
;
;
;** TX INT. SEQ. **
;
; DATA LATE IGNORED AS PROTOCOL WILL RECOVER.
;
UBTIS:
MOV R0, -(SP)
MOV R1, -(SP)
MOV R2, -(SP)
MOV #DPTB, R0
TXCOMM:
MOV VEC(R0), R1; GET VECTOR ADDRESS
CLR -(SP); DUMMY ENTRY ON STACK TO MIMIC INPUT
JMP RXTX
; GO TO IDLE
UBERR: ; ERROR EXIT
MOV R2,SEG(R0); STORE THE BAD CHAR
MOV #177777,MODE(R0)
BR UBEXIT
UBIDLE:
MOV (R1),P1(R0) ;SAVE STATUS
CLR MODE(R0) ;FLAG NO ERRORS
UBEXIT:
MOV #DPRNO, INTVAL
BIC #100,(R1); UBRCS IMPLIED
BIC #100,UBTCS(R1)
DOINT: MOV (SP)+, R2
MOV (SP)+, R1
MOV (SP)+, R0
JMP INT; CALCULATE BYTE COUNT?
;NEXT STATE EXIT
; 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
RTS PC; LAST CHAR??
;
;
;** CRC ROUTINE **
;
CRC: BIT #1,(R0); POINTER ON WRD BDRY?
BNE CRCEND; NO, SO RETURN
ADD @0(R0),P1(R0); ADD WHOLE WORD INTO CRC STORE
ADC P1(R0); AND CARRY IF NECESSARY
CRCEND: RTS PC
.END