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