.TITLE	XDTLOA - LOAD XDT
	.SBTTL	XDTLOA - TITLE PAGE
	.IDENT	/V01.01/
;
; ************************************************************************
;                                                                        *
; THIS PROGRAM IS PROVIDED ON AN "AS IS" BASIS ONLY.  DIGITAL  EQUIPMENT *
; COMPUTER USER'S SOCIETY,  DIGITAL EQUIPMENT CORPORATION, MONSANTO, AND *
; THE AUTHOR DISCLAIM  ALL WARRANTIES ON THE PROGRAM,  INCLUDING WITHOUT *
; LIMITATION, ALL IMPLIED WARRANTIES OF MERCHANTABLITY AND FITNESS.      *
;									 *
; FULL PERMISSION AND CONSENT IS HEREBY GIVEN TO DECUS  AND TO THE DECUS *
; SPECIAL INTEREST  GROUPS  TO  REPRODUCE,  DISTRIBUTE,  AND PUBLISH AND *
; PERMIT  OTHERS  TO  REPRODUCE  IN  WHOLE  OR  IN PART, IN ANY FORM AND *
; WITHOUT RESTRICTION, THIS PROGRAM AND ANY INFORMATION RELATING TO IT.  *
;									 *
; ************************************************************************
;
; THIS ROUTINE LOADS XDT.
;
; VERSION:	01.01
;
; AUTHOR:	R.W. STAMERJOHN	  MAPC	10-MAR-80
;
; MODIFICATION HISTORY:
;
;	V01.00	RWS	10-MAR-80	INITIAL VERSION
;
;	V01.01	RWS	28-OCT-80	REMOVE GETVAL, PUTVAL REFERENCES

	.SBTTL	XDTLOA - DECLARATIONS
	.DSABL	GBL
;
; MACRO LIBRARY CALLS:
;
;	SYMBOLICS DEFINITIONS (EXEMC.MLB).
;
	.MCALL	HWDDF$			;DEFINE HWD OFFSETS
	HWDDF$
	.MCALL	PCBDF$			;DEFINE PCB OFFSETS
	PCBDF$
;
;	OTHER MACROS (RSXMAC.SML).
;
	.MCALL	CALL,CALLR,RETURN	;SUBROUTINE MACROS
;
; GLOBAL DECLARATIONS:
;
	.GLOBL	XDTLOA			;ROUTINE ENTRY
;
; GLOBAL REFERENCES:
;
;	XDT CODE REFERENCES.
;
	.GLOBL	EXEXIT			;XDT DISPATCH TABLE
	.GLOBL	SSTADR			;XDT VECTORE ADDRESSES
	.GLOBL	SSTVEC			;XDT EXTERNAL VECTOR TABLE
	.GLOBL	SSTXDT			;XDT INTERNAL VECTOR TABLE
	.GLOBL	XDTBEG			;START OF XDT TEMPLATE
	.GLOBL	XDTCSR			;XDT TERMINAL CSR BLOCK
	.GLOBL	XDTSIZ			;SIZE OF XDT PARTITION CODE
;
;	XDT POOL REFERENCES.
;
	.GLOBL	SYSBEG			;START OF TEMPLATE
	.GLOBL	SYSSIZ			;SIZE  OF TEMPLATE
	.GLOBL	STKADR			;TEMPORARY STACK ADDRESS
	.GLOBL	XDTAPR			;XDT APR WORD

	.GLOBL	TRP004			;TRAP 04 ADDRESS
	.GLOBL	TRP010			;TRAP 10 ADDRESS
	.GLOBL	TRP014			;TRAP 14 ADDRESS
	.GLOBL	TRP020			;TRAP 20 ADDRESS
	.GLOBL	TRP030			;TRAP 30 ADDRESS
	.GLOBL	TRP250			;TRAP 250 ADDRESS
	.GLOBL	TRPDCD			;XDT DCD TRAP
	.GLOBL	TRPERR			;XDT ERR TRAP
	.GLOBL	TRPTYP			;XDT TYP TRAP

	.GLOBL	CRSRTN			;XDT CRASH RETURN
	.GLOBL	EXERTN			;XDT EXECUTIVE RETURN
	.GLOBL	RTNRTN			;XDT NORMAL RETURN
;
;	RSX11M SUBROUTINES.
;
	.GLOBL	$ALOCB			;(CORAL) ALLOCATE CORE BLOCK
	.GLOBL	$BLXIO			;(BFCTL) BLOCK COPY
	.GLOBL	$DEACB			;(CORAL) DEALLOCATE CORE BLOCK
	.GLOBL	$RELOC			;(IOSUB) RELOCATE ADDRESS
	.GLOBL	$TRACE			;(SSTSR) TRACE TRAP ROUTINE
;
;	RSX11M VARIABLES.
;
	.GLOBL	$PARHD			;PCB LISTHEADER

	.SBTTL	XDTLOA - MACRO DEFINITIONS
;
; DEFINE SYSTEM STATE MACRO.
;
	.MACRO	SYSTEM	ADDR

	EMT	376
	.WORD	ADDR
S.R0	= 2
S.R1	= 4
S.R2	= 6
S.R3	= 10

	.ENDM	SYSTEM
;
; DEFINE FATAL ERROR MACRO.
;
	.MACRO	FATAL	MSG

	TRAP	1
	.ASCIZ	#MSG#
	.EVEN

	.ENDM	FATAL

	.SBTTL	XDTLOA - LOCAL DATA
;
; LOCAL DATA:
;
;	WORKING VARIABLES.
;
SYSADR:	.WORD	0			;SYSTEM POOL ADDRESS
;
;	MAPPING TABLES. ORDER MUST MATCH XDT INTERNAL ORDER.
;

MAPTB1:	.WORD	SSTVEC			;MAP XDT'S VECTOR TABLE
	.WORD	6			;MAP 6 ENTRIES
	.WORD	TRP004			;
	.WORD	TRP250			;
	.WORD	TRP014			;
	.WORD	TRP020			;
	.WORD	TRP010			;
	.WORD	TRP030			;

MAPTB2:	.WORD	SSTXDT			;MAP XDT'S VECTOR TABLE
	.WORD	7			;MAP 7 ENTRIES
	.WORD	TRPERR			;
	.WORD	TRPERR			;
	.WORD	TRPERR			;
	.WORD	TRPDCD			;
	.WORD	TRPERR			;
	.WORD	TRPERR			;
	.WORD	TRPTYP			;

MAPTB3:	.WORD	EXEXIT			;MAP XDT'S MAPPING TABLE
	.WORD	3			;MAP 5 ENTRIES
	.WORD	EXERTN			;
	.WORD	RTNRTN			;
	.WORD	CRSRTN			;

	.SBTTL	XDTLOA * LOAD XDT
;
;+
; LOAD XDT. CHECK PARAMATERS, GET PARTITION, AND LOAD XDT CODE.
;
; INPUT:
;
;	R4 = ADDRESS OF RAD50 PARTITION NAME
;	R5 = TERMINAL CSR ADDRESS
;
; OUTPUT:
;
;	XDT LOADED.
;
;-
;
XDTLOA::					;REF. LABEL
	CMP	@#14,#$TRACE		;IS XDT ALREADY LOADED?
	BEQ	1000$			; IF EQ - NO, CONTINUE
	FATAL	<XDT ALREADY LOADED>	;DECLARE FATAL ERROR
;
; STORE CSR FOR XDT TO USE.
;
1000$:	MOV	#XDTCSR,R0		;GET CSR BLOCK STORAGE

	.REPT	4

	MOV	R5,(R0)+		;STORE CSR VALUE
	TST	(R5)+			;BUMP TO NEXT REGISTER

	.ENDR
;
; GET SYSTEM POOL BUFFER.
;
2000$:	CLR	R0			;PRESET POOL FAILURE
	SYSTEM	2200$			;;ENTER SYSTEM STATE
	MOV	#SYSSIZ,R1		;;GET SIZE OF POOL BUFFER
	CALL	$ALOCB			;;ALLOCATE SYSTEM BUFFER
	BCS	2100$			;; IF CS - ALLOCATION FAILED
	MOV	R0,S.R0(SP)		;;RETURN BUFFER ADDRESS
2100$:	RETURN				;;RETURN TO TASK STATE
2200$:	MOV	R0,SYSADR		;STORE POOL ADDRESS
	BNE	3000$			; IF NE - ALLOCATION SUCCESSFUL
	FATAL	<POOL ALLOCATION FAILED>;DECLARE DATA ERROR
;
; COPY SYSTEM TEMPLATE TO POOL AND MAP XDT TO IT.
;
3000$:	MOV	#SYSBEG,R1		;GET START OF TEMPLATE
	MOV	#SYSSIZ,R2		;GET SIZE OF TEMPLATE
	ASR	R2			; IN WORDS
3100$:	MOV	(R1)+,(R0)+		;COPY TEMPLATE
	SOB	R2,3100$		; AND LOOP TILL DONE
	MOV	R4,-(SP)		;SAVE PARTITION NAME
	MOV	SYSADR,R5		;GET POOL ADDRESS
	MOV	#SYSBEG,R4		;GET TEMPLATE ADDRESS
	MOV	#MAPTB1,R3		;GET MAPPING TABLE
	CALL	SYSMAP			;MAP SST EXTERNAL VECTORS
	MOV	#MAPTB2,R3		;GET MAPPING TABLE
	CALL	SYSMAP			;MAP SST INTERNAL VECTORS
	MOV	#MAPTB3,R3		;GET MAPPING TABLE
	CALL	SYSMAP			;MAP SST INTERFACE CODE
	MOV	(SP)+,R4		;RESTORE PARTITON NAME
;
; COMPUTER SIZE OF XDT AND STORE IN SYSTEM POOL.
;
	MOV	#XDTSIZ/100,R0		;GET SIZE OF XDT IN 32W
	INC	R0			;BUMP BY ONE ALWAYS
	MOV	R0,P.BLKS(R5)		;SET AS XDT PARTITION SIZE
;
; SEARCH FOR PARTITION AND SETUP XDT PCB.
;
	SYSTEM	4500$			;;ENTER SYSTEM STATE
	MOV	#1,S.R0(SP)		;;PRESET NO PARTITION ERROR
	MOV	#$PARHD,R0		;;GET PARTITION LISTHEAD
4000$:	MOV	(R0),R0			;;GET NEXT PARTITION
	BEQ	4400$			;; IF EQ - NO PARTITION
	CMP	P.NAM+0(R0),(R4)	;;DO NAMES MATCH?
	BNE	4000$			;; IF NE - NO, LOOP
	CMP	P.NAM+2(R0),2(R4)	;;DO NAMES MATCH?
	BNE	4000$			;; IF NE - NO, LOOP
;
; CHECK FOR ILLEGAL COMMON PARTITION.
;
	INC	S.R0(SP)		;;PRESET COMMON PARTITION ERROR
	BIT	#PS.COM,P.STAT(R0)	;;IS PARTITION COMMON?
	BNE	4400$			;; IF NE - YES, ERROR
;
; PROCESS A TASK PARTITION.
;
	INC	S.R0(SP)		;;PRESET PARTITION BUSY ERROR
	BIT	#PS.SYS,P.STAT(R0)	;;IS PARTITION SYSTEM?
	BNE	4100$			;; IF EQ - YES, CONTINUE
	TSTB	P.BUSY+1(R0)		;;IS PARTITION BUSY?
	BNE	4400$			;; IF NE - YES, ERROR
	MOV	P.MAIN(R0),R1		;;GET MAIN PARTITION
	TSTB	P.BUSY+1(R1)		;;IS MAIN PARTITION BUSY?
	BNE	4400$			;; IF NE - YES, ERROR
	INC	S.R0(SP)		;;PRESET NO ROOM
	CMP	P.BLKS(R0),P.BLKS(R5)	;;IS PARTITION LARGE ENOUGH?
	BLO	4400$			;; IF LO - NO, ERROR
	BISB	P.BUSY+0(R0),P.BUSY+1(R0) ;;MARK PARTITION BUSY
	BISB	P.BUSY+0(R0),P.BUSY+1(R1) ;;MARK PARTITION BUSY
	MOV	P.REL(R0),P.REL(R5)	;;COPY PARTITION BASE
	MOV	P.STAT(R0),P.STAT(R5)	;;COPY PARTITION FLAGS
	BIS	#PS.CHK,P.STAT(R0)	;;MARK PARTITION NOT CHECKPOINTABLE
	MOV	R0,P.MAIN(R5)		;;COPY REAL PARTITION PCB ADDRESS
	CLR	S.R0(SP)		;;MARK NO ERROR
	RETURN				;;RETURN TO CALLER
;
; PROCESS A SYSTEM PARTITION.
;
;	R0 = ADDRESS OF PREVIOUS PCB
;	R1 = ADDRESS OF NEXT PCB
;	R2 = ADDRESS OF START OF HOLE
;	R3 = SCRATCH
;	R4 = ADDRESS OF MAIN PCB
;	R5 = ADDRESS OF NEW PCB
;
4100$:	INC	S.R0(SP)		;;PRESET NO ROOM
	MOV	R0,R4			;;COPY MAIN PCB ADDRESS
	MOV	P.REL(R4),R2		;;SET STARTING HOLE ADDRESS
	CLR	-(SP)			;;CLEAR PREVIOUS PCB ADDRESS
4200$:	MOV	P.SUB(R0),R1		;;GET ADDRESS OF NEXT SUB-PCB
	BEQ	4300$			;; IF EQ - NO MORE
	MOV	P.REL(R1),R3		;;GET SIZE OF HOLE
	SUB	R2,R3			;; FROM NEW TO LAST
	CMP	R3,P.BLKS(R5)		;;IS HOLE LARGE ENOUGH?
	BLO	4210$			;; IF LO - NO, SKIP
	MOV	R0,(SP)			;;SHOW A HOLE WAS FOUND
	MOV	R1,P.SUB(R5)		;;LINK NEW PCB TO NEXT
	MOV	P.REL(R1),P.REL(R5)	;;MAKE BASE OF NEW PCB
	SUB	P.BLKS(R5),P.REL(R5)	;; AS HIGH AS POSSIBLE
4210$:	MOV	R1,R0			;;SET PREVIOUS AS PAST
	MOV	P.REL(R1),R2		;;GET END OF PREVIOUS
	ADD	P.BLKS(R1),R2		;; FOR NEW CALCULATION
	BR	4200$			;; AND LOOP
4300$:	MOV	P.REL(R4),R3		;;CALCULATE SIZE OF
	ADD	P.BLKS(R4),R3		;; LAST HOLE IN THE
	SUB	R2,R3			;; PARTITION
	CMP	R3,P.BLKS(R5)		;;IS HOLE LARGE ENOUGH?
	BLO	4310$			;; IF LO - NO
	MOV	P.REL(R4),P.REL(R5)	;;GET BASE OF NEW PARTITION
	ADD	P.BLKS(R4),P.REL(R5)	;; AS HIGH AS POSSIBLE IN THE
	SUB	P.BLKS(R5),P.REL(R5)	;; IN THE LAST HOLE
	CLR	P.SUB(R5)		;;MARK NO LINK TO PAST
	MOV	R0,(SP)			;;SET LAST PCB FOUND
4310$:	MOV	(SP)+,R0		;;GET ADDRESS OF LAST PCB
	BEQ	4400$			;; IF EQ - NONE, ERROR
	MOV	R4,P.MAIN(R5)		;;LINK IN MAIN PCB
	MOV	R5,P.SUB(R0)		;;LINK NEW PCB TO LAST
	CLR	S.R0(SP)		;;MARK NO ERROR
4400$:	RETURN				;;RETURN TO TASK STATE
;
; PROCESS ANY PARTITION ERRORS
;
4500$:	MOV	R0,R4			;WAS AN ERROR DECLARED
	BEQ	5000$			; IF EQ - NO, CONTINUE
	SYSTEM	4510$			;;ENTER SYSTEM STATE
	MOV	SYSADR,R0		;;GET ADDRESS OF SYSTEM BUFFER
	MOV	#SYSSIZ,R1		;;GET SIZE OF SYSTEM BUFFER
	CALLR	$DEACB			;;RETURN BUFFER TO POOL
4510$:	DEC	R4			;IS ERROR #1
	BNE	4520$			; IF NE - NO
	FATAL	<PARTITION NOT PRESENT>	;DECLARE FATAL ERROR
4520$:	DEC	R4			;IS ERROR #2
	BNE	4530$			; IF NE - NO
	FATAL	<COMMON PARTITION SPECIFIED> ;DECLARE FATAL ERROR
4530$:	DEC	R4			;IS ERROR #3
	BNE	4540$			; IF NE - NO
	FATAL	<TASK PARTITION BUSY>	;DECLARE FATAL ERROR
4540$:	FATAL	<NO ROOM IN PARTITION>	;DECLARE FATAL ERROR
;
; COMPUTE AND STORE XDT MAPPING REGISTERS.
;
5000$:	MOV	#XDTAPR,R0		;GET ADDRESS IN TEMPLATE
	SUB	#SYSBEG,R0		;SUBTRACT START OF TEMPLATE
	ADD	R5,R0			;GET ADDRESS IN POOL BUFFER
	MOV	P.REL(R5),(R0)+		;STORE PAR VALUE
	MOV	P.BLKS(R5),R1		;GET PDR VALUE
	SWAB	R1			;POSITION PDR VALUE
	BIS	#6,R1			;SET FOR RW ACCESS
	MOV	R1,(R0)			;STORE IN SYSTEM BUFFER
	MOV	#STKADR,R0		;GET ADDRESS OF STACK
	SUB	#SYSBEG,R0		;SUBTRACT OFF START OF TEMPLATE
	ADD	R5,R0			;GET ADDRESS IN POOL
	MOV	R0,(R0)			;STORE AS STACK ADDRESS
;
; COPY XDT TEMPLATE TO THE PARTITION.
;
	SYSTEM	6000$			;;ENTER TASK STATE
	MOV	#XDTBEG,R0		;;GET SOURCES ADDRESS
	CALL	$RELOC			;;RELOCATE ADDRESS
	SUB	#20000,R2		;;CONVERT TO APR5 DISPLACEMENT
	MOV	P.REL(R5),R3		;;GET DESTINATION BIAS
	MOV	#140000,R4		;;GET DISTINATION DISPLACEMENT
	MOV	#XDTSIZ,R0		;;GET SIZE OF TRANSFER
	CALLR	$BLXIO			;;TRANSFER XDT TO PARTITION
;
; TAKE A DEEP BREATH AND MAP EXECUTIVES VECTORS TO CREATED XDT.
;
6000$:	MOV	#SSTVEC,R0		;GET VECTOR TABLE
	MOV	#SSTADR,R1		;GET VECTOR ADDRESS
	MOV	#7,R2			;GET NUMBER OF VECTORS
	MTPS	#PR7			;;;DISABLE INTERRUPTS
6100$:	MOV	(R0)+,@(R1)+		;;;COPY A VECTOR
	SOB	R2,6100$		;;;LOOP TILL DONE
	MTPS	#PR0			;;;ENABLE INTERRUPTS
;
; ALL DONE, RETURN TO CALLER.
;
	RETURN				;RETURN

	.SBTTL	SYSMAP * MAP XDT POOL TO XDT
;
;+
; THIS ROUTINE MAPS THE XDT POOL TO XDT. IT RESETS THE NECESSARY ADDRESSES.
;
; INPUT:
;
;	R3 = MAPPING TABLE
;	R4 = START OF TEMPLATE
;	R5 = START OF POOL BUFFER
;
; OUTPUT:
;
;	ALL ADDRESSES IN MAPPING TABLE RECOMPUTED AND STORED IN XDT.
;
;-
SYSMAP:	MOV	(R3)+,R2		;GET SST STORAGE ADDRESS
	MOV	(R3)+,R1		;GET NUMBER OF ENTRIES
1000$:	MOV	(R3)+,R0		;GET WORD TO MAP
	SUB	R4,R0			;SUBTRACT OFF TEMPLATE
	ADD	R5,R0			;ADD IN POOL ADDRESS
	MOV	R0,(R2)+		;STORE IN XDT TEMPLATE
	SOB	R1,1000$		; LOOP TILL DONE
	RETURN				;RETURN TO CALLER

	.END