diff --git a/build/misc.tcl b/build/misc.tcl index 9127ca69..f15b6d48 100644 --- a/build/misc.tcl +++ b/build/misc.tcl @@ -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" diff --git a/doc/kldcp/ioelev.conven b/doc/kldcp/ioelev.conven new file mode 100755 index 00000000..371f3d64 --- /dev/null +++ b/doc/kldcp/ioelev.conven @@ -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. + \ No newline at end of file diff --git a/doc/kldcp/kldcp.inst b/doc/kldcp/kldcp.inst new file mode 100644 index 00000000..44701163 --- /dev/null +++ b/doc/kldcp/kldcp.inst @@ -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, is a symbol; don't type the angle +brackets. + +To examine and deposit memory:î______________________________ + +"EM
" types out the contents of the addressed location. If +
is omitted, the last address used is used again. "EN" +examines the last address used plus one. "EM , " +examines the address through the address, inclusive. +Don't put spaces around the comma. + +"DM
: " deposits into memory. You can omit the +
, 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 " 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)  \ No newline at end of file diff --git a/doc/programs.md b/doc/programs.md index 08a17a7c..e62dc6d7 100644 --- a/doc/programs.md +++ b/doc/programs.md @@ -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. diff --git a/src/kldcp/apt11.2 b/src/kldcp/apt11.2 new file mode 100755 index 00000000..6b11f4fb --- /dev/null +++ b/src/kldcp/apt11.2 @@ -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 +$$C2: JMP $CNTLC + +ACTLDC: PMSG + BR ACTERR + +ACTBCK: PMSG + BR ACTERR + +ACTLDF: PMSG + +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 +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 + 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 + 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 + \ No newline at end of file diff --git a/src/kldcp/beg11.1 b/src/kldcp/beg11.1 new file mode 100755 index 00000000..b20ca95a --- /dev/null +++ b/src/kldcp/beg11.1 @@ -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 + \ No newline at end of file diff --git a/src/kldcp/bpnt11.1 b/src/kldcp/bpnt11.1 new file mode 100755 index 00000000..91e79f5f --- /dev/null +++ b/src/kldcp/bpnt11.1 @@ -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 + MOV 4(SP),R0 + PNTOCT +$BPEX1: PCRLF +$BPEXT: JMP $CONSL ;RETURN TO MONITOR + +$BPERR: PMSG + 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 +.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 + 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 + \ No newline at end of file diff --git a/src/kldcp/br11.9 b/src/kldcp/br11.9 new file mode 100755 index 00000000..28d0688f --- /dev/null +++ b/src/kldcp/br11.9 @@ -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 + MOV R1,R0 + PNTOCT + PMSG + MOV 16(SP),R0 ;GET ADDRESS OF CALL +$DFTMX: TST -(R0) + PNTOCT + JMP $CNTLC + +$ECTIM: PMSG + +$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!,@.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!,@.DIAG1 +$$DFXDN: +$KLCK3: WFZERO DCOMST +$KLCK4: RTS PC + +$KLCK2: TST KLCLKR ;WAS CLOCK RUNNING ? + BEQ $KLCK4 ;NO + MOV #DCOMST!DFUNC!,@.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!,@.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!,@.DIAG1 + JSR PC,$$DFXDN ;DO ONE MBOX CLOCK + DEC R4 ;DONE 3 CLOCKS ? + BGT 2$ ;NO, TRY AGAIN + +3$: MOV #DCOMST!DFUNC!,@.DIAG1 + JSR PC,$$DFXDN ;CONDITIONAL EBOX CLOCK + MOV #DCOMST!DFUNC!,@.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 + 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 + RTS PC + +$SMRLST:.WORD DCOMST!DFUNC! + .WORD DCOMST!DFUNC! + .WORD DCOMST!DFUNC! + .WORD DCOMST!DFUNC! + +.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!,@.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 ;SAVE R1,STORE DRAM ADDR ON STACK TOP + CLR R1 ;R1 IS AN INDEX COUNTER +1$: DRAMAD ;WRITE DRAM ADDRESS + MOV #DCOMST!DFUNC!,@.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!,@.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!,@.DIAG1 + JSR PC,$$DFXDN ;BURST 128 CLOCKS + DEC R3 ;ANY MORE ? + BGT 1$ ;YES, DO 128 MORE + +2$: MOV #DCOMST!DFUNC!,@.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!,@.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!,@.DIAG1 + JSR PC,$$DFXDN ;STOP EXECUTION + MOV #177,R0 + BURST ;RUN CLOCK FOR FIXED PERIOD + MOV #DCOMST!DFUNC!,@.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 diff --git a/src/kldcp/cdmp11.1 b/src/kldcp/cdmp11.1 new file mode 100755 index 00000000..1fb7f8a4 --- /dev/null +++ b/src/kldcp/cdmp11.1 @@ -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 + 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 + TST DEVTYP + BEQ $CDDT1 ;DECTAPE + MOV #256.,BUFSIZ + MOV #FILDSB,R0 + RPWRFL ;WRITE FILE DATA BLOCK + BCS $CDDVR ;ERROR + + POP + 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 + 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 + 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 + 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 + + \ No newline at end of file diff --git a/src/kldcp/cons11.48 b/src/kldcp/cons11.48 new file mode 100755 index 00000000..d408b363 --- /dev/null +++ b/src/kldcp/cons11.48 @@ -0,0 +1,2958 @@ +;;;MODIFICATION HISTORY +;;; +;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7) +;;; 15 NOV 75 CONVERTED TO PALX FORMAT +;;; 19 DEC 75 BUG FIXES, BREAK, DDT CMD, PCF CMD +;;; 30 MAR 76 MODIFIED TO COEXIST WITH ITS IOELEVEN PROGRAM + +.SBTTL CONSOLE PACKAGE FOR KL10/11 INTERFACE, 9-SEPT-75 + +CONSL: ;MOV #PR7,PS ;DISABLE INTERRUPTS + ;MOV #PR7,EMTVEC+2 + MOV #STACK,SP ;RESET STACK + MOV #$STUF,R0 ;SETUP FOR STACK UNDERFLOW + MOV R0,(SP) +1$: PUSH R0 + + MOV SP,$KONSP + +KONSL: MOV $KONSP,SP ;RESET STACK POINTER + + TTPINI ;INIT TTY POINTERS + + CLR DDTFLG + CLR IFILEF + CLR HLPPNT + CLR PCMDFLG + PFORCE ;ALL OUTPUT TO TTY + + JSR PC,$CKSUM ;COMPUTE CHECKSUM OF "KLDCP" + + CMP R0,$ILDSUM ;DOES IT MATCH AS LOADED ? + BEQ 2$ ;YES, OK !!!! + + MOV R0,$ILDSUM ;NO, ONLY REPORT CHANGES + PMSG + +2$: TST JFILEF + BNE $$CONSL + PMSG + BR $$CONSL + +$KONSL: TTIBRK ;GET BREAK CHAR FROM LAST OPERATION + BCS $KONS1 ;NO DATA + CMPB #',,R0 ;WAS LAST BREAK A COMMA ? + BEQ $RPT ;BR IF YES, CONTINUE STRING PROCESS + CMPB #' ,R0 ;WAS LAST BREAK A SPACE ? + BEQ $RPT ;YES, CONTINUE STRING PROCESS + CMPB #TAB,R0 ;WAS LAST BREAK A TAB ? + BEQ $RPT ;YES, CONTINUE STRING PROCESS + TST R0 + BEQ 11$ ;NULL, EOL + CMP #LF,R0 ;IS IT LF ? + BEQ 11$ ;YES + CMP #ALTMOD,R0 + BEQ 11$ ;IS IT ALTMODE ? + CMP #CR,R0 ;IS IT A CR ? + BNE 2$ ;NO, INVALID TERMINATION + +11$: TST RPTFLG ;PRESENTLY DOING A REPEAT ? + BEQ $KONS1 ;BR IF NO + + JSR PC,$PTTYC ;CHECK OPERATOR INTERRUPT + +1$: MOV #$INBUF+2,$INPTC ;REPEAT, REDO COMMAND + BR $RPT + +2$: JMP $CMDER + +$$CONSL:CLR RPTFLG + CLR DVDIRF ;CLEAR DEVICE DIRECTORY FLAG +$KONS1: TST PCMDFLG ;DOING PROGRAM COMMAND ? + BEQ 1$ ;NO + JMP PCMDE ;YES, RETURN TO PROGRAM +1$: TST IFILEF ;PROCESSING INDIRECT FILE ? + BEQ 2$ ;NO + JMP IFILIN ;YES, GET CHARS FROM STORAGE +2$: TST JFILEF ;DOING DOUBLE INDIRECT ? + BPL $KONS2 ;NO + JMP JFILIN ;YES, GET CHARS FROM STORAGE +$KONS2: MOV SP,$KONSP ;SAVE STACK POINTER + TSTB TENRUN ;IF TEN IS RUNNING, + BNE 2$ ;DON'T GIVE COMMAND PROMPT +1$: PFORCE + PNTCI + '> + PMSG <. _> +2$: RUNLP ;RUN LOOP &/OR READ IN A TTY LINE + BCC $RPT ;RESPONSE, GO PROCESS + CMP #$INBUF,$INPTR ;ANYTHING BEEN TYPED ? + BNE 1$ ;YES, REPROMPT + BR 2$ + +$RPT: CLR ALLFLG ;CLEAR ALL PRINT FLAG + TTISDL ;READ ONE CHARACTER + BCC $CMDER ;...NUMBER, ILLEGAL +1$: CMPB #';,R0 + BEQ $$CONSL ;SEMICOLON, LOCAL COPY ONLY + CMPB #'.,R0 + BEQ $RPT ;DOT, IGNORE + MOVB R0,$KDCEN ;PLACE IN END OF DECODER + + TTICHR ;READ SECOND CHARACTER + BCS $KONS1 ;EVEN 1 CHAR CMDS ARE 2 CHAR MIN. + CMPB #12,R0 ;IF THIS CHAR IS A LINE FEED + BEQ $KONS1 ;..1ST CHAR MUST HAVE BEEN CR, IGNORE + CMPB #15,R0 ;IF THIS CHAR A CR + BEQ 3$ ;THIS IS A SINGLE LETTER COMMAND + CMPB #33,R0 ;IF ALTMODE + BEQ 3$ ; DITTO + MOVB R0,$KDCEN+1 ;PLACE SECOND IN END OF DECODER + +;THE COMMAND PORTION OF THE INPUT STRING IS READY TO BE DECODED + +4$: MOV $KDCEN,R0 ;COMMAND TO R0 + MOV #$KDCRE,R1 ;ADDRESS OF LIST TO R1 + +2$: CMP R0,(R1)+ ;TEST FOR COMMAND + BNE 2$ ;NOT FOUND YET + CLR $KDCEN + CLR ENQFLG + JMP @$DISPH-$KDCRE-2(R1) ;EXIT TO SELECTED SUBROUTINE + +3$: MOVB #40,$KDCEN+1 ;MAKE SINGLE LETTER COMMAND + BR 4$ ;LETTER & SPACE FOR LOOKUP + +$CMDER: PNTCI + '? + BR $$$CC + +$$CNTLC:CLR DIAFLG + CLRB TENRUN ;CLEAR PDP-10 RUNNING FLAG + TST PCMDFLG ;DOING PROGRAM COMMAND ? + BNE $$$CC ;YES + CLR PRGRUN ;CLEAR PROGRAM RUNNING FLAG +$$$CC: SETFLG + $TTLKF + TST DEVTYP ;IN ACT10 MODE ? + BPL 1$ ;NO + TST ENQFLG ;DOING APT10 COMMAND ? + BEQ 1$ ;NO + + COMCLR ;ACT10, CLEAR COMM, THEN TO CONSL + +1$: PUSH $FORCE ;SAVE FORCED PRINTING FLAG + PFORCE + PCRLF ;FORCE PRINT ERROR + POP $FORCE ;RESTORE + + TST PCMDFLG ;DOING PROGRAM COMMAND ? + BEQ 2$ ;NO + JMP PCMDE1 ;YES, TAKE ERROR RETURN + +2$: CLR JFILEF ;CLEAR DOUBLE INDIRECT FLAG + JMP KONSL + +.SBTTL CONSOLE DISPATCH TABLE + +$KDCRE: .ASCII /R / ;REPEAT OPERATOR + .ASCII /FX/ ;DIAGNOSTIC FUNCTION EXECUTE + .ASCII /FW/ ;DIAGNOSTIC FUNCTION WRITE + .ASCII /FR/ ;DIAGNOSTIC FUNCTION READ + .ASCII /FS/ ;DIAGNOSTIC FUNCTION SYNC + .ASCII /DA/ ;DIAGNOSTIC DEPOSIT INTO AR + .ASCII /EX/ ;PDP-10 INSTRUCTION EXECUTE + .ASCII /MR/ ;MASTER RESET + +;PDP-10 EXAMINE/DEPOSIT FUNCTIONS + + .ASCII /EM/ ;EXAMINE 10 AT ADR AND PRINT + .ASCII /DM/ ;DEPOSIT DATA IN 10 ADDRESS + .ASCII /EN/ ;EXAMINE AND PRINT NEXT 10 ADDRESSES + .ASCII /DN/ ;DEPOSIT DATA INTO NEXT 10 ADDRESSES + .ASCII /MZ/ ;MEMORY ZERO + +;START/STOP FUNCTIONS + + .ASCII /SP/ ;STOP 10, CLEAR RUN FLOP + .ASCII /RN/ ;START 10, SET RUN FLOP + .ASCII /SI/ ;SINGLE INSTRUCTION,PUSH CONTINUE + .ASCII /PL/ ;PULSE CLOCK + .ASCII /BU/ ;BURST CLOCK + .ASCII /SM/ ;START MICRO CODE,SUPPORT EXAMINE/DEPOSIT + .ASCII /ST/ ;START AT 10 ADDRESS + .ASCII /SW/ ;PDP-10 SWITCHES + .ASCII /AC/ ;"AC BLK" SELECTION + .ASCII /MC/ ;PDP-10 MONITOR CONTINUE + .ASCII /EP/ ;SET EOP INTERVAL + +;PDP-11 FUNCTIONS + + .ASCII /SE/ ;START 11 AT ADR + .ASCII /EE/ ;EXAMINE 11 AT ADR AND PRINT + .ASCII /DE/ ;DEPOSIT DATA IN 11 ADDRESS + .ASCII /EB/ ;EXAMINE 11 BYTE + .ASCII /DB/ ;DEPOSIT 11 BYTE + .ASCII /ZE/ ;ZERO ELEVEN + +;RAM FUNCTIONS + + .ASCII /EC/ ;EXAMINE C-RAM AT ADDRESS AND PRINT + .ASCII /DC/ ;DEPOSIT DATA INTO C-RAM ADDRESS + .ASCII /RC/ ;READ C-RAM, FR'S 140-141-142-143 + .ASCII /ED/ ;EXAMINE D-RAM AT ADDRESS AND PRINT + .ASCII /DD/ ;[START DDT] OR DEPOSIT D-RAM + .ASCII /MM/ ;MICRO-CODE SYNC MARK + .ASCII /MU/ ;MICRO-CODE SYNC UNMARK + .ASCII /MT/ ;MICRO-CODE TIME CHANGE + +;CLOCK OPERATIONS + + .ASCII /CS/ ;CLOCK SOURCE + .ASCII /CR/ ;CLOCK RATE + +;PROCESSOR PARITY FUNCTIONS + + .ASCII /PD/ ;DISABLE PARITY STOP + .ASCII /PE/ ;ENABLE PARITY STOP + +;INTERNAL E-BOX REGISTER READ FUNCTIONS + + .ASCII /AR/ ;READ & PRINT AR REGISTER + .ASCII /BR/ ;READ & PRINT BR REGISTER + .ASCII /MQ/ ;READ & PRINT MQ REGISTER + .ASCII /FM/ ;READ & PRINT FM REGISTER + .ASCII /AD/ ;READ & PRINT ADDER + .ASCII /PC/ ;READ & PRINT PC + .ASCII /VM/ ;READ & PRINT VMA + .ASCII /SC/ ;READ & PRINT SC REGISTER + .ASCII /FE/ ;READ & PRINT FE REGISTER + .ASCII /ER/ ;READ & PRINT E-BUS REGISTER + .ASCII /PI/ ;READ & PRINT PI SYSTEM + .ASCII /AL/ ;PRINT ALL, C-RAM & REGISTERS + +;CACHE OPERATIONS + + .ASCII /CE/ ;CACHE ENABLE + .ASCII /CI/ ;CACHE INVALIDATE + .ASCII /CF/ ;CACHE FLUSH + +;REPEAT CONTROL + + .ASCII /RP/ ;REPEAT & PRINT OR RP04 SELECT + .ASCII /TD/ ;TIME DELAY + +;CONSOLE (TTY) CONTROL FUNCTION + + .ASCII /TP/ ;SET TTY PAGE LENGTH + .ASCII /TW/ ;SET TTY PAGE WIDTH + .ASCII /TF/ ;SET TTY FILL COUNT + + .ASCII /TT/ ;SWITCH TO REMOTE TELETYPE OPERATION +; .ASCII /LP/ ;LINE PRINTER SELECTION + + .ASCII /KL/ ;KLINIK SELECTION + +;KL10 MONITOR (PROGRAM & ACT10) COMMANDS + + .ASCII /B / ;BOOT + .ASCII /LI/ ;LOGIN + .ASCII /H / ;HELP + .ASCII /P / ;PROGRAM + .ASCII /LT/ ;LOAD TEN + .ASCII /LE/ ;LOAD ELEVEN + .ASCII /LR/ ;LOAD RAM + .ASCII /LB/ ;LOAD ELEVEN BINARY + .ASCII /V / ;VERFIY PROGRAM + .ASCII /S / ;SCRIPT + .ASCII /M / ;MASTER SCRIPT + .ASCII /C / ;COMMENT/CORRECTIVE ACTION + .ASCII /GO/ ;GO START PROGRAM + .ASCII /LO/ ;LOGOUT + .ASCII /GS/ ;GENERATE SCRIPT +; .ASCII /CD/ ;PDP-11 CORE DUMP + .ASCII /TA/ ;ACT10 TO RP04 TRANSFER + .ASCII /WF/ ;DECTAPE TO RP04 WRITE + .ASCII /WU/ ;RP04 TO DECTAPE WRITE + .ASCII /UI/ ;DECTAPE INITIALIZE + .ASCII /UD/ ;DECTAPE DELETE + .ASCII /US/ ;DECTAPE SALVAGE + .ASCII /FL/ ;FLAP DECTAPE + .ASCII /RE/ ;'RENM' RENAME RP04 FILE + .ASCII /T / ;TIME + .ASCII /BT/ ;BOOT TEN + + .ASCII /AT/ ;SWITCH TO ACT10 MODE + .ASCII /DT/ ;SWITCH TO DECTAPE MODE, SELECT UNIT + .ASCII /RX/ ;SWITCH TO FLOPPY MODE, SELECT UNIT + .ASCII /DI/ ;DIRECTORY, DECTAPE/RP04/FLOPPY + + .ASCII /BP/ ;BREAKPOINT TRAP LAYER + .ASCII /BC/ ;BREAKPOINT CONTINUE + .ASCII /RG/ ;TYPE OUT BREAK STUFF + .ASCII /RB/ ;REMOVE BREAKPOINTS + .ASCII /HC/ ;ERROR HALT CONTINUE + + .ASCII /RI/ ;REINITIALIZE SYSTEM + + .ASCII /I / ;INDIRECT COMMAND FILE PROCESS + .ASCII /J / ;DOUBLE INDIRECT COMMAND FILE + .ASCII /JC/ ;"J" FILE CONTINUE + .ASCII /IT/ ;TURN ON I.T.S. PROG + .ASCII /DS/ ;DISK STATUS + +$KDCEN: 0 ;ERROR TRAP FOR NONEXISTANT COMMANDS + +;DISPATCH TABLE + +$DISPH: .RPT ;REPEAT OPERATION + .DFXCT ;DIAGNOSTIC FUNCTION EXECUTE + .DFWRT ; " " WRITE + .DFRD ; " " READ + .FS ; " " SYNC + .DA ; " DEPOSIT INTO AR + .XCT ;EXECUTE 10 INSTRUCTION + .MRESET ;MASTER RESET + .EXM ;EXAMINE 10 + .DP ;DEPOSIT 10 + .EXMNX ;EXAMINE NEXT 10 + .DPNX ;DEPOSIT NEXT 10 + .MZ ;MEMORY ZERO + $SP ;STOP 10 + $RN ;RUN 10 + $SI ;SINGLE INSTRUCT 10 + .PL ;PULSE 10 + .BU ;BURST CLOCK + .SM ;START MACHINE + $ST ;START 10 + $SW ;SWITCHES 10 + .AC ;"AC BLK" SELECTION + $MC ;MONITOR CONTINUE + .EP ;SET EOP INTERVAL + .SE ;START ELEVEN + .EE ;EXAMINE ELEVEN + .DE ;DEPOSIT ELEVEN + .EB ;EXAMINE 11 BYTE + .DB ;DEPOSIT 11 BYTE + .ZE ;ZERO ELEVEN + $EC ;EXAMINE C_RAM + $DC ;DEPOSIT C-RAM + $RC ;READ C-RAM + $ED ;EXAMINE D_RAM + $DDTX ;[START DDT] OR DEPOSIT D_RAM + .MM ;MICRO-CODE MARK + .MU ;MICRO-CODE UNMARK + .MT ;MICRO-CODE TIME CHANGE + + .CS ;SELECT CLOCK SOURCE + .CR ;SELECT CLOCK RATE + .PD ;PROCESSOR PARITY DISABLE + .PE ;PROCESSOR PARITY ENABLE + .AR ;READ REGISTERS + .BR + .MQ + .FM + .AD + .PC + .VM + .SC + .FE + .ERG + .PI ;READ & PRINT PI SYSTEM + .ALL ;PRINT ALL + .CE ;CACHE ENABLE + .CI ;CACHE INVALIDATE + .CF ;CACHE FLUSH + .RPTP ;REPEAT & PRINT + .TD ;TIME DELAY + $TP ;SET TTY PAGE LENGTH + $TW ;SET TTY PAGE WIDTH + $TF ;SET TTY FILL PARAMETER + $TT ;SWITCH TO REMOTE TTY +; $LPT ;LINE PRINTER SELECTION + .KLINIK ;KLINIK SELECTION + +;KL10 MONITOR (PROGRAM & ACT10) COMMANDS + + $BOOT ;BOOT SYSTEM + $LOGIN ;LOG IN + $HELP ;HELP + $PROG ;LOAD PROGRAM + $LDT ;LOAD TEN + $LDE ;LOAD ELEVEN + $LDR ;LOAD RAM + $LDB ;LOAD ELEVEN BINARY + $VERIFY ;VERIFY PROGRAM + $SCRPT ;SCRIPT REQUEST + $MSCP ;MASTER SCRIPT REQUEST + $COMNT ;COMMENT + $GO ;PROGRAM GO + $LOGO ;LOG OUT + $GSCP ;GENERATE SCRIPT +; $CD ;PDP-11 CORE DUMP + $TA ;ACT10 TO RP04 TRANSFER + $WF ;DECTAPE TO RP04 WRITE FILE + $WU ;RP04 TO DECTAPE WRITE + $UI ;DECTAPE INITIALIZE + $UD ;DECTAPE DELETE + $US ;DECTAPE SALVAGE + $UF ;DECTAPE FLAP + $RE ;'RENM' RP04 RENAME FILE + $TIME ;TIME + $BOOTT ;BOOT PDP-10 + $AT ;SELECT ACT-10 MODE + $DT ;SELECT DECTAPE MODE & UNIT + $RX ;SELECT FLOPPY MODE & UNIT + $DI ;DIRECTORY, DECTAPE/RP04/FLOPPY + .BP ;BREAKPOINT INSERTION + .BC ;BREAKPOINT CONTINUE + .RG ;PRINT SAVED REGISTERS + .RB ;REMOVE BREAKPOINTS + .HC ;HALT CONTINUE + .RI ;REINITIALIZE CONSOLE + $IFILE ;INDIRECT FILE + $JFILE ;DOUBLE INDIRECT FILE + $JC ;J FILE CONTINUE + $ITS ;TURN ON I.T.S. PROG + DSKSTS ;PRINT DISK STATUS + + $CMDER ;NO SUCH COMMAND + +.SBTTL DIAGNOSIC CONSOLE UTILITY COMMAND PROCESS + +;UTILITY PROGRAM CHECK + +$KLUCK: CMP PID,PIDU ;UTILITY PROGRAM IN CORE ? + BNE 1$ + CMP PID+2,PIDU+2 + BNE 1$ + CMP PDVER,#DECVER ;PROPER VERSION ? + BNE 1$ + RTS PC ;OK + +1$: PMSG + JMP $CNTLC + +PIDU: .RAD50 /KLDCPU/ + +;TRANSFER FROM APT10 DISPATCH + +$TA: JSR PC,$KLUCK ;UTILITY IN CORE ? + JMP @TAPT ;YES + +;WRITE FILE FROM DTA/FLOPPY DISPATCH + +$WF: JSR PC,$KLUCK ;UTILITY IN CORE ? + JMP @WFILE ;YES + +$WU: JSR PC,$KLUCK + JMP @WUTAPE + +$UI: JSR PC,$KLUCK + JMP @UINIT + +$UD: JSR PC,$KLUCK + JMP @UFDELE + +$US: JSR PC,$KLUCK + JMP @USALV + +$UF: JSR PC,$KLUCK + JMP @UFLAP + +;REMOTE TELETYPE COMMUNICATIONS DISPATCH + +$TT: JSR PC,$KLUCK ;UTILITY IN CORE ? + JMP @REMOTE ;YES + +;RP04 DISK DIRECTORY DISPATCH + +$RPDIR: JSR PC,$KLUCK ;UTILITY IN CORE ? + JMP @DSKDIR ;YES + +;CHECK FOR I.T.S. IOELEVEN PROGRAM IN CORE + +ITSCHK: CMP PID,PIDI + BNE 1$ + CMP PID+2,PIDI+2 + BNE 1$ + RTS PC ;OK + +1$: PMSG + CLR ITSFLG + MOV #PR7,PS ;TURN OFF INTS AGAIN + MOV #PR7,EMTVEC+2 + JMP $CNTLC + +PIDI: .RAD50 /IOELEV/ + +;THE "ITS" COMMAND COMES HERE + +$ITS: TTICHR ;MAKE SURE 3RD CHAR IS "S" + BCS 1$ + CMPB R0,#'S + BNE 1$ +20$: TTICHR ;COULD BE ITS OFF COMMAND + BCS 1$ + CMPB R0,#40 + BEQ 20$ + CMPB R0,#'O + BNE 2$ + TTICHR + BCS 1$ + CMPB R0,#'F + BNE 1$ + TTICHR + BCS 1$ + CMPB R0,#'F + BNE 1$ + TTITRM + JSR PC,ITSOF1 ;TURN IOELEV OFF + JMP $KONSL + +2$: TTBTRM + JSR PC,ITSCHK ;MAKE SURE IOELEV IS AROUND + MOV #-1,ITSFLG + MOV #PR0,PS ;TURN ON INTERRUPTS + MOV #PR0,EMTVEC+2 + JSR PC,@#3000 ;GET PROGRAM INITIALIZED, WILL RETURN IF TEN NOT RUNNING + JMP $KONSL ;RETURN TO COMMAND PROC + +1$: JMP $CMDER + +;SUBROUTINE TO TURN ITS OFF IF ON. CLOBBERS NO REGISTERS, +;BUT DOES DO A RESET. +ITSOFF: TST ITSFLG + BNE 1$ + RTS PC + +1$: MOV R0,-(SP) + PMSG + JSR PC,ITSOF1 + MOV (SP)+,R0 + RTS PC + +ITSOF1: CLR ITSFLG +30$: TSTB @$TPS + BPL 30$ + RESET ;IS THIS DESIRABLE? + ;GOTTA FLUSH INTERRUPTS SOMEHOW + CLR R0 + SOB R0,. ;DELAY 100 MS FOR LUCK + RTS PC + +.SBTTL CONSOLE COMMAND REPEAT CONTROL + +.RPT: SETFLG + RPTFLG ;SET REPEAT FLAG + +.RPTX: PNORML + JMP $RPT + +.RPTP: TTISDL + BCC 1$ ;NUMBER + TTBACK + MOV #177400,RPTFLG ;SET REPEAT & PRINT + BR .RPTX + +1$: JMP $RP ;MUST BE RP04 SELECTION + +.SBTTL PROGRAM CONSOLE COMMAND PROCESS + +$PRGNPT:SETFLG ;PROGRAM COMMAND, NO PRINT + PCMDNF + BR $PRGXX +$PRGCMD:CLR PCMDNF +$PRGXX: SETFLG + PCMDFLG ;SET PROGRAM COMMAND FLAG + TST R0 + BEQ 2$ ;USE CURRENT INPUT BUFFER, R0=0 + CMP #-1,R0 + BNE 3$ + MOV #$OUTBF,R0 ;USE OUTPUT BUFFER, R0 = -1 + MOV R0,$OUTPT +3$: JSR PC,$PCMDX ;TRANSFER COMMAND TO INPUT BUFFER +2$: MOV #$INBUF,$INPTC ;SET PICKUP POINTER + MOV SP,$$SVSP ;SAVE STACK POINTER + JMP $RPT ;PROCESS COMMAND + +PCMDE: MOV $$SVSP,SP ;RESTORE STACK POINTER + CLR PCMDFLG + CLR PCMDNF + CLR ENQFLG + EXIT +PCMDE1: MOV $$SVSP,SP +PCMDE3: CLR PCMDFLG ;ERROR, C-BIT SET RETURN + CLR PCMDNF + CLR HLPPNT + EXITERR +PCMDE2: MOV $$SVSP,SP + BIS #NBIT,14(SP) ;CONTROL C DURING TYPEOUT + BR PCMDE3 ;NBIT & CBIT SET RETURN + +$PCMDX: MOV #$INBUF,R1 ;MOVE COMMAND TO INPUT BUFFER +$DIASX=. +1$: MOVB (R0)+,(R1)+ ;TRANSFER CHARS + BNE 1$ ;TILL NULL + DEC R1 + MOVB #CR,(R1)+ + MOVB #LF,(R1)+ + MOV R1,$INPTR ;SAVE EOL POINTER + RTS PC + +;PROGRAM INDIRECT CCL FILE PROCESS + +$TTICCL:MOV IFINP,R1 ;XFER CHARS INTO INPUT BUFFER + TSTB (R1) ;FIRST CHAR A NULL ? + BEQ 1$ ;YES, FINISHED + JSR PC,IJFILX + MOV R1,IFINP ;RESAVE POINTER + EXIT +1$: EXITERR ;FINISHED, C-BIT SET RETURN + +;INDIRECT COMMAND FILE PROCESS + +IFILIN: MOV IFINP,R1 ;XFER CHARS INTO INPUT BUFFER + TSTB (R1) ;FIRST CHAR A NULL ? + BEQ IFILX1 ;YES, FINISHED + JSR PC,IJFILX + MOV R1,IFINP ;RESAVE STORAGE POINTER + TST JFILEF ;DON'T PRINT "I" IF UNDER "J" + BNE 3$ +IFILX=. + $PMSG ;PRINT COMMAND LINE + $INBUF +3$: JMP $RPT ;GO PROCESS + +IFILX1: JMP CONSL ;FINISHED + +;DOUBLE INDIRECT COMMAND FILE PROCESS + +JFILIN: TST PRGRUN ;PROGRAM PRESENTLY RUNNING ? + BEQ 3$ ;NO + JMP $KONS2 ;YES, WAIT TILL IT'S DONE +3$: MOV JFINP,R1 ;XFER CHARS INTO INPUT BUFFER + + TSTB (R1) ;FIRST CHAR A NULL ? + BEQ 2$ ;YES, FINISHED + + JSR PC,IJFILX + MOV R1,JFINP ;RESAVE STORAGE POINTER + BR IFILX + +2$: CLR JFILEF + BR IFILX1 + +IJFILX: MOV #$INBUF,R0 + MOV R0,$INPTC + +1$: MOVB (R1)+,(R0)+ + BNE 1$ + + MOV R0,$INPTR + RTS PC + +.SBTTL DIAGNOSTIC FUNCTIONS + +;DIAGNOSTIC FUNCTION EXECUTE + +.DFXCT: DFLEGAL ;FUNCTION LEGAL ? + TTISDO ;GET FUNCTION + CMP R0,#037 ;FUNCTION VALID ? + BGT $DFERR ;FX IS 000 TO 037 + + DFXCT ;DF EXECUTE + BR .DFX ;RETURN TO CONSOLE + +;DIAGNOSTIC FUNCTION WRITE + +.DFWRT: DFLEGAL ;FUNCTION LEGAL ? + TTISDO ;GET FUNCTION + CMP R0,#040 + BLT $DFERR + CMP R0,#077 + BGT $DFERR ;FW IS 040 TO 077 + MOV R0,R2 ;SAVE FUNCTION + TTIS36 ;GET DATA + MOV R0,R1 ;PUT ADR OF 36BITS IN R1 + + MOV R2,R0 ;FUNCTION IN R0 + DFWRT ;DIAGNOSTIC FUNCTION WRITE + +.DFX: JMP $KONSL + +;DIAGNOSTIC FUNCTION SYNC, GENERATES PULSE AT "A36E1" + +.FS: DFLEGAL ;FUNCTION LEGAL ? + TTITRM + DFXCTT + 74 ;SYNC IS FUNCTION EXECUTE 74 + BR .DFX + +$DFERR: PMSG + JMP $CNTLC + +;DIAGNOSTIC READ AND PRINT + +.DFRD: DFLEGAL ;FUNCTION LEGAL ? + CLR R3 + TTISDO ;GET FUNCTION + MOV R0,R2 + TTIBRK + BCS $DFERR + CMPB #COMMA,R0 ;IF BREAK IS A COMMA, MULTIPLE DFRD + BNE 1$ + + INC R3 + TTCOCT + MOV R0,R4 ;SAVE LAST DFRD +1$: TSTB RPTFLG + BNE 2$ + + MOV R2,R0 + PNTOCS + PSLASH +2$: MOV R2,R0 + BEQ 21$ ;FR 0 USED TO READ E-BUS + CMP R0,#100 + BLT $DFERR + CMP R0,#177 + BGT $DFERR ;FR IS 100 TO 177 +21$: MOV #.DFRDA,R1 + DFRDMV + TSTB RPTFLG + BNE 3$ + MOV R1,R0 + PNT36B ;PRINT IN BINARY + +3$: TST R3 + BEQ 4$ + + PCRLF + CMP R2,R4 + BHIS 4$ + INC R2 + BR 1$ + +4$: BR ALLEXT + +.DFDP: DFLEGAL ;FUNCTION LEGAL ? + MOV #.DFRDA,R1 + DFRDMV ;READ THE E-BUS + + TSTB RPTFLG + BNE .DFX +.DFDPC: MOV #.DFRDA,R0 + PNT36 ;PRINT IT OUT + +ALLEXT: TST ALLFLG ;DOING ALL ? + BNE 1$ ;YES + TSTB RPTFLG ;DOING A REPEAT ? + BNE 2$ ;YES +ALLEX1=. + PCRLF +2$: BR .DFX +1$: RTS PC ;ALL, CONTINUE + +.MQ: TTITRM +$ALLMQ=. + PMSGR +1$: MOV #DPMQ,R0 + BR .DFDP + +.FM: DFLEGAL ;FUNCTION LEGAL ? + TTITRM +$ALLFM=. + TSTB RPTFLG + BNE 1$ + PNTCI + "FM + DFRDT ;READ FM ADDRESS + DPFMA + MOV @.DAT2,R0 + SHIFTR + 5 + BIC #177760,R0 + PNTODT + 2 + PNTCI + '/ +1$: MOV #DPFM,R0 + BR .DFDP + +$DPERR: JMP $DFERR + +.AR: TTICHR + BCS $DPERR + CMPB #'X,R0 ;IS COMMAND 3 LETTERS ? + BEQ 1$ ;BR IF 3RD LETTER IS X + TTBTRM +$ALLAR=. + PMSGR +2$: MOV #DPAR,R0 + BR .DFDP ;READ AND PRINT AR + +1$: TTITRM +$ALARX=. + PMSGR +3$: MOV #DPARX,R0 + BR .DFDP + +.AD: TTICHR + BCS $DPERR + CMPB #'X,R0 ;IS COMMAND 3 LETTERS ? + BEQ 1$ ;BR IF 3RD LETTER IS X + CMPB #'B,R0 + BEQ .ADB ;ADB, PRINT ADDRESS BREAK + TTBTRM +$ALLAD=. + PMSGR +2$: MOV #DPAD,R0 + BR .DFDP ;READ AND PRINT AD + +1$: TTITRM +$ALADX=. + PMSGR +3$: MOV #DPADX,R0 + BR .DFDP ;READ AND PRINT ADX + +.BR: TTICHR + BCS $DPERR + CMPB #'X,R0 ;IS COMMAND 3 LETTERS ? + BEQ 1$ ;BR IF 3RD LETTER IS X + TTBTRM +$ALLBR=. + PMSGR
+2$: MOV #DPBR,R0 + BR .DFDP ;READ AND PRINT BR + +1$: TTITRM +$ALBRX=. + PMSGR +3$: MOV #DPBRX,R0 + BR .DFDP ;READ AND PRINT THE BRX + +.ERG: TTICHR + BCS $DPER1 + CMPB #'G,R0 + BNE $DPER1 + TTITRM + +$ALLEB: PMSGR + MOV #DPERG,R0 + BR .DFDP ;READ & PRINT EBUS REGISTER + +;MASTER RESET + +.MRESET:TTITRM + MRESET + BR .DAX + +;DEPOSIT INTO AR + +.DA: DFLEGAL ;FUNCTION LEGAL ? + TTIS36 ;GET 36 BIT AR DATA + MOV R0,R1 ;ADR OF 36 BITS TO R1 + JSR R5,WIRAR1 ;CALL IR/AR WRITE ROUTINE +.DAX: JMP $KONSL + +.PC: TTICHR + BCS $DPER1 + CMPB #'F,R0 + BEQ .PCF + TTBTRM +$ALLPC=. + PMSG + TST TENRUN ;PDP-10 PRESENTLY RUNNING ? + BEQ 1$ ;NO, GO AHEAD THEN + DFXCTT + CLRRUN ;CLEAR RUN + TDELAY ;WAIT FOR HALT LOOP + DFXCTT + STPCLK ;STOP CLOCK + + DFPC ;READ PC + + PUSH R0 + DFXCTT + STRCLK ;START CLOCK + DFXCTT + SETRUN ;SET RUN + DFXCTT + CONBUT ;SET CONTINUE + POP R0 + BR PCVMAP ;GO PRINT + +1$: DFPC + +PCVMAP: + PNTADR + TST ALLFLG + BNE 1$ + JMP ALLEX1 ;RETURN TO CONSOLE +1$: RTS PC ;ALL, RETURN TO ROUTINE + +.VM: DFLEGAL ;FUNCTION LEGAL ? + TTICHR + BCS $DPER1 + CMPB #'A,R0 + BEQ 1$ + CMPB #'H,R0 + BEQ .VMH + BR $DPER1 +1$: TTITRM +$ALVMA=. + PMSG + DFVMA + BR PCVMAP + +$DPER1: JMP $DFERR + +.VMH: TTITRM +$ALVMH=. + PMSG + DFVMAH + BR PCVMAP + +.ADB: DFLEGAL ;FUNCTION LEGAL ? + TTITRM + PMSG + DFADB + BR PCVMAP + +;PCF COMMAND - PRINT THE PC FLAGS + +.PCF: TTITRM + TST TENRUN ;TEN MUST BE STOPPED WHILE FLAGS ARE GOBBLED + BEQ 1$ + DFXCTT + CLRRUN + TDELAY + DFXCTT + STPCLK + JSR PC,PCF + DFXCTT + STRCLK + DFXCTT + SETRUN + DFXCTT + CONBUT + BR 2$ + +1$: JSR PC,PCF +2$: JMP ALLEX1 ;CRLF AND RETURN TO KONSL + +PCF: PMSG + MOV #PCFTBL,R5 + CLR R4 ;R4 ZERO IF THIS IS FIRST FROB TYPED +1$: MOVB (R5)+,R0 ;GET DIAG FUNC FOR NEXT BIT + BEQ 9$ ;BR IF END OF TABLE + DFRD ;GET BIT INTO DTE REG + MOV @.DAT1,R2 ;BITS 0-3 + MOV @.DAT2,R1 ;BITS 4-19 + .REPT 4 + ASL R1 + ROL R2 + .ENDR ;BITS 0-7 (4.9-4.2) RIGHT ALIGNED IN R2 + MOVB (R5)+,R1 ;GET MASK FOR BIT OF INTEREST + BPL 2$ + COM R2 ;BIT BACKWARDS IN HARDWARE + NEG R1 +2$: MOV (R5)+,R0 ;GET POINTER TO BIT NAME STRING + BIT R1,R2 + BEQ 3$ + TST R4 ;IF NOT FIRST, PUT A COMMA, SPACE + BEQ 4$ + PNTCI + ", +4$: PNTAL ;BIT IS ON, GIVE NAME + INC R4 +3$: BR 1$ ;LOOP BACK FOR NEXT BIT + +9$: RTS PC + +;PC FLAGS TABLE +;FIRST BYTE IS DIAG FCN, SECOND IS MASK FOR BIT (NEGATIVE => BIT COMPLEMENTED) +;SECOND WORD -> ASCIZ BIT NAME + +.MACRO PCFTE NAME,DFN,MASK + .LIT $$ZZQ,<.ASCIZ\NAME\> + .BYTE DFN,MASK + .WORD $$ZZQ +.ENDM + +PCFTBL: PCFTE OV,131,40 + PCFTE CRY0,131,20 + PCFTE CRY1,131,10 + PCFTE FOV,132,20 + PCFTE FPD,130,2 + PCFTE USER,134,-40 + PCFTE IOTLSR,136,4 + PCFTE PUBLIC,135,20 + PCFTE ADB INH,137,40 + PCFTE TRP 2,130,40 + PCFTE TRP 1,130,4 + PCFTE FXU,132,10 + PCFTE DIV,131,2 + 0 + +.FE: TTITRM +$ALLFE: PMSGR +1$: MOV #DPFE,R4 + BR FESCP + +.SC: TTITRM +$ALLSC: PMSGR +1$: MOV #DPSC,R4 + + +FESCP: DFLEGAL ;FUNCTION LEGAL ? + MOV R4,R0 + DFRD + + MOV @.DAT2,R3 ;GET LO-ORDER 5 BITS + SWAB R3 ;FROM 7-11 OF DEXWDS + BIC #177740,R3 + + MOV R4,R0 + INC R0 + DFRD + + MOV @.DAT2,R0 ;GET HI-ORDER 5 BITS + SHIFTR + 3 + BIC #176037,R0 + BIS R3,R0 ;COMBINE HI & LO ORDER BITS + + TSTB RPTFLG + BNE 1$ + PNTODT + 4 + PSPACE +1$: JMP ALLEXT + +;PRINT PRIORITY INTERRUPT FUNCTIONS + +.PI: DFLEGAL ;FUNCTION LEGAL ? + TTITRM + JSR PC,$ALPIG ;PRINT PI GENS + JSR PC,$ALPIH ;PRINT PI HOLDS + JSR PC,$ALPIO ;PRINT PI ON'S + PCRLF + JMP $KONSL + +$ALPIG: PMSG + DFRDT + READ1 ;READ PI GENS + ;FR 101, BITS 11-17 +$ALPIY: MOV @.DAT2,R0 + SHIFTR + 2 + +$ALPIX: BIC #177600,R0 ;DATA IS ONLY 7 BITS + PNTODT + 3 + RTS PC + +$ALPIH: PMSG < PI HOLD/> + DFRDT + READ0 ;READ PI HOLDS + MOV @.DAT2,R0 ;FR 100, BITS 03-09 + MOV @.DAT1,R1 + ROR R1 + ROR R0 + SHIFTR + 9. + BR $ALPIX + +$ALPIO: PMSG < PI ON/> + DFRDT + READ0 ;READ PI ONS + BR $ALPIY ;FR 100, BITS 11-17 + +;PRINT ALL - C-RAM & REGISTERS + +.ALL: TTICHR + BCS 1$ + CMPB #'L,R0 + BNE 1$ + TTITRM + DFLEGAL ;FUNCTION LEGAL ? + PNTCPU + JMP $KONSL +1$: JMP $DFERR ;ERROR + +$PNTCPU:SETFLG + ALLFLG ;SET ALL FLAG + PUSH RPTFLG + CLR RPTFLG + + JSR PC,$ALLEC ;PRINT C-RAM + + JSR PC,$ALLAR ;PRINT AR + JSR PC,$ALLBR ;PRINT BR + JSR PC,$ALLAD ;PRINT ADDER + JSR PC,$ALLSC ;PRINT SC + JSR PC,$ALLPC ;PRINT PC + PCRLF + + JSR PC,$ALARX ;PRINT ARX + JSR PC,$ALBRX ;PRINT BRX + JSR PC,$ALADX ;PRINT ADX + JSR PC,$ALLFE ;PRINT FE + JSR PC,$ALVMA ;PRINT VMA + PCRLF + + JSR PC,$ALLMQ ;PRINT MQ + JSR PC,$ALLFM ;PRINT FM + JSR PC,$ALLEB ;PRINT EBUS REGISTER + JSR PC,$ALVMH ;PRINT VMA HELD + PCRLF + +;THESE JUST TAKE UP TIME DURING MICROCODE TRACING, SO HAVE BEEN COMMENTED OUT +; JSR PC,$ALPIG ;PRINT PI GENS +; JSR PC,$ALPIH ;PRINT PI HOLDS +; JSR PC,$ALPIO ;PRINT PI ON'S +; PCRLF + POP RPTFLG + CLR ALLFLG + EXIT + +.SBTTL PDP-10 START/STOP FUNCTIONS + +;THESE REQUIRE STANDARD MICROCODE TO DO ANYTHING WORTHWHILE! + +;STOP PDP-10, CLEAR RUN FLOP + +$SP: TTITRM + TENSP ;STOP TEN + BCC 1$ + JMP .XCTER ;DID NOT STOP PROPERLY +1$: CLR PRGRUN + BR $RNX ;HOPE ENOUGH DELAY BUILT IN + +;CONTINUE PDP-10 FROM OLD PC. ASSUME CLOCK MAY BE OFF + +$RN: TTICHR + CMPB #'P,R0 + BEQ $RNP + TTBTRM +$RNN: CLR CLKPE ;CLEAR CLOCK PARITY ENABLES + MOV #20,R2 + MOV PEBITS,R1 ;GET ENABLE BITS + BEQ 2$ ;NOT ENABLED + BIT R2,R1 ;AR/ARX PARITY ENABLED ? + BEQ 1$ ;NO + BIS #2,CLKPE ;YES, SET ENABLE BIT +1$: BIS #1,CLKPE ;SET CLOCK STOP ENABLE + +2$: DFWRTT + CLKPE + LDCHK2 ;LOAD ENABLE FUNCTION REGISTER + +3$: BIC R2,R1 + MOV R1,CLKPE ;SETUP FM,CRAM,DRAM, FS + DFWRTT + CLKPE + LDCHK1 ;LOAD CONDITION ENABLE REGISTER + + DFXCTT ;GET CLOCK RUNNING + STRCLK + DFXCTT ;SET RUN AND LET 'ER GO + SETRUN + DFXCTT ;SET CONTINUE BUTTON + CONBUT + SETFLG + TENRUN ;SET TEN RUN FLAG + SETFLG + PRGRUN ;SET PROGRAM RUNNING FLAG +$RNX: JMP $KONSL + +$RNP: TTITRM ;RUN WITH MICRO TRACE + DFXCTT ;STOP CLOCK SO WON'T RUN UNTIL WE'RE READY + STPCLK + DFXCTT ;SET RUN AND LET 'ER GO + SETRUN + JMP SIPNT ;PUSH CONTINUE & START TRACING + +;START PDP-10 DDT + +$DDTX: TTISDL + BCS 1$ ;NON-NUMBER + JMP $DD ;NUMBER, MUST BE FOR D-RAM + +1$: CMPB #'T,R0 + BEQ 2$ ;"DDT", START PDP-10 AT "DDTSRT" + JMP $DFERR +2$: TTITRM + MOV TDDT,$$STJRS ;SET UP JRST INSTRUCTION + MOVB TDDT+2,$$STJRS+2 + ;I WISH THE HARDWARE PROVIDED AND EASY WAY TO CLEAR "USER" + ;MAYBE WE SHOULD PUT A SPECIAL JRST IN THE MICRCODE? + ;INSTEAD, A WARNING: + DFRDT + 134 + BIT #2,@.DAT1 + BNE 3$ + PMSG + JMP $CNTLC + +3$: CLR TENTTY + MOV #$$STJRS,R0 + EXCT ;DO JRST TO DDT START ADDRESS + BCC $RNN ;AND GO SAY -10 IS RUNNING +$DDTER: JMP .XCTER ;OR BARF IF UCODE HUNG + +;SINGLE INSTRUCT PDP-10. ASSUME CLOCK IS RUNNING AND RUN IS SET + +$SI: TENSP ;STOP TEN + BCS $DDTER ;DID NOT STOP PROPERLY, BARF + CLR R5 + TTISDL + BCS 4$ ;NON-NUMBER + TTIDEC + BCS 2$ ;NO ARG, DO ONCE + MOV R0,R5 +2$: DFXCTT ;PRESS CONTINUE PULSER + CONBUT + TDELAY ;SMALL TIME DELAY + DEC R5 ;COMPLETED REQUESTED INSTRUCTIONS ? + BGT 2$ + JMP $KONSL ;YES, RETURN TO CONSOLE + +4$: CMPB #'P,R0 + BNE 2$ + +5$: TTITRM ;"SIP",SINGLE INSTRUCT AND PRINT + DFXCTT ;STOP CLOCK + STPCLK + JMP SIPNT ;REST SAME AS LAST OF "EXP" + +;DIAGNOSTIC FUNCTION LEGALITY CHECK + +$DFLEGAL:TST TENRUN ;PDP-10 PRESENTLY RUNNING ? + BNE 1$ ;YES, OPERATION ILLEGAL, ABORT + EXIT +1$: PMSG + JMP $$$CC + +;PULSE THE E-BOX CLOCK + +.PL: DFLEGAL ;FUNCTION LEGAL ? + CLR TENCLK ;TURN OFF CLOCK IF ON + TTISDL + BCS 1$ ;NO ARG, DO ONCE + TTIDEC + BCS 1$ ;DO ONCE ANYWAY + MOV R0,R1 ;SAVE PULSE COUNT + BR 2$ +1$: CLR R1 +2$: ECLOK + BCC 3$ + JSR R1,$ECTIM +3$: DEC R1 ;DONE REQUESTED CLOCKS ? + BGT 2$ ;NOT YET +.PLX: JMP $KONSL + +;START MICROCODE IDLE. +;SUPPORT EXAMINE, DEPOSIT, AND EXECUTE OPERATIONS. + +.SM: TTITRM + SM ;DO THE EMT + BCS .XCTER + BR .PLX + +;CACHE INVALIDATE + +.CI: MOV #$$CI,R0 + +.CIF: TTITRM + DFLEGAL ;FUNCTION LEGAL ? + EXCT + BCS .XCTER ;FAILED + BR .PLX ;OK, RETURN TO CONSOLE + +;CACHE FLUSH + +.CF: MOV #$$CF,R0 + BR .CIF + +$$CI: IO10 DATAI,CCA,,0 ;INVALIDATE WITHOUT CORE UPDATE +$$CF: IO10 BLKO,CCA,,0 ;SWEEP CACHE, VALIDATING CORE +.EVEN + +;EXECUTE A PDP10 INSTRUCTION. + +.XCT: TENSP ;STOP TEN + BCS .XCTER ;DID NOT STOP PROPERLY + + TTISDL + BCS 1$ ;NON-NUMBER + + TTIS36 + + EXCT + BCS .XCTER + + BR .XCT2 + +1$: CMPB #'P,R0 ;"EXP" = EXECUTE & PRINT + BNE .XCT1 + + TTIS36 + + LODAR ;LOAD INTO AR + BCS .XCTER + +SIPNT=. + PNORML + DFXCTT ;SET CONTINUE BUTTON + CONBUT + +2$: ECLOK ;CLOCK TO GET STARTED + BCC 3$ + JSR R1,$ECTIM + +3$: BIT #HALTLP,@.DIAG1 + BNE 2$ ;TILL WE LEAVE HALT LOOP + PNTCPU ;PRINT C-RAM & REGISTERS + +4$: ECLOK ;CLOCK + BCC 5$ + JSR R1,$ECTIM + +5$: PNTCPU ;& PRINT TILL BACK TO HALT LOOP + BIT #HALTLP,@.DIAG1 + BEQ 4$ + +.XCT2: JMP $KONSL + +.XCT1: CMPB #'T,R0 ;"EXT" = EXECUTE & TRACE SETUP + BNE .CNSER + + TTIS36 + + LODAR ;LOAD INTO AR + BCS .XCTER + + DFXCTT ;SET CONTINUE BUTTON + CONBUT + + BR .XCT2 + +.XCTER: PMSG + JMP $CNTLC + +.CNSER: JMP $DFERR + +;BURST THE KL10 CLOCK + +.BU: DFLEGAL ;FUNCTION LEGAL ? + CLR TENCLK ;TURN OFF CLOCKK IF ON + TTISDL + BCS 2$ ;NO ARG, DO ONCE + TTIDEC + BCS 2$ ;DO ONCE ANYWAY +1$: BURST ;PERFORM BURST + BR .XCT2 +2$: MOV #1,R0 ;DO ONE BURST + BR 1$ + +;SELECT CLOCK SOURCE + +.CS: TTISDL + BCC 1$ + MOV CLKDFL,R0 + SR R0,2 +.CSR=. + BIC #177774,R0 + PNTNBR + PCRLF + JMP $CONSL + +1$: TTISDO + CMP R0,#2 + BGT .CSRER + + SHIFTL + 2 + BIC #14,CLKDFL ;CLEAR OLD SOURCE +.CCMN1: BIS R0,CLKDFL ;SET NEW SOURCE +.CCMN: DFLEGAL ;FUNCTION LEGAL ? + TST TENRUN + BEQ 1$ + TENSP ;STOP TEN + BCS .XCTER ;DID NOT STOP PROPERLY +1$: DFWRTT ;WRITE TO CLOCK + CLKDFL + LDSEL + JMP $KONSL + +.CSRER: JMP $PARA + +;SELECT CLOCK RATE + +.CR: TTISDL + BCC 1$ + MOV CLKDFL,R0 + BR .CSR + +1$: TTISDO + CMP R0,#3 + BGT .CSRER + + BIC #3,CLKDFL ;CLEAR OLD RATE + BR .CCMN1 + +;PROCESSOR PARITY DISABLE + +.PD: TTITRM + CLR PEBITS ;CLEAR PARITY ENABLE BITS + JMP $CONSL + +;PARITY ENABLED AND CLOCK ERROR STOP MESSAGES + +$PEAR: .ASCIZ %, AR/ARX% +$PEFM: .ASCIZ %, FM PARITY% +$PECR: .ASCIZ %, CRAM PARITY% +$PEDR: .ASCIZ %, DRAM PARITY% +$PEFS: .ASCIZ %, FS PROBE% +.EVEN + +;PROCESSOR PARITY ENABLE + +;PARITY ENABLE BITS ARE CODED AS FOLLOWS: +; AR/ARX, FM, CRAM, DRAM, FS +; 0 = PARITY DISABLED +; 37 WOULD = ALL ENABLED + +.PE: TTISDL + BCC 1$ + +20$: PMSG + MOV PEBITS,R1 ;PRINT PARITY ENABLE BITS + MOV R1,R0 + PNTODT + 2 +10$: BIT #20,R1 + BEQ 11$ + $PMSG + $PEAR ;AR/ARX PAGE FAIL +11$: BIT #10,R1 + BEQ 12$ + $PMSG + $PEFM ;FM PARITY +12$: BIT #4,R1 + BEQ 13$ + $PMSG + $PECR ;CRAM PARITY +13$: BIT #2,R1 + BEQ 14$ + $PMSG + $PEDR ;DRAM PARITY +14$: BIT #1,R1 + BEQ 15$ + $PMSG + $PEFS ;FS PROBE +15$: PCRLF +3$: JMP $CONSL + +1$: TTISDO + CMP R0,#37 + BGT .CSRER + MOV R0,PEBITS ;SAVE + BR 20$ + +;MICRO-CODE SYNC MARK ROUTINES + +.MU: MOV #-1,R5 ;MICRO UNMARK + BR .MMC + +.MM: CLR R5 ;MICRO MARK + +.MMC: DFLEGAL ;FUNCTION LEGAL ? + TTICRA ;GET C-RAM ADDRESS + MOV R0,$ECADR + + RCRAM ;READ C-RAM + + TST R5 + BNE 3$ + BIS #20,4(R0) ;SET MARK BIT + BR .MMX +3$: BIC #20,4(R0) ;CLEAR MARK BIT + +.MMX: MOV R0,R1 + MOV $ECADR,R0 + WCRAM ;WRITE C-RAM BACK + JMP $KONSL + +;MICRO-CODE TIME FIELD CHANGE ROUTINE + +.MT: DFLEGAL ;FUNCTION LEGAL ? + TTICRA + MOV R0,$ECADR + + TTISDO + CMP R0,#3 ;TIME FIELD IS 0-3 + BGT .CSRER + MOV R0,R5 + + MOV $ECADR,R0 + RCRAM ;READ C-RAM + BIC #12,(R0) ;CLEAR OLD TIME + CLR R4 + BIT #2,R5 + BEQ 1$ + BIS #10,R4 +1$: BIT #1,R5 + BEQ 2$ + BIS #2,R4 +2$: BIS R4,(R0) ;SET NEW TIME + BR .MMX + +;CACHE ENABLE + +;CACHE ENABLE BITS ARE CODED AS FOLLOWS: +; 10 = CACHE 0 +; 4 = CACHE 1 +; 2 = CACHE 2 +; 1 = CACHE 3 +; 17 WOULD = ALL CACHES ENABLED + +.CE: TTISDL ;GET ENABLE CODE + BCS 20$ ;CR, PRINT ENABLE +1$: TTISDO + CMP R0,#17 ;ENABLE IS 0 TO 17 + BGT 2$ + MOV R0,CLKDFL+4 ;PUT IN CLOCK DEFAULT PARAMETER WORD + BR 20$ +2$: JMP $PARAM + +20$: PMSG + MOV CLKDFL+4,R1 + MOV R1,R0 + PNTODT ;PRINT CODE + 2 +21$: CLR R2 + BIT #10,R1 ;CACHE 0 ENABLED ? + BEQ 22$ + JSR PC,.CEP + +22$: INC R2 + BIT #4,R1 ;CACHE 1 ENABLED ? + BEQ 23$ + JSR PC,.CEP + +23$: INC R2 + BIT #2,R1 ;CACHE 2 ENABLED ? + BEQ 24$ + JSR PC,.CEP + +24$: INC R2 + BIT #1,R1 ;CACHE 3 ENABLED ? + BEQ 25$ + JSR PC,.CEP + +25$: PCRLF + JMP $CONSL + +.CEP: PMSG <, CACHE > + MOV R2,R0 + PNTNBR ;PRINT CACHE ENABLE DIGIT + RTS PC + +;AC BLOCK SELECTION +;SETS UP "PAGDFL" WORD USED BY "DATAO PAG,0" +;DURING "STD,STM,STL & DDT" START COMMANDS +;SAME "PAGDFL" WORD USED BY "DATAO PAG,20" +;DURING AC BLOCK SELECTION COMMAND + +.AC: DFLEGAL + MOV #PAGDFL+2,R5 + TTISDL ;ALLOW FOR "ACBLK" OR "AC BLK" + BCC 5$ ;NUMBER + CMPB #'B,R0 + BNE 5$ + TTICHR + CMPB #'L,R0 + BNE 5$ + TTICHR + CMPB #'K,R0 + BNE 5$ + + TTISDL ;ANY NUMBER ? + BCS 4$ ;NO, PRINT PRESENT SELECTION + + TTISDO ;GET SELECTION DIGIT + CMP R0,#7 ;MUST BE 0 TO 7 + BGT 5$ + BEQ 3$ ;IF BLK #7, GIVE UCODE WARNING + +1$: PUSH R0 + PMSG + MOV (R5),R0 + SHIFTR + 11. + PNTNBR + PNTCI + ", + POP R0 + SHIFTL ;PLACE SELECTION DIGIT IN BITS 6-8 + 11. + BIC #034000,(R5) + BIS R0,(R5) ;INSERT IN PAGE DEFAULT WORD + +4$: PMSG + MOV (R5),R0 ;PRINT PRESENT AC BLOCK SELECTION + SHIFTR + 11. + PNTNBR + PCRLF + EXAMT ;SAVE MEM LOCATION 20 + 20 + $SAV20 + BCS 6$ + DPOSVT ;PUT DATAO PAG ARGUMENT IN 20 + 20 + PAGDFL + BCS 6$ + MOV #DATPAG,R0 + EXCT ;EXECUTE DATAO PAG + BCS 6$ + DPOSVT ;RESTORE 20 + 20 + $SAV20 + BCS 6$ + JMP $CONSL + +3$: PUSH R0 + PMSG + POP R0 + BR 1$ + +6$: PMSG + JMP $CNTLC + +5$: JMP $PARAM ;ERROR + +DATPAG: IO10 DATAO,PAG,,20 ;SELECT AC BLOCK +.EVEN + +;START PDP10 AT ADDRESS SPECIFIED AS LOWER 18 BITS OF 36-BIT ARGUMENT. + +$ST: TTISDL + BCS 4$ ;NON-NUMBER + TTIS36 ;READ ADDRESS, LEAVE R0 POINTING AT IT +$$ST=. + CLR R5 + +5$: MOV #$$STJRS,R1 ;STUFF ADDRESS INTO JRST + MOVB (R0)+,(R1)+ + MOVB (R0)+,(R1)+ + BICB #3,(R1) + BISB (R0),(R1) ;DO LAST TWO BITS + +3$: TST R5 ;ADDRESS START ? + BNE 31$ ;NO, PERFORM FULL SYSTEM RESET + BR 11$ ;YES, JUST DO JRST + +1$: PUSH R0 + EXCT ;EXECUTE A TEN INSTR + BCS $STERR + POP R0 + ADD #5,R0 + DEC R1 + BNE 1$ ;DO ANOTHER + JSR PC,$TI36C ;ZERO SELECTED AC BLOCK + MOV #$DRAM,R1 + MOV #16.,R0 ;FROM AC0 TO AC17 + D10ZRO ;NECESSARY FOR FM PARITY + BCS $STERR + +11$: MOV #$$STJRS,R0 + EXCT ;EXECUTE JRST TO START ADR + BCS $STERR + + CLR TENTTY ;TURN OFF "TENCHR" ROUTINE + JSR PC,$CMCLR ;CLEAR COMMON STORAGE + MOV #100.,$ENDCT ;REPORT EOP EVERY 100 + JMP $RNN + +31$: SM ;START MACHINE + BCS $STERR + DPOSVT ;DEPOSIT "DATAO PAG,0" ARGUMENT + 0 ;IN AC0, SELECTS CURRENT AC USAGE + PAGDFL + BCS $STERR + SETFLG ;SET TEN RUN FLAG + TENRUN + TENSW ;DEPOSIT PDP-10 SWITCHES + BCC 32$ + JMP C10SWE ;SWITCH ERROR +32$: MOV #4.,R1 + MOV #$STTB1,R0 + BR 1$ + +4$: CMPB #'D,R0 ;IF "STD", START 10 DIAGNOSTIC + BNE 6$ + MOV #TDIAG,R0 +7$: TTITRM +$$$ST=. + MOV #-1,R5 + BR 5$ +6$: CMPB #'L,R0 ;IF "STL", START PDP-10 LOADER + BNE 8$ + MOV #TLDR,R0 + BR 7$ +8$: CMPB #'M,R0 ;IF "STM", START PDP-10 MONITOR + BNE 11$ + MOV #TMON,R0 ;IF NONE, START AT LAST START ADR + BR 7$ +$STERR: JMP .XCTER + +$STTB1: IO10 CONO,APR,,267760 ;RESET APR + IO10 CONO,PI,,10000 ;PI SYSTEM CLEAR + IO10 CONO,PAG,,0 ;PAGING SYSTEM CLEAR + IO10 DATAO,PAG,,0 ;USER BASE CLEAR & AC SELECT +.EVEN +.CNERR: JMP $PARA + +.SBTTL PDP-10 DEPOSIT AND EXAMINE CONSOLE FUNCTIONS + +.DP: MOV #.DPXAD,R5 + TTISDL + BCS .DPS + TTIS36 + MOV (R0)+,(R5)+ ;LOW ADDRESS + MOV (R0),(R5) ;HIGH ADDRESS +.DPNX1: TST -(R5) + +.DPCOM: TTIS36 ;GET DATA + MOV R5,R1 ;PTR TO ADR + JSR PC,$TENRN + DPOS ;DO IT + BCS 1$ + JMP $KONSL + +1$: PMSG + JSR R1,$DFTM1 + +.DPNX: MOV #.DPXAD,R5 + ADD #1,(R5)+ ;BUMP LOW + ADC (R5) ;CARRY TO HIGH + BR .DPNX1 + +.DPS: BVS .DPCOM ;COLON, USE PRESENT ADDRESS + BR .CNERR + +$TENRN: BIT #ERRSTP,@.DIAG1 ;TEN CLOCK RUNNING ? + BEQ 1$ ;YES, OK + JMP TENCERR ;NO, REPORT IT +1$: RTS PC + +;MEMORY ZERO +; "MZ ADR,COUNT" + +.MZ: DFLEGAL ;FUNCTION LEGAL ? + TTIS36 ;INPUT PDP-10 START ADDRESS + MOV $DRAM,MMDAT ;SAVE IT + MOV $DRAM+2,MMDAT+2 + MOV #MMDAT,R1 ;POINTER FOR D10ZRO + TTIS36 ;INPUT NUMBER OF PDP-10 WORDS + BCS 1$ + MOV $DRAM+2,R2 ;PICK UP NUMBER OF 64K MOBIES + BEQ 2$ + BPL 4$ + MOV #XMEMSZ/64.,R2 ;MZ 0,-1. DON'T TRY TO CLEAR + CLR $DRAM ; 4096 MILLION WORDS. +4$: CLR R0 ;CLEAR ONE SMALL MOBY + D10ZRO + BCS 3$ + JSR PC,$TIRDY ;ALLOW ^C IN THIS SLOW LOOP + BCS 69$ + CMPB $TICHR,#CNTRLC + BNE 69$ + JMP $TICC ;^C, ABORT + +69$: INC MMDAT+2 ;BUMP ADDRESS + DEC R2 + BGT 4$ +2$: MOV $DRAM,R0 ;CLEAR FINAL FRACTIONAL MOBY + BEQ 5$ ;EXACT MULTIPLE OF 64K + D10ZRO ;ZERO MEMORY + BCS 3$ + +5$: JMP $KONSL + +1$: MOV #1,$DRAM ;NO COUNT SPECIFIED + BR 2$ ;SO CLEAR ONE WORD + +3$: PMSG + JSR R1,$DFTM1 + +.EXM: MOV #.DPXAD,R5 + CLR R3 + TTISDL + BCS .EXMSP ;NON-NUMBER + TTIS36 ;GET PDP-10 ADDRESS + MOV (R0)+,(R5)+ ;SAVE LOW 16 BITS + MOV (R0),(R5) ;SAVE HIGH BITS + TST -(R5) + TTIBRK ;GET BREAK + BCS .CNERR + CMPB #',,R0 + BNE .EXCOM + COM R3 ;COMMA, MULTIPLE PRINT + PNORML + TTIS36 ;GET ENDING ADDRESS + MOV (R0),R4 ;SAVE LOW 16 BITS + +.EXCOM: MOV R5,R0 + JSR PC,$TENRN + EXAM + BCS 3$ +5$: TSTB RPTFLG + BNE 1$ + MOV R5,R0 + PNTADR + PNTBAK ;BACKUP POINTER TO WIPE OUT SPACE + PSLASH + MOV #$DRAM,R0 + PNT36 + + TST R3 ;DOING MULTIPLE PRINT ? + BEQ 2$ + PCRLF + CMP (R5),R4 + BEQ 2$ + INC (R5) ;INCREMENT LOW 16 BITS, 64K + BR .EXCOM ;DO NEXT ADDRESS +2$: PCRLF +1$: JMP $KONSL + +3$: BMI 4$ + PMSG + JSR R1,$DFTM1 + +4$: $PMSGR + $EBPAR ;E-BUS PARITY ERROR + BR 5$ + +.EXMSP: BVS .EXMNX ;COLON OR SLASH, EXAMINE NEXT + BNE .EXCOM ;NONE, EXAMINE SAME + SUB #1,(R5)+ ;UPARROW, EXAMINE PREVIOUS + SBC (R5) + BR .EXMN1 +.EXMNX: MOV #.DPXAD,R5 + ADD #1,(R5)+ + ADC (R5) +.EXMN1: INC $INPTC + CLR R3 + TST -(R5) + BR .EXCOM + +.SBTTL CONSOLE IDLE RUN LOOP + +;PROVIDES PDP-10 SUPPORT WHEN "TENRUN" SET +;AND ADDITIONALY PDP-10 MONITOR SUPPORT IF "MONMODE" SET + +$RUNLP: TSTB TENRUN ;PDP-10 RUN TIME SUPPORT ? + BNE 1$ + JMP $TTILIN ;NO, CONSOLE COMMAND INPUT + +1$: CLR DDTTM2 ;SETUP DDT MODE TIMEOUT +;LOOPS BACK TO HERE IF NOTHING TO DO. +2$: TST ITSFLG ;USING I.T.S. IO-ELEVEN PROGRAM? + BEQ 11$ ;NO, USE D.E.C. STUFF + JSR PC,ITSCHK ;YES, MAKE SURE IT'S STILL IN CORE + JSR PC,@#3000 ;IT IS, CALL IT + BCS MTTYI0 ;RETURNS WITH CARRY SET => TEMPORARY KLDCP CMD MODE. + ;OTHERWISE, PROBABLY 10 HALTED. CHECK IT OUT. +11$: BIT #KLRUN,@.DIAG1 + BNE 3$ + JMP TENDEAD ;PDP-10 HALTED + +3$: BIT #ERRSTP,@.DIAG1 ;PDP-10 CLOCK ERROR STOP ? + BEQ 31$ + JMP TENCERR ;YES, REPORT +31$: BIT #TO11DB,@.STDTE + BNE TENCMD ;PDP-10 REQUESTED SERVICE + +4$: JSR PC,C10COP ;PERFORM CLOCK OPERATIONS + +5$: TST MONMODE ;MONITOR SUPPORT MODE ? + BEQ 20$ ;NO + +6$: JSR PC,$TIRDY ;TTY INPUT FLAG SET ? + BCC MTTYIN ;YES, SEND CHAR TO 10 + +7$: TST MTTYOF ;TTY OUTPUT IN PROGRESS ? + BEQ 2$ ;NO + +8$: JSR PC,$TORDY ;TTY OUTPUT COMPLETED ? + BCC MTTYOC ;YES, NOTIFY 10 + BR 2$ ;STAY IN MONITOR LOOP + +20$: TST DDTFLG ;PDP-10 DDT INPUT MODE ? + BEQ 21$ ;NO +23$: DEC DDTTM2 ;WAITED LONG ENOUGH ? + BNE 2$ ;NOT YET + CLR DDTFLG ;YES, REVERT TO CONSOLE MODE + +21$: JSR PC,$TIRDY ;ANY TTY INPUT YET ? + BCS 2$ ;NO, STAY IN RUN LOOP + JMP $TILRN ;YES, GO INPUT + +;MONITOR TELETYPE CHARACTER INPUT + +MTTYIN: MOVB $TICHR,R0 ;GET INPUT CHAR + CMPB R0,#MSWCHR ;MONITOR TO "KLDCP" SWITCH CHAR ? + BNE MTTYI1 +MTTYI0: PMSG <\KLDCP\. _> ;PROMPT FOR TEMPORARY KLDCP MODE + JMP $TTILIN ;AND READ ONE KLDCP COMMAND LINE + +MTTYI1: MOV R0,TENDAT + DPOSVT ;SEND CHAR TO TEN + $DTF11 + TENDAT + BCS MTTYER ;FAILED + D10MON ;SET -1 TO 10 TTY INPUT FLAG + $DTMTI + BCS MTTYER +C10DN1: MOV #INT10S,@.STDTE ;DING TEN + BR $RUNLP +MTTYER: JMP C10TIE + +;MONITOR TELETYPE OUTPUT COMPLETE + +MTTYOC: D10MON ;SET -1 TO 10 TTY OUTPUT DONE FLAG + $DTMTD + BCS MTTYER + CLR MTTYOF ;CLEAR OUTPUT IN PROGRESS + BR C10DN1 ;CAUSE DTE20 INTERRUPT + +;MONITOR TELETYPE OUTPUT ROUTINE + +MTTYO: MOV R5,R0 ;GET OUTPUT CHAR + BIC #177400,R0 ;STRIP TO 8 BITS, 10 DOES PARITY + MOVB R0,$TOCHR ;PRINT CHAR + JSR PC,$TOOUT + SETFLG + MTTYOF ;SET OUTPUT IN PROGRESS FLAG +MTTYX: BR C10DON ;ALLOW 10 TO CONTINUE + +;MONITOR MODE CONTROL + +MTTYC: SETFLG ;SET + MONMODE + BR MTTYX +MTTYCF: CLR MONMODE ;CLEAR + BR MTTYX +$MC: SETFLG ;CONSOLE MONITOR CONTINUE + MONMODE + JMP $CONSL + +MTTYS: MOV MONMODE,R0 ;SEND 10 MONITOR TTY STATE + JMP C10TIX + +.SBTTL PDP-10 RUN TIME SUPPORT + +TENCMD: EXAMT ;GET COMMAND CODE + $DTCMD + $ECMD + BCC 1$ + BPL 2$ ;EXAMINE FAILED + $PMSG + $EBPAR ;E-BUS PARITY ERROR +2$: BR C10DNX + +1$: MOV $ECMD,R5 + MOV R5,R1 + SWAB R1 + BIC #177760,R1 + SL R1,1 + JMP @CMD10T(R1) ;DISPATCH TO ROUTINE + +CMD10T: C10TO ;TTY OUT + C10PRG ;PROGRAM CONTROL + C10CLK ;CLOCK + C10SW ;SWITCHES + C10TO ;TTY OUT + C10TI ;TTY IN + C10PNT ;PRINT CONTROL + C10DDT ;DDT INPUT MODE + MTTYO ;MONITOR TTY OUTPUT + MTTYC ;MONITOR TTY MODE CONTROL ON + MTTYCF ;MONITOR TTY MODE CONTROL OFF + MTTYS ;MONITOR TTY STATE + C10DNX ;14-17 UNUSED NOW + C10DNX + C10DNX + C10DNX + +C10DON: MOV #INT11C,@.STDTE ;CLEAR DONG + D10MON ;SET -1 TO 10 "$DTFLG" + $DTFLG ;DTE20 OPERATION COMPLETE FLAG + BCS C10DNX + JMP $RUNLP ;WAIT FOR NEXT COMMAND + +C10DNX: CLR TENRUN + PMSG + BR $$TDX + +TENCERR:CLR TENRUN + CLR KLCLKR ;CLEAR TEN RUNNING + PFORCE + PMSG <\KL10 CLOCK ERROR STOP> + DFRDT + 106 + BIT #BIT5,@.DAT3 ;FIELD SERVICE ? + BEQ 1$ + $PMSG + $PEFS ;FS PROBE + +1$: DFRDT + 105 + BIT #BIT5,@.DAT3 ;FM PARITY ? + BEQ 2$ + $PMSG + $PEFM ;FM PARITY + +2$: DFRDT + 104 + BIT #BIT5,@.DAT3 ;CRAM PARITY ? + BEQ 3$ + $PMSG + $PECR ;CRAM PARITY + +3$: DFRDT + 103 + BIT #BIT5,@.DAT3 ;DRAM PARITY ? + BEQ 4$ + $PMSG + $PEDR ;DRAM PARITY +4$: PNTCPU ;PRINT ALL CPU INFORMATION + BR $$TDX + +TENDEAD: CLR TENRUN ;CLEAR TEN RUN FLAG + PFORCE + PMSG <\KL10 HALTED > + SETFLG + ALLFLG + JSR PC,$ALLPC + JSR PC,$ALVMA +.IF DF MBYHLT + PCRLF + MOV #111,R0 ;GET APR FM BLOCK 1,2,4 (BITS 4.1-4.3) + ;ALSO 3.7-3.9 GET PREV AC BLOCK + MOV #$DRAM,R1 ;INTO $DRAM (HANDY BUFFER) + DFRDMV + MOVB $DRAM+3,R0 ;BITS 4-11 + BIC #-100,R0 ;GET JUST CURRENT*8+PREVIOUS + PUSH R0 ;SAVE SELECTED BLOCK + PMSG + MOV #-1,R0 + PRGCMD + BCS $$TDX + PMSG + MOV #-1,R0 + PRGCMD + PMSG + POP R0 + MOVB R0,PAGDFL+3 ;STORE INTO PAGE DEFAULT WORD + ASR R0 ; SO PREVIOUS BLOCK GETS RESTORED + ASR R0 ;THEN EXTRACT CURRENT BLOCK + ASR R0 + PNTOCS ;NOW DO AC BLK N COMMAND + PCRLF + MOV #-1,R0 + PRGCMD +.ENDC ;MBYHLT +$$TDX: PCRLF ;TEN BLEW UP (FELL FLAT?) + MOV #7,R5 ;((WAS MOWED DOWN BY A FELL FLAT DISK?)) +1$: PBELL ;GO FEEP FEEP FEEP FEEP FEEP + CLR R0 +3$: DEC R0 + BNE 3$ + DEC R5 + BNE 1$ + JMP $CONSL + +C10TO: SETFLG + TENTTY ;ALLOW "TENCHR" TO OPERATE + MOV #$TNBUF,$TNPTC ;RESET 10 INPUT POINTERS + MOV #$TNBUF,$TNPTR + MOV R5,R1 ;GET ASCII CHAR + PLDBUF ;PUT IN TTY OUT BUFFER +C10DNJ: BR C10DON + +C10TI: CLR DDTFLG + CMP #$OUTBF,$OUTPT ;ANY OUTPUT WAITING ? + BNE C10TIZ ;YES +11$: CMP $TNPTC,$TNPTR ;CURRENT BUFFER EMPTY ? + BGE C10TIZ ;YES + + MOV $TNPTC,R1 ;GET CHAR POINTER + MOVB (R1)+,R0 ;FETCH CHAR FROM 10 BUFFER + MOV R1,$TNPTC + +C10TIX: MOV R0,TENDAT ;PUT CHAR IN 28-35 OF TEN WORD + DPOSVT ;DEPOSIT IN FROM 11 WORD + $DTF11 + TENDAT + BCC C10DNJ +C10TIE: PMSG + BR $$TDX + +C10TIZ: TTILIN ;INPUT LINE FOR TEN + BCS 5$ ;NO RESPONSE + MOV #$TNBUF,R1 +3$: TTICHR ;GET CHAR FROM INPUT + BCS 4$ ;EMPTY + MOVB R0,(R1)+ ;PUT IN TEN BUFFER + BR 3$ +4$: MOV R1,$TNPTR ;UPDATE 10 EOL POINTER + MOV #$TNBUF,$TNPTC ;SET PICKUP POINTER TO START + BR C10TI ;GO SEND FIRST CHAR TO TEN +5$: CLR R0 ;NULL = TIMEOUT + BR C10TIX + +C10PNT: MOV R5,R1 ;GET CONTROL BYTE + BIC #177400,R1 + MOV R1,$FORCE ;PUT IN FORCE FLAG + CLR DDTFLG ;CLEAR DDT MODE +C10X: JMP C10DON + +C10SW: DPOSVT ;LOAD SWITCHES INTO FROM 11 WORD + $DTF11 + SWS10 + BCC C10X +C10SWE: PMSG + BR $$TDX + +$SW: MOV #SWS10,R5 + TTISDL + BCS 1$ ;NON-NUMBER, TYPE PRESENT + TTIS36 + MOV (R0)+,(R5)+ ;PUT IN SWITCH WORD + MOV (R0),(R5) +2$: TENSW ;DO PDP-10 SWITCHES + BCS C10SWE ;ERROR + JMP $KONSL + +1$: PFORCE + MOV R5,R0 ;PRINT CURRENT SWITCHES + PNT36 + PCRLF + BR 2$ + +C10DDT: SETFLG + DDTFLG ;SET FOR DDT MODE INPUT + PFORCE ;SET FORCED PRINTOUT + CMP #$OUTBF,$OUTPT ;ANY OUTPUT WAITING ? + BEQ 2$ ;NO + SETFLG + $TTLKF ;PREVENT INPUT CHECKS + PRINTT ;YES, PRINT IT +2$: TTLOOK ;GET INPUT CHAR + BCS 3$ ;NOTHING THERE, SEND ZERO +3$: CMPB R0,#MSWCHR + BEQ 4$ ;BREAK => RETURN TO KLDCP + CMPB R0,#CNTRLX ;CONTROL X, NEXT LINE IS CONSOLE CMD + BNE C10TIX + PNTCI + "^X + JMP $TTILIN + +4$: JMP MTTYI0 + +C10PRG: MOV R5,R1 ;GET CONTROL FIELD + BIC #177760,R1 + SL R1,1 + JMP @C10PT(R1) ;DISPATCH + +C10PT: TENDEAD ;HALT + C10P1 ;FATAL + C10P2 ;ERROR HALT + C10P3 ;END OF PROGRAM + C10P4 ;END OF PASS + C10P5 ;GIVE PDP-10 CLOCK DEFAULT WORD + DIASEL ;"DIAMON" FILE SELECTION + DIARD ;"DIAMON" FILE READ + P10CMD ;PDP-10 PROGRAM COMMAND + C10DNX + C10DNX + C10DNX + C10DNX + C10DNX + C10DNX + C10DNX + +C10P2: CLRB TENRUN +C10P1: CLR TENCLK +C10X1: BR C10X + +C10P3: CLRB TENRUN ;TURN OFF TEN RUNNING + ERREOP ;END OF PROGRAM + +C10P4: EOP + BR C10X + +C10P5: DPOSVT + $DTF11 + CLKDFL + BCS C10CER + BR C10CX + +C10CLK: MOV R5,R1 + BIC #177774,R1 + SL R1,1 + JMP @C10CPT(R1) + +C10CPT: C10C0 ;DISABLE + C10C1 ;ENABLE + C10C2 ;ENABLE & WAIT + C10C3 ;READ PDP-10 CLOCK COUNT + +C10C0: CLR TENCLK +C10CX: BR C10X1 + +C10C3: DPOSVT ;LOAD CLOCK COUNT INTO FROM 11 WORD + $DTF11 + CLKCNT + BCS C10CER ;ERROR + BR C10CX + +C10C1: SETFLG + TENCLK +C10CX1: BIC #200,KWLKS +1$: TSTB KWLKS ;WAIT FOR CLOCK + BPL 1$ ;THEN CLEAR TO ALLOW FOR + BIC #200,KWLKS ;16MS BEFORE 1ST CLOCK + MOV #CLKCNT,R0 ;INIT CLOCK COUNTER + CLR (R0)+ + CLR (R0)+ + CLR (R0) + BR C10CX + +C10C2: EXAMT ;GET WAIT COUNT FROM TO 11 WORD + $DTT11 + C10CW + BCS C10CER + MOV #177400,TENCLK + BR C10CX1 + +C10COP: TSTB KWLKS ;CLOCK FLAG SET ? + BPL 1$ ;NO, RETURN + BIC #200,KWLKS ;CLEAR FLAG + INC $TTYTIM ;COUNT TTY TIMER + CMP SWR,$$SWR ;PDP-11 CONSOLE SWITCHES CHANGED ? + BEQ 3$ ;NO + PUSH R0 + TENSW ;YES, DO PDP-10 SWITCHES + BCS C10CER ;ERROR + POP R0 +3$: TSTB TENRUN ;IS 10 RUNNING ? + BEQ 1$ ;NO + TST TENCLK + BEQ 1$ ;CLOCK NOT ENABLED + ADD #1,CLKCNT ;INCREMENT PDP-10 CLOCK COUNT + ADC CLKCNT+2 + ADC CLKCNT+4 + TSTB TENCLK ;DOING WAIT ? + BNE 2$ ;NO + CMP CLKCNT,C10CW ;WAITED LONG ENOUGH ? + BNE 1$ ;NOT YET +2$: PUSH + D10MON ;SET -1 TO 10 "$DTCLK" + $DTCLK + BCS C10CER + MOV #INT10S,@.STDTE ;DING TEN + POP +1$: RTS PC + +C10CER: CLR TENCLK + PMSG + JMP $$TDX + +;PDP-10 SWITCH REGISTER + +$TENSW: MOV SWR,$$SWR ;GET PDP-11 SWITCHES + MOV $$SWR,$SWS10+2 + + MOV #$SWS10,R1 ;POSITION FOR 0 TO 15 OF + MOV #4,R3 ;PDP-10 SWITCH REGISTER + PROL36 + + MOV #$SWS10+2,R4 + MOV #SWS10+2,R5 + + BIC #17,(R4) ;CLEAR 16-19 FROM NEW + BIC #177760,(R5) ;CLEAR 4-15 FROM OLD + + BIS (R4)+,(R5)+ ;INSERT BITS 4-15 + + BIC #177760,(R4) ;CLEAR HI JUNK FROM NEW + BIC #17,(R5) ;CLEAR 0-3 FROM OLD + + BIS (R4),(R5) ;INSERT BITS 0-3 + + TSTB TENRUN ;PDP-10 RUNNING ? + BEQ 1$ ;NO + + DPOSVT ;DEPOSIT PDP-10 SWITCH REGISTER + $DTSWR ;IN DTE20 COMM AREA + SWS10 + BCS 2$ ;ERROR +$TCX=. +1$: EXIT +2$: EXITERR ;RETURN + +;PDP-10 LAST TYPED CHARACTER ROUTINE + +$TENCHR:TSTB TENRUN ;PDP-10 RUNNING ? + BEQ $TCX ;NO + TST TENTTY ;TTY DEPOSIT ALLOWED ? + BEQ $TCX ;NO + PUSH R0 + DPOST ;YES, SEND LAST TYPED CHAR + $DTCHR + $TNCHR + POP R0 + BR $TCX ;DON'T CARE IF FAILED + +.SBTTL PDP-10 PROGRAM COMMAND + +P10CMD: MOV #-1,R0 ;USE OUTPUT BUFFER + PRGCMD ;& PROGRAM COMMAND + BCS DIANF ;C-BIT SET, ERROR + BR DIAFND ;PASSED + +.SBTTL "DIAMON" FILE SELECTION AND READ ROUTINES + +DIASEL: MOV #$INBUF,R1 ;PUT "P" & "SPACE" FIRST + MOV #"P ,(R1)+ ;IN CASE ACT10 LOAD + MOV #$OUTBF,R0 ;TRANSFER "DIAMON" FILE.EXT + MOV R0,$OUTPT ;TO INPUT BUFFER + JSR PC,$DIASX + MOV #$INBUF+2,$INPTC ;SET PICKUP POINTER + + NAMEXT ;SETUP FILE NAME.EXT + + SETFLG + LDCNTL ;SET LOAD CONTROL TO HELP + SETFLG + DIAFLG ;SET PROCESSING TO "DIAMON" MODE + + JMP DEVFIL ;GO LOOKUP & READ FIRST ASCII LINE + +;RETURN HERE WHEN FILE FOUND + +DIAFND: CLR R0 ;SET FOUND INDICATOR + +$DIAFX: JMP C10TIX ;USE 10 TTY INPUT ROUTINE + +;RETURN HERE WHEN FILE NOT FOUND + +DIANF: MOV #-1,R0 ;SET NOT FOUND INDICATOR + BR $DIAFX + +;"DIAMON" FILE READ + +DIARD: JSR PC,$TI36C ;CLEAR 36 BIT WORD STORAGE + + CMP $INPTC,$INPTR ;ANY CURRENT INPUT ? + BLE DIARNL ;NO +1$: JMP ACTLD2 ;GO READ NEXT INPUT LINE + +DIARNL=. ;RETURN HERE WITH NEW LINE SETUP +2$: MOV #5,R2 ;5 ASCII CHARS PER 36 BIT WORD + +3$: CMP $INPTC,$INPTR ;EOL ? + BGT 4$ ;YES + MOVB @$INPTC,R0 ;GET FILE LINE CHAR + INC $INPTC + MOV #7,R1 + JSR PC,SHFT36 ;SHIFT 36 BIT WORD LEFT 7 + BISB R0,$DRAM ;INSERT NEW ASCII BYTE + DEC R2 ;DONE 5 CHARS ? + BGT 3$ ;NOT YET + +4$: CLR R1 ;LEFT JUSTIFY FOR PDP-10 ASCII + JSR PC,SHFT36 + + DPOSVT ;LOAD INTO FROM 11 WORD + $DTF11 + $DRAM + BCC 6$ ;OK + +5$: PMSG + JMP $$TDX + +DIAEOF=. ;DIAMON READ END-OF-FILE + D10MON ;SET FROM 11 WORD -1 + $DTF11 + BCS 5$ ;ERROR + +6$: JMP C10DON ;TELL 10 TO CONTINUE + +.SBTTL PDP-11 CONSOLE FUNCTIONS + +;START PDP11 AT ADDRESS GIVEN + +.SE: TTISDL + BCS 2$ ;NON-NUMBER + +1$: TTOCTE ;READ AN OCTAL ADDRESS + +4$: MOV R0,SEADR ;GO TO ADDRESS IN R0 + JMP SRT11 + +2$: CMPB #'D,R0 ;"D", START DIAGNOSTIC + BEQ 3$ + CMPB #'C,R0 ;"C", START CONSOLE + BNE $$CMDE + MOV #PRGSRT,R0 + BR 4$ +3$: MOV #3000,R0 + BR 4$ + +;EXAMINE ELEVEN AT ADDRESS GIVEN + +.EE: MOV #1,R5 + BR .EEB + +.EB: CLR R5 + +.EEB: MOV #.EADR,R2 + CLR R3 + TTISDL + BCS 6$ ;NON-NUMBER + + TTCOCT ;READ AN OCTAL ADDRESS + + MOV R0,R1 + MOV R0,(R2) ;SAVE ADR FOR DEPOSIT + + TTIBRK ;GET BREAK CHAR + BCS $$PARA + CMPB #COMMA,R0 + BNE 2$ + INC R3 ;SET MULTIPLE PRINT FLAG + PNORML + TTCOCT ;GET LAST ADDRESS + MOV R0,R4 ;SAVE END ADR + +2$: BIC R5,R1 ;IF WORD, MAKE EVEN +21$: MOV R1,R0 + MOV R1,(R2) ;SAVE ADDRESS + PNTOCT ;PRINT ADDRESS + PSLASH + +1$: TST R5 ;BYTE ? + BEQ 3$ ;YES + + MOV (R1),R0 + PNTOCT ;PRINT CONTENTS OF ADDRESS + BR 4$ + +3$: MOVB (R1),R0 + BIC #177400,R0 + PNTOCS ;PRINT BYTE CONTENTS + +4$: TST R3 + BEQ 5$ + PCRLF + CMP R1,R4 + BHIS 5$ + INC R1 ;INCREMENT ADDRESS + ADD R5,R1 ;IF WORD, INC BY 2 + BR 2$ + +5$: PCRLF + JMP $KONSL + +6$: BEQ 7$ ;UPARROW + BVC 61$ ;NONE + INC (R2) ;EXAMINE NEXT 11 ADDRESS + ADD R5,(R2) +61$: MOV (R2),R1 + INC $INPTC ;ADVANCE PAST TERMINATOR + BR 2$ + +7$: DEC (R2) + SUB R5,(R2) + BR 61$ + +;ZERO ELEVEN + +.ZE: TTOCTE ;GET START ADDRESS + MOV R0,R5 + + TTCOCT ;GET END ADDRESS + +1$: CLR (R5)+ ;ZERO 11 + CMP R5,R0 ;COMPLETED ? + BLOS 1$ ;NO + JMP $CONSL + +;DEPOSIT ELEVEN DATA + +.DE: MOV #1,R5 ;DEPOSIT 11 WORD + BR .DEB + +.DB: CLR R5 ;DEPOSIT 11 BYTE + +.DEB: MOV #.EADR,R2 + TTISDL + BCS 5$ ;NON-NUMBER + + TTCOCT ;READ OCTAL ADDRESS + +1$: MOV R0,R1 + TST R5 + BEQ 2$ + BIT R5,R0 + BNE $$PARA ;WORD, ODD ADDRESSES ILLEGAL + +2$: TTISDL + BCS $$CMDE + TTCOCT ;GET DATA + + MOV R1,(R2) + + TST R5 ;BYTE ? + BEQ 3$ + + MOV R0,(R1) ;STOW IT + BR 4$ + +3$: MOVB R0,(R1) ;STOW 11 BYTE +4$: JMP $KONSL + +5$: BVC $$CMDE ;IF COLON, USE PREVIOUS EXAMINE ADDRESS + MOV (R2),R0 + BR 1$ + +$$PARA: JMP $PARA +$$CMDE: JMP $CMDE + +.SBTTL KL10 MONITOR & ACT10 COMMAND ROUTINES + +$VERIFY:SETFLG + VERIFY + PNORML + BR $PROG1 + +$LDT: MOV #1,LDOVRD ;LOAD TEN, OVERRIDE EXT + BR $PROG2 +$LDE: MOV #2,LDOVRD ;LOAD ELEVEN, OVERRIDE EXT + BR $PROG2 +$LDR: MOV #3,LDOVRD ;LOAD RAM, OVERRIDE EXT + BR $PROG2 +$LDB: MOV #6,LDOVRD ;LOAD ELEVEN BIN, OVERRIDE EXT + BR $PROG2 + +$PROG: CLR LDOVRD ;CLEAR OVERRIDE +$PROG2: CLR VERIFY +$PROG1: CLR LDCNTL ;CLEAR LOAD CONTROL FLAG + CLR SRTFLG ;CLEAR SELF START FLAG + CLRB CONSOL-1 ;OVERLAY INUSE INDICATOR + BR $HELP1 ;GO LOAD PROGRAM + +$JFILE: SETFLG + JFILEF ;SET DOUBLE INDIRECT FLAG + CLR PRGRUN ;CLEAR PROGRAM RUNNING FLAG + MOV #TOUTBF+5000,IFINP ;SETUP STORAGE POINTER + BR $IIX + +$IFILE: MOV #TOUTBF,IFINP ;SETUP STORAGE POINTER +$IIX: CLR PCMDFLG ;CLEAR PROGRAM COMMAND + SETFLG + IFILEF ;SET INDIRECT FILE FLAG + CLR @IFINP ;CLEAR 1ST BUFFER WORD + CLRB CONSOL-1 ;OVERLAY INUSE INDICATOR + +$HELP: CLR LDOVRD ;CLEAR LOAD OVERRIDE FOR H,I,J + SETFLG + LDCNTL ;SET LOAD CONTROL TO "HELP" + PNORML + TST DEVTYP + BPL $HELP1 + JMP ACTFIL ;ACT10 HELP +$HELP1: JMP DVLOAD ;RP04/DECTAPE/FLOPPY HELP + +$AT: TTITRM + SETFLG + DEVTYP ;SET ACT10 MODE + COMCLR ;CLEAR COMMUNICATIONS + BR $DTX + +$DT: CLR FLOPPY + TTISDL + BCS $DTC ;LETTER + TTISDO ;GET UNIT SELECTION DIGIT + CMP R0,#7 ;MUST BE 0 TO 7 + BGT $CMDEJ + SWAB R0 ;PUT IN PROPER PLACE FOR TC11 + MOV R0,DTUNIT ;SAVE IT +$RXX: CLR DEVTYP ;SET DECTAPE MODE +$DTX: JMP $KONSL + +$RX: SETFLG + FLOPPY + TTISDL + BCS $DTC ;LETTER + TTISDO ;GET SELECTION DIGIT + CMP R0,#1 ;MUST BE EITHER 0 OR 1 +$CMDEJ: BGT $CMDE + BNE $RX.1 + MOV #RXU1,R0 +$RX.1: MOV R0,RXUNIT ;SAVE FOR RX11/RX01 FLOPPY + BR $RXX + +$DTC: CMP #"CO,$INBUF+2 ;IS COMMAND 'DTCOPY'/'RXCOPY' ? + BNE 1$ + CMP #"PY,$INBUF+4 + BNE 1$ + JSR PC,$KLUCK ;UTILITY IN CORE ? + TST FLOPPY + BEQ 2$ + JMP @RXCOPY ;FLOPPY COPY +2$: JMP @DTCOPY ;YES +1$: JMP $CMDER + +$GO: INC $INPTC +$$GO: MOV PGOCTL,R0 ;GO, START PROGRAM + JMP @LDSTRT(R0) + +LDSTRT: SRT11X + SRT10 + +$JC: TTITRM + SETFLG ;SET J FILE FLAG TO CONTINUE + JFILEF ;INTERRUPTED J FILE PROCESS + BR $DTX + +SRT11X: MOV PGOADR,SEADR +SRT11: TST SEADR + BEQ 1$ ;IF ADR 0, START AT 3000 + BIT #1,SEADR + BNE ADRERR ;ODD ADDRESSES NOT ALLOWED + +2$: JSR PC,$CMCLR ;CLEAR COMMON STORAGE + + CLR IFILEF ;END INDIRECT PROCESS + SETFLG + PRGRUN + MOV #STACK-2,R0 ;PASS STACK BASE ADR IN R0 + MOV R0,SP ;RESET STACK + TST EMTLDD ;CLOBBER IN EMT VECTOR IF NECC. + BEQ 10$ + MOV EMTLDD,EMTVEC + MOV EMTLDD+2,EMTVEC+2 +10$: JMP @SEADR ;START 11 PROGRAM AT LOAD ADDRESS + +1$: MOV #3000,SEADR + BR 2$ + +;ACT10 TIME REQUEST + +$TIME: TTBTRM + TST DEVTYP + BPL $TIME1 ;ONLY LEGAL IN ACT10 MODE + + COMENQ ;REQUEST APT10 SERVICE + + MOV #$INBUF,R0 + COMCMD ;SEND COMMAND + + $PMSG ;PRINT INPUT LINE + CINBF + COMCLR +$TIME3: JMP $CONSL + +$TIME1: JMP NONACT ;NON ACT10 + +$LOGO: +$LOGIN: TST DEVTYP ;ONLY LEGAL IN ACT10 MODE + BPL $TIME1 + TTITRM + + COMENQ ;REQUEST SERVICE + + MOV #$INBUF,R0 + COMCMD ;SEND COMMAND + COMEOT + BR $TIME3 + +SRT10: MOV #TGOADR+2,R0 + MOV #PGOADR+2,R1 ;PUT LOAD ADR IN 10 GO ADR + MOV (R1),(R0) + MOV -(R1),-(R0) + JMP $$$ST ;GO TO 10 START ROUTINE + +$COMNT: TST DEVTYP ;ACT10 MODE ? + BPL 1$ ;NO, LOCAL ONLY + + COMENQ ;REQUEST APT10 SERVICE + + MOV #$INBUF,R0 + COMCMD ;SEND MESSAGE + COMEOT + +1$: BR $TIME3 ;BACK TO CONSOLE + +$BOOT: +$SCRPT: +$MSCP: +$GSCP: +$BOOTT: JMP $CMDER + +ADRERR: PMSG + BR COMNER + +$PARA: PMSG + BR COMNER + +$CMDE: JMP $CMDER + +NONACT: PMSG + BR COMNER + +NORESP: PMSG + +COMNER: JMP $CNTLC + +;REINITIALIZE SYSTEM + +.RI: CLR $ONETM + JMP START + +.SBTTL LINE PRINTER SELECTION ROUTINE + +.IFNZ 0 ;TURN OFF TO SAVE SPACE? +$LPT: PMSG + TTILIN + TTIYES + BCS $LPT ;JUNK + BMI 10$ ;NO + MOV #NOLP,ERRVEC ;DO WE HAVE A LINE PRINTER CONTROLLER ? + MOV $LPS,R0 + TST (R0) + TST R0 + BNE 1$ ;LP11 + MOV #LP20A,R0 + TST (R0) + TST R0 + BNE 2$ ;LP20A + MOV #LP20B,R0 + TST (R0) + TST R0 + BNE 2$ ;LP20B + MOV #$TIMOT,ERRVEC + PMSG + JMP $CNTLC +1$: CLR LPTYPE ;LP11 - TYPE = 0 + BR 3$ +2$: MOV R0,LPTYPE ;LP20 - TYPE = CONTROLLER BASE ADDRESS +3$: MOV #$TIMOT,ERRVEC + SETFLG + LPTFLG + TST LPTYPE + BNE 5$ + TST @$LPS ;LP11 - LPT OK ? + BMI 20$ ;NO +4$: JMP $CONSL + +5$: JSR PC,LP20INI ;INITIALIZE LP20 + BCS 20$ ;ERROR + BR 4$ +10$: CLR LPTFLG ;TURN OFF LINE PRINTER + BR 4$ +20$: PMSG + BR $LPT + +NOLP: CLR R0 ;NO LP CONTROLLER BUS TRAP + RTI + +.SBTTL LP20 INITIALIZATION ROUTINE + +LP20INI:MOV LPTYPE,R5 ;SETUP BASE ADDRESS + MOV #LPLINI!LPRERR,(R5) ;CLEAR LP20 + MOV #VFUDAT,R0 ;SETUP VFU BUFFER + MOV R0,LPBSAD(R5) ;SETUP BUFFER ADDRESS + MOV #037756,(R0)+ ;VFU LOAD CODE & ALL CHANS + MOV #77,(R0)+ + MOV #100,R1 ;SET FOR 64 LINES ON PAGE +1$: CLR (R0)+ + DEC R1 + BNE 1$ + MOV #167400,(R0) ;VFU STOP LOAD CODE + MOV #-206,LPBCTR(R5) ;206 BYTE XFER + MOV #LPVLOD!LPPENB!LPGO,(R5) ;VFU LOAD & GO + JSR PC,LP20DN ;WAIT FOR DONE + BCS 3$ ;ERROR + CLR LPCBUF(R5) ;CLEAR LP20 RAM + MOV #LPLINI!LPRERR,(R5) + MOV #-1000,R0 ;LOCATION COUNT + MOVB #LPPENB,(R5) ;PARENB & NOT GO +2$: CLR LPRAMD(R5) ;CLEAR + INC LPCBUF(R5) ;INCREMENT ADDRESS + INC R0 ;COUNT IT + BNE 2$ ;IF NOT DONE, GO BACK + CLC ;COMPLETED, C-BIT CLEAR RETURN + RTS PC + +3$: SEC ;ERROR, C-BIT SET RETURN + RTS PC +.ENDC ;TURN OFF TO SAVE SPACE? + +.SBTTL CONSOLE TELETYPE FUNCTIONS + +$TP: MOV #$TPLIN,R5 ;SET TTY PAGE LENGTH + BR $TPW + +$TW: MOV #$PGWID,R5 ;SET TTY PAGE WIDTH + +$TPW: TTISDL + BCS $PARAM + + TTIDEC ;SPECIFIED IN DECIMAL + BCS $DECN ;WASNT A DECIMAL NUMBER + + MOV R0,(R5) ;SET IT UP + +$TPWF: JMP $CONSL ;RETURN TO CONSOLE FOR NEXT COMMAND + +;TTY FILL CHARACTER PARAMETER + +$TF: TTISDO + + CMP R0,#5 ;CHECK FILL PARAMETER UPPER LIMIT + BGT $FILPL + + MOV R0,$TTYFL ;SET TTY FILL PARAMETER + + BR $TPWF + +;MESSAGES TO OPERATOR + +$DECN: +$FILPL: +$OCTN: +$PARAM: JMP $PARA + +.SBTTL KLINIK FIELD SERVICE REMOTE DIAGNOSTICS ENABLE + +.KLINIK:CMP #"IN,$INBUF+2 + BNE 2$ + CMP #"IK,$INBUF+4 + BNE 2$ + + TST DL11EFLG ;PRESENTLY ENABLED ? + BEQ 1$ ;NO + +KLUNK=. + CLR DL11EFLG ;YES, CLEAR IT + PMSG + JMP $CNTLC + +1$: CLR @$FSTKS ;INITIALIZE + BIS #DLDTR!DLRTS,@$FSTKS ;SET DATA TERMINAL READY + BIT #DLCTS,@$FSTKS ;DO WE HAVE CLEAR TO SEND ? + BEQ FSDISC ;NO + COM DL11EFLG ;ENABLE KLINIK + PMSG + JMP $CNTLC + +2$: JMP $CMDER + +;DL11E DISCONNECT, CLEAR TO SEND NOT SET + +FSDISC: CLR DL11EFLG + PMSG <\DL11E NOT CLR TO SEND, > + BR KLUNK + +.SBTTL DISK STATUS PRINTER + +;DS n TELLS YOU ALL ABOUT RP04 #n. PDP10 MUST BE STOPPED SINCE WE USE ITS RH10 +DSKSTS: DFLEGAL ;10 MUST NOT BE RUNNING + TTCOCT ;DISK NUMBER TO R0 + BIC #-8,R0 ;TRUNCATE TO LOW 3 BITS + MOV R0,R2 ;SAVE DSK # + ASL R2 ;SHIFTED LEFT 2 BITS + ASL R2 + EXAMT ;SAVE LOCATION 20 + .WORD 20,$SAV20 + MOV #TENDAT,R4 ;3-WORD BLOCK TO HOLD PDP10 DATAO/DATAI WORD + MOV #DSKSTB,R3 ;ADDRESS TABLE OF REGISTERS TO DISPLAY +10$: MOVB (R3)+,R0 ;GET CHAR + BEQ 99$ ;NULL MEANS ALL REGS DISPLAYED + PNTCHR + MOVB (R3)+,R0 ;GIVE NAME OF REG + PNTCHR + MOVB (R3)+,R0 + PNTCHR + PSPACE + CLR (R4)+ ;CLEAR 1.1-2.7 OF WORD TO DATAO WITH + MOV R2,(R4) ;DRIVE NUMBER TO 3.1-3.3 + MOVB (R3)+,R0 ;GET REGISTER NUMBER, WHICH GOES TO 4.4-4.9 + CLR R1 ;R1 WILL GET LOW 2 BITS, R0 HIGH 4 + ASR R0 + ROR R1 + ASR R0 + ROR R1 + BIS R1,(R4)+ ;LOW 2 BITS TO 4.4-4.5 + MOV R0,(R4) ;HIGH 4 BITS TO 4.6-4.9 + CMP -(R4),-(R4) ;RESTORE POINTER TO 36-BIT WORD + DPOSVT ;PUT TENDAT INTO 20 + .WORD 20,TENDAT + BCS 69$ + MOV #DTO270,R0 ;EXECUTE DATAO 270,20 + EXCT + BCS 69$ ;LOST, GIVE IT UP + MOV #DTI270,R0 ;EXECUTE DATAI 270,20 + EXCT + BCS 69$ + EXAMT ;GET BACK 20 + .WORD 20,TENDAT ;1.1-2.7 IS THE INTERESTING STUFF + MOV TENDAT,R0 ;PRINT 6 DIGITS + PNTOCT + PCRLF ;WHAT THE HELL, DON'T TRY TO PUT MULTIPLE PER LINE + BR 10$ ;NEXT REGISTER + +69$: PMSG ;HERE IF EXAMINE/DEPOSIT FAILS OR SOMETHING + JMP $CNTLC + +99$: DPOSVT ;RESTORE 20 + .WORD 20,$SAV20 + BCS 69$ + JMP $KONSL ;DONE WITH COMMAND, CONTINUE EXECUTING LINE + +DTI270: IO10 DATAI,270,0,20,0 ;DATAI 270,20 +DTO270: IO10 DATAO,270,0,20,0 ;DATAO 270,20 + +;TABLE OF DISK REGISTER NAMES (3 CHARS) AND REGISTER NUMBERS (1 BYTE) +;TERMINATE WITH NULL CHARACTER +DSKSTB: .ASCII /DCL/ + .BYTE 0 + .ASCII /STS/ + .BYTE 1 + .ASCII /ATN/ + .BYTE 4 + .ASCII /ER1/ + .BYTE 2 + .ASCII /ER2/ + .BYTE 14 + .ASCII /ER3/ + .BYTE 15 + .ASCII /CCY/ + .BYTE 13 + .ASCII /CYL/ + .BYTE 12 + .ASCII /ADR/ + .BYTE 5 + .BYTE 0 + .EVEN diff --git a/src/kldcp/dta11.7 b/src/kldcp/dta11.7 new file mode 100755 index 00000000..54ed9713 --- /dev/null +++ b/src/kldcp/dta11.7 @@ -0,0 +1,1092 @@ +;;;MODIFICATION HISTORY +;;; +;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7) +;;; 15 NOV 75 CONVERTED TO PALX FORMAT +;;; + +.SBTTL PROGRAM FILE LOADER, 4-SEPT-75 + +;LOAD CONTROL FLAG WORD "LDCNTL" +;BIT15=1 IS HELP, PRINT FILE READ +;WORD = 0 .A10, PDP-10 LOAD +; 1 .A11, PDP-11 LOAD +; 2 .RAM, KL10 C-RAM ZERO +; 3 .RAM, KL10 C-RAM LOAD +; 4 .RAM, KL10 D-RAM LOAD +; 5 .BIN, PDP-11 BIN LOAD +;ACT10 .BIN LOADED AS .A11 +; .SAV LOADED AS .A10 + +;PROGRAM DETERMINATION & LOAD CONTROL INITIALIZATION + +DVLOAD: NAMEXT ;SETUP NAME.EXT + +96$: TST R0 ;ANY EXT ? + BNE 4$ ;YES + TSTB JFILEF ;DOING "J" COMMAND ? + BEQ 50$ ;NO + MOV #"CM,R4 ;YES, DEFAULT EXT IS "CMD" + MOV #"D ,R5 + BR 52$ +50$: TSTB IFILEF ;DOING "I" COMMAND ? + BEQ 51$ ;NO + MOV #"CC,R4 ;YES, DEFAULT EXT IS "CCL" + MOV #"L ,R5 + BR 52$ +51$: MOV #"A1,R4 ;IF NO EXT, USE "A10" + MOV #"0 ,R5 +52$: MOV R4,EXTBF + MOV R5,EXTBF+2 + +4$: MOV #LDCNTL,R3 + TST (R3) ;IS THIS "HELP" + BMI 12$ ;BR IF YES + MOV #TEMP+1,R4 + MOV #EXTBF+2,R5 + MOVB (R5),(R4) ;MAKE A WORD OUT OF 2ND & 3RD CHAR + MOVB -(R5),-(R4) + CMPB #'A,-(R5) ;IS FIRST CHAR AN "A" ? + BEQ 6$ ;BR IF YES + CMPB #'B,(R5) ;IS FIRST CHAR A "B" ? + BEQ 14$ ;BR IF YES + CMPB #'S,(R5) ;IS FIRST CHAR AN "S" ? + BEQ 16$ ;BR IF YES + CMPB #'R,(R5) ;IS FIRST CHAR AN "R" ? + BEQ 6$ ;BR IF YES + +5$: TST LDOVRD ;ANY LOAD EXT OVERRIDE ? + BNE 12$ ;YES + BR $$$NAM ;NAME.EXT ERR + +6$: CMP #"10,(R4) + BEQ 7$ ;BR IF ".A10" + CMP #"11,(R4) + BEQ 8$ ;BR IF ".A11" + CMP #"AM,(R4) + BEQ 9$ ;BR IF ".RAM" + BR 5$ ;NONE, REPORT ERROR + +7$: CLR (R3) ;SETUP LOAD CONTROL + BR 12$ +8$: MOV #1,(R3) + CLR EMTLDD ;INIT SAVED MAGIC LOC TO EMPTY + BR 12$ +9$: MOV #2,(R3) +12$: TST LDOVRD ;ANY LOAD EXT OVERRIDE ? + BEQ 20$ ;NO + MOV LDOVRD,R0 ;SET LOAD CONTROL ACCORDINGLY + DEC R0 + MOV R0,(R3) +20$: TST (R3) ;TEST LDCNTL + BLE 21$ ;JUMP IF PDP10, HELP, I, OR J. + JSR PC,ITSOFF ;IF LOADING 11 OR RAM, FLUSH IOELEV +21$: JMP DEVFIL ;GO GET FILE & LOAD + +14$: CMP #"IN,(R4) ;IS EXTENSION ".BIN" ? + BNE 5$ ;BR IF NO + MOV #5,(R3) ;YES, SET LOAD CONTROL + BR 12$ + +16$: CMP #"AV,(R4) ;IS EXTENSION ".SAV" ? + BEQ 7$ ;YES, ACT10 TREATS AS ".A10" + BR 5$ + +;PROCESS FILENAME.EXT FROM INPUT BUFFER + +$NAMEXT:MOV #NAMBF,R0 ;CLEAR NAME LOOKUP BUFFER + MOV #20040,R1 ;TO SPACES + MOV #5,R2 +70$: MOV R1,(R0)+ ;UP TO 9 CHARS + DEC R2 + BGT 70$ + + MOV #NAMBF,R2 ;LOOKUP NAME + MOV #7,R1 ;MAXIMUM OF 6 CHARS IN NAME + TTISDL + BCS 99$ ;LETTER, ALREADY IN R0 +1$: TTICHR ;GET CHAR FROM TTY BUFFER + BCS 5$ +99$: CMPB #'.,R0 + BEQ 2$ ;BR IF PERIOD, NAME.EXT SEPARATOR + CMPB #33,R0 + BEQ 97$ ;ALTMODE, SELF START + CMPB #15,R0 + BEQ 96$ ;CR, NO EXTENSION + CMPB #SPACE,R0 ;IF SPACE, NO EXT + BEQ 96$ + DEC R1 + BEQ 5$ ;BR IF MORE THAN 6 CHARS + MOVB R0,(R2)+ ;STORE CHAR + BR 1$ + +2$: MOV #EXTBF,R2 ;GET EXTENSION + MOV #4,R1 +3$: TTICHR + BCS 5$ + CMPB #33,R0 + BEQ 13$ ;BR IF ALTMODE + CMPB #15,R0 + BEQ 98$ ;BR IF CR + CMPB #SPACE,R0 ;BR IF SPACE + BEQ 98$ + DEC R1 + BEQ 5$ ;BR IF MORE THAN 3 CHARS + MOVB R0,(R2)+ ;STORE CHAR + BR 3$ + +97$: COM SRTFLG ;SET SELF START FLAG + BR 96$ + +13$: COM SRTFLG + +98$: CMP #4,R1 + BNE 10$ +96$: CLR R0 +10$: EXIT + +$$$NAM=. +5$: $PMSG ;NAME.EXT ERR + $$NAM + JMP $CNTLC + +$$NAM: .ASCIZ /NAME.EXT ERR/ +.EVEN + +;DECTAPE/RP04/FLOPPY LOADER START + +DTRPLD: MOV #-1,DEVLC + CMP #5,LDCNTL ;PDP-11 .BIN FILE LOAD ? + BNE LLD1 + JMP LDBIN + +LLD1: DVDATA ;LOAD FIRST BUFFER + BCC LLD2 + JMP DVEOF ;EOF + +LLD2: TST DEVTYP + BPL 1$ + JMP ACTLD2 ;ACT10 PROCESS + +1$: MOV #$INBUF,R5 ;SET UP START OF CHAR BUFFER + MOV R5,$INPTC + +LLD3: MOV DVCNT,R4 ;SETUP DEVICE BYTE COUNTER + MOV DVADR,R3 ;SETUP DEVICE DATA BLOCK ADDRESS + +LLD4: TST R4 ;ANY DATA REMAINING ? + BGT 2$ ;YES + + DVDATA ;NO, READ NEXT DEVICE BLOCK + BCC LLD3 + JMP DVEOF ;END OF FILE ? + +2$: MOVB (R3)+,R0 ;GET FRAME, ONE 7 BIT CHAR + DEC R4 ;COUNT IT + BIC #177600,R0 + TST R0 ;IS FRAME A NULL ? + BEQ LLD4 ;BR IF YES, DON'T STORE + MOVB R0,(R5)+ ;STORE IN BUFFER + CMP R5,#$INBUF+140. + BLE 1$ ;BR IF BUFFER DIDN'T OVERFLOW + JMP $LINERR ;REPORT BUFFER OVERFLOW +1$: CMP #12,R0 ;IS CHAR A LINE FEED ? + BEQ LLDONE ;BR IF LINE DONE + BR LLD4 ;LOOP TILL LF FOUND + +LDERR: JMP ACTLDF ;LOAD ERROR + +LLDONE: MOV R4,DVCNT ;RESAVE POINTERS + MOV R3,DVADR + CLRB (R5) ;STORE A NULL TO END STRING + MOV R5,$INPTR + INC DEVLC ;COUNT LINE + MOV DEVLC,SWR ;DISPLAY (ON AN 11/40? I DOUBT IT - DAM) + TST LDCNTL ;IS HELP FLAG SET ? + BPL LDPROC ;BR IF NO + JMP DAHLP ;DTA/ACT HELP + +LDPROC: CLR LDOCTF ;CLEAR OCTAL LOAD FLAG + CLR LDZBLK + MOV LDCNTL,R1 ;GET LOAD CONTROL + MOV $INPTC,R5 ;SETUP INPUT POINTER + MOVB (R5)+,R0 ;GET FIRST CHAR FROM FILE + CMPB #';,R0 ;IS FIRST CHAR A SEMICOLON ? + BEQ LDPRO1 ;YES, PROCESS COMMENT LINE + CMPB LDLTR(R1),R0 ;DOES 1ST CHAR MATCH LOAD TYPE ? + BEQ LDPRO3 ;YES + TST LDCNTL ;IS THIS .A10 FILE ? + BNE LDPRO2 ;NO, ERROR + CMPB #'Z,R0 ;YES, IS FIRST CHAR A "Z" ? + BNE LDPRO2 ;NO, ERROR + COM LDZBLK ;YES, SET CORE ZERO FLAG + BR LDPRO3 + +LDPRO1: TST DEVLC ;COMMENT, IS THIS FIRST LINE ? + BNE LLD2 ;NO + PUSH PCMDNF ;SAVE PGM CMD NO PRINT FLAG + SWITCH + BIT R0,#CHAIN ;IS CHAIN SWITCH SET ? + BEQ 1$ ;NO + MOV #-1,PCMDNF ;YES, PREVENT FILE ID PRINTOUT + +1$: MOVB (R5)+,R1 ;PUT FILE ID LINE IN OUTPUT BUFFER + BEQ 2$ ;NULL, DONE + PLDBUF + BR 1$ +2$: POP PCMDNF ;RESTORE FLAG + PNTRST ;RESET OUTPUT POINTERS ANYWAY + BR LLD2 + +LDPRO2: JMP ACTLDC ;LOAD TYPE ERROR + +LDPRO3: MOVB (R5)+,R0 ;GET 2ND CHAR + CMPB #'O,R0 ;IS IT AN O ? + BEQ LDOCT ;YES, OCTAL DATA FORMAT LOAD + CMPB #40,R0 ;IS IT A SPACE ? + BNE LDPRO2 ;BR IF NO + +LDCLR: MOV #LDCNT,R1 ;SETUP CONVERTED STORAGE ADDRESS +LDCNV: CLR R2 ;CLEAR WORD FORMER +1$: MOVB (R5)+,R0 ;GET CHAR + CMP #15,R0 ;IS IT A CR ? + BEQ 1$ ;YES, IGNORE + CMP #12,R0 ;IS IT A LF ? + BEQ LDEOL ;YES, END OF LINE + CMP #54,R0 ;IS IT A COMMA ? + BEQ 2$ ;YES, GO STORE WORD + TST LDOCTF ;LOADING OCTAL ? + BNE 3$ ;YES + SL R2,6 ;SHIFT WORD FORMER LEFT 6 + BIC #100,R0 ;CLEAR ASCIIZED BIT +4$: BIS R0,R2 ;INSERT NEW BIT + BR 1$ ;LOOP TILL WORD FORMED + +2$: MOV R2,(R1)+ ;STORE 16 BIT WORD + BR LDCNV ;GO DO NEXT + +3$: SL R2,3 ;OCTAL LOAD + BIC #177770,R0 ;CLEAR ALL BUT NUMBER PART + BR 4$ + +LDOCT: COM LDOCTF ;OCTAL LOAD, SET FLAG + BR LDCLR + +LDEOL: MOV R2,(R1) ;STORE CHECKSUM + +LDCKSM: TST LDOCTF ;LOADING OCTAL ? + BNE 2$ ;YES, NO CHECKSUM + MOV #LDCNT,R2 ;CHECKSUM LOAD STORAGE + CLR R0 +1$: ADD (R2)+,R0 + CMP R2,R1 + BLE 1$ + TST R0 ;IS CHECKSUM = 0 ? + BEQ 2$ ;BR IF 0 + JMP ACTBCK ;BAD CHECKSUM + +2$: MOV LDCNTL,R0 ;DISPATCH TO PROPER LOAD ROUTINE + SL R0,1 ;DETERMINED FROM LDCNTL WORD + JMP @LDTYPE(R0) + +LDTYPE: LDTEN ;.A10, LOAD TEN + LDELVN ;.A11, LOAD ELEVEN + LDCZRO ;.RAM, ZERO C-RAM + LDCRAM ;.RAM, LOAD C-RAM + LDDRAM ;.RAM, LOAD D-RAM + +LDLTR: .ASCII /TEZCD/ + +$$LD11: .ASCIZ /11 ERR,ADR=/ +$$COR: .ASCIZ /COR=/ +$$ACT: .ASCIZ /ACT=/ +$$RAM: .ASCIZ /\RAM ERR,COR=/ +$$TEN: .ASCIZ /\10 ERR,ADR=/ + .EVEN + +$LINERR:PMSG + JMP $CNTLC + +;LOAD DONE ROUTINE + +LDDONE: TST DEVTYP ;LOAD DONE + BMI 1$ ;BR IF ACT10 MODE + JMP DADONE + +1$: JMP ACTDON ;ACT10 PROCESS + +;PDP-11 CORE LOAD ROUTINE + +LDELVN: MOV LDCNT,R0 ;GET LOAD WORD COUNT + BEQ 2$ ;IF 0, THIS IS TRANSFER BLOCK + MOV #LDATA,R2 ;SETUP DATA PICKUP POINTER + MOV LDADR,R1 ;GET LOAD MEMORY ADDRESS + BIT #1,R1 ;LOAD WORD OR BYTE ? + BNE 3$ ;BYTE LOAD + +1$: TST VERIFY + BNE 11$ +19$: CMP R1,#EMTVEC ;DON'T CLOBBER LOSING EMT VECTOR + BLO 69$ ;SINCE THAT MAKES LOADER BOMB + CMP R1,#EMTVEC+4 + BHIS 69$ + MOV (R2)+,EMTLDD-EMTVEC(R1) ;SAVE FOR SE CMD + TST (R1)+ + BR 13$ + +69$: MOV (R2)+,(R1)+ ;MOVE WORD FROM STOR TO MEMORY +13$: DEC R0 ;DECREMENT WORD COUNT + BGT 1$ ;LOOP TILL ALL WORDS MOVED +18$: JMP LLD2 ;GO DO NEXT LOAD LINE + +11$: CMP (R2),(R1) ;COMPARE CURRENT AGAINST FILE + BEQ 12$ + PUSH R0 + $PMSG + $$LD11 ;"11 ERR,ADR=" + MOV R1,R0 + PNTOCT + + $PMSG + $$COR ;"COR=" + MOV (R2),R0 + PNTOCT + + $PMSG + $$ACT ;"ACT=" + MOV (R1),R0 + PNTOCT + PCRLF + POP R0 + +12$: TST (R2)+ + TST (R1)+ + BR 13$ + +3$: TST VERIFY + BNE 31$ + +39$: MOVB (R2)+,(R1)+ ;ODD ADDRESS, BYTE LOAD + MOVB (R2)+,(R1)+ ;2 BYTES PER WORD +38$: DEC R0 ;DECREMENT WORD COUNT + BGT 3$ ;LOOP TILL ALL BYTES MOVED + BR 18$ ;GO ON TO NEXT + +31$: CLR R5 +32$: PUSH R0 + CMPB (R2),(R1) + BEQ 33$ + + $PMSG + $$LD11 ;"11 ERR,ADR=" + MOV R1,R0 + PNTOCT + + $PMSG + $$COR ;"COR=" + MOVB (R2),R0 + BIC #177400,R0 + PNTOCS + + PSPACE + $PMSG + $$ACT ;"ACT=" + MOVB (R1),R0 + BIC #177400,R0 + PNTOCS + PCRLF +33$: POP R0 + INC R2 + INC R1 + TST R5 + BNE 38$ + INC R5 + BR 32$ + +2$: MOV LDADR,R0 +LD11DN: MOV R0,PGOADR + CLR PGOCTL + BR LDDONE + +;PDP-11 BINARY LOAD ROUTINE + +LDBIN: DVDATA ;LOAD DEVICE BUFFER +LDBIN1: CLR $CKS11 ;INIT CHECKSUM + DVFRAM ;READ FRAME + DECB R0 ;CHECK FOR BLOCK START + BNE LDBIN1 ;NOT YET + DVFRAM ;READ ANOTHER FRAME + + DVWRD ;GET FULL BYTE COUNT + MOV R0,LBC + SUB #6,LBC + BEQ LJMP ;BYTE COUNT OF 6 IS XFER BLOCK + DVWRD ;GET LOAD ADDRESS + MOV R0,R5 ;STORE LOAD ADDRESS + +LDBIN2: DVFRAM ;READ DATA FRAME + DEC LBC + BGE LDBIN3 ;BR IF MORE DATA REMAINS + TSTB $CKS11 ;CORRECT CHECKSUM ? + BEQ LDBIN1 ;BR IF GOOD CHECKSUM +LDBINE: PMSG <\CKSUM ERR> +$LDBNE: JMP $CNTLC + +LDBIN3: TST VERIFY + BNE 1$ + CMP R5,#PRGSRT ;TRYING TO LOAD INTO KLDCP ? + BLO 10$ ;NO + PMSG <\ADR ERR> + BR $LDBNE ;YES, BAD !! +10$: MOVB R0,(R5)+ ;STORE DATA 1 BYTE AT A TIME + BR LDBIN2 ;LOOP + +1$: CMPB R0,(R5) + BNE 3$ +2$: INC R5 + BR LDBIN2 + +3$: PUSH R0 + $PMSG + $$LD11 ;"11 ERR,ADR=" + + MOV R5,R0 + PNTOCT + + $PMSG + $$COR ;"COR=" + POP R0 + PNTOCS + + PSPACE + $PMSG + $$ACT ;"ACT=" + MOVB (R5),R0 + BIC #177400,R0 + PNTOCS + PCRLF + BR 2$ + +LJMP: DVWRD ;GET POSSIBLE XFER ADDRESS + PUSH R0 + DVFRAM + TSTB $CKS11 ;CORRECT CHECKSUM ? + BNE LDBINE ;BR IF BAD + POP R0 ;SETUP START ADDRESS + BR LD11DN + +;KL10 LOAD D-RAM ROUTINE + +;CALLS "WDRAM" WITH R0 = D-RAM ADDRESS +; R1 = LOAD DATA ADDRESS + +LDDRAM: MOV LDCNT,R2 ;GET LOAD WORD COUNT + BEQ 2$ ;WC = 0, TRANSFER BLOCK + MOV LDADR,R3 ;SETUP D-RAM ADDRESS + MOV #LDATA,R4 ;DATA PICKUP ADDRESS + +1$: MOV R3,R0 ;D-RAM ADDRESS TO R0 + MOV R4,R1 ;DATA ADDRESS TO R1 + + TST VERIFY + BNE 11$ ;VERIFY D-RAM + WDRAM ;WRITE D-RAM + +11$: MOV R3,R0 + RDRAM ;READ D-RAM + MOV R0,R5 + BIC #20,(R0) ;CLEAR COMPUTED PARITY + CMP (R0)+,(R1)+ ;COMPARE EVEN WORD + BNE 20$ + BIC #20,(R0) ;CLEAR COMPUTED PARITY + CMP (R0)+,(R1)+ ;COMPARE ODD WORD + BNE 20$ + CMP (R0),(R1) ;COMPARE COMMON WORD + BNE 20$ +21$: ADD #2,R3 ;TO NEXT EVEN D-RAM ADDRESS + ADD #6,R4 ;SETUP NEXT DATA PICKUP ADR + SUB #3,R2 ;DECREMENT WORD COUNT + BGT 1$ ;BR IF NOT DONE YET + BR $LLD2 ;BACK FOR NEXT LOAD FILE LINE + +2$: JMP LDDONE ;LOAD FINISHED + +20$: $PMSG + $$RAM ;"RAM ERR,COR=" + MOV R3,R0 + MOV R4,R1 + PNTDRM ;PRINT CORRECT D-RAM + + $PMSG + $$ACT ;"ACT=" + MOV R3,R0 + MOV R5,R1 + PNTDRM ;PRINT ACTUAL D-RAM + BR 21$ ;CONTINUE + +;KL10 C-RAM ZERO + +LDCZRO: MRESET ;MASTER RESET + TST VERIFY + BNE 2$ ;NO ZEROING IF VERIFY + MOV LDATA,R1 ;GET C-RAM ZERO COUNT + BEQ 2$ ;0 ZERO COUNT, BYPASS ZEROING C-RAM + MOV LDADR,R0 ;SETUP STARTING ADDRESS + + MICNUL ;ZERO C-RAM +2$: INC LDCNTL ;ADVANCE LOAD CONTROL TO C-RAM LOAD + BR $LLD2 + +;KL10 LOAD C-RAM ROUTINE + +;CALLS "WCRAM" WITH R0 = C-RAM ADDRESS +; R1 = DATA PICKUP ADDRESS + +LDCRAM: MOV LDCNT,R2 ;GET LOAD WORD COUNT + BEQ 2$ ;WC = 0, TRANSFER BLOCK + MOV LDADR,R3 ;SETUP C-RAM ADDRESS + BIS #BIT14,R3 ;SET SPECIAL RESET BIT + MOV #LDATA,R4 ;DATA PICKUP ADDRESS + +1$: TST LDOCTF ;LOADING OCTAL ? + BNE 3$ ;YES +4$: MOV R3,R0 ;C-RAM ADDRESS TO R0 + MOV R4,R1 ;DATA PICKUP ADDRESS TO R1 + + TST VERIFY + BNE 41$ + WCRAM ;WRITE C-RAM +41$: MOV R3,R0 + RCRAM ;READ C-RAM BACK + + MOV #6,R5 + MOV R4,R1 +11$: CMP (R0)+,(R1)+ ;RAM LOADED PROPERLY ? + BNE 12$ ;NO + DEC R5 + BNE 11$ +42$: INC R3 ;TO NEXT C-RAM ADDRESS + ADD #12.,R4 ;TO NEXT PICKUP ADDRESS + SUB #6,R2 ;DECREMENT WORD COUNT, 6 11 WDS PER + BGT 1$ ;BR IF NOT DONE YET +$LLD2=. + JMP LLD2 ;GET NEXT LOAD FILE LINE + +2$: MOV LDADR,R0 ;SELECT C-RAM STARTING ADDRESS + WWADR ;WRITE ADDRESS TO C-RAM + INC LDCNTL ;ADVANCE LOAD CONTROL TO D-RAM LOAD + BR $LLD2 + +;OCTAL C-RAM LOAD, DATA IS BACKWARDS FROM UPSIDE DOWN NORMAL + +3$: MOV (R4),R0 ;GET WORD 0 + MOV 10(R4),(R4) ;PUT WORD 5 IN 0'S PLACE + MOV R0,10(R4) ;PUT WORD 0 IN 5'S PLACE + MOV 2(R4),R0 ;GET WORD 1 + MOV 6(R4),2(R4) ;PUT WORD 4 IN 1'S PLACE + MOV R0,6(R4) ;PUT WORD 1 IN 4'S PLACE + BR 4$ ;NOW GO LOAD IN C-RAM + +12$: $PMSG ;"RAM ERR,COR=" + $$RAM + MOV R3,R0 + MOV R4,R1 + PNTCRM + PCRLF + $PMSG + $$ACT ;"ACT=" + MOV R3,R0 + MOV #$BUFRC,R1 + PNTCRM + PCRLF + BR 42$ + +;LOAD TEN CORE ZERO + +; START ADDRESS, LOW 16 BITS IN LDADR +; , BITS 18 & 19 IN HI-BYTE OF LDCNT +; ZERO COUNT IN LDATA +; WORD COUNT SIGNIFIES NUMBER OF LDATA WORDS USED FOR ZEROING +; "D10ZRO" - INCREMENTS PDP-10 ADDRESS WHILE ZEROING + +LDTEN: MOV #L10ADR+2,R3 ;SETUP BLOCK START ADDRESS POINTER + CLR (R3) + MOVB LDCNT+1,(R3) ;HI-BYTE OF LDCNT IS ADR BITS 18 & 19 + MOV LDADR,-(R3) ;SETUP ADR BITS 20-35 + + TST LDZBLK ;TEN CORE ZERO BLOCK ? + BEQ LDRDIN ;NO, LOAD DATA + +LDTENZ: SM ;START MACHINE + BCC 3$ + JMP .XCTER ;FAILED +3$: TST VERIFY + BNE 2$ ;DON'T ZERO IF VERIFY + MOV #LDATA,R4 + MOVB LDCNT,R2 ;IS WC = 0 ? + BEQ 2$ ;YES, NO ZEROING + MOV R3,R1 ;SETUP ADDRESS +1$: MOV (R4)+,R0 ;SETUP ZERO COUNT + D10ZRO ;DEPOSIT ZEROS, CLEARING CORE + BCS LD10ER + MOV #.DPXAD,R1 + DEC R2 ;COMPLETED ALL ZEROS ? + BNE 1$ ;NOT YET + +2$: BR $LLD2 ;ALL REQUESTED CORE ZEROED. + +;LOAD TEN DATA + +;CALLS "DPOSVR" WITH R0 = LOAD DATA ADDRESS +; R1 = PDP-10 ADDRESS + +LDRDIN: MOVB LDCNT,R2 ;GET LOAD WORD COUNT + BEQ 2$ ;WC = 0, TRANSFER BLOCK + MOV #LDATA,R4 ;DATA PICKUP ADDRESS + +1$: MOV R3,R1 + MOV R4,R0 ;SETUP DATA PICKUP ADDRESS + + TST VERIFY + BNE LD10V + DPOSVR ;DEPOSIT & VERIFY + BCS LD10VR ;FAILED +$LRDIN=. + ADD #1,(R3)+ ;INCREMENT 10 ADDRESS + ADC (R3) + TST -(R3) + ADD #6,R4 ;SETUP NEXT DATA PICKUP ADDRESS + SUB #3,R2 ;DECREMENT WORD COUNT + BGT 1$ ;BR IF NOT DONE YET + BR $LLD2 ;BACK FOR NEXT LOAD FILE LINE + +2$: MOV #PGOADR,R4 + MOV (R3)+,(R4)+ ;TRANSFER START ADDRESS + MOV (R3),(R4) ;TO GO ADDRESS + MOV #2,PGOCTL + JMP LDDONE + +LD10VR: BMI LD10ER ;N-BIT SET DEPOSIT FAILED + BEQ LD10ER ;Z-BIT SET, EXAMINE FAILED +LD10VE=. + PUSH R0 + $PMSG ;"10 ERR,ADR=" + $$TEN + MOV #L10ADR,R0 + PNTADR + + $PMSG + $$COR ;"COR=" + MOV R4,R0 + PNT36 + + $PMSG + $$ACT ;"ACT=" + POP R0 + PNT36 + PCRLF + BR $LRDIN + +LD10V: MOV R1,R0 + EXAM ;EXAMINE PRESENT CONTENTS + BCS LD10ER ;CAN'T EXAMINE + MOV R0,R1 + MOV R4,R0 + CMPR36 ;COMPARE WITH LOAD FILE + BCC $LRDIN ;OK + BR LD10VE ;BAD + +LD10ER: $PMSG ;"10 ERR,ADR=" + $$TEN + MOV #L10ADR,R0 + PNTADR + JMP $CNTLC + +;DEVICE FILE DIRECTORY LOOKUP + +DEVFIL: SETFLG ;INIT DEVICE LINE COUNT + DEVLC + TTPINI ;INIT TTY POINTERS + CLR $OUTBF + TST DEVTYP ;LOAD FROM WHAT DEVICE ? + BEQ DTFIL ; 0 = DECTAPE + BMI 1$ ; -1 = ACT10 + JMP RPFIL ; 1 = RP04 +1$: JMP ACTFIL + +DTFIL: TST FLOPPY + BEQ 10$ + RXFILE ;FLOPPY + BR 11$ +10$: DTAFILE +11$: BCS 1$ + JMP DTRPLD +1$: JMP $NONXF ;NON-EX FILE + +;DECTAPE FORMAT +;FIRST DIRECTORY BLOCK = 102 (8) + +;FILE DIRECTORY BLOCK +; LINK TO NEXT BLOCK +; 1 - FILE NAME 1 +; 2 - FILE NAME 2 +; 3 - FILE EXTENSION +; 4 - DATE +; 5 - SPARE +; 6 - START BLOCK # +; 7 - LENGTH +; 8 - END BLOCK # +; 9 - SPARE +;FILE DATA BLOCK +; LINK TO NEXT BLOCK +; 255 DATA WORDS + +;DECTAPE PROGRAM FILE SEARCH + +$DTAFILE:DTINIT ;DECTAPE INITIALIZATION +DTAFL1: TST FLOPPY + BEQ 20$ + RXRDFL ;FLOPPY READ FILE + BR 21$ +20$: DTRDFL ;READ UFD DIRECTORY BLOCK +21$: BCS 11$ ;EOF, CAN'T FIND FILE + MOV (R0),R0 ;PUT FIRST BUFFER ADR IN R0 + MOV #28.,R1 ;28 ENTRIES IN DIRECTORY + +1$: MOV (R0)+,DIRST0 ;STORE RAD50 NAME + MOV (R0)+,DIRST1 + MOV (R0)+,DTEXT ;STORE RAD50 EXT + CMP (R0)+,(R0)+ ;SKIP 2 WORDS + MOV (R0)+,DTSTRT ;SAVE STARTING BLOCK # + MOV (R0)+,DTLNGTH ;SAVE LENGTH + CMP (R0)+,(R0)+ ;MOVE TO NEXT ENTRY + PUSH + R50UPK ;UNPACK NAME + DIRST0,DIRST2 + BCS 10$ + R50UPK + DIRST1,DIRST3+1 + BCS 10$ + R50UPK ;UNPACK EXTENSION + DTEXT,DTEXTS + BCS 10$ ;ERROR RETURN + + TST DVDIRF ;DOING "DIR" ? + BNE $DTDI1 ;YES + + MOV #NAMBF,R3 ;LOAD ADDRESS OF INPUT DATA + MOV #DIRST2,R4 ;LOAD ADDRESS OF TABLE + MOV #6,R0 ;SET COUNT +3$: CMPB (R3)+,(R4)+ ;CHECK NAME DATA + BNE 10$ ;BR IF NOT SAME + DEC R0 ;DONE 6 TIMES ? + BNE 3$ ;BR IF NOT + MOV #EXTBF,R3 ;LOAD ADDRESS OF EXT INPUT + MOV #DTEXTS,R4 ;LOAD ADDRESS OF EXT STOR + MOV #3,R0 ;SET COUNT 3 CHARS +6$: CMPB (R3)+,(R4)+ ;CHECK EXT DATA + BNE 10$ ;BR IF NOT SAME + DEC R0 ;DONE 3 TIMES ? + BNE 6$ ;BR IF NOT + POP + MOV DTSTRT,DVBUF ;LOAD STARTING BLOCK + EXIT ;NOW GO LOAD FILE +$DTDI2=. +10$: POP + DEC R1 ;BEEN THROUGH 28 ENTRIES ? + BNE 1$ ;NOT YET + BR DTAFL1 ;TRY NEXT UFD BLOCK + +11$: EXITERR + +;DECTAPE/FLOPPY DIRECTORY ROUTINE + +$DTDI1: CLR NAMBF + CLR DTEXT + CMP #020040,DIRST2 ;DON'T PRINT SPACES + BEQ 1$ + + $PMSG ;PRINT "FILE" + DIRST2 + + PSPACE + + $PMSG ;PRINT "EXT" + DTEXTS + + MOV #TAB,R0 + PNTCHR + MOV DTLNGTH,R0 + PNTDEC ;PRINT NUMBER OF BLOCKS + + PCRLF +1$: BR $DTDI2 ;GO DO NEXT + +$DI: TTITRM + PNORML + TST DEVTYP + BEQ $DTDIR ;DECTAPE + BMI 1$ ;ILLEGAL ON ACT10 + JMP $RPDIR ;RP04 + +1$: JMP $CMDE + +$DTDIR: SETFLG + DVDIRF ;SET DIRECTORY FLAG + TST FLOPPY + BEQ 1$ + RXFILE ;FLOPPY + BR 2$ +1$: DTAFILE +2$: JMP $CONSL + +;READ DEVICE FRAME SUBROUTINE + +$DVFRAM:TST DVCNT ;USED ALL DATA ? + BGT 1$ ;NO + + DVDATA ;YES, READ NEXT BLOCK + BCS DVEOF ;EOF + +1$: MOVB @DVADR,R0 ;GET ONE BYTE + INC DVADR ;INCREMENT PICKUP ADDRESS + DEC DVCNT ;COUNT IT + BIC #177400,R0 ;CLEAR JUNK, CHAR IS 8 BITS + ADD R0,$CKS11 + BR $$DVX + +;READ DEVICE BUFFER SUBROUTINE + +$DVDATA:TST DEVTYP + BNE 4$ + + TST FLOPPY + BEQ 1$ + RXRDFL ;FLOPPY + BR 11$ +1$: DTRDFL ;DECTAPE READ +11$: BCS 3$ ;EOF +2$: MOV (R0)+,DVADR ;SAVE BUFFER ADDRESS + MOV (R0),DVCNT ;SAVE BUFFER BYTE COUNT + BR $$DVX + +3$: EXITERR ;EOF + +4$: MOV #FILDSB,R0 + RPRDFL ;RP04 FILE DATA BLOCK READ + BCC 2$ + + CMP #1,R0 ;ERROR, EOF ? + BEQ DVEOF ;YES + RPERROR ;NO, JUST ERROR + +DVEOF: TST LDCNTL ;EOF, PRINTING A HELP FILE ? + BMI 1$ ;YES + PMSG <\EOF ?> + JMP $CNTLC +1$: JMP DAHLPD + +;ASSEMBLE ONE 16 BIT DATA WORD + +$DVWRD: DVFRAM ;READ FRAME + MOV R0,LTMP + DVFRAM ;GET ANOTHER FRAME + SWAB R0 ;PLACE IN HIGH ORDER BYTE + BIS R0,LTMP ;PUT 2 BYTES TOGETHER + MOV LTMP,R0 ;PUT BACK IN R0 + BR $$DVX + +;DECTAPE INITIALIZATION + +$DTINIT:MOV #102,DVBUF ;SET STARTING BLOCK NUMBER +$$DVX: EXIT + +;FILE NOT FOUND + +$NONXF: TST DIAFLG ;DOING "DIAMON" FILE SELECTION ? + BEQ 1$ ;NO + JMP DIANF ;YES, "DIAMON" FILE NOT FOUND + +1$: PMSG + JMP $CNTLC + +;RAD50 UNPACK SUBROUTINE + +$R50UPK:ADD #4,12(SP) ;RETURN OVER TRAILING PARAMETERS + PUSH R0 + MOV $EMADR,R5 + MOV (R5)+,R4 ;RAD50 ADDRESS TO R4 + MOV (R4),R4 ;RAD50 VALUE TO R4 + MOV (R5),R3 ;STORE ADDRESS TO R3 + MOV #2,R1 + MOV #-1,-(6) ;SET STACK STOP +1$: MOV R4,-(6) ;SAVE PREVIOUS VALUE + CLR R4 ;CLEAR R4 FOR NEXT REMAINDER +2$: MOV (6),R0 ;TAKE 3/4 OF VALUE + BISB @PC,R0 ;??????? + MOV R0,R2 + ROR R2 + ASR R2 + SUB R2,R0 + BIC #37,R0 ;PREPARE TO TAKE 1/4 OF RESULT + SUB R0,(6) ;BUT REDUCE ORIGINAL BY 3/4 + ROR R0 ;GET 3/16 OF ORIGINAL + ASR R0 + SUB R0,(6) + ADD R0,R4 ;THIS GIVES 1ST APPROXIMATION + CMP (6),#47 ;LOW AS POSSIBLE ? + BHI 2$ ;IF SO THIS IS BYTE REQUIRED + ASR R4 + ASR R4 + ASR R4 + DEC R1 ;DONE 2 BYTES ? + BNE 1$ ;BR IF NOT + CMPB R4,#47 ;LAST BYTE TOO BIG ? + BHI 4$ ;IF YES, ERROR +3$: TSTB R4 ;SPACE ? + BEQ 6$ ;IF YES, ADD 40 + CMPB R4,#35 ;IF UNUSED CODE .... + BNE 5$ +4$: MOV #'X,R4 ;ASCII X TO R4 + BR 9$ ;GO TO ERROR EXIT +5$: CMPB R4,#33 ;$ ? + BEQ 8$ ;IF YES, GO ADD 11 + BHI 7$ ;FOR DIGIT OR DOT ADD 22 + ADD #40,R4 ;FOR LETTER ADD 100 +6$: ADD #16,R4 +7$: ADD #11,R4 +8$: ADD #11,R4 +9$: MOVB R4,(3)+ ;STORE RESULT + MOV (6)+,R4 ;GET NEXT BYTE + BPL 3$ ;BR IF NOT STACK STOP + POP R0 +$$$DVX: BR $$DVX + +;DECTAPE READ/WRITE FILE ROUTINES + +$DTRDFL:TST DVBUF ;ANY DATA BLOCKS REMAINING ? + BNE $DTRFL ;YES +$$DTXE: EXITERR ;NO + +$DTRFL: MOV DVBUF,DTBLK ;SET REQUESTED BLOCK + MOV #DVBUF,CASAV ;SET BUFFER ADDRESS + MOV #-256.,WCSAV ;SET WORD COUNT + + DTREAD ;DECTAPE READ + BCS $$DTXC ;FAILED + + MOV #$DTINFO,R0 +$$DTX: EXIT + +$$DTXC: JMP $CNTLC ;FAILED + +$DTWTFL:MOV #DVBUF,CASAV + MOV #-256.,WCSAV + + DTWRT ;WRITE DECTAPE + BCC $$DTX ;OK + BR $$DTXC ;FAILED + +$DTINFO:DVBUF+2 ;FIRST USABLE DATA WORD + 510. ;BYTE COUNT + +$DTBASE:MOV #DTBLK,R0 ;RETURN PARAMETER BASE ADDRESS + BR $$DTX + +;DECTAPE DEVICE READ/WRITE ROUTINE + +$DTREAD:MOV #TCRDATA+TCDO,R0 + BR $DTXFR + +$DTWRT: MOV #TCWDATA+TCDO,R0 + +$DTXFR: MOV R0,DTXCMD ;SAVE COMMAND + MOV #3,TRYCTR ;SET MAXIMUM TRY COUNT, 3. + +$DTXF1: MOVB DTUNIT+1,R4 ;SETUP UNIT + MOV WCSAV,@#TCWC ;SETUP WORD COUNT + MOV CASAV,@#TCBA ;SETUP READ ADDRESS + MOV #TCRNUM+TCDO,R0 + MOV #TCCM,R1 + MOV #TCREV,R3 + MOV DTBLK,R2 ;SETUP BLOCK # AND DIRECTION + BPL $DTXF2 + NEG R2 + ADD #10,R4 ;REVERSE, SET REV INDICATOR + BIS R3,R0 ;START UP IN REVERSE + +$DTXF2: MOV #6,REVCNT ;SET MAXIMUM REVERSAL COUNT, 6. + CLR INTSW ;SET INTSW FOR SEARCH + +$DTXF3: PUSH R3 + JSR PC,$TIRDY ;ANY OPERATOR INTERRUPTS ? + BCS 2$ ;NO + MOVB $TICHR,R3 ;GET CHAR + BICB #200,R3 + CMPB #CNTRLC,R3 ;IS IT CONTROL C ? + BNE 2$ ;NO + BIC #116,(R1) ;YES, STOP DECTAPE + JMP $TICC ;AND ABORT +2$: POP R3 + BIS DTUNIT,R0 ;SELECT UNIT + MOV R0,(R1) ;SET TCCM +1$: BIT #TCERR+TCRDY,(R1) ;WAIT FOR DONE OR ERROR + BEQ 1$ + BMI DTER ;BR IF ERROR + TSTB INTSW ;SEARCH OR TRANSFER ? + BNE DATINT ;BR IF TRANSFER + CMP @#TCDT,R2 ;BLOCK MATCH ? + BEQ DTSRF ;BR IF YES + BGT DTSRE ;BR IF LARGER + BIT R3,(R1) ;SMALLER, REVERSE ? + BEQ $DTXF3 ;FORWARD, CONTINUE DIRECTION + +DTSRA: ADD #3,@#TCDT ;+3 TO TCDT + CMP @#TCDT,R2 ;LOWER BY 3 OR MORE ? + BLOS DTREV ;YES, GO REVERSE + BR $DTXF3 ;NO, CONTINUE DIRECTION + +DTSRE: BIT R3,(R1) ;BLK HIGH, CHECK DIRECTION + BNE $DTXF3 ;BR IF REV, CONTINUE DIRECTION + SUB #3,@#TCDT ;FWD, -3 TO TCDT + CMP R2,@#TCDT ;HIGHER BY 3 OR MORE ? + BLE DTREV ;REVERSE IF HIGHER BY 3 OR MORE + BR $DTXF3 ;NO, CONTINUE DIRECTION + +DTSRF: CMPB @#TCCM1,R4 ;BLOCK SAME, SAME DIRECTION ? + BNE $DTXF3 ;BR IF NOT, CONTINUE SEARCH +$DTXF4: COMB INTSW ;WANTED ??? + MOVB DTXCMD,R0 ;SET UP XFER COMMAND + TST DTBLK + BPL $DTXF3 ;FORWARD READ + BIS R3,R0 ;REVERSE READ + BR $DTXF3 + +DTER: TSTB INTSW ;SEARCH OR XFER ? + BNE DTERA ;BR IF XFER + TST @#TCST ;END ZONE ? + BMI DTREV ;BR IF YES, TO REVERSE +DTERA: BIT #TCSOFT,@#TCST ;CHECK FOR SOFT ERROR + BEQ DTHDER ;BR IF NOT SOFT ERROR + DECB TRYCTR ;3RD TRY ? + BEQ $DTXF3 ;BR IF YES + BR $DTXF1 ;GO TRY AGAIN + +DTERB: BIC #116,(R1) ;STOP DECTAPE + PMSG +DTERC: PMSG < DTA ERR> + EXITERR + +DTHDER: BIC #116,(R1) ;STOP DECTAPE + PMSG + BR DTERC + +DTREV: ADD R3,R0 ;CHANGE DIRECTION + BIC #BIT12,R0 +DTREVC: DECB REVCNT ;6TH REVERSAL ? + BNE $DTXF3 ;BR IF NOT + BIC #116,(R1) ;STOP DECTAPE + PMSG + BR DTERC + +DATINT: BIC #116,(R1) ;STOP DECTAPE + EXIT ;DONE diff --git a/src/kldcp/fd11.1 b/src/kldcp/fd11.1 new file mode 100755 index 00000000..f3f5c385 --- /dev/null +++ b/src/kldcp/fd11.1 @@ -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 + \ No newline at end of file diff --git a/src/kldcp/floppy.1 b/src/kldcp/floppy.1 new file mode 100755 index 00000000..8d79d13b --- /dev/null +++ b/src/kldcp/floppy.1 @@ -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 + BR RXERC +RXERB: PMSG +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 + \ No newline at end of file diff --git a/src/kldcp/kldcp.20 b/src/kldcp/kldcp.20 new file mode 100755 index 00000000..92a59ea2 --- /dev/null +++ b/src/kldcp/kldcp.20 @@ -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 diff --git a/src/kldcp/prm11.14 b/src/kldcp/prm11.14 new file mode 100755 index 00000000..d15f8486 --- /dev/null +++ b/src/kldcp/prm11.14 @@ -0,0 +1,1679 @@ +;;;MODIFICATION HISTORY +;;; +;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7) +;;; 15 NOV 75 CONVERTED TO PALX FORMAT +;;; 12 AUG 76 MODIFY LITERAL GENERATING MACROS TO AVOID ODD NUMBER OF BYTES +;;; + +.SBTTL *PRM11* DECSYSTEM10 PDP-11 PROGRAM/SUBROUTINE PARAMETERS, 4-AUG-75 + +;PROGRAM CONTROL SWITCHES + +ABORT==100000 ;ABORT AT PROGRAM PASS COMPLETION + +RSTART==40000 ;RESTART TEST +TOTALS==20000 ;PRINT TEST TOTALS +NOPNT==10000 ;INHIBIT ALL PRINT OUT (EXCEPT FORCED) + +PNTLPT==4000 ;PRINT ON LINE-PRINTER +DING==2000 ;RING TTY BELL ON ERROR +LOOPER==1000 ;LOOP ON ERROR + +ERSTOP==400 ;HALT ON ERROR +PALERS==200 ;PRINT ALL ERRORS +RELIAB==100 ;RELIABILITY RUN MODE + +TXTINH==40 ;TEXT INHIBIT +INHPAG==20 ;INHIBIT PAGING (PDP-10) +MODDVC==10 ;MODIFY DEVICE CODE (PDP-10) + +INHCSH==4 ;INHIBIT CACHE (PDP-10) +OPRSEL==2 ;OPERATOR SELECTION +CHAIN==1 ;CHAIN CONTROL SWITCH + +;OPERATOR DEFINITION - SUBROUTINE CALLS +.SBTTL EMT DEFS + +FATAL= EMT!0 ;FATAL PROGRAMMING ERROR. +ERRHLT= EMT!1 ;PROGRAM HALT, ONLY IF "ERSTOP" SWITCH SET +PRGHLT= EMT!2 ;PROGRAM HALT, DON'T CHECK SWITCH +RUNLP= EMT!3 ;CONSOLE IDLE RUN LOOP +DFLEGAL=EMT!226 ;DIAGNOSTIC FUNCTION LEGALITY CHECK + +;TELETYPE INPUT DEFINITIONS +; *** CALL SEQUENCE *** +; TT---- +; RETURN, C BIT SET FOR NO/ERROR RESPONSE + +TTILIN= EMT!4 ;READ TTY LINE INPUT INTO BUFFER +TTILNW= EMT!224 ;READ TTY LINE INPUT, WAIT FOREVER +TTICCL= EMT!225 ;PROCESS TTY INPUT FROM INDIRECT CCL BUFFER +TTICHR= EMT!5 ;INPUT A CHARACTER FROM BUFFER +TTBACK= EMT!144 ;BACKUP INPUT POINTER +TTLOOK= EMT!6 ;LOOK FOR A TTY INPUT +TTIOCT= EMT!7 ;INPUT AN OCTAL NUMBER FROM BUFFER +TTCOCT= EMT!10 ;INPUT & CHECK OCTAL, RTN IF OK +TTOCTE= EMT!200 ;INPUT EVEN OCTAL NUMBER +TTIDEC= EMT!11 ;INPUT A DECIMAL NUMBER FROM BUFFER +TTIYES= EMT!12 ;ASK YES-NO, N BIT ON NO, C BIT SET ON ERROR +TTALTM= EMT!13 ;ALT-MODE CHECK, C BIT SET IF NON-ALT-MODE +TTI36= EMT!14 ;READ 36 DIGIT NUMBER FROM BUFFER +TTIBRK= EMT!15 ;GET NUMBER INPUT BREAK CHARACTER +TTISDL= EMT!16 ;SPACE DELETE, C BIT SET ON NON-NUMBER +TTISDO= EMT!17 ;SPACE DELETE & OCTAL INPUT, RTN IF OK +TTIS36= EMT!20 ;SPACE DELETE & 36BIT INPUT, RTN IF OK +TTICRA= EMT!21 ;INPUT C-RAM ADDRESS +TTITRM= EMT!22 ;CHECK INPUT TERMINATOR, RTN IF OK +TTBTRM= EMT!23 ;BACKUP, THEN " +TTERM= EMT!201 ;NUMBER TERMINATION CHECK, C BIT SET IF ERROR +TTPINI= EMT!217 ;INITIALIZE INPUT & OUTPUT BUFFER POINTERS + +;TELETYPE OUTPUT DEFINITIONS +; *** CALL SEQUENCE *** +; MOV ARG,R0 ;IF CALL REQUIRES AN ARGUMENT +; P----- + +PNTAL= EMT!24 ;PRINT ASCII LINE, ADDRESS IN R0 +$PMSG= EMT!25 ;PRINT MESSAGE, TRAILING PARAMETER +$PMSGR= EMT!26 ;PRINT MESSAGE, CONDITIONAL ON "RPTFLG" +PNTCHR= EMT!27 ;PRINT ASCII CHARACTER IN R0 +PNTCI= EMT!214 ;PRINT CHAR IMMEDIATE, TRAILING CHARS +PNTNBR= EMT!30 ;PRINT NUMBER +PCRLF= EMT!31 ;PRINT CR-LF +PSPACE= EMT!32 ;PRINT A SPACE +PSLASH= EMT!33 ;PRINT A SLASH +PCOMMA= EMT!34 ;PRINT A COMMA +PTAB= EMT!227 ;PRINT A TAB +PNTOCT= EMT!35 ;PRINT OCTAL NUMBER IN R0 +PNTOCS= EMT!36 ;PRINT OCTAL IN R0, SUPPRESS LEADING ZEROS +PNTDEC= EMT!37 ;PRINT DECIMAL NUMBER IN R0 +PNT18= EMT!40 ;PRINT LOWER 18 OF 36 BIT NUMBER +PNT23= EMT!41 ;PRINT LOWER 23 BITS OF 36 BIT NUMBER +PNT22= EMT!41 ; " OLD PNT23 " +PNT36= EMT!42 ;PRINT 36 BIT NUMBER, ADDRESS IN R0 +PNT36B= EMT!134 ;PRINT 36 BIT NUMBER IN BINARY +PNTADR= EMT!137 ;PRINT PDP-10 ADDRESS +PFORCE= EMT!43 ;SET FORCED PRINTOUT FLAG +PNORML= EMT!44 ;CLEAR FORCED PRINTOUT FLAG +PBELL= EMT!45 ;DING THE TTY BELL +PNTODC= EMT!46 ;PRINT SPECIFIED OCTAL DIGITS +PNTODT= EMT!47 ;PRINT SPECIFIED DIGITS, TRAILING PARAMETER + +PRINTT= EMT!151 ;PRINT, TTY OUTPUT +PTTY= EMT!152 ;PRINT, TTY DRIVER +PLPT= EMT!153 ;PRINT, LPT DRIVER +PLDBUF= EMT!154 ;PRINT, LOAD BUFFER + +PNTBAK= EMT!177 ;PRINT, BACKUP OUTPUT INSERTION POINTER + +PNTRST= EMT!215 ;PRINT, OUTPUT POINTERS RESET + +;MISCELLANEOUS FUNCTIONS + +REGSAV= EMT!50 ;SAVE R0 THROUGH R5 +REGRST= EMT!51 ;RESTORE R0 THROUGH R5 +SHIFTR= EMT!53 ;SHIFT R0 RIGHT, TRAILING PARAMETER +SHIFTL= EMT!54 ;SHIFT R0 LEFT, TRAILING PARAMETER +PROL36= EMT!146 ;ROTATE LEFT 36 BITS +SETFLG= EMT!55 ;SET -1 TO FLAG, TRAILING PARAMETER +MULTPY= EMT!72 ;MULTIPLY +TDELAY= EMT!56 ;SMALL DELAY +SWITCH= EMT!57 ;READ THE SWITCH REGISTER, RETURNED IN R0 +SWTSAM= EMT!60 ;RETURN PRESENT STORED SWITCHES IN R0 + +EOP= EMT!61 ;END OF PASS ROUTINE, RETURNS IF NOT COMPLETED +ERREOP= EMT!62 ;ERROR END OF PASS +EOPSET= EMT!63 ;SET END OF PASS PRINTOUT INTERVAL + +;DEVICE ROUTINES + +NAMEXT= EMT!206 ;FILE NAME.EXT PROCESS +DTAFILE=EMT!207 ;DECTAPE FILE SELECTION +RPFILE= EMT!210 ;RP04 FILE SELECTION +R50UPK= EMT!155 ;RAD50 TO ASCII UNPACK +ASCR50= EMT!165 ;ASCII TO RAD50 CONVERSION +DTINIT= EMT!156 ;DECTAPE INITIALIZATION +RPINIT= EMT!157 ;RP04 INITIALIZATION +RPLOAD= EMT!166 ;RP04 LOAD PACK +DVDATA= EMT!160 ;DEVICE DATA BLOCK READ +DTRDFL= EMT!211 ;DECTAPE READ FILE +DTWTFL= EMT!212 ;DECTAPE WRITE FILE +DTBASE= EMT!213 ;RETURN DECTAPE PARAMETER BASE ADDRESS +DTREAD= EMT!161 ;DECTAPE READ +DTWRT= EMT!205 ;DECTAPE WRITE +RPFIND= EMT!167 ;RP04 FIND FILE +RPLKUP= EMT!170 ;RP04 FILE DIRECTORY LOOKUP +RPRDFL= EMT!171 ;RP04 READ FILE +RPWRFL= EMT!172 ;RP04 WRITE FILE +RPREAD= EMT!162 ;RP04 READ +RPWRIT= EMT!173 ;RP04 WRITE +RPADDR= EMT!174 ;RP04 ADDRESS CALCULATION +RPBASE= EMT!175 ;RETURN RP04 PARAMETER BLOCK BASE ADDRESS +RPERROR=EMT!237 ;RP04 ERROR REPORTER +DVFRAM= EMT!163 ;DEVICE DATA FRAME READ +DVWRD= EMT!164 ;DEVICE WORD READ +RXFILE= EMT!230 ;RX11/RX01 FLOPPY FILE SELECTION +RXINIT= EMT!231 ; FLOPPY INITIALIZATION +RXRDFL= EMT!232 ; FLOPPY READ FILE +RXWTFL= EMT!233 ; FLOPPY WRITE FILE +RXBASE= EMT!234 ; FLOPPY PARAMETER BLOCK BASE ADDRESS +RXREAD= EMT!235 ; FLOPPY READ +RXWRT= EMT!236 ; FLOPPY WRITE + +;COMMUNICATION ROUTINES + +COMCMD= EMT!220 ;COMMUNICATIONS COMMAND +COMRTRY=EMT!221 ;COMMUNICATIONS COMMAND RETRY +COMENQ= EMT!222 ;COMMUNICATIONS ENQUIRY +COMEOT= EMT!223 ;COMMUNICATIONS END OF TRANSMISSION +COMLIN= EMT!64 ;COMMUNICATIONS LINE INPUT +COMSND= EMT!65 ;COMMUNICATIONS LINE OUTPUT +COMACK= EMT!66 ;COMMUNICATIONS ACKNOWLEDGE +COMNAK= EMT!67 ;COMMUNICATIONS NEGATIVE ACKNOWLEDGE +COMCLR= EMT!70 ;COMMUNICATIONS CLEAR +COMCTL= EMT!71 ;COMMUNICATIONS CONTROL SEQUENCE + +;KL10 ROUTINES + +WCRAM= EMT!73 ;WRITE IN TO C-RAM +RCRAM= EMT!74 ;READ THE C-RAM +WWADR= EMT!75 ;WRITE C-RAM ADDRESS +MICNUL= EMT!203 ;C-RAM FILL WITH 0'S +MICFIL= EMT!204 ;C-RAM FILL WITH 1'S + +MRESET= EMT!76 ;MASTER RESET + +TENSW= EMT!145 ;PDP-10 SWITCHES + +TENSP= EMT!77 ;TURN OFF TEN RUNNING + +TENCHR= EMT!176 ;PDP-10 LAST TYPED CHARACTER + +SM= EMT!100 ;START MACHINE +EXCT= EMT!101 ;EXECUTE PDP10 INSTR, REQUIRES SM +LODAR= EMT!102 ;SPECIAL AR LOAD FOR EXCT AND MBOX TEST +SETMPH= EMT!147 ;SET M-BOX PHASE + +ECLOK= EMT!135 ;E BOX CLOCK +ESYNC= EMT!136 ;E BOX SYNC + +EXAM= EMT!103 ;EXAMINE 10 MEMORY +EXAMT= EMT!104 ;EXAMINE 10 MEMORY, TRAILING PARAMETERS +DPOS= EMT!105 ;DEPOSIT INTO 10 MEMORY +DPOST= EMT!106 ;DEPOSIT INTO 10 MEMORY, TRAILING PARAMETERS +DPOSVR= EMT!107 ;DEPOSIT AND VERIFY 10 MEMORY +DPOSVT= EMT!110 ;DEPOSIT AND VERIFY 10 MEMORY, TRAILING PARAMETERS +D10MON= EMT!111 ;DEPOSIT -1 INTO 10 FLAG WORD +D10ZRO= EMT!112 ;PDP-10 MEMORY ZERO + +CMPR36= EMT!52 ;COMPARE 5 BYTE 36-BIT WORD + +DTEBAS= EMT!113 ;RETURN DTE20 BASE ADDRESS + +DFXCT= EMT!114 ;DIAGNOSTIC FUNCTION EXECUTE +DFXCTT= EMT!115 ;DF EXECUTE, TRAILING PARAMETER + +DFRD= EMT!116 ;DIAGNOSTIC FUNCTION READ +DFRDT= EMT!140 ;DF READ, TRAILING PARAMETER +DFRDMV= EMT!117 ;DIAGNOSTIC FUNCTION READ & MOVE + +DFWRT= EMT!120 ;DIAGNOSTIC FUNCTION WRITE +DFWRTT= EMT!141 ;DF WRITE, TRAILING PARAMETERS +DFWIR= EMT!121 ;DIAGNOSTIC FUNCTION WRITE IR + +DFSCLK= EMT!122 ;DIAGNOSTIC FUNCTION, SINGLE STEP CLOCK + +DFPC= EMT!123 ;DIAGNOSTIC FUNCTION READ PC +DFVMA= EMT!124 ;DIAGNOSTIC FUNCTION READ VMA +DFADB= EMT!125 ;DIAGNOSTIC FUNCTION READ ADDRESS BREAK +DFVMAH= EMT!150 ;DIAGNOSTIC FUNCTION READ VMA HELD + +RDRAM= EMT!126 ;READ D-RAM +WDRAM= EMT!127 ;WRITE D-RAM +DRAMAD= EMT!130 ;SELECT D-RAM ADDRESS + +CLKPRM= EMT!202 ;RETURN ADDRESS OF "CLKDFL" WORD + +BURST= EMT!131 ;BURST M-BOX CLOCK + +PNTCPU= EMT!132 ;PRINT CPU, C-RAM & REGISTERS + +PNTCRM= EMT!142 ;PRINT C-RAM, LOGICAL FIELD FORMAT + +PNTDRM= EMT!143 ;PRINT D-RAM, LOGICAL FIELD FORMAT + +PRGCMD= EMT!133 ;PROGRAM COMMAND + +PRGNPT= EMT!216 ;PROGRAM COMMAND, NO PRINT + +.SBTTL MACRO DEFS + +.IIF P2, $$CLIT==$$LITT ;LITERAL STORAGE ASSIGNMENT +.IELSE $$CLIT==2000 ;DOESN'T MATTER ON PASS 1 BUT HAS TO BE DEFINED + +.MACRO PMSG $ARG + $PMSG + $$CLIT +; .NLIST SRC + $$CLC==. + .=$$CLIT + .ASCIZ $ARG + .IIF NZ .&1, .BYTE 0 ;ASCIIZER LOSSAGE + $$CLIT==. + .=$$CLC +; .LIST SRC +.ENDM + +.MACRO PMSGR $ARG + $PMSGR + $$CLIT +; .NLIST SRC + $$CLC==. + .=$$CLIT + .ASCIZ $ARG + .IIF NZ .&1, .BYTE 0 ;ASCIIZER LOSSAGE + $$CLIT==. + .=$$CLC +; .LIST SRC +.ENDM + +.MACRO PNTMSG $ARG + MOV #$$CLIT,R0 + PNTAL +; .NLIST SRC + $$CLC==. + .=$$CLIT + .ASCIZ $ARG + .IIF NZ .&1, .BYTE 0 ;ASCIIZER LOSSAGE + $$CLIT==. + .=$$CLC +; .LIST SRC +.ENDM + +.MACRO EXIT + JMP $EXIT +.ENDM + +.MACRO EXITSKP + JMP $EXITS +.ENDM + +.MACRO EXITERR + JMP $EXITE +.ENDM + +;BASIC MACROS + +.MACRO PUSH A +; .NLIST SRC + .IRP B, + MOV B,-(SP) ;PUSH B ON STACK + .ENDM +; .LIST SRC +.ENDM + +.MACRO POP A +; .NLIST SRC + .IRP B, + MOV (SP)+,B ;POP STACK INTO B + .ENDM +; .LIST SRC +.ENDM + +.MACRO MULT SOURCE,REG + PUSH SOURCE + PUSH REG + MULTPY + POP REG + .NTYPE X,REG + .IF EQ X&1 + .IFT + POP REG+1 + .IFF + INC SP + INC SP + .ENDC +.ENDM + +.MACRO .LIT $LTAG,$LARG + $$CLC==. + .=$$CLIT + .EVEN + $LTAG=. + .IIF B <$LARG>,0 + .IIF NB <$LARG>,$LARG + .EVEN + $$CLIT==. + .=$$CLC +.ENDM + +.MACRO SL REG,NUM +; .NLIST SRC + .IF GT NUM-7 + .IFT + SWAB REG + .REPT NUM-8. + ASL REG + .ENDR + .IFF + .REPT NUM + ASL REG + .ENDR + .ENDC +; .LIST SRC +.ENDM + +.MACRO SR REG,NUM +; .NLIST SRC + .IF GT NUM-7 + .IFT + SWAB REG + .REPT NUM-8. + ASR REG + .ENDR + .IFF + .REPT NUM + ASR REG + .ENDR + .ENDC +; .LIST SRC +.ENDM + +.MACRO EXOR REG,DESTIN,SCRTCH + .IF NB SCRTCH + .IFT + MOV REG,SCRTCH + BIC DESTIN,SCRTCH + BIC REG,DESTIN + BIS SCRTCH,DESTIN + .IFF + MOV REG,-(SP) + BIC DESTIN,(SP) + BIC REG,DESTIN + BIS (SP)+,DESTIN + .ENDC +.ENDM + +;STANDARD PROGRAM ASSIGNMENTS + +.IIF NDF STACK,STACK=157776 ;INITIAL STACK POINTER +.IIF NDF CONSOL,CONSOL=100000 ;CONSOLE START ADDRESS + +CBIT==1 ;CARRY BIT +NBIT==10 ;NEGATIVE BIT +ZBIT==4 ;ZERO BIT +VBIT==2 ;OVERFLOW BIT +TBIT==20 ;TRAP BIT + +;REGISTER DEFINITIONS + +R0= %0 ;GENERAL REGISTERS +R1= %1 +R2= %2 +R3= %3 +R4= %4 +R5= %5 +R6= %6 +SP= %6 ;STACK POINTER +PC= %7 ;PROGRAM COUNTER + +;PDP11/40 STANDARD TRAP VECTOR ASSIGNMENTS + +RESVED==0 ;RESERVED +ERRVEC==4 ;TIME OUT, BUS ERROR +RESVEC==10 ;RESERVED INSTRUCTION +TRTVEC==14 ;BREAK POINT VECTOR +IOTVEC==20 ;IOT TRAP VECTOR +PWRVEC==24 ;POWER FAIL TRAP VECTOR +EMTVEC==30 ;EMT TRAP VECTOR +TRAPVEC==34 ;"TRAP" TRAP VECTOR +TKVEC==60 ;TTY KEYBOARD VECTOR +TPVEC==64 ;TTY PRINTER VECTOR +TA11==260 ;CASSETTE TAPE READER +TC11==214 ;DECTAPE VECTOR +TBITVEC==14 +BPTVEC==14 + +;PDP11/40 STANDARD ADDRESS ASSIGNMENTS + +PS=177776 ;CPU STATUS +STKLMT=177774 ;STACK LIMIT +SWR=177570 ;CONSOLE SWITCH REGISTER +TTODBR=177566 ;TTY OUT DBR +TTOCSR=177564 ;TTY OUT CSR + +TTIDBR=177562 ;TTY IN DBR +TTICSR=177560 ;TTY IN CSR + +XORCR=174200 +XORSR=174202 + +;BIT ASSIGNMENTS + +BIT00==1 +BIT0==BIT00 +BIT01==2 +BIT1==BIT01 +BIT02==4 +BIT2==BIT02 +BIT03==10 +BIT3==BIT03 +BIT04==20 +BIT4==BIT04 +BIT05==40 +BIT5==BIT05 + +BIT06==100 +BIT6==BIT06 +BIT07==200 +BIT7==BIT07 +BIT08==400 +BIT8==BIT08 + +BIT09==1000 +BIT9==BIT09 +BIT10==2000 +BIT11==4000 + +BIT12==10000 +BIT13==20000 +BIT14==40000 + +BIT15==100000 + +;PRIORITY ASSIGNMENTS + +PR0==000 +PR1==040 +PR2==100 +PR3==140 +PR4==200 +PR5==240 +PR6==300 +PR7==340 + +;CHARACTERS USED + +MSWCHR==377 ; MONITOR TO "KLDCP" SWITCH CHAR, HACKED BY BREAK +TEXTERM=0 ; TERMINATES TEXT +TAB==11 ; TAB +CNTRLI==11 ; CONTROL-I (TAB) +LF==12 ; LINE FEED +VT==13 ; VERTICAL TAB +FF==14 ; FORM FEED +CR==15 ; CARRIAGE RETURN +BELL==7 ; BELL +BLANK==40 ; BLANK (SPACE) +SPACE==40 ; SPACE +COMMA==54 ; COMMA +SLASH==57 ; SLASH +BKSLH==134 ; BACK SLASH +BKARW==137 ; BACK ARROW +XOFF==023 ; X-OFF (CONTROL S) +XON==021 ; X-ON (CONTROL Q) +CNTRLO==017 ; CONTROL O +CNTRLU==025 ; CONTROL U +CNTRLA==001 ; CONTROL A +CNTRLC==003 ; CONTROL C +CNTRLD==004 ; CONTROL D +CNTRLK==013 ; CONTROL K +CNTRLL==14 ; CONTROL L +CNTRLR==022 ; CONTROL R +CNTRLT==024 ; CONTROL T +CNTRLX==030 ; CONTROL X +CNTRLZ==032 ; CONTROL Z +RUBOUT==177 ; RUB OUT +ALTMOD==33 ; ALTMODE +ETB==27 ; END OF TRANSMISSION BLOCK (CONTROL W) +NULL==026 ; NULL FILLER CHAR +SYN==001 ; COMMUNICATIONS SYNC CHAR (CONTROL A) + +;.NLIST +.IF DF DTEASB +;.LIST + +.SBTTL DTE20 DEVICE REGISTER AND BIT DEFINITIONS, 4-JUNE-75 + +DTEADR=174400 ;ADDRESS OF (FIRST) DTE20 DEVICE REGISTER BLOCK +DTESIZ==000040 ;SPACING BETWEEN CONSECUTIVE DTE20'S +DTEMAX==4 ;MAXIMUM NUMBER OF DTE20'S ON ONE PDP-11 +DTESZS==5 ;SHIFT TO CONVERT DTE ADDRESS TO DTE # + +.IF DF DTEDEF +;OFFSETS FROM THE BASE OF THE DTE20 DEVICE REGISTER BLOCK +;TO SPECIFIC 10/11 INTERFACE RAM LOCATIONS AND REGISTERS. + +; THE FIRST 12 REGISTERS ARE NOT INITIALIZED BY "INIT" (BECAUSE THEY ARE IN RAMS) + +DLYCNT==00 ;DELAY COUNT (ADDRESS XXXX00) +DEXWD3==02 ;DEPOSIT OR EXAMINE WORD 3 (ADDRESS XXXX02) +DEXWD2==04 ;DEPOSIT OR EXAMINE WORD 2 (ADDRESS XXXX04) +DEXWD1==06 ;DEPOSIT OR EXAMINE WORD 1 (ADDRESS XXXX06) +TENAD1==10 ;10 ADDRESS WORD 1 FOR DEX (ADDRESS XXXX10) +TENAD2==12 ;10 ADDRESS WORD 2 FOR DEX (ADDRESS XXXX12) +TO10BC==14 ;TO10 BYTE COUNT (ADDRESS XXXX14) +TO11BC==16 ;TO11 BYTE COUNT (ADDRESS XXXX16) +TO10AD==20 ;TO10 PDP11 MEMORY ADDRESS (ADDRESS XXXX20) +TO11AD==22 ;TO11 PDP11 MEMORY ADDRESS (ADDRESS XXXX22) +TO10DT==24 ;TO10 PDP11 DATA WORD (ADDRESS XXXX24) +TO11DT==26 ;TO11 PDP11 DATA WORD (ADDRESS XXXX26) + +; THE LAST 4 REGISTERS ARE INITIALIZED BY "INIT" (BECAUSE THEY ARE IN FLIP-FLOPS) + +DIAG1==30 ;DIAGNOSTIC WORD 1 (ADDRESS XXXX30) +DIAG2==32 ;DIAGNOSTIC WORD 2 (ADDRESS XXXX32) +STATUS==34 ;10/11 INTERFACE STATUS WORD (ADDRESS XXXX34) +DIAG3==36 ;DIAGNOSTIC WORD 3 (ADDRESS XXXX36) +.ENDC + +; THE FOLLOWING ARE THE ADDRESSES OF THE DTE20 INTERRUPT VECTORS + +DTEIV0==774 ;INTERRUPT VECTOR FOR DTE20 #0 +DTEIV1==770 ;INTERRUPT VECTOR FOR DTE20 #1 +DTEIV2==764 ;INTERRUPT VECTOR FOR DTE20 #2 +DTEIV3==760 ;INTERRUPT VECTOR FOR DTE20 #3 + +;BIT ASSIGNMENTS FOR 10/11 INTERFACE REGISTERS + +;BIT ASSIGNMENTS FOR TENAD1 + +PHYS==BIT15 ;EXAMINE/DEP PHYSICAL ADDRESS +USEVIR==BIT14!BIT13 ;EX/DP USER VIRTUAL ADDRESS +XUPT==BIT14 ;EX/DP VIA USER PROCESS TABLE +EXVIRT==BIT13 ;EX/DP EXEC VIRTUAL ADDRESS +DEP==BIT12 ;MODE BIT FOR DEPOSIT (0=EXAMINE) +PRTOFF==BIT11 ;PROTECT OFF +XEPT==0 ;EX/DP VIA EXEC PROCESS TABLE + +;BIT ASSIGNMENTS FOR TO11BC + +INT10==BIT15 ;SET DONE AND INTERRUPT BOTH 10 AND 11 +ZSTOP==BIT14 ;STOP ON NULL (ZERO) CHARACTER +BYTE2==BIT13 ;TWO EIGHT BIT BYTES PER WORD +TO11BM==BIT13 ;TO-11 BYTE MODE + +;BIT ASSIGNMENTS FOR DIAG1 (WRITE) + +DS00==BIT15 ;DIAGNOSTIC STATUS +DS01==BIT14 ; " +DS02==BIT13 ; " +DS03==BIT12 ; " +DS04==BIT11 ; " +DS05==BIT10 ; " +DS06==BIT9 ; " +DFUNC==BIT7 ;DOING DIAGNOSTIC FUNCTION (DFRD,DFWRT,DFXCT) +PULSE==BIT4!BIT5 ;SINGLE PULSE THE 10/11 CLOCK (ALSO SETS + ;10/11 DIAGNOSTIC MODE) +DCOMST==BIT0 ;DIAGNOSTIC COMMAND START +DCSRT==BIT0 ;DIAGNOSTIC COMMAND START (NEW NAME FOR DCOMST) +DSEND==BIT2 ;SEND THE EBUS DURING DIAGNOSTIC FUNCTION +DIKL10==BIT3 ;KL10 DIAGNOSTIC MODE +D1011==BIT5 ;10/11 INTERFACE DIAGNOSTIC MODE + +;BIT ASSIGNMENTS FOR DIAG1 (READ) + +TO10==BIT7 ;INTERFACE MAJOR STATE = TO10 TRANSFER +DEX==BIT8 ; " " " = DEPOSIT OR EXAMINE +TO11==BIT6 ; " " " = TO11 TRANSFER +VEC04==BIT4 ;VECTOR INTERRUPT ADDRESS BIT 4 +VEC03==BIT3 ; " " " " 3 +VEC02==BIT2 ; " " " " 2 +HALTLP==BIT9 ;EBOX IS IN HALT LOOP +KLRUN==BIT10 ;RUN FLOP, KL IS EXECUTING INSTRUCTIONS +ERRSTP==BIT11 ;EBOX CLOCK STOPPED DUE TO ERROR + +;BIT ASSIGNMENTS FOR DIAG2 (WRITE) + +EDONES==BIT14 ;SET EBUS DONE +DRESET==BIT6 ;PERFORM DIAGNOSTIC CLEAR + +;BIT ASSIGNMENTS FOR DIAG2 (READ) + +;BIT ASSIGNMENTS FOR DIAG3 (WRITE) + +SCD==BIT5 ;SHIFT CAPTURED DATA (PARITY ERROR DATA) +CDD==BIT4 ;CLEAR DUPE & DURE ERROR FLAGS +WEP==BIT3 ;WRITE EVEN (BAD) PARITY +CNUPE==BIT1 ;CLEAR NUPE +TO10BM==BIT0 ;TO-10 TRANSFER BYTES FROM THE 11 + +;BIT ASSIGNMENTS FOR DIAG3 (READ) + +RFMAD0==BIT15 ;RFM ADDRESS BIT 0 +RFMAD1==BIT14 ; " " " 1 +RFMAD2==BIT13 ; " " " 2 +RFMAD3==BIT12 ; " " " 3 + +;BIT ASSIGNMENTS FOR DIAG3 (READ) + +SWSLFT==BIT15 ;SWAP SELECT LEFT +CAB08==BIT14 ;CAPTURED UNIBUS ADDRESS BIT 08 +DUPE==BIT4 ;DATO UNIBUS PARITY ERROR +DURE==BIT2 ;DATO UNIBUS RECIEVER ERROR +NUPE==BIT1 ;NPR UNIBUS PARITY ERROR +UPECD==BIT13!BIT12!BIT11!BIT10!BIT9 ;UNIBUS PARITY ERR, CAPTURED DATA + +;BIT ASSIGNMENTS FOR STATUS (WRITE) + +DON10S==BIT15 ;SET TO10 DONE +DON10C==BIT14 ;CLEAR TO10 DONE +ERR10S==BIT13 ;SET TO10 ERROR +ERR10C==BIT12 ;CLEAR TO10 ERROR +INT11S==BIT11 ;SET 10 REQ INTERRUPT (INTERRUPTS 11) +INT11C==BIT10 ;CLEAR 10 REQ INTERRUPT (REMOVES INTERRUPT TO 11) +PERCLR==BIT9 ;CLEAR -11 MEMORY PARITY ERROR +INT10S==BIT8 ;SET REQUEST 10 INTERRUPT (INTERRUPTS 10) +DON11S==BIT7 ;SET TO11 DONE +DON11C==BIT6 ;CLEAR TO11 DONE +INTRON==BIT5 ;ENABLE DTE20 TO INTERRUPT THE 11 +EBUSPC==BIT4 ;CLEAR EBUS PARITY ERROR +INTROF==BIT3 ;DISABLE THE DTE20 11-INTERRUPTS +EBUSPS==BIT2 ;SET EBUS PARITY ERROR +ERR11S==BIT1 ;SET TO11 ERROR +ERR11C==BIT0 ;CLEAR TO11 ERROR + +;BIT ASSIGNMENTS FOR STATUS (READ) + +TO10DN==BIT15 ;TO10 DONE +TO10ER==BIT13 ;TO 10 ERROR (NPR TIMEOUT OR BUS ERROR) +RAMIS0==BIT12 ;DATA OUT OF DTE RAM IS ALL 0S (RFM=0) +TO11DB==BIT11 ;10 REQUESTING 11 INTERRUPT (DOORBELL FROM 10) +DXWRD1==BIT10 ;DEPOSIT OR EXAMINE WORD ONE +D11MPE==BIT9 ;-11 MEMORY PARITY ERROR +TO10DB==BIT8 ;REQUEST 10 INTERRUPT (DOORBELL FROM 11) +TO11DN==BIT7 ;TO11 DONE +EBSEL==BIT6 ;E BUFFER SELECT +NULSTP==BIT5 ;NULL STOP +BPARER==BIT4 ;EBUS PARITY ERROR +RM==BIT3 ;THIS DTE20 IN RESTRICTED MODE +DEXDON==BIT2 ;DEPOSIT OR EXAMINE DONE +TO11ER==BIT1 ;TO 11 ERROR (NPR TIMEOUT OR BUS ERROR) +INTSON==BIT0 ;INTERRUPTS ON, DTE20 ENABLED TO INTERRUPT 11 + +;CLOCK CONTROL FUNCTIONS + +STPCLK==000 ; STOP CLOCK +STRCLK==001 ; START CLOCK +SSCLK==002 ; SINGLE STEP THE MBOX CLOCK +SECLK==003 ; SINGLE STEP EBOX CLOCK +CECLK==004 ; CONDITIONAL EBOX CLOCK +CLRMR==006 ; CLEAR MR RESET +SETMR==007 ; SET MR RESET +BRCLK==005 ; BURST THE CLOCK + +;CLOCK LOAD FUNCTIONS + +LDBRR==42 ; LOAD BURST REGISTER RIGHT HALF +LDBRL==43 ; LOAD BURST REGISTER LEFT HALF +LDSEL==44 ; LOAD SOURCE AND RATE SELECTS +LDDIS==45 ; LOAD EBOX CLOCK DISTRIBUTION REGISTER +LDCHK1==46 ; LOAD PARITY CHECK REGISTER (ENABLE BAD PARITY STOP) +LDCHK2==47 ; LOAD EBOX INTERNAL CHECK REGISTER + +;DRAM FUNCTIONS + +LDRAM1==60 ; LOAD A & B FIELDS EVEN +LDRAM2==61 ; LOAD A & B FIELDS ODD +LDRAM3==62 ; LOAD COMMON J1-J4 +LDRJEV==63 ; LOAD PARITY & J8-J10 EVEN +LDRJOD==64 ; LOAD PARITY & J8-J10 ODD +DRAMAB==133 ; READ D-RAM A & B +DRJ710==135 ; READ D-RAM J7-J10 +DRJ1.4==134 ; READ D-RAM J1-J4 + +;IR DRAM CONTROL + +DISIOJ==65 ; DISABLE 7XX & JRST=254 +DISACF==66 ; DISABLE THE IR AC'C +ENIOJA==67 ; ENABLE 7XX, JRST=254 & IR AC'S + +;CRAM FUNCTIONS + +LCRAM1==57 ; LOAD C-RAM DATA +LCRAM2==56 +LCRAM3==55 +LCRAM4==54 +LCRAM5==53 +LCRDAL==52 ; LOAD CRAM ADDRESS LEFT (00-04) +LCRDAR==51 ; LOAD CRAM ADDRESS RIGHT (05-10) +RCRAM1==147 ; READ C-RAM DATA +RCRAM2==146 +RCRAM3==145 +RCRAM4==144 +RCSPEC==141 ; READ C-RAM SPEC + +;MISC CONTROL FUNCTIONS + +IRLOAD==14 ; LOAD THE IR FROM AD +DRLTCH==15 ; LOAD D-RAM LATCHES +CLRRUN==10 ; CLEAR RUN FLIP-FLOP +SETRUN==11 ; SET RUN FLIP-FLOP +CONBUT==12 ; THE CONTINUE BUTTON +LDAR==77 ; LOAD THE AR + +;MBOX CONTROL FUNCTIONS + +LDMBXA==71 ; LOAD MEMORY TO CACHE SELECTOR +LDCHAN==70 ; LOAD CHANNEL DIAGNOSTIC CONDITIONS + +;PI CONTROL FUNCTIONS + +READ0==100 ; PI (READ STATUS 0) +READ1==101 ; PI (READ STATUS 1) +READ2==102 ; PI (READ STATUS 2) +READ3==103 ; PI (READ STATUS 3) + +;DATA PATH CONTROL FUNCTIONS + +DPAR==120 ; AR +DPBR==121 ; BR +DPMQ==122 ; MQ +DPFM==123 ; FM +DPFMA==114 ; FM ADR +DPBRX==124 ; BRX +DPARX==125 ; ARX +DPADX==126 ; ADX +DPAD==127 ; AD +DPPC==153 ; PC +DPVMA==157 ; VMA +DPVMHD==157 ; VMA HELD +DPADB==153 ; ADDRESS BREAK +DPERG==167 ; E-BUS REGISTER +DPFE==132 ; FE 05-09 +DPFE1==133 ; FE 00-04 +DPSC==130 ; SC 05-09 +DPSC1==131 ; SC 00-04 + +.SBTTL KL10 EBOX MACRO DEFINITIONS, 4-JUNE-75 + +;MACRO TO TURN 36 BIT WORDS INTO 5 UPSIDE DOWN BYTES + +.MACRO WD36 A,B,C + .NLIST SRC + .BYTE <377&C>,<</400>!<*20>>,</20> + .BYTE ,</400> + .LIST SRC +.ENDM + +;PDP10 CPU INSTRUCTION MACRO. TAKES 5 ARGUMENTS AS IN NORMAL +;10 CODE. 5 FIELDS MUST BE PRESENT (4 FIELD SEPARATORS) +;BUT THE AD,AC,I, AND XR FIELDS MAY BE LEFT BLANK AND IF SO, +;WILL ASSEMBLE AS ZERO. THE OP FIELD MUST NOT BE LEFT BLANK. + +.MACRO I10 OP,CAC,CI,CAD,CXR + ADH==0 + ADL==0 + .IF NB CAD + .IRPC AD1,CAD + .IIF GE ,ADH==ADL/10000 + ADL==10*+AD1 + .ENDM + .ENDC + .IIF B CAC,AC==0 + .IIF NB CAC,AC==CAC + .IIF B CI,I==0 + .IIF NB CI,I==CI + .IIF B CXR,XR==0 + .IIF NB CXR,XR==CXR + .NLIST SRC + .BYTE ,<!>,>+> + .BYTE >, + .LIST SRC +.ENDM I10 + +CRMSIZ==2777 ;# C-RAM WORDS + +;MACRO TO GENERATE A RIGHT JUSTIFIED 3-BYTE VALUE +;FOR A 22-BIT ARGUMENT + +.MACRO WD22 AD + ADH==0 + ADL==0 + .IRPC AD1,AD + .IIF GE ,ADH==<10*ADH>+ + ADL==10*+AD1 + .ENDM + .NLIST SRC + .BYTE ,<!>, + .LIST SRC +.ENDM WD22 + +;PDP10 I/O INSTRUCTION MACRO. TAKES 5 ARGUMENT AS NOTED ABOVE +;IN THE DESCRIPTION OF THE I10 MACRO. THE 8 I/O OP CODES ARE +;DEFINED AS ARE DEVICE CODES APR, PI, PAG, AND CCA. + +.MACRO IO10 OP,DV,CI,AD,CXR + .IIF B CI,I==0 + .IIF NB CI,I==CI + .IIF B CXR,XR==0 + .IIF NB CXR,XR==CXR + BLKO==2 + DATAO==3 + BLKI==0 + DATAI==1 + CONO==4 + CONI==5 + CONSZ==6 + CONSO==7 + APR==0 + PI==4 + PAG==10 + CCA==14 + ADH==0 + ADL==0 + .IRPC AD1,AD + .IIF GE ,ADH==ADL/10000 + ADL==10*+AD1 + .ENDM + .NLIST SRC + .BYTE ,<!>,>+> + .BYTE >, + .LIST SRC +.ENDM IO10 + +;THIS IS A MACRO TO WAIT FOR A DONE FLAG + +.MACRO WFZERO BITSEL + MOV #2500.,-(SP) ;SET TIMEOUT CNT + 91$: BIT #BITSEL,@.DIAG1 ;TEST BIT + BEQ 92$ ;LEAVE IF BIT ZERO(OK) + DEC (SP) ;DECREMENT CNT + BNE 91$ ;CONTINUE LOOP + TST RPTFLG ;OTHERWISE TIME OUT + BNE 92$ + JSR R1,$DFTIM + 92$: TST (SP)+ ;RESET STACK & CONTINUE +.ENDM + + +;THIS MACRO IS A WAIT FOR FLAG MACRO. +;IT WAITS FOR A TEST BIT TO GO TO ONE +;FROM A ZERO + +.MACRO WFONE BITSEL + MOV #2500.,-(SP) ;SET TIMEOUT CNT + 93$: BIT #BITSEL,@.STDTE ;TEST BIT + BNE 94$ ;LEAVE IF NOW A ONE(OK) + DEC (SP) ;DECREMENT CNT + BNE 93$ ;CONTINUE LOOP + TST RPTFLG ;OTHERWISE TIME OUT + BNE 94$ + JSR R1,$DFTIM + 94$: TST (SP)+ ;RESET STACK +.ENDM + +.NLIST +.ENDC ; DTEASB +.LIST +.NLIST +.IF DF DTEBBD +.LIST + +.SBTTL *BBD* DTE20 DEVICE REGISTER AND BIT DEFINITIONS, 2-JAN-75 + +DTEADR=164000 ;ADDRESS OF (FIRST) DTE20 DEVICE REGISTER BLOCK +DTESIZ==000040 ;SPACING BETWEEN CONSECUTIVE DTE20'S +DTEMAX==4 ;MAXIMUM NUMBER OF DTE20'S ON ONE PDP-11 +DTESZS==5 ;SHIFT TO CONVERT DTE ADDRESS TO DTE # + +.IF DF DTEDEF +;OFFSETS FROM THE BASE OF THE DTE20 DEVICE REGISTER BLOCK +;TO SPECIFIC 10/11 INTERFACE RAM LOCATIONS AND REGISTERS. + +; THE FIRST 12 REGISTERS ARE NOT INITIALIZED BY "INIT" (BECAUSE THEY ARE IN RAMS) + +DLYCNT==00 ;DELAY COUNT (ADDRESS XXXX00) +DEXWD1==02 ;DEPOSIT OR EXAMINE WORD 1 (ADDRESS XXXX02) +DEXWD2==04 ;DEPOSIT OR EXAMINE WORD 2 (ADDRESS XXXX04) +DEXWD3==06 ;DEPOSIT OR EXAMINE WORD 3 (ADDRESS XXXX06) +TENAD1==10 ;10 ADDRESS WORD 1 FOR DEX (ADDRESS XXXX10) +TENAD2==12 ;10 ADDRESS WORD 2 FOR DEX (ADDRESS XXXX12) +TO10BC==14 ;TO10 BYTE COUNT (ADDRESS XXXX14) +TO11BC==16 ;TO11 BYTE COUNT (ADDRESS XXXX16) +TO10AD==20 ;TO10 PDP11 MEMORY ADDRESS (ADDRESS XXXX20) +TO11AD==22 ;TO11 PDP11 MEMORY ADDRESS (ADDRESS XXXX22) +TO10DT==24 ;TO10 PDP11 DATA WORD (ADDRESS XXXX24) +TO11DT==26 ;TO11 PDP11 DATA WORD (ADDRESS XXXX26) + +; THE LAST 4 REGISTERS ARE INITIALIZED BY "INIT" (BECAUSE THEY ARE IN FLIP-FLOPS) + +DIAG1==30 ;DIAGNOSTIC WORD 1 (ADDRESS XXXX30) +DIAG2==32 ;DIAGNOSTIC WORD 2 (ADDRESS XXXX32) +STATUS==34 ;10/11 INTERFACE STATUS WORD (ADDRESS XXXX34) +DIAG3==36 ;DIAGNOSTIC WORD 3 (ADDRESS XXXX36) +.ENDC + +; THE FOLLOWING ARE THE ADDRESSES OF THE DTE20 INTERRUPT VECTORS + +DTEIV0==170 ;INTERRUPT VECTOR FOR DTE20 #0 +DTEIV1==174 ;INTERRUPT VECTOR FOR DTE20 #1 +DTEIV2==270 ;INTERRUPT VECTOR FOR DTE20 #2 +DTEIV3==274 ;INTERRUPT VECTOR FOR DTE20 #3 + +; THE FOLLOWING MACRO (DTEVEC) DYNAMICLY COMPUTES THE INTERRUPT +; VECTOR ADDRESS ASSOCIATED WITH A PARTICULAR DTE20. +; THE FIRST ARGUMENT (DTEDRB) IS A REGISTER OR MEMORY LOCATION +; WHICH CONTAINS THE BASE ADDRESS OF THE DEVICE REGISTER BLOCK +; FOR A PARTICULAR DTE20. +; THE SECOND ARGUMENT (DTEIVB) IS A REGISTER OR MEMORY LOCATION +; INTO WHICH THIS MACRO WILL STORE THE BASE ADDRESS OF THE INTERRUPT +; VECTOR ASSOCIATED WITH THE SAME DTE20. + +.MACRO DTEVEC DTEDRB,DTEIVB,?LABEL + MOVB DTEDRB,DTEIVB + .NTYPE DTE$T0,DTEIVB + .IF NE DTE$T0&70 ;IS "DTEIVB" A REGISTER? + .IFT + CLRB DTEIVB+1 + .ENDC + ADD #DTEIV0,DTEIVB ;THIS MACRO DEPENDS ON THE BIT + BIT #DTESIZ,DTEIVB ;PATTERNS IN THE DEVICE REGISTER + BNE LABEL ;ADDRESSES AND INTERRUPT VECTOR + SUB #DTESIZ+DTEIV0-DTEIV1,DTEIVB ;ADDRESSES. + LABEL: +.ENDM DTEVEC + +;BIT ASSIGNMENTS FOR 10/11 INTERFACE REGISTERS + +;BIT ASSIGNMENTS FOR TENAD1 + +DEP==BIT15 ;MODE BIT FOR DEPOSIT (0=EXAMINE) +F1==BIT7 ;HIGH ORDER BIT OF FAST AC BLOCK +F2==BIT6 ;LOW " " " " " " + +;BIT ASSIGNMENTS FOR TO10BC + +INT11==BIT15 ;SET DONE AND INTERRUPT BOTH 10 AND 11 + +;BIT ASSIGNMENTS FOR TO11BC + +INT10==BIT15 ;SET DONE AND INTERRUPT BOTH 10 AND 11 +ZSTOP==BIT14 ;STOP ON NULL (ZERO) CHARACTER + +;BIT ASSIGNMENTS FOR TO10AD AND TO11AD + +BYTE2==BIT0 ;TWO EIGHT-BIT BYTES PER WORD + +;BIT ASSIGNMENTS FOR DIAG1 (WRITE) + +DPULSE==BIT7 ;PULSE THE KL10 CLOCK +PULSE==BIT4!BIT0 ;SINGLE PULSE THE 10/11 CLOCK (ALSO SETS + ;10/11 DIAGNOSTIC MODE) +DBUSEN==BIT3 ;DIAGNOSTIC BUS ENABLE +DCSRT==BIT3 ;DIAGNOSTIC COMMAND START (NEW NAME FOR DBUSEN) +DSEND==BIT2 ;SEND THE EBUS DURING DIAGNOSTIC FUNCTION +DIKL10==BIT1 ;KL10 DIAGNOSTIC MODE +D1011==BIT0 ;10/11 INTERFACE DIAGNOSTIC MODE + +;BIT ASSIGNMENTS FOR DIAG1 (READ) + +TO10==BIT7 ;INTERFACE MAJOR STATE == TO10 TRANSFER +DEX==BIT6 ; " " " == DEPOSIT OR EXAMINE +TO11==BIT5 ; " " " == TO11 TRANSFER +VEC04==BIT4 ;VECTOR INTERRUPT ADDRESS BIT 4 +VEC03==BIT3 ; " " " " 3 +VEC02==BIT2 ; " " " " 2 + +;BIT ASSIGNMENTS FOR DIAG2 (WRITE) + +EDONES==BIT14 ;SET EBUS DONE +STHOLD==BIT7 ;STAY IN CURRENT MAJOR STATE +CLEAR==BIT6 ;PERFORM DIAGNOSTIC CLEAR + +;BIT ASSIGNMENTS FOR DIAG2 (READ) + +;BIT ASSIGNMENTS FOR DIAG3 (READ) + +RAMIS0==BIT7 ;RFM==0 (ALL ZEROES COMING OUT OF RAM) +RFMAD0==BIT1 ;RFM ADDRESS BIT 0 +RFMAD1==BIT8 ; " " " 1 +RFMAD2==BIT9 ; " " " 2 +RFMAD3==BIT10 ; " " " 3 + +;BIT ASSIGNMENTS FOR STATUS (WRITE) + +DON10S==BIT15 ;SET TO10 DONE +DON10C==BIT14 ;CLEAR TO10 DONE +ERR10S==BIT13 ;SET TO10 ERROR +ERR10C==BIT12 ;CLEAR TO10 ERROR +INT11S==BIT11 ;SET 10 REQ INTERRUPT (INTERRUPTS 11) +INT11C==BIT10 ;CLEAR 10 REQ INTERRUPT (REMOVES INTERRUPT TO 11) +PERCLR==BIT9 ;CLEAR -11 MEMORY PARITY ERROR +INT10S==BIT8 ;SET REQUEST 10 INTERRUPT (INTERRUPTS 10) +DON11S==BIT7 ;SET TO11 DONE +DON11C==BIT6 ;CLEAR TO11 DONE +ERR11S==BIT1 ;SET TO11 ERROR +ERR11C==BIT0 ;CLEAR TO11 ERROR + +;BIT ASSIGNMENTS FOR STATUS (READ) + +TO10DN==BIT15 ;TO10 DONE +PI10OF==BIT14 ;THIS DTE20 IS NOT TRYING TO INTERRUPT THE -10 +TO10ER==BIT13 ;TO 10 ERROR (NPR TIMEOUT OR BUS ERROR) +INTR11==BIT12 ;11 INTERRUPT PENDING +DOOR10==BIT11 ;10 REQUESTING 11 INTERRUPT (DOORBELL FROM 10) +DXWRD1==BIT10 ;DEPOSIT OR EXAMINE WORD ONE +PARERR==BIT9 ;-11 MEMORY PARITY ERROR +DOOR11==BIT8 ;REQUEST 10 INTERRUPT (DOORBELL FROM 11) +TO11DN==BIT7 ;TO11 DONE +EBSEL==BIT6 ;E BUFFER SELECT +NULSTP==BIT5 ;NULL STOP +DEAD10==BIT4 ;KL10 STOPPED +DBUSON==BIT3 ;DIAGNOSTIC BUS ENABLED +DEXDON==BIT2 ;DEPOSIT OR EXAMINE DONE +TO11ER==BIT1 ;TO 11 ERROR (NPR TIMEOUT OR BUS ERROR) + +; FUNCTION SELECT CODES + +STPCLK==010 ; STOP CLOCK +STRCLK==011 ; START CLOCK +SSCLK==014 ; SINGLE STEP THE CLOCK +CLRMR==016 ; CLEAR MR RESET +SETMR==017 ; SET MR RESET +BRCLK==015 ; BURST THE CLOCK +LDCLK==012 ; LOAD CLOCK BURST COUNTER & RATE +CLKCND==101 ; READ CLOCK CONDITION + +LDRAM1==030 ; LOAD D-RAM DATA +LDRAM2==031 +LDRAM3==032 +RDRAMA==131 ; READ D-RAM ADDRESS +RDRAM1==132 ; READ D-RAM DATA +RDRAM2==133 +DRAMAB==132 ; D-RAM A & B +DRAMJ==133 ; D-RAM J + +LCRAM1==040 ; LOAD C-RAM DATA +LCRAM2==041 +LCRAM3==042 +LCRAM4==043 +LCRAM5==044 +LCRAMA==047 ; LOAD C-RAM ADDRESS +RCRAM1==140 ; READ C-RAM DATA AND ADDRESS +RCRAM2==141 ; READ C-RAM DATA +RCRAM3==142 +RCRAM4==143 + +RELCTR==000 ; RELINQUISH CONTROL OF THE TRANSLATOR +DIAGRD==001 ; SET TRANSLATOR IN 10 TO 11 DIRECTION +DIAGLD==002 ; SET TRANSLATOR IN 11 TO 10 DIRECTION +IRLOAD==003 ; ENABLE LOADING OF THE AR & IR REGISTERS +DRLTCH==005 ; LOAD D-RAM LATCHES +CLRRUN==007 ; CLEAR RUN FLIP-FLOP +SETRUN==006 ; SET RUN FLIP-FLOP +CONBUT==004 ; THE CONTINUE BUTTON + +READ0==110 ; PI (READ STATUS 0) +READ1==111 ; PI (READ STATUS 1) +READ2==112 ; PI (READ STATUS 2) +READ3==113 ; PI (READ STATUS 3) + +DPAR==120 ; AR (DATA PATH) +DPBR==121 ; BR +DPMQ==122 ; MQ +DPFM==123 ; FM +DPBRX==124 ; BRX +DPARX==125 ; ARX +DPADX==126 ; ADX +DPAD==127 ; AD +DPFE==133 ; FE +DPSC==131 ; SC +DPERG==157 ; E-BUS REGISTER + +RDPCH==130 ; READ PC 18-26 +RDPCL==131 ; READ PC 27-35 +RDVMAH==132 ; READ VMA 18-26 +RDVMAL==133 ; READ VMA 27-35 + +MCHLTLP==42 ; U CODE HALT LOOP ADDRESS + +.SBTTL *BBD* KL10 EBOX MACRO DEFINITIONS, 4-MAR-75 + +;MACRO TO TURN 36 BIT WORDS INTO 5 UPSIDE DOWN BYTES + +.MACRO WD36 A,B,C + .NLIST SRC + .BYTE <377&C>,<</400>!<*20>>,</20> + .BYTE ,</400> + .LIST SRC +.ENDM + +;PDP10 CPU INSTRUCTION MACRO. TAKES 5 ARGUMENTS AS IN NORMAL +;10 CODE. 5 FIELDS MUST BE PRESENT (4 FIELD SEPARATORS) +;BUT THE AD,AC,I, AND XR FIELDS MAY BE LEFT BLANK AND IF SO, +;WILL ASSEMBLE AS ZERO. THE OP FIELD MUST NOT BE LEFT BLANK. + +.MACRO I10 OP,CAC,CI,CAD,CXR + ADH==0 + ADL==0 + .IF NB CAD + .IRPC AD1,CAD + .IIF GE ,ADH==ADL/10000 + ADL==10*+AD1 + .ENDM + .ENDC + .IIF B CAC,AC==0 + .IIF NB CAC,AC==CAC + .IIF B CI,I==0 + .IIF NB CI,I==CI + .IIF B CXR,XR==0 + .IIF NB CXR,XR==CXR + .NLIST SRC + .BYTE ,<!>,>+> + .BYTE >, + .LIST SRC +.ENDM I10 + +;MACRO TO GENERATE A RIGHT JUSTIFIED 3-BYTE VALUE +;FOR A 22-BIT ARGUMENT + +.MACRO WD22 AD + ADH==0 + ADL==0 + .IRPC AD1,AD + .IIF GE ,ADH==<10*ADH>+ + ADL==10*+AD1 + .ENDM + .NLIST SRC + .BYTE ,<!>, + .LIST SRC +.ENDM WD22 + +;PDP10 I/O INSTRUCTION MACRO. TAKES 5 ARGUMENT AS NOTED ABOVE +;IN THE DESCRIPTION OF THE I10 MACRO. THE 8 I/O OP CODES ARE +;DEFINED AS ARE DEVICE CODES APR, PI, PAG, AND CCA. + +.MACRO IO10 OP,DV,CI,AD,CXR + .IIF B CI,I==0 + .IIF NB CI,I==CI + .IIF B CXR,XR==0 + .IIF NB CXR,XR==CXR + BLKO==2 + DATAO==3 + BLKI==0 + DATAI==1 + CONO==4 + CONI==5 + CONSZ==6 + CONSO==7 + APR==0 + PI==4 + PAG==10 + CCA==14 + ADH==0 + ADL==0 + .IRPC AD1,AD + .IIF GE ,ADH==ADL/10000 + ADL==10*+AD1 + .ENDM + .NLIST SRC + .BYTE ,<!>,>+> + .BYTE >, + .LIST SRC +.ENDM IO10 + +;THIS IS A MACRO TO WAIT FOR A DONE FLAG + +.MACRO WFZERO BITSEL + MOV #2500.,-(SP) ;SET TIMEOUT CNT + 91$: BIT #BITSEL,@.DIAG1 ;TEST BIT + BEQ 92$ ;LEAVE IF BIT ZERO(OK) + DEC (SP) ;DECREMENT CNT + BNE 91$ ;CONTINUE LOOP + TST RPTFLG ;OTHERWISE TIME OUT + BNE 92$ + JSR R1,$DFTIM + 92$: TST (SP)+ ;RESET STACK & CONTINUE +.ENDM + + +;THIS MACRO IS A WAIT FOR FLAG MACRO. +;IT WAITS FOR A TEST BIT TO GO TO ONE +;FROM A ZERO + +.MACRO WFONE BITSEL + MOV #2500.,-(SP) ;SET TIMEOUT CNT + 93$: BIT #BITSEL,@.STDTE ;TEST BIT + BNE 94$ ;LEAVE IF NOW A ONE(OK) + DEC (SP) ;DECREMENT CNT + BNE 93$ ;CONTINUE LOOP + TST RPTFLG ;OTHERWISE TIME OUT + BNE 94$ + JSR R1,$DFTIM + 94$: TST (SP)+ ;RESET STACK +.ENDM + +.NLIST +.ENDC ; DTEBBD +.LIST +.NLIST +.IF DF DVASB +.LIST + +.SBTTL DEVICE SYMBOL DEFINITIONS, 4-JUNE-75 + +; PRIORITY LEVELS FOR SERVICE ROUTINES. + +TPILEV==PR6 ; TERMINAL PRIORITY LEVEL +NXMPIL==PR7 ; "NON-X-MEM" PRIORITY LEVEL +DHRPS==TPILEV ; DH11 RECEIVER PRIORITY +DHTPS==DHRPS ; DH11 TRANSMITTER +DLRPS==DHRPS ; DL11 +DLTPS==DLRPS +KWLPS==DHRPS ; KW11 PRIORITY LEVEL +NXMPS==NXMPIL ; "NON-X-MEM" PRIORITY LEVEL + +; BIT DEFINITIONS FOR THE PARAMETER WORD. + +PDHDNS==11 ; DH11 DEVICE NUMBER SHIFT +PDHDNM==7000 ; DH11 DEVICE NUMBER MASK +PDHLNS==4 ; DH11 LINE NUMBER SHIFT +PDHLNM==360 ; DH11 LINE NUMBER MASK +PDHLSS==0 ; DH11 LINE SPEED SHIFT +PDHLSM==17 ; DH11 LINE SPEED MASK +PDLFCS==PDHLNS ; DL11 FILLER CLASS SHIFT +PDLFCM==PDHLNS ; DL11 FILLER CLASS MASK + +; OTHER DEVICES. + +DP11BA==174770 ; DP11 DEVICE REGISTERS BASE ADDRESS +DP11RS==10 ; DP11 DEVICE REGISTER SIZE +DP11VS==10 ; DP11 INTERRUPT VECTOR SIZE +DM11BA==170500 ; DM11 DEVICE REGISTER BASE ADDRESS +DM11RS==10 ; DM11 DEVICE REGISTER SIZE +DM11VS==4 ; DM11 INTERRUPT VECTOR SIZE +DR11BA==167770 ; DR11 DEVICE REGISTER BASE ADDRESS +DR11RS==10 ; DR11 DEVICE REGISTER SIZE +DR11VS==10 ; DR11 INTERRUPT VECTOR SIZE + +.NLIST +.ENDC ;DVASB +.LIST +.NLIST +.IF DF KWASB +.LIST + +.SBTTL KW11 DEVICE REGISTERS AND BIT DEFINITIONS, 4-JUNE-75 + +KWLIV==100 ; VECTOR ADDRESS + +KWLKS=177546 ; LINE CLOCK STATUS DEVICE ADDRESS + +KWLKE==100 ; LINE CLOCK INTERRUPT ENABLE BIT + +.SBTTL MM11 DEVICE REGISTERS AND BIT ASSIGNMENTS, 4-JUNE-75 + +MMLPIV==114 ;VECTOR ADDRESS + +MMLPBA=172100 ;1ST MM11-LP DEVICE ADDRESS +MMLPEA=172136 ;LAST MM11-LP DEVICE ADDRESS + +MMERRF==BIT15 ;ERROR FLAG + +MMADDM==7740 ;ADDRESS MASK +MMADDS==5 ;ADDRESS SHIFT + +MMWWP==BIT2 ;WRITE WRONG PARITY +MMPIE==BIT0 ;PARITY INTERRUPT ENABLE + +.NLIST +.ENDC ;KWASB +.LIST +.NLIST +.IF DF DLASB +.LIST + +.SBTTL DL11 DEVICE REGISTERS AND BIT DEFINITIONS, 4-JUNE-75 + +DLRIV==60 ; RECEIVER VECTOR ADDRESS +DLTIV==DLRIV+4 ; TRANSMITTER VECTOR ADDRESS +DLBA=177560 ; BASE FOR DEVICE ADDRESSES +DLRCSR==0 ; RECEIVER STATUS REGISTER +DLRBUF==2 ; RECEIVER BUFFER REGISTER +DLXCSR==4 ; TRANSMITTER STATUS REGISTER +DLXBUF==6 ; TRANSMITTER BUFFER REGISTER + +; BIT DEFINITIONS FOR "DLRCSR"- RECEIVER CONTROL STATUS REGISTER. + +DLDSC==BIT15 ; DATA STATUS CHANGE +DLRI==BIT14 ; RING INDICATOR +DLCTS==BIT13 ; CLEAR TO SEND +DLCD==BIT12 ; CARRIER DETECT +DLRA==BIT11 ; RECEIVER ACTIVE +DLSRD==BIT10 ; SECONDARY RECEIVED DATA +DLRD==BIT7 ; RECEIVER DONE +DLRIE==BIT6 ; RECEIVER INTERRUPT ENABLE +DLDIE==BIT5 ; DATA SET INTERRUPT ENABLE +DLSTD==BIT3 ; SECONDARY TRANSMITTED DATA +DLRTS==BIT2 ; REQUEST TO SEND +DLDTR==BIT1 ; DATA TERMINAL READY +DLRE==BIT0 ; READER ENABLE + +; BIT DEFINITIONS FOR "DLRBUF"- RECEIVER BUFFER. + +DLERR==BIT15 ; ERROR +DLORE==BIT14 ; OVERRUN ERROR +DLFE==BIT13 ; FRAMING ERROR +DLRDPE==BIT12 ; RECEIVED DATA PARITY ERROR +DLRDS==0 ; RECEIVED DATA SHIFT +DLRDM==377 ; RECEIVED DATA MASK + +; BIT DEFINITIONS FOR "DLXCSR"- TRANSMITTER CONTROL STATUS REGISTER. + +DLTR==BIT7 ; TRANSMITTER READY +DLTIE==BIT6 ; TRANSMITTER INTERRUPT ENABLE +DLMAIN==BIT2 ; MAINTENANCE +DLBRK==BIT0 ; BREAK + +; BIT DEFINITIONS FOR "DLXBUF"- TRANSMITTER BUFFER. + +DLTDS==0 ; TRANSMITTER DATA SHIFT +DLTDM==377 ; TRANSMITTER DATA MASK + +.NLIST +.ENDC ;DLASB +.LIST +.NLIST +.IF DF DHASB +.LIST + +.SBTTL DH11 DEVICE REGISTERS AND BIT DEFINITIONS, 4-JUNE-75 + +DHIVBA==300 ; INTERRUPT VECTOR BASE ADDRESS +DHRIV==0 ; RECEIVER VECTOR ADDRESS +DHTIV==DHRIV+4 ; TRANSMITTER VECTOR ADDRESS +DHBA==160020 ; BASE FOR DEVICE ADDRESSES +DHSCR==0 ; SYSTEM CONTROL REGISTER +DHNRCR==2 ; NEXT RECEIVER CHARACTER REGISTER +DHLPR==4 ; LINE PARAMETER REGISTER +DHCAR==6 ; CURRENT ADDRESS REGISTER +DHBCR==10 ; BYTE COUNT REGISTER +DHBAR==12 ; TRANSMIT BUFFER ACTIVE REGISTER +DHTBR==14 ; TRANSMIT BREAK REGISTER +DHSSR==16 ; SILO STATUS REGISTER + +; BIT DEFINITIONS FOR "DHSCR"- STATUS CONTROL REGISTER. + +DHTI==BIT15 ; TRANSMITTER INTERRUPT +DHSI==BIT14 ; STORAGE INTERRUPT +DHTNIE==BIT13 ; TRANSMITTER AND NON-X-MEM INTERRUPT ENABLE +DHSIE==BIT12 ; STORAGE INTERRUPT ENABLE +DHMC==BIT11 ; MASTER CLEAR +DHNXM==BIT10 ; NON-X-MEM +DHMAIN==BIT9 ; MAINTENANCE +DHCNXM==BIT8 ; CLEAR NON-X-MEM BIT +DHRI==BIT7 ; RECEIVER INTERRUPT +DHRIE==BIT6 ; RECEIVER INTERRUPT ENABLE +DHMES==4 ; MEMORY EXTENSION SHIFT +DHMEM==60 ; MEMORY EXTENSION MASK +DHLSS==0 ; LINE SELECTION SHIFT +DHLSM==17 ; LINE SELECTION MASK + +; BIT DEFINITIONS FOR "DHNRCR"- NEXT RECEIVER CHARACTER REGISTER. + +DHDP==BIT15 ; DATA PRESENT +DHORE==BIT14 ; OVERRUN ERROR +DHFE==BIT13 ; FRAMING ERROR +DHRDPE==BIT12 ; RECEIVER DATA PARITY ERROR +DHRLNS==10 ; RECEIVER LINE NUMBER SHIFT +DHRLNM==7400 ; RECEIVER LINE NUMBER MASK +DHRDS==0 ; RECEIVER DATA SHIFT +DHRDM==377 ; RECEIVER DATA MASK + +; BIT DEFINITIONS FOR "DHLPR"- LINE PARAMETER REGISTER. + +DHAEE==BIT15 ; AUTO-ECHO ENABLE +DHHD==BIT14 ; HALF-DUPLEX +DHTSS==12 ; TRANSMITTER SPEED SHIFT +DHTSM==36000 ; TRANSMITTER SPEED MASK +DHRSS==6 ; RECEIVER SPEED SHIFT +DHRSM==1700 ; RECEIVER SPEED MASK +DHEP==BIT5 ; EVEN PARITY +DHPE==BIT4 ; PARITY ENABLE +DHTSB==BIT2 ; TWO STOP BITS +DHCLS==0 ; CHARACTER LENGTH SHIFT +DHCLM==3 ; CHARACTER LENGTH MASK +DHCL5==0 ; CHARACTER LENGTH - 5 BITS +DHCL6==1 ; CHARACTER LENGTH - 6 BITS +DHCL7==2 ; CHARACTER LENGTH - 7 BITS +DHCL8==3 ; CHARACTER LENGTH - 8 BITS + +; BIT DEFINITIONS FOR "DHSSR"- SILO STATUS REGISTER. + +DHSFLS==10 ; SILO FILL LEVEL SHIFT +DHSFLM==37400 ; SILO FILL LEVEL MASK +DHREMS==6 ; READ EXTENDED MEMORY SHIFT +DHREMM==300 ; READ EXTENDED MEMORY MASK +DHSALS==0 ; SILO ALARM LEVEL SHIFT +DHSALM==77 ; SILO ALARM LEVEL MASK + +.NLIST +.ENDC ;DHASB +.LIST +.NLIST +.IF DF TAASB +.LIST + +.SBTTL TA11 (CASSETTE) DEVICE REGISTER AND BIT DEFINITIONS, 4-JUNE-75 + +TACS=177500 ;CONTROL AND STATUS REGISTER +TADB=TACS+2 ;DATA BUFFER REGISTER + +TAIV==260 ;INTERRUPT VECTOR + +; BIT ASSIGNMENTS WITHIN THE CONTROL AND STATUS REGISTER + +TAGO==1 ;GO = START OPERATION +TAFUNC==16 ;"FUNCTION TO BE PERFORMED" FIELD +TAWFG==0*2 ;"WRITE FILE GAP" FUNCTION +TAWRIT==1*2 ;"WRITE DATA" FUNCTION +TAREAD==2*2 ;"READ DATA" FUNCTION +TASRF==3*2 ;"SPACE REVERSE FILE" FUNCTION +TASRB==4*2 ;"SPACE REVERSE BLOCK (RECORD)" FUNCTION +TASFF==5*2 ;"SPACE FORWARD FILE" FUNCTION +TASFB==6*2 ;"SPACE REVERSE BLOCK (RECORD)" FUNCTION +TAREWD==7*2 ;"REWIND" FUNCTION +TAILBS==20 ;INITIATE LAST BYTE SEQUENCE +TAREDY==40 ;READY +TAINTE==100 ;INTERRUPT ENABLE +TARQST==200 ;TRANSFER REQUEST +TAUNIT==400 ;UNIT SELECTION +TAOFFL==1000 ;UNIT OFF LINE +TATERR==2000 ;TIMING ERROR (LOST DATA) +TAFGAP==4000 ;FILE GAP +TALOCK==10000 ;WRITE LOCKED +TALEAD==20000 ;CLEAR LEADER +TABCHK==40000 ;BLOCK CHECK (BAD CRC AFTER READ) +TAEROR==100000 ;ERROR (ERROR SUMMARY BIT) + +.NLIST +.ENDC ;TAASB +.LIST +.NLIST +.IF DF RXASB +.LIST + +.SBTTL RX11/RX01 (FLOPPY) REGISTERS AND BIT DEFINITIONS, 22-JULY-75 + +;RX11 STANDARD DEVICE ADDRESSES + +RXCS=177170 ;COMMAND STATUS REGISTER +RXDB=177172 ;DATA BUFFER REGISTER +RXSA=177172 ;SECTOR ADDRESS REGISTER +RXTA=177172 ;TRACK ADDRESS REGISTER +RXES=177172 ;ERROR STATUS REGISTER + +RXIV==264 ;INTERRUPT VECTOR ADDRESS + +;RX11 FUNCTION CODES + +RXFBUF==0 ;FILL BUFFER +RXEBUF==2 ;EMPTY BUFFER +RXWSEC==4 ;WRITE SECTOR +RXRSEC==6 ;READ SECTOR +RXRSTAT=12 ;READ STATUS +RXWDDS==14 ;WRITE DELETED DATA SECTOR +RXRERR==16 ;READ ERROR REGISTER + +;RX11 COMMAND AND STATUS REGISTER BIT DEFINITIONS + +RXGO==1 ;GO +RXU1==20 ;RX01 UNIT # 1 +RXDONE==40 ;DONE +RXIE==100 ;INTERRUPT ENABLE +RXTREQ==200 ;TRANSFER REQUEST +RXINI==40000 ;INITIALIZE +RXERROR==100000 ;ERROR + +;RX11 ERROR STATUS REGISTER BIT DEFINITIONS + +RXCRCE==1 ;CRC ERROR +RXPARE==2 ;PARITY ERROR +RXIDONE==4 ;INITIALIZE DONE +RXDDD==100 ;DELETED DATA DETECTED +RXDRDY==200 ;DRIVE READY + +.NLIST +.ENDC ;RXASB +.LIST +.NLIST +.IF DF TCASB +.LIST + +.SBTTL TC11 (DECTAPE) DEVICE REGISTERS AND BIT DEFINITIONS, 4-JUNE-75 + +;DECTAPE PARAMETERS + +TCILO==BIT12 ;ILLEGAL OPERATION +TCSELE==BIT11 ;SELECTION ERROR +TCIE==BIT6 ;INTERRUPT ENABLE +TCDO==BIT0 ;DO OPERATION +TCRDATA==BIT2 ;READ DATA +TCWDATA==BIT3+BIT2 ;WRITE DATA +TCRNUM==BIT1 ;READ BLOCK NUMBER +TCREV==BIT11 ;REVERSE DIRECTION +TCPAR==BIT14 ;PARITY ERROR +TCBLKM==BIT10 ;BLOCK MISSED +TCDATM==BIT9 ;DATA MISSED +TCMTE==BIT13 ;MARK TRACK ERROR +TCERR==BIT15 ;DECTAPE ERROR +TCRDY==BIT7 ;READY + +TCSOFT==TCPAR+TCBLKM+TCDATM+TCMTE + +TCST=177340 ;STATUS REGISTER +TCCM=177342 ;COMMAND REGISTER +TCCM1=177343 ;COMMAND UPPER BYTE +TCWC=177344 ;WORD COUNT REGISTER +TCBA=177346 ;BUS MEMORY ADDRESS +TCDT=177350 ;DATA REGISTER + +.NLIST +.ENDC ;TCASB +.LIST +.NLIST +.IF DF RPASB +.LIST + +.SBTTL RH11/RP04 REGISTER AND BIT DEFINITIONS, 4-JUNE-75 + +BLKSIZ==256. ;DISK BLOCK SIZE (IN 16-BIT WORDS) +IFESIZ==3 ;INDEX FILE ENTRY SIZE (IN 16-BIT WORDS) +FDESIZ==16. ;FILE DIRECTORY ENTRY SIZE (IN 16-BIT WORDS) + +RPCS1==0 ;OFFSET TO RH11/RP04 CONTROL & STATUS REGISTER 1 +RPTRE==BIT14 ;"TRANSFER ERROR" BIT IN RPCS1 +RPMCPE==BIT13 ;"MASSBUS CONTROL BUS PARITY ERROR" BIT IN RPCS1 +RPDVA==BIT11 ;"DRIVE AVAILABLE" BIT IN RPCS1 +RPRDY==BIT7 ;"CONTROLLER READY" BIT IN RPCS1 +RPPRST==21 ;READ-IN PRESET FUNCTION IN RPCS1 +RPPACK==23 ;PACK ACKNOWLEDGE (SET VV) FUNCTION IN RPCS1 +RPWTFN==61 ;WRITE DATA FUNCTION IN RPCS1 +RPRDFN==71 ;READ DATA FUNCTION IN RPCS1 + +RPWC==2 ;OFFSET TO RH11/RP04 WORD COUNT REGISTER + +RPBA==4 ;OFFSET TO RH11/RP04 UNIBUS ADDRESS REGISTER + +RPDA==6 ;OFFSET TO RH11/RP04 TRACK & SECTOR ADDRESS REGISTER + +RPCS2==10 ;OFFSET TO RH11/RP04 CONTROL & STATUS REGISTER 2 +RPCLR==BIT5 ;"CONTROLLER (AND MASSBUS) CLEAR" BIT IN RPCS2 + +RPDS==12 ;OFFSET TO RH11/RP04 DRIVE STATUS REGISTER +RPATA==BIT15 ;"ATTENTION ACTIVE" BIT IN RPDS +RPERR==BIT14 ;"COMPOSITE ERROR" BIT IN RPDS +RPMOL==BIT12 ;"MEDIUM ON-LINE" BIT IN RPDS +RPDPR==BIT8 ;"DRIVE PRESENT" BIT IN RPDS +RPDRY==BIT7 ;"DRIVE READY" BIT IN RPDS +RPVV==BIT6 ;"VOLUME VALID" BIT IN RPDS + +RPOF==32 ;OFFSET TO RH11/RP04 OFFSET REGISTER (CONTAINING FMT22) +RPFMT==BIT12 ;"FMT22" (16-BIT WORDS) BIT IN RPOF +RPECI==BIT11 ;"ERROR CORRECTION CODE INHIBIT" BIT IN RPOF + +RPDC==34 ;OFFSET TO RH11/RP04 DESIRED CYLINDER REGISTER + +.NLIST +.ENDC ;RPASB +.LIST +.NLIST +.IF DF LPASB +.LIST + +.SBTTL LP20 REGISTER AND BIT DEFINITIONS, 27-JUNE-75 + +LP20A=177440 ;LP20 1ST CONTROLLER ADDRESS +LP20B=177460 ;LP20 2ND CONTROLLER ADDRESS +LPAVEC==210 ;LP20A INTERRUPT VECTOR +LPBVEC==200 ;LP20B INTERRUPT VECTOR + +LPCSRA==0 ;OFFSET TO LP20 PRIMARY STATUS REGISTER +LPERR==BIT15 ;"ERROR" BIT IN LPCSRA +LPPZRO==BIT14 ;"PAGZRO" BIT IN LPCSRA +LPUCHR==BIT13 ;"UNDCHR" BIT IN LPCSRA +LPVRDY==BIT12 ;"UNDCHR" BIT IN LPCSRA +LPONLN==BIT11 ;"ONLINE" BIT IN LPCSRA +LPDELH==BIT10 ;"DELHLD" BIT IN LPCSRA +LPLINI==BIT9 ;"LOINIT" BIT IN LPCSRA +LPRERR==BIT8 ;"RSTERR" BIT IN LPCSRA +LPDONE==BIT7 ;"DONE" BIT IN LPCSRA +LPIENB==BIT6 ;"INTENB" BIT IN LPCSRA +LPBA17==BIT5 ;"BUSA17" BIT IN LPCSRA +LPBA16==BIT4 ;"BUSA16" BIT IN LPCSRA +LPVLOD==BIT3 ;"VFULOD" BIT IN LPCSRA +LPTMOD==BIT2 ;"TSTMOD" BIT IN LPCSRA +LPPENB==BIT1 ;"PARENB" BIT IN LPCSRA +LPGO==BIT0 ;"GO" BIT IN LPCSRA + +LPCSRB==2 ;OFFSET TO LP20 ERROR AND TEST REGISTER +LPTPBT==BIT12 ;"LPTPBT" BIT IN LPCSRB +LPT02==BIT10 ;"TEST02" BIT IN LPCSRB +LPT01==BIT9 ;"TEST01" BIT IN LPCSRB +LPT00==BIT8 ;"TEST00" BIT IN LPCSRB +LPOFFL==BIT7 ;"OFFLIN" BIT IN LPCSRB +LPVERR==BIT6 ;"VFUERR" BIT IN LPCSRB +LPTPAR==BIT5 ;"LPTPAR" BIT IN LPCSRB +LPMPAR==BIT4 ;"MEMPAR" BIT IN LPCSRB +LPRPAR==BIT3 ;"RAMPAR" BIT IN LPCSRB +LPSYNT==BIT2 ;"SYNTIM" BIT IN LPCSRB +LPDEMT==BIT1 ;"DEMTIM" BIT IN LPCSRB +LPGOER==BIT0 ;"GOERR" BIT IN LPCSRB + +LPBSAD==4 ;OFFSET TO LP20 DMA BUS ADDRESS REGISTER + +LPBCTR==6 ;OFFSET TO LP20 DMA BYTE COUNTER REGISTER + +LPPCTR==10 ;OFFSET TO LP20 PAGE COUNTER REGISTER + +LPRAMD==12 ;OFFSET TO LP20 RAM DATA REGISTER + +LPCBUF==14 ;OFFSET TO LP20 CHAR BUFFER REGISTER (BYTE) +LPCCTR==15 ;OFFSET TO LP20 COLUMN COUNTER REGISTER (BYTE) + +LPCKSM==16 ;OFFSET TO LP20 CHECKSUM REGISTER (BYTE) +LPPDAT==17 ;OFFSET TO LP20 PRINTER DATA REGISTER (BYTE) +.NLIST +.ENDC ;LPASB +.LIST + \ No newline at end of file diff --git a/src/kldcp/rp0411.4 b/src/kldcp/rp0411.4 new file mode 100755 index 00000000..9d75b771 --- /dev/null +++ b/src/kldcp/rp0411.4 @@ -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 + 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 #--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 #,(R1) + BNE 2$ ;-4 ERROR, DRIVE ERROR + + DEC R0 + BIT #,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 #--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 #,(R1) + BEQ 1$ ;WAIT FOR COMPLETION OR ERROR + + BIT #,(R1) + BNE 2$ ;ERROR + + BIT #,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 diff --git a/src/kldcp/sbst11.10 b/src/kldcp/sbst11.10 new file mode 100755 index 00000000..c6dd7964 --- /dev/null +++ b/src/kldcp/sbst11.10 @@ -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 + \ No newline at end of file diff --git a/src/kldcp/sub11.14 b/src/kldcp/sub11.14 new file mode 100755 index 00000000..456469b2 --- /dev/null +++ b/src/kldcp/sub11.14 @@ -0,0 +1,2152 @@ +;;;MODIFICATION HISTORY +;;; +;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7) +;;; 15 NOV 75 CONVERTED TO PALX FORMAT +;;; 19 DEC 75 BUG FIXES, BREAK, LA36 +;;; 30 MAR 76 MODIFIED TO COEXIST WITH ITS IOELEVEN PROGRAM + +.SBTTL BASIC INITIALIZATION ROUTINE, 19-AUG-75 + +;*THIS SUBROUTINE PERFORMS THE MOST ELEMENTARY SET UP FOR THE CPU +;*THIS ROUTINE MUST BE EXECUTED BY ALL OF THE POSSIBLE START +;*OPTIONS PRIOR TO ANY OTHER SUBROUTINE + +$$ILOAD:RESET ;DISABLE ALL DEVICES FROM INTERRUPTING + MOV #STACK,SP + MOV #<<.DELAY-$ILDCLR>/2>,R1 + MOV #$ILDCLR,R0 +1$: CLR (R0)+ ;CLEAR SPECIAL CONTROL WORDS + DEC R1 + BGT 1$ + MOV #17,CLKDFL+4 ;INITIAL DEFAULT, ALL 4 CACHES + MOV #36,PEBITS ;INITIAL DEFAULT, AR/ARX, FM, CRAM, DRAM + ;AND NOT FS PROBE, PARITY STOP ENABLES + JSR PC,$CKSUM ;CHECKSUM "KLDCP" + MOV R0,$ILDSUM ;SAVE + +$SBRINT:MOV #STACK,SP ;SET THE STACK POINTER + TST ITSFLG + BNE 11$ ;IF IOELEV IN, DON'T CLOBBER VECTORS + CLR PID ;CLOBBERING VECTORS, IT'S ALL + ;OVER FOR ANY PROGRAM IN LOW CORE +.IF DF %%DDT + MOV @#14,-(SP) ;IF DDT IS IN CORE, DON'T WIPE OUT BPT VEC + MOV @#16,-(SP) +.ENDC + MOV #PR7,PS ;SET CPU TO PR7 + CLR R0 ;SET ENTIRE VECTOR AREA TO: +1$: MOV #$FATLE,(R0)+ ; ;ADDRESS OF ERROR HANDLER + MOV #PR7,(R0)+ ; ;PR7 + CMP R0,#1000 + BLT 1$ + + MOV #$TIMOT,@#ERRVEC ;TIME OUT BUS ERROR VECTOR + MOV #$RESVD,@#RESVEC ;RESERVED INSTRUCTION VECTOR + MOV #$PWRDN,@#PWRVEC ;POWER FAIL VECTOR + MOV #$BRKPT,@#IOTVEC ;IOT VECTOR + MOV #$EMTRP,@#EMTVEC ;EMT VECTOR + +.IF NDF %%DDT + MOV #.BCCT,@#BPTVEC ;SET BP VECTOR +.IFF + MOV (SP)+,@#16 ;SET UP FOR DDT + MOV (SP)+,@#14 ;WE WON'T BE USING THE KLDCP BREAKPOINTS, PROBABLY +.ENDC +11$: MOV #BUFCLR,R0 ;CLEAR BUFFER STORAGE BETWEEN: +21$: CLR (R0)+ ;BUFCLR: AND $ILDCLR: + CMP R0,#$ILDCLR + BNE 21$ + MOV SP,$KONSP + + CLR CONSOL-2 + + TTPINI ;RESET TTY POINTERS + + MOV #120.,$PGWID ;SET PAGE WIDTH FOR LA36 + MOV #0,$TTYFL ;SET FILL PARAMETER FOR LA36 + PFORCE ;MUST TYPE STARTUP + + MOV #NOPAR,ERRVEC ;SET BUS TIMEOUT IN CASE NO PARITY + MOV #MEMPE,MMLPIV ;SETUP PARITY VECTOR + MOV #MMPIE,MMLPBA ;ENABLE PARITY ERRORS + MOV #$TIMOT,ERRVEC ;RESTORE BUS TIMEOUT + + TST $ONETM + BNE 3$ + + JSR PC,.CB ;CLEAR BP'S + + PMSG <\DECSYSTEM10 DIAGNOSTIC CONSOLE\VERSION > + MOV #MCNVER,R0 + PNTOCS + PNTCI + '. + MOV #DECVER,R0 + PNTOCS + PMSG <, MIT VERSION > + MOV #MITVER,R0 + PNTDEC + PMSG <\11 SWR = > + MOV SWR,R0 + PNTOCT ;PRINT CONSOLE SWITCHES + PCRLF + +3$: JSR PC,DTEINI ;DTE20 INITIALIZATION + + TST DEVTYP ;USING RP04 ? + BLE 4$ ;NO + RPLOAD ;YES, INIT & LOAD PACK + BCC 4$ + RPERROR ;FAILED + +4$: JMP CONSL ;NOW TO CONSOLE + +NOPAR: RTI ;NO PARITY REGISTER + +$CMCLR: MOV #$CMTAG,R0 ;CLEAR COMMON STORAGE +1$: CLR (R0)+ + CMP R0,#MONCTL + BLT 1$ + RTS PC + +$CKSUM: CLR $KDCEN ;CLEAR ONLY CHANGEABLE LOCATION + MOV #START,R1 + CLR R0 +2$: ADD (R1)+,R0 ;CHECKSUM "KLDCP" + CMP R1,$$FF + BLOS 2$ + RTS PC + +.SBTTL SET EOP INTERVAL TALLY + +$EOPSET:MOV R0,$ENDCT ;SET EOP INTERVAL TALLY + EXIT + +;CONSOLE SET EOP INTERVAL + +.EP: TTISDL + BCS 1$ + TTIDEC ;SPECIFIED AS DECIMAL INTERVAL + BCS 1$ + MOV R0,$ENDCT + CLR $EOPCT + JMP $KONSL +1$: JMP $PARAM + +.SBTTL END OF PASS ROUTINE + +$EOP: MOV #$PASS,R5 + INC (R5) ;INCREMENT THE PASS NUMBER + CMP (R5),#30001. ;LIMIT MAX COUNT TO 30000 + BLT 4$ + CLR (R5) + INC (R5) + MOV $ENDCT,$EOPCT ;RESET REPORT INTERVAL + +4$: MOV (R5),SWR ;DISPLAY PASS COUNT + SWITCH ;READ THE SWITCH REGISTER + + BIT R0,#ABORT ;ABORT AFTER CURRENT PASS? + BNE 1$ ;YES + + DEC $EOPCT ;DECREMENT EOP + BGT 3$ + BR 2$ + +1$: MOV #1,$ITERA ;SET ITERATION SO WE WILL EXIT + +2$: PMSG + + MOV (R5),R0 ;PASS COUNT TO R0 + PNTDEC + PCRLF + + MOV $ENDCT,$EOPCT ;RESTORE COUNTER + +3$: DEC $ITERA ;DECREMENT ITERATION COUNT + BEQ $ERREOP + CLR $ITERA + EXIT + +.SBTTL ERROR EOP + +$ERREOP:TST MONCTL ;STAND ALONE ? + BNE $EROP ;NO, *WHAT TO DO ??* + CLR TENRUN ;TURN OFF TEN SUPPORT + CLR PRGRUN ;YES, ALLOW "J" AGAIN + +$EROP: JMP CONSL ;MONITOR, TO NEXT SCRIPT ENTRY + +.SBTTL ERROR HALT + +$PRGHLT:PUSH R0 + PMSG <\PRG> + BR $PH2 + +$ERRHLT:PUSH R0 + SWITCH + BIT R0,#ERSTOP ;STOP ON ERROR ? + BNE 1$ ;YES + POP R0 + EXIT ;NO, KEEP GOING + +1$: PMSG <\ERROR> + +$PH2: SETFLG + .HCFLG ;ALLOW HALT CONTINUE + +$PH1: MOV (SP)+,$R0SAV ;SETUP SO "RG" CAN PRINT + MOV (SP)+,$R5SAV + MOV (SP)+,$R4SAV + MOV (SP)+,$R3SAV + MOV (SP)+,$R2SAV + MOV (SP)+,$R1SAV + MOV (SP)+,.HCADR + MOV (SP)+,$PSSAV + MOV SP,$SPSAV + PMSG < HALT AT > + + MOV .HCADR,R0 ;GET ADDRESS + SUB #2,R0 ;COMPUTE ACTUAL ADDRESS + PNTOCT ;PRINT ERROR HALT ADDRESS + PCRLF + JMP $CONSL ;RETURN TO MONITOR + +.HC: TST .HCFLG + BNE 1$ + JMP $CMDER ;HC NOT ALLOWED +1$: CLR .HCFLG + JSR PC,.BCHC + MOV $SPSAV,R6 + MOV $PSSAV,PS + JMP @.HCADR + +.SBTTL PRINT ASCIZ MESSAGE (PNTAL) + +$PNTAL: BICB #200,(R0) ;CLEAR JUNK + TSTB (R0) ;REACHED EOL YET? + BEQ 3$ ;YES + TST HLPPNT ;PRINTING A HELP FILE + BNE 4$ ;YES + CMPB (R0),#BKARW ;BACKARROW (-)? + BEQ 2$ ;YES + CMPB (R0),#BKSLH ;BACKSLASH (\)? + BEQ 1$ +4$: MOVB (R0)+,R1 ;PUT CHAR IN R1 + PLDBUF ;LOAD INTO OUTPUT BUFFER + BR $PNTAL ;DO TILL E-O-L + +1$: MOV #CR,R1 ;BACKSLASH + PLDBUF ;OUTPUT CR & LF + MOV #LF,R1 + PLDBUF +11$: INC R0 + BR $PNTAL + +2$: CLR CTRLOF ;CLEAR CONTROL O FLAG + PRINTT ;BACKARROW, PRINT BUFFER + BR 11$ + +3$: BR $$PNTX + +.SBTTL PRINT ASCII NUMBER (PNTNBR) + +$PNTNBR:BIC #177770,R0 + BIS #'0,R0 + +.SBTTL PRINT ASCII CHARACTER (PNTCHR) + +$PNTCHR:MOVB R0,R1 + PLDBUF +$$PNTX: EXIT + +$PSPACE: MOV #SPACE,R0 + BR $PNTCHR + +$PSLASH: MOV #SLASH,R0 + BR $PNTCHR + +$PCOMMA: MOV #COMMA,R0 + BR $PNTCHR + +$PTAB: MOV #TAB,R0 + BR $PNTCHR + +.SBTTL PRINT BUFFER LOAD ROUTINE + +$PLDBUF:PUSH R0 + MOV $OUTPT,R0 + BIC #177600,R1 ;STRIP TO 7 BITS + MOVB R1,(R0)+ ;PUT CHAR IN BUFFER + CLRB (R0) ;INSERT TRAILING NULL + MOV R0,$OUTPT + POP R0 + CMP $OUTPT,#$OUTBF+140.;EXCEEDED BUFFER CAPACITY + BGE 2$ + +1$: CMPB #LF,R1 ;WAS CHAR LINE FEED + BEQ 2$ ;YES + CMPB #BELL,R1 ;WAS CHAR BELL ? + BEQ 2$ ;YES + CMPB #NULL,R1 ;WAS CHAR NULL ? + BEQ 2$ ;YES +3$: BR $$PNTX ;NO, RETURN + +2$: TST PCMDNF ;DOING NO PRINT PROGRAM COMMAND + BNE 3$ + PLPT ;LINE PRINTER + PRINTT ;PRINT BUFFER + CLR $TTLKF ;CLEAR TTLOOK FLAG + PUSH R0 + PNTRST ;RESET OUTPUT POINTERS + POP R0 + BR 3$ + +;PRINT, BACKUP OUTPUT INSERTION POINTER + +$PNTBAK:CMP $OUTPT,#$OUTBF ;ALL THE WAY BACK ? + BLE 1$ ;YES + DEC $OUTPT ;NO, BACKUP ONE BYTE +1$: BR $$PNTX + +;TELETYPE POINTER INITIALIZATION + +$TTPINI:MOV #$INBUF,$INPTC + MOV #$INBUF,$INPTR + +$PNTRST:MOV #$OUTBF,R0 + MOV R0,$OUTPT + MOV R0,$OUTPP + BR $$PNTX + +.SBTTL TELETYPE PRINT OUTPUT ROUTINE + +$PRINT: PUSH R0 + TST $FORCE ;FORCED PRINT OUT + BNE 19$ ;YES BYPASS SWITCH TEST + + TSTB LPTFLG ;PRINT ON LPT ? + BNE 99$ ;BR IF YES + + SWITCH + BIT R0,#NOPNT ;PRINTOUT INHIBITED + BEQ 1$ + +99$: MOV $OUTPT,$OUTPP ;DONE, SET PRINTED TO POSITION + POP R0 + BR $$PNTX ;RETURN + +19$: CLR CTRLOF ;CLEAR CONTROL O FLAG +1$: MOV $OUTPP,R1 + +11$: CMPB #CR,(R1) ;IS CHAR CR? + BEQ 2$ ;BR IF YES + CMP $PRNTH,$PGWID ;NO,ARE WE AT RIGHT MARGIN + BLT 3$ ;BR IF NO + MOVB #CR,R0 ;YES, FREE CR/LF + PTTY + MOVB #LF,R0 + PTTY + +2$: INC $TPLIT ;COUNT LINE + +3$: MOVB (R1),R0 ;GET CHARACTER + BEQ 99$ ;IF NULL, DONE + PTTY ;PRINT CHAR + TSTB (R1)+ ;LOOP TILL E-O-L + BNE 11$ +4$: JSR PC,C10COP + JSR PC,$TORDY ;THEN WAIT FOR TTY TO BE READY + BCS 4$ + BR 99$ + +.SBTTL TELETYPE DRIVER + +$PTTY: CLR R2 + CLR R3 +1$: JSR PC,$PTTYC ;DO OPERATOR CHECKS + TST R3 ;R3 = 0 IF NOTHING + BEQ 4$ +2$: CMPB #XON,R3 + BEQ 6$ ;XON,PRINT + CMPB #XOFF,R3 + BNE 4$ +3$: MOV #-1,R2 ;XOFF,STOP PRINT +4$: TST R2 + BNE 1$ ;IF XOFF, WAIT FOR XON +6$: TST CTRLOF ;CONTROL O'D ? + BNE 7$ ;YES + CMPB #CR,R0 ;CR + BNE 7$ + TST $TPLIN ;YES, IN PAGE MODE + BEQ 7$ ;NO + CMP $TPLIT,$TPLIN ;FILLED THIS PAGE + BLT 7$ + CLR $TPLIT ;YES,CLEAR COUNTER,XOFF + BR 3$ + +7$: CLR R2 + CMPB #CNTRLI,R0 ;IS CHAR A TAB? + BNE 10$ +8$: JSR PC,$PTTY1 ;COMPUTE SPACES COUNT +9$: INC R2 ;COMPLETED "TAB"? + MOVB #BLANK,R0 + +10$: CMPB #33,R0 ;IS IT ALTMODE? + BNE 101$ + MOV #'$,R0 ;YES, CHANGE INTO DOLLAR SIGN +101$: JSR PC,C10COP ;PERFORM CLOCK OPERATIONS + TST CTRLOF + BNE 11$ + JSR PC,$TORDY ;WAIT TILL TTY IS READY + BCS 10$ + MOVB R0,$TOCHR ;PRINT CHAR + JSR PC,$TOOUT +19$: JSR PC,$PTTY2 ;WILL CHAR MOVE PRINT HEAD ? + +11$: TST R2 ;DOING SPACES? + BNE 9$ ;BR IF YES + + TST CTRLOF + BNE 15$ + MOV #$DTBL0,R2 ;FILLER PROCESS +12$: TSTB (R2) + BEQ 15$ ;BR IF CHAR DOESN'T REQUIRE FILLS + CMPB (R2)+,R0 + BNE 12$ + DEC R2 ;FOUND + SUB #$DTBL0,R2 + ASL R2 + MOV $DTBL1(R2),R2 ;ADDRESS TO R2 + ADD $TTYFL,R2 ;ADD FILL PARAMETER + MOVB (R2),R2 ;R2 = NUMBER OF FILLS + CMPB R0,#CR ;CR? + BNE 13$ ;NO + CMP $PRNTH,#15. ;MORE THEN 15 CHARS ON LINE ? + BGT 16$ + SR R2,1 ;NO, 1/4 TH OF FILLERS THEN +16$: CMP $PRNTH,#40. ;MORE THAN 40 CHARS ON LINE ? + BGT 17$ + SR R2,1 ;NO, 1/2 OF FILLERS THEN +17$: CLR $PRNTH ;SET PRINT HEAD TO LEFT MARGIN + +13$: DEC R2 ;COMPLETED FILLERS? + BLT 15$ +14$: JSR PC,C10COP ;PERFORM CLOCK OPERATIONS + JSR PC,$TORDY + BCS 14$ + MOVB #NULL,$TOCHR ;SEND FILLER + JSR PC,$TOOUT + BR 13$ +15$: EXIT ;RETURN + +$PTTY1: MOV $PRNTH,R2 ;HEAD POSITION +1$: SUB #8.,R2 ;DIVIDED BY 8 + BGE 1$ ;REMAINDER IS SPACES COUNT + RTS PC + +$PTTY2: CMPB R0,#BLANK ;WILL CHAR MOVE PRINT HEAD? + BLT 1$ ;BR IF NO + INC $PRNTH ;YES +1$: RTS PC + +.SBTTL LINE PRINTER DRIVER + +.IF DF LPASB +$PLPT: PUSH R0 + TST LPTFLG ;PRINT ON LPT ? + BPL 99$ ;NO + TSTB LPTFLG + BEQ 99$ + TST $FORCE ;FORCED PRINT ? + BNE 1$ ;YES, BYPASS SWITCH TEST + SWITCH + BIT R0,#NOPNT ;PRINTOUT INHIBITED ? + BEQ 1$ ;NO +99$: POP R0 + EXIT ;RETURN + +1$: TST LPTYPE ;LP20 OR LP11 ? + BNE 50$ ;LP20 + TST @$LPS ;IS LPT OK ? + BMI 4$ ;BR IF ERROR + MOV #$OUTBF,R1 +2$: MOVB (R1)+,R0 ;GET CHAR + BEQ 99$ ;NULL, DONE +3$: CLR R2 + CMPB #CNTRLI,R0 ;TAB ? + BNE 41$ + JSR PC,$PTTY1 ;YES, COMPUTE SPACES COUNT +42$: INC R2 + MOV #BLANK,R0 +41$: JSR PC,$PTTYC ;DO OPERATOR CHECKS +32$: TST @$LPS ;LPT OK ? + BMI 4$ ;NO + JSR PC,C10COP ;PERFORM CLOCK OPERATIONS + TSTB @$LPS ;LPT READY ? + BPL 41$ ;NO + MOVB R0,@$LPB ;PRINT CHARACTER + JSR PC,$PTTY2 ;WILL CHAR MOVE PRINT HEAD ? +45$: TST R2 ;COMPLETED "TAB" ? + BNE 42$ +43$: CMPB R0,#CR + BNE 44$ + CLR $PRNTH ;IF CR, RESET HEAD POSITION +44$: BR 2$ + +4$: MOV #$LPTOF,R1 ;"LPT OFF LINE" +5$: MOVB (R1),R0 + PTTY + TSTB (R1)+ + BEQ 6$ + BR 5$ +6$: CLRB LPTFLG ;PRINT ON TTY TILL RESELECTED + BR 99$ + +50$: MOV LPTYPE,R5 ;LP20 DRIVER ROUTINE + MOV #LPLINI!LPRERR,(R5) ;CLEAR LP20 + DEC LPPCTR(R5) ;CLEAR PAGE COUNTER + MOV #$OUTBF,R0 ;GET BUFFER ADDRESS + MOV R0,LPBSAD(R5) ;SETUP LP20 BUFFER ADDRESS + SUB $OUTPT,R0 ;COMPUTE BYTE COUNT + MOV R0,LPBCTR(R5) ;SETUP LP20 BYTE COUNT + MOV #LPPENB!LPGO,(R5) ;START XFER + JSR PC,LP20DN ;WAIT FOR DONE + BCS 4$ ;ERROR + BR 99$ ;DONE + +LP20DN: JSR PC,C10COP ;PERFORM CLOCK OPERATIONS + BIT #LPERR!LPPZRO!LPUCHR!LPDONE,(R5) + BEQ LP20DN ;WAIT FOR DONE OR ERROR + + TSTB (R5) ;DONE ? + BPL 1$ ;NO, ERROR + CLC + RTS PC ;DONE, C-BIT CLEAR RETURN + +1$: SEC + RTS PC ;ERROR, C-BIT SET RETURN + +$LPTOF: .ASCIZ /LPT OFF +/ +.EVEN + +.ENDC ;LPASB +.IELSE $PLPT: EXITERR + +;OPERATOR INTERRUPT TYPEIN CHECKS + +$PTTYC: CLR R3 + TST $TTLKF ;INPUT CHECKS INHIBITED ? + BNE 5$ ;YES + JSR PC,$TIRDY ;ANY OPERATOR ACTION ? + BCS 5$ ;NO + MOVB $TICHR,R3 + MOV R3,$TNCHR + TENCHR ;SEND CHAR TO TEN + CMPB #CNTRLC,R3 ;CONTROL C ? + BNE 3$ + TTPINI ;FLUSH REST OF OUTPUT + TST PCMDFLG ;DOING PROGRAM COMMAND ? + BNE 2$ ;YES + JMP $TICC ;CONTROL C, RETURN TO CONSOLE + +2$: JMP PCMDE2 ;PROGRAM COMMAND, RETURN TO CALLER + +3$: CMPB #CNTRLO,R3 + BNE 1$ + COM CTRLOF ;CONTROL O, STOP OUTPUT + MOV #$PTCO,R3 +10$: JSR PC,C10COP + JSR PC,$TORDY + BCS 10$ + MOVB (R3)+,$TOCHR + BNE 90$ + CLR R3 + BR 5$ +90$: JSR PC,$TOOUT + BR 10$ +1$: CMPB #CNTRLL,R3 ;CONTROL L, CHANGE LPT SELECTION + BNE 4$ + TST LPTFLG + BPL 4$ + COMB LPTFLG ;ONLY IF SELECTED +4$: CMPB #CNTRLX,R3 ;CONTROL X, CONSOLE COMMAND + BNE 5$ + JMP $TICX ;DO "TTILIN" & GO TO "$RPT" +5$: RTS PC + +$PTCO: .ASCIZ /^O +/ +.EVEN + +.SBTTL PRINT CRLF + +$PCRLF: PMSG <\> + BR $$PEX + +.SBTTL RING TTY BELL + +$PBELL: MOVB #BELL,R0 + PTTY ;DING THE BELL DIRECTLY + BR $$PEX + +.SBTTL PRINT SPECIFIED OCTAL DIGITS + +$PODT: MOV @$EMADR,R1 ;TRAILING PARAMETER + ADD #2,12(SP) + +$PNTODC:MOV R1,R2 ;SETUP DIGIT COUNT + BGT 1$ + FATAL +1$: CMP R1,#6 + BLE 2$ + FATAL +2$: MOV #$TTSAV+2,R1 + CLR (R1) ;SETUP OCTAL NUMBER + MOV R0,-(R1) + JSR PC,$PODMV ;SETUP PARAMETERS + CLR $0FLG ;NO SPACE FOLLOWING NUMBER + MOVB $PODCD-1(R2),R3 ;GET PRESET SHIFT COUNT + PROL36 ;PRESET NUMBER + BR $P23X ;GO PRINT NUMBER + +$PODCD: .BYTE 33.,30.,27.,24.,21.,18. + +.SBTTL PRINT PDP-10 ADDRESS + +;PRINTS 23 BIT FORMAT IF ANY OF 13-17 ADDRESS BITS ARE SET. +;OTHERWISE PRINTS 18 BIT FORMAT. + +$PADR: JSR PC,$$P23 + BIT #174,4(R1) ;ANY OF 13-17 SET ? + BNE $P23Y ;YES + MOV #6,R3 + PROL36 ;NO, DUMP HI-ORDER BITS + BR $P18X ;PRINT 18 BITS + +$$P23: JSR PC,$P36MV + MOV #12.,R3 + PROL36 ;POSITION 23 BITS + BIC #177600,4(R1) ;CLEAR UPPER JUNK BITS + RTS PC + +.SBTTL PRINT LOWER 18 BITS OF 36 BIT NUMBER + +$PNT18: JSR PC,$P36MV + + MOV #18.,R3 + PROL36 ;SHIFT LOWER 18 BITS TO UPPER + BR $P18X + +.SBTTL PRINT LOWER 23 BITS OF 36 BIT NUMBER + +$PNT23: JSR PC,$$P23 + +$P23Y: MOV #2,R2 + INC R4 + BR $P23X + +.SBTTL PRINT 36 BIT NUMBER IN BINARY + +$P36B: JSR PC,$P36MV + COM R5 + BR $P36BX + +.SBTTL PRINT 36 BIT NUMBER + +$PNT36: JSR PC,$P36MV +$P36BX: INC R4 +$P18X=. + +2$: MOV #6,R2 +$P23X=. +1$: MOV #3,R3 + + PROL36 ;ROTATE 3 + JSR PC,$PRT36 ;PRINT OCTAL + + DEC R2 ;FINISHED HALF WORD YET ? + BNE 1$ + + TST $0FLG + BEQ 3$ + PSPACE + +3$: DEC R4 ;FINISHED FULL WORD YET ? + BPL 2$ + +$$PEX: EXIT + +$PRT36: MOV 4(R1),R0 ;GET THE WORD + SWAB R0 + TST R5 + BNE 1$ + PNTNBR ;PRINT OCTAL + RTS PC + +1$: PUSH R4 + MOV R0,R4 + MOV #177776,R3 + SR R0,2 + BIC R3,R0 + PNTNBR ;PRINT HI-BIT OF OCTAL + MOV R4,R0 + SR R0,1 + BIC R3,R0 + PNTNBR ;PRINT MIDDLE-BIT OF OCTAL + MOV R4,R0 + BIC R3,R0 + PNTNBR ;PRINT LO-BIT OF OCTAL + PSPACE + POP R4 + RTS PC + +$P36MV: MOV #6,R3 ;MOVE 6 BYTES + MOV #$TTSAV,R2 ;TO SETUP DATA + MOV R2,R1 +1$: MOVB (R0)+,(R2)+ + DEC R3 + BNE 1$ +$PODMV: CLR R5 + CLR R4 + MOV #4,R3 + MOV R3,$0FLG ;SET SPACE FLAG + PROL36 ;PRESET NUMBER + RTS PC + +$PROL36:ROL (R1) + ROL 2(R1) + ROL 4(R1) + DEC R3 + BNE $PROL36 + BR $$PEX + +.SBTTL PRINT OCTAL + +$PNTOCT:MOV #-1,R4 ;PRINT OCTAL + BR $PNTO + +.SBTTL PRINT OCTAL ZERO SUPRRESS + +$PNTOSC:CLR R4 ;PRINT OCTAL ZERO SUPPRESS +$PNTO: MOV #6,R1 ;SET FOR 6 DIGITS + MOV R0,R2 ;SAVE INPUT NUMBERS + CLR R5 ;CLEAR THE ZERO FILL FLAG + TST R4 ;ZERO SUPPRESS ? + BNE 10$ ;NO + TST R0 ;TEST FOR A ZERO INPUT NUMBER + BNE 1$ + CLR R1 ;INPUT = 0 PRINT AND EXIT + BR 5$ + +10$: INC R5 +1$: CLR R0 + ROL R2 ;MSD TO C BIT + BR 3$ + +2$: ROL R2 + ROL R2 + ROL R2 + MOV R2,R0 +3$: ROL R0 + + BIC #177770,R0 ;GET RID OF JUNK + BEQ 4$ + INC R5 ;SET ZERO FILL FLAG + +4$: TST R5 ;SUPPRESS ? + BEQ 6$ +5$: PNTNBR ;PRINT DIGIT +6$: DEC R1 + BGT 2$ + + TST R4 + BEQ 7$ + PSPACE ;SPACE UNLESS OCTAL SUPPRESS +7$: BR $$PEX1 + +.SBTTL CONVERT BINARY TO DECIMAL AND TYPE ROUTINE + +$PNTDEC:MOV #5,R1 ;SET FOR 5 DIGIT + MOV R0,R2 ;SAVE INPUT NUMBER + CLR R5 ;CLEAR ZERO FILL FLAG + TST R0 ;TEST SIGN OF INPUT NUMBER + BPL 1$ ;POSITIVE GO TYPE IT + MOVB #'-,R0 ;PRINT A MINUS SIGN + PNTCHR ;SEND TO BUFFER + NEG R2 ;NEGATE THE NUMBER + MOV R2,R0 ;GET NUMBER AGAIN + BIC #100000,R0 ;CLEAR SIGN BIT +1$: TST R0 ;TEST FOR A ZERO INPUT NUMBER + BNE 2$ ;NON ZERO + PNTNBR ;PRINT A SINGLE ZERO AND EXIT + BR 9$ ;EXIT +2$: CLR R3 ;ZERO THE CONSTANTS INDEX +3$: CLR R0 ;CLEAR THE BCD NUMBER +4$: SUB $DTBL(R3),R2 ;FORM THIS BCD DIGIT + BLT 5$ ;BR IF DONE + INC R0 ;INCREASE THE BCD DIGIT BY 1 + BR 4$ +5$: ADD $DTBL(R3),R2 ;ADD BACK THE CONSTANT + TST R0 ;TEST IF DIGIT IS A ZERO + BEQ 6$ ;YES + INC R5 ;NO SET ZERO FILL FLAG + BR 7$ + +6$: TST R5 ;IS ZERO FILL FLAG SET + BEQ 8$ ;YES EXIT +7$: BIS #'0,R0 ;MAKE THE BCD DIGIT ASCII + PNTCHR +8$: TST (R3)+ ;JUST INCREMENTING + DEC R1 ;DONE YET + BGT 3$ ;GO DO THE NEXT DIGIT +9$: PNTCI + '. ;PRINT DECIMAL POINT +$$PEX1: EXIT ;RETURN TO USER + +.SBTTL TTY INPUT ROUTINE TTICHR + +$TTICHR:CLR R0 + CMP $INPTC,$INPTR ;ARE WE AT END ON CURRENT BUFFER + BGT $TTIX2 ;YES EXIT + MOVB @$INPTC,R0 ;FETCH CHARACTER FROM BUFFER + INC $INPTC + +$TTIX1: BIC #177600,R0 + BR $$PSX2 ;OK RETURN +$TTIX2: BR $$PEX2 ;ERROR RETURN + +.SBTTL TTY LOOK + +;*TELETYPE KEYBOARD CHECK ROUTINE +;*CHECKS FOR ANY KEY STRUCK,RETURNS IMMEDIATELY +;*RETURNS WITH C-BIT SET IF NO TYPEIN + +$TTLOOK:INC $TTLKF ;SET INHIBIT INPUT CHECKS + CLR R0 + JSR PC,$TIRDY ;ANYTHING BEEN TYPED + BCS $TTIX2 ;NO, C-BIT RETURN + MOVB $TICHR,R0 ;YES, PUT IT IN R0 + CLR $TTLKF ;CLEAR INHIBIT INPUT CHECKS + BR $$PSX2 ;RETURN + +.SBTTL TTY ALT-MODE CHECK ROUTINE + +;*CHECK FOR ALT-MODE IF NOTHING TYPED OR NOT ALTMODE C-BIT SET +;*IF ALT-MODE WAS TYPED THEN C-BIT CLEAR + +$TTALTM:TTLOOK ;ANYTHING TYPED + BCS 2$ ;NO + + CMPB R0,#175 + BEQ 3$ + CMPB R0,#176 + BEQ 3$ + CMPB R0,#ALTMOD + BEQ 1$ + +$$PEX2=. +2$: EXITERR ;EXIT +$$PSX2=. +1$: EXIT ;OK RETURN + +3$: MOVB #ALTMOD,R0 + BR 1$ + +.SBTTL TTIYES YES OR NO ROUTINE + +; NO BITS SET IF YES +; N-BIT SET IF NO +; C-BIT SET IF NEITHER + +$TTIYES:TTICHR ;GET INPUT CHARACTER + BCS $$PEX2 ;NO CHAR AVAILABLE + CMPB #'Y,R0 ;WAS THE CHAR A "Y" ? + BEQ $$PSX2 ;BR IF YES + CMPB #'N,R0 ;WAS THE CHAR AN "N" ? + BNE $$PEX2 ;BR IF NO, NEITHER + BIS #NBIT,14(SP) ;"NO", SET N-BIT + BR $$PSX2 + +.SBTTL PRINT A SELECTED NUMBER OF SPACES + +$PNTSPC:DEC R1 + BLT 1$ + + PSPACE ;PRINT SPACE + BR $PNTSPC + +1$: RTS PC + +.SBTTL BACKUP TTY INPUT BUFFER POINTER + +$TTBACK:CMP $INPTC,#$INBUF + BLE $$PEX2 ;CAN'T, C-BIT SET RETURN + DEC $INPTC ;BACKUP POINTER + BR $$PSX2 + +.SBTTL READ SWITCH REGISTER + +$SWITCH:MOV SWR,R0 ;PUT SWR INTO R0 + +1$: MOV R0,$SWTCH ;SAVE A COPY FOR FUTURE REFERENCE + BR $$PEX3 ;RETURN TO USER + +.SBTTL RETURN WITH COPY OF SWITCHES + +$SWTSAM:MOV $SWTCH,R0 ;COPY OF SWITCHES TO RO + BR $$PEX3 + +.SBTTL SET FORCE PRINT FLAG + +$PFORCE:SETFLG + $FORCE ;177777 TO FORCE FLAG + BR $$PEX3 ;RETURN + + +.SBTTL CLEAR FORCE PRINT FLAG + +$PNORML:CLR $FORCE ;0 TO FORCE FLAG +$$PEX3: EXIT ;RETURN + +;TTILIN ENTRY POINT FROM RUNLP + +$TILRN: CLR TILNWF ;CLEAR TTY WAIT FLAG + JSR PC,$TILN3 ;INIT TTILIN ROUTINE + PUSH $FORCE + MOV #$INBUF,R1 + BR $TILN2 ;GO INPUT, 1ST CHAR ALREADY AVAILABLE + +$TILN3: CLR CTRLOF ;CLEAR CONTROL O FLAG + CMP #$OUTBF,$OUTPT ;ANY OUTPUT WAITING ? + BEQ 1$ ;NO + PRINTT ;YES, PRINT IT +1$: CLR $TPLIT ;CLEAR LINES ON PAGE + CLR $0FLG ;CLEAR RUBOUT FLAG + CLR $TTYTIM ;CLEAR TTY TIMEOUT + RTS PC + +.SBTTL INPUT A STRING FROM TTY + +$TTILNW:SETFLG ;SET TTY WAIT FLAG + TILNWF + BR $TILNX + +$TTILIN:CLR TILNWF ;CLEAR TTY WAIT FLAG + +$TILNX: JSR PC,$TILN3 ;INIT ROUTINE + PUSH $FORCE + PFORCE +95$: MOV #$INBUF,R1 +$TILN1=. +2$: JSR PC,C10COP ;PERFORM CLOCK OPERATIONS + TST TILNWF ;WAIT FOREVER ? + BNE 21$ ;YES, NO TIMEOUT + CMP $TTYTIM,#<3*60.*60.>;TTY TIMED OUT ? + BGT 99$ ;YES, C-BIT SET EXIT + +21$: JSR PC,$TIRDY ;TTY IN FLAG SET + BCS 2$ +$TILN2=. + CLR $TTYTIM + MOVB $TICHR,(R1) ;MOVE CHARACTER TO BUFFER + MOVB (R1),$TNCHR ;SAVE CHAR FOR TEN + BEQ 2$ ;NULL, IGNORE + TENCHR ;SEND TEN THE CHAR + + CLR R5 ;DO SPECIAL CHAR PROCESS +80$: CMPB (R1),TILINC(R5) + BEQ 81$ ;FOUND + INC R5 + TSTB TILINC(R5) + BEQ 82$ ;IF 0, END OF LIST + BR 80$ + +81$: SL R5,1 ;DISPATCH + JMP @TILINA(R5) + +82$: CMPB (R1),#141 + BLT 83$ + CMPB (R1),#172 + BGT 83$ + BICB #40,(R1) ;CONVERT LOWER TO UPPER CASE + +83$: PUSH R1 + MOVB (R1),R1 ;PUT CHAR IN R1 + PLDBUF ;INSERT FOR LPT + INC $OUTPP ;MOVE PRINTED-TO-POSITION + POP R1 + +10$: TST $0FLG ;RUBOUT KEY SET? + BEQ 11$ ;BR IF NO + + MOVB #BKSLH,R0 ;TYPE A BACK SLASH + PTTY + CLR $0FLG ;CLEAR RUBOUT FLAG + +11$: MOVB (R1)+,R0 ;CHAR TO R0 + PTTY ;PRINT IT + BR 2$ ;BACK FOR MORE + +99$: MOV R1,$INPTR ;SAVE INPUT POINTER + POP $FORCE + EXITERR ;TIMED OUT, C-BIT SET RETURN + +$TIRUB: TST $0FLG ;MULTIPLE RUBOUTS ? + BNE 1$ ;YES + INC $0FLG ;SET RUBOUT FLAG + MOVB #BKSLH,R0 ;TYPE A BACKSLASH + PTTY + +1$: DEC R1 ;BACKUP BY ONE + CMP R1,#$INBUF-1 ;INPUT BUFFER EMPTY ? + BNE 2$ ;NO + + PCRLF ;EMPTY, PRINT CR/LF + POP $FORCE + BR $TILNX ;AWAIT NEW LINE + +2$: MOVB (R1),R0 ;PRINT RUBBED OUT CHAR + PTTY + BR $TILN1 + +;SPECIAL CHAR PROCESS + +$TICU: PMSG <^U\> ;CONTROL U, DUMP LINE + POP $FORCE + BR $TILNX + +$TICR: INC R1 ;CARRIAGE RETURN + MOVB #LF,(R1) ;INSERT LF ALSO + +$TIBELL:PCRLF ;PRINT CR/LF + +$TIEXT: MOV R1,$INPTR ;UPDATE INPUT POINTER + MOV #$INBUF,$INPTC ;INIT CHAR POINTER + POP $FORCE + EXIT ;RETURN + +$TIALT: MOVB #ALTMOD,(R1) ;ALTMODE + PMSG <$\> ;PRINT DOLLAR SIGN CR/LF + BR $TIEXT + +$TIBKS: PCRLF ;BACKSLASH, DO LOCAL CR/LF + BR $TILN1 + + +$TICC: PNTCI ;CONTROL C, ABORT + "^C + JMP $CNTLC + +$TICL: TST LPTFLG ;CONTROL L, LPT SELECTION + BPL $TILN1 + COMB LPTFLG + BR $TILN1 + +$TILF: MOVB (R1),R0 ;LINE FEED + PTTY + BR $TIEXT + +$TICO: CLR CTRLOF ;CLEAR CONTROL O FLAG + PNTCI + "^O + BR $TIBELL ;CR/LF & TERMINATE + +$TICX: TTPINI + PNTCI + "^X + TTILIN ;GET COMMAND LINE + BCS $TICC ;TIMED OUT + MOV $KONSP,SP ;RESTORE STACK POINTER + JMP $RPT ;GO PROCESS COMMAND + +;SPECIAL CHARACTERS + +TILINC: .BYTE CR,LF + .BYTE BELL,ALTMOD + .BYTE 175,176 + .BYTE CNTRLL,CNTRLU + .BYTE CNTRLC,BKSLH + .BYTE RUBOUT,CNTRLO + .BYTE XON,XOFF + .BYTE CNTRLX,0 + +;SPECIAL CHAR DISPATCH TABLE + +TILINA: $TICR + $TILF + $TIBELL + $TIALT + $TIALT + $TIALT + $TICL + $TICU + $TICC + $TIBKS + $TIRUB + $TICO + $TIBELL + $TIBELL + $TICX + +.SBTTL CTY & FSTTY DL11 DRIVERS + +$TIRDY: TSTB @$TKS ;ANY CTY INPUT ? + BPL 2$ ;NO + BIT #20000,@$TKB ;BREAK? + BNE 5$ + MOVB @$TKB,$TICHR ;GET CHAR + BICB #200,$TICHR +1$: CLC ;C-BIT CLEAR RETURN + RTS PC + +5$: MOVB #MSWCHR,$TICHR ;TURN BREAK INTO MAGIC CHARACTER WHICH, WHEN READ, + BR 1$ ;CAUSES CONSOLE TO SWITCH OUT OF MONITOR MODE. + +2$: TST DL11EFLG ;DOING DL11E ? + BEQ 3$ ;NO + BIT #DLCTS,@$FSTKS ;YES, STILL HAVE CLEAR TO SEND ? + BEQ 4$ ;NO + + TSTB @$FSTKS ;ANY FSTTY INPUT ? + BPL 3$ ;NO + MOVB @$FSTKB,$TICHR ;YES, GET CHAR + BR 1$ ;C-BIT CLEAR RETURN + +3$: SEC ;NO INPUT, C-BIT SET RETURN + RTS PC + +4$: JMP FSDISC ;DL11E DISCONNECT + +$TORDY: TSTB @$TPS ;IS CTY READY ? + BPL 2$ ;NO + TST DL11EFLG ;DOING DL11E ? + BEQ 1$ ;NO + BIT #DLCTS,@$FSTKS ;STILL HAVE CLEAR TO SEND ? + BEQ 3$ ;NO + + TSTB @$FSTPS ;IS FSTTY READY ? + BPL 2$ ;NO + +1$: CLC ;ALL READY, C-BIT CLEAR RETURN + RTS PC + +2$: SEC ;NOT READY + RTS PC + +3$: JMP FSDISC ;DL11E DISCONNECT + +$TOOUT: MOVB $TOCHR,@$TPB ;PRINT ON CTY + + TST DL11EFLG + BEQ 1$ + MOVB $TOCHR,@$FSTPB ;PRINT ON FSTTY +1$: RTS PC + +.SBTTL READ AN OCTAL NUMBER FROM THE TTY + +;REGISTER USAGE +;R0 = TTY CHARACTER 7 BIT FROM $INBUF +;R2 = WORK REGISTER +;R3 = CLEARED/SET = NO OCTAL CHARS/AT LEAST 1 OCTAL CHAR + +$TTIOCT:CLR R2 ;CLEAR WORK REGISTER + JSR PC,$TMINUS ;CHECK FOR PLUS & MINUS +1$: TTICHR ;PICKUP THIS CHARACTER + BCS 2$ + + CMPB R0,#60 ;MAKE SURE THIS CHARACTER + BLT 2$ ;IS AN OCTAL DIGIT + CMPB R0,#67 + BGT 2$ + + INC R3 ;TO SHOW I GOT ONE CHARACTER + + ASL R2 + ASL R2 + ASL R2 + + BIC #177770,R0 + ADD R0,R2 + BR 1$ + +2$: CLR R0 ;SET UP FOR EXIT + + TST R3 ;DID WE GET ANY DATA + BEQ $$PEX7 ;NO, ERROR RETURN + + MOV R2,R0 + TST R4 ;NEGATE FLAG SET ? + BEQ $$PEX6 ;NO + NEG R0 ;YES, MAKE NUMBER NEGATIVE +$$PEX6: JMP $TTERM ;VERIFY TERMINATION & EXIT +$$PEX7: EXITERR ;ERROR RETURN + +$TMINUS:CLR R3 ;CLEAR CHAR COUNTER + CLR R4 ;CLEAR NEGATE FLAG + MOV $INPTC,R5 ;SAVE INPUT POINTER + TTICHR ;GET 1ST CHAR + BCS 82$ ;NONE AVAILABLE + CMPB #'+,R0 + BEQ 80$ + CMPB #'-,R0 ;NEGATE ? + BNE 81$ ;BR IF NO + INC R4 ;YES, SET NEGATE FLAG +80$: INC R5 ;YES, ADVANCE PAST - +81$: MOV R5,$INPTC +82$: RTS PC + +.SBTTL READ A DECIMAL NUMBER FROM THE TTY + +$TTIDEC:MOV #$TTSAV,R2 ;RESERVE STORAGE + JSR PC,$TMINUS ;CHECK FOR PLUS & MINUS +1$: TTICHR ;READ IN A CHARACTER + BCS 2$ + CMPB R0,#60 ;MAKE SURE THIS CHARACTER + BLT 2$ ;IS A DIGIT BETWEEN 0 & 9 + CMPB R0,#71 + BGT 2$ + INC R3 ;SO I KNOW I GOT A DIGIT + BIC #177760,R0 ;DON'T LET NUMBER GET TO BIG + MOVB R0,(R2)+ + BR 1$ +2$: CLR R0 ;CLEAR OUTPUT + TST R3 ;DID WE GET ANY THING + BEQ 6$ ;NO + +;NOW WE CONVERT IT + + CLR R1 ;CLEAR TABLE INDEX +3$: CMP R2,#$TTSAV + BLT 5$ ;YES NORMAL EXIT + MOVB -(R2),R5 ;PUT IN R5 +4$: DEC R5 ;DONE YET + BLT 7$ + ADD $TBLL(R1),R0 ;TALLY IT UP + BR 4$ +7$: TST (R1)+ ;UPDATE TABLE TALLY + BR 3$ +5$: TST R4 ;NEGATE NUMBER ? + BEQ 9$ + NEG R0 ;YES +9$: BR $$PEX6 ;RETURN +6$: BR $$PEX7 ;ERROR RETURN + +.SBTTL READ A 12 DIGIT OCTAL (36 BIT) NUMBER + +;$0FLG, 0=NO DATA; 0,-1=ONE DATA WORD; -1,-1= TWO PART DATA +;DATA IS TRUNCATED TO 6 OCTALS IN EITHER HALF OF 2 PART DATA +;DATA IS TRUNCATED TO 12 OCTALS IN 1 PART DATA +;DURING CONVERSION +;1 PART DATA; $0FLG =0 +;2 PART DATA; $0FLG=-1,0 DURING HI6; 0,-1 DURING LO6 + +$TTI36: JSR PC,$TI36C + CLR $SVH + CLR $SVM + CLR $0FLG + CLR $NEG + JSR PC,$TMINUS + TST R4 + BEQ 1$ + INCB $NEG+1 ;SET NEGATE FLAG + +1$: TTICHR ;READ A CHAR +99$: BCS 98$ ;BUFFER EMPTY + + CMPB R0,#60 ;MAKE SURE ITS OCTAL + BLT 2$ + CMPB R0,#67 + BGT 2$ + + MOVB #-1,$0FLG ;WE GOT AT LEAST 1 DIGIT + BR 1$ + +2$: TSTB $0FLG + BEQ 69$ + CMPB R0,#BLANK ;WAS IT A SPACE ? + BNE 3$ ;NOPE + MOVB #-1,$0FLG+1 ;SET 2 WORD FLAG + TTICHR ;GET 1ST CHAR OF 2ND PART +98$: BCS 97$ + CMPB #'+,R0 + BEQ 71$ + CMPB #'-,R0 ;IS IT MINUS ? + BEQ 21$ ;YES + DEC $INPTC ;NO, BACKUP INPUT POINTER + BR 1$ +21$: INCB $NEG ;SET 2ND PART NEGATE FLAG +71$: BR 1$ ;PROCESS 2ND HALF WORD + +3$: MOV R5,$INPTC ;RESET INPUT POINTER + CLRB $0FLG + +4$: TTICHR +97$: BCS 96$ + CMPB R0,#60 + BLT 5$ + CMPB R0,#67 + BGT 5$ + + BICB #370,R0 + MOV #3,R1 + +6$: JSR PC,SHFT36 ;SHIFT 36 BIT WORD LEFT 3 + + BISB R0,$DRAM ;INSERT NEW CHAR + BR 4$ + +5$: TSTB $0FLG+1 ;DOING 2 PART NUMBER ? + BEQ 8$ ;BR IF NO + +51$: TSTB $NEG+1 ;NEGATE UPPER PART ? + BEQ 52$ ;NO + + JSR PC,NEG36 ;NEGATE 36 BIT WORD + +52$: MOV #18.,R1 ;YES, MOVE NUMBER TO UPPER 18 BITS + +7$: JSR PC,SHFT36 ;SHIFT 36 BIT WORD LEFT 18 + + MOV -(R5),$SVH ;SAVE UPPER BITS + MOV -(R5),$SVM ;SAVE MIDDLE BITS + JSR PC,$TI36C + + SWAB $0FLG ;MAKE $0FLG 0,-1 + TTICHR ;GET 1ST CHAR OF 2ND PART +96$: BCS 9$ + CMPB #'+,R0 + BEQ 4$ + CMPB #'-,R0 ;IS IT MINUS ? + BEQ 4$ ;YES + DEC $INPTC ;NO, BACKUP INPUT POINTER + BR 4$ + +8$: TSTB $0FLG + BEQ 10$ ;BR IF 1 PART + TSTB $NEG ;NEGATE LOWER PART ? + BEQ 81$ ;NO + + JSR PC,NEG36 ;NEGATE 36 BIT WORD + +81$: MOV #$DRAM+2,R1 + BIC #177774,(R1) + BIS $SVM,(R1)+ + CLR (R1) ;CLEAR BITS 0-17 + BIS $SVH,(R1) ;REINSERT UPPER BITS + BR 12$ + +10$: TSTB $NEG+1 ;MAKE NUMBER NEGATIVE ? + BEQ 12$ ;BR IF NO + JSR PC,NEG36 ;NEGATE 36 BIT WORD + +12$: BIC #177760,$DRAM+4 ;STRIP OVERFLOW + MOV #$DRAM,R0 ;RETURN STORAGE ADR IN R0 + JMP $TTERM ;VERIFY TERMINATION & EXIT +69$: CLR R0 ;NO DIGITS TYPED +9$: TTERM ;VERIFY TERMINATION + EXITERR ;ERROR RETURN + +;SHIFT 36 BIT WORD C(R1) PLACES LEFT + +SHFT36: MOV #$DRAM,R5 + CLC + ROL (R5)+ + ROL (R5)+ + ROL (R5)+ + DEC R1 + BGT SHFT36 + RTS PC + +;NEGATE - TWO'S COMPLEMENT 36 BIT WORD + +NEG36: MOV #$DRAM,R1 ;MAKE 1'S COMPLEMENT + COM (R1)+ + COM (R1)+ + COM (R1) + MOV #$DRAM,R1 + ADD #1,(R1)+ ;MAKE THAT 2'S COMPLEMENT + ADC (R1)+ + ADC (R1) + BIC #177760,(R1) ;STRIP OVERFLOW + RTS PC + +$TI36C: MOV #$DRAM,R0 ;CLEAR STORAGE + CLR (R0)+ + CLR (R0)+ + CLR (R0)+ + RTS PC + +.SBTTL SIGNED MULTIPLY SUBROUTINE + +$MULTP: PUSH R0 + MOV 22(SP),R1 + MOV 20(SP),R0 ;MULTIPLICAND + CLR R4 ;CLEAR SIGN + TST R0 ;TEST SIGN + BPL 1$ + + INC R4 ;SET SIGN BIT + NEG R0 ;MAKE MULTIPLICAND POSITIVE + +1$: TST R1 ;TEST SIGN OF MULTIPLIER + BPL 2$ + + DEC R4 ;UPDATE SIGN BIT + NEG R1 ;MAKE MULTIPLIER POSITIVE + +2$: MOV #17.,R3 ;SET LOOP COUNT + CLR R2 ;SET UP FOR MULTIPLY LOOP + +3$: BCC 4$ ;DONT ADD IF MULTIPLICAND IS ZERO + ADD R1,R2 + +4$: ROR R2 ;POSITION THE PARTIAL PRODUCT + ROR R0 ;AND THE MULTIPLICAND + DEC R3 ;DONE YET + BNE 3$ ;NOPE + + TST R4 ;TEST SIGN + BEQ 5$ ;PRODUCT IS POSITIVE + + NEG R0 ;PRODUCT SHOULD BE NEGATIVE + NEG R2 + SBC R0 ;SUBTRACT CARRY + +5$: MOV R0,20(SP) ;MOST SIGNIFICANT BITS + MOV R2,22(SP) ;LEAST SIGNIFICANT BITS + POP R0 + EXIT ;EXIT + +.SBTTL BREAK CHARACTER + +$TTIBRK:DEC $INPTC ;BACKUP INPUT POINTER + TTICHR + BCC $$PEX4 ;NOTHING IN BUFFER +$$PEX5: EXITERR + +.SBTTL TELETYPE INPUT SPACE DELETE ROUTINE + +$TTSDL: TTICHR + BCS $TTSDX ;BUFFER EMPTY + CMPB R0,#BLANK + BEQ $TTSDL ;DELETE SPACES + CMPB R0,#TAB + BEQ $TTSDL ;DELETE TABS + CMPB #'-,R0 ;TREAT + OR - + BEQ 3$ ;SAME AS NUMBER + CMPB #'+,R0 + BEQ 3$ + CMPB R0,#60 + BLT 1$ ;BR IF NON-NUMBER + CMPB R0,#71 + BGT 1$ ;BR IF NON-NUMBER +3$: DEC $INPTC ;NUMBER, BACKUP INPUT POINTER + BR $$PEX4 ;C-BIT CLEAR RETURN +1$: CMPB R0,#': ;COLON OR SLASH, V-BIT & C-BIT SET + BEQ 10$ + CMPB R0,#'/ + BEQ 10$ + CMPB R0,#'^ ;UPARROW, Z-BIT & C-BIT SET + BNE $$PEX5 + BIS #ZBIT,14(SP) + BR $$PEX5 + +10$: BIS #VBIT,14(SP) + BR $$PEX5 +$TTSDX: JMP $PARAM + +.SBTTL TELETYPE INPUT TERMINATION CHECK + +$TTITRM:INC $INPTC ;BECAUSE "TTERM" DECREMENTS +$TTBTRM:TTERM ;VERIFY TERMINATOR + BCS $TTSDX ;BAD, C-BIT SET RETURN + BR $$PEX4 ;OK + +$TTERM: PUSH R0 + DEC $INPTC ;BACKUP INPUT POINTER + TTICHR ;GET TERMINATION CHAR + BCS 2$ ;NONE + MOV #TRMTAB,R1 ;SETUP TERMINATION SCAN POINTER +1$: CMPB R0,(R1) ;CHAR MATCH LEGAL TERMINATOR ? + BEQ 2$ ;YES + TSTB (R1)+ ;NOT YET, GO TO NEXT + BEQ 3$ ;NO MATCH, ERROR + BR 1$ +2$: POP R0 + BR $$PEX4 ;OK, C-BIT CLEAR RETURN +3$: POP R0 + BR $$PEX5 ;ERROR, C-BIT SET RETURN + +TRMTAB: .BYTE SPACE,TAB + .BYTE COMMA,CR + .BYTE ALTMOD,72 ;COLON + .BYTE 57,0 ;SLASH + +.SBTTL INPUT & CHECK OCTAL NUMBER + +$TTCOCT:TTISDL + BCS $TTSDX + TTIOCT + BCS $TTSDX ;NON-OCTAL + BR $$PEX4 ;OK + +$TOCTE: TTCOCT + BIT #1,R0 ;ONLY EVEN OCTAL + BNE $TTSDX + BR $$PEX4 + +.SBTTL TELETYPE DELETE SPACES & INPUT OCTAL NUMBER + +$TTSDO: TTCOCT + TST R0 ;MUST BE POSITIVE ALSO + BMI $TTSDX +$$PEX4=. + EXIT + +.SBTTL TELETYPE DELETE SPACES & INPUT 36BIT NUMBER + +$TTS36: TTISDL ;DELETE SPACES + BCS $TTSDX + TTI36 ;INPUT 36 BIT NUMBER + BCS $TTSDX + BR $$PEX4 + +.SBTTL TELETYPE INPUT C-RAM ADDRESS + +$TICRA: TTISDO ;GET ADDRESS + CMP R0,#CRMSIZ + BLE $$PEX4 + JMP ADRERR ;TOO BIG + +.SBTTL SHIFT R0 RIGHT/LEFT ROUTINES + +$SHFTR: MOV @$EMADR,R1 ;GET SHIFT COUNT +1$: ASR R0 ;SHIFT RIGHT + DEC R1 + BGT 1$ +$SHFTX: EXITSKP ;SKIP OVER TRAILING PARAMETER + +$SHFTL: MOV @$EMADR,R1 +1$: ASL R0 ;SHIFT LEFT + DEC R1 + BGT 1$ + BR $SHFTX + +.SBTTL PRINT MESSAGE, CONDITIONAL DEPENDING ON "RPTFLG" + +$$PMSR: TSTB RPTFLG ;DOES REPEAT FLAG ALLOW PRINTING ? + BNE $SHFTX ;NO + +.SBTTL PRINT MESSAGE + +$$PMSG: MOV @$EMADR,R0 ;MESSAGE ADDRESS TO R0 + PNTAL ;PRINT + BR $SHFTX ;SKIP RETURN + +.SBTTL PRINT CHARACTER IMMEDIATE + +$PNTCI: MOV $EMADR,R2 ;GET DATA ADDRESS + MOVB (R2)+,R1 ;GET FIRST BYTE + PLDBUF ;INSERT IN BUFFER + MOVB (R2),R1 ;GET 2ND BYTE + BEQ 1$ ;IS THERE ANY ? + PLDBUF ;YES, INSERT IN BUFFER +1$: BR $SHFTX ;SKIP RETURN + +.SBTTL SMALL TIME DELAY + +$DELAY: MOV #10.,R1 +1$: DEC R1 + BNE 1$ + EXIT + +;CONSOLE TIME DELAY FOR REPEAT LOOPS + +.TD: TTISDL + BCS 1$ ;NO ARG, DO ONCE + TTIDEC + BCS 1$ ;DO ONCE ANYWAY + MOV R0,R1 ;SAVE DELAY COUNT + BR 2$ +1$: CLR R1 +2$: TDELAY ;SMALL TIME DELAY + DEC R1 ;DONE REQUESTED DELAYS ? + BGT 2$ + JMP $KONSL + +.SBTTL SAVE AND RESTORE R0-R5 ROUTINES + +$REGSAV:PUSH R0 + PUSH 16(SP) + PUSH 16(SP) + RTI + +;*RESTORE R0-R5 + +$REGRST:MOV 14(SP),34(SP) + MOV 12(SP),32(SP) + ADD #16,SP + POP + RTI + +;FATAL VECTOR INTERRUPT + +$FATLE: PUSH R0 + PMSG + BR $EOR + +$TIMOT: PUSH R0 + PMSG + BR $EOR + +$RESVD: PUSH R0 + PMSG + +$EOR: CLR TENRUN + POP R0 + PUSH + BR $EOR2 + +;STACK UNDERFLOW + +$STUF: MOV #STACK-2,SP + MOV SP,$KONSP + PMSG + CLR PCMDFLG + JMP $CNTLC + +$NOTAS: PMSG +$EOR2: CLR PCMDFLG + JMP $PH1 + +$FATAL: PUSH R0 + PMSG + BR $EOR2 + +.SBTTL EMT DECODER + +;*THIS ROUTINE WILL PICKUP THE LOWER BYTE OF THE "EMT" INSTRUCTION +;*AND USE IT TO INDEX THROUGH THE EMT TABLE FOR THE STARTING ADDRESS +;*OF THE DESIRED ROUTINE. THEN USING THE ADDRESS OBTAINED IT WILL +;*GO TO THAT ROUTINE. + +$EMTRP: CMP SP,#COREND-600+20 + BLE $STUF ;OFF BOTTOM OF STACK + PUSH + MOV 14(SP),R0 ;GET EMT ADDRESS (+2) + BIC #17,16(SP) ;CLEAR ALL STATUS BITS + MOV R0,$EMADR ;SAVE + MOV -(R0),R0 ;GET RIGHT BYTE OF EMT + BIC #177400,R0 + CMP R0,#<<$EMTAE-$EMTAD>/2> + BGE $NOTAS ;EMT IN RANGE ? + SL R0,1 ;ROUND TO WORD ADDRESS + MOV $EMTAD(R0),R0 ;INDEX TO TABLE + RTS R0 ;GO TO ROUTINE + +.SBTTL EMT TABLE + +;*THIS TABLE CONTAINS THE STARTING ADDRESSES OF THE ROUTINES CALLED +;*BY THE "EMT" INSTRUCTION. + +; ROUTINE +; ------- +$EMTAD: $FATAL ;EMT + 0 + $ERRHLT ; 1 + $PRGHLT ; 2 + $RUNLP ; 3 + $TTILIN ; 4 + $TTICHR ; 5 + $TTLOOK ; 6 + $TTIOCT ; 7 + $TTCOCT ;EMT + 10 + $TTIDEC ; 11 + $TTIYES ; 12 + $TTALTM ; 13 + $TTI36 ; 14 + $TTIBRK ; 15 + $TTSDL ; 16 + $TTSDO ; 17 + $TTS36 ;EMT + 20 + $TICRA ; 21 + $TTITRM ; 22 + $TTBTRM ; 23 + $PNTAL ; 24 + $$PMSG ; 25 + $$PMSR ; 26 + $PNTCHR ; 27 + + $PNTNBR ;EMT + 30 + $PCRLF ; 31 + $PSPACE ; 32 + $PSLASH ; 33 + $PCOMMA ; 34 + $PNTOCT ; 35 + $PNTOSC ; 36 + $PNTDEC ; 37 + $PNT18 ;EMT + 40 + $PNT23 ; 41 + $PNT36 ; 42 + $PFORCE ; 43 + $PNORML ; 44 + $PBELL ; 45 + $PNTODC ; 46 + $PODT ; 47 + $REGSAV ;EMT + 50 + $REGRST ; 51 + $CMP36 ; 52 + $SHFTR ; 53 + $SHFTL ; 54 + $SETFLG ; 55 + $DELAY ; 56 + $SWITCH ; 57 + $SWTSAM ;EMT + 60 + $EOP ; 61 + $ERREOP ; 62 + $EOPSET ; 63 + $COMLIN ; 64 + $COMSND ; 65 + $COMACK ; 66 + $COMNAK ; 67 + $COMCLR ;EMT + 70 + $COMCTL ; 71 + $MULTP ; 72 + $WCRAM ; 73 + $RCRAM ; 74 + $WWADR ; 75 + $MRESET ; 76 + $TENSP ; 77 + $SM ;EMT + 100 + $XCT ; 101 + $LODAR ; 102 + $EXAM ; 103 + $EXAMT ; 104 + $DPOS ; 105 + $DPOST ; 106 + $DPOSVR ; 107 + + $DPSVT ;EMT + 110 + $D10MON ; 111 + $D10ZRO ; 112 + $DTEBAS ; 113 + $DFXCT ; 114 + $DXCTT ; 115 + $DFRD ; 116 + $DFRDMV ; 117 + $DFWRT ;EMT + 120 + $DFWIR ; 121 + $DFSCLK ; 122 + $DFPC ; 123 + $DFVMA ; 124 + $DFADB ; 125 + $RDRAM ; 126 + $WDRAM ; 127 + $DRAMAD ;EMT + 130 + $BURST ; 131 + $PNTCPU ; 132 + $PRGCMD ; 133 + $P36B ; 134 + $ECLOK ; 135 + $ESYNC ; 136 + $PADR ; 137 + $DFRDT ;EMT + 140 + $DWRTT ; 141 + $PCRAM ; 142 + $PDRAM ; 143 + $TTBACK ; 144 + $TENSW ; 145 + $PROL36 ; 146 + $SETMPH ; 147 + $DFVMH ;EMT + 150 + $PRINTT ; 151 + $PTTY ; 152 + $PLPT ; 153 + $PLDBUF ; 154 + $R50UPK ; 155 + $DTINIT ; 156 + $RPINIT ; 157 + $DVDATA ;EMT + 160 + $DTREAD ; 161 + $RPREAD ; 162 + $DVFRAM ; 163 + $DVWRD ; 164 + $ASCR50 ; 165 + $RPLOAD ; 166 + $RPFIND ; 167 + + $RPLKUP ;EMT + 170 + $RPRDFL ; 171 + $RPWRFL ; 172 + $RPWRIT ; 173 + $RPADDR ; 174 + $RPBASE ; 175 + $TENCHR ; 176 + $PNTBAK ; 177 + $TOCTE ;EMT + 200 + $TTERM ; 201 + $CLKPRM ; 202 + $MICNUL ; 203 + $MICFIL ; 204 + $DTWRT ; 205 + $NAMEXT ; 206 + $DTAFILE ; 207 + $RPFILE ;EMT + 210 + $DTRDFL ; 211 + $DTWTFL ; 212 + $DTBASE ; 213 + $PNTCI ; 214 + $PNTRST ; 215 + $PRGNPT ; 216 + $TTPINI ; 217 + $COMCMD ;EMT + 220 + $CMRTRY ; 221 + $COMENQ ; 222 + $COMEOT ; 223 + $TTILNW ; 224 + $TTICCL ; 225 + $DFLEGAL ; 226 + $PTAB ; 227 + $RXFILE ;EMT + 230 + $RXINIT ; 231 + $RXRDFL ; 232 + $RXWTFL ; 233 + $RXBASE ; 234 + $RXREAD ; 235 + $RXWRT ; 236 + $RPERR ; 237 +$EMTAE=. + +$ESYNC: PUSH R0 + JMP $NOTAS + +.SBTTL POWER DOWN AND UP ROUTINES + +$PWRDN: MOV #$PWRUP,@#PWRVEC ;SET UP VECTOR +$ILLUP: HALT + BR $ILLUP ;HANG UP + +;POWER UP ROUTINE + +$PWRUP: MOV #PR7,PS ;SET CPU PRIO:7 + MOV #STACK,SP ;SET SP + CLR R5 ;WAIT LOOP FOR THE TTY +1$: INC R5 ;WAIT FOR THE INC + BNE 1$ ;OF WORD + MOV #$PWRDN,@#PWRVEC ;SET UP THE POWER DOWN VECTOR + CLR CONSOL-2 + CLR LPTFLG ;DISCONNECT LINE PRINTER + CLR DL11EFLG ;DISCONNECT KLINIK !!! + INC $PWRCNT ;COUNT POWER RESTARTS + MOV #KWLKS,R3 + CLR R5 +10$: TSTB (R3) ;WAIT FOR CLOCK TICK + BPL 10$ + BIC #200,(R3) + INC R5 ;COUNT IT + CMP R5,#<5.*60.> ;WAITED 5 SEC FOR TTY POWER ? + BLE 10$ ;NOT YET + PMSG <\"POWER RESTART" > + MOV $PWRCNT,R0 + PNTDEC + PCRLF + CLR R5 ;CLEAR TIME-UP COUNTER +2$: JSR PC,$TIRDY ;ANY OPERATOR INTERRUPT ? + BCS 3$ ;NO + MOVB $TICHR,R4 ;YES, GET CHAR + CMPB #CNTRLC,R4 ;IS IT CONTROL C ? + BEQ 4$ ;YES, ABORT TIME-UP WAIT +3$: TSTB (R3) ;CLOCK SET ? + BPL 2$ ;NO + BIC #200,(R3) + INC R5 ;COUNT CLOCK TICK + CMP R5,#<5.*60.> ;WAITED 5 SECONDS FOR KL10 ? + BLE 2$ ;NOT YET +4$: JMP START + +.SBTTL EXIT SUBROUTINE + +$EXITE: BIS #CBIT,14(SP) ;SET C-BIT ERROR + BR $EXIT + +$SETFLG:MOV @$EMADR,R1 ;SET -1 TO FLAG WORD + MOV #-1,(R1) + +$EXITS: ADD #2,12(SP) ;SKIP RETURN +$EXIT: POP + RTI ;RETURN TO USER + +;MEMORY PARITY + +MEMPE: TST MEMPEF ;BEEN HERE ALREADY ? + BPL 1$ + FATAL ;YES +1$: COM MEMPEF ;SET FLAG + BIC #MMPIE,MMLPBA ;CLEAR ENABLE + BIT #MMERRF,MMLPBA ;ERROR SET ? + BNE 2$ + FATAL ;NO, HOW DID THIS GET HERE ? +2$: PMSG + JMP $CNTLC + +.SBTTL PDP10 OPERATIONS + +;PDP-10 MEMORY ZERO +; R0 = COUNT, R1 = POINTER TO START ADDRESS + +$D10ZRO: MOV R0,R5 ;SAVE COUNT + DEC R5 + MOV #.DPXAD,R4 + MOVB (R1)+,(R4)+ + MOVB (R1)+,(R4)+ + MOVB (R1),(R4) + TST -(R4) + CLR @.DAT1 ;CLEAR DTE20 DATA WORDS + CLR @.DAT2 + CLR @.DAT3 + +$D10ZX: MOV R4,R1 ;POINTER TO ADDRESS + BR $DPSX1 + +;PDP-10 SET -1 TO FLAG WORD +; ADDRESS IN TRAILING PARAMETER + +$D10MON: MOV #L10ADR+2,R1 ;SETUP 10 ADR BLOCK POINTER + CLR (R1) + MOV @$EMADR,-(R1) ;PUT 10 ADR IN ADR BLOCK + MOV #TENMO,R0 ;SETUP -1 DATA WORD + ADD #2,12(SP) ;SKIP RETURN OVER TRAILING PARAMETER + CLR R5 + BR $DPOSX + +;EXAMINE AND DEPOSIT 10 MEMORY + +$DPOST: JSR PC,$10ADR ;SETUP PARAMETERS + +$DPOS: CLR R5 + JSR PC,$D10ADR ;SETUP PDP-10 ADDRESS + +$DPOSX: MOV #$TEMP0,R2 ;STUFF THE DEXWRDS + MOVB (R0)+,(R2)+ + MOVB (R0)+,(R2)+ + MOVB (R0)+,(R2)+ + MOVB (R0)+,(R2)+ + MOVB (R0)+,(R2)+ + MOVB (R0),(R2)+ + BIC #177760,-(R2) + MOV .DAT1,R3 + MOV (R2),(R3) ;BITS 00-03 TO .DAT1 + MOV -(R2),-(R3) ;BITS 04-19 TO .DAT2 + MOV -(R2),-(R3) ;BITS 20-35 TO .DAT3 +$DPSX1: BIS #DEP,2(R1) ;SET FLAG + BR $EXDEP + +$EXAMT: JSR PC,$10ADR ;SETUP PARAMETERS + BR $EXAMX + +$EXAM: MOV R0,R1 + JSR PC,$D10ADR ;SETUP PDP-10 ADDRESS + MOV #$DRAM,R0 +$EXAMX: CLR R5 + BIC #DEP,2(R1) ;CLEAR FLAG BIT + +$EXDEP: MOV #EBUSPC,@.STDTE ;E-BUS PARITY CLEAR + BIS #PHYS!PRTOFF,2(R1) + + MOV 2(R1),@.TENA1 + MOV (R1),@.TENA2 ;START DTE20 + + MOV EMTIMO,-(SP) ;SET TIMEOUT COUNT +93$: BIT #DEXDON,@.STDTE ;TEST BIT + BNE 94$ ;LEAVE IF NOW A ONE(OK) + DEC (SP) ;DECREMENT COUNT + BNE 93$ ;CONTINUE LOOP + TST RPTFLG ;OTHERWISE TIMEOUT + BNE 94$ ;UNLESS UNDER REPEAT + CLR TENRUN ;CLEAR TEN RUNNING + CLR R5 ;CLEAR BLOCK ZERO INDICATOR + BIS #CBIT,16(SP) +94$: TST (SP)+ ;RESET STACK + + BIT #DEP,2(R1) + BNE 1$ ;DEPOSIT BRANCHES + PUSH R0 + MOV .DAT3,R3 + MOV (R3)+,(R0)+ ;BITS 20-35 FROM .DAT3 + MOV (R3)+,(R0)+ ;BITS 04-19 FROM .DAT2 + MOV (R3),(R0) ;BITS 00-03 FROM .DAT1 + BIC #177760,(R0) + POP R0 + BIT #BPARER,@.STDTE ;E-BUS PARITY ERROR ? + BEQ 1$ ;NO + BIS #CBIT!VBIT!NBIT!ZBIT,14(SP) ;SET ALL COND BITS +1$: TST R5 ;EXAM, DPOS OR FINISHED BLOCK ZERO ? + BEQ 2$ ;YES + DEC R5 ;BLOCK ZERO, DECREMENT COUNT + ADD #1,(R4) ;INCREMENT PDP-10 ADDRESS + ADC 2(R4) + BR $D10ZX ;CLEAR NEXT WORD +2$: EXIT + +$D10ADR:MOV #L10ADR,R4 + MOVB (R1)+,(R4)+ + MOVB (R1)+,(R4)+ + MOVB (R1),(R4) + BIC #177760,(R4) + MOV #L10ADR,R1 + RTS PC + +$EBPAR: .ASCIZ/?E-BUS PARITY ERROR / +.EVEN + +$DPSVT: JSR PC,$10ADR ;SETUP PARAMETERS + +$DPOSVR: PUSH R0 + DPOS + BCS $DPVRP + MOV R1,R0 + EXAM + BCS $DPVRE + POP R0 + MOV #$DRAM,R1 + +;5-BYTE COMPARE ROUTINE, C & V BIT SET IF ERROR + +$CMP36: PUSH R1 + MOV #5,R2 +1$: CMPB (R0)+,(R1)+ + BNE 2$ + DEC R2 + BNE 1$ + BR $DPVRX +2$: BIS #CBIT!VBIT,16(SP) ;SET C & V FOR VERIFY ERROR +$DPVRX: POP R0 ;POINT TO ACTUAL + EXIT + +$DPVRP: BIS #CBIT!NBIT,16(SP) + BR $DPVRX +$DPVRE: BIS #CBIT!ZBIT,16(SP) + BR $DPVRX + +;PDP-10 ADDRESS PARAMETER SETUP + +$10ADR: MOV $EMADR,R5 ;SETUP TRAILING PARAMETER PICKUP + MOV #L10ADR+2,R1 ;SETUP 10 ADR BLOCK POINTER + CLR (R1) ;CLEAR HI ADR + + MOV (R5)+,-(R1) ;SETUP PDP-10 ADDRESS + MOV (R5),R0 ;POINTER TO DATA BLOCK IN R0 + ADD #4,14(SP) ;RETURN OVER TRAILING PARAMETERS + RTS PC + +;START MICROCODE + +$SM: PUSH R0 + MRESET ;RESET KL10 + CLR R0 ;SELECT UCODE START ADR + WWADR + DFXCTT ;GET CLOCK GOING + STRCLK + + MOV #2,R1 + MOV #$SMTAB,R0 +1$: PUSH R0 + EXCT ;DO TEN INSTR + BCS 2$ + POP R0 + ADD #5,R0 ;NEXT + DEC R1 + BNE 1$ + + POP R0 + EXIT + +2$: POP R0 + POP R0 +$SMERR: EXITERR + +$SMTAB: IO10 CONO,APR,,200000 ;IO SYS CLEAR + IO10 CONO,PI,,10000 ;PI SYS CLEAR + .EVEN + +;PDP-10 INSTRUCTION EXECUTE + +$XCT: LODAR + BCS 6$ + DFXCTT ;SET CONTINUE BUTTON + CONBUT + DFXCTT ;RUN THE CLOCK + STRCLK + + TST RPTFLG ;DOING REPEAT ? + BNE 2$ ;YES, NO CHECK + + MOV #1000.,R1 +4$: BIT #HALTLP,@.DIAG1 + BNE 2$ + DEC R1 ;NO, WAITED LONG ENOUGH + BNE 4$ +6$: BR $SMERR + +2$: EXIT + +;ECLOK - GIVE A COMPLETE EBOX CLOCK + +$ECLOK: MOV #4000.,R5 + +91$: DFSCLK ;STEP RAW CLOCK + DFRDT ;READ CLOCK STATE + 104 + BIT #BIT2,@.DAT3 ;CLK E BOX SOURCE HIGH ? + BNE 92$ + DEC R5 + BNE 91$ + TST RPTFLG + BNE 92$ + BIS #CBIT,14(SP) ;REPORT TIMEOUT + +92$: DFXCTT + CECLK + EXIT + +;PDP-10 CONTROLLED STOP ROUTINE + +$TENSP: PUSH R0 + CLR TENRUN ;CLEAR LOGICAL TEN RUNNING FLAG +; CLR TENCLK ;CLEAR TEN USING CLOCK FLAG + ;DON'T CLEAR TENCLK BECAUSE MIGHT WANT TO CONTINUE THE SYSTEM + + MOV #DCOMST!DFUNC!,@.DIAG1 + JSR PC,$$DFXDN ;CLEAR RUN FLOP + + MOV #1000.,R1 +1$: BIT #HALTLP,@.DIAG1 + BNE 2$ ;TEN RETURNED TO HALT LOOP + DEC R1 + BNE 1$ + BR 5$ ;FAILED TO RETURN TO HALT LOOP + +2$: DFRDT + 131 + BIT #BIT1,@.DAT2 ;BIT 18, CON CACHE LOOK + BEQ 4$ ;FALSE, CACHE IS NOT ON + + MOV #$$CF,R0 + EXCT ;EXECUTE CACHE FLUSH + BCS 5$ ;FAILED + + MOV #1000.,R1 +3$: DFRDT + 110 + BIT #BIT2,@.DAT1 ;BIT 1, SWEEP BUSY ENABLE + BEQ 4$ ;FINISHED SWEEP + DEC R1 + BNE 3$ + BR 5$ ;FAILED TO FINISH CACHE SWEEP + +4$: POP R0 ;SUCESSFUL RETURN + EXIT + +5$: POP R0 ;FAILED RETURN + EXITERR