.SBTTL	MININT - miscelaneous interrupts and strange functions

; this section contains the minor interrupts
;  (parity error, bus trap, illegal instruction, 
;  iot instruction, emt instruction, trace trap (bpt 
;  instruction and t-bit), clock, power fail and unknown).
;  this section also contains the code to record trace
;  information, which is driven by the trace interrupt
;  or by the trace macro.  the chunk ownership recording
;  subroutines and the kg11-a simulator have been
;  included here for lack of any
;  obviously better place to put them.

.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

; 3(001) BS	MODIFIED TO SAVE REGISTERS ON STOPCODE WITH DEBUG OFF
;
; 3(002) 06-FEB-81 RLS	modified TRCSBR to allow block traces

; 3(003) 24-Feb-81 RLS	add call to TSKTIK in CLKINT - counts task timers where
;			they should be.
;			Also calls to once/tick routines DSPDQT,DSPDLT.

; 3(004) 10-MAR-81 RLS	Remove loop detector stopcd from CLKINT - who cares?

; 3(005) 05-oct-81 rls	Move call to DSPDLS from DSPIDL to CLKINT

VMINNT=005


VEDIT=VEDIT+VMINNT

; COME HERE FOR VARIOUS TRAPS.  BUS ERROR TRAP WITH THE DL10
;  DISABLED CAUSES A SPECIAL EXIT.  ALL OTHER TRAPS ARE
;  FATAL.

; HERE ON PARITY ERROR INTERRUPT.

MP.INT:	MOV	MP.REG,MEMERR	;SAVE FOR INTERESTED PARTIES
	STOPCD	MEM		;HALT.
PARSTP:	0			;provide mnemonic trap address

; HERE ON BUS TIMEOUT.

	.ENABL	LSB
NXMINT:	MOV	(SP)+,NXMPC	;RECORD PC OF BUS TRAP
	MOV	NXMGO,-(SP)	;REPLACE WITH SPECIFIED PC
	RTI			; GO THERE, RESTORING INTERRUPTS

; NORMALLY, BUS TRAPS COME HERE.

NXMNRM:	TST	DLGONE		;DO WE ALREADY KNOW THE DL10 IS GONE?
	BEQ	11$		;NO, SPECIAL EXIT.
	STOPCD	NXM		;YES, MUST BE FATAL ERROR.
NXMGON:	0			;provide mnemonic trap address

; HERE ON BUS ERROR TRAP AND THE DL10 IS DISABLED.  DO SPECIAL
; BRANCH IF REQUESTED.

11$:	TST	NXMSP		;ANY SPECIAL EXIT SPECIFIED?
	BEQ	12$		;NO.
	MOV	#-1,DLGONE	;YES, NOTE DL10 IS NOW GONE.
	CLR	DLGNTM		;WAIT A WHILE BEFORE TRYING TO RESTART IT
	MOV	NXMSP,SP	;LOAD STACK POINTER
	CLR	NXMSP		;ONLY DO THIS ONCE
	SEC			;SET "C" AS A FLAG
	RETURN

; HERE IF NO SPECIAL EXIT SPECIFIED

12$:	STOPCD	NXM		;HALT.
NXMSTP:	0			;provide mnemonic trap address
	.DSABL	LSB

; HERE ON ILLEGAL INSTRUCTION, IOT, EMT AND RANDOM
; INTERRUPT.

ILSINT:	MOV	#ILSINT,ILSTYP	;set trap type = illegal instruction
	BR	ERRINT		;go process the trap

IOTINT:	MOV	#IOTINT,ILSTYP	;set trap type = IOT
	BR	ERRINT		;go process the trap

EMTINT:	JMP	SKED		;scheduler call

ERRINT:	MOV	(SP)+,ILSERR	;SAVE TRAP INFO
	MOV	(SP)+,ILSERR+2	;IN CASE ANYBODY IS INTERESTED
	STOPCD	ILS		;HALT.
ERRSTP:				;provide a mnemonic for ddt

; HERE ON POWER FAIL.  NO ATTEMPT IS MADE TO RECOVER, SINCE
;  IT IS PRUDENT TO RUN CHK11 AFTER A POWER FAILURE.

PWFINT:
.IIF NDF,FT2020, HALT			;POWER FAILURE.
.IIF DF,FT2020, BR	.		;DON'T HALT FOR 2020s
	.BLKW	20.
TRPSTK:	.WORD	0		;SP AT TRAP TIME GOES HERE

TRPPS:	.WORD	0		;PS AT STOPCD

TRPTRP:	MOV	SP,#0		;trap within trap processing
	MOV	R0,#0
	MOV	R1,#0
	MOV	R2,#0
	MOV	R3,#0
	MOV	R4,#0
	MOV	R5,#0
	HALT

; HERE ON TRAP INSTRUCTION.  THIS IS USED ONLY BY THE STOPCD
; MACRO.

TRPINT:	TST	TRPERR		;check if already been here
	BNE	TRPTRP		;ugh!
	MOV	(SP)+,TRPERR	;SAVE TRAP INFO
	TST	(SP)+		;we already stored condition codes
	MOV	TRPPS,TRPERR+2

	MOV	R0,STOPR0	;SAVE THE ACS
	MOV	R1,STOPR1	;FOR DEBUGGING
	MOV	R2,STOPR2
	MOV	R3,STOPR3
	MOV	R4,STOPR4
	MOV	R5,STOPR5
	MOV	(SP)+,STOPSP	;SAVE STACK POINTER, TOO.

.IF EQ,FTKG11			;IF WE HAVE A KG11-A...
	MOV	@#KG.STS,STOPKG	;SAVE KG11-A REGISTERS
	MOV	@#KG.BCC,STOPKG+2
	MOV	@#KG.DTA,STOPKG+4
.ENDC ;.IF EQ,FTKG11
	CLR	R5		;LINE NUMBER*2
11$:	MOV	LINTBL(R5),R4	;GET LINE CONTROL BLOCK
	BEQ	12$		;NONE
	TST	LB.TRP(R4)	;be paranoid
	BEQ	12$
	CALL	@LB.TRP(R4)	;store the device registers in the lcb
12$:	ADD	#2,R5		;GO TO NEXT LINE
	CMP	#NLINES*2,R5	;DONE ENOUGH?
	BNE	11$		;NO, DO ANOTHER.
.IF NE,FT.KDP
	CALL	TRAPMD		;STOP THE KMC11S [1A(731)]
.ENDC ;.IF NE,FT.KDP
	MOV	TRPERR,R0	;GET OLD PC
	SUB	#2,R0		;POINT TO TRAP INSTR
	MOVB	(R0),TRPCOD	;GET TRAP CODE
	BNE	13$		;BRANCH IF VALID CODE
.IIF NDF,FT2020, HALT			;NOT--SOMETHING VERY WRONG!
.IIF DF,FT2020, BR	.	;DON'T HALT ON A 2020

13$:	MOV	TRPCOD,R1	;FETCH STOP CODE
	CALL	DLSTCS		;STORE STOP CODE SO PDP-10 CAN SEE IT.
14$:	MOV	TRPCOD,R0	;SHOW STOP CODE IN LIGHTS (11/40)
.IF NDF,FT2020 ;IF NOT ON A 2020
	HALT			;ALL DONE.
	BR	14$		;DON'T ALLOW "CONTINUE".
.ENDC ;END IF NDF,FT2020
.IIF DF,FT2020, BR	.	;DON'T HALT ON A 2020

;general debugging stopcode - "CALL" it
;	intended for patching in via DDT11.

BUGHLT:	STOPCD	BUG
BUGSTP:	BR	BUGHLT
	.SBTTL		CLOCK INTERRUPTS - ONCE A JIFFIE FROM THE KW11-L

CLKINT:	INTSKD	NOTRACE
	CLKOFF			;turn off clock so it can't reinterrupt if at low level
	MTPS	#PR.CLK*40	;set the clock service level

	SAVE	<R0,R1,R2,R3,R4,R5>
	INC	JIFCLK		;INCREMENT JIFFIE CLOCK
	BIT	#77,JIFCLK	;HAVE A MULT. OF 64 JIFFIES PAST?
	BNE	10$		;NO.
	CLR	BSYSEC		;yes - reset previous second counters
	CLR	IDLSEC
	BIT	#7777,JIFCLK	;check 4096 jiffies
	BNE	10$
	CLR	BSYMIN		;yes - reset 1 minute counters
	CLR	IDLMIN

10$:	TST	DSPTCB		;sample busy/idleness
	BNE	11$		;currently busy
	INC	IDLMIN		;currently idle
	INC	IDLSEC
	BR	12$

11$:	INC	BSYMIN
	INC	BSYSEC

12$:	CALL	DSPDQT		;DO ONCE-A-TICK DQ11(line driver) CODE
	CALL	DSPDLT		;DO ONCE-A-TICK DTE(10 interface device) CODE
	CALL	TSKTIK		;decrement all the task timers

	DEC	SECCLK		;count down  the second timer
	BGT	20$		;not yet
	MOV	#JIFSEC,SECCLK	;reset the timer
	CALL	DSPDLS		;do the once per second 10 interface function
20$:
	RESTOR	<R5,R4,R3,R2,R1,R0>
	CLKON			;turn the clock back on
	RTI			; AND EXIT THE INTERRUPT.

CLRALR:	SAVE	R4		;flush line alarm
	MOV	TCLCB(R5),R4	;get lcb
	CLR	LB.ALR(R4)	;clear timer - now no flags can be set
	BIC	#EBALR*400+EBALR,(R5);clear any flags that might have been set
	RESTOR	R4
	RETURN


DSPDQT:	MOV	#LINTBL,R2	;do once per tick code for all lines
	MOV	NSLINS,R1
10$:	MOV	(R2)+,R4	;get line block
	TST	LB.TIK(R4)	;be paranoid
	BEQ	20$
	SAVE	<R1,R2>
	CALL	@LB.TIK(R4)	;do it
	RESTOR	<R2,R1>
20$:	SOB	R1,10$
	RETURN
	.SBTTL		TRACE TRAP INTERRUPTS

; HERE ON TRACE INTERRUPTS, CAUSED BY BIT 4 IN THE PS.
;  RECORD THE CURRENT PC AND PS FOR DEBUGGING.

.IF NE,FTRACE
.IFT
BPTINT:	MOV	R0,-(SP)	;SAVE R0
	TST	TRCBTS		;ARE WE DOING EVENT TRACING?
	BNE	12$		;YES, DONT DO INSTRUCTION TRACING
	MOV	TRCPTR,R0	;NO, GET CURRENT POINTER
	CMP	#TRCTBE,R0	;REACHED END OF TABLE?
	BNE	11$		;NO.
	MOV	#TRCTBS,R0	;YES, SET TO BEGINNING
11$:	MOV	2(SP),(R0)+	;STORE PC IN TABLE
	MOV	4(SP),(R0)+	;STORE PS IN TABLE
	MOV	R0,TRCPTR	;STORE UPDATED POINTER

; THIS IS A GOOD PLACE TO PUT AD-HOCK DEBUGGING CODE, FOR EXAMPLE,
;  TO CHECK FOR A LOCATION BEING WIPED OUT.

12$:
.IF NE,DEBUG
	BR	14$		;NO SPECIAL CHECKS RIGHT NOW

; HERE ON FAILURE.

13$:	MOV	(SP)+,R0	;RESTORE R0
	STOPCD	DBG		;DEBUG STOP !!

; HERE ON NO FAILURE

14$:
.ENDC ;.IF NE,DEBUG
	MOV	(SP)+,R0	;RESTORE R0
	RTT			;DISMISS TRACE TRAP
.IFF
BPTINT:	STOPCD	ILS		;ILL INSTR IF NOT TRACING
.ENDC ;.IF NE,FTRACE
	.SBTTL		TRCSBR,TRCSBB - trace functions called by TRACE macro

; SUBROUTINE TO RECORD AN EVENT IN THE TRACE TABLE.  CALLED
;  BY THE "TRACE" MACRO.

.IF NE,FTRACE
	.ENABL	LSB
TRCSBR:				;entry for single variable trace
	MOV	(SP),-(SP)	;map into block form
	MOV	#1,2(SP)	;block of 1

TRCSBB:				;entry for stack block traces
				;SP/ret
				;SP+2/n = #variables to trace
				;SP+4/last arg
				;...
				;SP+4+2*n-2/1st arg
	MFPS	-(SP)		;save interrupt level
	MTPS	#BR7		;disable interrupts
	MOV	(SP)+,TRCSVP
	MOV	R0,TRCSV0	;save R0,R1
	MOV	R1,TRCSV1
	MOV	TRCPTR,R1	;get trace table pointer
	MOV	(SP),(R1)+	;trace caller
	CMP	#TRCTBE,R1	;check wrap
	BHI	4$
	MOV	#TRCTBS,R1
4$:	MOV	2(SP),R0	;calc ptr to 1st arg
	INC	R0
	INC	R0
	ASL	R0
	ADD	SP,R0		;R0 -> 1st arg + 2
	MOV	R0,TRCA1
	BR	6$
5$:	MOV	-(R0),(R1)+	;trace args
	CMP	#TRCTBE,R1	;check wrap
	BHI	6$
	MOV	#TRCTBS,R1
6$:	DEC	2(SP)		;count it
	BGE	5$
	MOV	R1,TRCPTR	;update trac ptr
	MOV	(SP)+,R0	;get ret loc
	MOV	TRCA1,SP	;flush all args from stack
	MOV	R0,-(SP)	;put ret on stack before turning on interrupts
	MOV	TRCSV0,R0	;restore registers
	MOV	TRCSV1,R1
	MTPS	TRCSVP		;allow the world to breathe again
	RETURN			;done

TRCBLK:				;entry to trace a memory block
				;SP/ret
				;ret/block adr
				;ret+2/block length
	MFPS	-(SP)		;save interrupt level
	MTPS	#BR7		;disable interrupts
	SAVE	<R0,R1,R2,R3>	;save the regs
	MOV	12(SP),R0	;get ret loc
	MOV	TRCPTR,R1	;get trace ptr
	MOV	R0,(R1)+	;trace caller
	CMP	#TRCTBE,R1	;check wrap
	BHI	15$
	MOV	#TRCTBS,R1
15$:	MOV	(R0)+,R2	;get trace block pointer
	MOV	(R0)+,R3	;get length
	MOV	R0,12(SP)	;update ret loc
20$:	MOV	(R2)+,(R1)+	;trace args
	CMP	#TRCTBE,R1	;check wrap
	BHI	25$
	MOV	#TRCTBS,R1
25$:	SOB	R3,20$
	MOV	R1,TRCPTR	;update trac ptr
	RESTOR	<R3,R2,R1,R0>	;restore the regs
	MTPS	(SP)+		;allow the world to breathe again
	RETURN			;done
	.DSABL	LSB

TRCSV0:	.WORD	0
TRCSV1:	.WORD	0
TRCA1:	.WORD	0
TRCSVP:	.WORD	0
.ENDC ;.IF NE,FTRACE
	.SBTTL		CHUNK OWNER RECORDING

.IF NE,CHOWNR

; SUBROUTINE TO RECORD THE OWNER OF A CHUNK FOR DEBUGGING
;  PURPOSES.
;
; R0 = CHUNK ADDRESS
; R1 = OWNER ID (BIT 0 = 0)

CHOWNG:	MOV	R0,-(SP)	;SAVE CHUNK ADDRESS
	CALL	CHOWNX		;COMPUTE INDEX INTO OWNER TABLE
	CMP	R0,#<CHOWNL*2>	;ROOM TO FIT IN TABLE?
	BHIS	11$		;NO, IGNORE IT.
	MOV	R1,CHOWNT(R0)	;YES, STORE IN TABLE
11$:	MOV	(SP)+,R0	;RESTORE CHUNK ADDRESS
	RETURN

; SUBROUTINE TO MARK A CHUNK FREE IN THE OWNER TABLE.
;  THE ID OF THE OWNER IS NOT OBLITERATED.
;
; R0 = CHUNK ADDRESS

CHOWNF:	MOV	R0,-(SP)	;SAVE CHUNK ADDRESS
	CALL	CHOWNX		;COMPUTE INDEX INTO CHUNK OWNER TABLE
	CMP	R0,#<CHOWNL*2>	;WILL THE TABLE HOLD THIS INDEX?
	BHIS	11$		;NO, IGNORE IT.
	BIT	#1,CHOWNT(R0)	;check if freeing a free chunk
	BEQ	10$		;ok
	STOPCD	BUG

10$:	BIS	#1,CHOWNT(R0)	;YES, FLAG CHUNK NOW FREE.
11$:	MOV	(SP)+,R0	;RESTORE CHUNK ADDRESS
	RETURN
; SUBROUTINE TO COMPUTE THE INDEX INTO THE OWNER TABLE.
;
; R0 = CHUNK ADDRESS
;
; ON RETURN: 
;
; R0 = INDEX INTO THE OWNER TABLE
;
; IF THE CHUNK ADDRESS IS INVALID, THIS SUBROUTINE NEVER RETURNS.

CHOWNX:	SAVE	<R1,R2>
	SUB	CHLOW,R0	;CONVERT CHUNK ADDRESS TO RELATIVE
	BLO	20$
	CLR	R1		;COMPARISON ADDRESS
	CLR	R2		;INDEX
11$:	CMP	R0,R1		;HAVE WE REACHED THE CHUNK?
	BLOS	12$		;YES, R2 HAS THE INDEX.
	ADD	#CHSIZE,R1	;NO, INCREASE COMPARISION ADDRESS
	ADD	#2,R2		; AND KEEP INDEX IN PARALLEL
	BR	11$		;SEE IF WE HAVE REACHED IT.

; HERE IF WE HAVE REACHED THE CHUNK ADDRESS

12$:	BLO	20$
	MOV	R2,R0		;PUT INDEX INTO R0
	RESTOR	<R2,R1>
	RETURN

20$:	STOPCD	BAF

.ENDC ;.IF NE,CHOWNR
	.SBTTL		KG11-A SIMULATION SUBROUTINE

; SUBROUTINE TO ACCUMULATE A CHARACTER INTO THE BCC.
;
; CALL:
;	MOV	ARG,-(SP)	;PUT ARG ON STACK
;	CALL	KGSIMA	;ACCUMULATE BCC
;
; ALL REGISTERS ARE PRESERVED.

.IF NE,FTKG11

KGSIMA:	MOV	R0,-(SP)	;SAVE R0
	MOV	4(SP),R0	;GET ARGUMENT CHARACTER
	MOV	R1,-(SP)	;SAVE R1
	MOV	R2,-(SP)	;SAVE R2
	MOV	KGSIMW,R1	;R1 = ACCUMULATED CRC
	XOR	R1,R0		;EXCLUSIVE OR BYTE WITH OLD CRC
	MOV	R0,R2		;SAVE A COPY OF RESULT
	BIC	#177760,R0	;EXTRACT LOW 4 BITS
	ASL	R0		;BYTE ADDRESS , WORD INDEX
	MOV	KGTBL(R0),R0	;GET FIRST MODIFIER WORD
	BIC	#177417,R2	;NOW EXTRACT HIGH FOUR BITS
	ASR	R2		;SET UP TO ENTER SECOND HALF
	ASR	R2		;AGAIN BYTE ADDRESS TO
	ASR	R2		;WORD INDEX
	MOV	KGTBL+32.(R2),R2 ;GET SECOND MODIFIER WORD
	XOR	R2,R0		;EXCLUSIVE OR MODIFIER VALUES
	CLRB	R1		;CLEAR LOW BYTE OF OLD CRC
	SWAB	R1		;NOW WORK ON UPPER BYTE
	XOR	R0,R1		;PRODUCE UPDATED CRC
	MOV	R1,KGSIMW	;SAVE NEW VALUE OF CRC REGISTER
	MOV	(SP)+,R2	;RESTORE R2
	MOV	(SP)+,R1	;RESTORE R1
	MOV	(SP)+,R0	;RESTORE R0
	MOV	(SP)+,(SP)	;REMOVE ARGUMENT FROM STACK
	RETURN
; THIS TABLE IS USED BY THE KG11-A SIMULATOR TO FORM
;  A BCC.  THE FIRST HALF OF THE TABLE IS INDEXED BY THE
;  LOW FOUR BITS, THE SECOND HALF BY THE HIGH FOUR BITS.

KGTBL:	.WORD	0		;FIRST HALF OF TABLE
	.WORD	140301
	.WORD	140601
	.WORD	500
	.WORD	141401
	.WORD	1700
	.WORD	1200
	.WORD	141101
	.WORD	143001
	.WORD	3300
	.WORD	3600
	.WORD	143501
	.WORD	2400
	.WORD	142701
	.WORD	142201
	.WORD	2100

	.WORD	0		;SECOND HALF OF TABLE
	.WORD	146001
	.WORD	154001
	.WORD	12000
	.WORD	170001
	.WORD	36000
	.WORD	24000
	.WORD	162001
	.WORD	120001
	.WORD	66000
	.WORD	74000
	.WORD	132001
	.WORD 	50000
	.WORD	116001
	.WORD	104001
	.WORD	42000

.ENDC ;.IF NE,FTKG11
; TTY ROUTINES FOR CHK11

	.CKTTS