1
0
mirror of https://github.com/PDP-10/its.git synced 2026-02-03 15:22:48 +00:00

KLDCP - KL10 diagnostics console program.

This commit is contained in:
Lars Brinkhoff
2018-06-12 22:35:45 +02:00
parent c40ea830fa
commit 8563a595d0
18 changed files with 11973 additions and 0 deletions

473
src/kldcp/apt11.2 Executable file
View File

@@ -0,0 +1,473 @@
;;;MODIFICATION HISTORY
;;;
;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7)
;;; 15 NOV 75 CONVERTED TO PALX FORMAT
;;;
.SBTTL APT10 PDP-11 PROCESS, 13-AUG-75
ACTFIL: CMP #5,LDCNTL ;LOADING ".BIN" ?
BNE 1$
MOV #1,LDCNTL ;YES, ACT10 CONVERTS TO ".A11"
1$: COMENQ ;REQUEST APT10 SERVICE
MOV #$INBUF,R0
COMCMD ;SEND COMMAND TO REMOTE
BCS 2$ ;C-BIT SET, FILE NOT FOUND
CLR ARETRY ;CLEAR RETRY COUNTER
BR ACTLD1 ;GO TO LOAD PROCESS
2$: JMP $NONXF
ACTLD2: TST DEVTYP
BMI 1$ ;ACT10
JMP LLD2 ;DECTAPE/RP04
1$: COMACK ;ACK PREVIOUS LINE
BCS ACTEOF ;C-BIT SET, EOF
CLR ARETRY ;CLEAR RETRY COUNTER
ACTLD1: INC DEVLC ;COUNT LINE
MOV DEVLC,SWR ;DISPLAY
TST LDCNTL ;DOING A "HELP" ?
BPL 1$ ;NO
DAHLP=.
TST DIAFLG ;DOING DIAMON
BEQ 30$ ;NO
TST DEVLC ;YES, FIRST LINE ?
BNE 31$ ;NO
JMP DIAFND ;YES, DIAMON FILE FOUND
31$: JMP DIARNL ;DIAMON READ NEW LINE
30$: TST IFILEF ;DOING AN INDIRECT FILE ?
BEQ 4$
JMP IFILEP ;YES, STORE INPUT
4$: SETFLG
HLPPNT ;NORMAL BACKSLASHES
MOV #$INBUF,R0 ;YES, PRINT INPUT LINE
TST DEVTYP
BPL 41$
MOV #CINBF,R0
41$: PNTAL
CLR HLPPNT
BR ACTLD2 ;REPEAT TILL "EOT"
1$: JMP LDPROC ;GO TO LOAD PROCESS
ACTEOF: COMCLR
DAHLPD=.
TST DIAFLG ;DOING DIAMON ?
BEQ 10$ ;NO
JMP DIAEOF ;YES, SEND DIAMON END OF FILE
10$: TST IFILEF ;INDIRECT/DOUBLE INDIRECT ?
BNE 21$ ;YES
PCRLF ;NO, JUST HELP
BR 23$ ;BACK TO CONSOLE
21$: TST JFILEF ;DOUBLE INDIRECT ?
BPL 22$ ;NO
TSTB JFILEF ;PRESENT JUST INDIRECT ?
BEQ 22$ ;YES
CLRB JFILEF ;SET DONE WITH READING "J"
MOV #TOUTBF+5000,JFINP ;SET "J" POINTER TO BEGINNING
JMP CONSL ;START RUNNING
22$: MOV #TOUTBF,IFINP ;SET POINTER TO BEGINNING
CLRB IFILEF
23$: JMP $CONSL ;GO PROCESS INDIRECT FILE
ACTDON: COMACK ;ACK TRANSFER BLOCK
BCC 3$
DADONE=.
TST SRTFLG ;SELF START ?
BEQ 1$
JMP $$GO ;YES
1$: JMP $CONSL ;NO
3$: PMSG <?EOF,ERR>
$$C2: JMP $CNTLC
ACTLDC: PMSG <?LOAD CHR>
BR ACTERR
ACTBCK: PMSG <?CKSUM>
BR ACTERR
ACTLDF: PMSG <?FORMAT>
ACTERR: PMSG < ERR: LOAD LINE >
MOV DEVLC,R0
PNTDEC ;PRINT LOAD LINE NUMBER
PCRLF
TST DEVTYP
BPL 2$ ;DECTAPE/RP04
INC ARETRY
CMP #4,ARETRY ;REACHED RETRY LIMIT ?
BEQ 1$ ;YES
COMNAK ;NO, NAK MESSAGE & TRY AGAIN
DEC DEVLC ;DECREMENT LINE COUNT
JMP ACTLD1
1$: PMSG <CAN'T LOAD>
2$: BR $$C2
.SBTTL COMMUNICATIONS ROUTINES
$COMACK:INC MSGNBR ;COUNT MESSAGE
$$CMACK:MOV #ACKMSG,R5 ;MESSAGE ACKNOWLEDGE
BR $COMCX
$COMNAK:MOV #NAKMSG,R5 ;MESSAGE NEGATIVE ACKNOWLEDGE
BR $COMCX
$COMCMD:CLR R5 ;MESSAGE COMMAND
$COMCX: MOV #3,R4 ;RETRY 3 TIMES
1$: TST R5
BNE 2$
COMSND ;COMMAND SEND
BR 3$
2$: MOV R5,R0
COMCTL ;CONTROL SEQUENCE SEND
3$: COMLIN ;GET REPLY
BCS 5$ ;ERROR
BPL 7$ ;CONTROL SEQUENCE
MOV #136,R3 ;NORMAL MESSAGE
BIT #1,MSGNBR ;ODD OR EVEN MESSAGE NUMBER
BEQ 4$
MOV #041,R3
4$: CMP R3,COMNBR ;CORRECT MESSAGE NUMBER ?
BNE $$CMACK ;NO, MUST BE REPEAT
CLR R0
41$: EXIT ;NEW MESSAGE READY FOR PROCESS
5$: DEC R4 ;EXCEEDED RETRY LIMIT ?
BNE 6$ ;NO, TRY AGAIN
JMP $COMERR ;YES, REPORT ERROR & ABORT
6$: TST R5
BNE 61$ ;CONTROL REPEAT
CMP #-5,R0 ;RECIEVED CHECKSUM ERROR ?
BEQ 61$ ;YES, SEND NAK
COMRTRY ;COMMAND RETRY
BR 3$
61$: MOV #NAKMSG,R5
BR 2$
7$: TTICHR ;GET CONTROL SEQUENCE CHARACTER
CMPB #'A,R0
BEQ 41$ ;A, ACKNOWLEDGE
CMPB #'Z,R0
BEQ 8$ ;Z, END OF TRANSMISSION
CMPB #'N,R0
BNE 71$
MOV #-7,R0 ;N, NEGATIVE ACKNOWLEDGE
BR 5$
71$: MOV #-10,R0 ;UNKNOWN RESPONSE
BR 5$
8$: EXITERR ;END OF FILE
$COMERR:PUSH R0
PMSG <?COMM ERR >
POP R0
NEG R0
MOV R0,R1
PNTOCS
PNTCI
",
DEC R1
SL R1,1
MOV CMERTB(R1),R0
PNTAL
JMP $CNTLC
CMERTB: CMER1
CMER2
CMER3
CMER4
CMER5
CMER6
CMER7
CMER10
CMER1: .ASCIZ %NO RESPONSE%
CMER2: .ASCIZ %LONG LINE%
CMER3: .ASCIZ %MSG NBR%
CMER4: .ASCIZ %NO CR%
CMER5: .ASCIZ %MSG CKSUM%
CMER6: .ASCIZ %FORMAT%
CMER7: .ASCIZ %NAK%
CMER10: .ASCIZ %UNKNOWN%
.EVEN
$COMSND:MOV #COUTBF,R5
CLR R3
1$: CMPB (R0),#CR ;REACHED CR YET ?
BEQ 2$ ;YES
CMPB (R0),#ALTMOD ;OR ALTMODE ?
BEQ 12$ ;YES, SUBSTITUTE CR
TSTB (R0) ;REACHED NULL BYTE ?
BNE 11$
MOV #-6,R0 ;YES, INCORRECT MESSAGE FORMAT
BR $COMERR
11$: MOVB (R0),R2
ADD R2,R3 ;ACCUMULATE CHECKSUM
MOVB (R0)+,(R5)+ ;TRANSFER MSG TO OUTPUT BUFFER
BR 1$
12$: MOV #ALTMOD,(R5)+
BR 22$
2$: MOVB (R0)+,(R5)+ ;PUT CR IN OUTPUT
22$: CLRB (R5) ;FOLLOW WITH NULL
MOV #COUTBF-4,R5 ;SETUP MESSAGE START
MOVB #136,(R5)
BIT #1,MSGNBR ;SET UP MESSAGE NUMBER CHAR
BEQ 21$
MOVB #041,(R5)
21$: INC R5
NEG R3 ;NEGATE CHECKSUM
MOV R3,R0
SWAB R0
BIC #177400,R0
SHIFTR
4
JSR PC,COMASC
MOVB R0,(R5)+ ;INSERT 1ST CHECK CHAR
MOV R3,R0
SHIFTR
6
JSR PC,COMASC
MOVB R0,(R5)+ ;INSERT 2ND CHECK CHAR
MOV R3,R0
JSR PC,COMASC
MOVB R0,(R5)+ ;INSERT 3RD CHECK CHAR
$CMRTRY:MOV #COUTBF-4,R0 ;SETUP MESSAGE POINTER
$COMCTL:TSTB @$CMTKS ;ANY OLD CHARS ?
BPL 1$
MOVB @$CMTKB,$TTYIN ;YES, GET GET OF IT
BR $COMCTL
1$: TSTB @$CMTPS ;WAIT TILL OUTPUT IS READY
BPL $COMCTL
MOV #2,R1 ;SEND 2 SYNC CHARACTERS
2$: MOVB #SYN,@$CMTPB
3$: TSTB @$CMTPS
BPL 3$
DEC R1
BNE 2$
4$: MOVB (R0)+,R1 ;GET MESSAGE CHAR
BEQ 6$ ;IF NULL, DONE
MOVB R1,@$CMTPB ;SEND CHAR
5$: TSTB @$CMTPS ;WAIT TILL OUTPUT READY
BPL 5$
BR 4$ ;SEND TILL NULL
6$: EXIT ;COMPLETED
COMASC: BIC #177700,R0 ;KEEP 6 BITS
CMP R0,#74 ;LEAVE 75,76,77 ALONE
BGT 1$
BIS #100,R0 ;SET BIT 7 FOR ASCIIZE
1$: RTS PC
$COMLIN:MOV #CINBF-4,R1 ;START BUFFER ADDRESS
CLR $TTYTIM ;CLEAR TIMEOUT
CLR R5 ;CLEAR IN SYNC FLAG
1$: JSR PC,C10COP ;PERFORM CLOCK OPERATIONS
CMP $TTYTIM,#<20.*60.> ;20 SECS
BGT 90$ ;TIMED OUT
TSTB @$CMTKS ;COMM IN FLAG SET ?
BMI 2$ ;YES
JSR PC,$PTTYC ;ANY OPERATOR INTERRUPT ?
BR 1$ ;NO
2$: MOVB @$CMTKB,(R1) ;MOVE CHAR TO BUFFER
BICB #200,(R1)
TSTB (R1)
BEQ 1$ ;IGNORE NULLS
CMPB (R1),#SYN ;SYNC CHAR ?
BEQ 21$ ;YES
TST R5 ;RECIEVED SYNC YET ?
BEQ 1$ ;NO, DUMP GARBAGE CHARS
CMPB (R1),#ALTMOD
BEQ 3$ ;ALTMODE, CONTROL SEQUENCE
CMPB (R1),#'$ ;DOLLAR, PDP-10 SENDS THIS FOR ALTMODE
BNE 22$
CMP R1,#CINBF ;LEGAL ONLY IF IN CONTROL SEQUENCE
BLT 3$
22$: CMPB (R1),#LF
BEQ 4$ ;LF, MESSAGE SEGMENT
INC R1
CMP R1,#CINBF+140.
BLE 1$ ;STILL ROOM
BR 91$ ;NO, LINE TOO LONG
21$: MOV #-1,R5 ;SYNC, SET IN SYNC FLAG
BR 1$
3$: INC R1 ;NULL TO END BUFFER
CLRB (R1)
MOV R1,$INPTR ;SETUP INPUT POINTERS
MOV #CINBF-4,$INPTC
EXIT ;CONTROL SEQUENCE RETURN
4$: INC R1
CLRB (R1)
MOV R1,$INPTR ;SETUP INPUT POINTERS
MOV #CINBF-4,R1
CMPB #041,(R1)
BEQ 41$
CMPB #136,(R1)
BEQ 41$
BR 92$ ;MESSAGE NUMBER INCORRECT
41$: MOVB (R1)+,COMNBR ;SAVE MESSAGE NUMBER
CLR R0 ;SETUP FOR MESSAGE CHECKSUM
MOV #3,R5 ;CHARS 2,3,4 ARE CHECKSUM
42$: SL R0,6
MOVB (R1)+,R4 ;GET 1ST CHECK CHAR
BIC #100,R4 ;CLEAR ASCIIZE BIT
BIS R4,R0 ;INSERT IN 16 BIT CHECKSUM
DEC R5
BGT 42$ ;DO 3 CHARS
43$: CMPB (R1),#CR ;REACHED EOL ?
BEQ 44$ ;YES
TSTB (R1) ;PAST EOL WITHOUT CR ?
BEQ 93$ ;YES, NO CR ERROR
MOVB (R1)+,R3
ADD R3,R0 ;ACCUMULATE CHECKSUM
BR 43$
44$: TST R0 ;DID CHECKSUM COMPUTE TO 0 ?
BNE 94$ ;NO, CHECKSUM ERROR
MOV #CINBF,$INPTC ;MESSAGE SEGMENT OK
BIS #NBIT,14(SP) ;SET NORMAL MESSAGE INDICATOR
EXIT
90$: MOV #-1,R0 ;NO RESPONSE ERROR
BR 99$
91$: MOV #-2,R0 ;LINE TOO LONG ERROR
BR 99$
92$: CMPB #'?,(R1) ;IS MESSAGE NUMBER QUESTION MARK ?
BEQ COMQ ;YES, HOST ERROR
MOV #-3,R0 ;MESSAGE NUMBER CHAR ERROR
BR 99$
93$: MOV #-4,R0 ;NO CARRIAGE RETURN ERROR
BR 99$
94$: MOV #-5,R0 ;MESSAGE CHECKSUM ERROR
99$: EXITERR ;ERROR EXIT, C-BIT SET, CODE IN R0
COMQ: $PMSG ;PRINT ERROR REPLY
CINBF-4
JMP $CNTLC
$COMENQ:COMCLR ;CLEAR COMMUNICATIONS
SETFLG
ENQFLG ;SET APT10 IN PROGRESS
MOV #3,R4
10$: CLR MSGNBR ;INITIALIZE MESSAGE NUMBER
MOV #ENQMSG,R0
COMCTL ;SEND "ENQ" MESSAGE
COMLIN ;WAIT FOR REPLY
BCS 1$ ;ERROR, CODE IN R0
BMI 3$ ;NORMAL MESSAGE REPLY ?
TTICHR
CMPB #'A,R0 ;A, ACKNOWLEDGE
BNE 1$
EXIT ;ACKED, GO AHEAD
1$: TST R0 ;IS REPLY CODE NEGATIVE ?
BMI 4$ ;YES, COMLIN ERROR
CMPB #'Z,R0 ;IS REPLY EOT, WAIT ?
BNE 3$ ;NO
CLR $TTYTIM ;YES, WAIT 10 SECONDS
2$: JSR PC,$PTTYC
JSR PC,C10COP
CMP $TTYTIM,#<10.*60.>
BLE 2$
BR $COMENQ ;THEN TRY AGAIN
3$: PMSG <?APT10 ENQ>
JMP $CNTLC
4$: DEC R4
BNE 10$ ;RETRY
JMP $COMERR ;COMMUNICATIONS ERROR
$COMEOT:MOV #EOTMSG,R0
COMCTL
EXIT
$COMCLR:CLR ENQFLG
MOV #CANMSG,R0
COMCTL
MOV #100000,R1
1$: TSTB @$CMTKS ;ANY INPUT IN PROGRESS ?
BPL 2$
MOVB @$CMTKB,R0 ;IF SO, GET RID OF IT
BR 1$
2$: DEC R1
BNE 1$ ;A LITTLE DELAY
EXIT
ENQMSG: .BYTE 'E,33,0
ACKMSG: .BYTE 'A,33,0
NAKMSG: .BYTE 'N,33,0
CANMSG: .BYTE 'C,33,0
EOTMSG: .BYTE 'Z,33,0
.EVEN
IFILEP: MOV #$INBUF,R0 ;SETUP POINTERS
TST DEVTYP
BPL 10$
MOV #CINBF,R0
10$: MOV IFINP,R1
1$: MOVB (R0)+,(R1)+ ;TRANSFER CHARS TO STORAGE
BNE 1$ ;TILL NULL
CLRB (R1) ;THEN STORE 2ND NULL
MOV R1,IFINP ;RESAVE POINTER
CMP R1,#TOUTBF+10000-200
BLE 2$ ;EXCEEDED BUFFER ROOM ?
JMP $LINERR ;YES
2$: JMP ACTLD2 ;REPEAT TILL EOF

58
src/kldcp/beg11.1 Executable file
View File

@@ -0,0 +1,58 @@
;;;MODIFICATION HISTORY
;;;
;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7)
;;; 15 NOV 75 CONVERTED TO PALX FORMAT
;;;
.SBTTL *BEGIN* PROGRAM CONTROL, 4-AUG-75
.=PRGSRT
;STARTING ADDRESS
START: JMP @#$SBRINT ;NORMAL START
$CNTLC: JMP @#$$CNTLC ;CTRL/C
$ILOAD: JMP $$ILOAD ;INITIAL LOAD
$CONSL: JMP $$CONSL ;RETURN TO CONSOLE
;DEVICE ADDRESS PARAMETERS
$TKS: 177560 ;TTY KBD STATUS
$TKB: 177562 ;TTY KBD BUFFER
$TPS: 177564 ;TTY PRINTER STATUS
$TPB: 177566 ;TTY PRINTER BUFFER
$LPS: 177514 ;LP11 - LINE PRINTER STATUS
$LPB: 177516 ;LP11 - LINE PRINTER BUFFER
$FSTKS: 175610 ;FIELD SERVICE KLINIK INPUT STATUS
$FSTKB: 175612 ;FIELD SERVICE KLINIK INPUT BUFFER
$FSTPS: 175614 ;FIELD SERVICE KLINIK OUTPUT STATUS
$FSTPB: 175616 ;FIELD SERVICE KLINIK OUTPUT BUFFER
$CMTKS: 175620 ;COMM INPUT STATUS
$CMTKB: 175622 ;COMM INPUT BUFFER
$CMTPS: 175624 ;COMM OUTPUT STATUS
$CMTPB: 175626 ;COMM OUTPUT BUFFER
RPRH11: 176700 ;RH11 CONTROLLER ADDRESS
;PDP-10 KL10 PARAMETERS
TENMO: -1 ;PDP-10 MINUS ONE
-1
17
TDIAG: $STD ;DIAGNOSTIC START ADDRESS
0
TDDT: $DDT ;DDT START ADDRESS
0
TLDR: $STL ;LOADER START ADDRESS
0
TMON: $STM ;MONITOR START ADDRESS
0
EMTIMO: 25000. ;EM/DM TIMEOUT COUNT

219
src/kldcp/bpnt11.1 Executable file
View File

@@ -0,0 +1,219 @@
;;;MODIFICATION HISTORY
;;;
;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7)
;;; 15 NOV 75 CONVERTED TO PALX FORMAT
;;;
.SBTTL BREAKPOINT FUNCTIONS, 1-JULY-75
;BP ;PRINTS ACTIVE BREAKPOINTS
;BP ADR ;INSERT BP
;BC ;BP CONTINUE
;BC COUNT ;BP CONTINUE FOR COUNT
;RB ;REMOVE CURRENT BP
;RB 0 ;REMOVE ALL BP'S
;RB ADR ;REMOVE BP AT ADR
;BREAK POINT INSERTION
.BP: TTISDL
BCC 4$ ;NUMBER, INSERT BP
1$: MOV #$BT+2,R1 ;PRINT ACTIVE BP'S
2$: MOV (R1),R0 ;GET BP ADDRESS
BEQ 3$ ;EMPTY
PNTOCT ;PRINT BP ADDRESS
3$: ADD #6,R1
CMP R1,#$BT+<6*$NB> ;FINISHED ?
BLT 2$ ;NO
BR $BPEX1
4$: TTOCTE ;INPUT EVEN ADDRESS
MOV R0,R2
JSR PC,$BTS ;SEARCH BP TABLE
BCC $BPERR ;ALREADY THERE
BEQ $BPERR ;TABLE FULL ALREADY
MOV R2,(R1) ;PUT INST ADR IN BP TABLE
MOV (R2),-(R1) ;PUT INST IN BP TABLE
CLR 4(R1) ;CLEAR CONTINUE COUNT
MOV #IOT,(R2) ;PUT BP IN PLACE OF INST
BR $BPEXT
;BREAK POINT TRAP
$BRKPT: CLR .HCFLG
MOV R0,$R0SAV ;SAVE ALL REGS R0 - R5
MOV #$R1SAV,R0
MOV R1,(R0)+
MOV R2,(R0)+
MOV R3,(R0)+
MOV R4,(R0)+
MOV R5,(R0)+
MOV SP,(R0) ;FOR REG PRINT ONLY, NOT RESTORED
ADD #4,(R0) ;MAKE IT AS IT WAS BEFORE BP
MOV (SP),R2 ;GET AFTER TRAP PC
TST -(R2) ;MAKE IT BEFORE TRAP PC
JSR PC,$BTS ;FIND BP IN TABLE
1$: MOV R2,(SP) ;PUT ADR ON STACK FOR "RTI" LATER
MOV R2,$BCA ;SAVE BP CONTINUE ADDRESS
PUSH -(R1) ;SAVE PROGRAM INST ON STACK
DEC 4(R1) ;DECREMENT CONTINUE COUNT
BGT .ABC ;COUNT GT 0, AUTO CONTINUE
2$: CLR TENRUN
PFORCE
PMSG <\BP AT >
MOV R2,R0
PNTOCT
PMSG <PS=>
MOV 4(SP),R0
PNTOCT
$BPEX1: PCRLF
$BPEXT: JMP $CONSL ;RETURN TO MONITOR
$BPERR: PMSG <BP ERR>
BR .BPERR
;BREAKPOINT CONTINUE
.BC: TTISDL
BCC .BCCNT ;CONTINUE COUNT
.ABC: CMP $BCA,2(SP) ;IS STACK OK, IF SO CONTINUE
BEQ 1$ ;OTHERWISE SP BAD OR NOT IN BP
.BCERR=.
PMSG <CAN'T CONT>
.BPERR=.
JMP $CNTLC
1$: MOV @$BCA,$BTIS ;SAVE WHATS AT BP ADDRESS
POP @$BCA ;RESTORE PROGRAM INST
JSR PC,.BCHC2 ;RESTORE REGISTERS
BIS #TBIT,2(SP) ;SET FOR T-BIT TRAP
RTT ;RESTART FOR ONE INSTRUCTION
;T-BIT TRAP COMES TO HERE
.BCCT: BIC #TBIT,2(SP) ;CLEAR T-BIT
MOV $BTIS,@$BCA ;PUT BP/INST BACK IN PROGRAM
RTI ;RESUME
.BCCNT: TTIDEC ;INPUT CONTINUE COUNT
BCS $BPERR
MOV R0,R5
MOV $BCA,R2
JSR PC,$BTS ;FIND ENTRY IN TABLE
BCS .BCERR ;NOT THERE
1$: MOV R5,2(R1) ;PUT COUNT IN TABLE
BR .ABC
;REMOVE BREAKPOINTS
.RB: TTISDL
BCS 2$ ;REMOVE CURRENT BP
TTOCTE ;INPUT BP ADDRESS
TST R0
BEQ 4$ ;IF 0, REMOVE ALL BP'S
MOV R0,R2
3$: JSR PC,$BTS ;FIND ADDRESS IN TABLE
BCC 1$
PMSG <CAN'T FIND>
BR .BPERR
1$: JSR PC,$RB ;REMOVE BP
11$: BR $BPEXT
2$: MOV $BCA,R2 ;REMOVE CURRENT BP
BR 3$
4$: JSR PC,.CB ;CLEAR ALL BP'S
BR $BPEXT
;CLEAR ALL BREAKPOINTS
.CB: MOV #$BT+2,R1
1$: MOV (R1),R2 ;GET TABLE ENTRY
BEQ 2$ ;EMPTY
JSR PC,$RB ;REMOVE BP
2$: ADD #6,R1
CMP R1,#$BT+<6*$NB>
BLT 1$
RTS PC
$RB: CLR (R1) ;CLEAR ADDRESS FIELD
CMP (R2),#IOT ;BP IN MEMORY ?
BNE 1$ ;NO
MOV -2(R1),(R2) ;YES, RESTORE INSTRUCTION
1$: RTS PC
;REGISTER RESTORE
.BCHC: TTITRM
.BCHC2: MOV #$R0SAV,R5
MOV (R5)+,R0
MOV (R5)+,R1
MOV (R5)+,R2
MOV (R5)+,R3
MOV (R5)+,R4
MOV (R5),R5
RTS PC
;BREAKPOINT REGISTER PRINTOUT
.RG: PFORCE
CLR R2 ;REGISTER NUMBER
MOV #$R0SAV,R1 ;REG SAVE TABLE POINTER
1$: PNTCI
'R
MOV R2,R0
PNTNBR ;PRINT REGISTER NUMBER
4$: PSLASH
2$: MOV (R1)+,R0
PNTOCT ;PRINT CONTENTS
INC R2
CMP R2,#6
BLT 1$
BGT 3$
PNTCI
"SP
BR 4$
3$: BR $BPEX1
;SEARCH BP TABLE FOR ADDRESS IN R2
;C-BIT SET SEARCH FAILURE
;C-BIT & Z-BIT SET SEARCH FAILURE & TABLE FULL
; R1 = ADDRESS OF EMPTY SLOT IF TABLE NOT FULL
;C-BIT CLEAR, FOUND & R1 = ADDRESS OF ENTRY
$BTS: MOV #$BT+2,R1 ;INIT BP TABLE POINTER
CLR R0
1$: TST (R1) ;IS IT EMPTY ?
BNE 2$ ;NO
MOV R1,R0 ;YES, SAVE ADDRESS OF EMPTY SLOT
BR 3$
2$: CMP (R1),R2 ;IS THIS THE ENTRY ?
BNE 3$ ;NO
CCC ;YES, INDICATE WITH C-BIT CLEAR
RTS PC
3$: ADD #6,R1 ;STEP TO NEXT ENTRY
CMP #$BT+<6*$NB>,R1
BGT 1$
MOV R0,R1 ;COUNDN'T FIND, Z-BIT SET = FULL
SEC ;INDICATE WITH C-BIT SET
RTS PC

929
src/kldcp/br11.9 Executable file
View File

@@ -0,0 +1,929 @@
;;;MODIFICATION HISTORY
;;;
;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7)
;;; 15 NOV 75 CONVERTED TO PALX FORMAT
;;; 30 MAR 76 MODIFIED TO COEXIST WITH ITS IOELEVEN PROGRAM
.SBTTL DTE20 INITIALIZATION ROUTINE, 9-SEPTEMBER-75
DTEINI: TST $ONETM ;HAVE WE GONE THROUGH THIS ONCE BEFORE ?
BNE 3$ ;BR IF YES
MOV #DTEADR,R0
11$: MOV #16.,R2
MOV #.DELAY,R1
1$: MOV R0,(R1)+ ;SETUP DTE20 INDIRECT ADDRESS POINTERS
INC R0
INC R0
DEC R2
BNE 1$
3$: SETFLG
$ONETM
MOV #$STJRS,R0 ;SETUP "JRST" START INSTRUCTION
MOV #$$STJRS,R1 ;MUST BE IN STORAGE BECAUSE
MOV (R0)+,(R1)+ ;THE JRST ADR IS VARIABLE
MOV (R0)+,(R1)+
MOV (R0)+,(R1)+
MOV #$PAGDFL,R0 ;SETUP "DATAO PAG,0" DEFAULT ARGUMENT
MOV #PAGDFL,R1 ;MUST BE IN STORAGE BECAUSE THE CURRENT
MOV (R0)+,(R1)+ ;AC BLOCK SELECTION IS VARIABLE
MOV (R0)+,(R1)+
MOV (R0)+,(R1)+
CLR R0
SETMPH ;SET M-BOX PHASE
RTS PC
$PAGDFL:WD36 7000,0040,0000 ;LD'S & NO ST ACC
.EVEN
JRST==254
$STJRS: I10 JRST,0,,0
.EVEN
$DTEBAS:MOV .DELAY,R0
EXIT
.SBTTL ROUTINE TO READ THE EBUS VIA THE DTE20
;THIS IS THE ROUTINE TO READ 36 BITS FROM THE EBUS
;THE CALL REQUIRES THE DIAGNOSTIC FUNCTION TO BE EXECUTED
;TO BE IN REGISTER R0,RIGHT JUSTIFIED.
;CALLING SEQUENCE:
; CALL-1: MOV #DIAG FUNCTION,R0
; CALL: DFRD
$DFRDT: MOV @$EMADR,R0 ;PICKUP TRAILING PARAMETER
ADD #2,12(SP) ;SKIP RETURN
$DFRD: JSR PC,$KLCK1 ;CHECK KL10 CLOCK RUNNING
ASL R0 ;MAKE DIAG FCN IN CORRECT BITS
SWAB R0 ;MAKE DIAG FCN IN CORRECT BYTE
BIS #DCOMST!DFUNC!DIKL10,R0 ;SET CORRECT DTE20 BITS
MOV R0,@.DIAG1 ;EXECUTE THE FUNCTION
$DFXX: WFZERO DCOMST ;WAIT FOR DONE FLAG
JSR PC,$KLCK2 ;RESTART CLOCK IF NECESSARY
EXIT
$DFTIM: CLR TENRUN
PMSG <?DF TIMEOUT AT >
MOV R1,R0
PNTOCT
PMSG <PC = >
MOV 16(SP),R0 ;GET ADDRESS OF CALL
$DFTMX: TST -(R0)
PNTOCT
JMP $CNTLC
$ECTIM: PMSG <?CLK>
$DFTM1: PMSG < ERR AT >
MOV R1,R0
BR $DFTMX
.SBTTL ROUTINE TO EXECUTE DIAG FUNCTION VIA DTE20
;THIS IS THE ROUTINE TO EXECUTE A NON-DATA
;DIAGNOSTIC FUNCTION. THE CALL REQUIRES THE
;DIAGNOSTIC FUNCTION TO BE EXECUTED TO BE IN
;REGISTER R0,RIGHT JUSTIFIED
;CALLING SEQUENCE:
; CALL-1: MOV #DIAG FUNCTION,R0
; CALL: DFXCT
;DIAGNOSTIC FUNCTION EXECUTE, TRAILING PARAMETER
$DXCTT: MOV @$EMADR,R0 ;PICKUP TRAILING PARAMETER
ADD #2,12(SP) ;SKIP RETURN
BR $DFXCT
;DIAGNOSTIC FUNCTION EXECUTE, SINGLE STEP KL10 CLOCK
$DFSCLK:CLR KLCLKR ;CLEAR KL10 CLOCK RUNNING
MOV #DCOMST!DFUNC!<SSCLK*1000>,@.DIAG1
BR $$DFX1
;DIAGNOSTIC FUNCTION EXECUTE
$DFXCT: CMP R0,#001 ;KL10 CLOCK START FUNCTION ?
BEQ 1$ ;YES
CMP R0,#007 ;ANY OTHER CLOCK CONTROL FUNCTION ?
BGT 2$ ;NO
CLR KLCLKR ;YES, CLEAR LOGICAL CLOCK RUN FLAG
BR 2$
1$: MOV #-1,KLCLKR ;CLOCK START, SET LOGICAL CLOCK RUN FLAG
2$: ASL R0 ;MAKE DIAG FCN IN CORRECT BITS
SWAB R0 ;MAKE DIAG FCN IN CORRECT BYTE
BIS #DCOMST!DFUNC,R0 ;SET CORRECT DTE20 BITS
MOV R0,@.DIAG1 ;EXECUTE THE FUNCTION
$$DFX1: WFZERO DCOMST ;WAIT FOR DONE
EXIT ;RETURN
;DIAGNOSTIC FUNCTION EXECUTE, FAST
$DFXFST:ASL R0 ;DIAG FUNCTION TO CORRECT BITS
SWAB R0
BIS #DCOMST!DFUNC,R0
MOV R0,@.DIAG1 ;EXECUTE THE FUNCTION
BR $$DFXDN
;KL10 CLOCK RUNNING CONTROLS
$KLCK1: TST KLCLKR ;KL10 CLOCK RUNNING ?
BEQ $KLCK4 ;NO
MOV #DCOMST!DFUNC!<STPCLK*1000>,@.DIAG1
$$DFXDN:
$KLCK3: WFZERO DCOMST
$KLCK4: RTS PC
$KLCK2: TST KLCLKR ;WAS CLOCK RUNNING ?
BEQ $KLCK4 ;NO
MOV #DCOMST!DFUNC!<STRCLK*1000>,@.DIAG1
BR $KLCK3
FFDEP: DEP ;DTE20 DEPOSIT/EXAM BIT
;DIAGNOSTIC FUNCTION, WRITE IR
$DFWIR: DFWRT ;THE LOAD AR FUNCTION IS ALREADY SETUP
MOV #DCOMST!DFUNC!<IRLOAD*1000>,@.DIAG1
JSR PC,$$DFXDN ;STROBE DATA FROM AD TO IR
EXIT
.SBTTL ROUTINE TO WRITE 36 BITS TO THE EBUS
;THIS IS THE ROUTINE TO WRITE 36 BITS TO THE EBUS
;THE ROUTINE REQUIRES THAT THE ADDRESS OF THE DATA
;TO BE WRITTEN IS IN REGISTER R1. THE DIAGNOSTIC
;FUNCTION WHICH DOES THE WRITE MUST BE RIGHT
;JUSTIFIED IN REGISTER R0.THE DATA TO BE WRITTEN MUST
;BE IN 5 CONSECUTIVE BYTES AS FOLLOWS:
; .BYTE EBUS BITS 28-35
; .BYTE EBUS BITS 20-27
; .BYTE EBUS BITS 12-19
; .BYTE EBUS BITS 04-11
; .BYTE EBUS BITS 00-03
;CALLING SEQUENCE:
; CALL-2: MOV #ADDR,R1
; CALL-1: MOV #DIAG FCN,R0
; CALL: DFWRT
$DFWRT: JSR PC,$KLCK1 ;KL10 CLOCK RUNNING ?
PUSH R1 ;SAVE DESTINATION FOR POSTERITY
BIT #1,R1 ;DATA ON WORD BOUNDRY ?
BEQ 2$ ;YES
MOV #XXDAT,R5
MOVB (R1)+,(R5)+ ;PUT BITS 28-35 INTO CORE WORD
MOVB (R1)+,(R5)+ ;PUT BITS 20-27 INTO CORE
MOV -(R5),@.DAT3 ;PUT BITS 20-35 INTO DTE20
MOVB (R1)+,(R5)+ ;PUT BITS 12-19 INTO CORE WORD
MOVB (R1)+,(R5)+ ;PUT BITS 4-11 INTO CORE WORD
MOV -(R5),@.DAT2 ;PUT BITS 4-19 INTO DTE20
MOVB (R1)+,(R5) ;PUT BITS 0-3 INTO CORE WORD
BIC #177760,(R5) ;OFF TRASH
MOV (R5),@.DAT1 ;BITS 0-3 INTO DTE20
1$: MOV #DIKL10!DSEND,@.DIAG1 ;SET BIT TO DIAGNOSE KL10
MOV FFDEP,@.TENA1 ;SET DEPOSIT BIT OF DTE20
MOV FFDEP,@.TENA2 ;DO A PSEUDO DEPOSIT
WFONE DEXDON ;WAIT FOR A FLAG
ASL R0 ;GET DIAG FCN IN BIT POSITION
SWAB R0 ;GET DIAG FCN IN BYTE POSITION
BIS #DCOMST!DSEND!DIKL10!DFUNC,R0 ;SET DTE20 BITS
MOV R0,@.DIAG1 ;EXECUTE THE DIAGNOSTIC FUNCTION
POP R0 ;RESTORE WHERE GOT DATA
JMP $DFXX ;WAIT FOR DONE & EXIT
2$: MOV (R1)+,@.DAT3 ;BITS 20-35
MOV (R1)+,@.DAT2 ;BITS 4-19
MOV (R1),@.DAT1 ;BITS 0-3
BR 1$
.SBTTL ROUTINE TO DO EBUS READ, THEN STORE DATA SOMEPLACE
;ENTER THIS ROUTINE WITH R0 CONTAINING DIAGNOSTIC FUNCTION TO EXECUTE
;AND R1 CONTAINING ADDRESS OF BUFFER WHERE DATA SHOULD BE PLACED
$DFRDMV:DFRD ;GO READ KL10 DATA
PUSH R1 ;SAVE DESTINATION
MOV .DAT3,R0 ;GET ADDRESS OF DTE20 REG
MOVB (R0)+,(R1)+ ;DATA FROM DTE TO CORE
MOVB (R0)+,(R1)+ ;DATA FROM DTE TO CORE
MOVB (R0)+,(R1)+ ;DATA FROM DTE TO CORE
MOVB (R0)+,(R1)+ ;DATA FROM DTE TO CORE
MOVB (R0)+,(R1)+ ;DATA FROM DTE TO CORE
POP R0 ;RESTORE REG R1
EXIT
;DIAGNOSTIC FUNCTION WRITE, TRAILING PARAMETER
$DWRTT: MOV $EMADR,R5
MOV (R5)+,R1 ;DATA ADDRESS TO R1
MOV (R5),R0 ;DIAG FUNCTION TO R0
ADD #4,12(SP) ;RETURN OVER TRAILING PARAMETERS
BR $DFWRT
.SBTTL MASTER RESET ROUTINE
;THIS IS A ROUTINE TO DO A MASTER RESET.
$MRESET:PUSH R0 ;SAVE REGISTERS
TST TENRUN ;PDP-10 PRESENTLY RUNNING ?
BEQ 90$ ;BR IF NOT
TENSP ;STOP TEN
CLR TENCLK ;NOW TEN MUST NOT NEED CLOCK INTERRUPTS ANY MORE
90$: MOV #DRESET,@.DIAG2 ;CLEAR DTE20 DIAG2
MOV #DON10C!ERR10C!INT11C!PERCLR!DON11C!ERR11C,@.STDTE ;CLEAR DTE20 STATUS
DFWRTT ;WRITE TO CLOCK
CLKDFL ;SET CLOCK TO DEFAULT
LDSEL
CLR KLCLKR ;CLEAR KL10 CLOCK RUNNING
MOV #LLISTL,R1 ;MUST EXECUTE TEN DIAG FUNCTIONS IN MR
MOV #LLIST,R2 ;ADDRESS OF FUNCTIONS INTO R2
1$: MOVB (R2)+,R0 ;FUNCTION TO R0 FOR THE EXECUTE CALL
JSR PC,$DFXFST ;EXECUTE THE DIAGNOSTIC FUNCTION
DEC R1 ;DECREMENT COUNT OF # OF FUNCTIONS LEFT
BNE 1$ ;CONTINUE TILL DONE
MOV #3,R4 ;SYNC MBOX NXM LOGIC
2$: DFRDT ;TEST A CHANGE COMING L
162
BIT #BIT3,@.DAT3
BEQ 3$ ;ASSERTED, CONTINUE
MOV #DCOMST!DFUNC!<SSCLK*1000>,@.DIAG1
JSR PC,$$DFXDN ;DO ONE MBOX CLOCK
DEC R4 ;DONE 3 CLOCKS ?
BGT 2$ ;NO, TRY AGAIN
3$: MOV #DCOMST!DFUNC!<CECLK*1000>,@.DIAG1
JSR PC,$$DFXDN ;CONDITIONAL EBOX CLOCK
MOV #DCOMST!DFUNC!<CLRMR*1000>,@.DIAG1
JSR PC,$$DFXDN ;CLEAR MR
MOVB (R2)+,R0
JSR PC,$DFXFST ;SET IR DECODE
MOVB (R2)+,R0 ;GET THE NEXT FUNCTION FROM THE LIST
MOV #WREADY,R1 ;CLEAR A 36 BIT BUFFER FOR SENDING DATA
MOV R1,R5
CLR (R5)+ ;CLEAR A WORK AREA
CLR (R5)+
CLR (R5)
DFWRT ;WRITE 0'S TO EBUS & PREVENT SBUS RESET
MOVB #12,(R1)
MOVB (R2)+,R0 ;GET NEXT DIAG FUNCTION
DFWRT ;LOAD MEMORY TO CACHE SELECTOR
POP R0
EXIT
;MASTER RESET DIAGNOSTIC FUNCTION LIST
LLIST: .BYTE STPCLK ;STOP CLOCK
.BYTE SETMR ;SET MASTER RESET
.BYTE STRCLK ;START CLOCK
.BYTE LDBRR ;LOAD BURST REGISTER RIGHT
.BYTE LDBRL ;LOAD BURST REGISTER LEFT
.BYTE LDDIS ;LOAD CLOCK DISTRIBUTION REGISTER
.BYTE LDCHK1 ;LOAD PARITY CHECK REGISTER
.BYTE LDCHK2 ;LOAD EBOX INTERNAL CHECK REGISTER
.BYTE LDCHAN ;INITIALIZE CHANNELS
.BYTE STPCLK ;STOP CLOCK
LLISTL==.-LLIST ;BUT THE LAST 3 ARE SPECIAL
.BYTE ENIOJA ;SET IR DECODE TO KL10 MODE
.BYTE 76 ;D.F. TO CONTROL EBUS REG
.BYTE LDMBXA ;LOAD MEMORY TO CACHE SELECTOR
.EVEN
.SBTTL CONTROL RAM ADDRESS ROUTINE
$WWADR: PUSH R1 ;SAVE R1
TST R0 ;IF BIT 15 SET, AVOID MASTER RESET
BMI 1$
BIT #BIT14,R0 ;IF BIT 14 SET, SPECIAL RESET
BEQ 2$
JSR PC,$SPCMR ;SPECIAL MASTER RESET
BR 1$
2$: MRESET
1$: BIC #BIT15!BIT14,R0 ;CLEAR CONTROL BITS ANYWAY
MOV #WREADY+2,R5
CLR (R5) ;CLEAR A WORK AREA
CLR -(R5)
PUSH R0
JSR PC,99$ ;GO LOAD EBUS BITS 00-05
MOV #LCRDAL,R0 ;WILL WRITE BITS 00-04 OF CR-ADR
DFWRT
POP R0 ;GET COPY OF ORIGINAL CR-ADR
SWAB R0 ;GET BITS 00-04
ASR R0 ;TO LOW ORDER BITS
ASR R0 ;OF R0.
JSR PC,99$ ;GO LOAD EBUS BITS 00-05
MOV #LCRDAR,R0 ;WILL WRITE BITS 5-10 OF CRADR
DFWRT
POP R1 ;RESTORE R1
EXIT
99$: BIC #77,R0 ;DEAL ONLY WITH 6 BITS
MOVB R0,WREADY+3 ;MOV TO EBUS BITS 4 & 5
SWAB R0
MOVB R0,WREADY+4 ;MOV TO EBUS BITS 0,1,2, & 3
MOV R5,R1 ;ADDRESS FOR DFWRT
RTS PC
.SBTTL WCRAM ROUTINE
$WCRAM: MOV R1,R2 ;GET COPY OF DATA ADDRESS
WWADR ;GO AND WRITE C-RAM ADDRESS
MOV #3,R4 ;FOUR LOOPS PER C-RAM WORD
1$: MOV #WREADY,R1 ;GET HOLDING AREA
MOVB (R2)+,(R1)+ ;REAL DATA TO HOLDING AREA
MOVB (R2)+,(R1)+
MOVB (R2),(R1)+
TST SIGNL ;SEE IF DESIRED BITS ON WORD BOUNDARY
BEQ 3$ ;AVOID RORING CODE IF YES
;THIS IS WONDERFUL RORING CODE
TSTB (R2)+ ;MUST INCREMENT DATA ADDR PTR
MOV #4,R0 ;FOUR SHIFTS IN THIS LOOP
2$: MOV #WREADY+3,R1 ;POINT TO HOLDING AREA
RORB -(R1) ;SHIFT & INCLUDE "C" BIT
RORB -(R1)
RORB -(R1)
DEC R0 ;DONE?
BNE 2$ ;LOOP BACK IF NO
;COMMON CODE
3$: COM SIGNL ;CHANGE BOUNDARY FLAG
BIC #177760,WREADY+2 ;ONLY 4 BITS COUNT
4$: JSR PC,$STRCH ;GO FILL IN EBUS SPACE
MOVB WRLIST(R4),R0 ;CORRECT WRITE FUNCTION TO R0
MOV #WREADY,R1 ;ADDRESS OF DATA
DFWRT
DEC R4 ;DONE ENTIRE RAM WORD?
BGE 1$ ;BR BACK IFNO
;CODE TO LOAD DISP 00-04
MOVB (R2),WREADY+4 ;GET DATA FOR DISP
ASRB WREADY+4 ;SHIFT DATA
RORB WREADY+3 ;TO EBUS BITS
ASRB WREADY+4 ;00-05
RORB WREADY+3
DFWRTT ;WRITE
WREADY ;DATA ADDRESS
LCRAM5 ;DIAG FUNCTION
EXIT ;DONE
WRLIST: .BYTE LCRAM1 ;CRAM BITS 00-19
.BYTE LCRAM2 ;CRAM BITS 20-39
.BYTE LCRAM3 ;CRAM BITS 40-59
.BYTE LCRAM4 ;CRAM BITS 60-79-EVEN
.EVEN
$STRCH: MOV WREADY,R0 ;GET UNSPACED DATA
MOVB WREADY+2,WREADY+3 ;PUT C-RAM 0-3 BITS INTO CORRECT CORE
CLR R3 ;NO JUNK LEFT IN R3
SEC ;SET "C" BIT TO USE AS FLAG
1$: MOV #4,R5 ;FOUR SHIFTS BETWEEN BLANKS
2$: ROR R3 ;NEW DATA LEFT END OF DESTINATION
BCS 3$ ;IF FLAG FALLS OUT..DONE
ROR R0 ;ROTATE SOURCE BITS RIGHT
DEC R5 ;DONE 4 YET??
BGE 2$ ;BR IF NO
ROL R0 ;REPAIR ANY DAMAGES
CLC ;ZERO THE "C" BIT
ROR R3 ;AND ROLL ZEROES
BR 1$ ;AND CONTINUE
;GET HERE TO FINISH UP
3$: CLC ;ZERO "C" BIT AGAIN
ROL R0 ;BITS 4-7
ROL R0 ;MUST BE CORRECTED
MOV R3,WREADY ;BITS 8-19 INTO CORE
MOVB R0,WREADY+2 ;BITS 4-7 INTO CORE
RTS PC ;DONE
;SPECIAL BASIC MASTER RESET
$SPCMR: PUSH <R0,R1,R2>
CLR KLCLKR ;CLEAR KL10 CLOCK RUNNING
MOV #$SMRLST,R1 ;COMMAND ADR TO R1
MOV #4,R2 ;FOUR COMMANDS
1$: MOV (R1)+,@.DIAG1
JSR PC,$$DFXDN ;EXECUTE FUNCTION
DEC R2
BNE 1$
POP <R2,R1,R0>
RTS PC
$SMRLST:.WORD DCOMST!DFUNC!<SETMR*1000>
.WORD DCOMST!DFUNC!<STRCLK*1000>
.WORD DCOMST!DFUNC!<STPCLK*1000>
.WORD DCOMST!DFUNC!<CLRMR*1000>
.SBTTL RCRAM ROUTINE
$RCRAM: TST R0 ;IS R0 NEG
BMI 1$ ;READ CURRENT CR IF YES
WWADR ;EXAMINE ADDRESS IN R0 IF HERE
MOV #DCOMST!DFUNC!<SECLK*1000>,@.DIAG1
JSR PC,$$DFXDN ;CLOCK ADDRESS CONTENTS TO C.R.
1$: MOV #$BUFRC+10.,R3 ;GET BUFFER ADDR FOR C-RAM CONTENTS
MOV #$RDLST,R4 ;GET DIAG FUNCTION LIST
2$: MOVB (R4)+,R0 ;DIAG FUNCTION
DFRD
MOV #WREADY,R1 ;DESTINATION OF READ/MOVE
MOV .DAT3,R0
MOV (R0)+,(R1)+
MOV (R0)+,(R1)+
MOV (R0),(R1)
JSR PC,$SQASH ;GO CLEAR OUT BLANKS
MOV #WREADY+3,R0 ;ADDRESS OF DATA JUST READ
MOVB -(R0),-(R3) ;BITS 16-19 TO BUFFER
TST SIGNL2 ;CHECK TRAFFIC LIGHT
BNE 4$ ;BR TO RORING IF WRONG BOUNDARY
3$: MOVB -(R0),-(R3) ;BITS 20-27 TO WORK AREA
MOVB -(R0),-(R3) ;BITS 28-35 TO WORK AREA
COM SIGNL2 ;CHANGE SIGNAL
BR 2$ ;GET MORE DATA
4$: ASLB (R3) ;NEED TO FIX A HALF BYTE
ASLB (R3)
ASLB (R3)
ASLB (R3)
PUSH R0 ;DON'T LOSE DATA ADDRESS
MOV #4,R0 ;DO NEXT LOOP FOUR TIMES
10$: MOV R3,R2 ;ADDRESS OF DATA TO R2
ROLB (R2)+ ;SHIFT AND DON'T FORGET "C"
ROLB (R2)+
ROLB (R2)+
ROLB (R2)+
DEC R0 ;ASSEMBLED COMPLETE HALF BYTE
BNE 10$ ;LOOP AGAIN IF NO
POP R0 ;RETRIEVE DATA ADDRESS
TSTB (R3)+ ;FIX DESTINATION ADDRESS
TST SIGNL3 ;CHECK SIGNAL
BNE 15$ ;DONE IF MINUS
COM SIGNL3 ;OTHERWISE CHANGE SIGNAL
BR 3$ ;CONTINUE
15$: MOVB WREADY+1,-(R3) ;ENDING UP
MOVB WREADY,-(R3) ;CRAM BITS 0-15 TO BUFFER
COM SIGNL3 ;SIGNL3 TO ZERO
COM SIGNL2 ;SIGNL2 TO ZERO
DFRDT
RCSPEC ;READ SPEC FIELD
MOV @.DAT2,R1 ;GET DISP 03,04
MOV @.DAT1,R0 ;GET DISP 00,01,02
ROL R1 ;JUSTIFY IN R0
ROL R0
ROL R1
ROL R0
BIC #177740,R0 ;CLEAR TRASH
MOVB R0,$BUFRC+12 ;SAVE IN BUFFER
MOV #$BUFRC+2,R0 ;RETURN DATA ADDRESS IN R0
BIC #5,(R0) ;CLEAR PARITY BITS
BIC #52525,-(R0) ;AND FIX ADDRESS
EXIT ;DONE
$RDLST: .BYTE RCRAM1 ;READ CRAM 0-19
.BYTE RCRAM2 ;READ CRAM 20-39
.BYTE RCRAM3 ;READ CRAM 40-59
.BYTE RCRAM4 ;READ CRAM 60-79-EVEN
$SQASH: MOV WREADY,R1 ;GET STRETCHED BITS 8-19
MOV WREADY+2,R2 ;GET STRECHED BITS 0-7
CLR R0 ;CLEAR A DESTINATION
SEC ;SET A DONE FLAG
ROR R0 ;AND ROLLIT INTO R0
1$: MOV #4,R5 ;FOUR BITS PER GROUP
2$: DEC R5 ;DONE A GROUP OF FOUR
BLT 20$ ;BRANCH IF NO
ASR R2 ;ROTATE SOURCE BITS RIGHT
ROR R1 ;ALL TWENTY OF THEM
ROR R0 ;BEGIN WITH FIRST FLAG INTO R0
BCC 2$ ;IF FLAG FALLS OUT..DONE
;HERE TO FINISH UP
ASR R1 ;MAKE LAST BLANKS
ASR R1 ;GO VERY FAR AWAY
MOV R0,WREADY ;STORE RESULTS IN CORE
MOV R1,WREADY+2 ;ALL DONE
RTS PC ;RETURN
20$: ASR R2 ;HERE TO SHIFT AWAY
ROR R1 ;THE PAIR
ASR R2 ;OF BLANKS HIDDEN
ROR R1 ;AMIDST THE REAL DATA
BR 1$ ;CONTINUE
.SBTTL MICNUL, FILL C-RAM LOCATIONS WITH ZEROS
$MICNUL:MOV R1,R2 ;NUMBER OF WORDS TO R2
MOV R0,R3 ;SAVE START ADDRESS
BIS #100000,R3 ;BYPASS MR AFTER FIRST TIME
MOV #ZEROS,R1
1$: WWADR ;WRITE C-RAM ADDRESS
MOV #3,R4
MOVB #LCRAM1,R0 ;1ST FUNCTION IS A WRITE
DFWRT
2$: MOVB FLST(R4),R0 ;DIAG FUNCTION
JSR PC,$DFXFST
DEC R4
BGE 2$ ;ZERO ALL BITS
INC R3 ;INCREMENT C-RAM ADDRESS
MOV R3,R0
DEC R2 ;FINISHED ALL WORDS YET ?
BGT 1$
10$: EXIT ;YES
FLST: .BYTE LCRAM5
.BYTE LCRAM4
.BYTE LCRAM3
.BYTE LCRAM2
.BYTE LCRAM1
.EVEN
.SBTTL MICFIL, C-RAM FILL WITH ONES ROUTINE
$MICFIL:MOV R1,R2 ;NUMBER OF WORDS TO R2
MOV R0,R3 ;SAVE ADDRESS
BIS #100000,R3 ;BYPASS MR AFTER FIRST TIME
MOV #TENMO,R1 ;36 BITS OF ONES
1$: WWADR ;WRITE C-RAM ADDRESS
MOV #4,R4
2$: MOVB FLST(R4),R0 ;DIAG FUNCTION
DFWRT
DEC R4 ;DO ALL BITS
BGE 2$
INC R3 ;INCREMENT C-RAM ADDRESS
MOV R3,R0
DEC R2 ;DONE ALL ADDRESSES YET ?
BGT 1$
10$: EXIT
.SBTTL WDRAM ROUTINE
$WDRAM: MOV R0,R2 ;COPY DRAM ADDRESS
ROR R0 ;CHECK IF ODD OR EVEN
BCC 1$ ;BR IF EVEN
JMP ADRERR ;ADDRESS ERROR IF ODD
1$: ROL R0 ;FIX ADDRESS
PUSH R1 ;SAVE POINTER TO DATA
DRAMAD ;GO WRITE DRAM ADDRESS
POP R3 ;PUT POINTER TO DATA IN R3
MOV (R3)+,R1 ;DATA INTO R1
JSR R5,DATEVE ;WRITE EVEN DATA
MOV (R3)+,R1 ;DATA INTO R1
JSR R5,DATODD ;WRITE ODD DATA
MOV (R3),R1 ;DATA INTO R1
JSR R5,DATCOM ;WRITE COMMON DATA
EXIT
.SBTTL RDRAM ROUTINE
$RDRAM: PUSH <R1,R0> ;SAVE R1,STORE DRAM ADDR ON STACK TOP
CLR R1 ;R1 IS AN INDEX COUNTER
1$: DRAMAD ;WRITE DRAM ADDRESS
MOV #DCOMST!DFUNC!<DRLTCH*1000>,@.DIAG1
JSR PC,$$DFXDN ;STROBE DATA TO LATCHES
DFRDT
DRJ710 ;FUNCTION TO READ J07,08,09,10
MOV @.DAT2,R0 ;GET J DATA 7-10
ASR R0 ;RIGHT JUSTIFY
ASR R0 ;J-FIELD DATA
BIC #177700,R0 ;CLEAR EXTRA
MOVB R0,RDRTMP(R1) ;SAVE DATA IN CORE
INC R1 ;INCREMENT INDEX
DFRDT
DRAMAB ;FUNCTION TO READ "A" & "B" FIELD
MOV @.DAT2,R0 ;GET A & B DATA
ASR R0 ;RIGHT JUSTIFY
ASR R0 ;IN R0
BIC #177700,R0 ;CLEAR EXTRA
MOVB R0,RDRTMP(R1) ;STORE IN CORE
INC R1 ;INCREMENT INDEX
;DECIDE IF THIS IS FIRST OR SECOND PASS
CMP R1,#3 ;INDEX UP TO 3 YET??
BGE 2$ ;ON OUT IF YES
POP R0 ;IF NO,GET DRAM ADDRESS
INC R0 ;GET ODD HALF OF EVEN/ODD PAIR
BR 1$ ;LOOP AGAIN
2$: DFRDT
DRJ1.4 ;FUNCTION TO READ J01-J04
MOV @.DAT2,R0 ;GET JDATA 01-04
ASR R0 ;RIGHT JUSTIFY
ASR R0 ;J1-J4 BITS
BIC #177760,R0 ;CLEAR UNWANTED
MOVB R0,RDRTMP+4 ;BIT SET TO CORE
MOV #RDRTMP,R0 ;PASS BACK DATA ADDRESS IN R0
POP R1 ;RESTORE R
EXIT
.SBTTL DRAM SUBROUTINES
$DRAMAD: MOV #DDRAM,R3 ;GET ADDRESS OF EBUS DATA
MOV R3,R4 ;GET A COPY IN R4
CMPB (R4)+,(R4)+ ;INCREMENT IT TO DDRAM+2
MOV R0,R2 ;PUT ACTUAL ADDRESS IN R2
COM R2 ;READY TO TEST ADDR BITS 0-2
BIT #700,R2 ;MAKE THE TEST
BEQ 1$ ;BR IF ADDR IS 7XX
;CODE FOR NON 7XX ADDRESSES
COM R2 ;WAS NOT 7XX,SO FIX ADDRESS
ASL R2 ;JUSTIFY ADDRESS IN
ASL R2 ;CORRECT BIT POSITION
ASL R2 ;NEED THREE SHIFTS
CLRB (R4)+ ;INCREMENT TO DDRAM+3
MOVB R2,(R4)+ ;MOVE ADDR BITS 4-8 TO EBUS DATA
SWAB R2 ;GET THE REST OF THE BITS
MOVB R2,(R4) ;MOVE ADDR BITS 0-3 TO EBUS DATA
4$: JSR PC,$SPCMR ;SPECIAL MASTER RESET
JSR R5,WIRAR ;GO TO DO THE ACTUAL WRITE
EXIT
;CODE FOR 7XX ADRESSES
1$: COM R2 ;FIX ADDRESS TO ORIGINAL STATE
ROR R2 ;PUT LOW ORDER BIT IN "C" BIT
BCS 2$ ;"C" SET MEANS IR BIT 12 MUST=1
CLRB (R4)+ ;NO "C" BIT MEANS IR BIT 12 MUST=0
BR 3$ ;GO TO MOVE ADDRESS TO EBUS DATA
2$: MOVB #200,(R4)+ ;SET IR BIT 12=1
3$: BIC #340,R2
MOVB R2,(R4)+ ;MOVE D-RAM ADDR TO EBUS BIT POSITION 7-11
MOVB #16,(R4) ;SET THE 7 FROM 7XX IN EBUS DATA
BR 4$
;WRITE THE IR
WIRAR: MOV #DDRAM,R1 ;EBUS DATA ALWAYS AT DDRAM
WIRAR1: MOV #LDAR,R0 ;FUNCTION TO LOAD AR
DFWIR
RTS R5
;NOW FOR COMMON LITTLE PIECES OF THE LOADING OF THE DRAM
DATCOM: MOV #LDRAM3,R0 ;GET DIAG FUN TO WRITE COMMON
ASL R1 ;JUSTIFY DATA FOR THE EBUS
ASL R1
BR CON2 ;GO WRITE IT
DATODD: MOV #LDRAM2,$DDRMS ;FUNCTION FOR J-FIELD A & B
MOV #LDRJOD,R0 ;FUNCTION FOR J-FIELD ODD
BR CON1 ;GO
DATEVE: MOV #LDRAM1,$DDRMS ;FUNCTION FOR J-FIELD A & B
MOV #LDRJEV,R0 ;FUNCTION J-FIELD EVEN
CON1: ASL R1 ;JUSTIFY PIECE I'M
ASL R1 ;INTERESTED IN FOR J-DATA FIELDS
PUSH R1 ;SAVE DATA TO BE SENT
JSR R5,CON2 ;WRITE J-DATA
POP R1 ;GET DATA AGAIN
SWAB R1 ;NOW I'VE GOT A & B
MOV $DDRMS,R0 ;GET CORRECT DIAG FUNCTION, & WRITE
CON2: MOVB R1,DDRAM+2 ;R1 ALWAYS HAS THE DATA
MOV #DDRAM,R1 ;I ALWAYS PUT IT IN DDRAM
DFWRT
RTS R5 ;NOW WRITE
;CLOCK DEFAULT PARAMETER ADDRESS
$CLKPRM:MOV #CLKDFL,R0 ;PUT ADDRESS IN R0
EXIT
.SBTTL M-BOX CLOCK BURST ROUTINE
$BURST: CLR KLCLKR ;CLEAR KL10 CLOCK RUNNING
MOV #$STDAT,R1 ;WORD POINTER TO R1
MOV R0,R2 ;BURST COUNT TO R2
BIC #177600,R2 ;SAVE LOWER 7 BITS
ROL R0
SWAB R0
CLR R3
BISB R0,R3 ;# OF 128. CLOCK MULTIPLES
BEQ 2$ ;NONE, DO BURST
1$: MOV #DCOMST!DFUNC!<STPCLK*1000>,@.DIAG1
JSR PC,$$DFXDN ;CLEAR BURST MODE
CLR (R1)
MOV #LDBRR,R0
DFWRT ;CLEAR BURST REG RIGHT
MOV #10,(R1)
MOV #LDBRL,R0
DFWRT ;LOAD BURST REG LEFT
MOV #DCOMST!DFUNC!<BRCLK*1000>,@.DIAG1
JSR PC,$$DFXDN ;BURST 128 CLOCKS
DEC R3 ;ANY MORE ?
BGT 1$ ;YES, DO 128 MORE
2$: MOV #DCOMST!DFUNC!<STPCLK*1000>,@.DIAG1
JSR PC,$$DFXDN ;CLEAR BURST MODE
MOV R2,R3 ;NUMBER LEFT TO DO
BIC #177760,R2
MOV R2,(R1)
MOV #LDBRR,R0
DFWRT ;LOAD BURST REG RIGHT
SR R3,4
MOV R3,(R1)
MOV #LDBRL,R0
DFWRT ;LOAD BURST REG LEFT
MOV #DCOMST!DFUNC!<BRCLK*1000>,@.DIAG1
JSR PC,$$DFXDN ;BURST THE CLOCK
EXIT
.SBTTL LOAD AR ROUTINE
; ROUTINE TO LOAD THE AR WITH AN INSTRUCTION TO BE EXECUTED.
; GETS THE MICROCODE TO THE HALT LOOP, AND THEN LINES UP THE
; MBOX PHASE CHANGE TIMING WITH EBOX SYNC BEFORE LOADING
; THE AR. THE LATTER IS NECCESSARY IN ORDER TO MAKE INSTRUCTION
; EXECUTION REPEATABLE AT THE CLOCK TICK LEVEL FOR "TRACE" AND
; FOR THE MBOX DIAGNOSTIC.
$LODAR: MOV R0,R3 ;SAVE DATA POINTER
MOV #DCOMST!DFUNC!<CLRRUN*1000>,@.DIAG1
JSR PC,$$DFXDN ;STOP EXECUTION
MOV #177,R0
BURST ;RUN CLOCK FOR FIXED PERIOD
MOV #DCOMST!DFUNC!<CECLK*1000>,@.DIAG1
JSR PC,$$DFXDN ;GET EBOX CLOCK FALSE
BIT #HALTLP,@.DIAG1
BNE 1$ ;IF AT HALT LOOP
3$: EXITERR
; NOW CALL ROUTINE TO GET MBOX IN PHASE
1$: JSR PC,$MBPHS
BCC 2$ ;BR IF ALL OK
BR 3$
2$: MOV R3,R1
MOV #LDAR,R0
DFWRT ;LOAD AR
EXIT
; SETMPH EMT ROUTINE TO SELECT WHICH MBOX PHASE TO SYNC UP TO
;DURING THE LODAR PROCESS. R0 SELECTS ONE OF FOUR PLACES TO SYNC.
; R0 = 0, A CHANGE COMING; R0 = 1, HALFWAY TWIXT A AND B
; R0 = 2, B CHANGE COMING; R0 = 3, HALFWAY TWIXT B AND A.
$SETMPH:MOV R0,$STODD ;SAVE FOR HALF-PHASE TEST
BIC #BIT0,R0 ;CLR ODD-EVEN BIT
MOV $STMTB(R0),$MPHDF ;SET POINTER
EXIT
$STMTB: .BYTE 162,10 ;A CHANGE COMING DF AND MASK
.BYTE 163,200 ;B CHANGE COMING DF AND MASK
.SBTTL MBOX PHASE ROUTINE
; ROUTINE TO PHASE THE MBOX WITH THE EBOX HALT LOOP.
; MICROCODE ASSUMPTIONS: THE HALT LOOP IS TWO INSTRUCTIONS
; THE FIRST IS AT AN EVEN ADDRESS AND HAS T=2T
; THE SECOND IS AT AN ODD ADDRESS AND HAS T=3T
; THIS CODE LOOKS FOR THE INTERSECTION OF THE EVEN ADDRESS,
; CLK SYNC TRUE, PHASE CHANGE COMING TRUE, AND THE SELECTED
; PHASE (A OR B CHANGE COMING). THE LATTER IS CHOSEN BY
; THE "SETMPH" EMT.
$MBPHS: MOV #20.,R2 ;SET TIMOUT VALUE
1$: MOV #1,R1 ;SET TICK COUNTER
DFRDT
102
BIT #BIT2,@.DAT3 ;BIT 33, CLK SYNC H
BEQ 41$ ;FALSE, TRY 1 CLOCK
DFRDT
144
BIT #BIT14,@.DAT2 ;BIT 5, CR ADR 10 H
BNE 42$ ;ODD, TRY 2 CLOCKS
DFRDT
164
BIT #BIT5,@.DAT3 ;BIT 30,PHASE CHANGE COMING L
BNE 45$ ;FALSE, TRY 5 CLOCKS
MOVB $MPHDF,R0
DFRD
CLR R0
BITB $MPHMK,@.DAT3 ;EITHER A OR B CHANGE COMING L
BEQ 2$ ;TRUE, EXIT
MOV #10.,R0 ;NEED 10 CLOCKS
2$: BIT #BIT0,$STODD ;WANT HALFWAY BETWEEN?
BEQ 3$ ;BR IF NOT
ADD #5,R0 ;FIVE MORE TICKS THEN
3$: BURST ;DO THIS BURST:0,5,10, OR 15
CLC
RTS PC ;WE'RE THERE
45$: ADD #3,R1 ;MAKE IT FOUR
42$: INC R1 ;MAKE IT TWO OR FIVE
41$: MOV R1,R0
BURST ;DO ONE TWO OR FIVE
DEC R2 ;COUNT TIMEOUT
BNE 1$
SEC
RTS PC ;TOOK TOO LONG, ERROR
.SBTTL VMA, VMAH, PC & ADDRESS BREAK ROUTINE
;ROUTINE TO READ ONE OF 4 REGISTERS ON THE VMA BOARD.
;ROUTINE RETURNS WITH R0 POINTING TO A 36 BIT WORD WITH
;THE DESIRED DATA JUSTIFIED AT BIT 35
$DFVMH: MOV #DPVMHD,R0 ;FUNCTION TO READ VMA HELD
BR $DFPC1
$DFPC: MOV #DPPC,R0 ;FUNCTION TO READ PC
$DFPC1: MOV #3,R5
MOV #273,R4 ;MASK FOR REGISTER OFFSET FROM BIT 35
BR $VMPC
$DFVMA: MOV #DPVMA,R0 ;DIAG FUNCTION TO READ VMA
BR $VMPC1
$DFADB: MOV #DPADB,R0 ;DIAG FUNCTION TO READ ADDRESS BREAK
$VMPC1: MOV #356,R4
CLR R5
$VMPC: PUSH R0
MOV #4,R2 ;FOUR READS PER REGISTER
MOV #VMADAT,R1 ;FIRST CLEAR ENTIRE 36-BIT BUFFER
CLR (R1)+
CLR (R1)+
CLR (R1)+
1$: MOV #WREADY,R1 ;PUT DFRD DATA HERE
DFRDMV
MOV #5,R0 ;MASK RECEIVED DATA, FIVE BYTES WORTH
2$: BICB R4,(R1)+
DEC R0
BGT 2$
MOV #WREADY+5,R1 ;NOW MOVE READ DATA
MOV #VMADAT+5,R0 ;TO VMA REGISTER DATA
BISB -(R1),-(R0)
BISB -(R1),-(R0)
BISB -(R1),-(R0)
BISB -(R1),-(R0)
BISB -(R1),-(R0)
ROLB (R0)+ ;AND NOW SHIFT 35 BITS
ROLB (R0)+ ;BY ONE BIT
ROLB (R0)+
ROLB (R0)+
ROLB (R0)+
DEC (SP) ;CREATE NEXT DIAG FUNCTION
MOV (SP),R0 ;TAKE IT OFF THE STACK
DEC R2 ;DONE FOUR FUNCTIONS YET?
BGT 1$ ;BR IF MORE TO DO
;ALL DONE READING DATA, NOW JUSTIFY CORRECTLY FOR THE RETURN MACHINE
3$: MOV #VMADAT+5,R0 ;MUST CORRECT BY OFFSET AMOUNT
RORB -(R0)
RORB -(R0)
RORB -(R0)
RORB -(R0)
RORB -(R0)
DEC R5 ;DONE YET?
BGT 3$ ;BR IF NO
;OFFSET MAY ORIGINALLY NEED TO BE GREATER THAN 0 IF
;VMA DIAG MIXERS NOT RIGHT JUSTIFIED AT EBUS BIT 35
4$: POP R0
MOV #VMADAT,R0
EXIT

322
src/kldcp/cdmp11.1 Executable file
View File

@@ -0,0 +1,322 @@
;;;MODIFICATION HISTORY
;;;
;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7)
;;; 15 NOV 75 CONVERTED TO PALX FORMAT
;;;
.SBTTL PDP-11 CORE DUMP, 4-SEPT-75
;CORE IMAGE CONVERTED TO ".A11" FORMAT
;CONSOLE COMMAND: "CD FILE START,END"
$CD: TTITRM
NAMEXT ;SETUP FILE NAME.EXT
TST R0 ;ANY EXT ?
BNE 1$ ;YES
MOV #"A1,EXTBF ;NO, USE ".A11"
MOV #"1 ,EXTBF+2
1$: TTOCTE ;INPUT DUMP START ADDRESS
MOV R0,R5
TTCOCT ;INPUT DUMP END ADDRESS
INC R0
BIC #1,R0
SUB R5,R0 ;COMPUTE DUMP WORD COUNT
BPL 99$
JMP $CDERR ;ADDRESSES BACKWARDS
99$: SR R0,1
INC R0
MOV R0,R4
TTBTRM ;VERIFY LINE TERMINATOR
PNTRST ;RESET OUTPUT POINTERS
PNTCI
';
MOV #6,R1
MOV #NAMBF,R2
JSR PC,$CDFID ;INSERT FILE NAME
PNTCI
'.
MOV #3,R1
MOV #EXTBF,R2
JSR PC,$CDFID ;INSERT FILE EXTENSION
TTBACK
TTICHR
CMPB #' ,R0
BEQ 3$
CMPB #' ,R0
BEQ 3$
2$: TST DEVTYP
BMI $CDACT ;ACT10
BNE $CDRP ;RP04
JMP $CDDTA ;DECTAPE
3$: PNTCI
"
4$: TTICHR
BCS $CDERR
CMPB #CR,R0
BEQ 2$
PNTCHR
BR 4$
$CDFID: MOVB (R2)+,R0
CMPB #' ,R0
BEQ 1$
PNTCHR
DEC R1
BNE $CDFID
1$: RTS PC
$CDRP: RPFILE ;FIND AND SETUP FILE
BCC 1$
JMP $NONXF
1$: MOV #DVBUF,CDADR ;SETUP BUFFER STORE ADDRESS
BR $CDDON
$CDACT: COMENQ
MOV #$INBUF,R0
COMCMD ;TRANSMIT COMMAND TO ACT10
CMPB #'A,R0
BNE $CDERR ;ERROR
BR $CDDON
$CORDMP:TTPINI ;INITIALIZE POINTERS
PNTCI ;LINE STARTS WITH "E" & "SPACE"
"E
MOV #16.,R3 ;SETUP ASCIIZED WORD COUNT
CMP R3,R4 ;THAT MANY WORDS LEFT IN DUMP ?
BLOS 1$
MOV R4,R3 ;NO, USE REMAINDER
1$: MOV R3,TEMP ;INIT CHECKSUM
MOV R3,R0 ;OUTPUT WORD COUNT
BIS #100,R0 ;WILL ALWAYS BE 1 THROUGH 16
PNTCHR
PCOMMA
MOV R5,R0 ;OUTPUT BLOCK ADDRESS
ADD R5,TEMP ;CHECKSUM
SUB R3,R4 ;DECREMENT DUMP WORD COUNT
JSR PC,$CDA11 ;ASCIIZE
PCOMMA
2$: MOV (R5)+,R0 ;OUTPUT DATA WORD
ADD R0,TEMP ;CHECKSUM
JSR PC,$CDA11 ;ASCIIZE
PCOMMA
DEC R3 ;DONE THIS BLOCKS DATA WORDS ?
BNE 2$ ;NOT YET
MOV TEMP,R0 ;OUTPUT NEGATED CHECKSUM
NEG R0
JSR PC,$CDA11 ;ASCIIZE
$CDDON: PNTCI ;FINISH LINE WITH CR
CR
TST DEVTYP
BMI $CDAC1 ;ACT10
JMP $CDDEV ;DEVICE
$CDAC1: MOV #3,R1 ;RETRY 3 TIMES
INC MSGNBR ;COUNT MESSAGE
$CDXFR: MOV #$OUTBF,R0
MOV R0,$OUTPT
COMCMD ;TRANSMIT DATA BLOCK
CMPB #'A,R0 ;ACKNOWLEDGED ?
BNE $CDTRY ;ERROR, RETRY
$CDCON: TST R4 ;DUMP COUNT POSITIVE = WORDS LEFT
BMI 1$ ;DUMP COUNT NEGATIVE = ALL DONE
BNE $CORDMP ;DUMP COUNT ZERO = DO "EOF" BLOCK
COM R4 ;TRANSMIT "END OF FILE" BLOCK
PNTCI ;EOF BLOCK = "E ,,"
"E ;WORD COUNT = 0
PNTCI ;START ADDRESS = 0
",, ; "NON-STARTABLE" ON LOAD
BR $CDDON
1$: TST DEVTYP
BMI 2$
JMP $CDDVD ;DEVICE
2$: COMEOT ;ALL DONE, FINISH FILE WITH EOT
JMP $CONSL ;WHEW, BACK TO CONSOLE
$CDTRY: DEC R1 ;RETRY ?
BNE $CDXFR ;YES, RESEND MESSAGE
$CDERR: PMSG <?CORDMP ERR>
JMP $CNTLC
$CDA11: TST R0 ;THIS WORD ALL ZEROS ?
BEQ 3$ ;YES, DON'T OUTPUT
CLR R1
MOV R0,R2 ;SETUP HI-ORDER OIT
SWAB R0
BIC #177400,R0
SHIFTR
4
TST R0 ;OIT ZERO ?
BEQ 1$ ;YES, SUPPRESS
JSR PC,$CDP11 ;ASCIIZE AND PUT IN BUFFER
COM R1
1$: MOV R2,R0 ;SETUP MIDDLE OIT
SHIFTR
6
BIC #177700,R0
TST R1 ;HI-ORDER OIT NON-ZERO ?
BNE 11$ ;YES
TST R0 ;ZERO, MIDDLE OIT ZERO ALSO ?
BEQ 2$ ;YES, SUPPRESS
11$: JSR PC,$CDP11 ;ASCIIZE AND PUT IN BUFFER
2$: MOV R2,R0 ;SETUP LOW-ORDER OIT
BIC #177700,R0
JSR PC,$CDP11 ;ASCIIZE AND PUT IN BUFFER
3$: RTS PC
$CDP11: CMP R0,#74 ;LEAVE 75, 76, 77 ALONE
BGT 1$
BIS #100,R0 ;SET BIT 7 FOR ASCIIZE
1$: PNTCHR ;PUT IN BUFFER
RTS PC
;CORE DUMP TO DEVICE ROUTINES
$CDDEV:
$CDRP1: MOV $OUTPT,R0
MOVB #LF,(R0)+ ;FINISH LINE WITH LF
CLRB (R0)
MOV CDADR,R0 ;SETUP BUFFER STORE ADDRESS
MOV #$OUTBF,R1 ;SETUP PICKUP POINTER
MOV R1,$OUTPT
$CDDT2=.
1$: CMP #DVBUF+<256.*2>,R0
BEQ 2$ ;FILLED THIS DATA BLOCK
MOVB (R1)+,(R0)+ ;PUT DATA IN DEVICE BUFFER
BNE 1$ ;NULL, END OF LINE
MOV R0,CDADR ;RESAVE BUFFER POINTER
JMP $CDCON ;CONTINUE CORE DUMP
2$: PUSH <R0,R1>
TST DEVTYP
BEQ $CDDT1 ;DECTAPE
MOV #256.,BUFSIZ
MOV #FILDSB,R0
RPWRFL ;WRITE FILE DATA BLOCK
BCS $CDDVR ;ERROR
POP <R1,R0>
MOV #DVBUF,R0
MOV R0,CDADR
BR 1$
$CDDTA: TST FLOPPY
BEQ 10$
RXFILE ;FIND AND SETUP FLOPPY FILE
BR 11$
10$: DTAFILE ;FIND AND SETUP DECTAPE FILE
11$: BCC 1$
JMP $NONXF
1$: JSR PC,$$CDTA ;SETUP FIRST BLOCK
JMP $CDDON
$$CDTA: TST FLOPPY
BEQ 10$
RXRDFL ;READ FLOPPY BLOCK
BR 11$
10$: DTRDFL ;READ DECTAPE BLOCK
11$: BCS 2$ ;EOF
MOV #DVBUF+2,R0 ;CLEAR DATA PART OF BUFFER
1$: CLR (R0)+
CMP #DVBUF+<256.*2>,R0
BNE 1$
MOV #DVBUF+2,CDADR
RTS PC
2$: PMSG <?INSUFFICIENT ROOM>
JMP $CNTLC
$CDDT1: TST FLOPPY
BEQ 10$
RXWTFL ;WRITE DATA BLOCK BACK TO FLOPPY
BR 11$
10$: DTWTFL ;WRITE DATA BLOCK BACK TO DECTAPE
11$: BCS $CDDTR ;ERROR
JSR PC,$$CDTA ;READ & SETUP NEXT
POP <R1,R0>
MOV CDADR,R0 ;BUFFER ADDRESS TO R0
BR $CDDT2
$CDDTD: CLR DVBUF ;CLEAR LINK, THIS BLOCK EOF
TST FLOPPY
BEQ 10$
RXWTFL ;WRITE LAST FLOPPY BLOCK
BR 11$
10$: DTWTFL ;WRITE LAST DECTAPE BLOCK
11$: BCS $CDDTR ;ERROR
JMP $CONSL ;ALL DONE
$CDDTR: PMSG <?WRITE ERROR>
JMP $CNTLC
;DEVICE FINISH CORE DUMP
$CDDVD: BNE $CDRP2
BR $CDDTD
$CDRP2: MOV CDADR,R0
1$: CLRB (R0)+
CMP #DVBUF+<256.*2>,R0
BNE 1$
2$: MOV CDADR,R0 ;COMPUTE WORD COUNT
SUB #DVBUF,R0
INC R0
BIC #1,R0
SR R0,1
MOV R0,BUFSIZ ;SET AS BUFFER SIZE
COM RPEOF ;WRITE END-OF-FILE
MOV #FILDSB,R0
RPWRFL ;WRITE LAST FILE DATA BLOCK
BCS $CDDVR ;ERROR
JMP $CONSL ;WHEW !, ALL DONE
$CDDVR: RPERROR

2958
src/kldcp/cons11.48 Executable file

File diff suppressed because it is too large Load Diff

1092
src/kldcp/dta11.7 Executable file

File diff suppressed because it is too large Load Diff

552
src/kldcp/fd11.1 Executable file
View File

@@ -0,0 +1,552 @@
;;;MODIFICATION HISTORY
;;;
;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7)
;;; 15 NOV 75 CONVERTED TO PALX FORMAT
;;;
.SBTTL CONTROL RAM CONSOLE FUNCTIONS, 9-SEPTEMBER-75
$EC: DFLEGAL ;FUNCTION LEGAL ?
TTISDL
BCS 8$ ;NON-NUMBER
1$: TTICRA ;READ IN C-RAM ADDRESS
BR 3$
8$: BVC 82$
MOV $ECADR,R0 ;COLON, READ & LIST SAME CRAM ADDRESS
INC $INPTC
BR 33$
82$: TTBTRM
$ALLEC=.
DFRDT ;EXAMINE PRESENT C-RAM OUTPUT
RCRAM2
JSR PC,$ECGET
PUSH $ECADR
DFRDT ;READ HIGH ORDER BITS
RCRAM1
POP R0 ;LOW ORDER TO R0
JSR PC,$ECGET
ASL R0 ;POSITION TO 6-0
ASL R0
SWAB R0
BISB R0,$ECADR ;STUFF LOW ORDER
MOV #-1,R0 ;-1 READS CURRENT C-RAM OUTPUT
BR 33$
3$: MOV R0,$ECADR ;SAVE C-RAM ADDRESS
33$: RCRAM ;READ THE RAM ADDRESS
MOV R0,$ADR1 ;SAVE STARTING ADDRESS OF DATA LIST
TST ALLFLG
BNE 91$
9$: PCRLF ;PRINT OCTAL VALUE OF C-RAM
JSR PC,$$ECA ;PRINT C-RAM ADDRESS
MOV $ADR1,R5 ;GET C-RAM DATA LIST ADDRESS
ADD #12,R5
MOV (R5),R4 ;SAVE SPEC
MOV -(R5),R0 ;PRINT 1ST C-RAM WORD, LAST IN LIST
PNTOCT
MOV -(R5),R0 ;PRINT 2ND C-RAM WORD
PNTOCT
MOV -(R5),R0 ;PRINT 3RD C-RAM WORD
PNTOCT
MOV -(R5),R0 ;PRINT 4TH C-RAM WORD
PNTOCT
MOV -(R5),R0 ;PRINT 5TH C-RAM WORD
PNTOCT
MOV R4,R0 ;PRINT 6TH C-RAM WORD (SPEC)
PNTODT
2
91$: MOV $ECADR,R0
MOV $ADR1,R1
PNTCRM ;PRINT C-RAM BY LOGICAL FIELDS
JMP ALLEXT
$ECGET: MOV @.DAT2,$ECADR ;GET BITS 4,5
MOVB @.DAT1,$ECADR ;GET BITS 0-3
SWAB $ECADR
BIC #170077,$ECADR
RTS PC
;FIELD PRINT OUT, THIS IS THE C-RAM BIT FIDDLER
$PCRAM: MOV R0,$ECADR
MOV R1,$ADR1
91$: PMSG <\ LOC/ J T AR AD BR MQ FM SCAD SC FE SH # VMA MEM COND SPEC M\>
JSR PC,$$ECA ;PRINT C-RAM ADDRESS
$DCTPC: MOV #$CRMD0,R5 ;GET PRIMARY DECISION TABLE ADDRESS
$DCTP1: CLR R0
MOV (R5)+,R4 ;R4=SECONDARY DECISION TABLE ADDRESS
BEQ $END ;WOW WE MADE IT TO THE END
2$: MOVB (R4)+,R3 ;GET A BYTE FROM SECONDARY TABLE
BEQ $NEXT ;GET NEXT FIELD
MOVB R3,R2 ;CALCULATE BYTE LOCATION
ASRB R3 ;/2
ASRB R3 ;/4
ASRB R3 ;/8
ADD $ADR1,R3
MOVB (R3),R3 ;FETCH THE DATA BYTE
BICB #370,R2 ;R2=BIT LOCATION
3$: ASRB R3 ;CALCULATE BIT LOCATION
DEC R2 ;FOUND BIT YET
BGE 3$
ROL R0 ;PLACE BIT IN R0
BR 2$
$NEXT: MOVB (R5)+,R1 ;R1=OCTAL CHARACTERS IN NUMBER
PNTODC ;PRINT THE NUMBER
MOVB (R5)+,R1 ;R1=POST SPACING PARAMETER
JSR PC,$PNTSPC
BR $DCTP1
$END: MOV $ADR1,R5 ;SPECIAL PRINT OF SPEC FIELD
MOVB 12(R5),R0
PNTODT
2
PSPACE
MOVB 4(R5),R0
SHIFTR
4
BIC #177776,R0
PNTOCS
TST ALLFLG
BEQ 1$
PCRLF
1$: EXIT
;READ THE C-RAM AND PRINT ACTUAL BY E-BUS ARRANGMENT
$RC: DFLEGAL ;FUNCTION LEGAL ?
TTISDL
BCS 3$ ;NON-NUMBER
BR 2$ ;NUMBER, MUST BE ADDRESS
1$: MOV #RCRAM1,R0
JSR R5,$RCP ;FIRST 36
MOV #RCRAM2,R0
JSR R5,$RCP ;2ND 36
MOV #RCRAM3,R0
JSR R5,$RCP ;3RD 36
MOV #RCRAM4,R0
JSR R5,$RCP ;4TH 36
TST RPTFLG
BNE 11$
PCRLF
11$: JMP $KONSL
2$: TTICRA ;GET C-RAM ADDRESS
MOV R0,$ECADR
5$: MOV $ECADR,R0
WWADR ;WRITE C-RAM ADDRESS
DFSCLK
DFSCLK
JSR PC,$$ECA ;PRINT C-RAM ADDRESS
PSPACE
BR 1$
3$: BVC 32$
INC $INPTC ;COLON, READ SAME C-RAM ADDRESS
BR 5$
32$: TTBTRM ;READ PRESENT C-RAM ADDRESS
BR 1$
$RCP: MOV #.DFRDA,R1
DFRDMV ;READ C-RAM
MOV R1,R0
PNT36 ;PRINT IT
PSPACE
1$: RTS R5
;PRINT C-RAM ADDRESS
$$ECA: MOV $ECADR,R0
PNTODT
4
PSLASH
RTS PC
.SBTTL DISPATCH RAM CONSOLE FUNCTIONS
;LOAD D-RAM SUBROUTINE
$DDNPR: JMP $PARAM
$DD: DFLEGAL ;FUNCTION LEGAL ?
TTISDO ;GET THE ADDRESS
BIT #1,R0
BNE 98$ ;MUST BE EVEN ADDRESS
MOV R0,$ADR ;SAVE THE ADDRESS
CMP R0,#776 ;TEST ADDRESS SIZE
BLE 2$
98$: JMP ADRERR
2$: TTIBRK ;READ A CHARACTER
BCS $DDNPR ;NO COLON
CMPB R0,#': ;IS IT A COLON
BEQ 21$
CMPB R0,#'/
BNE $DDNPR
21$: JSR PC,$DDA ;READ A FIELD
MOV R0,$DRAM ;STORE "A" FIELD
JSR PC,$DDB
BIS R0,$DRAM ;STORE "B" FIELD
TTISDO ;READ "P" FIELD
BIC #177776,R0 ;SAVE "P" FIELD
SHIFTL
5
BIS R0,$DRAM
TTISDO ;READ "J" FIELD
CMP R0,#1777
BLE 3$
$DDSIZ=.
PMSG <\J SIZE ERR>
JMP $CNTLC
3$: MOV R0,$DRAM+6 ;SAVE FOR COMMON
BIC #177760,R0
BIS R0,$DRAM ;SAVE "J" EVEN
;DONE WITH EVEN NOW PROMPT FOR ODD
$DRAMO: PMSG < DD > ;PROMPT
MOV $ADR,R0 ;ODD ADDRESS
INC R0
PNTOCS
PMSG <:_> ;PRINT COLON, OUTPUT
TTILIN
BCS $DDNPR
JSR PC,$DDA ;READ ODD "A" FIELD
MOV R0,$DRAM+2 ;INSERT ODD "A" FIELD
JSR PC,$DDB ;READ ODD "B" FIELD
BIS R0,$DRAM+2
TTISDO ;READ ODD "P" FIELD
BIC #177776,R0
SHIFTL
5
BIS R0,$DRAM+2
TTISDO ;READ ODD "J" FIELD
CMP R0,#1777
BGT $DDSIZ
1$: MOV R0,$DRAM+10 ;SAVE FOR COMMON
BIC #177760,R0
BIS R0,$DRAM+2 ;SAVE "J" ODD
BIC #17,$DRAM+6
BIC #17,$DRAM+10
CMP $DRAM+6,$DRAM+10 ;ARE BOTH COMMONS THE SAME ?
BEQ 2$
CMP #254,$ADR ;IS THIS JRST/JFCL ?
BEQ 2$ ;YES, COMMONS MAY BE DIFFERENT
PMSG <\J CMN ERR>
JMP $CNTLC
2$: MOV $DRAM+10,R0 ;USE ODD COMMON
SR R0,6
MOV R0,$DRAM+4 ;INSERT "J" COMMON
MOV $ADR,R0
MOV #$DRAM,R1
MRESET
WDRAM ;WRITE THE D-RAM
PCRLF
JMP @#$KONSL
99$: JMP $OCTN
$DDA: TTISDO ;READ "A" FIELD
SHIFTL
11.
BIC #143777,R0
RTS PC
$DDB: TTISDO ;READ "B" FIELD
SHIFTL
8.
BIC #174377,R0
RTS PC
;EXAMINE D-RAM SUBROUTINE
$EDNOA: JMP $OCTN
$EDODD: JMP ADRERR
$ED: DFLEGAL ;FUNCTION LEGAL ?
TTISDL
BCS 5$
TTISDO ;READ THE ADDRESS
BIT #1,R0
BNE $EDODD ;MUST BE EVEN ADDRESS
MOV R0,$EDADR
4$: CMP R0,#777 ;TEST FOR HIGHEST ADDRESS
BLE 2$
41$: JMP ADRERR
5$: BVC 52$
51$: MOV $EDADR,R0 ;COLON, EXAMINE SAME DRAM ADDRESS
INC $INPTC
BR 4$
52$: TTBTRM
MOV $EDADR,R0
BR 4$
2$: MOV R0,$EDADR
MRESET
RDRAM ;READ D-RAM
MOV R0,R1
MOV $EDADR,R0
PNTDRM ;PRINT D-RAM
JMP $KONSL
;PRINT D-RAM IN LOGICAL FIELD FORMAT
$PDRAM: MOV R0,R5
PMSG <\ADR: A B P J\>
MOV 4(R1),R0 ;POSITION COMMON J-FIELD
SHIFTL
6 ;FOR PRINTING
MOV R0,R2
CLR R4
1$: MOV R5,R0 ;PRINT D-RAM ADDRESS
PNTODT
3
PSLASH
PSPACE
MOV (R1),R0 ;PRINT A-FIELD
SHIFTR
11.
PNTNBR
PSPACE
MOV (R1),R0 ;PRINT B-FIELD
SHIFTR
8.
PNTNBR
PSPACE
MOV (R1),R0 ;PRINT PARITY
SHIFTR
5
BIC #177776,R0
PNTNBR
PSPACE
MOV (R1)+,R0 ;PRINT J-FIELD
BIC #177760,R0
BIS R2,R0
PNTODT
4
PCRLF
TST R4 ;COMPLETED D-RAM PAIR ?
BNE 2$
INC R4 ;NO, SET FLAG
INC R5 ;SETUP ODD ADDRESS
BR 1$ ;GO DO ODD PRINTOUT
2$: EXIT
.SBTTL DEPOSIT C-RAM SUBROUTINE
$DCNCL: JMP $PARAM
$DC: DFLEGAL ;FUNCTION LEGAL ?
TTICRA
2$: MOV R0,$ADR ;SAVE ADDRESS
TTIBRK ;GET THE COLON
BCS $DCNCL
CMPB R0,#':
BEQ 20$
CMPB R0,#'/
BNE $DCNCL ;NO COLON
20$: MOV #$TTSAV,R5 ;CLEAR STORAGE
CLR (R5)+
CLR (R5)+
CLR (R5)+
CLR (R5)+
CLR (R5)+
CLR (R5)
MOV #5,R4
4$: TTISDL
BCS 3$ ;USE 0'S AFTER FIRST NON-NUMBER
TTCOCT
MOV R0,-(R5)
DEC R4
BNE 4$
TTISDL
BCS 3$
TTCOCT
BIC #177740,R0
MOV R0,$TTSAV+12
3$: MOV $ADR,R0
MOV #$TTSAV,R1
WCRAM
JMP @#$KONSL
;C-RAM PRIMARY DECISION TABLE
;
$CRMD0: .WORD $FJ ;J FIELD
.BYTE 4,1 ;CHARACTERS , POST SPACING
.WORD $FT ;T FIELD
.BYTE 1,1
.WORD $FAR ;AR FIELD
.BYTE 2,1
.WORD $FAD ;AD FIELD
.BYTE 4,1
.WORD $FBR ;BR FIELD
.BYTE 1,2
.WORD $FMQ ;MQ FIELD
.BYTE 1,2
.WORD $FFM ;FM FIELD
.BYTE 1,2
.WORD $FSCAD ;SCAD FIELD
.BYTE 3,2
.WORD $FSC ;SC FIELD
.BYTE 1,2
.WORD $FFE ;FE FIELD
.BYTE 1,2
.WORD $FSH ;SH FIELD
.BYTE 1,1
.WORD $FNUM ;NUM FIELD
.BYTE 3,2
.WORD $FVMA ;VMA FIELD
.BYTE 1,2
.WORD $FMEM ;MEM FIELD
.BYTE 2,3
.WORD $FCOND ;COND FIELD
.BYTE 2,3
.WORD 0 ;END OF TABLE WORD
;C-RAM SECONDARY DECISION TABLES
$FJ: .BYTE 74.,73. ;J00(5), J01(6)
.BYTE 72.,71. ;J02(7), J03(8)
.BYTE 70.,69. ;J04(9), J05(10)
.BYTE 68.,67. ;J06(11), J07(12)
.BYTE 66.,65. ;J08(13), J09(14)
.BYTE 64.,0 ;J10(15)
$FT: .BYTE 3.,1. ;T00(76), T01(78)
.BYTE 0,0
$FAR: .BYTE 43.,11. ;ARXM SEL4(36), ARXM SEL2(68)
.BYTE 9.,34. ;ARXM SEL1(70), ARM SEL4(45)
.BYTE 15.,13. ;ARM SEL2(64), ARM SEL1(66)
.BYTE 0,0
$FAD: .BYTE 51.,47. ;ADB SEL2(28), ADB SEL1(32)
.BYTE 54.,53. ;ADA DIS(25), ADA SEL2(26)
.BYTE 52.,5. ;ADA SEL1(27), AD CRY(74)
.BYTE 55.,59. ;AD BOOLE(24), AD SEL 8 (20)
.BYTE 58.,57. ;AD SEL 4 (21), AD SEL 2 (22)
.BYTE 56.,0 ;AD SEL 1 (23)
$FBR: .BYTE 25.,27. ;BRX LOAD(54), BR LOAD(52)
.BYTE 0,0
$FMQ: .BYTE 63.,0 ;MQ SEL(16)
$FFM: .BYTE 23.,22. ;FM ADR SEL4(56), FM ADR SEL2(57)
.BYTE 21.,0 ;FM ADR SEL1(58)
$FSCAD: .BYTE 37.,19. ;SCADB SEL2(42), SCADB SEL1(60)
.BYTE 79.,39. ;SCADA DIS(0), SCADA SEL2(40)
.BYTE 38.,78. ;SCADA SEL1(41), SCAD 4(1)
.BYTE 77.,76. ;SCAD 2(2), SCAD 1(3)
.BYTE 0,0
$FSC: .BYTE 17.,0 ;SCM SEL 2(62)
$FFE: .BYTE 75.,0 ;FE LOAD(4)
$FSH: .BYTE 33.,32. ;SH/ARMM SEL2(46), SH/ARMM SEL1(47)
.BYTE 0,0
$FNUM: .BYTE 50.,49. ;#00(29), #01(30)
.BYTE 48.,46. ;#02(31), #03(33)
.BYTE 45.,44. ;#04(34), #05(35)
.BYTE 42.,41. ;#06(37), #07(38)
.BYTE 40.,0 ;#08(39)
$FVMA: .BYTE 35.,7. ;VMA SEL 2(44), VMA SEL 1(72)
.BYTE 0,0
$FMEM: .BYTE 31.,30. ;MEM 00(48), MEM 01(49)
.BYTE 29.,28. ;MEM 02(50), MEM 03(51)
.BYTE 0,0
$FCOND: .BYTE 62.,61. ;COND 00(17), COND 01(18)
.BYTE 60.,26. ;COND 02(19), COND 03(53)
.BYTE 24.,20. ;COND 04(55), COND 05(59)
.BYTE 0,0

217
src/kldcp/floppy.1 Executable file
View File

@@ -0,0 +1,217 @@
;;;MODIFICATION HISTORY
;;;
;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7)
;;; 15 NOV 75 CONVERTED TO PALX FORMAT
;;;
.SBTTL RX11/RX01 (FLOPPY) DEVICE DRIVER ROUTINES, 22-JULY-75
;FLOPPY READ/WRITE FILE ROUTINES
$RXFILE:RXINIT ;INITIALIZE FLOPPY
JMP DTAFL1 ;REST SAME AS DECTAPE
$RXRDFL:TST DVBUF ;ANY DATA BLOCKS REMAINING ?
BNE $RXRFL ;YES
$$RXXE: EXITERR ;NO
$RXRFL: MOV DVBUF,RXBLK ;SET REQUESTED BLOCK
MOV #DVBUF,CASAV ;SET BUFFER ADDRESS
MOV #-256.,WCSAV ;SET WORD COUNT
RXREAD ;FLOPPY READ
BCS $$RXXC ;FAILED
MOV #$DTINFO,R0
$$RXX: EXIT
$$RXXC: EXITERR ;FAILED
$RXWTFL:MOV #DVBUF,CASAV
MOV #-256.,WCSAV
RXWRT ;WRITE FLOPPY
BCC $$RXX ;OK
BR $$RXXC ;FAILED
RXERA: PMSG <?BLK#>
BR RXERC
RXERB: PMSG <?HARD>
RXERC: PMSG < FLOPPY ERROR>
JMP $CNTLC
;FLOPPY READ/WRITE ROUTINE
$RXREAD:CLR RXCMD ;INDICATE READ OPERATION
BR $RXXFR
$RXWRT: MOV #1,RXCMD ;INDICATE WRITE OPERATION
$RXXFR: MOV #10.,TRYCTR ;SET MAXIMUM TRY COUNT, 10.
MOV #RXCS,R4 ;RX11 COMMAND REG ADDRESS TO R4
MOV RXUNIT,RXWCMD ;UNIT # TO COMMAND WORD
MOV RXBLK,RXBLKT ;BLOCK NUMBER TO WORK TEMP
CMP RXBLKT,#494. ;CHECK FOR VALID BLOCK NUMBER
BLO 1$ ;BR IF OK
BR RXERA ;NOT, REPORT BLOCK NUMBER ERROR
1$: JSR PC,$RXCTS ;COMPUTE TRACK AND SECTOR ADDRESS
2$: MOV TRYCTR,R2 ;GET RETRY COUNT
3$: JSR PC,$PTTYC ;DO OPERATOR CHECKS
CLR R1 ;CLEAR ERROR INDICATOR
TST RXCMD ;READ OR WRITE ?
BNE 4$ ;WRITE
JSR PC,$RXR1 ;READ A SECTOR
BR 5$
4$: JSR PC,$RXW1 ;WRITE A SECTOR
5$: BEQ 6$ ;BR IF NO ERROR IN OPERATION
JSR R5,$RXFUNC ;READ STATUS, INIT FLOPPY
RXINI!RXRSTAT!RXGO
MOV RXWCMD,(R4) ;REALLY DO IT
JSR PC,$RXCKDN ;WAIT FOR DONE
DEC R2 ;DONE # OF REQUIRED RETRIES ?
BNE 3$ ;NO
BR RXERB ;YES, REPORT HARD ERROR
6$: SUB #64.,WCSAV ;ALL WORDS TRANSFERED ?
BLE 7$ ;BR IF YES
ADD #128.,CASAV ;NO, UPDATE TRANSFER ADDRESS
JSR PC,$RXITS ;UPDATE TRACK AND SECTOR ADDRESS
BR 2$ ;DO NEXT TRANSFER
7$: EXIT ;DONE
;SUBROUTINE TO READ ONE SECTOR
$RXR1: JSR R5,$RXFUNC ;ISSUE A READ FUNCTION
RXRSEC!RXGO
JSR PC,$RXLTS ;LOAD TRACK AND SECTOR ADDRESS
JSR PC,$RXGBUF ;GET THE SECTOR READ
BR $RXW2 ;FINISH UP
;SUBROUTINE TO WRITE ONE SECTOR
$RXW1: JSR PC,$RXFBUF ;FILL BUFFER WITH 1 SECTOR OF DATA
JSR R5,$RXFUNC ;ISSUE A WRITE FUNCTION
RXWSEC!RXGO
JSR PC,$RXLTS ;LOAD TRACK AND SECTOR ADDRESS
$RXW2: JSR PC,$RXCKDN ;WAIT FOR DONE
TST R1 ;TEST ERROR INDICATOR
RTS PC ;DONE, RETURN
;SUBROUTINE TO CHECK FOR DONE/ERROR
$RXCKDN:TST R1 ;ERROR ALREADY ?
BNE $RXTR3 ;BR IF YES
1$: BIT #RXERROR!RXDONE,(R4)
BMI $RXTR2 ;ERROR
BEQ 1$ ;NOTHING YET
BR $RXTR3 ;DONE SET
;SUBROUTINE TO CHECK FOR TRANSFER REQUEST
$RXTRQ: TST R1 ;ERROR ALREADY ?
BNE $RXTR3 ;YES
1$: BIT #RXERROR!RXTREQ,(R4)
BMI $RXTR2 ;ERROR SET
BEQ 1$ ;NOTHING YET
BR $RXTR3 ;TRANSFER REQUEST SET
$RXTR2: INC R1 ;SET ERROR INDICATOR
$RXTR3: TST R1 ;TEST ERROR INDICATOR
RTS PC
;SUBROUTINE TO ISSUE DESIRED FUNCTION
$RXFUNC:BIC #177757,RXWCMD ;CLEAR ALL BUT UNIT #
BIS (R5)+,RXWCMD ;SET THE DESIRED FUNCTION
JSR PC,$RXCKDN ;WAIT FOR DONE
BNE 1$ ;BR IF ERROR INDICATOR SET
MOV RXWCMD,(R4) ;ISSUE THE FUNCTION
1$: RTS R5
;SUBROUTINE TO LOAD TRACK AND SECTOR ADDRESS
$RXLTS: JSR PC,$RXTRQ ;WAIT FOR TRANSFER REQUEST
MOV RXSADR,2(R4) ;LOAD THE SECTOR ADDRESS
JSR PC,$RXTRQ ;WAIT FOR TRANSFER REQUEST
MOV RXTADR,2(R4) ;LOAD THE TRACK ADDRESS
RTS PC
;SUBROUTINE TO EMPTY SECTOR BUFFER INTO DESIRED CORE AREA
$RXGBUF:JSR R5,$RXFUNC ;ISSUE EMPTY BUFFER FUNCTION
RXEBUF!RXGO
MOV CASAV,R3 ;GET TRANSFER ADDRESS
MOV #128.,R0 ;WILL TRANSFER 128 BYTES
1$: JSR PC,$RXTRQ ;WAIT FOR TRANSFER REQUEST
BNE 3$ ;BR IF ERROR INDICATOR SET
2$: MOVB 2(R4),(R3)+ ;MOVE BYTE INTO CORE BUFFER
DEC R0 ;DONE 128 BYTES ?
BNE 1$ ;NOT YET
3$: RTS PC
;SUBROUTINE TO FILL SECTOR BUFFER FROM DESIRED CORE AREA
$RXFBUF:JSR R5,$RXFUNC ;ISSUE FILL BUFFER FUNCTION
RXFBUF!RXGO
MOV CASAV,R3 ;GET TRANSFER ADDRESS
MOV #128.,R0 ;WILL TRANSFER 128 BYTES
1$: JSR PC,$RXTRQ ;WAIT FOR TRANSFER REQUEST
BNE 3$ ;BR IF ERROR INDICATOR SET
2$: MOVB (R3)+,2(R4) ;MOVE BYTE INTO SECTOR BUFFER
DEC R0 ;DONE 128 BYTES ?
BNE 1$ ;NOT YET
3$: RTS PC
;SUBROUTINE TO INCREMENT TRACK AND SECTOR ADDRESS AS FOLLOWS:
; ADD 8 TO SECTOR ADDRESS, IF RESULT GREATER THAN 26, SUBTRACT
; 26 FROM RESULT. ADD 1 TO TRACK ADDRESS, DO ONLY IF "$RXITS" ENTERED
; LESS THAN 4 TIMES. IF 4, ADD 1 TO BLOCK NUMBER AND RECOMPUTE
; TRACK AND SECTOR ADDRESS FOR NEW BLOCK NUMBER.
$RXITS: DEC $$ITS1 ;4TH TIME THROUGH ?
BEQ 2$ ;YES
ADD #8.,RXSADR ; +8 TO SECTOR ADDRESS
CMP RXSADR,#26. ;LARGER THAN 26 ?
BLOS 1$ ;NO
SUB #26.,RXSADR ;YES, SUBTRACT 26
1$: INC RXTADR ; +1 TO TRACK ADDRESS
RTS PC
2$: INC RXBLKT ; +1 TO BLOCK NUMBER
;RECOMPUTE TRACK AND SECTOR ADDRESS
;SUBROUTINE TO COMPUTE TRACK AND SECTOR ADDRESS FROM BLOCK NUMBER
; VALID BLOCK NUMBERS ARE 0 TO 493(10)
; TRACK ADDRESS = BLOCK NUMBER/26X4+1
; SECTOR ADDRESS = (REMAINDER OF BK/26)+1
$RXCTS: MOV RXBLKT,RXSADR
CLR -(SP) ;CLEAR THE QUOTIENT
1$: SUB #26.,RXSADR ;DIVIDE BY 26 BY SUBTRACTING
BCS 2$ ;BR IF GONE UNDER, CORRECT DIVIDEND
ADD #4,(SP) ; +4 TO QUOTIENT
BR 1$ ;GO FOR MORE
2$: ADD #27.,RXSADR ;FINAL SECTOR ADDRESS
INC (SP) ;ADD 1 TO QUOTIENT
MOV (SP)+,RXTADR ;FINAL TRACK ADDRESS
MOV #4,$$ITS1 ;FOR "$RXITS" SUBROUTINE
RTS PC
;FLOPPY INITIALIZATION ROUTINE
$RXINIT:MOV #3,DVBUF ;SET STARTING UFD BLOCK NUMBER
EXIT
;FLOPPY PARAMETER BASE ADDRESS
$RXBASE:MOV #RXBLK,R0 ;BASE ADDRESS TO R0
EXIT

120
src/kldcp/kldcp.20 Executable file
View File

@@ -0,0 +1,120 @@
;DECSYSTEM10 KL10 PDP-11 DIAGNOSTIC CONSOLE PROGRAM
DECVER==007 ;ORIGINALLY MODIFIED FROM DEC 0.7 VERSION
MCNVER==0
MITVER==%FNAM2
.TITLE KLDCP DECSYSTEM10 KL10 PDP-11 DIAGNOSTIC CONSOLE PROGRAM, VER 0.7
;;;MODIFICATION HISTORY
;;;
;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7)
;;; 15 NOV 75 CONVERTED TO PALX FORMAT
;;; 30 MAR 76 MODIFIED TO COEXIST WITH ITS IOELEVEN PROGRAM
;.LIST MC,MD
;.DSABL GBL
;.DSABL REG
.ABS
;.ENABL AMA ;AMERICAN MEDICAL ASSOC? DOES ANYONE KNOW WHAT THIS DOES?
;JOHN R. KIRCHOFF
;DIGITAL EQUIPMENT CORPORATION
;MARLBORO, MASS. 01752
;ASSEMBLY PARAMETERS
;IF SYMBOL IS DEFINED, FROB GETS ASSEMBLED
KLDCP==1 ;ASSEMBLE KLDCP
DTEASB==1 ;ASSEMBLE DTE20
DVSASB==1 ;ASSEMBLE DEVICE SERVICE
KWASB==1 ;ASSEMBLE KW CLOCK
DLASB==1 ;ASSEMBLE DL11
;DHASB==1 ;DON'T ASSEMBLE DH11
;TAASB==1 ;DON'T ASSEMBLE TA CASSETTE
RXASB==1 ;ASSEMBLE RX11/RX01 FLOPPY
TCASB==1 ;ASSEMBLE TC DECTAPE
RPASB==1 ;ASSEMBLE RP04 DISK PACK
;LPASB==1 ;DON'T ASSEMBLE LP20 LINE PRINTER
;MBYHLT==1 ;DEFINE THIS SYMBOL TO PRINT MOBY INFO WHEN MACHINE HALTS
$NB==8. ;USE 8 BREAKPOINTS
;SUBROUTINE CODE BEGINS AT 16K (WORDS)
.IIF NDF PRGSRT, PRGSRT==16.*1024.*2.
.IIF NDF COREND, COREND==28.*1024.*2.
TOUTBF==70000 ;OVERLAY BUFFER
;bag-biter clobbers core with reckless abandon from here to 100000
;PDP-10 KL10 EXEC PROCESS TABLE PARAMETERS
$STD==440 ;PDP-10 DIAGNOSTIC START ADDRESS
$DDT==441 ;PDP-10 DDT START ADDRESS
$STL==442 ;PDP-10 LOADER START ADDRESS
$STM==443 ;PDP-10 MONITOR START ADDRESS
$DTFLG==444 ;DTE20 OPERATION COMPLETE FLAG
$DTCLK==445 ;DTE20 CLOCK INTERRUPT FLAG
$DTCI==446 ;DTE20 CLOCK INTERRUPT INSTRUCTION
$DTT11==447 ;DTE20 10 TO 11 ARGUMENT
$DTF11==450 ;DTE20 11 TO 10 ARGUMENT
$DTCMD==451 ;DTE20 TO 11 COMMAND WORD
$DTSEQ==452 ;DTE20 OPERATION SEQUENCE NUMBER
$DTOPR==453 ;DTE20 OPERATION IN PROGRESS FLAG
$DTCHR==454 ;DTE20 LAST TYPED CHARACTER
$DTMTD==455 ;DTE20 MONITOR TTY OUTPUT COMPLETE FLAG
$DTMTI==456 ;DTE20 MONITOR TTY INPUT FLAG
$DTSWR==457 ;DTE20 PDP-10 SWITCH REGISTER
;KLDCPU UTILITY PROGRAM PARAMETERS
;UTILITY IDENTIFICATION
PID==3004 ;PROGRAM NAME
PDVER==3010 ;DEC VERSION
PMVER==3012 ;MCN VERSION
;UTILITY SUB-PROGRAM DISPATCH ADDRESSES
PTABLE==3020 ;START OF TABLE
RXCOPY==3020 ;RX11/RX01 FLOPPY COPY PROGRAM
DTCOPY==3022 ;TC11 DECTAPE COPY PROGRAM
WFILE==3024 ;WRITE FILE FROM DTA/RX TO RP04 PROGRAM
TAPT==3026 ;TRANSFER FILE FROM APT10 TO RP04 PROGRAM
DSKDIR==3030 ;RP04 DISK DIRECTORY
REMOTE==3032 ;REMOTE TELETYPE COMMUNICATIONS
WUTAPE==3034 ;WRITE FILE FROM RP04 TO MICRO TAPE
UINIT==3036 ;INITIALIZE MICRO TAPE
UFDELE==3040 ;DELETE FROM MICRO TAPE
USALV==3042 ;CHECK MICRO TAPE
UFLAP==3044 ;FLAP MICRO TAPE
XMEMSZ==512. ;# K OF PDP10 MEMORY TO CLEAR IN MZ 0,-1
FUQ:: ;THIS IS HERE TO AVOID GETTING A "LOCAL TAG BEFORE
;FIRST LABEL" ERROR MESSAGE FROM BAG-BITING PALX
;(THERE ARE MACRO DEFINITIONS WITH LOCAL TAGS IN THEM)
;INSERT THE REST OF KLDCP
.INSRT PRM11
.INSRT BEG11
.INSRT CONS11
.INSRT BPNT11
.INSRT SUB11
.INSRT FD11
.INSRT DTA11
.INSRT FLOPPY
.INSRT RP0411
.INSRT APT11
;.INSRT CDMP11
.INSRT BR11
.INSRT SBST11
.END $ILOAD

1679
src/kldcp/prm11.14 Executable file

File diff suppressed because it is too large Load Diff

649
src/kldcp/rp0411.4 Executable file
View File

@@ -0,0 +1,649 @@
;;;MODIFICATION HISTORY
;;;
;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7)
;;; 15 NOV 75 CONVERTED TO PALX FORMAT
;;;
.SBTTL RP04 CONSOLE SELECTION, 5-AUG-75
$RP: TTISDO ;GET RP04 SELECTION DIGIT
CMP R0,#7 ;MUST BE 0 TO 7
BLE 1$
JMP $CMDE
1$: MOV R0,RPUNIT ;SAVE
MOV #1,DEVTYP ;SET RP04 MODE
RPLOAD ;INIT & LOAD PACK
BCS $RPERR
2$: JMP $KONSL
.SBTTL RP04 FILE DIRECTORY LOOKUP
RPFIL: RPFILE
BCS 1$
JMP DTRPLD
1$: JMP $NONXF
$RPFILE:CLR RPEOF ;CLEAR END-OF-FILE
ASCR50 ;CONVERT FILE.EXT TO RAD50
NAMBF
NAMRAD
BCC 1$
$PMSG ;NAME.EXT ERR
$$NAM
BR $RPERX
1$: MOV #NAMRAD,R0
MOV #FILDSB,R1
RPLKUP ;LOOK UP FILE IN DIRECTORY
BCC 3$
CMP #-24,R0
BNE $RPERR
EXITERR
3$: EXIT
;RP04 ERROR REPORTER
$RPERR: PUSH R0
PMSG <?RP04 ERROR >
POP R0
NEG R0
MOV R0,R1
PNTOCS ;PRINT ERROR STATUS WORD
PNTCI
",
DEC R1
SL R1,1
MOV RPERTB(R1),R0
PNTAL ;PRINT ERROR REASON
$RPERX: JMP $CNTLC
RPERTB: RPER1
RPER2
RPER3
RPER4
RPER5
RPER6
RPER7
RPER10
RPER11
RPER12
RPER13
RPER14
RPER15
RPER16
RPER17
RPER20
RPER21
RPER22
RPER23
RPER24
RPER25
;RP04 ERROR MESSAGES
RPER1: .ASCIZ %UNIT #%
RPER2: .ASCIZ %UNAVAIL%
RPER4:
RPER5:
RPER3: .ASCIZ %DRV INIT%
RPER6: .ASCIZ %HOME BLK RD%
RPER7: .ASCIZ %NO HOME BLK%
RPER10: .ASCIZ %FILE SYS NAME%
RPER11: .ASCIZ %NO INDEX%
RPER12: .ASCIZ %NO DIR FILE%
RPER13: .ASCIZ %PAST EOF%
RPER20:
RPER14: .ASCIZ %POS%
RPER15: .ASCIZ %READ ERR%
RPER16: .ASCIZ %ALLOC CNG%
RPER17: .ASCIZ %BUFSIZ%
RPER21: .ASCIZ %INSUFF ALLOC%
RPER22: .ASCIZ %DIR REWRT%
RPER23: .ASCIZ %DATA WRT%
RPER24: .ASCIZ %EOF%
RPER25: .ASCIZ %RAD50%
.EVEN
.SBTTL RP04 FILE RENAME
;COMMAND IS:
; RENM:FILE.EXT FILE1.EXT
$RE: TTICHR
CMPB #'N,R0
BNE 1$
TTICHR
CMPB #'M,R0
BEQ 2$
1$: JMP $CMDER
2$: TTITRM
NAMEXT ;SETUP CURRENT FILE NAME.EXT
RPFILE ;FIND AND SETUP FILE
BCC 4$
JMP $NONXF
4$: NAMEXT ;SETUP NEW FILE NAME.EXT
ASCR50 ;CONVERT NEW FILE.EXT TO RAD50
NAMBF
NAMRAD
BCS 1$ ;NAME.EXT ERROR
MOV #WRTBAK,R5 ;POINTER TO WRITE-BACK INFO TO R5
MOV (R5)+,R4 ;GET CORE ADDRESS OF FILE DESCRIPTOR
MOV #NAMRAD,R3
MOV (R3)+,(R4)+ ;TRANSFER NEW RAD50 FILE NAME.EXT
MOV (R3)+,(R4)+ ;TO CURRENT FILE DESCRIPTOR BLOCK
MOV (R3),(R4)
MOV (R5)+,CYLNDR
MOV (R5)+,TRKSCT
RPWRIT ;REWRITE DIRECTORY BLOCK
BCC 3$
MOV #-22,R0
RPERROR
3$: JMP $CONSL
.SBTTL ASCR50 ASCII TO RAD50 CONVERSION ROUTINE
;CALL:
; ASCR50
; ASCII ADDRESS
; RAD50 ADDRESS
;NINE BYTES OF ASCII INPUT
;THREE WORDS OF RAD50 OUTPUT
$ASCR50:ADD #4,12(SP) ;RETURN OVER TRAILING PARAMETERS
PUSH R0
MOV $EMADR,R5
MOV (R5)+,R1 ;SETUP ASCII ADDRESS
MOV (R5),R4 ;SETUP RAD50 STORAGE ADDRESS
MOV #066600,R3
1$: CLR (R4) ;RESULT WORD
2$: MOV #30$,R0 ;SETUP SCAN TABLE
3$: MOVB (R0)+,R2 ;PUT CONVERSION IN R2
BEQ 20$ ;IF END OF TABLE, ERROR
CMPB (R1),(R0)+ ;COMPARE ASCII CHAR
BLO 20$ ;IF LESS THAN TABLE ENTRY, ERROR
CMPB (R1),(R0)+
BHI 3$ ;LOOP, HAVEN'T FOUND YET
MOVB (R1)+,R0 ;FOUND, ASCII CHAR TO R0
ADD R2,R0 ;CONVERT
ASL (R4)
ASL (R4)
ASL (R4)
ADD (R4),R0
ASL (R4)
ASL (R4)
ADD R0,(R4)
ASL R3 ;SHIFT RAD50 WORD COUNTER
BMI 2$ ;NOT DONE WITH THIS RAD50 YET
BEQ 10$ ;IF 0, ALL DONE
TST (R4)+ ;STEP TO NEXT RAD50 WORD
BR 1$ ;GO DO NEXT
10$: POP R0
EXIT
20$: POP R0
EXITERR
30$: .BYTE -40,' ,' ;SPACE
.BYTE -11,'$,'$ ;DOLLAR SIGN
.BYTE -22,'.,'. ;PERIOD
.BYTE -22,'0,'9 ;DIGITS
.BYTE -100,'A,'Z ;UPPER CASE LETTERS
; .ENABL LC
.BYTE -140,'a,'z ;LOWER CASE LETTERS
.BYTE 0 ;INDICATE THE END OF THE TABLE
.EVEN
.SBTTL RPLOAD RP04 LOAD PACK (READ HOME BLOCK) ROUTINE
$RPLOAD:RPINIT ;INITIALIZE RP04
BCS 10$
MOV #-6,R5
CLR CYLNDR
MOV #1,TRKSCT
MOV #DVBUF,BUFADR
MOV #BLKSIZ,BUFSIZ
MOV #-BLKSIZ,WRDCNT
RPREAD ;READ HOME BLOCK
BCS 9$ ;-6 ERROR
DEC R5
;SAVE INFORMATION ABOUT THE INDEX FILE & FILE DIRECTORY
MOV #DVBUF+<105.*2>,R1
MOV #RPIXCY,R2
1$: MOV (R1)+,(R2)+
CMP R1,#DVBUF+<111.*2>
BLO 1$
;CHECK THAT THIS IS REALLY THE HOME BLOCK
CMP DVBUF,#105755 ;LAST 16 BITS OF "HOM" IN SIXBIT
BNE 9$ ;-7, BRANCH IF NOT HOM BLOCK
DEC R5
;CHECK THAT THIS PACK CONTAINS OUR FILE SYSTEM (KLFEDDCS)
MOV #DVBUF+<98.*2>,R1
MOV #FSNAME,R2
2$: CMP (R1)+,(R2)+
BNE 9$ ;-10, BRANCH IF FILE SYSTEM NAME IS INCORRECT
CMP R1,#DVBUF+<104.*2>
BLO 2$
DEC R5
;TST RPIXCY ;DOES INDEX FILE EXIST?
;BLE 9$ ;-11, BRANCH IF INDEX FILE DOES NOT EXIST
DEC R5
TST RPFDCY ;DOES FILE DIRECTORY EXIST?
BLE 9$ ;-12, BRANCH IF FILE DIRECTORY DOES NOT EXIST
EXIT ;INDICATE SUCCESS
9$: MOV R5,R0 ;PUT ERROR CODE IN R0
10$: SETFLG ;INDICATE FAILURE
RPUNIT
11$: EXITERR
FSNAME: .ASCII /KLFEDDCS / ;FILE SYSTEM NAME
.SBTTL RPFIND FIND FILE IN RP04 DIRECTORY
;R0 = POINTER TO FILE NAME IN RAD50
;R1 = POINTER TO RETURN STORE BLOCK
; CORE ADR OF FILE DESCRIPTOR BLOCK
; CYLINDER NUMBER
; TRACK/SECTOR NUMBER
$RPFIND:MOV R0,R4 ;SAVE FILE NAME POINTER
MOV R1,R5 ;SAVE RETURN POINTER
MOV #DVBUF,BUFADR
MOV #-BLKSIZ,WRDCNT
MOV #BLKSIZ,BUFSIZ
MOV #FILDSB,R3 ;SETUP FILE DESCRIPTOR POINTER
MOV #RPFDCY,R2 ;SETUP DIRECTORY START
MOV (R2)+,4*2(R3)
MOV (R2)+,5*2(R3)
MOV (R2),R0 ;CHANGE DIR BLOCK COUNT TO
SHIFTL ;WORD COUNT
8.
MOV R0,9.*2(R3)
CLR 8.*2(R3)
MOV R3,R2
ADD #FDESIZ*2,R2
CLR (R2)+ ;CLEAR CURRENT POSITION
CLR (R2)
1$: MOV R3,R0
RPRDFL ;READ DIRECTORY DATA BLOCK
BCS 4$ ;ERROR
MOV (R0)+,R2 ;DATA BUFFER POSITION
MOV (R0),R1 ;BYTE COUNT
2$: CMP (R2),(R4) ;COMPARE DIRECTORY ENTRY
BNE 3$ ;AND REQUESTED FILE
CMP 1*2(R2),1*2(R4)
BNE 3$
CMP 2*2(R2),2*2(R4)
BNE 3$ ;NOT THIS ENTRY
MOV R2,(R5)+ ;RETURN CORE ADDRESS OF DESCRIPTOR BLOCK
MOV CYLNDR,(R5)+ ;RETURN CYLINDER NUMBER
MOV TRKSCT,(R5)+ ;RETURN TRACK/SECTOR NUMBERS
EXIT ;"SUCCESS" RETURN
3$: ADD #FDESIZ*2,R2 ;FINISHED THIS DIRECTORY BLOCK ?
SUB #FDESIZ*2,R1
BHI 2$ ;NO
BR 1$ ;YES, GO READ NEXT
4$: CMP #1,R0 ;EOF ?
BNE 5$ ;NO, RETURN ERROR CODE
MOV #-24,R0 ;YES, RETURN EOF CODE
5$: EXITERR
.SBTTL RPLKUP RP04 FILE DIRECTORY LOOKUP ROUTINE
;R0/ POINTER TO FILENAME IN RAD50
;R1/ STORE ADDRESS FOR FILE DESCRIPTOR
;FILE DESCRIPTOR BLOCK
; 0/ FILENAME
; 1/ "
; 2/ FILE EXT
; 3/ CREATION DATE
; 4/ PHYSICAL BLOCK NUMBER
; 5/ "
; 6/ NUMBER OF WORDS ALLOCATED
; 7/ "
; 8/ NUMBER OF WORDS WRITTEN
; 9/ "
; 10/ PDP-11 LOAD ADDRESS
; 11/ PDP-11 START ADDRESS
; 12/ FILE TYPE & FILE STATUS
; 13/ CHECKSUM
; 14/ 0
; 15/ 0
; 16/ CURRENT POSITION
; 17/ "
$RPLKUP:MOV R1,R5 ;SAVE FILE DESCRIPTOR POINTER
MOV #WRTBAK,R1
RPFIND ;FIND FILE
BCS 2$ ;NOT THERE
MOV #FDESIZ,R2 ;TRANSFER FILE INFO
MOV (R1),R1
1$: MOV (R1)+,(R5)+ ;TO FILE DESCRIPTOR BLOCK
DEC R2
BNE 1$
CLR (R5)+ ;SET CURRENT POSITION AT ZERO
CLR (R5)+
EXIT
2$: EXITERR
.SBTTL RPRDFL READ A FILE (ON THE RP04)
;R0 = POINTER TO FILE DESCRIPTOR
$RPRDFL:MOV R0,R2 ;SETUP FILE DESCRIPTOR POINTER
MOV R2,R4
ADD #16.*2,R4 ;R4 POINTS TO CURRENT POSITION BLOCK
MOV BUFSIZ,R3 ;BUFFER SIZE TO R3
MOV 8.*2(R2),R0 ;R0 = M.S. NUMBER OF WORDS WRITTEN
MOV 9.*2(R2),R1 ;R1 = L.S. NUMBER OF WORDS WRITTEN
SUB 2(R4),R1 ;R1 = L.S. NUMBER OF WORDS REMAINING
SBC R0 ;PROPAGATE THE "BORROW"
SUB (R4),R0 ;R0 = M.S. NUMBER OF WORDS REMAINING
BLT 40$ ;BRANCH IF PAST EOF (ERROR)
BGT 10$ ;BRANCH IF MORE THAN 2**16 WORDS REMAIN
TST R1 ;NOW LOOK AT L.S. # OF WORDS REMAINING
BEQ 60$ ;BRANCH IF AT EOF
CMP R1,R3 ;COMPARE REMAINING WORDS WITH "BUFSIZ"
BHI 10$ ;BRANCH IF REMAINING WORDS IS LARGER
MOV R1,R3 ;REMAINING WORDS IS SMALLER (OR EQUAL)
BR 15$ ;AVIOD TRUNCATING THE BUFFER SIZE
10$: BIC #BLKSIZ-1,R3 ;TRUNCATE TO A MULTIPLE OF THE BLOCK SIZE
15$: BIT #BLKSIZ-1,2(R4) ;IS CURRENT POSITION A MULTIPLE OF BLOCK SIZE?
BNE 50$ ;BRANCH IF NOT A MULTIPLE OF BLOCK SIZE
MOV 4*2(R2),CYLNDR ;CYLINDER NUMBER OF START OF FILE
MOV 5*2(R2),TRKSCT ;TRACK,SECTOR OF START OF FILE
MOV (R4),R2 ;R2 = M.S. CURRENT POSITION
SWAB R2
BISB 3(R4),R2
MOV R2,OFFSET
RPADDR ;COMPUTE BLOCK # TO BE READ
NEG R3
MOV R3,WRDCNT ;SETUP WORD COUNT
NEG R3
RPREAD ;READ FILE DATA BLOCK
BCS 70$ ;READ ERROR
ADD R3,2(R4) ;UPDATE L.S. CURRENT POSITION
ADC (R4) ;PROPAGATE CARRY INTO M.S. CURRENT POSITION
ASL R3 ;CONVERT WORDS READ TO BYTES
75$: MOV R3,$RPINFO+2 ;AND STORE AS BYTE COUNT ARGUMENT
MOV BUFADR,$RPINFO ;STORE BUFFER ADDRESS
MOV #$RPINFO,R0
EXIT
40$: MOV #-13,R0 ;WE SEEM TO BE PAST THE EOF
BR 30$
50$: MOV #-14,R0 ;WE WERE POSITIONED AT A NON-MULTIPLE OF BLKSIZ
BR 30$
60$: MOV #1,R0 ;WE WERE ALREADY AT EOF
BR 30$
70$: MOV #-15,R0 ;INDICATE THAT NO DATA WAS READ
30$: EXITERR
.SBTTL RPWRFL WRITE A FILE (ON THE RP04)
;R0 = POINTER TO FILE DESCRIPTOR
;BUFADR = ADDRESS OF BUFFER
;BUFSIZ = NUMBER OF WORDS TO BE WRITTEN
;RPEOF = BIT15=0, DON'T WRITE EOF; BIT15=1, WRITE EOF
$RPWRFL:MOV R0,R2
MOV 16.*2(R2),R0 ;R0 = M.S. CURRENT POSITION
MOV 17.*2(R2),R1 ;R1 = L.S. CURRENT POSITION
MOV BUFSIZ,R3
BEQ 70$ ;BRANCH IF THE WORD COUNT IS ZERO
TST RPEOF ;WRITING AN EOF ?
BMI 1$ ;YES
BIT #BLKSIZ-1,R3 ;IS BUFSIZ A MULTIPLE OF BLKSIZ?
BNE RPWER1 ;BRANCH IF IT IS NOT A MULTIPLE
1$: BIT #BLKSIZ-1,R1 ;IS THE CURRENT POSITION A MULTIPLE?
BNE RPWER2 ;BRANCH IF IT IS NOT A MULTIPLE
MOV R0,R4 ;R4 = M.S. CURRENT POSITION
ADD R3,R1 ;R1 = L.S. NEW POSITION
ADC R0 ;R0 = M.S. NEW POSITION
CMP 6.*2(R2),R0 ;COMPARE WITH WORDS ALLOCATED
BGT 5$ ;BRANCH IF MORE WORDS ALLOCATED
BLT RPWER3 ;BRANCH IF NOT ENOUGH WORDS ALLOCATED
CMP 7.*2(R2),R1 ;ITS CLOSE, LOOK FURTHER
BLO RPWER3 ;BRANCH IF NOT ENOUGH WORDS ALLOCATED
5$: SWAB R4
BISB <17.*2>+1(R2),R4
MOV R4,OFFSET
MOV 4.*2(R2),CYLNDR ;CYLINDER NUMBER
MOV 5.*2(R2),TRKSCT ;TRACK/SECTOR NUMBERS
RPADDR
NEG R3
MOV R3,WRDCNT
NEG R3
RPWRIT ;WRITE DATA BLOCK
BCS RPWER5
ADD R3,17.*2(R2) ;COMPUTE NEW CURRENT POSITION
ADC 16.*2(R2) ;PROPAGATE CARRY
MOV 17.*2(R2),9.*2(R2) ;SET EOF AT CURRENT POSITION
MOV 16.*2(R2),8.*2(R2) ;(M.S. ALSO)
70$: TST RPEOF ;ARE WE WRITING AN EOF
BPL RPWEX ;NO
MOV R2,R0
MOV #WRTBAK,R1
MOV #DVBUF,BUFADR
MOV #-BLKSIZ,WRDCNT
MOV #BLKSIZ,BUFSIZ
MOV 2(R1),CYLNDR ;SETUP SAME DIRECTORY BLOCK
MOV 4(R1),TRKSCT
RPREAD ;READ CURRENT FILE DIRECTORY BLOCK
BCS RPWER4
MOV (R1)+,R3
CMP 6.*2(R2),6.*2(R3)
BNE RPWER0 ;BRANCH IF ALLOCATION IS DIFFERENT
CMP 7.*2(R2),7.*2(R3)
BNE RPWER0 ;BRANCH IF ALLOCATION IS DIFFERENT
MOV #FDESIZ,R4
71$: MOV (R2)+,(R3)+
DEC R4
BNE 71$
MOV (R1)+,CYLNDR
MOV (R1)+,TRKSCT
RPWRIT ;REWRITE DIRECTORY
BCS RPWER4
RPWEX: EXIT ;SUCCESSFUL COMPLETION WITH NO EOF
RPWER0: MOV #-16,R0 ;ATTEMPT TO CHANGE FILE'S ALLOCATION
BR RPWERX
RPWER1: MOV #-17,R0 ;BUFSIZ IS NOT A MULTIPLE OF BLOCK SIZE
BR RPWERX
RPWER2: MOV #-20,R0 ;CURRENT POS. IS NOT A MULTIPLE OF BLOCK SIZE
BR RPWERX
RPWER3: MOV #-21,R0 ;INSUFFICIENT ALLOCATION TO COMPLETE THIS WRITE
BR RPWERX
RPWER4: MOV #-22,R0 ;DIRECTORY REWRITE FAILURE
BR RPWERX
RPWER5: MOV #-23,R0 ;DATA BLOCK WRITE FAILURE
RPWERX: EXITERR
.SBTTL RPINIT STORES UNIT NUMBER & TRIES TO SET VOLUME VALID
$RPINIT:MOV #-1,R0
MOV RPUNIT,R2 ;CHECK RP04 UNIT #
BIT #-7-1,R2
BNE 2$ ;-1 ERROR, BAD
DEC R0
MOV RPRH11,R1
MOV #RPCLR,RPCS2(R1) ;CLEAR RP04
MOV R2,RPCS2(R1) ;SELECT
BIT #RPDVA,(R1) ;IS DRIVE AVAILABLE ?
BEQ 2$ ;-2 ERROR, NO
DEC R0
MOV RPDS(R1),R2 ;READ STATUS
COM R2
BIC #-<RPMOL!RPDPR!RPDRY>-1,R2
BNE 2$ ;-3 ERROR, DRIVE ERROR
DEC R0
MOV #RPPRST,(R1) ;SET READ-IN PRESET
1$: TSTB (R1) ;WAIT FOR CONTROLLER READY
BPL 1$
BIT #<RPTRE!RPMCPE>,(R1)
BNE 2$ ;-4 ERROR, DRIVE ERROR
DEC R0
BIT #<RPATA!RPERR>,RPDS(R1)
BNE 2$ ;-5 ERROR, DRIVE ERROR
3$: EXIT
2$: BIS #100000,RPUNIT ;ERROR, FORCE RESELECT
EXITERR
.SBTTL RPBASE RETURN RP04 PARAMETER BLOCK BASE ADDRESS
$RPBASE:MOV #FILDSB,R0
EXIT
.SBTTL RPREAD & RPWRIT, RP04 READ & WRITE I/O ROUTINES
$RPWRIT:MOV #RPWTFN,R5 ;SETUP WRITE FUNCTION
CLR R4
BR RPFUNC
$RPREAD:MOV #RPRDFN,R5 ;SETUP READ FUNCTION
MOV #10.,R4 ;10 RETRIES
RPFUNC: JSR PC,$PTTYC
TST RPUNIT ;VALID UNIT ?
BMI 2$ ;NO
MOV RPRH11,R1
5$: MOV RPUNIT,RPCS2(R1) ;SELECT DRIVE
BIT #RPDVA,(R1) ;IS DRIVE AVAILABLE ?
BEQ 2$ ;NO
MOV RPDS(R1),R2 ;CHECK DRIVE STATUS
COM R2
BIC #-<RPMOL!RPDPR!RPDRY!RPVV>-1,R2
BNE 2$ ;ERROR
MOV CYLNDR,RPDC(R1) ;START DRIVE OPERATION
MOV TRKSCT,RPDA(R1)
MOV BUFADR,RPBA(R1)
MOV WRDCNT,RPWC(R1)
MOV R5,(R1)
1$: BIT #<RPTRE!RPMCPE!RPRDY>,(R1)
BEQ 1$ ;WAIT FOR COMPLETION OR ERROR
BIT #<RPTRE!RPMCPE>,(R1)
BNE 2$ ;ERROR
BIT #<RPATA!RPERR>,RPCS2(R1)
BNE 4$ ;ERROR
3$: EXIT ;COMPLETED
2$: EXITERR
4$: DEC R4 ;RETRY READ ERRORS, 10 TIMES
BLE 2$ ;HARD ERROR
MOV #RPCLR,RPCS2(R1) ;CLEAR RP04
BR 5$ ;TRY AGAIN
.SBTTL RPADDR ADDS OFFSET TO AN RP04 PHYSICAL ADDRESS
$RPADDR:MOV CYLNDR,R0 ;SETUP INITIAL VALUES
MOV TRKSCT,R1
MOV OFFSET,R2
MOVB R1,R3 ;COMPUTE NEW POSITION
CLRB R1
SWAB R1
ADD R3,R2
1$: BPL 2$
DEC R0
ADD #19.*20.,R2
BR 1$
2$: SUB #19.*20.,R2
BLT 3$
INC R0
BR 2$
3$: ADD #19.*20.,R2
4$: SUB #20.,R2
BLT 5$
INC R1
BR 4$
5$: ADD #20.,R2
6$: SUB #19.,R1
BLT 7$
INC R0
BR 6$
7$: ADD #19.,R1
SWAB R1
BISB R2,R1
MOV R0,CYLNDR ;RETURN NEW POSITION
MOV R1,TRKSCT
EXIT

397
src/kldcp/sbst11.10 Executable file
View File

@@ -0,0 +1,397 @@
;;;MODIFICATION HISTORY
;;;
;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7)
;;; 15 NOV 75 CONVERTED TO PALX FORMAT
;;;
.SBTTL *STORE* PROGRAM STORAGE FILE, 5-AUG-75
.MACRO INFORM A,B
.IF P2
.PRINT\A=B
\
.ENDC
.ENDM
INFORM PROGRAM END,\.
.NLIST
.IF DF KLDCP
.LIST
;DECISION TABLES FOR KL10/11 SUBROUTINE PACKAGE
$DTBL0:
$LF: .BYTE 12
$CR: .BYTE 15
$BELL: .BYTE 07
.BYTE 00
.EVEN
$DTBL1: $LFTBL ;LINE FEED FILL TABLE
$CRTBL ;CARRIAGE RETURN FILL TABLE
$BELLT ;BELL FILL TABLE
$LFTBL: .BYTE 1,1
.BYTE 2,1
.BYTE 2,4
$CRTBL: .BYTE 0,0
.BYTE 9.,1
.BYTE 2,4
$BELLT: .BYTE 2,2
.BYTE 2,2
.BYTE 2,2
$DTBL: 10000.
1000.
100.
10.
1.
$TBLL: 1.
10.
100.
1000.
10000.
.NLIST
.ENDC ;KLDCP
.LIST
;THIS SECTION CONTAINS ALL PROGRAM TEXT LITERALS
$$FF: $$CLIT
$$LITT=.
$$$FF=$$CLIT
INFORM LITERAL END,\$$CLIT
;BUFFER CREATION MACROS
$$BUF= COREND-600 ;ROOM FOR STACK
;WORD BUFFER ASSIGNMENT MACRO
;USAGE IS: .BUFW TAG=,NUMBER-OF-WORDS [OPTIONAL]
.MACRO .BUFW $BTAG,$BARG
.IIF NE $$BUF&1,$$BUF=$$BUF-1
.IIF B $BARG,$$BARG=1
.IIF NB $BARG,$$BARG=$BARG
$$BUF=$$BUF-<$$BARG*2>
; .NLIST
; .LIST ME
; .LIST
$BTAG $$BUF
; .NLIST ME
.ENDM
;BYTE BUFFER ASSIGNMENT MACRO
.MACRO .BUFB $BTAG,$BARG
.IIF B $BARG,$$BARG=1
.IIF NB $BARG,$$BARG=$BARG
$$BUF=$$BUF-$$BARG
; .NLIST
; .LIST ME
; .LIST
$BTAG $$BUF
; .NLIST ME
.ENDM
; .NLIST LOC
;PROGRAM BUFFERS & STORAGE AREA
;CLEARED ON INITIALIZATION
;STORAGE FOR DTE20 ADDRESS POINTERS
.BUFW .DIAG3= ;XXX36
.BUFW .STDTE= ;XXX34
.BUFW .DIAG2= ;XXX32
.BUFW .DIAG1= ;XXX30
.BUFW .T11DT= ;XXX26
.BUFW .T10DT= ;XXX24
.BUFW .T11AD= ;XXX22
.BUFW .T10AD= ;XXX20
.BUFW .BC11= ;XXX16
.BUFW .BC10= ;XXX14
.BUFW .TENA2= ;XXX12
.BUFW .TENA1= ;XXX10
.BUFW .DAT1= ;XXX06
.BUFW .DAT2= ;XXX04
.BUFW .DAT3= ;XXX02
.BUFW .DELAY= ;XXX00
;SPECIAL LOAD ONLY CLEAR & SETUP AREA
.BUFW $ONETM= ;ONE TIME FLAG
.BUFW $ILDSUM= ;"KLDCP" CHECKSUM
.BUFW $PWRCNT= ;POWER RESTART COUNT
.BUFW DEVTYP= ;DEVICE TYPE: -1=ACT, 0=DTA, 1=RP04
.BUFW FLOPPY= ;-1, USE RX11/RX01 FLOPPY
.BUFW LPTFLG= ;LINE PRINTER FLAG
.BUFW LPTYPE= ;LINE PRINTER TYPE
.BUFW RXUNIT= ;FLOPPY UNIT
.BUFW DTUNIT= ;DECTAPE UNIT
.BUFW RPUNIT= ;RP04 UNIT
.BUFW $BKFLG= ;BREAKPOINT FLAG
.BUFW CLKPE=,3 ;CLOCK PE DFWRT STORAGE
.BUFW PEBITS= ;CLOCK STOP PARITY ENABLE BITS
.BUFW PAGDFL=,3 ;KL10 "DATAO PAG,0" DEFAULT
.BUFW CLKDFL=,3 ;KL10 CLOCK DEFAULT
.BUFW SWS10=,3 ;PDP-10 SWITCHES
.BUFW $SWS10=,3
.BUFW $$SWR=
.BUFW $$STJRS=,3 ;PDP-10 START "JRST"
.BUFW $STODD= ;"SETMPH" VARIABLES
.BUFB $MPHMK= ;MASK, A OR B CHANGE
.BUFB $MPHDF= ;DIAG FCN, A OR B CHANGE
.BUFW TGOADR=,2 ;PDP-10 GO START ADDRESS
.BUFW PGOADR=,2 ;PROGRAM GO ADDRESS
.BUFW PGOCTL= ;PROGRAM GO CONTROL
.BUFW SEADR= ;PDP-11 START ADDRESS
.BUFW ITSFLG= ;NON-ZERO ITS IOELEVEN PROGRAM IS IN CORE
;KLINIK FIELD SERVICE REMOTE FLAG
.BUFW DL11EFLG=
;BP TABLE; INST, ADR, CNT
.BUFW $BT=,<$NB*3> ;BP TABLE
.BUFW $BCA= ;BP CONTINUE ADDRESS
.BUFW $BTIS= ;BP TEMP
$ILDCLR=$$BUF
;COMMON STORAGE
.BUFW $SWMON= ;MONITOR LOW ORDER SWITCHES
.BUFW MONCTL= ;0=STANDALONE, -1=MONITOR
.BUFW TENSWD= ;PDP-10 SWITCH DEPOSIT FLAG
.BUFW TENCLK= ;PDP-10 CLOCK ENABLE FLAG
.BUFW PCMDFLG= ;PROGRAM COMMAND FLAG
.BUFW PCMDNF= ;PROGRAM CMD NO PRINT FLAG
.BUFW $ITERA= ;ITERATION REGISTER
.BUFW $ENDCT= ;END OF PASS REPORT COUNT
.BUFW $EOPCT= ;END OF PASS COUNT
.BUFW $ERRPC= ;ERROR PC
.BUFW $ERTTL= ;TOTAL ERRORS DETECTED
.BUFW $ERFLG= ;ERROR FLAG
.BUFW $PASS= ;PASS COUNT
.BUFW $CMTAG= ;COMMON TAG
;DECTAPE/RP04 AND LOADING BUFFERS
.BUFW DVBUF=,256. ;DEVICE BUFFER
VFUDAT=DVBUF
.BUFW EXTBF=,2 ;ASCII EXTENSION BUFFER
.BUFW NAMBF=,3 ;ASCII NAME BUFFER
.BUFW DIRST4=
.BUFW DIRST3=
.BUFW DIRST2=
.BUFW DIRST1=
.BUFW DIRST0= ;PSEUDO DIRECTORY CONVERSION STORAGE
.BUFW DTEXT= ;RAD50 EXT
.BUFW DTEXTS=,3 ;UNPACKED EXT (ASCII)
.BUFW DTLNGTH= ;DECTAPE FILE LENGTH
.BUFW DTSTRT= ;DECTAPE FILE START BLOCK
.BUFW DVADR= ;DEVICE DATA ADDRESS POINTER
.BUFW DVCNT= ;DEVICE BYTE COUNT
.BUFW DVDIRF= ;DEVICE DIRECTORY FLAG
.BUFW CDADR= ;CORE DUMP BUFFER POINTER
.BUFW DIAFLG= ;"DIAMON" OPERATION FLAG
.BUFW RPEOF= ;END-OF-FILE FLAG
.BUFW WRTBAK=,3 ;RPLKUP & RPWRFL RETURN INFO
.BUFW $RPINFO=,2 ;DVDATA POINTERS
.BUFW NAMRAD=,3 ;RAD50 NAME.EXT
.BUFW RPFDNB= ;FILE DIRECTORY LENGTH IN BLOCKS
.BUFW RPFDTS= ;FILE DIRECTORY TRACK & SECTOR
.BUFW RPFDCY= ;FILE DIRECTORY CYLINDER NUMBER
.BUFW RPIXNB= ;INDEX FILE LENGTH IN BLOCKS
.BUFW RPIXTS= ;INDEX FILE TRACK & SECTOR
.BUFW RPIXCY= ;INDEX FILE CYLINDER NUMBER
.BUFW RPIXCB= ;INDEX FILE CURRENT BLOCK
.BUFW RPLAST= ;INDEX FILE LAST BLOCK
.BUFW CYLNDR= ;CURRENT CYLINDER
.BUFW TRKSCT= ;CURRENT TRACK & SECTOR
.BUFW OFFSET= ;CURRENT OFFSET
.BUFW BUFADR= ;BUFFER ADDRESS
.BUFW BUFSIZ= ;BUFFER SIZE
.BUFW WRDCNT= ;READ/WRITE WORD COUNT
.BUFW FILDSB=,FDESIZ+2 ;FILE DESCRIPTOR
;DECTAPE PARAMETER STORAGE
.BUFW REVCNT= ;REVERSE COUNT
.BUFW INTSW= ;INIT SWITCH
.BUFW $CKS11= ;PDP-11 BINARY CHECKSUM
.BUFW LTMP= ;LOAD TEMP
.BUFW LBC= ;LOAD BYTE COUNT
.BUFW TRYCTR= ;DECTAPE TRY COUNT
.BUFW DTXCMD= ;DECTAPE XFER COMAND
.BUFW WCSAV= ;WORD COUNT SAVE
.BUFW CASAV= ;CURRENT ADDRESS SAVE
.BUFW DTBLK= ;DECTAPE BLOCK NUMBER
;FLOPPY PARAMETER STORAGE
.BUFW $$ITS1= ;FLOPPY "$RXITS" COUNTER
.BUFW RXSADR= ;FLOPPY SECTOR ADDRESS
.BUFW RXTADR= ;FLOPPY TRACK ADDRESS
.BUFW RXBLKT= ;FLOPPY BLOCK # TEMP
.BUFW RXWCMD= ;FLOPPY WORKING COMMAND
.BUFW RXCMD= ;FLOPPY COMMAND
.BUFW RXBLK= ;FLOPPY BLOCK NUMBER
;LOAD PARAMETER STORAGE
.BUFW LDATAE=
.BUFW LDATA=,34. ;LOAD DATA
.BUFW LDADR= ;LOAD ADDRESS
.BUFW LDCNT= ;LOAD WORD COUNT
.BUFW LDOCTF= ;LOAD OCTAL FORMAT FLAG
.BUFW LDCNTL= ;LOAD CONTROL WORD
.BUFW LDOVRD= ;LOAD CONTROL OVERRIDE
.BUFW LDZBLK= ;LOAD 10 ZERO BLOCK FLAG
.BUFW SRTFLG= ;SELF START FLAG
.BUFW DEVLC= ;DEVICE LINE COUNT
.BUFW ARETRY= ;ACT10 RETRY COUNT
.BUFW HLPPNT= ;ACT10 HELP PRINT FLAG
.BUFW EMTLDD=,2 ;HOLDS WHAT TO LOAD INTO EMT VECTOR
;TELETYPE BUFFERS
.BUFW $INPTR= ;INPUT POINTERS
.BUFW $INPTC=
.BUFB $INBUF=,142. ;INPUT BUFFER
.BUFW $OUTPC= ;OUTPUT POINTERS
.BUFW $OUTPT=
.BUFW $OUTPP= ;OUTPUT PRINT POSITION
.BUFB $OUTBF=,142. ;OUTPUT BUFFER
.BUFW $TNPTR= ;10 INPUT POINTERS
.BUFW $TNPTC=
.BUFB $TNBUF=,142. ;10 INPUT BUFFER
.BUFW $TNCHR=,3 ;LAST CHAR TYPED (FOR TEN)
.BUFW TENTTY= ;10 "TENCHR" FLAG
.BUFW $TTYIN=
.BUFB $TTSAV=,12.
.BUFW ENQFLG= ;COMMUNICATIONS IN PROGRESS
.BUFW MSGNBR= ;COMMUNICATIONS MESSAGE NUMBER
.BUFW COMNBR= ;COMMUNICATION NUMBER
.BUFB COUTBF=,142. ;COMMUNICATIONS OUTPUT BUFFER
.BUFW COUTSP=,2 ;OUTPUT CONTROL CHARACTERS
.BUFB CINBF=,142. ;COMMUNICATIONS INPUT BUFFER
.BUFW CINSP=,2 ;INPUT CONTROL CHARACTERS
.BUFW $PRNTH= ;PRINT HEAD POSITION
.BUFW $PGWID= ;PAGE WIDTH
.BUFW $TPLIN= ;NUMBER OF LINES ON A PAGE
.BUFW $TPLIT= ;LINES TALLY
.BUFW $XOFLG= ;XOFF FLAG, -1 = NO PRINT
.BUFW CTRLOF= ;CONTROL O FLAG
.BUFW $EOLFLG= ;END OF LINE FLAG
.BUFW $TTLKF= ;TTLOOK INPUT CHECKS INHIBIT
.BUFW TILNWF= ;TTY INPUT WAIT FLAG
.BUFW $FORCE= ;FORCE PRINTOUT FLAG
.BUFW $TTYFL= ;TTY FILL PARAMETER
.BUFW $0FLG= ;ZERO FILL FLAG
.BUFW $NEG= ;NEGATE NUMBER INPUT FLAG
.BUFW $SVH=
.BUFW $SVM=
.BUFW $TICHR= ;TTY DRIVER INPUT CHAR
.BUFW $TOCHR= ;TTY DRIVER OUTPUT CHAR
.BUFW DDTFLG= ;PDP-10 DDT INPUT MODE FLAG
;CONSOLE PARAMETER STORAGE
.BUFW $KONSP= ;SAVED STACK POINTER
.BUFW ALLFLG= ;ALL PRINT FLAG
.BUFW RPTFLG= ;COMMAND REPEAT FLAG
.BUFW VERIFY= ;PROGRAM VERIFY FLAG
.BUFW .EADR= ;EXAMINE 11 ADDRESS
.BUFW $ECADR= ;EXAMINE C-RAM ADDRESS
.BUFW $EDADR= ;EXAMINE D-RAM ADDRESS
.BUFW $ADR=
.BUFW .DFRDA=,3
.BUFW .DPXAD=,2
.BUFW L10ADR=,2 ;LOAD 10 ADDRESS
.BUFW TENRUN= ;TEN RUNNING FLAG
.BUFW MONMODE= ;TEN MONITOR MODE FLAG
.BUFW MTTYOF= ;MONITOR TTY OUTPUT IN PROGRESS
.BUFW $TTYTIM= ;TTY TIMEOUT COUNT
;BREAKPOINT STORAGE
.BUFW $R0TMP=
.BUFW $PCSAV=
.BUFW $PSSAV=
.BUFW $TEMP0=,3
.BUFW $ADR1=
.BUFW $SPSAV=
.BUFW $R5SAV=
.BUFW $R4SAV=
.BUFW $R3SAV=
.BUFW $R2SAV=
.BUFW $R1SAV=
.BUFW $R0SAV=
;MISCELLANEOUS STORAGE
.BUFW $EMADR= ;EMT ADDRESS (+2)
.BUFW $SWTCH= ;SWITCHES
.BUFW $$SVSP=
.BUFW TEMP=
.BUFW IFILEF= ;INDIRECT FILE FLAG
.BUFW IFINP= ;INDIRECT STORAGE POINTER
.BUFW JFILEF= ;DOUBLE INDIRECT FILE FLAG
.BUFW JFINP= ;DOUBLE INDIRECT STORAGE POINTER
.BUFW PRGRUN= ;PROGRAM RUNNING FLAG
.BUFW MEMPEF= ;PARITY FLAG
.BUFW .HCFLG= ;ALLOW HALT CONTINUE FLAG
.BUFW .HCADR= ;HALT CONTINUE ADDRESS
.BUFW DDTTM1= ;DDT MODE TIMEOUT COUNTS
.BUFW DDTTM2=
.BUFW $ECMD=,3 ;DTE20 COMMAND STORAGE
.BUFW $SAV20=,3 ;PDP-10 SAVE 20 STORAGE
;KL10 SUBROUTINE STORAGE
.BUFW ZEROS=,3 ;SOURCE OF 36 ZEROS
.BUFW VMADAT=,3 ;VMA & PC TEMP
.BUFW XXDAT= ;DF WRITE TEMP
.BUFW MMDAT=,3 ;WWADR TEMP
.BUFW WREADY=,3 ;$WCRAM TEMP
.BUFW SIGNL=
.BUFW $BUFRC=,6 ;$RCRAM TEMP
.BUFW SIGNL2=
.BUFW SIGNL3=
.BUFW DDRAM=,3 ;$DRAMAD TEMP
.BUFW RDRTMP=,2 ;$RDRAM TEMP
.BUFW $DRAM=,6
.BUFW $DDRMS=
.BUFW $STDAT= ;$BURST TEMP
.BUFW KLCLKR= ;KL10 CLOCK LOGICALLY RUNNING FLAG
.BUFW TENDAT=,3 ;PDP-10 INPUT DATA WORD
.BUFW TENAC0=,2 ;PDP-10 AC0 ADDRESS
.BUFW C10CW=,3 ;PDP-10 CLOCK WAIT COUNT
.BUFW CLKCNT=,3 ;PDP-10 CLOCK COUNT
BUFCLR= $$BUF
; .LIST LOC
INFORM LOWEST VARIABLE,\$$BUF

2152
src/kldcp/sub11.14 Executable file

File diff suppressed because it is too large Load Diff