Trailing-Edge
-
PDP-10 Archives
-
BB-J992D-SB_1984
-
chk60.p11
There are 5 other files named chk60.p11 in the archive. Click here to see a list.
.SBTTL CHK60 - ONCE ONLY SYSTEM DIAGNOSTIC 01 MAY 79
.REPT 0
COPYRIGHT (C) 1982,1981, 1980, 1979
DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED
ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE
INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER
COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY
TRANSFERRED.
THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE
AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT
CORPORATION.
DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS
SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
.ENDR
; Revision History
; 1(13) 08-Sep-76 JBS Started revision history
; 1(14) 19-Oct-76 KR Added DZ11 code and support to count devices below it
; Also added more timing before RESET, and CPU type
; checking
; as well as fixing bug in core reporting on 11/34
; 1(15) 03-Nov-76 KR fixed bug in 11/05 CPU determination
; 1(16) 04-NOV-76 JBS INCLUDED EJW'S DTE CHECKING
; 1(17) 29-DEC-76 JBS INCLUDED SOME DN61-S CODE
; 1(20) 21-JAN-77 JBS REMOVED USE OF SPL INSTRUCTION
; 1(21) 25-JAN-77 JBS STARTED ADDING DN20 CODE (INCOMPLETE)
; 1(22) 28-JAN-77 JBS SUPPORT DS11 ONLY ON DC75 (CONFLICT WITH LP20)
; 1(23) 31-JAN-77 JBS ASSUME NOT DN20 ADDRESSING UNLESS REQUESTED
; 1(24) 01-FEB-77 JBS MINOR LISTING CLEANUP
; 1(25) 14-FEB-77 JBS UPDATED LEGAL NOTICE AS PER 005-003-286-03
; 1(26) 09-MAR-77 JBS STORE DTE20 ADDRESSES AND VECTORS
; AND DO SOME LISTING CLEANUP
; 1(27) 21-MAR-77 JBS REMOVE KGLOAD MACRO
;
; 1(30) 01-APR-77 JBS CHANGE NAME TO DN61
; 1(31) 06-APR-77 MM SAVE INTERRUPT VECTOR LOCATION
; IN A DIFFERENT GLOBAL CELL DTEDTO
; 1(32) 12-APR-77 JBS FIX SUPPRESSION OF KG11-A MESSAGE
; 1(33) 14-APR-77 JBS FIX DUP11 VECTOR CALCULATION
; AND ADD KMC11
; 1(34) 17-MAY-77 JBS REMOVE EXPLICIT REFERENCES TO PS REGISTER AND
; FILL VECTOR SPACE TO 1200 INSTEAD OF 1000.
; 1A(35) 27-JUN-77 JBS IMPROVE KMC11 CHECKING AND START IT
; IF REQUESTED.
; 1A(36) 30-JUN-77 JBS IMPROVE KMC11 CHECKING AGAIN AND LOAD ITS
; TO 1A(37) CRAM IF REQUESTED.
; 2(40) 18-JUL-77 JBS CHANGE VERSION NUMBER TO 2, DONT LOAD
; KMC11 CRAM IF SIZE11 DID.
; 2(41) 12-SEP-77 JBS DONT LOAD MORE THAN 2000 OCTAL
; WORDS OF KMC11 CRAM (I.E., DONT LOAD
; THE VERSION NUMBER).
; 2(42) 13-SEP-77 JBS REMOVE ALL REFERENCES TO REGISTER 'P'.
; 2(43) 14-OCT-77 JBS FIX KMC11 STARTING LOOP TO START MORE
; THAN ONE KMC11
; 2(44) 16-JAN-78 DRL FILL ONLY TO 1000 NOT 1200 FOR VECTORS
; (THIS PREVENTS SCREWING DDT.P11)
; 3(45) 16-JAN-78 DRL CORRECT DC75 CONDITIONALS
; UPDATA VERSION NUMBER
; TAKE OUT EXTRA DC75 CODE
; FIX DL10 TESTS
; 3(46) 23-JAN-78 DRL RESTRUCTURE DEVICE MACROS, AND
; FIX WAY CODE IS INCLUDED OR NOT
; 3(47) 2-Mar-78 KR Add code to check all of memory, using
; memory management if present
; 3(50) 5-Mar-78 KR Add code to distinguish types of KMC11's on DN20
; 3(51) 21-JUN-78 DRL Fix timing problems for dz11's
; 3(52) 7-jul-78 drl Add LP20 code
; 3(53) 3-AUG-78 DRL Make the LP20 code a little smarter
; 3(54) 5-Sep-78 KR Add DMC11 code, and make DZ11 code skip echo test
; if interrupt didn't occur (since it will
; always fail as well)
; 3(55) 12-Sep-78 Allow DL10 on other than 100000
; 3(56) 19-Sep-78 DMCC/EGF/JBS/LAD/KR/EJW/MM/DRL/KR/DRL/KR
; 3(56A) 24-Jan-79 JW Add cludge to make sure memory test does not
; go beyond 28K in case there is some device
; at 160000.
; 3(57) 01-MAY-79 BS INCLUDE KMC11 MICROCODE LOADER FOR ALL KMC COMBINATIONS
; 3(60) 06-Apr-79 KR Replace 3(57) with code to check all 3 types of KMC11
; and load the appropriate microcode for each
; 3(61) 06-Apr-79 KR Fix FTGLOM to default to 0 if not defined
; 3(62) 06-Apr-79 KR Fix errors in 3(60)
; 3(63) 06-APR-79 BS FIX ERRORS IN 3(62)
; 3(64) 28-JUN-79 JW Add FT.MF for systems which have no parity unit.
; FT.MF undefined means parity unit present.
; 4(65) 10-MAR-82 RLS GCO 4.2.1263 - add device check of DQ11 under FT.D20.
; THIS CODE IS EXECUTED ONCE AND THEN OVERLAID WITH TABLES
;
; CALL TO CHK60 IS AS FOLLOWS:
; JSR PC,CHK.11
; .ASCIZ \PROGRAM NAME\
; RETURNS BY JUMP TO 'BEGIN'
; OR TO 'CKDONE' IF THIS IS DEFINED
;
; CHK60 WILL DETERMINE WHAT HARDWARE IS PRESENT
; AND WILL PERFORM A FEW SIMPLE DIAGNOSTIC TESTS OF THE HDW
;
; FOR DEV = < DH11, DM11BB, DP11, DQ11, DS11, DU11>
; CHK60 WILL: JSR PC,CKA'DEV
; WITH (R3) = DEVICE VECTOR
; AND (R4) = DEVICE ADR
; AND (R1) = DEVICE ADR
; ONCE FOR EACH DEVICE AND A FINAL:
; JSR PC,CKA'DEV WITH (R4)=0
;
; ALL SYMBOLS BEGINING CHK OR CK ARE RESERVED FOR CHK60
; DEFINE CONDITIONALS WE USE, IF THE ARE NOT YET DEFINED
; DO NODE TYPED FIRST
.IIF NDF FT.D75,FT.D75=0 ; NO DC75 IN SYSTEM
.IIF NDF FT.D80,FT.D80=0 ; NO DN80 IN SYSTEM
.IIF NDF FT.D81,FT.D81=0 ; NO DN81 IN SYSTEM
.IIF NDF FT.D82,FT.D82=0 ; NO DN82 IN SYSTEM
.IIF NDF FT.D85,FT.D85=0 ; NO DN85 IN SYSTEM
.IIF NDF FT.D87,FT.D87=0 ; NO DN87 IN SYSTEM
.IIF NDF FT.87S,FT.87S=0 ; NO DN87S IN SYSTEM
.IIF NDF FT.D20,FT.D20=0 ; NO DN20 IN SYSTEM
.IIF NDF FT.200,FT.200=0 ; NO DN200 IN SYSTEM
; NOW DO DEVICES
.IIF DF,FT.KDP,FT.KMC=FT.KDP ;need KMC11 cruft if KDP driver present
.IIF NDF FT.KMC,FT.KMC=0 ;0 TO NOT START KMC11
;OTHER DEFAULTS
.IIF NDF FLOATV FLOATV= 300 ;FIRST FLOATING VECTOR
.IIF NDF FLOATD FLOATD= 160000 ;FLOATING DEVICES BEGIN HERE + 10 [1(14)]
.IIF NDF CKDONE,CKDONE= BEGIN
.IIF NDF DL10AD,DL10AD=.
.BLKW 1 ;PUT DL10 ADR HERE IF NOWHERE ELSE
.IIF NDF,FTGLOM,FTGLOM=0 ;default FTGLOM to nothing 3(61)
.SBTTL CHK60 MACRO'S
;THIS MACRO IS USED FOR TYPING TEXT AND/OR FOR
;ERROR REPORTING.
;
; ARG BITS ;WHAT TO DO ON A TRAP
CKEFAT= B0 ;FATAL ERROR - HALT
CKEPC= B1 ;PRINT ADDRESS OF ERROR TRAP
CKEMSG= B2 ;PRINT THE MESSAGE FOLLOWING CK11SC
CKEDID= B3 ;PRINT DEVICE ID AND REG
CKEMSE= B4 ;PRINT THE MESSAGE POINTED TO BY
; THE ADDRESS FOLLOWING THE TRAP.
CKENCL= B5 ;PRINT TEXT WITH OUT CR+LF
CKEGB= B6 ;PRINT ADR/REG=XXXXX GD=XXXXX BD=XXXXX XOR=XXXXX
CKADPH=B7 ;address is virtual, print physical [3(47)]
;
; ARG MSG ;TEXT TO BE OUTPUT
;
; ARG COMENT ;ADD A COMMENT TO TRAP
;
; ARG STOPCD ;ON A FATAL ERROR VALUE TO BE PUT IN R0
;
.MACRO CK11SC BITS,MSG,COMENT,STOPCD
.NCHR CKZZZX,<MSG>
.IIF NB,STOPCD, MOV #STOPCD,CKSPCD ;VALUE TO DISPLAY IN R0,
;AND DATA LIGHTS ON FATAL ERROR
.IIF EQ,CKZZZX, TRAP BITS ;COMENT
.IF NE,CKZZZX
.IF EQ,<BITS&CKEMSE>
TRAP BITS!CKEMSG ;COMENT
; ASCIZ <MSG>
.ENDC
.IF NE,<BITS&CKEMSE>
TRAP BITS&<^CCKEMSG> ;COMENT
.WORD MSG ;ADR OF MESSAGE
.ENDC
.ENDC
.ENDM CK11SC
;THIS MACRO IS USED TO CHECK INTERRUPT CONDITIONS
;
; ARG ENBADR ;DEVICE ADR TO ENABLE INTERRUPTS
;
; ARG INTADR ;DEVICE ADR TO GENERATE AN INTERRUPT
;
; ARG ENLBIT ;BIT TO ENABLE INTERRUPTS
;
; ARG INTBIT ;BITS TO CHECK INTERRUPT CONDITIONS
;
; ARG BITCLR ;BITS TO CLEAR INTERRUPT CONDITIONS
; ;IF CLEARING INTERRUPT BITS WON'T CLEAR
; ;THEM. [EXAMPLE - DL10]
;
; ARG INTSUB ;subroutine to cause interrupt, if normal bit
; ;setting doesnt work. Otherwise 0.
;
.MACRO $CKINT ENBADR,INTADR,ENLBIT,INTBIT,BITCLR,INTSUB
.IIF NB,ENBADR, MOV ENBADR,R1 ;LOAD ENABLE ADR
.IIF NB,INTADR, MOV INTADR,R2 ;LOAD INTERRUPT ADR
JSR R5,CKINT ;GO CHECK INTERRUPTS
.WORD ENLBIT ;ENABLE BITS - ENLBIT
.WORD INTBIT ;INTERRUPT BITS - INTBIT
.IIF B,BITCLR, .WORD 0 ;NO SPECIAL CLEAR BITS
.IIF NB,BITCLR, .WORD BITCLR ;BITS TO CLEAR DEVICE - BITCLR
.IIF B,INTSUB, .WORD 0 ;no interrupt SUB,routine needed
.IIF NB,INTSUB, .WORD INTSUB ;subroutine to generate interrupt
.ENDM $CKINT
;THIS MACRO IS USED TO TO CALL THE ROUTINE TO CHECK A DEVICE
;AND ASSIGN THE FLOATING ADDRESS AND VECTORS IF THE DEVICE
;IS THE TYPE THAT REQUIRES IT.
;
; ARG A ;DEVICE ADDRESS OR 0 IF FLOATING DEVICE
;
; ARG MAXN ;MAXIMUM NUMBER OF DEVICES
;
; ARG VI ;VECTOR INCREMENT
;
; ARG HI ;HARDWARE INCREMENT
;
; ARG VM ;VECTOR MULTIPLE
;
; ARG NAM ;ADDRESS OF DEVICE NAME
;
; ARG FV ;FIRST VECTOR ADR (FIXED DEV ONLY)
;
.MACRO DEVICE A,MAXN,VI,HI,VM,NAM,FV
;DETERMINE HOW MANY NAM'11S IN SYSTEM
JSR R5,CHKDEV ;ADJUST FLOATING VECTOR FOR NAM'11
.WORD A ;1ST NAM'11 ADR IS A
.BYTE <MAXN>,<VI> ;MAXIMUM NUMBER OF NAM'11 IS MAXN,
; VECTOR INCREMENT IS VI
.BYTE <HI>,<VM> ;HARDWARE INCREMENT IS HI,
; 1ST VECTOR MULTIPLE IS VM
.WORD 0 ;WILL BECOME NUMBER OF DEVICES
.WORD CKN'NAM'11 ;ADDRESS OF ASCIZ \NAM'11\
.IIF NDF CK..'NAM,CK..'NAM=1
.IIF DF CK'NAM'11,CK'NAM'$$=CK'NAM'11 ;IF DEFINED, USE THE PROC
.IIF NDF CK'NAM'11,CK'NAM'$$=CKPOPJ ;ELSE JUST EXIT
.WORD CK'NAM'$$ ;ADDRESS OF ROUTINE TO CHECK
; DEVICE (CK'NAM'11)
.IIF DF CKA'NAM'11,CKA'NAM'$$=CKA'NAM'11 ;IF PROGRAM ENTRY DEFINED, USE IT
.IIF NDF CKA'NAM'11,CKA'NAM'$$=CKPOPJ ;ELSE JUST EXIT
.WORD CKA'NAM'$$ ;CALL FOR MAIN PROGRAM (CKA'NAM'11)
.WORD CKV'NAM'11 ;POINTS TO VECTOR SETUP TABLE
.WORD 0 ;WILL CONTAIN NUMBER OF NAM'11 FOUND
.WORD 0 ;WILL CONTAIN FIRST NAM'11 VECTOR ADR
.IIF NDF,NAM'.LVL,NAM'.LVL=0
.WORD NAM'.LVL*40 ;CONTAINS NAM'11 PI LEVEL
.WORD FV ;DEVICE FIRST VECTOR (FIXED DEV ONLY)
.ENDM DEVICE
.MACRO NODEV TYPE
.IRP TYPX,<TYPE>
.IIF NDF CK..'TYPX,CK..'TYPX=0
.ENDR
.ENDM
;THIS MACRO IS USED FOR SETTING CHARACTERISTICS TABLE
;
; ARG DA ;DEVICE ADDRESS TO PUT IN CHARACTERISTICS TABLE
;
; ARG DV ;DEVICE VECTOR ADDRESS TO PUT IN TABLE
;
; ARG PI ;DEVICE PI LEVEL TO PUT IN TABLE
;
.MACRO CHKCHR DA,DV,PI
.IIF NB,<DA>, MOV DA,CHKCHR+CKDA ;PUT DA IN DEVICE ADR SLOT
.IIF NB,<DV>, MOV DV,CHKCHR+CKDV ;PUT DV IN DEVICE VEC SLOT
.IIF NB,<PI>, MOV PI,CHKCHR+CKPI ;PUT PI IN DEVICE INT LVL SLOT
.ENDM CHKCHR
;THIS MACRO CALLS MACRO "CKVEC1" WHICH BUILDS A TABLE
;FOR EACH DEVICE. THE INFORMATION IN THE TABLE IS OF THE FOLLOWING FORM:
;
; CKV'NAM'11:.BYTE NUMBER OF MAIN ROUTINES,NUMBER OF VECTOR PER DEV
; .WORD NAM'VA'NUM
;
; EXAMPLE:
;
; 1. MAIN PROGRAM HAS 1 DQ11
;
; THE MAIN PROGRAM MUST GIVE DQ #0 VECTOR A THE TAG: DQVA0
;
; DQ #0 VECTOR B THE TAG: DQVB0
;
; THE RESULTING TABLE WILL BE:
;
; CKVDQ11:.BYTE 1,2
; DQAV0
; DQBV0
;
; 2. MAIN PROGRAM HAS 2 DQ11'S
;
; THE MAIN PROGRAM MUST GIVE DQ #0 VECTOR A THE TAG: DQVA0
; DQ #0 VECTOR B THE TAG: DQVB0
; DQ #1 VECTOR A THE TAG: DQVA1
; DQ #1 VECTOR B THE TAG: DQVB1
;
; THE RESULTING TABLE WILL BE:
;
; CKVDQ11:.BYTE 2,2
; DQVA0
; DQVB0
; DQVA1
; DQVB1
;
;
; ARG NAM ;NAME (2 CHARACTERS)
;
; ARG NUMV ;NUMBER OF VECTORS PER DEVICE
;
; ARG MAXN ;MAXIMUM NUMBER OF DEVICES OF A TYPE
;
.MACRO CKVECT NAM,NUMV,MAXN
.IF NE CK..'NAM
CKZQZQ=0
CKV'NAM'11:.BYTE NAM'QQQ,NUMV ;NUM OF VEC FOR EACH NAM'11 IS NUMV
NAM'QQQ=0 ;DEFINE AND SET TO 0
.REPT MAXN
CKVEC1 NAM,NUMV,\CKZQZQ
CKZQZQ=CKZQZQ+1
.ENDR
.ENDC ;.IF NE CK..'NAM
.ENDM CKVECT
;
.MACRO CKVEC1 NAM,NUMV,NUM
.IF DF,NAM'VA'NUM
NAM'QQQ=NAM'QQQ+1 ;COUNT NUMBER IN MAIN
.IIF GE,<NUMV-1>, .WORD NAM'VA'NUM ;VECTOR A FOR DEV NAM'11
.IIF GE,<NUMV-2>, .WORD NAM'VB'NUM ;VECTOR B FOR DEV NAM'11
.IIF GE,<NUMV-3>, .WORD NAM'VC'NUM ;VECTOR C FOR DEV NAM'11
.IIF GE,<NUMV-4>, .WORD NAM'VD'NUM ;VECTOR D FOR DEV NAM'11
.ENDC
.ENDM CKVEC1
;THIS MACRO IS USED FOR SAVING GOOD, BAD, AND ADR ON THE STACK
;PRIOR TO CALLING "CHKERR".
;
; ARG GD ;GOOD DATA
;
; ARG BD ;BAD DATA
;
; ARG ADR ;ADDRESS WHERE IT HAPPENED
;
.MACRO CKSERR GD,BD,ADR
MOV GD,-(SP) ;SAVE GOOD (GD) ON STACK
MOV BD,-(SP) ;SAVE BAD (BD) ON STACK
MOV ADR,-(SP) ;SAVE ADDRESS (ADR) ON STACK
.ENDM CKSERR
.SBTTL DEFINE DEVICE BLOCKS FOR EACH NODE TYPE
; THE CHOICES ARE:
; 1 DC75
; 2 DN80/81/82
; 3 DN85/87
; 4 DN87S
; 5 DN20/21/200
;
; EACH OF THESE ASSIGNS VECTORS AND CSR'S IN A DIFFERENT MANNER.
CKCDEV: ;NOTHING BUT DEVICE MACROS MAY EXIST BETWEEN THE LABELS
;CKCDEV AND CKCEND, AS THESE MACROS CAUSE CODE & TABLES
;TO BE BUILD. ALSO, THE SYMBOL CKCADD MUST BE DEFINED
; TO BE .-CKCDEV AFTER THE FIRST DEVICE MACRO FOR EACH
; TYPE OF SYSTEM (I.E. THE LENGTH OF THE DEVICE MACRO).
.SBTTL DEVICE MACROS FOR ALL POSSIBLE CONFIGURATIONS
.REPT 0
DEVICE CTISTS,1,0,0,0,KL,CTOVEC ;OPR TTY (DL11-A)
DEVICE CR.STS,1,0,0,0,CR,CR.VEC ;CARD READER (CR11)
DEVICE LP.STS,2,<-10>,10,0,LP,LP.VEC ;LINE PRINTER (LP11)
DEVICE PP.STS,1,0,0,0,PP,PP.VEC ;PAPER TAPE PUNCH (PP11)
DEVICE PR.STS,1,0,0,0,PR,PR.VEC ;PAPER TAPE READER (PR11)
DEVICE TC.STS,1,0,0,0,TC,TC.VEC ;DEC TAPE CONTROL (TC11)
DEVICE TM.STS,1,0,0,0,TM,TM.STS ;MAG TAPE CONTROL (TM11)
DEVICE 177446,1,0,0,0,RC,210 ;OLD SMALL DISK (RC11)
DEVICE 177460,1,0,0,0,RF,204 ;FIXED HEAD DISK (RF11)
DEVICE 176700,1,0,0,0,RH,254 ;FANCY DISK CONTROLER (RH11)
DEVICE 176710,1,0,0,0,RP,254 ;DISK PACK CONTROL (RP11-C)
DEVICE 177500,1,0,0,0,TA,260 ;CASSETTE TAPE (TA11)
DEVICE 177404,1,0,0,0,RK,220 ;DISK CARTRIDGE CONTROL (RK11)
DEVICE 172540,1,0,0,0,KP,104 ;REAL TIME CLOCK (KW11-P)
DEVICE DS.DVA,1,20,10,0,DS,DS.VEC ;SYNC I/O (DS11)
.IF NE FTDTE20
DEVICE 174400,1,0,0,0,TE,774 ;TEN/ELEVEN INTERFACE (DTE20-#0)
DEVICE 174440,1,0,0,0,TE,770 ;TEN/ELEVEN INTERFACE (DTE20-#1)
DEVICE 174500,1,0,0,0,TE,764 ;TEN/ELEVEN INTERFACE (DTE20-#2)
DEVICE 174540,1,0,0,0,TE,760 ;TEN/ELEVEN INTERFACE (DTE20-#3)
.ENDC
;
; DN87S/DN61S NON FLOATING HARDWARE
;
DEVICE 176000,1,0,0,0,DL,300 ;TTY INTERFACE (DL11-E)
DEVICE 160020,10,20,20,0,DH,330 ;MULTIPLEX TTY INTERFACE (DH11)
DEVICE 170500,10,20,10,0,DM,320 ;MODEM CONTROL INTERFACE (DM11)
DEVICE 175200,20,4,10,0,DN,660 ;AUTO CALL UNIT (DN11)
DEVICE 160230,14,10,10,0,DQ,520 ;DMA SYNC I/O (DQ11)
;
; END DN87S/DN61S
;
; DN20/DN21 NON FLOATING HARDWARE
;
DEVICE 160540,3,10,10,0,MH,540 ;INTERFACE PROCESSOR (KMC11) for DUP11
DEVICE 160640,3,10,10,0,ME,300 ;KMC11 for DZ
DEVICE 160740,20,10,10,0,MC,670 ;DMC11
DEVICE 160300,14,10,10,0,UP,570 ;INTERUPT SYNC I/O WITH BIT STUFFER (DUP11)
DEVICE 160010,20,10,10,0,DZ,340 ;ASYNC MULTIPLEX I/O (DZ11)
DEVICE LT0STS,2,<-4>,<-20>,0,LT,LT.VEC ;LP20 CONTROLLER
;
; END DN20/DN21
;
DEVICE 174770,40,10,<-10>,10,DP,0 ;INTERUPT SYNC I/O (DP11)
DEVICE 172600,20,4,10,4,R6,0 ;TYPESET PAPER TAPE READER (PA611)
DEVICE 172700,20,4,10,4,P6,0 ;TYPESET PAPER TAPE PUNCH (PA611)
DEVICE 175200,100,4,10,4,DN,0 ;AUTO CALL UNIT (DN11)
DEVICE 170500,20,4,10,10,DM,0 ;MODEM CONTROL INTERFACE (DM11)
DEVICE 175000,4,14,40,14,DV,0 ;SYNC PREPROCESSOR (DV11)
DEVICE 175610,20,10,10,10,DL,0 ;ASYNC I/O (DL11-E)
DEVICE 0,20,10,10,10,DJ,0 ;MULTIPLEXED ASYNC I/O (DJ11)
DEVICE 0,20,10,20,10,DH,0 ;MULTIPLEXED DMA ASYNC I/O (DH11)
DEVICE 0,20,10,10,10,DQ,0 ;DMA SYNC I/O (DQ11)
DEVICE 0,20,10,10,4,DU,0 ;SYNC I/O WITH SYNC FILL (DU11)
DEVICE 0,20,10,10,4,UP,0 ;SYNC I/O WITH BIT STUFFER (DUP11)
DEVICE 0,1,10,10,4,LK,0 ;SPACEWAR BUTTONS ON GT40 (LK11)
DEVICE 0,20,10,10,4,MC,0 ;DDCMP SYNC I/O (DMC11)
DEVICE 0,10,10,10,4,DZ,0 ;MULTIPLEXED ASYNC I/O WITH FIFO (DZ11)
DEVICE 0,3,10,10,4,MD,0 ;INTERFACE PROCESSOR (KMC11)
.ENDR
.SBTTL DC75 DEVICE VECTORS
.IF NE FT.D75
DEVICE CTISTS,1,0,0,0,KL,CTOVEC ;OPR TTY (DL11-A)
CKCADD=.-CKCDEV
DEVICE 172540,1,0,0,0,KP,104 ;REAL TIME CLOCK (KW11-P)
DEVICE DS.DVA,1,20,10,0,DS,DS.VEC ;SYNC I/O (DS11)
.ENDC ;.IF NE FT.D75
.SBTTL DN80,DN81,DN82 VECTOR TABLES
.IF NE FT.D80!FT.D81!FT.D82
DEVICE CTISTS,1,0,0,0,KL,CTOVEC ;OPR TTY (DL11-A)
CKCADD=.-CKCDEV
DEVICE CR.STS,1,0,0,0,CR,CR.VEC ;CARD READER (CR11)
DEVICE LP.STS,2,<-10>,10,0,LP,LP.VEC ;LINE PRINTER (LP11)
DEVICE PP.STS,1,0,0,0,PP,PP.VEC ;PAPER TAPE PUNCH (PP11)
DEVICE PR.STS,1,0,0,0,PR,PR.VEC ;PAPER TAPE READER (PR11)
DEVICE 172540,1,0,0,0,KP,104 ;REAL TIME CLOCK (KW11-P)
DEVICE 174770,40,10,<-10>,10,DP,0 ;INTERUPT SYNC I/O (DP11)
DEVICE 172600,20,4,10,4,R6,0 ;TYPESET PAPER TAPE READER (PA611)
DEVICE 172700,20,4,10,4,P6,0 ;TYPESET PAPER TAPE PUNCH (PA611)
DEVICE 175200,100,4,10,4,DN,0 ;AUTO CALL UNIT (DN11)
DEVICE 170500,20,4,10,10,DM,0 ;MODEM CONTROL INTERFACE (DM11)
DEVICE 175610,20,10,10,10,DL,0 ;ASYNC I/O (DL11-E)
DEVICE 0,20,10,10,10,DJ,0 ;MULTIPLEXED ASYNC I/O (DJ11)
DEVICE 0,20,10,20,10,DH,0 ;MULTIPLEXED DMA ASYNC I/O (DH11)
DEVICE 0,20,10,10,10,DQ,0 ;DMA SYNC I/O (DQ11)
DEVICE 0,20,10,10,4,DU,0 ;SYNC I/O WITH SYNC FILL (DU11)
DEVICE 0,20,10,10,4,UP,0 ;SYNC I/O WITH BIT STUFFER (DUP11)
DEVICE 0,1,10,10,4,LK,0 ;SPACEWAR BUTTONS ON GT40 (LK11)
DEVICE 0,20,10,10,4,MC,0 ;DDCMP SYNC I/O (DMC11)
DEVICE 0,10,10,10,4,DZ,0 ;MULTIPLEXED ASYNC I/O WITH FIFO (DZ11)
DEVICE 0,3,10,10,4,MD,0 ;INTERFACE PROCESSOR (KMC11)
.ENDC ;.IF NE FT.D80!FT.D81!FT.D82
.SBTTL DN85,DN87 VECTOR TABLES
.IF NE FT.D85!FT.D87
DEVICE CTISTS,1,0,0,0,KL,CTOVEC ;OPR TTY (DL11-A)
CKCADD=.-CKCDEV
DEVICE CR.STS,1,0,0,0,CR,CR.VEC ;CARD READER (CR11)
DEVICE LP.STS,2,<-10>,10,0,LP,LP.VEC ;LINE PRINTER (LP11)
DEVICE PP.STS,1,0,0,0,PP,PP.VEC ;PAPER TAPE PUNCH (PP11)
DEVICE PR.STS,1,0,0,0,PR,PR.VEC ;PAPER TAPE READER (PR11)
DEVICE 172540,1,0,0,0,KP,104 ;REAL TIME CLOCK (KW11-P)
DEVICE 174770,40,10,<-10>,10,DP,0 ;INTERUPT SYNC I/O (DP11)
DEVICE 172600,20,4,10,4,R6,0 ;TYPESET PAPER TAPE READER (PA611)
DEVICE 172700,20,4,10,4,P6,0 ;TYPESET PAPER TAPE PUNCH (PA611)
DEVICE 175200,100,4,10,4,DN,0 ;AUTO CALL UNIT (DN11)
DEVICE 170500,20,4,10,10,DM,0 ;MODEM CONTROL INTERFACE (DM11)
DEVICE 175610,20,10,10,10,DL,0 ;ASYNC I/O (DL11-E)
DEVICE 0,20,10,10,10,DJ,0 ;MULTIPLEXED ASYNC I/O (DJ11)
DEVICE 0,20,10,20,10,DH,0 ;MULTIPLEXED DMA ASYNC I/O (DH11)
DEVICE 0,20,10,10,10,DQ,0 ;DMA SYNC I/O (DQ11)
.ENDC ;.IF NE FT.D85!FT.D87
.SBTTL DN87S,DN61S DEVICE VECTOR TABLES
.IF NE FT.87S
DEVICE CTISTS,1,0,0,0,KL,CTOVEC ;OPR TTY (DL11-A)
CKCADD=.-CKCDEV
DEVICE CR.STS,1,0,0,0,CR,CR.VEC ;CARD READER (CR11)
DEVICE LP.STS,2,<-10>,10,0,LP,LP.VEC ;LINE PRINTER (LP11)
DEVICE PP.STS,1,0,0,0,PP,PP.VEC ;PAPER TAPE PUNCH (PP11)
DEVICE PR.STS,1,0,0,0,PR,PR.VEC ;PAPER TAPE READER (PR11)
DEVICE 172540,1,0,0,0,KP,104 ;REAL TIME CLOCK (KW11-P)
.IF NE FTDTE20
DEVICE 174400,1,0,0,0,TE,774 ;TEN/ELEVEN INTERFACE (DTE20-#0)
DEVICE 174440,1,0,0,0,TE,770 ;TEN/ELEVEN INTERFACE (DTE20-#1)
DEVICE 174500,1,0,0,0,TE,764 ;TEN/ELEVEN INTERFACE (DTE20-#2)
DEVICE 174540,1,0,0,0,TE,760 ;TEN/ELEVEN INTERFACE (DTE20-#3)
.ENDC
;
; DN87S/DN61S NON FLOATING HARDWARE
;
DEVICE 176000,1,0,0,0,DL,300 ;TTY INTERFACE (DL11-E)
DEVICE 160020,10,20,20,0,DH,330 ;MULTIPLEX TTY INTERFACE (DH11)
DEVICE 170500,10,20,10,0,DM,320 ;MODEM CONTROL INTERFACE (DM11)
DEVICE 175200,20,4,10,0,DN,660 ;AUTO CALL UNIT (DN11)
DEVICE 160230,14,10,10,0,DQ,520 ;DMA SYNC I/O (DQ11)
;
; END DN87S/DN61S
;
.IF NE FTGLOM ; BIGLIST SWITCH AND ALL DEVICES
DEVICE 177446,1,0,0,0,RC,210 ;OLD SMALL DISK (RC11)
DEVICE 177460,1,0,0,0,RF,204 ;FIXED HEAD DISK (RF11)
DEVICE 176700,1,0,0,0,RH,254 ;FANCY DISK CONTROLER (RH11)
DEVICE 176710,1,0,0,0,RP,254 ;DISK PACK CONTROL (RP11-C)
DEVICE TC.STS,1,0,0,0,TC,TC.VEC ;DEC TAPE CONTROL (TC11)
DEVICE TM.STS,1,0,0,0,TM,TM.STS ;MAG TAPE CONTROL (TM11)
DEVICE 177500,1,0,0,0,TA,260 ;CASSETTE TAPE (TA11)
DEVICE 177404,1,0,0,0,RK,220 ;DISK CARTRIDGE CONTROL (RK11)
DEVICE DS.DVA,1,20,10,0,DS,DS.VEC ;SYNC I/O (DS11)
DEVICE 174770,40,10,<-10>,10,DP,0 ;INTERUPT SYNC I/O (DP11)
DEVICE 172600,20,4,10,4,R6,0 ;TYPESET PAPER TAPE READER (PA611)
DEVICE 172700,20,4,10,4,P6,0 ;TYPESET PAPER TAPE PUNCH (PA611)
DEVICE 0,20,10,10,10,DJ,0 ;MULTIPLEXED ASYNC I/O (DJ11)
DEVICE 0,20,10,10,4,DU,0 ;SYNC I/O WITH SYNC FILL (DU11)
DEVICE 0,20,10,10,4,UP,0 ;SYNC I/O WITH BIT STUFFER (DUP11)
DEVICE 0,1,10,10,4,LK,0 ;SPACEWAR BUTTONS ON GT40 (LK11)
DEVICE 0,20,10,10,4,MC,0 ;DDCMP SYNC I/O (DMC11)
DEVICE 0,10,10,10,4,DZ,0 ;MULTIPLEXED ASYNC I/O WITH FIFO (DZ11)
DEVICE 0,3,10,10,4,MD,0 ;INTERFACE PROCESSOR (KMC11)
.ENDC ;.IF NE FTGLOM
.ENDC ;.IF NE FT.87S
.SBTTL DN20,DN200 DEVICE VECTOR TABLES
.IF NE FT.D20!FT.200
DEVICE CTISTS,1,0,0,0,KL,CTOVEC ;OPR TTY (DL11-A)
CKCADD=.-CKCDEV
DEVICE CR.STS,1,0,0,0,CR,CR.VEC ;CARD READER (CR11)
DEVICE LP.STS,2,<-10>,10,0,LP,LP.VEC ;LINE PRINTER (LP11)
DEVICE PP.STS,1,0,0,0,PP,PP.VEC ;PAPER TAPE PUNCH (PP11)
DEVICE PR.STS,1,0,0,0,PR,PR.VEC ;PAPER TAPE READER (PR11)
DEVICE 172540,1,0,0,0,KP,104 ;REAL TIME CLOCK (KW11-P)
.IF NE FTDTE20
DEVICE 174400,1,0,0,0,TE,774 ;TEN/ELEVEN INTERFACE (DTE20-#0)
DEVICE 174440,1,0,0,0,TE,770 ;TEN/ELEVEN INTERFACE (DTE20-#1)
DEVICE 174500,1,0,0,0,TE,764 ;TEN/ELEVEN INTERFACE (DTE20-#2)
DEVICE 174540,1,0,0,0,TE,760 ;TEN/ELEVEN INTERFACE (DTE20-#3)
.ENDC
;
; DN20/DN21 NON FLOATING HARDWARE
;
.IF NE,FT.DQ ;if this DN20 has a DQ11
DEVICE 160230,14,10,10,0,DQ,520 ;DMA SYNC I/O (DQ11)
.ENDC ;.IF NE,FT.DQ
DEVICE 160540,3,10,10,0,MH,540 ;INTERFACE PROCESSOR (KMC11) for DUP
DEVICE 160300,14,10,10,0,UP,570 ;INTERUPT SYNC I/O WITH BIT STUFFER (DUP11)
DEVICE 160640,3,10,10,0,ME,300 ;KMC11 for DZ
DEVICE 160740,20,10,10,0,MC,670 ;DMC11
DEVICE 160010,20,10,10,0,DZ,340 ;ASYNC MULTIPLEX I/O (DZ11)
DEVICE LT0STS,2,<-4>,<-20>,0,LT,LT.VEC ;LP20 CONTROLLER
;
; END DN20/DN21
;
.ENDC ;.IF NE FT.D20!FT.200
CKCEND: ; END OF DEVICE TABLES
RTS PC
;FORCE THESE DEVICES (MAYBE)
.IIF NDF,CK..VR,CK..VR=0 ;don't print version unless asked
.IIF EQ FT.D75,CK..MM=1 ;MF11-UP
CK..KG=0 ;assume we don't need KG11
.IIF EQ,FTKG11,CK..KG=1 ;KG11-A if we need it
CK..KW=1 ;KW11-L
CK..CI=1 ;CTY I
CK..CO=1 ;CTY O
.IIF NE FTDL10!FTGLOM,CK..D1=1 ;DL10
NODEV <LT,CI,CO,MM,D1,KW,ME,MH>
NODEV <KL,CR,LP,PP,PR,TC,TM,RC,RF,RH,RP,TA,RK,KP,DS,TE>
NODEV <DL,DH,DM,DN,DQ,MD,UP,DZ,DP,R6,P6,DJ,DU,LK,MC,DV>
;
; GLOBAL CELLS FOR CHECK11
;
CHKFLG: .BLKW 1 ;CHK60 FLAGS
CKFERR= B0 ;ERROR DETECTED
CHKMMO= B1 ;memory management on [3(47)]
CKFIDT= B15 ;ID ALREADY TYPED
CKDEVN: .BLKW 1 ;UNIT # CURRENTLY BEING TESTED
CKDNAM: .BLKW 1 ;ADR OF DEVICE NAME(.ASCIZ)
.MACRO DEVTXT DEV,LAB,TEXTX
.IF NB,<DEV>
.IF NE CK..'DEV
LAB: .ASCIZ \TEXTX\
.ENDC
.IFF;.IF NB,<DEV>
LAB: .ASCIZ \TEXTX\
.ENDC;.IF NB,<DEV>
.ENDM DEVTXT
.MACRO DEVEQ OLD,NEW
.IF DF,CKA'OLD'11
CKA'NEW'11==CKA'OLD'11
.IFF;.IF DF,CKA'OLD'11
CKA'NEW'11=CKPOPJ
.ENDC;.IF DF,CKA'OLD'11
NEW'.LVL='OLD'.LVL
.ENDM DEVEQ
DEVTXT CI,CKNCI1,<CTY I>
DEVTXT CO,CKNCO1,<CTY O>
DEVTXT CR,CKNCR1,<CR11>
DEVTXT DH,CKNDH1,<DH11>
DEVTXT DJ,CKNDJ1,<DJ11>
DEVTXT D1,CKND10,<DL10>
DEVTXT KL,CKNKL1,<DL11-A>
DEVTXT DL,CKNDL1,<DL11-E>
DEVTXT DM,CKNDM1,<DM11-BB>
DEVTXT MC,CKNMC1,<DMC11>
DEVTXT MD,CKNMD1,<KMC11>
DEVTXT ME,CKNME1,<KMC11-DZ>
DEVTXT MH,CKNMH1,<KMC11-DUP>
DEVTXT DN,CKNDN1,<DN11>
DEVTXT DP,CKNDP1,<DP11>
DEVTXT DQ,CKNDQ1,<DQ11>
DEVTXT DS,CKNDS1,<DS11>
DEVTXT TE,CKNTE1,<DTE20>
DEVTXT DU,CKNDU1,<DU11>
DEVTXT UP,CKNUP1,<DUP11>
DEVTXT DV,CKNDV1,<DV11>
DEVTXT DZ,CKNDZ1,<DZ11>
DEVTXT ,CKNKG1,<KG11-A>
DEVTXT KW,CKNKW1,<KW11-L>
DEVTXT LK,CKNLK1,<LK11>
DEVTXT LP,CKNLP1,<LP11>
DEVTXT LT,CKNLT1,<LP20>
DEVTXT MM,CKNMM1,<MF11-UP>
DEVTXT PP,CKNPP1,<PP11>
DEVTXT PR,CKNPR1,<PR11>
DEVTXT P6,CKNP61,<PA611-P>
DEVTXT R6,CKNR61,<PA611-R>
DEVTXT RC,CKNRC1,<RC11>
DEVTXT RF,CKNRF1,<RF11>
DEVTXT RK,CKNRK1,<RK11>
DEVTXT RH,CKNRH1,<RH11>
DEVTXT RP,CKNRP1,<RP11-C>
DEVTXT TA,CKNTA1,<TA11>
DEVTXT TC,CKNTC1,<TC11>
DEVTXT TM,CKNTM1,<TM11>
DEVTXT KP,CKNKP1,<KW11-P>
.EVEN
CK.CAL: .BLKW 1 ;ADR OF JSR PC,CHK.11 IN MAIN PROGRAM
CHK.11: RESET ;CLEAR THE WORLD
MTPS #BR7 ;PROCESSOR LEVEL TO 7
MOV (SP)+,CK.CAL ;SAVE CALLING ADDRESS
MOV #FLOATV,CHKFLV ;FLOATING INT VEC BEGIN HERE
MOV #FLOATD,CHKFLD ;FLOATING DEV ADR'S BEGIN HERE
CLR CHKFLG ;CLEAR CHK60 FLAGS
CLR CKSPCD ;CLEAR STOP CODE; NON 0 ON FATAL
; ERROR PUTS C(CKSPCD) IN R0.
;INITIALIZE VECTOR SPACE
;
CKINTS: MOV 14,R3 ;SAVE ODT ADDRESS
CLR R0 ;START LOADING AT ADR 0
MOV #CHKINT,R1 ;WHERE TO GO ON INTERRUPT
MOV #BR7,R2 ;INTERRUPT PS
11$: MOV R1,(R0)+ ;SET INTERRUPT VECTOR
MOV R2,(R0)+ ;SET INTERRUPT LEVEL
INC R2
BIT #77,R0 ;HAVE WE HIT A LIMIT ?
BNE 12$
ADD #CHKITL,R1 ;YES SO CHANGE VECTOR
MOV #BR7,R2 ;RESET PS
12$:
.IF GE PDL-1000
CMP R0,#1000 ;FILL VECTORS UP TO 1000
.IFF
CMP R0,#PDL-2 ;OR UP TO START OF PROGRAM
.ENDC
BLT 11$ ;MORE TO DO.
MOV #CHKERR,TRPVEC ;WHERE TO GO ON ERROR TRAP
MOV R3,14 ;RESTORE ODT ADDRESS
;NOW CHECK THE CTY
;
MOV #13$,NXMVEC ;WHERE TO TRAP IF NO CTY
BIC #CKFIDT,CHKFLG ;SO WE PRINT DEV ID
TST CTOSTS ;CHECK CTY TRANSMIT STATUS REGISTER
TST CTOCHR
TST CTISTS
TST CTICHR
MOV #CKBUST,NXMVEC ;WHERE TO GO ON ILLEGAL NXM TRAP
BR 14$
13$: MOV #S..CTY,R0 ;NO CTY STOP CODE
HALT
MOV #13$,R0 ;ADR OF ERROR
HALT ;DISPLAY ADDRESS
JMP BEGIN ;DO TEST AGAIN IF HE CONTINUES
14$: MOV #CTOSTS,R4 ;CTY PUN STATUS
MOV R4,CHKCHR+CKDA ;DEV ADR
MOV R4,R1 ;CHKBIT NEEDS ADR IN R1
MOV #CTOVEC,CHKCHR+CKDV ;CTY PUN VECTOR
MOV #CKNCO1,CKDNAM ;NAME ADDRESS
CLR CKDEVN ;DEVICE 0
JSR R5,CHKBIT ;CHECK THE FOLLOWING BITS FOR R/W
CO.INE!CO..MM ;BITS TO CHECK FOR R/W
MOV #CO.INE,(R4) ;ENABLE INTERRUPTS
JSR R5,CHKINL ;CHECK INTERRUPT AND FIND DEV LEVEL
-1 ;TIME LOOP CONSTANT
CLR (R4) ;CLR DEV OUT
;NOW CHECK THE KBRD SECTION
;
CHKBRD: BIC #CKFIDT,CHKFLG ;SO WE PRINT DEV ID
MOV #CTISTS,R4 ;KBRD STATUS REG
MOV R4,CHKCHR+CKDA ;DEV ADR
MOV R4,R1 ;CHKBIT NEEDS ADR IN R1
MOV #CTIVEC,CHKCHR+CKDV ;VECTOR ADR
MOV #CKNCI1,CKDNAM ;ADR OF DEV NAME
JSR R5,CHKBIT ;CHECK THE FOLLOWING BITS
CI.INE ;BITS TO CHECK R/W
11$: CK11SC <0>,<Initializing >
.ASCIZ \Initializing \
.EVEN
MOV @CK.CALL,R0 ;GET ADDR OF .ASCIZ \PROG NANME\
JSR PC,CKTTXT ;TYPE PROGRAM NAME
.IF NE,CK..VR
CK11SC <CKENCL>,< v>
.ASCIZ \ v\
.EVEN
MOV JOBVER,R0 ;GET SOFTWARE VERSION NUMBER
JSR PC,CKTOCT
MOV JOBVER+2,R1 ;MINOR VERSION NUMBER
BEQ 12$ ;NONE.
ADD #'A-1,R1 ;MAKE A LETTER
JSR PC,CKTCHR
12$: MOV #'(,R1 ;() AROUND EDIT NUMBER
JSR PC,CKTCHR
MOV JOBVER+4,R0 ;EDIT NUMBER
JSR PC,CKTOCT
MOV #'),R1
JSR PC,CKTCHR
MOV JOBVER+6,R0 ;WHO LAST EDITED
BEQ 13$
MOV #'-,R1
JSR PC,CKTCHR
JSR PC,CKTOCT
13$:
.ENDC;.IF NE,CK..VR
.IF NE FT.CPU
;Determine CPU type [1(14)]
MOV #CKWRD,R0 ;point to word
; MOV R0,(R0)+ ;see behavior of CPU
.WORD 10020 ;so we don't get assembly error
CMP CKWRD,#CKWRD ;see what got stored
BNE CK4020 ;incremented, go distinguish 11/40 and 11/20
;here if 11/05, 11/04, 11/34, or 11/45
MOV #CKJMP,R0 ;point to dispatch table
; JMP (R0)+ ;go to appropriate place [1(15)]
.WORD 120 ;the above instruction (so we don't get Z error) [1(15)]
;here if 11/04, 11/34, or 11/45
CK0434: ;here to distinguish 04 from 34
MOV 4,-(SP) ;save NXM routine address on stack
MOV #12$,4 ;point to NXM handler
MOV #177770,R0 ;starting address
11$: ;loop to look for NXM
TST (R0) ;check this address
SUB #2,R0 ;wasn't NXM, try previous word
BNE 11$ ;keep looking
CK11SC <CKEFAT!CKEPC>,<no NXM??>,<no memory address caused NXM>
.ASCIZ /no NXM??/
.EVEN
12$: ;here when NXM address found
ADD #4,SP ;adjust stack
MOV #13$,4 ;next NXM address
MOV R0,R1 ;copy address
MOV R2,(R0)+ ;do it
HALT ;can never happen
13$: ;here on second NXM
ADD #4,SP ;adjust stack
CMP R0,R1 ;check values
BEQ CK04 ;if equal, it's an 11/04
MOV (SP)+,4 ;restore NXM trap
MOV 10,-(SP) ;save bad instruction trap
MOV #14$,10 ;point to us
.WORD 106700 ;execute 11/34 only instruction
MOV (SP)+,10 ;restore trap
BR CK34
14$: ;here if 11/45
ADD #4,SP ;adjust stack
MOV (SP)+,10 ;restore trap
BR CK45
CK4020: ;here to distinguish 11/40 from 11/20
MOV #CKJMP2,R0 ;point to dispatch
; JMP (R0)+ ;branch [1(15)]
.WORD 120 ;the above instruction (so we don't get Z error) [1(15)]
CKJMP: BR CK0434 ;here if doesn't increment [1(15)]
BR CK05 ;here if it does [1(15)]
CKJMP2: BR CK40 ;here if doesn't increment [1(15)]
BR CK20 ;here if it does [1(15)]
CK04: ;here if 11/04
JSR R0,CKTCRL ;print message
.ASCIZ % KD11-D (11/04)%
.EVEN
BR CKCPUE ;done
CK05: ;here if 11/05
JSR R0,CKTCRL ;print message
.ASCIZ % KD11-B (11/05 or 11/10)%
.EVEN
BR CKCPUE
CK20: ;here if 11/20
JSR R0,CKTCRL ;print message
.ASCIZ % KA11 (11/20) or KC11 (11/15)%
.EVEN
BR CKCPUE ;exit
CK34: ;here if 11/34
JSR R0,CKTCRL ;print message
.ASCIZ % KD11-E (11/34)%
.EVEN
BR CKCPUE
CK40: ;here if 11/40
JSR R0,CKTCRL ;print message
.ASCIZ % KD11-A (11/35 or 11/40)%
.EVEN
BR CKCPUE
CK45: ;here if 11/45
JSR R0,CKTCRL ;print message
.ASCIZ % KB11-A (11/45)%
.EVEN
BR CKCPUE
CKWRD: .WORD 0 ;word for checking CPU
CKCPUE: ;continue
.ENDC
CLR DL10AD
.IF NE CK..D1
;DETERMINE THE DL10 BASE ADDRESS
;
.IIF NDF,DL10SR,DL10SR=160000 ;STOP ADDRESS TO CHECK FOR DL10
CKDLXB:
.IF EQ,<CHKFFA&3777>
MOV #CHKFFA,R0 ;SET ADDRESS TO START LOOKING FOR A DL10
.ENDC
.IF NE,<CHKFFA&3777>
MOV #<CHKFFA!3777>+1,R0 ;SET ADDRESS TO START LOOKING FOR A DL10
.ENDC
CLR DL10AD ;SET FOR NO DL10
MOV #16$,NXMVEC ;WHERE TO GO ON A NXM
11$: MOV #DL.CNX!DL.CPE!DL.CWC!DL.11C,R1 ;BITS TO SET IN DL10
MOV (R0),R2 ;SAVE CONTENTS AS IT MAY BE CORE
BIS R1,(R0) ;CLEAR THESE CONDITIONS IF DL10
; OR IF MEMORY BITS WILL BE SET
ASL R1 ;POSITION BITS FOR SETTING CONDITIONS
CLR (R0) ;SEE IF SOMETHING THERE AND CLEAR IF IT IS THERE
TST (R0) ;MAKE SURE ITS CLEAR SINCE ITS THERE
BEQ 12$ ;BRANCH IF IT CLEARED
CLR -(SP) ;RESULT SHOULD BE 0
MOV (R0),-(SP) ;SAVE WHAT IT WAS
MOV R0,-(SP) ;SAVE THE ADDRESS WHERE IT HAPPENED
CK11SC <CKEFAT!CKEPC!CKEGB>,<Can't Clear DL10 or MEM>,<CLR @R0 DIDN'T CLEAR @R0>,<S..DL10>
.ASCIZ \Can't Clear DL10 or MEM\
.EVEN
12$: BIS R1,(R0) ;NOW SET DL10 BITS
CMP R1,(R0) ;SEE IF THEY SET BE IT MEMORY OR DL10
BEQ 13$ ;BRANCH IF THE SET OK
CKSERR R1,<(R0)>,R0 ;SAVE GD,BD,ADR
CK11SC <CKEFAT!CKEPC!CKEGB>,<DL10 or Mem Err>,<EITHER DL10 IS BAD OR MEMORY IS BAD>,<S..DL10>
.ASCIZ \DL10 or Mem Err\
.EVEN
13$: CLC ;CARRY MUST BE CLR
ROR R1 ;SHIFT TO CLEAR BITS JUST SET
BIS R1,(R0) ;SET BITS, IF DL10 ALL BITS SHOULD BE 0
TST (R0) ;SEE IF ALL 0
BEQ 17$ ;BRANCH IF SO
14$: MOV R2,(R0) ;RESTORE MEMORY
15$: ADD #4000,R0 ;GO TO NEXT POSSIBLE DL10 ADR
CMP R0,#DL10SR ;TIME TO STOP CHECKING FOR DL10?
BLOS 11$ ;BRANCH IF NOT
BR 18$ ;NEVER FOUND A DL10
16$: ADD #4,SP ;FLUSH NXM TRAP
BR 15$ ;GO CHECK NEXT POSSIBLE ADR
17$: MOV R0,DL10AD ;PUT DL10 BASE ADDR WE FOUND AWAY
18$:
.ENDC ;.IF NE CK..D1
;
;HERE TO SEE HOW MUCH CORE IS PRESENT
;
CHKCOR: CLR R0 ;START SMALL
MOV #12$,NXMVEC ;SET BUS TRAP VECTOR
11$: TST (R0) ;check this location [1(14)]
ADD #2,R0 ;point to next location [1(14)]
CMP R0,DL10AD ;SEE IF NEXT WORD IS DL10
BEQ 13$ ;;!!;;YES
CMP R0,#160000 ;;!!;;BEYOND 28K?
BNE 11$
BR 13$
12$: ADD #4,SP ;FLUSH STACK
13$: MOV R0,PHYLIM ;SAVE ADR OF 1ST NXM LOCATION
.IIF DF,CKAMEM,JSR PC,CKAMEM ;PRINT LAST MEM LOCATION
;
; ; CONTINUED ON NEXT PAGE
;
.SBTTL CHECK MEMORY - SLIDING BIT PATTERN
;HERE TO PERFORM A SIMPLE TEST ON FREE CORE.
;THE PATTERN USED IS A SLIDING BIT, WITH THE
;BIT IN EACH OF THE 16 BIT POSITIONS AND THE
;LAST PATTERN BEING ALL 0'S.
;
CKCOR:
CLR R0 ;FIRST ADR TO CHECK
MOV #11$,R1 ;LIMIT TO CHECK
JSR PC,11$ ;CHECK LOW CORE
MOV #CKMPAR,R0 ;BEGIN CHECKING HERE NOW
MOV PHYLIM,R1 ;AND STOP HERE
JSR PC,11$
JSR R0,CKTCRL ;PRINT AMOUNT OF CORE
.ASCIZ \ \
.EVEN
MOV PHYLIM,R0 ;GET AMOUNT
JSR PC,CKTOCT ;PRINT IT
JSR R0,CKTSTR ;FOLLOWED BY MSG:
.ASCIZ \ bytes of memory\
.EVEN
BR CKMPAR ;ALL OK
11$: MOV #1,R2 ;FIRST PATTERN
MOV @R0,R3 ;SAVE CURRENT DATA
12$: MOV R2,@R0 ;PUT PATTERN IN MEMORY
COM @R0 ;COMPLEMENT IT
COM @R0 ; AND AGAIN
CMP R2,@R0 ;DID IT GO ?
BEQ 13$ ;YES.
CKSERR R2,<(R0)>,R0 ;SAVE GD,BD,ADR
CK11SC <CKEMSE!CKEFAT!CKEPC!CKEGB!CKADPH>,<CKMG01>,<MEMORY ERROR>,<S..MEM>
13$: ASL R2 ;SHIFT PATTERN
BNE 12$
BCS 12$
MOV R3,@R0 ;RESTORE DATA
COM @R0 ;COMPLEMENT IT
COM @R0 ; AND AGAIN
CMP R3,(R0)+ ;BE SURE IT WENT
BEQ 14$
CKSERR R3,<-(R0)>,R0 ;SAVE GD,BD,ADR
CK11SC <CKEMSE!CKEFAT!CKEPC!CKEGB>,<CKMG01>,<MEMORY ERROR>,<S..MEM>
14$: CMP R0,R1
BNE 11$ ;LOOP BACK FOR REST OF MEMORY
CKPOPJ: RTS PC
;HERE TO CHECK THE MEMORY PARITY OPTION
CKMPAR: ;START CHECKING CORE HERE
.IF EQ FT.D75
.IF NDF,FT.MF
MOV #CKNMM1,CKDNAM ;SAVE NAME OF "DEVICE"
CLR CKDEVN ;"UNIT" IS 0
MOV #MP.REG,R1 ;OPTION REGISTER
MOV R1,CHKCHR+CKDA ;SAVE ADR IN CASE NEED TO TYPE IT
MOV NXMVEC,-(SP)
MOV #MP.VEC,CHKCHR+CKDV ;VECTOR FOR INTERRUPTS
CLR CHKCHR+CKPI ;NO PRIORITY LEVEL
MOV #14$,NXMVEC ;IN CASE PARITY OPTION NOT INSTALLED
CLR MP.REG ;TRY TO CLEAR MEMORY PARITY REGISTER
MOV (SP),NXMVEC ;RESTORE TRAP VECTOR
JSR R5,CHKBIT ;CHECK READ/WRITE BITS
107745
;NOW CHECK INTERRUPTS FROM PARITY CONTROL
; THIS IS DIFFICULT CUZ SETTING MP.ENB & MP.ERR WON'T CAUSE INTERRUPT
CLR R0 ;VECTOR WE TOOK WILL APPEAR HERE
MOV #MP.WWP,@R1 ;WE WANT TO WRITE WRONG PARITY
MOV CKMPAR,CKMPAR ;WRITE A BAD WORD
CLR @R1 ;BUT ONLY ONE WORD !
TST CKMPAR ;TRY FOR AN INTERRUPT
NOP ;IN CASE SLOW
TST R0 ;SEE IF WE GOT ONE
BEQ 11$
CK11SC <CKEMSE!CKEDID!CKEPC>,CKMG07,<INTERRUPTED WHEN NOT ENABLED>
11$: MOV #MP.ENB,@R1 ;NOW LETS GET THE INTERRUPT
TST CKMPAR
CLR @R1 ;DISABLE FURTHER INTERRUPTS
MOV CKMPAR,CKMPAR ;WRITE BACK RIGHT
TST R0 ;DID WE GET THE INTERRUPT ?
BNE 12$
CK11SC <CKEDID!CKEMSE!CKEPC>,CKMG04,<INTERRUPT DID NOT OCCUR>
BR 15$
12$: CMP R0,CHKCHR+CKDV ;WAS INTERRUPT RIGHT?
BEQ 13$ ;YES.
CKSERR <CHKCHR+CKDV>,R0,<#CKMPAR> ;GD,BD,ADR
CK11SC <CKEMSE!CKEDID!CKEPC!CKEGB>,CKMG05,<interrupted to wrong vector>
BR 15$ ;DONE.
; COME HERE IF PARITY OPTION IS PRESENT AND WORKING
13$: JSR R0,CKTCRL ;PRINT MESSAGE ABOUT IT
.ASCIZ \ MF11-UP\
.EVEN
MOV #MP.ENB,MP.REG ;ENABLE PARITY ERRORS
.IIF DF,CKAMF1,JSR PC,CKAMF1 ;DO MAIN LINE CHECKING
BR 15$ ;ALL DONE.
;HERE IF WE GET A BUS TRAP WHILE ACCESSING THE PARITY CONTROL REG
14$: MOV (SP)+,(SP)+ ;CLEAN OFF STACK
CK11SC <CKEDID!CKEPC!CKEMSE>,CKMG06,<not found>
15$: MOV (SP)+,NXMVEC
.ENDC ;.IF NDF FT.MF
.ENDC ;.IF EQ FT.D75
;HERE TO SEE IF ROM = BM873 OR M9301 IS PRESENT
.IF DF FT.ROM
.IF NE FT.ROM
CK.ROM: MOV NXMVEC,-(SP) ;SAVE BUSTRAP VECTOR
MOV #11$,NXMVEC
TST ROMADR ;IS ROM REALLY HERE ?
BR 12$ ;YES
;HERE BECAUSE ROM NOT PRESENT
11$: CLR GO.ROM ;MAKE JMP ROMADR = HALT
MOV (SP)+,(SP)+ ;CLEAN OFF STACK
12$: MOV (SP)+,NXMVEC
.ENDC;.IF NE FT.ROM
.ENDC;.IF DF FT.ROM
.SBTTL CHECK KW11-L HDW
;HERE TO BE SURE CLOCK IS PRESENT AND TICKS
CHKCLK: MOV #CKNKW1,CKDNAM ;SET UP FOR NAME
BIC #CKFIDT,CHKFLG ;SO WE PRINT DEV ID
MOV #CLKWRD,R4 ;SET UP DEV ADR
MOV R4,CHKCHR+CKDA ;SET UP DEVICE ADR
MOV #CLKVEC,CHKCHR+CKDV ;SET UP VECTOR ADR
CLR CKDEVN ;DEVICE NUMBER
MOV #13$,NXMVEC ;SET BUS TRAP IN CASE CLOCK IS NOT PRESENT
TST (R4) ;TRAP IF NOT INSTALLED
MOV #CKBUST,NXMVEC ;WHERE TO GO ON BUS TRAP
MOV CLKVEC,-(SP) ;SAVE WHERE TO GO ON INT
MOV #14$,CLKVEC ;SETUP INTERRUPT VECTOR
MOV #3,CHKTIM ;TIME 3 TICKS
MTPS #0 ;LET INTERRUPTS HAPPEN
MOV #KW.INE,(R4) ;ENABLE THE CLOCK
BEQ 12$ ;IF COUNTED OUT ALREADY EVIL
CLR R0 ;INITIALIZE WATCHDOG COUNTER
TST CHKTIM ;see if count expired now [1(14)]
BEQ 12$ ;yes, too fast [1(14)]
11$: TST CHKTIM
BEQ CKCLK9 ;BRANCH IF TIMED OUT ALREADY
SOB R0,11$
CK11SC <CKEFAT!CKEPC!CKEDID>,<Slow>,<NO RESPONSE FROM KW11>,<S..KW1>
.ASCIZ \Slow\
.EVEN
12$: CK11SC <CKEFAT!CKEPC!CKEDID>,<Fast>,<KW11 TICKING TO FAST>,<S..KW1>
.ASCIZ \Fast\
.EVEN
13$: CK11SC <CKEFAT!CKEPC!CKEDID>,<Not Present>,<CAN' ACCESS KW11>,<S..KW1>
.ASCIZ \Not Present\
.EVEN
;HERE ON A KW11 INTERRUPT
14$: DEC CHKTIM ;COUNT OUT TIMER
BNE 15$
CLR (R4) ;TURN OFF CLOCK
15$: RTI ;DISMISS INTERRUPT
CHKTIM: .WORD 0
;
;
CKCLK9: MTPS #BR7 ;SET TO LEVEL 7
MOV #KW.INE,(R4) ;ENABLE INT
MOV (SP)+,CLKVEC ;RESTORE WHERE TO GO ON INT
JSR R5,CHKINL ;FIND THE INT LEVEL
-1 ;DELAY TO WAIT FOR INT
BIC #KW.INE,CLKWRD ;DISABLE CLK INTS
JSR R0,CKTCRL ;INDICATE CLOCK PRESENT
.ASCIZ \ KW11-L\
.EVEN
.IIF DF,CKAKW1,JSR PC,CKAKW1 ;CALL TO MAIN FOR CLOCK
.SBTTL CHECK KG11
;HERE TO CHECK THE KG11 IS PRESENT AND FUNCTIONING PROPERLY
CHKG11: MOV #17$,NXMVEC ;SET BUS TIMEOUT VECTOR
BIC #CKFIDT,CHKFLG ;SO WE PRINT DEV ID
CHKCHR <#KG.STS>,<#0>,<#0>
MOV #CKNKG1,CKDNAM ;FOR NAME
CLR CKDEVN ;DEVICE #
TST KG.STS ;CHECK STATUS
TST KG.BCC ;CHECK BCC
TST KG.DTA ;CHECK DATA REG
MOV #CKBUST,NXMVEC
CLR R0
11$: MOV #KG.SEN!KG.CLR!KG.DDB!3,KG.STS ;CLEAN OUT KG11-A
MOV R0,KG.DTA ;LOAD WITH DATA FROM R0
MOV #KG.SEN!1,KG.STS ; AND SET TO CRC-16
CMP R0,KG.BCC ;CHECK IT LOADED
BEQ 12$ ;BRANCH IF OK
CKSERR R0,KG.BCC,<#KG.BCC> ;GD,BD,ADR
CK11SC <CKEPC!CKEDID!CKEGB>,<Can't load BCC Correctly>,<CAN'T LOAD BCC CORRECTLY>
.ASCIZ \Can't load BCC Correctly\
.EVEN
12$: SOB R0,11$
;HERE TO CHECK CRC PORTION
;
MOV #777,R0 ;FIRST ENTRY FOR CRC
MOV #KG.SEN!KG.CLR!1,KG.STS ;CLEAR KG11 AND SET TO CRC-16
CLR R3 ;CLEAR SOFTWARE COPY
13$: MOV R0,-(SP)
BIC #^C377,R0 ;STRIP EXTRA BITS
MOV #^D8,R1 ;COUNTER
XOR R0,R3
MOV #120001,R0
15$: CLC ;CLEAR CARRY BIT
ROR R3
BCC 16$
XOR R0,R3
16$: SOB R1,15$
MOV (SP)+,R0
MOVB R0,KG.DTA ;INCLUDE CHAR IN HDW BCC
CMP R3,KG.BCC
BEQ 14$
CKSERR R3,KG.BCC,<#KG.BCC>
CK11SC <CKEPC!CKEGB!CKEDID>,<Incorrect CRC>,<INCORRECT CRC>
.ASCIZ \Incorrect CRC\
.EVEN
14$: SOB R0,13$
JSR R0,CKTCRL ;PRINT MSG ABOUT KG11
.ASCIZ \ KG11-A\
.EVEN
.IIF DF,CKAKG1,JSR PC,CKAKG1 ;CALL MAIN FOR KG11
BR 18$
; COME HERE IF KG11 IS NOT PRESENT. PRINT ERROR MESSAGE IF
; IT IS REQUIRED (I.E., NOT DC76).
17$:
.IIF EQ,CK..KG,BR 18$
.IF NE CK..KG
CK11SC <CKEPC!CKEDID>,<Not present >
.ASCIZ \Not present \
.EVEN
.ENDC
18$:
.IF NE CK..D1
.SBTTL CHECK DL10 HDW
;
CKDL10:
MOV DL10AD,R4 ;IF "DL10AD" IS NON 0 A DL10 IS PRESENT
; AND R4 WILL BE LOADED WITH BASE ADR
BEQ 12$ ;BRANCH IF WE DO NOT
BIC #CKFIDT,CHKFLG ;SO WE PRINT DEV ID
MOV #CKND10,CKDNAM ;DEVICE NAME
CLR CKDEVN ;DEVICE NUMBER
MOV R4,R1 ;PUT DEVICE ADDR FOR CHKBIT
MOV R4,CHKCHR+CKDA ;PUT IN CHARACTERISTICS TABLE FOR ERROR REPORTING
JSR R5,CHKBIT ;CHECK THE FOLLOWING BITS
DL.B00!DL.B01!DL.INE!DL.ERE
JSR R5,CHKDLX ;CHECK SET/CLEAR OF
DL.WCO ;WORD COUNT OVERFLOW
JSR R5,CHKDLX ;CHECK SET/CLEAR OF
DL.PAR ;PARITY ERROR
JSR R5,CHKDLX ;CHECK SET/CLEAR OF
DL.NXM ;NON EX MEM
JSR R5,CHKDLX ;CHECK SET/CLEAR OF
DL.11I
11$: MOV #DL.B01,(R4) ;SET DL10 FOR LEVEL 5
MOV #DL.VEC,CHKCHR+CKDV ;PUT DEVICE VECTOR IN TABLE FOR CKINT
$CKINT R4,R4,DL.INE,DL.11I,DL.11C
$CKINT R4,R4,DL.ERE,<DL.PAR!DL.NXM!DL.WCO>,<DL.CNX!DL.CPE!DL.CWC>
JSR R0,CKTCRL ;NOTE PRESENCE OF DL10
.ASCIZ \ DL10\
.EVEN
.IIF DF,CKADLX,JSR PC,CKADLX ;DO MAIN LINE CHECKING
12$:
.ENDC ;.IF NE CK..D1
JSR PC,CKCDEV ;check devices
;HERE WHEN CHK.11 IS ALL DONE
CHK.90: TST CHKFLG ;DID ALL FLAGS GET CLEARED ?
BEQ CHK.96 ;IF SO MAY CONTINUE
JSR R0,CKTCRL
.ASCIZ <12><7><40><7><40><7>\? Errors detected - Proceed (Y OR N)? \
.EVEN
JSR PC,11$ ;GET HIS YEH OR NAY
JSR R0,CKTCRL
.ASCIZ \ Are you SURE? \
.EVEN
JSR PC,11$
JSR PC,CKCRLF
BR CHK.96
11$: TST CTICHR ;CLEAR BUFFER
MOV #2*^D60*^D60+1,R0 ;CLOCK TICKS IN 2 MINUTES
12$: TSTB CTISTS ;WAIT FOR A CHAR
BMI 13$ ;GOT A CHARACTER
BIT #KW.TIC,CLKWRD ;CLOCK TICKED YET?
BEQ 12$ ;BRANCH IF NO TICK
CLR CLKWRD ;CLOCK WENT TICK, SO CLR IT
SOB R0,12$ ;WAITING TIME EXPIRED YET?
BR 16$ ;GIVE A 'N'
; QUESTION.
13$: MOVB CTICHR,R1 ;GET CHAR
14$: CMP R1,#040 ;IGNORE CONTROL CHARS
BLO 12$
BIC #^C177,R1 ;RETAIN CHAR ONLY
BIS #040,R1 ;AND CONVERT TO LOWER CASE
15$: CMPB #171,R1 ;ANSWERING YES ?
BEQ 17$
16$: MOV #156,R1 ;IF NOT Y TYPE A 'N'
JSR PC,CKTCHR ;TYPE A 'N'
JSR R0,CKTCRL
.ASCIZ \ Execution Deleted\
.EVEN
MOV #TRPINT,TRPVEC ;YES, SET UP FOR A STOPCD
MOV #TRPLVL,TRPVEC+2 ;
STOPCD CHK
17$: JMP CKTCHR ;TYPE 'Y' AND DO A RTS PC
;
;HERE BECAUSE EVERYTHING LOOKS OK
;
; WAIT A WHILE, THEN DO A UNIBUS RESET.
;
CHK.96: ;TIMER BEFORE RESET
MOV #10,R1 ;second half of timer [1(14)]
11$: CLR R0 ;TIMER BEFORE RESET
12$: SOB R0,12$ ;ON EXIT R0 IS 0 WHICH POINTS TO ADDR 0
SOB R1,11$ ;added timing [1(14)]
RESET
;
; NOW FILL IN LOW CORE IN CASE WE GET AN UNKNOWN INTERRUPT
;
MOV #BR7,R1 ;INTERRUPT PS
13$: MOV #ERRINT,(R0)+ ;PUT WHERE TO GO ON ILLEGAL INT
MOV R1,(R0)+ ;PUT PI LEVEL IN
14$: INC R1 ;INCREMENT PI LEVEL
BIC #20,R1 ;KEEP IN THE RANGE OF 340-357
.IF GE PDL-1000
CMP R0,#1000 ;FILL VECTORS UP TO 1000
.IFF
CMP R0,#PDL-2 ;OR UP TO START OF PROGRAM
.ENDC
BLT 13$ ;BRANCH IF MORE TO FILL
.IF NE,FT.KMC ;START KMC11 IF REQUESTED
; HERE TO START EACH KMC11 AT LOCATION 2.
CLR R0 ;KMC11 NUMBER * 2
15$: MOV MDCSR(R0),R3 ;GET ADDRESS OF KMC11 CSR
BEQ 16$ ;NONE, DON'T DO ANYTHING.
MOV #MD.CLR,(R3) ;CLEAR KMC11
MOV #MD.RMI,(R3) ;SET ROM I
MOV #<B15+B8+2>,6(R3) ;BRANCH TO 2
BIS #MD.SMP,(R3) ;EXECUTE THE INSTRUCTION
CLR (R3) ;CLEAR SEL 0
CLR 2(R3) ;CLEAR SEL 2
CLR 4(R3) ;CLEAR SEL 4
CLR 6(R3) ;CLEAR SEL 6
MOV #MD.RUN,(R3) ;START MICROPROCESSOR
16$: ADD #2,R0 ;INCREMENT KMC11 NUMBER * 2
CMP #NKMCR*2,R0 ;DONE ENOUGH?
BGT 15$ ;NO, DO THE REST. [2(43)]
.ENDC ;.IF NE,FT.KMC
; ; CONTINUED ON NEXT PAGE
;
; HERE TO FILL IN THE VECTORS FOR DEVICES WE KNOW ABOUT
;
.MACRO X DEV
.IF DF DEV'INT
.IFT
MOV #DEV'INT,DEV'VEC ;SET DEV TO GO TO DEV'VEC
MOV #DEV'LVL*40,DEV'VEC+2 ; AND SET THE LEVEL.
.IFF
MOV #ERRINT,DEV'VEC ;SET DEV TO GO TO ERRINT
MOV #DEV'LVL*40,DEV'VEC+2 ; AND SET THE LEVEL.
.ENDC
.ENDM X
;
X NXM ;BUS-TIMEOUT INTERRUPT
X ILS ;ILLEGAL INSTRUCTION INTERRUPT
X IOT ;IOT INSTRUCTION
X PWF ;POWER FAIL INT'S
X EMT ;EMT CALL'S
X TRP ;TRAP INSTRUCTION
X DL. ;DL10 INTERRUPT
X CLK ;KW11 INTERRUPT
X MP. ;MF11-LP PARITY CONTROL
X CTO ;CTY OUTPUT INTERRUPT
X CTI ;CTY INPUT INTERRUPT
.IF DF,DT.INT
MOV DTEDTO,R1 ;SET UP PTR TO INTP VEC [1(26)]
MOV #DT.INT,(R1)+ ;SET UP INTP VEC ADR [1(26)]
MOV #TE.LVL*40,(R1) ;SET UP THE LEVEL [1(26)]
.ENDC ;.IF DF,DT.INT
;
CKSETV: MOV #CKCDEV+4+16,R0 ;POINT TO DEVICE CHECK VECTOR TABLE ENTRY
11$: MOV R0,R3 ;R3 WILL BE USED TO LOOK AT EACH DEVICE
MOV (R3)+,R5 ;GET VECTOR TABLE ADR
BEQ 15$ ;BRANCH IF NONE
TST (R3) ;SEE IF ANY DEVICES FOUND
BEQ 15$ ;BRANCH IF NONE FOUND
MOVB (R5)+,R2 ;GET # OF MAIN ROUTINES
BEQ 15$ ;BRANCH IF NO MAIN ROUTINES
MOVB (R5)+,-(SP) ;GET NUMBER OF VECTORS FOR THE DEV
CMP R2,(R3)+ ;SEE IF MORE MAIN THAN DEVICES
BLE 12$ ;BRANCH IF #OF DEV >= # OF MAIN ROUTINES
MOV -2(R3),R2 ;SET NUMBER OF DEVICES
12$: MOV (R3)+,R4 ;SET VECTOR
13$: MOVB (SP),R1 ;SET NUMBER OF VECTORS
14$: MOV (R5)+,(R4)+ ;PUT MAIN VECTOR ADR IN VECTOR SPACE
MOV (R3),(R4)+ ;PUT PI LEVEL IN
SOB R1,14$ ;ALL VECTOR SET FOR A DEV (1)
SOB R2,13$ ;ALL DEV OF A KIND DONE?
CLR (SP)+ ;CLEAN STACK
15$: ADD #CKCADD,R0 ;GO TO NEXT DEVICE
CMP R0,#CKCEND ;ALL DEV DONE?
BLO 11$ ;BRANCH IF ANOTHER TO DO
CHK.99: MOV CK.CAL,R0 ;GET ADR OF PROGRAM CALL
MOV 11$,-4(R0)
CLR R0
SOB R0,.
JMP CKDONE ;RESTART
11$: BR .+6
.SBTTL CHECK SYSTEM FOR EXISTENCE OF OPTIONS
;HERE TO CHECK SYSTEM FOR EXISTENCE OF OPTIONS
; CALL JSR R5,CHKDEV
; (0) .WORD 1ST DEVICE ADR
; (2) .BYTE MAX #,VECTOR INC
; (4) .BYTE HDW INC,1ST VEC MULTIPLE
; (6) .WORD <ADR OF NUMBER OF DEVICES OR ZERO>
; (10) .WORD <ADR OF .ASCIZ \NAME\>
; (12) .WORD <ADR OF ROUTINE TO VERIFY OPERATION>
; (14) .WORD <ADR OF MAIN PROGRAM ROUTINE FOR DEVICE>
; (16) .WORD <ADR OF TABLE WHICH CONTAINS MAIN PROG VECTORS OR 0>
; (20) .WORD <# OF DEVICES FOUND>
; (22) .WORD <FIRST VECTOR FOUND>
; (24) .WORD <PI LEVEL>
; (26) .WORD <FIRST DEV VECTOR FOR FIXED TYPE DEV>
; RETURN
CHKDEV: MOV 10(R5),CKDNAM ;REMEMBER DEVICE NAME
CLR R2 ;INITIALIZE COUNTER FOR DEVICES
MOV CHKFLV,R3 ;COPY FOR USE
TSTB 5(R5) ;SEE IF FIXED TYPE DEV
BNE 11$ ;BRANCH IF NOT
MOV 26(R5),R3 ;VECTOR TO USE
11$: MOV @R5,R4 ;GET HDW ADR FOR 1ST DEVICE
BNE 12$ ;BRANCH IF NOT A FLOATING DEVICE
ADD #10,CHKFLD ;ADVANCE TO NEXT FLOAT DEVICE SLOT
MOV CHKFLD,R4 ;COPY FOR USE
12$: MOV #15$,NXMVEC ;SET BUS TRAP VECTOR
13$: TST (R4) ;CHECK TO SEE IF DEVICE IS PRESENT
MOV #CKBUST,NXMVEC ;SET FOR ILLEGAL BUS TRAP
TST R2 ;IS THIS THE FIRST OF ITS KIND ?
BNE 14$ ;BRANCH IF NOT FIRST
CLR 20(R5) ;CLEAR NUMBER OF DEV FOUND
CLR 22(R5) ;CLEAR FIRST VECTOR ADR
; CLR 24(R5) ;CLEAR PI LEVEL
MOVB 5(R5),R1 ;GET MULTIPLE VECTOR BEGINS ON
BEQ 14$ ;BRANCH IF FIXED DEV (LPT)
DEC R1
ADD R1,R3
BIC R1,R3
14$: INC R2 ;COUNT DEVICE
INC 20(R5) ;COUNT DEVICE AND REMEMBER IT
MOVB 3(R5),R1 ;GET VECTOR INCREMENT
ADD R1,R3
MOVB 4(R5),R1 ;GET HDW INCREMENT
ADD R1,R4 ;ADVANCE FLOATING DEVICE ADR POINTER
CMPB R2,2(R5) ;HAVE WE CHECK ALL POSSIBLE ?
BNE 12$ ;IF NOT LOOP BACK FOR REST
BR 16$
15$: MOV #CKBUST,NXMVEC
CMP (SP)+,(SP)+ ;POP OFF ADR AND STATUS
16$: TST 6(R5) ;DO WE HAVE ADR FOR NUMBER ?
BEQ 17$ ;IF NOT DON'T STUFF
MOV R2,@6(R5) ;PUT NUMBER FOR SOMEONE TO FIND
17$: TST R2 ;WERE THERE ANY OF THESE ?
BEQ CHKD02
CK11SC 0,< > ;TYPE CR/LF/TAB
.ASCIZ \ \
.EVEN
MOV R2,R0 ;NUMBER OF DEVICES WE FOUND
JSR PC,CKTOCT ;TYPE OUT THE NUMBER
JSR R0,CKTSTR ;TYPE A BLANK
.BYTE 040,0
MOV CKDNAM,R0 ;GET ADR OF ASCIZ STRING
JSR PC,CKTTXT ;TYPE DEVICE NAME
BIT #76,R2 ;HOW MANY ?
BEQ CHKDV1
CK11SC <CKENCL>,<'s>
.ASCIZ \'s\
.EVEN
CHKDV1: MOV R3,-(SP)
MOV R4,-(SP)
MOV R2,-(SP)
CLR CKDEVN ;CHECK UNIT 0 FIRST
MOV 26(R5),R3 ;GET FIRST VECTOR FOR POSSIBLE FIXED
MOVB 5(R5),R0 ;GET VECTOR MULTIPLE
BEQ 11$ ;BRANCH IF FIXED
MOV CHKFLV,R3 ;GET VECTOR FOR 1ST UNIT
DEC R0
ADD R0,R3
BIC R0,R3
11$: MOV (R5),R4 ;GET HDW ADR FOR FIRST UNIT
BNE 12$
MOV CHKFLD,R4 ;FLOATING DEVICE
12$: CLR CHKCHR+CKPI ;ROUTINE WILL SET PI LEVEL
MOV 12(R5),R0 ;ADR OF ROUTINE TO VERIFY DEVICE
BEQ 13$ ;BRANCH IF NO ROUTINE TO VERIFY
BIC #CKFIDT,CHKFLG ;HAVEN'T TYPED ID YET
MOV R4,CHKCHR+CKDA ;SAVE DEVICE ADDRESS
MOV R3,CHKCHR+CKDV ;SAVE VECTOR ADDRESS IN CHARACTERISTICS TABLE
MOV R4,R1 ;PUT DEV ADR IN R1 SINCE MOST
; ROUTINES WILL USE IT.
CLR CHKCHR+CKFLG ;CLEAR FLAGS AND LET DEVICE CHECK ROUTINE SET THEM
MTPS #BR7 ;MAKE SURE WE'RE AT LEVEL 7
JSR PC,(R0) ;CALL TO DEVICE CHECK
TST 22(R5) ;SEE IF VECTOR ADR SET YET
BNE 13$ ;BRANCH IF SET
MOV CHKCHR+CKDV,22(R5) ;SET FIRST VECTOR FOUND
; MOV CHKCHR+CKPI,24(R5) ;SET FIRST PI LEVEL FOUND
13$: CMP (R5),#DS.DVA ;DS11 ARE SPECIAL SO DON'T CALL MAIN HERE
BEQ 14$ ;BRANCH IF DS11
MOV #CHKCHR,R0 ;POINT TO THE CHARACTERISTIC TABLE
JSR PC,@14(R5) ;CALL TO MAIN PROGRAM
14$: MOVB 3(R5),R0 ;GET VECTOR INCREMENT
ADD R0,R3
MOVB 4(R5),R0 ;HDW INCREMENT
ADD R0,R4
INC CKDEVN ;ON TO NEXT DEVICE NUMBER
CMP (SP),CKDEVN
BNE 12$
MOV (SP)+,R2
MOV (SP)+,R4
MOV (SP)+,R3
CHKD02: ;SAVE <R3,R4>
;CLR R4 ;FLAG NO MORE DEVICES
;JSR PC,@14(R5) ;CALL MAIN PROGRAM
;RESTORE <R4,R3>
;HERE WHEN DONE CHECKING DEVICE
TSTB 5(R5) ;SEE IF FIXED DEV
BEQ CHKD01 ;BRANCH IF FIXED (LIKE LPT)
MOV CHKFLV,-(SP) ;RESET FLOATING VECTOR
MOV R3,CHKFLV
MOV (SP)+,R3
MOV (R5),R0 ;WAS THIS A FLOATING DEVICE ?
BNE CHKD01 ;BRANCH IF NOT
MOV CHKFLD,R0 ;COPY ADR OF FIRST DEVICE
MOV R4,CHKFLD
CHKD01: ADD #CKCADD-4,R5
RTS R5
.SBTTL BIT SET/BIT CLEAR TEST
;HERE TO CHECK WE CAN SET/CLEAR VARIOUS BITS
;
; CALL MOV #<ADR OF ASCIZ \NAME\>,CKDNAM
; MOV <DEVICE NUMBER>,CKDEVN
; MOV <DEVICE REGISTER ADDRESS>,R1
; JSR R5,CHKBIT
; <ALL BITS TO TEST>
;
CHKBIT: MOV R0,-(SP)
MTPS #BR7 ;DISABLE INTERRUPTS
MOV (R5),R0 ;GET BITS TO CHECK
BIC R0,(R1) ;TRY AND CLEAR ALL OF THEM
BIT R0,(R1) ;SEE IF ALL OF THEM CLEARED?
BEQ 11$ ;BRANCH IF ALL CLEAR
CLR -(SP) ;WHAT THE RESULT SHOULD BE
MOV (R1),-(SP) ;PUT C(DEV REG) ON STACK
MOV R0,-(SP) ;BUT ONLY CERTAIN BITS ARE BAD CANDIDATES
COM (SP) ;GET RID OF ONES
BIC (SP)+,(SP) ; THAT WE'RE NOT INTERESTED IN
MOV R1,-(SP) ;SAVE THE DEVICE ADR
CK11SC <CKEMSE!CKEPC!CKEDID!CKEGB>,<CKMG02>,<BITS WOULD NOT CLEAR>
11$: MOV #1,R0 ;START WITH B0 AND GO UNTIL B15 IS DONE
12$: BIT (R5),R0 ;WANT THIS BIT CHECKED?
BEQ 14$ ;BRANCH IF NOT, AND MAKE NEW BIT
BIS R0,(R1) ;TRY TO SET THE BIT
BIT R0,(R1) ;SEE IF THE BIT SET
BNE 13$ ;BRANCH IF IT SET
MOV R0,-(SP) ;SAVE GOOD
CLR -(SP) ;GOOD SHOUD BE 0 FOR THAT BIT
MOV R1,-(SP) ;DEV ADR WHERE IT HAPPENED
CK11SC <CKEMSE!CKEPC!CKEDID!CKEGB>,<CKMG03>,<BIT WOULD NOT SET>
13$: BIC R0,(R1) ;NOW THAT ITS SET TRY TO CLEAR IT
BIT R0,(R1) ;SEE IF IT CLEARED
BEQ 14$ ;BRANCH IF IT CLEARED AND GET NEW BIT
CLR -(SP) ;GOOD SHOUD BE 0
MOV R0,-(SP) ;SINCE IT DIDN'T CLEAR THIS BIT IS BAD
MOV R1,-(SP) ;DEV ADR THAT FAILED
CK11SC <CKEMSE!CKEPC!CKEDID!CKEGB>,<CKMG02>,<BIT WOULD NOT CLEAR>
14$: ASL R0 ;MAKE NEW BIT POSITION
BNE 12$ ;BRANCH IF THERE IS A BIT
MOV (SP)+,R0
TST (R5)+ ;GO OVER BITS FOLLOWING JSR
RTS R5 ;EXIT
.IF NE CK..D1
.SBTTL BIT SET/BIT CLEAR TEST FOR DL10
;ROUTINE TO CHECK DL10 BITS
;
CHKDLX: MOV (R5)+,R0 ;GET BIT TO CHECK
BIS R0,(R1) ;SET THE BIT IN THE DL10
CMP (R1),R0 ;DID IT SET AND ONLY IT SET?
BEQ 11$ ;BRANCH IF OK
CKSERR R0,<(R1)>,R1 ;GD, BD, ADR
CK11SC <CKEMSE!CKEPC!CKEDID!CKEGB>,<CKMG03>,<SET BIT BUT ITS NOT SET>
11$: ASR R0 ;SHIFT RIGHT TO GET IT IN CLEAR POSITION
BIS R0,(R1) ;SET BIT TO CLEAR BIT
TST (R1) ;ALL BITS SHOULD BE CLEAR NOW
BEQ 12$ ;BRANCH IF THEY ARE
CLR -(SP) ;THE GOOD
MOV (R1),-(SP) ;THE BAD
MOV R1,-(SP) ;THE BAD ADR
CK11SC <CKEMSE!CKEPC!CKEDID!CKEGB>,<CKMG02>,<SETTING BIT DID NOT CLEAR BIT>
12$: RTS R5 ;EXIT
.ENDC ;.IF NE CK..D1
.SBTTL PRINT DEVICE ID ROUTINE
CKDIDT: BIT #CKFIDT,CHKFLG ;HAVE WE ALREADY TYPE DEVICE ID ?
BNE 11$
JSR PC,CKCRLF ;EXTRA CR + LF
JSR R0,CKTCRL
.BYTE 007,0
CK11SC CKENCL,<? >
.ASCIZ \? \
.EVEN
MOV CKDNAM,R0 ;GET ASCIZ \DEVICE NAME\
JSR PC,CKTTXT ;TYPE DEVICE NAME
CK11SC <CKENCL>,< #>
.ASCIZ \ #\
.EVEN
MOV CKDEVN,R0 ;GET UNIT NUMBER
JSR PC,CKTOCT ;TYPE UNIT NUMBER
CK11SC <CKENCL>,<(Adr = >
.ASCIZ \(Adr = \
.EVEN
MOV CHKCHR+CKDA,R0 ;GET DEVICE ADDR
JSR PC,CKTOCT ;TYPE IT
CK11SC <CKENCL>,<)>
.ASCIZ \)\
.EVEN
BIS #CKFIDT,CHKFLG ;REMEMBER WE TYPED DEVICE ID
11$: RTS PC
.SBTTL ROUTINE TO FIND DEVICE INTERRUPT LEVEL
;
;CALL JSR R5,CHKINL ;WITH DEVICE READY TO INT BUT
; ; WITH THE PS SET TO LEVEL 7.
;
CHKINL: MOV R0,-(SP) ;SAVE R0
MOV R1,-(SP) ;SAVE R1
MOV R2,-(SP) ;SAVE R2
MOV #300,R2 ;START BY CHECKING LEVEL 6.
11$: MOV (R5),R1 ;GET TIME TO WAIT
CLR R0 ;WILL BE SET BY INT ROUTINE IF INT
MTPS R2 ;LOWER PS LEVEL
12$: TST R0 ;SEE IF INT YET
BNE 13$ ;NON 0 SAYS INTERRUPT
SOB R1,12$ ;TIME AND WAIT
MTPS #BR7 ;TIMED OUT SO SET LEVEL 7 AND LOWER AND TRY AGAIN
SUB #40,R2 ;MAKE LEVEL LOWER BY 1
BGE 11$ ;BRANCH IF LEVEL 0 NOT CHECKED YET
CK11SC <CKEMSE!CKEDID!CKEPC>,<CKMG04>,<DEVICE NEVER INTERRUPTED>
BR 15$ ;EXIT
13$: CMP R0,CHKCHR+CKDV ;SEE IF SAME AS WHAT IT SHOULD BE
BEQ 14$ ;BRANCH IF CORRECT VECTOR
CKSERR <CHKCHR+CKDV>,<R0>,<R4>
CK11SC <CKEMSE!CKEPC!CKEDID!CKEGB>,<CKMG05>,<Device INTERRUPTED to WRONG VECTOR>
14$: ADD #40,R2 ;MAKE THE DEVICE LEVEL
MOV R2,CHKCHR+CKPI ;SAVE LEVEL DEVICE INTERRUPTED AT
15$: MOV (SP)+,R2 ;RESTORE R2
MOV (SP)+,R1 ;RESTORE R1
MOV (SP)+,R0 ;RESTORE R0
TST (R5)+ ;SKIP OVER TIME DELAY CONSTANT
RTS R5 ;RETURN WITH DEVICE LEVEL SAVED IN CHARACTERISTICS TABLE
.SBTTL CHECK INTERRUPTS AND FIND DEVICE LEVEL
;ROUTINE TO CHECK INTERRUPTS AND FIND DEVICE LEVEL
;
; CALL MOV ENABLE ADR,R1
; MOV INT ADR,R2
; JSR R5,CKINT
; ENABLE BIT
; INTERRUPT BITS
; SPECIAL CLEAR BITS
; 0 if BIS sufficient to generate interrupt, else address
; of subroutine
;
CKINT: MOV R3,-(SP)
MOV R4,-(SP)
CLR CHKCHR+CKPI ;START WITH PI OF 0 (NO DEV)
CLR CKFLAG ;0 = PI LEVEL FOUND MUST BE PUT IN TABLE
; NON 0 = CHECK PI LEVEL FOUND WITH TABLE
MOV #1,R4 ;STARTING POSITION OF SLIDING INT BIT
CKINT1: MOV #BR7,R3 ;START CHECKING AT THIS LEVEL
CKINT2: MTPS R3 ;SET PS
CLR R0 ;SET TO 0 SO IF INT HAPPENS WE KNOW IT
CKINT3: BIT R4,2(R5) ;IS THERE A BIT TO TEST?
BNE 11$ ;BRANCH IF BIT IN POSITION
JMP CKINT7 ;MAKE NEW BIT POSITION
11$: TST 6(R5) ;subroutine supplied?
BEQ 12$ ;no, do normal
JSR PC,@6(R5) ;yes, use it
BR 13$ ;and continue
12$: BIS (R5),(R1) ;SET INTERRUPT ENABLE
BIS R4,(R2) ;SET INTERRUPT BIT
NOP ;ALLOW 1 EXTRA INST TIME FOR INT
13$:
MTPS #BR7 ;LET NO INT HAPPEN
BIC (R5),(R1) ;CLEAR INT ENABLE
TST 4(R5) ;SEE IF SPECIAL CLEAR
BEQ 14$ ;BRANCH IF NOT
BIS 4(R5),(R2) ;SPECIAL CLEAR
BR 15$ ;CONTINUE
14$: BIC 2(R5),(R2) ;CLEAR INT BITS
15$: TST R0 ;IF R0 IS NON 0 IT SHOULD BE THE
; VECTOR ADR. IF 0 NO INT HAPPENED.
BNE 16$ ;BRANCH IF INTERRUPT
SUB #40,R3 ;MAKE PS VALUE 1 LEVEL LESS
BGE CKINT2 ;BRANCH IF NEW LEVEL OK
CK11SC <CKEMSE!CKEPC!CKEDID>,<CKMG04>,<DEVICE NEVER INTERRUPTED>
BR CKINTF ;EXIT WITH FAILURE RETURN
;
;
; HERE WHEN THE DEVICE HAS INTERRUPTED
;
16$: TST CKFLAG ;FIRST TIME THROUGH?
BNE 17$ ;NO.
DEC CKFLAG ;YES, DON'T DO THIS AGAIN.
MOV R3,CHKCHR+CKPI ;STORE PRIORITY INTERRUPT LEVEL
ADD #40,CHKCHR+CKPI
TST CHKCHR+CKDV ;VECTOR SPECIFIED?
BNE 17$ ;YES, IT BETTER BE RIGHT.
MOV R0,CHKCHR+CKDV ;NO, SPECIFY IT NOW.
17$: CMP R0,CHKCHR+CKDV ;IS VECTOR RIGHT?
BEQ 18$ ;YES.
MOV R0,-(SP) ;SAVE RIGHT ADDR
CKSERR <CHKCHR+CKDV>,R0,<R2> ;GD,BD,ADR
CK11SC <CKEMSE!CKEPC!CKEDID!CKEGB>,<CKMG05>,<DEVICE INTERRUPTED TO WRONG VECTOR>
MOV (SP)+,CHKCHR+CKDV ;SET VECTOR RIGHT
BR CKINTE ;EXIT
;
18$: MOV R3,R0 ;GET PRESENT LEVEL
ADD #40,R0 ;MAKE IT THE DEVICE LEVEL
CMP R0,CHKCHR+CKPI ;CHECK LEVEL AGAINST LAST TIME
BEQ CKINT6 ;BRANCH IF LEVEL CHECKS
CKSERR <CHKCHR+CKPI>,R0,R4
CK11SC <CKEPC!CKEDID!CKEGB>,<Interrupt to Different PI Level>,<INTERRUPT TO DIFFERENT PI LEVEL>
.ASCIZ \Interrupt to Different PI Level\
.EVEN
BR CKINTE ;EXIT
;
;
CKINT6: MTPS #0 ;CHECK WITH LEVEL 0 AND
CLR R0 ; NO INT ENABLE BITS SET
BIS R4,(R2) ; AND INT BIT SET THAT NO INT OCCURRS
NOP ;PAUSE
NOP ;PAUSE
MTPS #BR7 ;DON'T LET AN INT HAPPEN
TST R0 ;SEE IF ONE HAPPENED
BEQ 11$ ;BRANCH IF NO INT
CK11SC <CKEMSE!CKEDID!CKEPC>,CKMG07,<INTERRUPT WHEN NOT ENABLED>
BR CKINTF ;EXIT WITH FAILURE RETURN
11$: TST 4(R5) ;SEE IF SPECIAL CLEAR
BEQ 12$ ;BRANCH IF NOT
BIS 4(R5),(R2) ;SPECIAL CLEAR (DL10 FOR ONE)
BR 13$ ;CONTINUE
12$: BIC R4,(R2) ;CLEAR INT BITS
13$: ASL R4 ;MAKE NEW BIT POSITION
BEQ CKINTE ;BRANCH IF DONE
JMP CKINT1 ;TEST NEW BIT
CKINT7: ASL R4 ;MAKE NEW INT BIT POSITION
BEQ CKINTE ;BRANCH IF NO NEW BIT POSITION
JMP CKINT3 ;BRANCH IF NEW BIT POSITION
CKINTE: ADD #10,R5 ;FOR CORRECT RETURN
CLC ;FLAG SUCCESS
CKINTG: ;COMMON RETURN CODE
MOV (SP)+,R4
MOV (SP)+,R3
RTS R5 ;RETURN
CKINTF: ADD #10,R5 ;FOR CORRECT RETURN ADDRESS
SEC ;TO INDICATE FAILURE
BR CKINTG ;GO TO COMMON RETURN CODE
CKFLAG: 0
.SBTTL HERE ON AN INTERRUPT WHILE IN CHK60
;HERE FROM AN INTERRUPT WHILE IN CHK60
; WILL RETURN VECTOR ADDRESS IN R0 (RANGE 0 TO 1174)
;
CHKINT: MFPS R0 ;GET PROCESSOR STATUS
JSR PC,11$ ;COMPUTE INTERRUPT ADDRESS
.WORD 0000 ;THESE INTERRUPTS ARE 0000-0074
CHKITL=.-CHKINT ;LENGTH OF INTERRUPT BLOCK
MFPS R0 ;GET PROCESSOR STATUS
JSR PC,11$
.WORD 0100
MFPS R0 ;GET PROCESSOR STATUS
JSR PC,11$
.WORD 0200
MFPS R0 ;GET PROCESSOR STATUS
JSR PC,11$
.WORD 0300
MFPS R0 ;GET PROCESSOR STATUS
JSR PC,11$
.WORD 0400
MFPS R0 ;GET PROCESSOR STATUS
JSR PC,11$
.WORD 0500
MFPS R0 ;GET PROCESSOR STATUS
JSR PC,11$
.WORD 0600
MFPS R0 ;GET PROCESSOR STATUS
JSR PC,11$
.WORD 0700
MFPS R0 ;GET PROCESSOR STATUS
JSR PC,11$
.WORD 1000
MFPS R0 ;GET PROCESSOR STATUS
JSR PC,11$
.WORD 1100
;
; HERE AFTER AN INTERRUPT TO COMPUTE THE ADDRESS FROM THE THE LOW
; FOUR BITS OF THE PS AND THE WORD AFTER THE JSR ABOVE.
;
11$: BIC #^C17,R0 ;STRIP EXTRA BITS
ASL R0 ;MULTIPLY BY 4
ASL R0
ADD @(SP)+,R0 ;MAKES VECTOR ADR
MOV #BR7,2(SP) ;SO DON'T TRAP BACK AGAIN
RTI
CHKFLV: .BLKW 1 ;CURRENT FLOATING DEVICE VECTOR
CHKFLD: .BLKW 1 ;CURRENT FLOATING DEVICE ADR
.IF NE CK..DH
.SBTTL CHECK DH11 HDW
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKDH11
CKDH11: MOV R3,-(SP) ;SAVE REGISTER
JSR R5,CHKBIT ;CHECK RD/WRT BITS
131177 ;READ/WRITE BITS
TST (R1)+ ;ADVANCE TO NXT REC CHAR REG
TST (R1)+ ;ADVANCE TO LINE PARAMETER REG(XX4)
JSR R5,CHKBIT ;CHECK RD/WRT BITS
177767 ;READ/WRITE BITS
TST (R1)+ ;ADVANCE TO CURRENT ADR REG(XX6)
CLR R2 ;START CHECK AT LINE 0
11$: JSR R5,CHKBIT ;CHECK RD/WRT BITS
-1 ;READ/WRITE BITS
INC R2 ;NEXT LINE TO CHECK
CMP R2,#17 ;DONE
BLE 11$ ;CHECK LINES 0-17
TST (R1)+ ;ADVANCE TO BYTE COUNT REG(X10)
CLR R2 ;START CHECK AT LINE 0
12$: JSR R5,CHKBIT ;CHECK RD/WRT BITS
-1 ;READ/WRITE BITS
INC R2 ;NEXT LINE TO CHECK
CMP R2,#17 ;ALL LINES CHECKED?
BLE 12$ ;CHECK ALL 20 LINES
TST (R1)+ ;ADVANCE TO BAR REG(XX12)
TST (R1)+ ;ADVANCE TO BREAK REG(X14)
JSR R5,CHKBIT ;CHECK BITS
-1 ;READ/WRITE BITS
TST (R1)+ ;ADVANCE TO SILO STATUS REG(X16)
JSR R5,CHKBIT ;CHECK READ/WRITE BITS
77
$CKINT R4,R4,<DH.RIE!DH..MM>,<DH..RI>
$CKINT ,,<DH.SIE!DH..MM>,<DH..SI>
ADD #4,CHKCHR+CKDV ;MAKE EXPECTED VECTOR FOR XMIT
$CKINT ,,<DH.TIE>,<DH..TI>
MOV R3,CHKCHR+CKDV ;PUT VECTOR ADDRESS IN TABLE
CKDH1A:
MOV R3,DHXMII ;ADR TO COME TO ON XMIT INT
ADD #4,DHXMII ;
MOV #CKBLK,R0 ;LOAD A BUFFER WITH COUNT PATTERN
MOV #400,R1 ;LOAD 400 CHARACTERS
CLR R2 ;START WITH 0
11$: MOVB R2,(R0)+ ;STORE THE COUNT PATTERN
INCB R2 ;NEW PATTERN
SOB R1,11$ ;BUFFER LOADED?
CLR R3 ;START WITH LINE 0
MOV #1,R2 ;LINE BIT (LINE 0)
CKDH1B: CLR DHDATA ;FIRST RCV'D SHOULD BE 0
.IIF NDF NTRIB,NTRIB=0
.IF NE NTRIB
;IF TRIBUTARY LINES IN USE
;USE MINIMAL TEST TO AVOID INTERFERRENCE
;WITH THE FUNCTIONAL STATIONS ON LINE
;THE PROBLEM ARISES BECAUSE MAINTAINANCE
;MODE ON THE DH11 DRIVES THE MODEM LINES!!!
MOV #-1,R1
DEC DHDATA
MOVB R1,CKBLK
.IFF
MOV #-400,R1
.ENDC ;.IF NE NTRIB
BIS #DH..MC,(R4) ;CLEAR THE DH
BIS #DH..MM!DH.SIE!DH.TIE!DH.RIE,(R4) ;ENABLE INTS
BIS R3,(R4) ;LOAD THE LINE NUMBER
MOV #B6!B8!B9!B10!B12!B13!DH.2SB!DH.CL8!DH.PEN!DH..OP,DH.LPR(R4) ;SEL 8BIT,9600,PAR,ODD
MOV R1,DH.BCR(R4) ;LENGTH TO XMIT
MOV #CKBLK,DH.CAR(R4) ;ADR WHERE THE DATA IS
MOV #4,DH.SSR(R4) ;ALARM LEVEL TO 4
CKDH1E: CLR R0 ;INT RETURNS ADR IN HERE
CLR R1 ;TIMER
MOV R2,DH.BAR(R4) ;SET LINE ACTIVE
11$: MTPS #0 ;LEVEL TO 0 FOR INTS
NOP ;LET AN INTERRUPT HAPPEN
MTPS #BR7 ;DON'T LET ONE HAPPEN
CMP R0,CHKCHR+CKDV ;SEE IF RCV INT YET
BEQ 16$ ;BRANCH IF RCV INT
CMP R0,DHXMII ;SEE IF XMIT INT
BEQ 13$ ;BRANCH IF XMIT INT
TST R0 ;SEE IF ANY INTERRUPT
BEQ 12$ ;BRANCH IF NO INTERRUPT
CKSERR <CHKCHR+CKDV>,R0,R3
CK11SC <CKEPC!CKEGB!CKEDID>,<Ill Int>,<ILLEGAL INT WHILE WAITING FOR DH11 INT>
.ASCIZ \Ill Int\
.EVEN
JMP CKDH1D ;DON'T TEST ANY MORE
12$: SOB R1,11$ ;TIME-OUT
CK11SC <CKEPC!CKEDID>,<No Int>,<NO DH11 INTERRUPT>
.ASCIZ \No Int\
.EVEN
JSR PC,CKDHPL ;REPORT LINE NUMBER
JMP CKDH1D ;DON'T TEST ANY MORE
13$: BIT #DH.NXM,(R4) ;SEE IF NXM
BEQ 14$ ;BRANCH IF NO NXM
CK11SC <CKEPC!CKEDID>,<Xmit Nxm>,<TRANSMIT NXM ON DH>
.ASCIZ \Xmit Nxm\
.EVEN
JSR PC,CKDHPL ;REPORT LINE NUMBER
BR CKDH1D ;DON'T TEST ANY MORE
14$: BIT #DH..TI,(R4) ;BETTER HAVE XMIT INT
BNE 15$ ;BRANCH IF WE DO
CK11SC <CKEPC!CKEDID>,<Ill Xmit Int>,<INT TO XMIT BUT FOR NO REASON>
.ASCIZ \Ill Xmit Int\
.EVEN
JSR PC,CKDHPL ;REPORT LINE NUMBER
BR CKDH1D ;DON'T TEST ANY MORE
15$: BIC #DH..TI,(R4) ;CLEAR XMIT INT
BR CKDH1E ;
16$: BIT #DH..SI,(R4) ;SEE IF SILO OVERFLOW
BEQ CKDH1C ;BRANCH IF SILO HAD ROOM
CK11SC <CKEPC!CKEDID>,<Silo Full>,<SILO OVERFLOW>
.ASCIZ \Silo Full\
.EVEN
JSR PC,CKDHPL ;REPORT LINE NUMBER
BR CKDH1D ;DON'T TEST ANY MORE
CKDH1C: BIC #DH..RI,(R4) ;CLEAR RCV INT (MUST FOR MAINT MODE)
MOV DH.NRC(R4),R0 ;GET STUFF FROM SILO
BIT #DH.DOV!DH..FE!DH..PE,R0 ;SEE IF ANY ERROR BITS WITH DATA
BEQ 11$ ;BRANCH IF NO ERRORS WITH THE DATA
MOV DHDATA,-(SP) ;MAKE THE GOOD
MOV R3,-(SP) ;PUT LINE # IN
SWAB (SP) ;GET IT IN THE (LB)
BIS (SP)+,(SP) ;LINE # NOW IN GOOD
BIS #DH.VDP,(SP) ;GOOD INCLUDES VALID DATA PRESENT
MOV R0,-(SP) ;THE BAD
MOV R3,-(SP) ;THE LINE UNDER TEST
CK11SC <CKEGB!CKEPC!CKEDID>,<Data Err Bit Set>,<ERROR BITS WITH THE DATA>
.ASCIZ \Data Err Bit Set\
.EVEN
BR CKDH1D ;DON'T TEST ANY MORE
11$: BIT #DH.VDP,R0 ;SEE IF VALID DATA
BNE 12$ ;BRANCH IF VALID DATA
CK11SC <CKEPC!CKEDID>,<Not Valid Data>,<NOT VALID DATA BIT SET>
.ASCIZ \Not Valid Data\
.EVEN
JSR PC,CKDHPL ;REPORT LINE NUMBER
BR CKDH1D ;DON'T TEST ANY MORE
12$: BIC #B15!B14!B13!B12,R0 ;CLEAR DATA ERROR BITS
SWAB R0 ;FOR CHECKING LINE #
CMPB R0,R3 ;SEE IF LINE #OK
BEQ 13$ ;BRANCH IF IT IS
MOV R3,-(SP) ;LEGAL LINE NUMBER
CLR -(SP) ;0 FOR BYTE MOVE
MOVB R0,(SP) ;THE ILLEGAL LINE NUMBER
MOV R3,-(SP) ;LINE UNDER TEST
CK11SC <CKEGB!CKEPC!CKEDID>,<Ill Line Num>,<ILLEGAL LINE NUMBER>
.ASCIZ \Ill Line Num\
.EVEN
BR CKDH1D ;DON'T TEST ANY MORE
13$: SWAB R0 ;FOR CHECKING THE DATA
CMPB R0,DHDATA ;SEE IF CORRECT DATA
BEQ 14$ ;BRANCH IF DATA OK
MOV DHDATA,-(SP) ;GOOD DATA
CLR -(SP) ;FOR BYTE MOVE
MOVB R0,(SP) ;THE BAD DATA
MOV R3,-(SP) ;THE LINE #
CK11SC <CKEGB!CKEPC!CKEDID>,<Data Err>,<DATA ERROR>
.ASCIZ \Data Err\
.EVEN
BR CKDH1D ;DON'T TEST ANY MORE
14$: INCB DHDATA ;NEW PATTERN EXPECTED
BEQ 15$ ;BRANCH IF LINE DONE
JMP CKDH1E ;
15$:
CKDH1D: INC R3 ;NEW LINE NUMBER
ASL R2 ;NEW BIT FOR NEXT LINE
BEQ CKDH1F ;BRANCH IF TEST ALL DONE
JMP CKDH1B ;
CKDHPL: CK11SC 0,< Line #>
.ASCIZ \ Line #\
.EVEN
MOV R3,R0 ;LINE NUMBER TO R0 FOR CALL
JSR PC,CKTOCT ;PRINT LINE NUMBER
RTS PC ;RETURN
CKDH1F: BIS #DH..MC,(R4) ;MASTER CLEAR
MOV (SP)+,R3 ;GET R3 BACK
RTS PC ;DH CHARACTER TEST DONE
DHDATA: 0
DHXMII: 0
.ENDC ;.IF NE CK..DH
.IF NE CK..DL
.SBTTL CHECK DL11-E HDW
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKDL11
;
CKDL11: MOV R3,-(SP)
JSR R5,CHKBIT ;CHECK READ/WRITE BITS
000156
TST (R1)+ ;ADVANCE TO RECEIVE DATA REGISTER
TST (R1)+ ;ADVANCE TO TRANSMIT STATUS REGISTER
JSR R5,CHKBIT
000105
MOV (SP)+,R3
RTS PC
.ENDC ;.IF NE CK..DL
.IF NE CK..LK
.SBTTL CHECK DL11-A HDW
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKKL11
;
CKKL11: MOV R3,-(SP)
JSR R5,CHKBIT ;CHECK READ/WRITE BITS
.WORD 000100
TST (R1)+ ;ADVANCE TO RECEIVE DATA REGISTER
TST (R1)+ ;ADVANCE TO TRANSMIT STATUS REGISTER
JSR R5,CHKBIT
.WORD 000104
MOV #CO.INE,4(R4) ;ENABLE PENDING OUTPUT INTERRUPT
JSR R5,CHKINL ;TEST INTERURPTS
.WORD -1 ;TIMEOUT COUNTER
BIC #CO.INE,4(R4) ;DISABLE THAT INTERRUPT
MOV (SP)+,R3
RTS PC
.ENDC ;.IF NE CK..KL
.IF NE CK..DM
.SBTTL CHECK DM11-BB HDW
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKDM11
CKDM11: JSR R5,CHKBIT ;CHECK FOLLOWING BITS
DM.ALI!DM.DNE!DM..MM!DM.ENB!DM.IEN
$CKINT ,R4,<DM.IEN>,<DM.DNE>
JSR PC,CKDMCS ;CLEAR SCAN AND CHECK IT CLEARED
BIS #DM.ENB,(R4) ;ENABLE SCAN
BIT #DM.BSY,(R4) ;SEE IF BSY SET
BNE 11$ ;BRANCH IF IT DID
CK11SC <CKEPC!CKEDID>,<Busy did not Set>,<BUSY DID NOT SET>
.ASCIZ \Busy did not Set\
.EVEN
11$: JSR PC,CKDMCS ;CLEAR SCAN AND CHECKED IT CLEARED
RTS PC
CKDMCS: MOV #DM.DNE!DM..MM!DM.IEN!DM.ENB!DM.ALI,R2 ;BITS WHICH SHOULD GET CLEARED
MOV #100,R0 ;TIME OUT FOR BUSY
BIS #DM.SCN,(R4) ;CLEAR SCAN
11$: BIT #DM.BSY,(R4) ;SEE IF BUSY CLEAR YET
BEQ 12$ ;BRANCH IF IT IS
SOB R0,11$ ;TIME OUT WAITING FOR BSY TO CLEAR
CK11SC <CKEPC!CKEDID>,<Busy did not Clear>,<CLEARING SCAN FAILED TO CLEAR BUSY>
.ASCIZ \Busy did not Clear\
.EVEN
12$: BIT R1,(R4) ;SEE IF THEY ARE ALL CLEAR
BEQ 14$ ;BRANCH IF THEY ARE ALL CLEAR
MOV (R4),R0 ;GET DM11 STATUS
COM R2 ;MASK OUT NON INTERESTING BITS
BIC R2,R0 ;
CLR -(SP) ;GOOD
MOV R0,-(SP) ;BAD
MOV R4,-(SP) ;ADR
CK11SC <CKEGB!CKEPC!CKEDID>,<Clear Scan Error>,<CLR SCAN FAILED TO CLEAR A BIT>
.ASCIZ \Clear Scan Error\
.EVEN
14$: RTS PC
.ENDC ;.IF NE CK..DM
.IF NE CK..DN
.SBTTL CHECK DN11 HDW
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKDN11
CKDN11: JSR R5,CHKBIT ;CHECK BITS
007714 ;READ/WRITE BITS
$CKINT ,R4,<DN..IE!DN..ME>,<DN.DNE>
RTS PC
.ENDC ;.IF NE CK..DN
.IF NE CK..DP
.SBTTL CHECK DP11 HDW
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKDP11
CKDP11: JSR R5,CHKBIT ;CHECK BITS
3707 ;READ/WRITE BITS
TST (R1)+ ;ADV TO REC BUF/SYN REG
; JSR R5,CHKBIT ;CHECK BITS
; 000000 ;READ/WRITE BITS
TST (R1)+ ;ADV TO XMT STATUS REG
JSR R5,CHKBIT
000143 ;READ/WRITE BITS
; TST (R1)+ ;ADV TO XMT BUFFER
; JSR R5,CHKBIT
; 000000 ;READ/WRITE BITS
$CKINT R4,R4,B6,B7
RTS PC
.ENDC ;.IF NE CK..DP
.IF NE CK..DQ
.SBTTL CHECK DQ11 HDW
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKDQ11
CKDQ11:
JSR R5,CHKBIT ;CHECK WE CAN SET BITS
110373 ;READ/WRITE BITS
TST (R1)+ ;ADVANCE TO XMT REGISTER
JSR R5,CHKBIT ;CHECK WE CAN SET BITS
101772 ;READ/WRITE BITS
TST (R1)+ ;ADVANCE TO ERR REGISTER
JSR R5,CHKBIT ;CHECK WE CAN SET BITS
017477 ;READ/WRITE BITS
TST (R1)+ ;ADVANCE TO SHADOW REGISTERS
JSR R5,CHKBIT
-1
;DETERMINE DQ11 INTERRUPT LEVEL
;
11$: $CKINT R4,R4,DQ.RIE,<DQ.RDP!DQ.RDS>
MOV CHKCHR+CKDV,-(SP) ;SAVE VECTOR
ADD #4,CHKCHR+CKDV ;MAKE VECTOR B
CMP (R1)+,(R2)+ ;POINT TO XMIT REG
$CKINT ,,<DQ.XIE>,<DQ.XDS!DQ.XDP>
TST (R2)+ ;ADVANCE INT BIT POINTER TO ERR REG
$CKINT ,,<DQ.EIE>,<DQ.VRC!DQ.XLE!DQ.RLE!DQ.XNX!DQ.RNX!DQ.XCL!DQ.RCL>
MOV (SP)+,CHKCHR+CKDV ;RESTORE VECTOR A VECTOR
;HERE BECAUSE DQ11 TRAPED TO RIGHT LOCATION
; CHECK WE CAN CLEAR THE DATASET FLAG
12$: MOV #5,R0 ;PATIENCE COUNTER ON DATASET FLAG
13$: BIC #DQ.DSF,2(R4) ;CLEAR DATASET FLAG
CMP (SP),(SP) ;TIME WASTER ONLY
BIT #DQ.DSF,2(R4) ;CHECK TO SEE IF DATASET FLAG STILL OFF
BEQ CHKDQE
SOB R0,13$
CK11SC <CKEDID!CKEPC>,<Can't Clr Dataset Flg>,< CAN'T CLEAR DATASET FLAG>
.ASCIZ \Can't Clr Dataset Flg\
.EVEN
;CHECK ERROR BITS WORK
;
CHKDQE: JSR PC,CKDQCL ;CLEAR ENTIRE DQ
MOV #40,R2 ;FIRST BIT TO TRY
11$: BIS R2,4(R4) ;SET AN ERROR BIT
MOV 4(R4),R0 ;GET ERR REG
BPL 12$ ;BRANCH IF B15 ERR NOT SET
BIT R2,R0 ;SEE IF THE BIT SET
BNE 13$ ;BRANCH IF B15 SET AND ERR BIT SET
12$: MOV R2,-(SP) ;SAVE GOOD
BIS #B15,(SP) ; ALSO MUST INCLUDE BIT 15.
JSR PC,CKDQES ;PUT BAD AND REG # ON STACK
CK11SC <CKEDID!CKEPC!CKEGB>,<Bit not Set>,<CAN'T SET BIT>
.ASCIZ \Bit not Set\
.EVEN
13$: BIC R2,4(R4) ;CLEAR BIT JUST SET, SHOULD ALSO CLEAR B15.
MOV 4(R4),R0 ;SAVE RESULTS
BMI 14$ ;BRANCH IF B15 SET (IT SHOULDN'T BE)
BIT R2,R0 ;SEE IF THE BIT IS CLEAR
BEQ 15$ ;BRANCH IF ITS 0
14$: CLR -(SP) ;WHAT GOOD SHOULD BE
JSR PC,CKDQES ;SAVE BD, AND REG # ON STACK
CK11SC <CKEDID!CKEPC!CKEGB>,<Bit not Clear>,<COULDN'T CLEAR BIT>
.ASCIZ \Bit not Clear\
.EVEN
15$: ASR R2 ;ALL DONE?
BNE 11$ ;BRANCH BACK IF ANOTHER BIT TO TEST
BR CHKDQS ;GO CHECK SECONDARY REGS
CKDQES: MOV (SP)+,R1 ;SAVE RETURN PC
MOV R0,-(SP) ;PUT C(ERR REG) ON STACK
MOV R2,-(SP) ;BIT WE TESTED
BIS #B15,(SP) ;INCLUDE ERROR BIT
COM (SP) ;
BIC (SP)+,(SP) ;KEEP ONLY THE INTERESTING BITS
MOV R4,-(SP) ;SAVE REG ADR
ADD #4,(SP) ;MAKE IT THE ERROR REG
JMP (R1) ;RETURN
;HERE TO CHECK WE CAN LOAD VARIOUS DQ11 SECONDARY REGISTERS
CHKDQS: CLR R0 ;1ST TRY TO CLEAR ALL SECONDARY REGISTERS
JSR PC,16$ ;GO DO IT
MOV #-1,R0 ;NOW TRY TO SET ALL SECONDARY REGISTERS
JSR PC,16$
MOV #1,R0 ;BIT TO LOAD
11$: JSR PC,16$ ;TRY TO LOAD BIT
ASL R0 ;SHIFT BIT
BNE 11$ ;BRANCH IF STILL HAVE BITS TO TEST
MOV #RG.SYN,R1 ;NOW TRY TO LOAD REG WITH REG #
12$: MOV R1,R0 ;DATA = REGISTER NUMBER
JSR PC,CKDQSL ;TRY TO LOAD REGISTER
CMP #RG.SYN,R1
BNE 13$
DEC R1 ;SKIP REG 10
13$: DEC R1 ;ON TO NEXT REGISTER
BPL 12$
MOV #RG.SYN,R1 ;NOW CHECK IT LOADED
14$: MOV R1,R0 ;DATA SHOULD BE SAME
JSR PC,CKDQSR ;CHECK DATA STILL THERE
CMP #RG.SYN,R1 ;WAS THIS THE FIRST REG ?
BNE 15$
DEC R1 ;YES SO SKIP REG 10
15$: DEC R1 ;ON TO NEXT REGISTER
BPL 14$ ;DO REST IF ANY
MOV #RG.MSC,R1 ;NOW TEST MISC REG
CLR R0 ;TRY TO CLEAR REGISTER
JSR PC,CKDQSL ;TRY TO LOAD IT
MOV #2,R0 ;TEST STEP-MODE BIT
JSR PC,CKDQSL
MOV #10,R0 ;TEST TEST-LOOP BIT
JSR PC,CKDQSL
CLR R0
JSR PC,CKDQSL ;CLEAR MISC REG
BR CHKDQL ;DO A LOOP BACK TEST
16$: MOV #RG.SYN,R1 ;1ST REGISTER TO LOAD
17$: JSR PC,CKDQSL
CMP #RG.SYN,R1 ;DID WE JUST CHECK THE SYN REG ?
BNE 18$
DEC R1 ;YES SO SKIP A REG
18$: DEC R1 ;ON TO THE NEXT REG
BPL 17$
RTS PC ;YES
;HERE TO LOAD A DQ11 2NDARY REGISTER
; CALL MOV #DATA,R0
; MOV #REG,R1
; JSR PC,CKDQSL
CKDQSL: BIS #DQ.MBM,R1
MOVB R1,5(R4) ;SELECT THE REGISTER
MOV R0,6(R4) ;LOAD THE DATA
CKDQSR: BIS #DQ.MBM,R1
MOVB R1,5(R4) ;SELECT THE REGISTER
BIC #DQ.MBM,R1
CMP R0,6(R4) ;CHECK TO SEE IF WE LOADED IT
BNE 11$
RTS PC
11$: MOV R0,-(SP) ;SAVE GOOD DATA
MOV 6(R4),-(SP) ;SAVE BAD DATA
MOV R1,-(SP) ;SAVE 2ND REG #
CK11SC <CKEDID!CKEPC!CKEGB>,<Secondary Reg Err>,<SECONDARY REG ERROR>
.ASCIZ \Secondary Reg Err\
.EVEN
RTS PC ;RETURN
.SBTTL FIND THE DQ11 SPECIAL CHARACTERS
;HERE TO DISCOVER WHAT THE SPECIAL
;CHARACTERS ARE IN THE DQ11.
;
CHKDQL:
.IF NE SPCVFY ;CHECK FOR SPECIAL CHARS ONLY IF USED
CLR CHKCHR+CKFLG ;CLEAR WHERE WE COUNT SPECIAL CHARS
MOV R2,-(SP) ;SAVE R2
MOV R3,-(SP) ;SAVE R3 (VECTOR)
MOV R5,-(SP) ;SAVE R5
MOVB #255,CHKXBF+2 ;SOMETHING OTHER THAN SYNC (226)
CLR R3 ;START WITH CHARACTER 0
CKDQLP:
11$: JSR PC,CKDQCL ;CLEAR DQ
MOV #CHKRBF,R5 ;ADDRESS TO LOAD
MOV #<<CHKRBF-CHKXBF>/2>,R1 ;LENGTH TO LOAD
CLR R2 ;DATA TO LOAD
JSR PC,CKLDBF ;LOAD BUFFER
MOV #226*401,CHKXBF ;SYNC CHAR WE USE
MOVB R3,CHKXBF+3 ;PUT CHAR IN XMIT BUFFER
DQREGS SYN,(R4) ;SYNC REG
MOV #226*401,6(R4) ;PUT SYNC CHAR IN REG
DQREGS MSC,(R4) ;MISC REG
MOV #4010,6(R4) ;LOAD MISC REG
DQREGS PTA,(R4) ;PRI XMIT ADDR REG
MOV #CHKXBF,6(R4) ;LOAD XMIT PRI ADDR REG
DQREGS STA,(R4) ;SEC XMIT ADR REG
MOV #CHKXBF,6(R4) ;LOAD XMIT SEC ADDR REG
DQREGS PRA,(R4) ;PRIMARY RECEIVE ADDR REG
MOV #CHKRBF,6(R4) ;LOAD REC ADDR REG PRI
DQREGS SRA,(R4) ;SEC REC ADR REG
MOV #CHKRBF,6(R4) ;LOAD REC ADDR REG SEC
DQREGS PTC,(R4) ;PRI XMIT CC
MOV #-4,6(R4) ;LOAD PRI XMIT CC
DQREGS STC,(R4) ;SEC XMIT CC
MOV #-2,6(R4) ;LOAD SEC XMIT CC
DQREGS PRC,(R4) ;PRI REC CC
MOV #-2,6(R4) ;LOAD PRI REC CC
DQREGS SRC,(R4) ;SEC REC CC
MOV #-2,6(R4) ;LOAD SEC REC CC
CLR R1 ;CLEAR SAVED STATUS
MOV #DQ.RGO!DQ.CIE!DQ.RIE,(R4) ;TELL REC TO GO WITH IE
MOV #DQ.XGO,2(R4) ;TELL XMIT TO GO
CKDQWA: CLR R5 ;FOR TIME-OUT
CLR R0 ;UPON INT R0 WILL GET VECTOR
MTPS #0 ;LET INT HAPPEN
11$: TST R0 ;SEE IF AN INTERRUPT
BNE 12$ ;BRANCH IF ONE (R0 IS NON 0)
SOB R5,11$ ;TIME OUT
CK11SC <CKEPC!CKEDID>,<Timed Out>,<TIMED OUT WHILE WAITING FOR AN INT>
.ASCIZ \Timed Out\
.EVEN
BR CKDQOT ;DON'T CHK THIS DQ ANY MORE
12$: CMP R0,CHKCHR+CKDV ;SEE IF WE CAME TO THE RIGH VECTOR
BEQ CKDQGI ;BRANCH IF WE DID
CKSERR <CHKCHR+CKDV>,R0,R4 ;SAVE GD,BD,DEV ADR
CK11SC <CKEPC!CKEDID!CKEGB>,<Interrupted to Wrong Vector>,<INTERRUPTED TO WRONG VECTOR>
.ASCIZ \Interrupted to Wrong Vector\
.EVEN
BR CKDQOT ;DON'T CHK ANY MORE OF THIS DQ
CKLDBF: MOV R2,(R5)+ ;PUT DATA IN ADDR
SOB R1,CKLDBF ;FILLED?
RTS PC ;YES.
CKDQGI: MOV (R4),R5 ;GET STATUS
TSTB R5 ;SEE IF DONE YET?
BMI 11$ ;BRANCH IF SO
BIT #DQ.RDS,R5 ;SEE IF SEC INT
BNE 14$ ;BRANCH IF IT IS
BIT #DQ.VCH,R5 ;SEE IF SPECIAL CHAR INT
BNE 12$ ;BRANCH IF SO
CK11SC <CKEDID!CKEPC>,<Illegal Interrupt>,<SOME BIT OTHER THAN SPEC CHAR INT'ED US>
.ASCIZ \Illegal Interrupt\
.EVEN
BR CKDQOT ;DON'T CHECK ANY MORE OF THIS DQ
11$: BIT #DQ.VCH,R5 ;SEE IF SPECIAL CHAR INT
BEQ 13$ ;BRANCH IF NOT
MOV R5,R1 ;SAVE REC STATUS FOR PRINT
BIC #DQ.VCH!DQ.RDP!DQ.CIE,(R4) ;DISMISS INT
BR CKDQWA ;GO WAIT FOR ANOTHER INT
12$: BIC #DQ.VCH,(R4) ;CLEAR FOR EXIT
BR CKDQWA ;GO WAIT FOR ANOTHER INT
13$: BIC #DQ.RDP,(R4) ;
BR CKDQWA ;GO WAIT FOR ANOTHER INT
14$: BIT #DQ.VCH,R1 ;WAS IT A SPECIAL CHAR?
BEQ 20$ ;NO, SO JUST UPDATE PATTERN
BIT #DQ.CHR,R1 ;WAS THERE CAUSE FOR VCH ?
BNE 15$ ;MUST BE NON 0 OR WHY ARE WE HERE
CK11SC <CKEDID!CKEPC>,<Spec Char Code Fld 0>,<SPECIAL CHAR CODE FIELD 0>
.ASCIZ \Spec Char Code Fld 0\
.EVEN
BR CKDQOT ;DON'T CHECK ANY MORE OF THIS DQ
15$: BIT #DQ.ETB!DQ.ETX!DQ.ENQ,R1 ;WAS IT INTERESTING SPECIAL CHAR ?
BNE 17$ ;IF SO FIND WHICH
BIS #B15,CHKCHR+CKFLG ;SET FLAG THAT SYNC INTERRUPTS
BR 20$
16$: .WORD B10
.WORD B9
.WORD B8
17$: MOV #4,R5 ;INDEX FOR SPECIAL CHAR TABLE
INC CHKCHR+CKFLG ;COUNT SPECIAL CHARACTER
18$: BIT 16$(R5),R1 ;CHECK FOR SPECIAL CHAR FLAG
BEQ 19$
MOV R3,CHKCHR+CKSPC(R5) ;PUT INTO THE TABLE
19$: SUB #2,R5
BGE 18$ ;LOOK FOR ANOTHER MAYBE
20$: INCB R3 ;NEXT CHAR TO CHECK
BEQ 21$ ;BRANCH IF ALL DONE
BIC #DQ.RDS!DQ.VCH!DQ.CIE!DQ.RIE,(R4) ;
JMP CKDQLP ;
CKDQOT=.
21$: MOV (SP)+,R5
MOV (SP)+,R3
MOV (SP)+,R2
CMPB CHKCHR+CKFLG,#4 ;SHOULD BE NO MORE THAT 4
BLE 23$ ;CHECK IF SO
CK11SC <CKEDID!CKEPC>,<More than 4 Spec Char Det>,<MORE THAN 4 SPEC CHAR WERE DETECTED>
.ASCIZ \More than 4 Spec Char Det\
.EVEN
BR CKDQOT ;DON'T CHECK ANY MORE OF THIS DQ
.IFF
22$: JSR R0,CKTSTR
.ASCIZ \ SKIPPING SPEC CHAR TEST\
.EVEN
MOV #377+<<.+6-22$>/2>,22$ ;SHUT OFF SKIPPING COMMENT
.ENDC ; .IF NE SPCVFY
23$: RTS PC ;RETURN
.SBTTL CLEAR THE DQ11
;ROUTINE TO CLEAR THE ENTIRE DQ
;
CKDQCL: MOV R0,-(SP)
MOV R1,-(SP)
MOV R2,-(SP)
DQREGS MSC,(R4) ;SELECT MISC REG
MOV #DQ.MC,6(R4) ;MASTER CLEAR
DQREGS MSC,(R4) ;SELECT MISC REG AGAIN
MOV #DQ.MC,6(R4) ;MASTER CLEAR AGAIN
MOV #17,R0 ;CLEAR ALL SEC REG
MOV #B12,R2 ;CLEAR BITS 13+14 IN ERR
11$: MOV R2,4(R4) ;SELECT A SEC REG
CLR 6(R4) ;CLEAR THAT SEC REG
ADD #B8,R2 ;SELECT NEXT SEC REG TO CLEAR
SOB R0,11$ ;ALL SEC CLEARED?
MOV (SP)+,R2 ;RESTORE REGS USED
MOV (SP)+,R1
MOV (SP)+,R0
RTS PC ;RETURN
.IIF NDF CHKBSZ,CHKBSZ=10
CHKXBF: .BLKB CHKBSZ
CHKRBF: .BLKB CHKBSZ
.ENDC ;.IF NE CK..DQ
.IF NE CK..DS
.SBTTL CHECK DS11 HDW [1(22)]
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKDS11
;
CKDS11:
MOV DS.AUX,R1 ;GET AUX REG TO SEE HOW MANY GROUPS
MOV #DS.AD1,R2 ;FOR CHECKING GROUP NUMBER
MOV #4,R0 ;ALWAYS 1 GROUP IF DS11
11$: BIT R2,R1 ;GROUP EXIST?
BEQ 12$ ;BRANCH IF NO GROUP
ADD #4,R0 ;COUNT 4 LINES FOR EACH GROUP
ASL R2 ;POSITION TO CHECK NEXT GROUP BIT
BNE 11$ ;BRANCH IF WE CAN CHECK ANOTHER
12$: JSR PC,CKTBOC ;PRINT NUMBER OF LINES
CK11SC CKENCL,< Lines>
.ASCIZ \ Lines\
.EVEN
MOV #DS.AUX,R1 ;CHECK THE AUX REG
JSR R5,CHKBIT ;CHECK FOLLOWING BITS
1700 ;BITS TO CHECK
MOV #DS.DVA-2,R1 ;SET TO CHECK LINES
MOV #DS.VEC,CHKCHR+CKDV ;VECTOR TO START AT
MOV 26(R5),CHKCHR+CKPI ;PI LEVEL FOR ALL DS11
MOV R0,R2 ;NUMBER OF LINES TO CHECK
MOV #CHKCHR,R0 ;POINT TO BLOCK FOR MAIN CALL
13$: ADD #2,R1 ;LINE ADR TO CHECK
MOV R1,CHKCHR+CKDA ;MAIN NEEDS THIS INFO
JSR R5,CHKBIT ;CHK RECEIVE STATUS REG
6477 ;BITS TO CHECK
TST (R1)+ ;ADVANCE TO REC DATA REG
JSR R5,CHKBIT ;CHK RECEIVE DATA REG
7777 ;BITS TO CHECK
TST (R1)+ ;ADVANCE TO XMIT STATUS REG
JSR R5,CHKBIT ;CHK XMIT STATUS REG
476 ;BITS TO CHECK
TST (R1)+ ;ADVNACE TO XMIT DATA REG
JSR R5,CHKBIT ;CHK XMIT DATA REG
7777 ;BITS TO CHECK
JSR PC,@14(R5) ;CALL THE MAIN PROGRAM
ADD #20,CHKCHR+CKDV ;ADVANCE VECTOR ADR FOR NEXT LINE
ADD #10,CHKCHR+CKDA ;ADVANCE DEVICE ADR FOR NEXT LINE
SOB R2,13$ ;ALL LINES CHECKED?
MOV #DS.VEC,CHKCHR+CKDV ;SO "CHKDEV" WILL FILL OUT BLOCK
RTS PC
.ENDC ;.IF NE CK..DS
.IF NE CK..UP
.SBTTL CHECK DUP11 HDW
;CALL MOV #<VECTOR ADR OF DUP11>,R3
; MOV #<HDW ADR OF DUP11>,R4
; MOV #<HDW ADR OF DUP11>,R1
; JSR PC,CKUP11
;
CKUP11: MOV R5,-(SP) ;SAVE R5
MOV R4,-(SP) ; AND R4
MOV R3,-(SP) ; AND R3
JSR R5,CHKBIT ;VERIFY THESE BITS WORK
.WORD UP.DTR!UP.RTS!UP.STD!UP.REN!UP.DIE!UP.SSY
ADD #4,R1 ;TEST OTHER CSR
JSR R5,CHKBIT ;VERIFY THESE BITS WORK
.WORD UP.HDX!UP.SND!UP.XIE
MOV #3,R0 ;BE SURE INIT BIT CLEARS ITSELF
MOV #UP.INI,UP.XSR(R4) ;INIT THE DUP11
11$: MOV UP.XSR(R4),R1 ;GET THE CSR
BIT #UP.INI,R1 ;HAS BIT CLEARED ITSELF?
BEQ 13$ ;YES, GO ON.
SOB R0,11$ ;NO, GIVE IT 2 MICROSECONDS
CKSERR #0,R1,R4 ;SAVE VALUES
CK11SC <CKEPC!CKEGB>,<DUP11 CLEAR FAILED>,<DUP11 CLEAR FAILED>
.ASCIZ /DUP11 clear failed/
.EVEN
12$: MOV #UP.INI,UP.XSR(R4) ;BE SURE DUP11 IS CLEAR
MOV (SP)+,R3 ;RESTORE R3
MOV (SP)+,R4 ; AND R4
MOV (SP)+,R5 ; AND R6
RTS PC ;RETURN.
;
; COME HERE IF THE DUP11 PASSES THE PRELIMINARY TESTS. CHECK ITS
; INTERRUPTS.
;
13$: MOV R4,R1 ;POINT TO TRANSMIT CSR
ADD #4,R1
MOV R1,R2
ADD #4,CHKCHR+CKDV ;MOVE XMIT VECTOR TO TRANSMIT
$CKINT ,,<UP.XIE>,<UP.XDN>,<UP.INI>
SUB #4,CHKCHR+CKDV ;RESTORE BASE VECTOR
BR 12$ ;ALL DONE.
.ENDC ;.IF NE CK..UP
.IF NE,CK..MD!CK..ME!CK..MH ;3(62)
.SBTTL CHECK KMC11 HDW ;3(60)
;CALL MOV #<VECTOR ADR OF KMC11>,R3
; MOV #<HDW ADR OF KMC11>,R4
; MOV #<HDW ADR OF KMC11>,R1
; JSR PC,CKMD11 or CKME11 or CKMH11 3(60)
;
; There are three flavors of KMC11 available -- MD (just plain)
; ME (intended to control DZ11) and MH (intended to control DUP-11).
; They are distinguished by their addresses, and are otherwise identical.
; CHK60 will check the KMC and optionally load the microcode, which must
; be included in the caller's source module at tag MDCODB, MECODB or MHCODB
; (depending upon the type of KMC11 to be loaded). 3(60)
.IF NE,CK..MD
CKMD11: ;start of plain KMC11 check 3(60)
.IF NE,FT.KMC ;if he wants it loaded
.IF DF,MDCODB
MOV #MDCODB,KMCMIC ;save address of microcode
.IFF;.IF DF,MDCODB
CLR KMCMIC ;indicate no load of microcode if none supplied
.ENDC;.IF DF,MDCODB
.IFF;.IF NE,FT.KMC ;if not
CLR KMCMIC ;store a zero to flag no microcode load
.ENDC;.IF NE,FT.KMC
BR CKKM11 ;go to common code
.ENDC;.IF NE,CK..MD
.IF NE,CK..ME
CKME11: ;start of KMC11 for DZ11 check 3(60)
.IF NE,FT.KMC ;if he wants it loaded
.IF DF,MECODB
MOV #MECODB,KMCMIC ;save address of microcode
.IFF;.IF DF,MECODB
CLR KMCMIC ;indicate no load if no microcode present
.ENDC;.IF DF,MECODB
.IFF;.IF NE,FT.KMC ;if not
CLR KMCMIC ;store a zero to flag no microcode load
.ENDC;.IF NE,FT.KMC
BR CKKM11 ;go to common code
.ENDC;.IF NE,CK..ME
.IF NE,CK..MH
CKMH11: ;start of KMC11 for DUP11 check 3(60)
.IF NE,FT.KMC ;if he wants it loaded
.IF DF,MHCODB
MOV #MHCODB,KMCMIC ;save address of microcode
.IFF;.IF DF,MHCODB
CLR KMCMIC ;indicate no load of microcode not present
.ENDC;.IF DF,MHCODB
.IFF;.IF NE,FT.KMC ;if not
CLR KMCMIC ;store a zero to flag no microcode load
.ENDC;.IF NE,FT.KMC
; BR CKKM11 ;fall into common code
.ENDC;.IF NE,CK..MH
CKKM11: MOV R5,-(SP) ;SAVE R5
MOV R4,-(SP) ; AND R4
MOV R3,-(SP) ; AND R3
MOV #MD.CLR,(R4) ;INITIALIZE THE KMC11
CLR (R4) ;CLEAR THE CSRS
CLR 2(R4)
CLR 4(R4)
CLR 6(R4)
JSR R5,CHKBIT ;VERIFY THESE BITS WORK
.WORD 377 ;ALL BITS OF BSEL 0
ADD #2,R1 ;LOOK AT SEL 2
JSR R5,CHKBIT ;VERIFY THESE BITS WORK
.WORD -1 ;ALL BITS OF SEL 2
ADD #2,R1 ;LOOK AT SEL 4
JSR R5,CHKBIT ;VERIFY THESE BITS WORK
.WORD -1 ;ALL BITS OF SEL 4
ADD #2,R1 ;LOOK AT SEL 6
JSR R5,CHKBIT ;VERIFY THESE BITS WORK
.WORD -1 ;ALL BITS OF SEL 6
.IF NE,FT.KMC
MOV KMCMIC,R1 ;get address of KMC11 microcode 3(60)
BEQ CKMDCC ;don't clobber anything if not loading 3(60)
TST 2(R1) ;see if user wants to preserve microcode 3(60)
BEQ CKMDCC ; DON'T CHECK INTERRUPTS (CLOBBERS CRAM 0)
.ENDC ;.IF NE,FT.KMC
;
; CHECK INTERRUPTS
;
$CKINT R4,R4,0,-1,MD.CLR,11$
BR CKMDCC ;CONTINUE TESTING THE KMC11
;
; SUBROUTINE TO CAUSE A KMC11 INTERRUPT
;
; R1 = ENABLE ADDRESS
; R2 = INTERRUPT ADDRESS
; R4 = CURRENT INTERRUPT BIT
; 0(R5) = INTERRUPT ENABLE BIT, CLEARED ON RETURN
; 4(R5) = INTERRUPT CLEAR BIT, SET ON RETURN
;
11$: MOV #MD.RMI,(R2) ;SET ROM I
MOV #<B8+B7>,6(R2) ;LOAD 200 INTO BRG
BIS #MD.SMP,(R2) ;EXECUTE THE INSTRUCTION
CLR (R2) ;TURN OFF STEP AND ROM I
MOV #MD.RMI,(R2) ;SET ROM I
MOV #<B14+B13+B9+B7+B4+11>,6(R2)
BIS #MD.SMP,(R2) ;STORE BRG INTO OUT* REG 11
CLR (R2) ;TURN OFF ROM I
RTS PC ;RETURN.
;
; IF WE HAVE A VALID COPY OF THE MICROCODE, WE CAN TEST
; THE CRAM. OTHERWISE BYPASS MOST OF THE TESTING.
;
CKMDCC:
.IF NE,FT.KMC
MOV KMCMIC,R1 ;get address of microcode 3(60)
BEQ 27$ ;if none, don't do anything 3(60)
TST 2(R1) ;is microcode image invalid? 3(69)
BNE 17$ ;NOT OBVIOUSLY
27$: JSR PC,CKMDEX ;YES, BE SURE WE CAN CYCLE THE CRAM
JMP CKMDXT ; BUT LEAVE ITS CONTENTS ALONE.
17$:
.ENDC ;.IF NE,FT.KMC
CLR R1 ;START AT CRAM ADDRESS 0
11$: CLR R0 ;DATA IS ZERO
JSR PC,CKMDWR ;WRITE 0 AND CHECK IT
INC R1 ;NEXT CRAM LOCATION
CMP #2000,R1 ;REACHED THE END OF THE CRAM?
BNE 11$ ;NO, DO THE REST.
JSR PC,CKMDEX ;COMPLEMENT THE CRAM TWICE
CLR R1 ;START AT THE BEGINNING AGAIN
12$: JSR PC,CKMDRD ;READ A WORD FROM THE CRAM
TST R0 ;IS IT ZERO?
BEQ 13$ ;YES, THAT IS OK.
CKSERR <#0>,R0,R1 ;GOOD, BAD, CRAM ADDRESS
CK11SC <CKEPC!CKEGB!CKEDID>,<CRAM CLEAR FAILED>,<CRAM CLEAR FAILED>
.ASCIZ / CRAM clear failed /
.EVEN
13$: INC R1 ;NEXT CRAM ADDRESS
CMP #2000,R1 ;REACHED THE END OF THE CRAM?
BNE 12$ ;NO, DO THE REST.
;
; NOW SET EACH CRAM LOCATION TO ITS OWN ADDRESS. THIS CHECKS FOR
; ADDRESSING FAILURES.
;
CLR R1 ;START AT LOCATION ZERO
14$: MOV R1,R0 ;GET ADDRESS
ASL R0 ; * 2 (WE ARE PUTTING THE 10-BIT
ASL R0 ; * 4 CRAM ADDRESS IN THE MIDDLE
ASL R0 ; * 8 OF THE 16-BIT WORD.)
JSR PC,CKMDWR ;WRITE ADDRESS INTO CRAM
INC R1 ;NEXT CRAM ADDRESS
CMP #2000,R1 ;REACHED END OF CRAM YET?
BNE 14$ ;NO, GO DO THE REST.
JSR PC,CKMDEX ;COMPLEMENT THE CRAM TWICE
CLR R1 ;START AT BEGINNING OF CRAM AGAIN
15$: JSR PC,CKMDRD ;READ WORD FROM CRAM
MOV R1,R2 ;GET CRAM ADDRESS
ASL R2 ; * 2
ASL R2 ; * 4
ASL R2 ; * 8
CMP R0,R2 ;IS THE CRAM OK?
BEQ 16$ ;YES.
CKSERR R2,R0,R1 ;GOOD, BAD, CRAM ADDRESS
CK11SC <CKEPC!CKEGB!CKEDID>,<CRAM ERROR>,<CRAM ERROR>
.ASCIZ / CRAM data = address error /
.EVEN
16$: INC R1 ;NEXT CRAM ADDRESS
CMP #2000,R1 ;REACHED THE END OF THE CRAM?
BNE 15$ ;NO, GO DO THE REST.
;
; NOW LOAD THE APPLICATION CODE INTO THE CRAM, IF REQUESTED.
;
CKMDCL:
.IF NE,FT.KMC
CLR R1 ;START AT THE BEGINNING OF THE CRAM
MOV KMCMIC,R2 ;POINT TO APPLICATION CODE 3(60)
11$: MOV (R2)+,R0 ;GET WORD TO LOAD
JSR PC,CKMDWR ;WRITE IT INTO THE CRAM
INC R1 ;POINT TO NEXT CRAM LOCATION
CMP R1,#2000 ;REACHED END OF CRAM? [2(41)]
BNE 11$ ;NO, LOAD THE REST.
JSR PC,CKMDEX ;COMPLEMENT THE CRAM TWICE
CLR R1 ;START AT BEGINNING OF CRAM AGAIN
MOV KMCMIC,R2 ;POINT TO APPLICATION CODE AGAIN 3(62)
12$: JSR PC,CKMDRD ;READ A WORD FROM THE CRAM
MOV (R2)+,R3 ;GET WORD THAT SHOULD BE THERE
CMP R3,R0 ;IS IT RIGHT?
BEQ 13$ ;YES.
CKSERR R3,R0,R1 ;GOOD, BAD, CRAM ADDRESS
CK11SC <CKEPC!CKEGB!CKEDID>,<CRAM LOAD ERROR>,<CRAM LOAD ERROR>
.ASCIZ / CRAM load error /
.EVEN
13$: INC R1 ;NEXT CRAM ADDRESS
CMP R1,#2000 ;REACHED END OF CRAM? [2(41)]
BNE 12$ ;NO, DO THE REST.
.ENDC ;.IF NE,FT.KMC
;
; HERE WHEN WE ARE DONE CHECKING THE KMC11
;
CKMDXT: MOV #MD.CLR,0(R4) ;BE SURE THE KMC11 IS CLEAR
MOV (SP)+,R3 ;RESTORE R3
MOV (SP)+,R4 ; AND R4
MOV (SP)+,R5 ; AND R5
RTS PC ;RETURN.
;
; SUBROUTINE TO COMPLEMENT THE DATA IN THE KMC11'S CRAM TWICE.
; IF THE KMC11 IS WORKING PROPERLY THIS WILL LEAVE THE CRAM
; UNCHANGED.
;
CKMDEX: CLR R1 ;START AT BEGINNING OF CRAM
11$: JSR PC,CKMDRD ;READ WORD FROM CRAM
COM R0 ;COMPLEMENT IT
JSR PC,CKMDWR ;WRITE IT BACK (AND CHECK IT)
INC R1 ;NEXT CRAM LOCATION
CMP #2000,R1 ;REACHED END OF CRAM?
BNE 11$ ;NO, DO THE REST.
;
; NOW COMPLEMENT CRAM THE SECOND TIME
;
CLR R1 ;BEGINNING OF THE CRAM
12$: JSR PC,CKMDRD ;READ A WORD FROM THE CRAM
COM R0 ;COMPLEMENT IT
JSR PC,CKMDWR ;WRITE IT BACK
INC R1 ;NEXT CRAM LOCATION
CMP #2000,R1 ;REACHED THE END OF THE CRAM?
BNE 12$ ;NO, DO THE REST.
RTS PC ;YES, ALL DONE.
;
; SUBROUTINE TO WRITE A WORD INTO THE KMC11'S CRAM
;
; R0 = WORD TO WRITE
; R1 = CRAM ADDRESS
; R4 = POINTER TO KMC11 CSR
;
CKMDWR: CLR (R4) ;CLEAR BSEL 1
MOV R1,4(R4) ;SET ADDRESS INTO SEL 4
MOV R0,6(R4) ;LOAD DATA INTO SEL 6
BIS #MD.RMO,(R4) ;SET ROM O
BIS #MD.RMO!MD.CWR,(R4) ;SET CRAM WRITE ALSO
CLR (R4) ;CLEAR ROM O AND CRAM WRITE
MOV R1,4(R4) ;SET ADDRESS AGAIN
BIS #MD.RMO,(R4) ;SET ROM O
MOV 6(R4),-(SP) ;GET DATA FROM CRAM
CLR (R4) ;CLEAR ROM O
CMP R0,(SP) ;DATA SAME AS WRITTEN?
BEQ 11$ ;YES.
MOV R2,-(SP) ;NO, SAVE R2
MOV 2(SP),R2 ;GET BAD DATA FROM CRAM
CKSERR R0,R2,R1 ;GOOD, BAD, CRAM ADDRESS
CK11SC <CKEPC!CKEGB!CKEDID>,<CRAM DATA ERROR>,<CRAM DATA ERROR>
.ASCIZ / CRAM data error in write check /
.EVEN
MOV (SP)+,R2 ;RESTORE R2
11$: MOV (SP)+,R0 ;DELETE DATA FROM STACK
RTS PC ;RETURN.
;
; SUBROUTINE TO READ A WORD FROM THE KMC11'S CRAM.
;
; R1 = ADDRESS
; R4 = POINTER TO KMC11 CSR
;
; ON RETURN:
;
; R0 = DATA FROM CRAM
;
CKMDRD: CLR (R4) ;CLEAR BSEL 1
MOV R1,4(R4) ;SET ADDRESS INTO BSEL 4
BIS #MD.RMO,(R4) ;SET ROM O
MOV 6(R4),R0 ;FETCH DATA
CLR (R4) ;CLEAR ROM O
RTS PC ;RETURN.
KMCMIC: .WORD 0 ;cell to contain address of KMC11 microcode 3(62)
.ENDC ;.IF NE,<CK..MD!CK..ME!CK..MH>
.IF NE,CK..MC
.SBTTL CHECK DMC11 HDW
;CALL MOV #<VECTOR ADR OF DMC11>,R3
; MOV #<HDW ADR OF DMC11>,R4
; MOV #<HDW ADR OF DMC11>,R1
; JSR PC,CKMC11
;
CKMC11: MOV R5,-(SP) ;SAVE R5
MOV R4,-(SP) ; AND R4
MOV R3,-(SP) ; AND R3
MOV #MC.MCL,(R4) ;INITIALIZE THE DMC11
CLR (R4) ;CLEAR THE CSRS
CLR 2(R4)
CLR 4(R4)
CLR 6(R4)
JSR R5,CHKBIT ;VERIFY THESE BITS WORK
.WORD 377 ;ALL BITS OF BSEL 0
ADD #2,R1 ;LOOK AT SEL 2
JSR R5,CHKBIT ;VERIFY THESE BITS WORK
.WORD -1 ;ALL BITS OF SEL 2
ADD #2,R1 ;LOOK AT SEL 4
JSR R5,CHKBIT ;VERIFY THESE BITS WORK
.WORD -1 ;ALL BITS OF SEL 4
ADD #2,R1 ;LOOK AT SEL 6
JSR R5,CHKBIT ;VERIFY THESE BITS WORK
.WORD -1 ;ALL BITS OF SEL 6
;
; CHECK INTERRUPTS
;
$CKINT R4,R4,0,-1,MC.MCL,11$
BR CKMCCC ;CONTINUE TESTING THE DMC11
;
; SUBROUTINE TO CAUSE A DMC11 INTERRUPT
;
; R1 = ENABLE ADDRESS
; R2 = INTERRUPT ADDRESS
; R4 = CURRENT INTERRUPT BIT
; 0(R5) = INTERRUPT ENABLE BIT, CLEARED ON RETURN
; 4(R5) = INTERRUPT CLEAR BIT, SET ON RETURN
;
11$: MOV #MC.RMI,(R2) ;SET ROM I
MOV #<B8+B7>,6(R2) ;LOAD 200 INTO BRG
BIS #MC.SMP,(R2) ;EXECUTE THE INSTRUCTION
CLR (R2) ;TURN OFF STEP AND ROM I
MOV #MC.RMI,(R2) ;SET ROM I
MOV #<B14+B13+B9+B7+B4+11>,6(R2)
BIS #MC.SMP,(R2) ;STORE BRG INTO OUT* REG 11
CLR (R2) ;TURN OFF ROM I
RTS PC ;RETURN.
;
; TEST CONTENTS OF CROM
;
CKMCCC:
JSR PC,CKMCEX ;YES, BE SURE WE CAN CYCLE THE CROM
;
; HERE WHEN WE ARE DONE CHECKING THE DMC11
;
CKMCXT: MOV #MC.MCL,0(R4) ;BE SURE THE DMC11 IS CLEAR
MOV (SP)+,R3 ;RESTORE R3
MOV (SP)+,R4 ; AND R4
MOV (SP)+,R5 ; AND R5
RTS PC ;RETURN.
;
; SUBROUTINE TO MAKE SURE WE CAN READ CROM
;
CKMCEX: CLR R1 ;START AT BEGINNING OF CROM
11$: JSR PC,CKMCRD ;READ WORD FROM CROM
INC R1 ;NEXT CROM LOCATION
CMP #2000,R1 ;REACHED END OF CROM?
BNE 11$ ;NO, DO THE REST.
RTS PC ;YES, ALL DONE.
;
; SUBROUTINE TO READ A WORD FROM THE DMC11'S CROM.
;
; R1 = ADDRESS
; R4 = POINTER TO DMC11 CSR
;
; ON RETURN:
;
; R0 = DATA FROM CROM
;
CKMCRD: CLR (R4) ;CLEAR BSEL 1
MOV R1,4(R4) ;SET ADDRESS INTO BSEL 4
BIS #MC.RMO,(R4) ;SET ROM O
MOV 6(R4),R0 ;FETCH DATA
CLR (R4) ;CLEAR ROM O
RTS PC ;RETURN.
.ENDC ;.IF NE CK..MC
.IF NE CK..DZ
.SBTTL Check DZ11 Hardware [1(14)]
;Call:
;
; MOV #<vector address>,R3
; MOV #<hardware address>,R4
; MOV #<hardware address>,R1
; JSR PC,CKDZ11
;
CKDZ11: ;check DZ11 hardware
MOV R5,-(SP) ;save register
MOV R4,-(SP) ; ditto
MOV R3,-(SP) ;save vector address
JSR R5,CHKBIT ;test CSR read/write bits
.WORD DZ.MAI!DZ.MSE!DZ.RIE!DZ.SAE!DZ.TIE ;all read/write bits
ADD #4,R1 ;point to transmit control register
JSR R5,CHKBIT ;test TCR read/write bits
.WORD -1 ;all bits are read/write
MOV #5,R0 ;timer
MOV #DZ.CLR,(R4) ;start clear going
11$: ;beginning of timing loop
MOV (R4),R1 ;get CSR value
BEQ CKDZ00 ;if zero, continue test
SOB R0,11$ ;else, decrement count and loop
;here if DZ11 clear bit takes too long
CKSERR #0,R1,R4 ;save values
CK11SC <CKEPC!CKEGB>,<DZ11 clear failed or slow>,<clear bit failed to zero CSR in 5 passes through loop>
.ASCIZ /DZ11 clear failed or slow/
.EVEN
CKDZE: ;end of DZ11 checking code
MOV #DZ.CLR,(R4) ;clear DZ11
MOV (SP)+,R3
MOV (SP)+,R4
MOV (SP)+,R5
RTS PC ;return to caller
CKDZ00: ;here to check transmit ready bit
MOV #DZ.MSE!DZ.MAI,(R4) ;set maintenance and start scan
MOV #377,R5 ;bit map of lines
MOV R5,DZ.TCR(R4) ;enable all output lines
11$: ;here to wait for transmit ready flag
MOV #3,R0 ;set up counter
12$: ;loop looking for flag
MOV (R4),R1 ;check CSR
BMI 13$ ;if minus, flag is on so branch
SOB R0,12$ ;loop till count expires
CK11SC <CKEPC>,<DZ11 transmit flag didn't set>,<after enabling all lines for output, DZ..TI bit didn't come up>
.ASCIZ /DZ11 transmit flag didn't set/
.EVEN
BR CKDZE
13$: ;here when transmit ready flag up
MOV #1,R0 ;assume line 0
SWAB R1 ;get bits into right half
BIC #177770,R1 ;turn off unwanted bits
BEQ 15$ ;if zero, done
14$: ;loop to shift bits
ASL R0 ;shift
SOB R1,14$ ; the right number of times
15$: ;here when we have bit in R0
MOV #0,DZ.TDR(R4) ;send out a character on this line
BIC R0,R5 ;clear line bit
BNE 11$ ;if not all done, wait for next
ADD #4,CHKCHR+CKDV ;point to right vector
$CKINT R4,R4,<DZ.MSE!DZ.MAI!DZ.TIE>,<377>,<DZ.CLR>,16$ ;check output interrupts
BCS CKDZE ;if interrupt didn't occur, skip rest of test
SUB #4,CHKCHR+CKDV ;point to input vector again
$CKINT R4,R4,<DZ.MSE!DZ.MAI!DZ.RIE>,<377>,<DZ.CLR>,17$ ;check input interrupts
BCS CKDZE ;if interrupt didn't occur, skip rest of test
JMP CKDZ01 ;go perform loopback check
16$: ;subroutine to cause output interrupt
JSR PC,21$ ;clear DZ11
MOV (R5),(R1) ;set enables
MOVB R4,DZ.TCR(R1) ;enable the current line
TST (R1) ;check status
BPL .-2 ;wait till bit comes up
RTS PC ;return to caller
17$: ;subroutine to generate input interrupt
JSR PC,16$ ;clear DZ11 and get ready to output character
MOV R4,-(SP) ;save bit for line
MOV R4,-(SP) ;save counter
CLR R4 ;line number
18$:
ASR (SP) ;shift out a bit
BEQ 19$ ;done, exit loop
INC R4 ;count bit
BR 18$ ;and continue
19$: ;here with bit converted to line number
BIS #17400,R4 ;code for highest speed + turn receiver on
MOV R4,DZ.LPR(R1) ;set speed
MOV #377,DZ.TDR(R1) ;send a character out
CLR DZ.TCR(R1) ;disable further output
TST (SP)+ ;clean up stack
MOV #700,R4 ;timer
20$: SOB R4,20$ ;wait appropriate time
MOV (SP)+,R4 ;restore bit
RTS PC ;return to caller
21$: ;subroutine to clear DZ11 and wait
MOV #DZ.CLR,(R1) ;clear DZ11
TST (R1) ;check for completion
BNE .-2 ;loop till done
RTS PC ;return to caller
CKDZ01: ;here to do data loopback check
MOV #CKDZTR,R5 ;point to character tables
MOV #10,R2 ;get count of lines to load
11$: ;loop to load parameters
DEC R2 ;decrement count
MOV R2,R1 ;copy into parameter data register
BMI 12$ ;if negative, exit loop
ADD #DZ.RON!DZ.SPD!DZ.CL8,R1 ;add bits to line number
MOV R1,DZ.LPR(R4) ;and set parameters for the line
CLR 40(R5) ;clear error table entry
CLR 20(R5) ;initialize output character
CLR (R5)+ ;and input character
BR 11$ ;and continue looping
12$: ;here when line parameters and initial conditions set
MOV #DZ.MSE!DZ.MAI,(R4) ;start DZ11 going
MOV #377,DZ.TCR(R4) ;enable all lines
MOV #10,-(SP) ;get count
13$: ;loop to send and get characters
TST (R4) ;check output status
BPL 14$ ;if not ready, branch
JSR PC,16$ ;else, output next character
CLR R2 ;reset timer
14$: ;here to test input
BIT #DZ..RI,(R4) ;any input ready?
BEQ 15$ ;no, branch
JSR PC,18$ ;yes, check it
CLR R2 ;reset timer
15$: ;here to see if time to quit
TST (SP) ;any more lines left to output to?
BNE 13$ ;yes, unconditionally loop back
SOB R2,13$ ;NO, DECREMENT COUNT AND BRANCH
TST (SP)+ ;clean up stack
BR CKDZ02 ;go print errors, if any
16$: ;subroutine to send character
MOV (R4),R1 ;get CSR contents
SWAB R1 ;swap bytes
BIC #177770,R1 ;and leave only line number
MOV R1,R3 ;copy it
ASL R1 ;shift left to become index into table
ADD #CKDZTX,R1 ;make absolute address
CMP #400,(R1) ;have we sent last character?
BNE 17$ ;no, branch
JSR PC,22$ ;yes, turn line number into a bit
BIC R3,DZ.TCR(R4) ;and turn of that line's transmit enable
DEC 2(SP) ;one less line to worry about
INC (R1) ;and up character so we don't get here again
RTS PC
17$: ;here to send character
MOV (R1),DZ.TDR(R4) ;copy to output buffer
INC (R1) ;and increment for next time
RTS PC
18$: ;subroutine to receive character
MOV DZ.RBF(R4),R0 ;get receive buffer
MOV R0,R1 ;copy it for determining line
SWAB R1 ;swap bytes
BIC #177770,R1 ;and leave only line number
MOV R1,R3 ;copy line number
ASL R1 ;make into displacement in table
ADD #CKDZTR,R1 ;and make absolute
TST R0 ;check for valid data
BMI 20$ ;yes, branch
MOV R0,40(R1) ;no, copy error work into table
19$: MOV R3,DZ.LPR(R4) ;clear input enable
MOV #400,20(R1) ;and store final character for output
RTS PC
20$: ;here to check data character
BIC #177400,R0 ;clear junk
CMP R0,0(R1) ;is it what we expected?
BEQ 21$ ;yes, branch
MOVB R0,1(R1) ;save what we got instead
BR 19$ ;and clear input
21$: ;here if character right
INC (R1) ;figure out next character
RTS PC
22$: ;subroutine to convert line number to bit
MOV #1,-(SP) ;initial bit value
TST R3 ;check line number
BEQ 24$ ;if zero, we are done
23$: ;loop to shift bits
ASL (SP) ;shift bit left
SOB R3,23$ ;until count exhausted
24$: ;here to put bit value in return reg
MOV (SP)+,R3 ;copy into register and clean up stack
RTS PC
;Here to check for errors
; if all OK on a line, will have 400 as expected receive character
; or expected receive character will contain good in RH and
; bad received character in LH.
; If the error was an error bit on receive, the
; CKDZTE table entry will be non-zero.
CKDZ02: ;print error messages on appropriate lines
MOV #CKDZTR,R5 ;point to beginning of table
11$: ;loop checking for errors
CMP R5,#CKDZTR+20 ;have we checked all lines?
BEQ 18$ ;yes, exit
CMP (R5),#400 ;check if all received OK
BEQ 17$ ;yes, continue looking
TST 40(R5) ;no, error bit detected?
BNE 13$ ;yes, branch to report it
JSR PC,12$ ;get line number into R0
MOVB (R5),R2 ;get expected char
MOVB 1(R5),R3 ;get received char
BIC #177400,R2 ;clear extra
BIC #177400,R3 ; bits
CKSERR R2,R3,R0 ;save good, bad and line as address
CK11SC <CKEPC!CKEGB!CKEDID>,<WRONG CHARACTER RECEIVED>;report error
.ASCIZ \Wrong character received\
.EVEN
BR 17$ ;and advance to next line
12$: ;subroutine to get line number
MOV R5,R0 ;copy address of entry
SUB #CKDZTR,R0 ;make displacement into table
ASR R0 ;make into line number
RTS PC
13$: ;here to check error bits
BIT #DZ.DOV,40(R5) ;overrun?
BEQ 14$ ;no, branch
CK11SC <CKEPC>,<RECEIVE OVERRUN>;type message
.ASCIZ \Receive overrun\
.EVEN
14$: ;here to check for framing error
BIT #DZ..FE,40(R5) ;framing error?
BEQ 15$ ;no, branch
CK11SC <CKEPC>,<FRAMING ERROR>;report error
.ASCIZ \Framing error\
.EVEN
15$: ;here to check for parity error
BIT #DZ..PE,40(R5) ;parity error?
BEQ 16$ ;no, branch
CK11SC <CKEPC>,<PARITY ERROR>;report error
.ASCIZ \Parity error\
.EVEN
16$: ;here to print line number
CK11SC <CKENCL>,< ON LINE >
.ASCIZ \ on line \
.EVEN
JSR PC,12$ ;get line number
JSR PC,CKTOCT ;print as octal number
17$: ;here to advance to next line
ADD #2,R5 ;advance table pointer
BR 11$ ;and go back
18$: ;here when done printing error messages
JMP CKDZE
.ENDC ;.IF NE CK..DZ
.IF NE CK..TE
.SBTTL CHECK DTE20 HARDWARE
;
; JSR PC,CKTE11
CKTE11:
; [1(17)]
.IIF DF,DTEBAD,MOV R1,DTEBAD ;SAVE DTE20 BASE ADR [1(26)]
JSR R5,CHKBIT ;CHECK DLYCNT IN DTE'S RAM
177777 ; SINCE WE CAN ACCESS ALL THE BITS
ADD #TE.STW-TE.DYC,R1 ;POINT TO STATUS REGISTER
.IIF DF,DTPSTA,MOV R1,DTPSTA ;SAVE THE POINTER TO STAT REG [1(26)]
MOV #TS.EEE,@R1 ;ENABLE INTERRUPTS
BIT #TS.IEN,@R1 ;DOES DTE AGREE?
BNE 11$ ;YEP
CK11SC <CKEPC!CKEDID>,<Setting TS.EEE didn't set TS.IEN>
.ASCIZ \Setting TS.EEE didn't set TS.IEN\
.EVEN
11$: MOV #TS.RES,@R1 ;NOW SEE IF IT WILL INTERRUPT US
JSR R5,CHKINL
-1 ;TIME DELAY COUNT
MOV #TS.DEI,@R1 ;TRY TO MAKE IT GO AWAY
BIT #TS.IEN,@R1 ;WHICH SHOULD TURN THIS OFF
BEQ 12$ ;OKAY
CK11SC <CKEPC!CKEDID>,<Setting TS.DEI didn't clear TS.IEN>
.ASCIZ \Setting TS.DEI didn't clear TS.IEN\
.EVEN
12$: BIT #TS.RM,@R1 ;WE SHOULD BE RESTRICTED
BNE 13$ ;WE ARE, FINE
CK11SC <CKEPC!CKEDID>,<DTE20 is not restricted>
.ASCIZ \DTE20 is not restricted\
13$: MOV #TS.RST,-(R1) ;REALLY INITIALIZE DTE20
.IIF DF,DTEDTO,MOV R3,DTEDTO ;SAVE PTR TO INTP VECTOR ADR [1(26)]
;DTEDTO GLOBAL CELL IS
; ALSO USED TO HOLD
; DEPOSIT/EXAMINE TIMEOUTS
RTS PC
.ENDC ;.IF NE CK..TE
.IF NE CK..CR
.SBTTL CHECK CR11 HARDWARE
;
; JSR PC,CKCR11
;
CKCR11:
JSR R5,CHKBIT ;CHECK HARDWARE BITS
CR.EJT!CR.INE
BIT #CR.BSY,(R4) ;SEE IF BUSY (MAYBE POWER OFF)
BEQ 11$ ;BRANCH IF COMMAND CAN BE GIVEV
CK11SC 0,< CR11 not Rdy>
.ASCIZ \ CR11 not Rdy\
.EVEN
MOV #CR.VEC,CHKCHR+CKPI ;GIVE DEFAULT LEVEL
RTS PC
11$: MOV #CR.INE!CR.CFD,(R4) ;SET INT ENABLE AND READ
; TO FORCE ANY KIND OF INT
CLR R0 ;FOR TIMING OUT
12$: BIT #CR.ERR!CR.CDN,(R4) ;SEE IF AN INT CONDITION EXISTS
BNE 13$ ;IF NOT, THEN WAIT.
SOB R0,12$ ;START TIMING OUT
BIC #CR.INE,(R4) ;DISABLE CR11 INT ENABLE
CK11SC <CKEPC!CKEDID>,<CR11 Timed Out>,<CR11 NOT RESPONDING>
.ASCIZ \CR11 Timed Out\
.EVEN
RTS PC
13$: JSR R5,CHKINL ;FIND INT LEVEL
-1 ;FOR TIME-OUT LOOP
BIC #CR.INE,(R4) ;DISABLE INT FOR CR11
RTS PC
.ENDC ;.IF NE CK..CR
.IF NE CK..LP
.SBTTL CHECK LP11 HARDWARE
;
; JSR PC,CKLP11
;
CKLP11:
BIT #LP.ERR,(R4) ;SEE IF DEV READY
BEQ 11$ ;BRANCH IF RDY
CK11SC <CKEMSG>,< LP11 #>
.ASCIZ \ LP11 #\
.EVEN
MOV CKDEVN,R0 ;DEV NUMBER
JSR PC,CKTOCT ;PRINT DEV NUM
CK11SC CKENCL,< Not ready.>
.ASCIZ \ Not ready.\
.EVEN
11$: JSR R5,CHKBIT ;CHECK HDW BITS
LP.INE
$CKINT ,R4,<LP.INE>,<LP.DNE>
RTS PC
.ENDC ;.IF NE CK..LP
.IF NE CK..LT
.SBTTL CHECK THE LP20 HARDWARE
CKLT11: BIT #LT.ERR,(R4) ; IS THE DEVICE OK ?
BEQ 11$ ; YES
CK11SC CKEMSG,< LP20 # >
.ASCIZ \ LP20 #\
.EVEN
MOV CKDEVN,R0 ; GET DEVICE NUMBER
JSR PC,CKTOCT ; OUTPUT IT
CK11SC CKENCL,< Not ready.>
.ASCIZ \ Not ready.\
.EVEN
11$: RTS PC
.ENDC
.IF NE CK..PP
.SBTTL CHECK PP11 HARDWARE
;
; JSR PC,CKPP11
;
CKPP11: JSR R5,CHKBIT
PP.INE
$CKINT ,R4,<PP.INE>,<PP.RDY>
RTS PC
.ENDC ;.IF NE CK..PP
.IF NE CK..PR
.SBTTL CHECK PR11 HARDWARE
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKPR11
;
CKPR11:
JSR R5,CHKBIT ;CHECK HARDWARE BITS
PR.INE
CLR R0 ;FOR TIME OUT
BIS #PR..RE!PR.INE,(R4) ;TELL READER TO DO SOMETHING
; TO FORCE ANY INTERRUPT COND
11$: BIT #PR.DNE!PR.ERR,(R4) ;SEE IF AN INT CONDITION IS THERE
BNE 12$ ;IF NOT, THEN WAIT FOR ONE.
SOB R0,11$ ;TIME OUT TO CATCH NO RESPONSE
CK11SC <CKEDID!CKEPC>,<Timed Out>,<NO RESPONSE>
.ASCIZ \Timed Out\
.EVEN
BIC #PR.INE,(R4) ;DISABLE INT ENABLE
RTS PC ;EXIT
12$: JSR R5,CHKINL ;FIND INT LEVEL
-1 ;FOR TIME-OUT
BIC #PR.INE,(R4) ;DISABLE INTS
RTS PC
.ENDC ;.IF NE CK..PR
.IF NE CK..RH
.SBTTL CHECK RH11 HARDWARE
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKRH11
;
CKRH11:;BIS #1,CHKRP+4+0 ;GROSS KLUDGE TO PREVENT CHKDEV FROM
RTS PC ; FINDING WHAT LOOKS LIKE AN RP.
; (THE DEVICE REGISTERS OVERLAP)
.ENDC ;.IF NE CK..RH
.IF NE CK..TC
.SBTTL CHECK TC11 HARDWARE
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKTC11
;
CKTC11:
JSR R5,CHKBIT ;TEST FOLLOWING BITS
TC.D17!TC.D16
TST (R1)+ ;ADVANCE TO COMMAND REGISTER
JSR R5,CHKBIT ;TEST FOLLOWING BITS
TC..MM!TC..DI!TC.REV!TC.US7!TC.INE!TC.A17!TC.A16
TST (R1)+ ;ADVANCE TO WORD COUNT REG
JSR R5,CHKBIT ;TEST FOLLOWING BITS
-1
TST (R1)+ ;ADVANCE TO BUS ADDR REG
JSR R5,CHKBIT ;TEST THE FOLLOWING BITS
-1
TST (R1)+ ;ADVANCE TO DATA REGISTER
JSR R5,CHKBIT ;CHECK FOLLOWING BITS
-1
MOV R4,R1 ;SET UP ADR FOR INT CHK
TST (R1)+ ;ADVANCE TO COMMAND REG
MOV R1,R2 ;SET UP FOR INT CHK
$CKINT ,,<TC.INE>,<TC.RDY>
RTS PC
.ENDC ;.IF NE CK..TC
.IF NE CK..TM
.SBTTL CHECK TM11 HARDWARE
;CALL MOV #<VECTOR ADR>,R3
; MOV #<HDW ADR>,R4
; MOV #<HDW ADR>,R1
; JSR PC,CKTM11
;
CKTM11: RTS PC
.ENDC ;.IF NE CK..TM
;HERE ON A UNEXPECTED BUS TRAP
;
CKBUST: CK11SC <CKEDID!CKEPC>,<Trap from>
.ASCIZ \Trap from\
.EVEN
MOV (SP),R0 ;GET PC OF NEXT INST
SUB #2,R0 ;MAKE PC WITHIN BAD INST
JSR PC,CKTBOC ;PRINT THE PC WHERE WE WERE DID IN
CK11SC <CKENCL!CKEFAT>,< to Adr 4>,<ILLEGAL BUS TRAP>,<S..NXM>
.ASCIZ \ to Adr 4\
.EVEN
.SBTTL CK11SC ROUTINE
;HERE ON ERROR IN CHK60
;
;AT HALT TIME R0 CONTAINS ADDRESS OF TRAP
;
CHKERR: ;here on error trap
MOV NXMVEC,-(SP) ;save NXM vector [3(47)]
MOV #2$,NXMVEC ;where to go if MM doesn't exist [3(47)]
BIC #CHKMMO,CHKFLG ;clear indicator [3(47)]
BIT #1,MM.SR0 ;see if memory management on [3(47)]
BEQ 3$ ;skip if not [3(47)]
BIS #CHKMMO,CHKFLG ;remember it [3(47)]
3$: CLR MM.SR0 ;turn it off [3(47)]
BR 4$ ;continue [3(47)]
2$: ADD #4,SP ;adjust stack [3(47)]
4$: MOV (SP)+,NXMVEC ;restore previous state [3(47)]
MOV R0,-(SP)
MOV 2(SP),-(SP) ;GET ADDRESS OF
SUB #2,(SP) ; THE TRAP INSTRUCTION.
BIT #CKEDID,@(SP) ;PRINT DEVICE ID+REG MSG
BEQ 11$ ;BRANCH IF NOT
BIS #CKFERR,CHKFLG ;REMEMBER WE HAD AN ERROR
JSR PC,CKDIDT ;
11$: BIT #CKEPC,@(SP) ;TYPE PC MESSAGE?
BEQ 12$ ;NO, SEE IF SOMETHING ELSE
CK11SC 0,< Error detected at PC> ;
.ASCIZ \ Error detected at PC\
.EVEN
BIS #CKFERR,CHKFLG ;REMEMBER WE HAD AN ERROR
MOV (SP),R0 ;GET ADDRESS
JSR PC,CKTBOC ;PRINT SPACE AND ADDRESS
12$: BIT #CKEMSG,@(SP) ;PRINT INLINE ERROR MESSAGE
BEQ 15$ ;BRANCH IF NO
BIT #CKENCL,@(SP) ;SEE IF NO CRLF
BNE 13$ ;BRANCH IF NO CRLF
JSR PC,CKCRLF ;CR+LF
13$: BIT #CKEDID!CKEGB,@(SP) ;IF DEV ID OR GD BD GIVE SPACES FOR FORMAT
BEQ 14$ ;
CK11SC CKENCL,< >
.ASCIZ \ \
.EVEN
14$: MOV 4(SP),R0 ;GET ADDRESS OF MESSAGE
JSR PC,CKTTXT ;RETURN R0 POINTS TO LOC
; FOLLOWING MESSAGE
MOV R0,4(SP) ;PUT RETURN PC ON STACK
15$: BIT #CKEMSE,@(SP) ;PRINT MSG AT END
BEQ 18$ ;BRANCH IF NOT
BIT #CKENCL,@(SP) ;SEE IF NO CRLF
BNE 16$ ;BRANCH IF NO CRLF
JSR PC,CKCRLF ;CR+LF
16$: BIT #CKEDID!CKEGB,@(SP) ;SEE IF CKEDID OR CKEGB SET, IF SO GIVE SPACES FOR FORMAT
BEQ 17$ ;BRANCH IF JUST TEXT
CK11SC CKENCL,< > ;2 TAB
.ASCIZ \ \
.EVEN
17$: MOV @4(SP),R0 ;GET ADDRESS OF THE MESSAGE
JSR PC,CKTTXT ;PRINT THE MESSAGE
ADD #2,4(SP) ;MAKE RETURN PC
18$: BIT #CKEGB,@(SP) ;SEE IF GOOD BAD PRINT OUT
BEQ CHKER0 ;BRANCH IF NOT THIS
CK11SC 0,< Adr/Reg =>
.ASCIZ \ Adr/Reg =\
.EVEN
MOV 10(SP),R0 ;GET ADR OFF THE STACK
BIT #CKADPH,@(P) ;see if virtual [3(47)]
BEQ 20$ ;no, do it normally [3(47)]
BIT #CHKMMO,CHKFLG ;was memory management on? [3(47)]
BEQ 20$ ;no, old style address [3(47)]
ROL R0 ;shift [3(47)]
ROL R0 ; high order [3(47)]
ROL R0 ; three bits [3(47)]
ROL R0 ; to test [3(47)]
BIC #177770,R0 ;which register [3(47)]
ASL R0 ;word index [3(47)]
ADD #KPAR0,R0 ;right PAR [3(47)]
MOV @R0,-(SP) ;get physical block [3(47)]
MOV 12(SP),R0 ;get address back [3(47)]
BIC #160000,R0 ;make displacement in block [3(47)]
CLR CHKX ;clear extended digit [3(47)]
CLC ;clear carry [3(47)]
ROL (SP) ;shift bits off end [3(47)]
ROL (SP)
ROL (SP)
ROL (SP)
ADC CHKX ;save high order unibus address bit [3(47)]
ROL CHKX ;make room for next bit [3(47)]
ROL (SP) ;get next extra bit [3(47)]
ADC CHKX ;save it as well [3(47)]
ADD R0,(SP) ;make real address (low 16 bits) [3(47)]
CLC ;clean out carry [3(47)]
ROL CHKX ;make room for next bit [3(47)]
ROL (SP) ;get sign bit [3(47)]
ADC CHKX ;put into extension [3(47)]
ROR (SP) ;clear sign bit [3(47)]
MOV CHKX,R0 ;get uppermost octal digit [3(47)]
JSR PC,CKTBOC ;print it [3(47)]
MOV (SP)+,R0 ;get rest [3(47)]
JSR PC,CKTOCT ;print it too [3(47)]
BR 25$ ;continue [3(47)]
20$: ; [3(47)]
JSR PC,CKTBOC ;PRINT ADR
25$: ;%
CK11SC <CKENCL>,< GD =>
.ASCIZ \ GD =\
.EVEN
MOV 14(SP),R0 ;GET "GOOD"
JSR PC,CKTBOC ;PRINT IT
CK11SC <CKENCL>,< BD =>
.ASCIZ \ BD =\
.EVEN
MOV 12(SP),R0 ;PRINT BAD STUFF
JSR PC,CKTBOC ;PRINT BAD
CK11SC CKENCL,< XOR =>
.ASCIZ \ XOR =\
.EVEN
MOV 14(SP),-(SP) ;GET GOOD
XOR R0,(SP) ;LEAVE ONLY QUESTIONABLE BITS
MOV (SP)+,R0 ;PRINT THEM
JSR PC,CKTBOC ;
CHKER0: BIT #CKEFAT,@(SP) ;FATAL ERROR - HALT REQUIRED?
BEQ CHKER2 ;BRANCH IN NOT FATAL
BIS #CKFERR,CHKFLG ;REMEMBER WE HAD AN ERROR
CK11SC 0,< Fatal Error>
.ASCIZ \ Fatal Error\
.EVEN
MOV CKSPCD,R0 ;PUT STOPCODE IN R0, IF 0 ITS NOT A STOPCODE TO BE DISPLAYED
BEQ CHKER3 ;IF 0
HALT ;STOP CODE IN R0, PRESS CONTINUE
; GIVES ADR WE CAME FROM
CHKER3: MOV (SP)+,R0 ;ADDRESS OF TRAP IN R0
HALT ;FATAL ERROR - R0 CONTAINS ERROR ADDRESS
JMP BEGIN ;IF CONTINUE DO PROGRAM AGAIN.
CHKER2: BIT #CKEGB,@(SP)+ ;SEE IF THERE WAS A GD-BD PRINT
BNE CHKER1 ;IF YES, CLEAR STACK
MOV (SP)+,R0
BR CHKER9 ;go exit [3(47)]
CHKER1: MOV (SP)+,R0
MOV (SP)+,4(SP) ;PC
MOV (SP)+,4(SP) ;PS
TST (SP)+ ;CLEAN THE STACK
CHKER9: ;here to exit CHKERR [3(47)]
BIT #CHKMMO,CHKFLG ;was memory management on? [3(47)]
BEQ 10$ ;no, skip [3(47)]
INC MM.SR0 ;yes, turn it back on [3(47)]
10$: ;dismiss trap [3(47)]
RTI ;return
CHKX: .WORD 0 ;extension for address [3(47)]
CKSPCD: .WORD 0 ;CONTAINS STOPCODE ON FATAL ERROR
CKDA= 0 ;DEVICE ADDRESS OFFSET
CKDV= 2 ;DEVICE VECTOR OFFSET
CKPI= 4 ;DEVICE PI LEVEL OFFSET
CKFLG= 6 ;DEVICE FLAGS OFFSET
CKSPC= 10 ;SPECIAL CHAR OFFSET
CHKCHR: .BLKW 1 ;DEVICE ADDRESS
.BLKW 1 ;DEVICE VECTOR
.BLKW 1 ;DEVICE PI LEVEL
.BLKW 1 ;DEVICE FLAGS
; B0-B5 = # OF DQ11 SPECIAL CHAR
; B15 = INTERRUPTED ON SYNC
.BLKW 4 ;SPECIAL CHARACTERS
CKVECT KL,1,1 ;DL11-A VECTOR SETUP
CKVECT CR,1,1 ;CR11 VECTOR SETUP
CKVECT DH,2,<^D16> ;DH11 VECTOR SETUP
CKVECT DL,2,<^D16> ;DL11-E VECTOR SETUP
CKVECT DM,1,<^D16> ;DM11-BB VECTOR SETUP
CKVECT DN,1,<^D64> ;DN11 VECTOR SETUP
CKVECT DP,2,<^D32> ;DP11 VECTOR SETUP
CKVECT DQ,2,<^D16> ;DQ11 VECTOR SETUP
CKVECT DS,4,<^D16> ;DS11 VECTOR SETUP
CKVECT TE,1,1 ;DTE20 VECTOR SETUP
CKVECT LT,1,2 ;LP20 VECTOR SETUP
CKVECT LP,1,2 ;LP11 VECTOR SETUP
CKVECT PP,1,1 ;PP11 VECTOR SETUP
CKVECT PR,1,1 ;PR11 VECTOR SETUP
CKVECT P6,1,<^D16> ;PA611-P VECTOR SETUP
CKVECT R6,1,<^D16> ;PA611-R VECTOR SETUP
CKVECT TC,1,1 ;TC11 VECTOR SETUP
CKVECT TM,1,1 ;TM11 VECTOR SETUP
CKVECT RC,1,1 ;RC11 VECTOR SETUP
CKVECT RF,1,1 ;RF11 VECTOR SETUP
CKVECT RH,1,1 ;RH11 (RJP04) VECTOR SETUP
CKVECT RP,1,1 ;RP11-C VECTOR SETUP
CKVECT TA,1,1 ;TA11 VECTOR SETUP
CKVECT RK,1,1 ;RK11 VECTOR SETUP
CKVECT KP,1,1 ;KW11-P VECTOR SETUP
CKVECT DJ,2,<^D16> ;DJ11 vector setup [1(14)]
CKVECT UP,2,<^D16> ;DUP11 vector setup [1(14)]
CKVECT MC,2,<^D16> ;DMC11 vector setup [1(14)]
CKVECT MD,2,3 ;KMC11 VECTOR SETUP [1(33)]
CKVECT MH,2,3 ;KMC11 FOR DUP [3(50)]
CKVECT ME,2,3 ;KMC11 FOR DZ [3(50)]
CKVECT LK,2,1 ;LK11-A vector setup [1(14)]
CKVECT DZ,2,<^D8> ;DZ11 vector setup [1(14)]
CKVECT DU,2,<^D16> ;DU11 vector setup [1(14)]
CKMG01: .ASCIZ \Mem Err\
CKMG02: .ASCIZ \Bit did not Clear\
CKMG03: .ASCIZ \Bit did not set\
CKMG04: .ASCIZ \Interrupt did not Occur\
CKMG05: .ASCIZ \Interrupted to Wrong Vector\
CKMG06: .ASCIZ \not found\
CKMG07: .ASCIZ \interrupted when not enabled\
.EVEN
CKBLK=CKINTS ;REMOVE THIS AREA AS A BUFFER FOR THE DH11 TEST
CKDZTR=CKBLK ;address of receive expected character table for DZ11
CKDZTX=CKDZTR+20 ;address of next char to transmit
CKDZTE=CKDZTX+20 ;address of error table
; PRINT SIZE OF PROGRAM.
CHKEND= .-2 ;EQUALS LAST ADDRESS
.IF DF,CHKFFA
CHKSIZ=<CHKFFA-2+3777>
.IF LT CHKSIZ
CHKSIZ=<<CHKSIZ&77777>/4000>+20
.IFF
CHKSIZ=CHKSIZ/4000
.ENDC
.PRINT CHKSIZ ;Size of program in octal K words.
.ENDC
CHKFFA: ;FIRST FREE ADDRESS
.LIST ME
;DEVEQ MD,ME
DEVEQ MD,MH
.END BEGIN