; 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