; 8K ABS LOADER FOR LSI-11 RT-11.	3-SEP-77
; LOADS .LDA FORMAT TAPES FOR RT-11 SAVE
; ALLOWS MAKING SAVE FILES OF PROGRAMS <0 - 21400>

.TITLE	RT-11 8K ABSLDR

.MCALL	.REGDEF, .EXIT, .PRINT, .TTYOUT, .TTYIN
	.REGDEF

.GLOBL	RELOC,	RESTOR,	START

.ASECT

.=22400

; RELOC SAVES MONITOR AREA THEN MOVES MEMORY DOWN
; BY 1000 BYTES.
; MOV IT DOWN FROM <1000-22400> TO <0-21400>
 
; THE TAPE MUST FIRST BE LOADED USING ABSLDR STARTING AT
; "START" OR 23500.  LOADS WITH A 1000 BYTE LOAD OFFSET.

; OPERATIONAL INSTRUCTIONS.

; LOADING A TAPE	."R ABS8KL<CR>"
;			PROGRAM FIDDLES PRIORITY AND DISABLES
;			INTERRUPT THEN HALTS AT 23432.
;			PROCEDE OR START AT 23500 TO READ TAPE.

; SAVING A FILE.	RESTART AT "RESTRT" = 23270
;			WHEN TAPE FINISHED LOADING. THIS RETURNS
;			TO MONITOR.
;			."D 40:23200<CR>" SPECIFY START ADDRESS.
;			."SAVE "<DEV:FILENAME> 1000-23776<CR>"

; RUNNING A SAVED FILE	."R FILENAME<CR>" HALTS AT 23244 WHEN
;			CORE IS RELOCATED. PROCEDE STARTS PROG
;			AT 200.

; RETURN TO RT-11	START AT "RESTOR" = 23252 TO RESTORE
; FROM RUNNING A	RT-11 PROVIDING USER DIDN'T USE MEMORY
; .SAV FILE		ABOVE 22400

OFFSET=1000	; LOAD BYTE OFFSET.
SAVBLN=600	; SAVE BUFFER LENGTH.

RELOCB:	.BLKW	SAVBLN/2

; ********************************************************
; STARTS HERE TO RUN A SAVED PROGRAM.

RELOC:	MOV	#340, -(SP)	; INHIBIT INTERRUPTS
	JSR	PC, SETPRI
	CLR	R0
	MOV	#RELOCB, R1	; SAVE BUFFER AT 22400-23200
2$:	MOV	(R0)+, (R1)+
	CMP	R0, #SAVBLN	; END OF SAVE.
	BLT	2$

; NOW MOVE CORE DOWN
	MOV	#OFFSET, R0	; SOURCE POINTER
	CLR	R1
4$:	MOV	(R0)+, (R1)+
	CMP	R0, #RELOCB
	BLT	4$
	HALT		; START MANUALLY
	JMP	@(PC)+
STRTAD:	200	; DEFAULT START ADDRESS

;**********************************************************
; RESTORE MONITOR VECTORS IF SAVED.

RESTOR:	CLR	R0
	MOV	#RELOCB, R1
2$:	MOV	(R1)+, (R0)+
	CMP	R0, #SAVBLN
	BLT	2$

;**************************************************************
; RESTART HERE TO RETURN TO RT-11

RESTRT:	MOV	#RELOCB, SP	; SET IT JUST IN CASE.
	BIS	#20000, @#44	; ENABLE RE-ENTER BIT.
	MOV	#RELOC, @#40	; SET UP START ADDR FOR CALLING
	MOV	#100, @#177560
	MOV	#100, @#177564	; RE-ENABLE INTERRUPTS
	CLR	-(SP)	; RESTORE PRIORITY
	JSR	PC, SETPRI
	.PRINT	#SAVIT
	.EXIT

SETPRI:	RTI

;************************************************************
; INITIAL START ADDRESS TO START LOADING BIN PAPER TAPE.

	NOP	; RE-ENTER ADDRESS.
START:	.PRINT	#LOADIT
	BIT	#100, @#177564	; WAIT TILL INTERRUPT DISABLED
	BNE	.-6

	MOV	#340, -(SP)	; SET PRIORITY HIGH
	JSR	PC, SETPRI
	CLR	R1	; USE TO INIT STUFF.
	MOV	R1, @#177560	; DISABLE TTI INT.
	MOV	R1, @#177564	; AND TTO.
	HALT

RESTART: MOV	#10706, L.LD1
	BR	L.LD1


.MACRO	ASCIZ	STRNG
	.ASCIZ	"STRNG"
	.ENDM

SAVIT:	ASCIZ	<TYPE 'SAVE DEV:FILE(CR)'>
LOADIT:	ASCIZ	<PUT TAPE IN READER>
	.EVEN

; PDP-11 ABSOLUTE BINARY LOADER -- V006A
;
;   INPUT FORMAT --
;	FRAME	-1   001
;		-2   000
;		-3   BYTE COUNT - LOWER ORDER
;		-4   BYTE COUNT - HIGHER ORDER
;		-5   LOAD ADDRESS - LOWER ORDER
;		-6   LOAD ADDRESS - HIGHER ORDER
;			.	DATA
;			.	  PLACED
;			.	    HERE
;		CKSM - LAST FRAME CONTAINS THE CHECKSUM
;
; IF THE BYTE COUNT IS EQUAL TO 6, THE LOAD ADDRESS
;  SPECIFIED WILL BE CONSIDERED TO BE THE DESIRED JUMP
;  ADDRESS.  IF THIS ADDRESS IS ODD, THE LOADER WILL HALT.
;
; IF THE BYTE COUNT IS > 6, DATA WILL BE LOADED INTO MEMORY.
;
;
; STORAGE REQ. = 75 WORDS.  REG. USED = R1,R2,R3,R4,R5,R6,R7.
;
; PROGRAMMING CONSIDERATIONS - CAUTIONS - TWO WORDS IMMEDIATELY
;  PRECEDING L.DEV ARE USED FOR THE LOADER SP STACK.
;
;  THIS LOADER IS SELF-RELOCATING AND WILL OPERATE ANYWHERE
;    IN MEMORY ABOVE LOCATION 400(8).
;
; OPERATING INSTRUCTIONS:
;	1.  USING THE BOOT LOADER, LOAD THE ABS LOADER TAPE.
;	2.  THE DEVICE ADDRESS USED WILL BE IN THE LAST WORD
;	    OF THE BOOT LOADER(USUALLY 37776).  IF THIS DEVICE
;	    ADDRESS IS ZERO THE ABSOLUTE LOADER WILL NOT RUN.
;	3.  PLACE THE ABSOLUTE LOADER LOAD ADDRESS IN THE SWITCH
;	    REGISTER AND PRESS LOAD ADDRESS.
;	4.  PLACE THE RELOCATION FACTOR, IF ANY, IN THE SWITCH
;	    REGISTER.
;	5.  PRESS START.
;	6.  IF THE LOADER HALTS WHEN DONE
;	    DO STEP 4 AND HIT CONTINUE TO READ ANOTHER TAPE
;
L.CKSM	=	%0		;CHECKSUM IS KEPT IN R0
L.ADR	=	%1		;LOAD ADDRESS
L.BC	=	%2		;BYTE COUNT
L.BYT	=	%3		;CONTENTS OF BYTE
R4	=	%4		;SCRATCH
L.PTR	=	%5		;READ SUBROUTINE POINTER
SP	=	%6		;STACK POINTER
PC	=	%7		;PROGRAM COUNTER
; START OF LOADER

.=RELOC+300
L.LD1:	BR	RESTAR	; SET PRIORITY.
;	MOV	PC,SP		;SET UP STACK
	CMP	-(SP),-(SP)	; TO START AT L.LD1-4
	MOV	PC,L.PTR	;GET RELOCATED
	ADD	#L.READ-.,L.PTR	; START ADDRESS OF READ ROUTINE
	CLR	L.ADR		;CLEAR THE LOAD ADDRESS
L.LD1B:	MOV	(PC)+, @SP	;PICK UP CONTENTS OF SR AND SAVE
	.WORD	OFFSET+1	; LOAD OFFSET SPECIFIER.
	ROR	@SP		;CHECK RELOCATION FACTOR
	BCS	L.LD1C		;JUMP IF SOME RELOCATION NEEDED
	CLR	@SP		;USE ADDR SPECIFIED ON TAPE
	BR	L.LD2		;GO DO LOAD
L.LD1C:	ASL	@SP		;CHECK FOR NON-ZERO
	BNE	L.LD2		;JUMP IF SWR SPECS. LOAD ADDR.
	MOV	L.ADR,@SP	;OTHERWISE CONTINE LOADING
				; FROM LAST LOAD
;
; LOOK FOR THE BEGINNING OF A BLOCK
;
L.LD2:	CLR	L.CKSM		;INITIALIZE CHECKSUM
	JSR	PC,@L.PTR	;READ A FRAME
	DECB	L.BYT		;CHECK FOR +1 (START OF A BLOCK)
	BNE	L.LD2		;LOOP UNTIL +1 IS FOUND
	JSR	PC,@L.PTR	;READ ANOTHER FRAME
;
; INPUT AND SAVE BYTE COUNT.  IF BYTE COUNT IS EQUAL TO 6
;  GO TO PROCESS JUMP.
;
	JSR	PC,L.GWRD	;GET FULL BYTE COUNT
	MOV	R4,L.BC		; SUBTRACT 4
	SUB	#4,L.BC		; TO MAKE BYTE COUNT CORRECT
	CMP	#2,L.BC		;WAS BYTE COUNT EQUAL TO 6?
	BEQ	L.JMP		;JUMP IF NO DATA
				; (E.G. - JUMP BLOCK)
	JSR	PC,L.GWRD	;GET LOAD ADDRESS
	ADD	@SP,R4		;GENERATE ACTUAL ADDRESS
	MOV	R4,L.ADR	;PUT ADDRESS IN PROPER CELL


; READ IN REMAINDER OF DATA
;  IF THE LOADER HALTS AT L.BAD, A CHECKSUM ERROR
;  HAS OCCURED.  R3 WILL CONTAIN THE EXPECTED CHECKSUM,
;  AND R0 WILL CONTAIN THE DEVIATION FROM THE EXPECTED
;  CHECKSUM.
;
L.LD3:	JSR	PC,@L.PTR	;READ A FRAME
	BGE	L.LD4		;BRANCH IF MORE DATA REMAINS
	TSTB	L.CKSM		;IF CHECKSUM IS
	BEQ	L.LD2		; CORRECT, THEN CONTINUE
L.BAD:	HALT			;CHECKSUM ERROR
	BR	L.LD2		;HIT CONTINUE TO IGNORE CHECKSUM
L.LD4:	MOVB	L.BYT,(L.ADR)+	;STORE 8 BITS AT A TIME
	BR	L.LD3		;    THEN RE-LOOP
;
; INPUT A FRAME, DECREMENT BYTE COUNT, AND ACCUMULATE CHECKSUM
;
L.READ:	MOV	L.DEV,L.BYT	;DEVICE ADDRESS TO L.BYT
	INCB	@L.BYT		;SELECT READER
L.R1:	TSTB	@L.BYT		;DONE ?
	BPL	L.R1		;NO
	MOVB	2(L.BYT),L.BYT	;GET CHARACTER
	ADD	L.BYT,L.CKSM	;ADD TO CHECKSUM
	BIC	#177400,L.BYT	;MASK OFF JUNK
	DEC	L.BC		;DECREMENT BYTE COUNT BY ONE
	RTS	PC
;
; ASSEMBLE ONE FULL WORD OF DATA
;
L.GWRD:	MOV	(SP)+,L.TMP	;SAVE RETURN IN TEMPORY
	JSR	PC,@L.PTR	;GET ONE CHARACTER
	MOV	L.BYT,R4	;SAVE R3 IN TEMPORARY
	JSR	PC,@L.PTR	;GET ANOTHER FRAME
	SWAB	L.BYT		;PLACE FRAME IN HIGHER BYTE
	BIS	L.BYT,R4	;ASSEMBLE BOTH FRAMES INTO
				; A COMPLETE WORD
	MOV	L.TMP,PC	;RETURN
;
; CHECK CORRECTNESS OF JUMP ADDRESS
;  HALT IF ADDRESS IS ODD, JUMP TO PROGRAM IF ADDRESS IS EVEN
;
L.JMP:	JSR	PC,L.GWRD	;GET POSSIBLE TRANSFER ADDRESS
	JSR	PC,@L.PTR	;GET CHECKSUM
	TSTB	L.CKSM		;IF INCORRECT
	BNE	L.BAD		;  GO TO CHECKSUM HALT ADDRESS
	ASR	R4		;GET LOW ORDER BIT
	HALT		; PLAY IT SAFE
	JMP	RESTRT
	BCC	L.JMP1		;SKIP IF ADDRESS IS EVEN
	HALT			;OTHERWISE HALT
	BR	L.LD1B		;RETURN TO START OF LOADING LOOP
L.JMP1:	ASL	R4		;RESTORE REGISTER
	ADD	@SP,R4
	JMP	@R4		;JUMP TO USER
L.TMP:	.WORD	0		;TEMPORY TO SAVE STACK SPACE

L.DEV:	177560	; DO IT HERE TO SAVE SPACE.
.=L.LD1+244

; BOOTSTRAP LOADER SET FOR LOW SPEED.

BOTLDR:	MOV	DEVICE, R1
RDLP:	MOV	(PC)+, R2	; LOAD POINTER
LODPTR:	352
	INC	(R1)		; ENABLE READER.
WAIT:	TSTB	(R1)		; READER READY WITH CHAR
	BPL	.-2		; WAIT.
	MOVB	2(R1),77400&.(R2)	; LOAD THE DATA BYTE
	INC	LODPTR
	BR	RDLP

DEVICE:	177560	; LOW SPEED RDR.

;
	.END	START

                                                                                                                                                                                                                            