1
0
mirror of https://github.com/PDP-10/its.git synced 2026-02-27 17:22:35 +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

View File

@@ -931,3 +931,7 @@ respond "TT10SW=" "0\r"
respond "VT05SW=" "0\r"
respond "DEBSW=" "0\r"
expect ":KILL"
# KL10 diagnostics console program.
respond "*" ":palx kldcp; kldcp\r"
expect ":KILL"

47
doc/kldcp/ioelev.conven Executable file
View File

@@ -0,0 +1,47 @@
Conventions for relations between KLDCP and IOELEV
Core locations -
3000 KLDCP does JSR PC, here when it has nothing to do
and 10 is running. IOELEV should INIT if it hasn't
already, then go into its main loop. It should CLC, RTS PC
if the 10 goes down; KLDCP will print appropriate message.
To go into temporary KLDCP command mode, SEC, RTS PC.
If microcode hangs, PMSG <...>, JMP 100004 (CTRLC).
3004, 3006 - .RAD50 /IOELEV/
3010, 3012 - random crufty version numbers (not actually used)
14, 16 BPT vector, I guess it's OK for 11 ddt to use these.
.. interrupt vectors for various devices are initially set
up by KLDCP to point to error routine; IOELEV can load
over these.
0-400 vectors
3000-? IOELEV (what is 400-3000 used for?)
?-100000 11 DDT
100000-? KLDCP
?-160000 stack
KLDCP will supply IOELEV with a stack; 11 DDT will have to be modified
to believe it.
Even while the IOELEV main loop is not running, interrupts will be
turned on and IOELEV P.I. level can run. Various things like "MR" will
do a pdp11 "RESET" instruction and flush this. This allows the right thing
to happen if the 10 halts, you go to KLDCP, in KLDCP you type DDT, and
now you're back in IOELEV.
Consequently IOELEV has to handle the flavor of teletype that DDT & SALV use.
It's best to do an "RI" before running, e.g., DEC diagnostics.
IOELEV isn't allowed to turn on interrupts for any devices that KLDCP
also uses; mainly, 60-cycle clock and DTE20. These have to be handled
entirely in the main program and not touched at all at P.I. level (since
IOELEV's P.I. level runs concurrently with KLDCP.)
IOELEV main program level can (and will) use KLDCP's EMT's to hack the DTE20.

104
doc/kldcp/kldcp.inst Normal file
View File

@@ -0,0 +1,104 @@
KL10 CONSOLE INSTRUCTIONS
Conventions:î____________
Commands end with carriage return. DELETE deletes the last character
typed; deleted characters are echoed between backslashes. CTRL/U
deletes the line being typed.
Numbers are octal. 36-bit numbers may be typed as two half-words
separated by a space. Negative numbers may be entered; thus -1 means
36 1-bits. In the following, <foo> is a symbol; don't type the angle
brackets.
To examine and deposit memory:î______________________________
"EM <address>" types out the contents of the addressed location. If
<address> is omitted, the last address used is used again. "EN"
examines the last address used plus one. "EM <first> , <last>"
examines the <first> address through the <last> address, inclusive.
Don't put spaces around the comma.
"DM <address> : <contents>" deposits into memory. You can omit the
<address>, but not the colon, to re-use the last address used.
Putting R and a space in front of a command repeats it, with
typeout turned off, until you hit CTRL/C.
The Switches:î_____________
The left-most 16 switches are on the pdp11 panel. Numbers have been
affixed to indicate the pdp10 bit numbers. The remaining switches are
set by the "SW <octal value>" command. "SW" alone types out the
current setting of the switches.
Running Diagnostics:î____________________
Load the DEC microcode with the "P U.RAM" command. Type "SM" to start
the microcode. To run DG series diagnostics, which run in the pdp11,
type e.g. "P DGKAB.A11", then "SED". To run other diagnostics, which
run in the pdp10, type "P SUBRTN", then "P DDMMG" (for instance), then
"STD" to start it.
Stopping a Running Program:î___________________________
Hit BREAK, then CTRL/C. If the running program is in the pdp10, the
"SP" command is needed to stop it.
Powering the machine back on:î_____________________________
Check for boxes with no lights on; their circuit breakers may have
tripped. Hit the DISK button to reload KLDCP. If it doesn't reload,
disk unit 0 may need to be powered on and off. Type "RP0" to select
disk unit 0. Do "J KLINIT". This loads the ITS microcode and
configures memory and cache. If you get a bunch of "ADR=xxx COR=yyy
ACT=000" messages, some memory is hung. Try resetting it. (RESET
switch is at bottom right inside front door of each memory.)
Standard Tests:î_______________
"J KLDIAG" runs a series of diagnostics to check out the processor.
Switch 0 is raised to stop each diagnostic (at the end of the current
pass) and run the next. If it says "please load u code ver 73" do "P
MBOX.RAM" then "HC". The "E bus diagnostic enable switch" is a toggle
inside the front door of the left-most bay, near the "DTE SWITCH
PANEL" decal.
To run memory tests, "P U.RAM", "SM", "PE0", "P SUBRTN", "P DDMMG",
"STD". Or, "P DGKBB.A11", "SED".
Other Commands:î_______________
"MR" does a master reset of the machine.
"SM" starts the microcode. Try this if you get "? UCODE HUNG",
"? EM ERR", etc.
"J NTSDDT" loads in an exec DDT from disk.
A complete list of KLDCP commands is in an 8 1/2 x 11 printout
labelled "KLDCP OPR" around somewhere in the machine room.
Map of the machine:î___________________
(Door) DISK #2 #1 #0 (RP04)
I/O BAY CPU BAY CONSOLE BAY
(DMA, DIA, IMP) (MBOX, EBOX) (PDP11, DECTAPE)
LA36
TAPE DRIVE (TU41) CONSOLE TTY DISK CONTROL (RH10)
TAPE CONTROL (TM10B) DISK CHANNEL (DF10C)
TAPE CHANNEL (DF10C) MEMORY A (MF10)
IO PDP11 CHANNEL (DL10) MEMORY B (MF10)
IO PDP11 (PDP11/40) . . .
IO PDP11 (DH11) MEMORY H (MF10)
(Door) 

View File

@@ -99,6 +99,7 @@
- JEDGAR, counter spying tool.
- JOBS, list jobs by category.
- JOTTO, word-guessing game.
- KLDCP, KL10 diagnostics console program.
- KLFEDR, KL10 frontend directory tool.
- KLRUG, KL10 frontend debugger.
- LAY, SUDS layout program.

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