.SBTTL	TITLE PAGE
	.TITLE	CR/CM HANDLER
	.IDENT	"V006A"
;
;
;
;
;
;
;    THE TERMS "RSX" AND "RSX-11"  IN THIS DOCUMENT
;    IMPLY "RSX-11D".
;
;
;
;           MODULE: "CR/CM-11 HANDLER TASK"
;
;           VERSION: V006A
;
;           AUTHOR: C. MONIA
;
;           DATE: 7 FEB 75
;
;
;    THIS MODULE CONTAINS:
;
;	1 -- MODULE FUNCTION DETAILS
;	2 -- INITIALIZATION ROUTINE
;	3 -- EXIT ROUTINES
;	4 -- EVENT POLLING CODE
;	5 -- PRELIMINARY PROCESSING FOR QUEUED REQUESTS
;	6 -- HANDLER UNIT IDENTIFICATION TABLE (UIT)
;	7 -- HANDLER DISPATCH TABLE
;	8 -- EXPRESS REQUEST PROCESSING
;	9 -- NORMAL REQUEST PROCESSING
;      10 -- READ REQUEST PROCESSING
;      11 -- I/O COMPLETION PROCESSING
;      12 -- TERMINATE REQUEST PROCESSING
;      13 -- HARDWARE ERROR REPORTING
;      14 -- HANDLER INTERRUPT SERVICE ROUTINE
;      15 -- POWERFAIL RECOVERY AST ROUTINE
;      16 -- DATA PARAMETER BLOCKS
;      17 -- CARD CODE CONVERSION TABLES
	.PAGE
;	MODIFICATIONS:
;
; NO.		DATE		PROGRAMMER
; ---		----		----------
;
; 001		07-SEP-73	C. MONIA
; 002		01-NOV-73	C. MONIA
; 003		07-FEB-74	M. CONNORS
; 004		01-NOV-74	S. HARDING/M. GONSALVES
; 005		7-FEB-75	K. HSU
; 006		7-APR-75	K. HSU
; 007		3-MAY-75	M. GONSALVES
; 008		22-JUL-75	M. GONSALVES
; 009		30-JUL-75	M. GONSALVES
;010		22-OCT-76	G. EVERHART
;	ADD ASCII MODE ON PUNCH OF 12-0-2-4-8 CONTROL CARD
	.PAGE
; DEFINE AND FLAG BAD ASSEMBLY PARAMETERS
	.IF DF ONLY26&ONLY29!DEFALT&ONLY26!DEFALT&ONLY29
;
	.ERROR			; INCORRECT ASSEMBLY PARAMETERS
ERR$=0			;++002 SET SWITCH FOR ERROR EXIT
;
	.ENDC

	.IIF	DF	ERR$,	.END


;
; LOCAL EQUATES:
;

;
; DEVICE REGISTERS:
;
CRB1=177162		; CARD READER DATA BUFFER #1
CRB2=177164		; CARD READER DATA BUFFER #2
CRS=177160		; CARD READER STATUS REGISTER
;
; CARD READER INTERRUPT TRAP VECTOR.
CRINV=230
;
;
; DEFINE THE DEFAULT ALPHA-NUMERIC MODE
;
	.IF DF DEFALT!ONLY26
AMODE=0		; DEFAULT ALPHANUMERIC MODE IS 026
	.ENDC
	.IF NDF	ONLY26&DEFALT
AMODE=4		;DEFAULT ALPHANUMERIC MODE IS '029'
	.ENDC


;
; HARDWARE STATUS REGISTER BITS:
;
CR.BSY=1000		; READER BUSY
CR.CDN=200		; CARD COLUMN DONE.
CR.CRD=40000		; CARD DONE
CR.EJT=2		; EJECT CARD
CR.ERR=100000		; READER ERROR
CR.NBL=100		; ENABLE READER INTERRUPTS.
CR.FLN=400		; READER OFFLINE.
CR.NLN=2000		; READER TO ONLINE.
CR.RDC=10000		; CARD READER CHECK
CR.RD=1			; READ A CARD
CR.SPR=20000		; CARD READER SUPPLY ERROR
CR.TMR=4000		; TIMING ERROR
;
;
; THE FOLLOWING COMBINATIONS OF THE ABOVE BITS ARE USEFUL
; DURING EXECUTION:
;
CR.GO=<CR.NBL!CR.RD>	; CONNECT READER TO INTERRUPTS AND READ A CARD
CR.EXC=<CR.CRD!CR.ERR!CR.NLN>/400 ; EXCEPTIONAL HARDWARE CONDITIONS.

;
; QIO SUBFUNCTION BITS:
;
; IQ.X			;  NO RETURN FUNCTION
; IQ.Q			;  QUEUE THIS REQUEST IN THE CONTROL QUEUE
; IQ.			; RESERVED
;
;
; SUBFUNCTION VALUES:
;


;
; THE FOLLOWING FLAGS DEFINE THE STATUS OF THE HANDLER AT TASK LEVEL:
;
CR.ABT=20		; HANDLER HAS BEEN INSTRUCTED TO ABORT A TRANSFER.
CR.BIN=200		; HANDLER IS READING IN BINARY MODE.
CR.MDE=4		; HANDLER IS READING IN 029/026 MODE.
CR.UND=2		; HANDLER HAS ISSUED A READ COMMAND
;
;DEFAULT  STATUS SETTINGS
;
DF.OFF=CR.ABT		; THESE BIT(S) ARE ALWAYS DEFAULTED OFF
;
; THE FOLLOWING FLAGS DEFINE THE STATUS OF THE INTERRUPT SERVICE ROUTINE:
IH.ERR=200		; SERVICE ROUTINE HAS DETECTED A HARDWARE ERROR.
IH.CRD=100		; SERVICE ROUTINE HAS DETECTED CARD DONE.
IH.NLN=4		; SERVICE ROUTINE HAS DETECTED CARD READER TO ONLINE
;

;
; INTERNAL BUFFER SIZE
;
	.IF NDF	MARKS
CRSIZE=80.
	.ENDC
;;
	.IF DF	MARKS
CRSIZE=40.
	.ENDC
;
	.IF DF	BINARY
CRSIZB=CRSIZE*3/2
	.ENDC
;
;
; SPECIAL PUNCHES
;
CREOF=007417		; 12-11-0-1-6-7-8-9 PUNCH; END OF FILE
CR026=004242		; 12-2-4-8 PUNCH; READ IN 026 MODE
CR029=005252		; 12-0-2-4-6-8 PUNCH; READ IN 029 MODE
CRASC=5242		;12-0-2-4-8 PUNCH--READ FULL ASCII CHAR SET
;
; EVENT FLAGS.
;
DV.DNE=000004		; IO DONE
DV.MTM=000010		; MARK TIME
;
; MISCELLANEOUS EQUATES:
LUN=2			; LOGICAL UNIT NUMBER ERROR MESSAGE
MAXFNC=<MAXFN-MINFN>/4 ;MAXIMUN ALLOWABLE FUNCTION CODE VALUE.
;
; ISR PSW

CRPSW=300		; PRIORITY LEVEL SIX
;
EXCUIC=0		; EXEC UIC
MAXBYT=512.		; MAXIMUM DATA TRANSFER.
;

	.SBTTL	MODULE FUNCTION-DETAILS
;
;+
;	THE CARD READER HANDLER WILL DRIVE EITHER THE CR-11 80
; COLUMN PUNCHED CARD READER OR THE 40 COLUMN CM-11 MARK SENSE READER.
; BY DEFINING THE PARAMETER 'MARKS AT ASSEMBLY TIME, INTERNAL
; BUFFER SIZE WILL BE REDUCED TO ACCOMODATE THE 40 COLUMN DEVICE.
;	TYPES OF SERVICE PROVIDED BY THE HANDLER CONSIST OF THE
; FOLLOWING:
;	(A) READ CARDS IN DEC '026' FORMAT AND TRANSLATE TO ASCII
;	(B) READ CARDS IN DEC '029' FORMAT AND TRANSLATE TO ASCII
;	(C) READ CARDS IN THE BINARY FORMAT DESCRIBED BELOW.
;
;
; ASSEMBLY  - TIME OPTIONS:
;
;
; CAPABILITIES MAY BE ADDED OR REMOVED (WITH A CORRESPONDING REDUCTION IN
; CORE REQUIREMENTS) AT ASSEMBLY TIME BY SPECIFYING ONE OR MORE OF THE
; FOLLOWING PARAMETERS:
;	(A) ONLY29	INTERPRET CARDS AS '029' CODE ONLY
;	(B) ONLY26	INTERPRET CARDS AS '026' CODES ONLY.
;	(C) DEFALT	INTERPRET BOTH TYPES OF CARDS WITH '026' AS DEFAULT ON L
;	(D)'NIL'	INTERPRET BOTH TYPES OF CARDS WITH '029' AS DEFAULT ON L
;	(E) BINARY	ALLOW CARDS TO BE READ IN BINARY MODE.
;	(F) MARKS	DEVICE IS A 'CM-11' MARK/SENSE READER.
;
;
; BINARY FORMAT:
;	WHEN A BINARY READ IS SPECIFIED,  EACH CARD COLUMN IS INPUT EX-
; ACTLY AS PUNCHED AND PACKED SUCH THAT FOUR CARD COLUMNS=THREE 16
; BIT WORDS IN THE FORMAT SHOWN BELOW:
;	CARD COLUMN 1:	WORD 1, BITS 15-4
;	CARD COLUMN 2:	WORD 1, BITS 3-0, WORD 2 BITS 15-8
;	CARD COLUMN 3:	WORD 2, BITS 7-0, WORD 3, BITS 15-12
;	CARD COLUMN 4:	WORD 3, BITS 11-0.
;
; RUN TIME OPERATION:
;
;	WHEN LOADED THE HANDLER WILL DECLARE ITSELF RESIDENT AND
; CONNECT TO THE INTERRUPT TRAP LOCATION VIA THE APPRO-
; PRIATE SYSTEMS SUBROUTINES. SHOULD THE ABOVE OPERATIONS FAIL, THE
; HANDLER WILL EXIT GRACEFULLY.
;	ONCE INITIALIZATION HAS BEEN COMPLETED, THE ROUTINE BEGINS
; POLLING FOR THE OCCURENCE OF ONE OR MORE OF THE FOLLOWING EVENT
; FLAGS:
;	I/O DONE		EFN #3
;	EXPRESS REQUESTS	EFN #2
;	MARK-TIME COMPLETE	EFN #4
;	NORMAL REQUESTS		EFN #1
;
; IF NONE OF THE ABOVE ARE PRESENT, THE ROUTINE ISSUES
; A WAIT-FOR DIRECTIVE ON THE ABOVE FLAGS AND RELIQUISHES
; CONTROL OF THE CPU.
;
; NORMAL REQUEST PROCESSING:
;
;	THE SET OF LEGITIMATE NORMAL REQUESTS CURRENTLY CONSISTS OF
;	(A)	READ LOGICAL BLOCK
;	(B)	READ VIRTUAL BLOCK
;	(C)	ATTACH
;	(D)	DETACH
;	(E)	ACCESS FOR READ
;	(F)	ACCESS FOR READ/WRITE
;	(G)	ACCESS FOR READ/WRITE/EXTEND
;
;	THE APPEARANCE OF ANY OF THESE ON THE EXPRESS QUEUE IS
; FLAGGED AS AN ERROR(-2 ERROR CODE).
;
; THE READ REQUEST:
;	THIS REQUEST IS ISSUED VIA THE QIO DIRECTIVE WITH A DPB
; SETUP AS FOLLOWS:
;	FUNCTION CODE:		002		; READ
;	SUB-FUNCTION:		000		; READ IN ALPHANUMERIC MODE
;	SUB-FUNCTION:		200		; READ IN BINARY MODE.
;
;	PARAMETER WORD 0:	BUFFER ADDRESS
;	PARAMETER WORD 1:	TRANSFER AMOUNT(BYTES).
;
;	PARAMETER WORDS 2 - 5 ARE UNUSED
;
;
;
;	NOTE: A BINARY REQUEST IS ILLEGAL(-2 ERROR RETURN) IF THIS
;	      CAPABILITY WAS NOT INCLUDED AT ASSEMBLY.
;
;
;
;	THE MAXIMUM AMOUNT OF DATA TRANSFERRABLE IN A SINGLE
;	REQUEST IS LIMITED TO THE SMALLEST OF THE FOLLOWING VALUES:
;
;
;		(A) THE NUMBER OF BYTES REQUESTED
;		(B) THE MAXIMUM AMOUNT OF DATA ON A SINGLE CARD.
;
;	EACH READ REQUEST RESULTS IN THE TRANSFER OF A SINGLE
; CARD OF DATA INTO THE HANDLER'S BUFFER. THUS WHILE ANY NON-ZERO
; BYTE COUNT IS ACCEPTED, THE HANDLER WILL ONLY TRANSFER A MAXIMUM
; OF 80 BYTES IN ASCII MODE OR 120 BYTES IN BINARY MODE. FOR THE
; CM-11, THE MAXIMUM AMOUNT OF DATA THAT MAY BE TRANSFERRED IN A
; SINGLE REQUEST IS 40 BYTES(ASCII) OR 60 BYTES (BINARY).
; IN ANY EVENT, A COUNT OF THE ACTUAL NUMBER OF BYTES TRANSFERRED
; IS PLACED IN THE SECOND WORD OF THE I/O STATUS BLOCK.
;
; CONTROL CARDS:
;
;
; 	CONTROL CARDS ARE USED TO PERFORM THE FOLLOWING FUNCTIONS:
;
;	ASCII MODE:
;
;		(A) SELECT THE TRANSLATION MODE (029 OR 026).
;		(B) EFFECT END-OF-FILE.
;
;	IN BINARY MODE ONLY THE END-OF-FILE CARD IS RECOGNIZED
;
; CONTROL PUNCHES ARE ONLY RECOGNIZED WHEN OCCURRING IN CARD
; COLUMN 1 (C/C 1 - 8 FOR EOF IN BINARY MODE). SUCH
; DATA IS NEVER TRANSFERRED TO THE USER NOR IS IT INCLUDED IN THE
; BYTE COUNT.
;
; CONTROL CARD FUNCTIONS:
;
;		PUNCH			FUNCTION
;		-----			--------
;
;		12-2-4-8		READ IN '029' MODE
;		12-0-2-4-6-8		READ IN '026' MODE
;		12-11-0-1-6-7-8-9	END OF CARD FILE
;
; ASCII MODE SELECTION:
;
;	THE TYPE OF TRANLATION TO BE PERFORMED IS SPECIFIED BY
; INCLUDING THE APPROPRIATE CONTROL CARD IN THE DECK. THIS
; MODE REMAINS IN EFFECT UNTIL ANOTHER MODE
; CARD IS ENCOUNTERED. IT IS ADVISABLE TO PRECEDE
; ALL DECKS READ IN ASCII WITH A CARD OF THIS TYPE SINCE TRANS-
; LATION MODE IS NOT AFFECTED BY END-OF-FILE. IN THE CASE WHERE
; THE READER IS ASSEMBLED FOR ONE MODE ONLY, HOWEVER, SUCH CARDS ARE
; IGNORED.
;
;
;
;
; END-OF FILE:
;
;
;	TO PERMIT THE READING OF LARGE CARD DECKS, THE HOPPER-EMPTY STATE
; IS ALWAYS TREATED AS AN ERROR. THUS, THE E-O-F CARD MUST TERMINATE
; THE CARD FILE IN CASES WHERE THE REQUESTING PROGRAM
; MAY INPUT MANY CARDS. FOR RECOGNITION IN BINARY MODE, THE
; SPECIFIED PUNCH MUST APPEAR IN AT LEAST C/C 1 - 8.
;
;
; INTERRUPT SERVICE ROUTINE PROCESSING:
;
;
;	INTERNAL PROCESSING CONSISTS OF READING EACH CARD COLUMN AT
; INTERRUPT LEVEL AND PLACING THE DATA IN THE HANDLER'S INTERNAL BUFFER
; FOR FURTHER PROCESSING AT TASK LEVEL. BINARY DATA IS PLACED IN THE
; BUFFER IN COMPRESSED FORM. THUS MINIMAL WORK IS ASSIGNED TO THE ISR.
; SPECIFICALLY THIS ROUTINE MUST:
;	(A) SAVE THE CONTENTS OF CARD COLUMN 1 FOR CONTROL PUR-
;           POSES.
;	(B) DETECT AND FLAG EXCEPTIONAL HARDWARE CONDITIONS(CARD-DONE,
;           ERROR, READER TO ONLINE).
;	(C) COMPRESS BINARY DATA AND STORE IN THE HANDLER'S BUFFER
;	(D) STORE THE CONTENTS OF THE 8-BIT READER BUFFER IN THE
;	    HANDLER'S BUFFER WHEN READING IN ALPHANUMERIC MODE.
;
;	ON DETECTING ANY EXCEPTIONAL HARDWARE CONDITION, THE ISR
; WILL DECLARE A SIGNIFICANT EVENT AND CAUSE EFN #3 TO BE SET.
;	THE TASK LEVEL ROUTINE COMPLETES THE TRANSFER OF DATA INTO
; THE USER'S AREA, PERFORMING ANY ALPHANUMERIC TRANSLATION REQUIRED.
; TRANSLATION IS DONE IN THE CURRENT MODE UNLESS THE CARDS TO BE
; READ ARE PRECEDED WITH A CONTROL CARD OF THE APPRO-
; PRIATE TYPE. SUCH CARDS ARE NOT RECOGNIZED WHEN THE READER IS
; ASSEMBLED FOR A SINGLE TRANSLATION MODE.
;	THE READER REMAINS IN THE LAST MODE SELECTED UNTIL
; ANOTHER ALPHANUMERIC MODE CARD IS READ.
;
; THE 'READ VIRTUAL BLOCK' REQUEST:
;
;	THE DPB IS THE SAME AS THE 'READ LOGICAL' REQUEST
; EXCEPT FOR THE FUNCTION CODE WHICH IS -- 21.
;
;
;
; ATTACH:
;	THE ATTACH FUNCTION REQUIRES A DPB SET UP PER THE SPECIFICATION.
;NO SPECIAL PARAMETERS ARE REQUIRED. AS IMPLIED, THIS FUNCTION GIVES
; THE USER SOLE CONTROL OVER THE DEVICE.
;
;
; DETACH:
;	DETACH REQUIRES A DPB SET UP PER THE SPECIFICATIONS. NO SPECIAL
; PARAMETERS ARE REQUIRED.
;
;
; ACCESS FOR READ; READ-WRITE; OR READ-WRITE EXTEND:
;
;	DPB:	NORMAL, NO PARAMETERS REQUIRED.
;
;	FUNCTION CODES ARE:
;
;	15 -- ACCESS FOR READ
;	16 -- ACCESS FOR READ-WRITE
;	17 -- ACCESS FOR READ-WRITE-EXTEND
;
;	EXCEPT FOR ACCESS VALIDATION, THESE CODES ARE EFFECTIVELY
; TREATED AS 'NO OPS' BY THE HANDLER.
;
; ERROR HANDLING:
;
;	THE HARDWARE IS TESTED FOR ERROR STATUS BOTH BEFORE AND AFTER
; A 'READ' IS ISSUED. ERRORS PRIOR TO ISSUING THE READ (VIZ. "READER
; OFFLINE") CAUSE THE MESSAGE:
;
;	*** CR0 -- NOT READY
;
; TO BE PRINTED ON DEVICE 'CO'. TO RECOVER, THE OPERATOR SHOULD CORRECT
; THE CONDITION AND DEPRESS 'RESET'.
;
;	ERRORS DETECTED AFTER THE READ WAS ISSUED CAUSE THE MESSAGE
;
;	*** CR0 -- READ FAILURE, CHECK HARDWARE STATUS
;
; TO BE PRINTED ON DEVICE 'CO'. THE OPERATOR SHOULD CHECK THE
; STATUS LIGHTS TO DETERMINE THE PROBLEM AND TAKE APPROPRIATE CORRE-
; CTIVE ACTION. RECOVERY IS THEN AFFECTED AS DESCRIBED ABOVE.
;
; EXPRESS REQUEST PROCESSING:
;	LEGITIMATE EXPRESS REQUESTS CURRENTLY CONSIST OF THE FOLLOWING
;	(A)	KILL
;	(B)	FLUSH
;	(C)	EXIT
;
;	THE LATTER TWO ARE ONLY HONORED IF ISSUED BY THE EXEC.
;
;	THE KILL REQUEST IS  ISSUED WITH A FUNCTION CODE OF 000
; AND SUBFUNCTION CODE OF 042. THE HANDLER SETS UP THE REQUEST
; NODE TO LOOK LIKE A FLUSH REQUEST THEN EXECUTES CODE COMMON
; TO BOTH TYPES OF REQUEST. THE PROCESSING IS DESCRIBED.
; BELOW.
;
; FLUSH:
;	THE FLUSH REQUEST IS ISSUED BY THE EXEC TO
; CANCEL ANY I/O IN PROGRESS FOR A USER AND PURGE THE QUEUE OF
; OF ALL REQUESTS FOR THE 'VICTIM TASK. THIS FUNCTION REQUIRES
; A REQUEST NODE SETUP AS FOLLOWS:
;
;	FUNCTION CODE:		000
;	SUB-FUNCTION:		012
;	PARAMETER WD 0:		ATL NODE ADDRSS, TASK TO BE FLUSHED.
;	PARAMETER WD 1:		STD  ADDRESS
;	PARAMETER WD 2:		PUD POINTER
;
;	FLUSH IMMEDIATELY CANCELS ANY I/O IN PROGRESS FOR THE
; VICTIM AND RETURNS ALL PENDING REQUESTS TO THE POOL VIA
; A CALL TO ..FLSH. THE NORMAL REQUEST FOR THE VICTIM IS TERMINATED
; WITHOUT SETTING THE REQUESTED EVENT FLAG OR AFFECTING
; THE AST,  BY CLEARING THE APPROPRIATE REQUEST NODE ENTRIES.
;
; EXIT:
;	EXIT REQUIRES A STANDARD REQUEST NODE HAVING A
; FUNCTION CODE OF 000 AND SUBFUNCTION CODE 042. THIS REQUEST
; CAUSES THE HANDLER TO TERMINATE PROCESSING ALL CURRENT REQUESTS
; (HANDLER RETURNS A FUNCTION CODE OF -2), AND RETURN THE
; REQUEST NODES TO THE POOL . THE ROUTINE THEN CALLS THE
; APPROPRIATE SYSTEMS SUBROUTINES TO DISCONNECT FROM THE INTERRUPT
; VECTOR , DECLARE ITSELF NON-RESIDENT AND ISSUE
; THE EXIT DIRECTIVE.
;
;
;
;-
; MACRO  DEFINITIONS:
	.MCALL	SDRQ$,DIR$,CALL,RETURN,QIO$
	.MACRO	CALL	SUB
	JSR	PC,SUB		; CALL SUB SUBROUTINE.
	.ENDM
;
	.MACRO	RETURN
	RTS	PC
	.ENDM
;
	.MACRO	INH		; INHIBIT INTERRUPTS
	MOV	@#PS,-(SP)	; PUT CURRENT PROCESSOR PS ON STACK
	BIS	#340,@#PS	; RAISE TO PRIORITY SEVEN.
	.ENDM
	.MACRO	.ENB		; ENABLE INTERRUPTS.
	MOV	(SP)+,@#PS	; RESTORE PSW.
	.ENDM
;
;

;
;
; LOCAL DATA:
;

	.PSECT	CRDATA		;++001
	.EVEN
;
CRDFLT:	.BYTE	AMODE		; DEFAULT HANDLER STATUS.
EOFSW:	.BYTE	1		; THRESHOLD COUNT FOR EOF
ERRFL:	.BYTE	0		; ERROR TYPE
CCOL:	.BYTE	0		; ODD/EVEN COLUMN INDICATOR
CRSTAT:	.BYTE	AMODE		; HANDLER STATUS
EOFCNT:	.BYTE	0		; TALLYS END-OF-FILE CHARACTERS.
ISSTAT:	.BYTE	0		; ISR STATUS.
;
	.EVEN
IHBFPT:	.WORD	0		; POINTER TO HANDLER'S INTERNAL BUFFER.
IHBFCT:	.WORD	0		; HANDLER BUFFER CHARACTER COUNT
USBFPT:	.WORD	0		; POINTER TO USER'S BUFFER
UBYTCT:	.WORD	0		; USER BYTE COUNT
USBTRQ:	.WORD	0		; DEFAULT ALPHA MODE.
BFLNTH:	.WORD	0		;  BUFFER SIZE FOR THIS TRANSFER.
CCOL1:	.WORD	0		;  CONTENTS OF CARD COLUMN 1
RNAP:	.WORD	0		; OFFSET TO RNA ENTRY IN UIT
	.IF	NDF,NOASCI	;ALLOW ASCII TO BE CONDITIONED OUT.
	;GCE/ RCA******
ASCMD:	.WORD	1	;NON-0 IF ASCII MODE ALPHAS IN
	;GCE/ RCA******
	.ENDC
;
	.PSECT			;++001

	.SBTTL	INITIALIZATION
;
;+
; THE FOLLOWING CODE PERFORMS FUNCTIONS REQUIRED TO:
; 	A.DECLARE HANDLER RESIDENT
; 	B.SETUP INTERRUPT TRAP VECTOR
; 	C.SETUP POWER FAIL AST.
;
;  SHOULD ANY OF THE ABOVE FAIL, THE HANDLER WILL EXIT THE SYSTEM
;
; ON COMPLETION, THIS AREA IS USED AS STACK
;-
;
CRINIT:	BIC	#CR.NBL,@#CRS	; MAKE SURE DEVICE IS OFF INTERRUPTS
	MOV	#CRUIT,R0	; DEVICE UIT
	MOV	#"CR,R2		; DEVICE NAME
	MOV	#UF.RH,R3	; DEVICE CHARACTERISTICS
	CALL	..DSUT		; SET THIS HANDLER RESIDENT
	BCS	CREXT		; EXIT ON FAILURE
;
	MOV	#CRINV,R0	; TRAP VECTOR LOCATION
	MOV	#CRISR,R1	; LOCATION OF SERVICE ROUTINE
	CLR	R2		; ISR RELOCATED WITH RESPECT TO THIS ROUTINE.
	MOV	CRUIT1,R5	; GET PUD POINTER
;
	CMP	R0,U.TV(R5)	; VERIFY THAT THIS PUD IS AVAILABLE.
	BNE	CREXT0		; SOMEONE WAS HERE FIRST.
	CMP	#CRS,U.DA(R5)	; SEE IF EXTERNAL PAGE ADDR. IS OK
	BNE	CREXT0		; NO, CAN'T EXECUTE THIS CODE; EXIT.
	MOVB	U.IP(R5),R3	; GET INTERRUPT PRIORITY FROM PUD.
	BIC	#177400,R3	; CLEAR POSSIBLE EXTENDED SIGN
	CALL	..CINT		; CONNECT TO INTERRUPTS
	BCS	CREXT0		; EXIT ON FAILURE.
;
	MOV	#PWRAST,-(SP)	; SETUP AST FOR POWER FAILURE
	EMT	377
	BCS	CREXT1		; EXIT WITH A SIGH.
;
	BIS	#EF.NIR,WFORFL		; SET NORMAL REQUEST  BIT IN FLAGS MASK
	BIS	#EF.XIR,WFORFL		; SET EXPRESS REQUEST BIT IN FLAGS MASK
;
	BIS	#EF.XIR,WFRXNM		;  ALTERNATE WAIT-FOR
	JSR	SP,CRPOL0	; USE THIS AREA AS STACK, BEGIN POLLING FLAGS.

	.SBTTL	EXIT ROUTINES
;
CREXT1:
	CLR	@#CRS		; TAKE READER OFF INTERRUPTS
	MOV	#CRINV,R0	; INTERRUPT TRAP ADDRESS
	CALL	..DINT		; DISCONNECT
;
;
CREXT0:
	MOV	#CRUIT,R0	; DISPATCH TABLE ADDRESS.
	CALL	..DNRC		; DECLARE NON RESIDENT
;
CREXT:
	MOV	#EXTDPB,-(SP)	; PUSH DPB ADDRESS
	EMT	377		; EXIT
	HALT			; SHOULD NEVER GET HERE.



	.SBTTL	EVENT POLLING
;
;	THIS ROUTINE IS ENTERED AFTER INITIALIZATION IS COMPLETE
; AND WHEN A SIGNIFICANT EVENT OCCURS. IT CHECKS FOR THE PRESENCE
; OF EVENT FLAGS IN THE FOLLOWING ORDER OF PRECEDENCE:
;	I/O DONE		EFN #3
;	EXPRESS REQUESTS	EFN #2
;	MARK-TIME EVENT		EFN #4
;	NORMAL REQUEST		EFN #1
;
;	IF THE HANDLER HAS NO WORK TO DO, IT WILL ISSUE A WAIT-FOR
; ON THE ABOVE FLAGS.
;
;	NOTE: TO PREVENT RACE CONDITIONS WITHIN THE CODE IT
;		IS MANDATORY THAT EACH PROCESSING ROUTINE RETURN
;		CONTROL TO EITHER 'CRPOLL' OR 'CRIDLE'/
;
;
;
CRPOL0:	CALL	SPLTST		;*** 004 - START UP SPOOLER
	MOV	#CR.NBL,@#CRS	;*** 004 ENABLE INTERRUPTS
CRPOLL:
	CLR	RNAP		; SET RNA OFFSET FOR NORMAL REQ.
	MOV	.CRTSK,R2	; GET ATL POINTER FROM .SCOM
	MOV	#CRUIT,R0	; UIT TABLE ADDRESS FOR SYSTEM SUBROUTINES
	MOV	A.EF(R2),R3	; FETCH EVENT FLAGS 1-16
	BIT	#DV.DNE,R3	; IO COMPLETION?
	BEQ	10$		; NO, CHECK FOR OTHER FLAGS.
	JMP	IODONE		; YES, HANDLE
;
;
10$:	BIT	#EF.XIR,R3	; EXPRESS REQUEST?
	BEQ	20$		; NO
	INC	RNAP		; BUMP RNA OFFSET
	JMP	IOEXP		; CATCH THE EXPRESS
;
20$:	BIT	#DV.MTM,R3	; 'MARK-TIME' OVER?
	BEQ	30$		; CHECK FOR NORMAL
	CLR	NOTINS		;*** 004 CLEAR NOT INSTALLED FLAG
	JMP	CRERR1		; OTHERWISE, JOG THE OPERATOR AGAIN.
;
30$:
	BIT	#EF.NIR,R3	; 'NORMAL' REQUEST?
	BEQ	40$		; NO, GO TO SLEEP
	JMP	IONORM		; OTHERWISE, PROCESS.
40$:
	TST	NOTINS		;*** 004 INSURE WE DONT GET A RACE
	BNE	45$		;*** 004 CONDITION OF CONTINUOUS TYPEOUTS
	TST	ACTIVE		;*** 004 READ IN PROGRESS?
	BNE	45$		;*** 004 YES - PROCEED
	TST	RECOGN		;*** 004 ALREADY RECOGNIZED?
	BNE	45$		;*** 004 YES - DON'T TRY SPOOLER
	CALL	SPLTST		;*** 004 TO START UP SPOOLER
45$:
	MOV	#WAIT4M,-(SP)	; WAIT ON THE ABOVE FLAGS
CRIDLE:	EMT	377		; ......
	JMP	CRPOLL		; FIND OUT WHAT HAPPENED
;
WFXIM:	MOV	#WF234,-(SP)	; DON'T WAIT ON NORMAL REQUESTS IF ONE IS IN PRO
	BR	CRIDLE

	.SBTTL	PRELIMINARY PROCESSING FOR QUEUED REQUESTS
;
;	THESE ROUTINES DEQUE REQUESTS FROM THE DEVICE QUEUES.
; IF A REQUEST CANNOT BE DEQUED(IE ANOTHER REQUEST IS IN PROGRESS)
; THE ROUTINE RETURNS TO POLLING. OTHERWISE, IODISP IS ENTERED
; TO VALIDATE USER ACCESS RIGHTS AND INSURE THAT THE FUNCTION
; CODE IS WITHIN RANGE OF THE DISPATCH TABLE...DISP IS THEN CALLED
; TO TRANSFER CONTROL TO THE APPROPRIATE PROCESSING CODE.
;
;
;  ENTER WITH UIT TABLE ADDRESS IN R0
IONORM:
	TST	CRUIT2		; ARE WE PROCESSING A REQ. NOW
	BEQ	10$		; NO, TRY TO DEQUE ANOTHER.
;
	BR	WFXIM		; YES -- RELINGUISH CPU UNTIL DONE.
;
10$:
	CALL	..DQRN		; TRY TO DEQUE A NORMAL REQUEST.
;
	BCS	CRPOLL		; NOTHING DOING, RETURN TO POLL
	BR	IODISP		; CHECK ACCESS RIGHTS, DISPATCH IF OK
;
;
IOEXP:	CALL	..DQRE		; TRY TO DEQUE AN EXPRESS REQUEST.
	BCS	CRPOLL		; NO LUCK, KEEP TRYING.
;
;  MAIN DISPATCHING ROUTINE:
; 	ENTER WITH:
; 		R0:	UIT ADDRESS
; 		R1:	RNA ADDRESS
; 		R2:	ADDRESS OF PUD POINTER
;
IODISP:
	CALL	..VACC		; MAKE SURE USER HAS ACCESS RIGHTS.
	BCC	5$		; OK?
	JMP	ILLPRI		; CAN'T DO IT, NOTIFY REQUESTOR.
5$:	CMPB	R.FC+1(R1),#MAXFNC ; CHECK FOR WILD FUNCTION CODE.
	BLO	10$		; CONTINUE
	JMP	ILLFNC		;
10$:
	JMP	..DISP		; CALL DISPATCHER

	.SBTTL	UNIT IDENTIFICATION TABLE
;
;+
;  UIT TABLE:
; 	STRUCTURED AS FOLLOWS:
; 		WD. 00:	ADDRESS OF DISPATCH TABLE
;		WD. 01:	MAX NO. OF UNITS (1) & # UNITS FOUND BY ..DISP
; 		WD. 02:	UNIT NO OF LAST NORMAL REQUEST & LAST EXPRESS REQUEST
; 		WD. 03:	POINTER TO UIT ENTRY OF NEXT REQUEST TO DEQUE
; 		WD. 04:	POINTER TO UIT ENTRY OF LAST REQUEST DEQUED
; 		WD. 05:	UNIT NO. BEFORE ..DSUT, PUD POINTER AFTERWORDS.
; 		WD. 06:	RNA-NORMAL REQUEST
; 		WD. 07:	RNA-EXPRESS REQUESTS
; 	WORDS 5-7 ARE REPEATED FOR EACH UNIT IN THE SYSTEM.
;-
;
CRUIT:	.WORD	DISPCH		; DISPATCH TABLE ADDRESS
	.BYTE	1,0		; ONE UNIT
	.BYTE	0,0		; UNIT, LAST NORMAL REQUEST, LAST EXPRESS REQUES
	.WORD	0		; UIT ENTRY, NEXT REQUEST TO DEQUE
	.WORD	0		; UIT ENTRY, LAST REQUEST DEQUED
CRUIT1:	.WORD	0		; PUD POINTER-UNIT 0
CRUIT2:	.WORD	0		; LAST NORMAL RNA
	.WORD	0		; EXPRESS RNA
;

	.SBTTL	DISPATCH TABLE
;
;+
;  DISPATCH TABLE:
; 	TWO WORD ENTRY FOR EACH FUNCTION PLUS ONE TWO WORD HEADER.
; 	    EACH ENTRY CONSISTS OF THE FOLLOWING:
;
; 	    WD. 00: LOW BYTE= CONTROL VARIABLE USED BY ..DISP AND ..VACC
; 	    	    HI  BYTE= NUMERIC SUFFIX FOR HANDLER LIBRARY ROUTINE NAME
;			      OR CHARACTERISTICS MASK
;
; 	    WD. 01: ADDRESS OF DISPATCH ROUTINE OR ADDRESS OF BUFFER TO
; 		    BE TRANSFERRED VIA 'SEND/REQUEST.
;
; CONTROL BYTE:
;	    THE HIGH ORDER 4 BITS DEFINE HOW ..DISP
;	   HANDLES TABLE ENTRIES SPECIFICALLY:
;		BIT 0:	WORD 2 IN AN ENTRY IS A SEND/REQUEST
;			BUFFER POINTER TO TASK FXX'NNN' WHERE 'NNN'
;			IS THE CONTENTS OF THE HI BYTE IN WD. 1.
;
;		BIT 1:	HIGH ORDER 5 BITS OF SUBFUNCTION CODE MUST BE 0
;		BIT 2:	BIT 1 (EXPRESS) OF SUBFUNCTION CODE MUST BE 0
;		BIT 3:	RESERVED.
;
;
; 	    IF BIT 0 IS ON, THE ROUTINE GENERATES A SEND/REQUEST
; 	    FOR TASK "FXXNNN", WHERE NNN IS THE CONTENTS OF THE
; 	    HIGH BYTE. OTHERWISE THE ADDRESS IN WORD 2 IS INTER-
; 	    PRETED AS A JUMP ADDRESS FOR TRANSFER OF CONTROL.
; 	      HEADER WORD 0 DEFINES WHERE CONTROL RETURNS ON
; 	    SUCCESSFUL SEND/REQUEST EXECUTION. HEADER WORD ONE SPECI-
; 	    FIES THE RETURN POINT SHOULD THE ABOVE DIRECTIVE FAIL.
;
;	THE LOW ORDER FOUR BITS ARE USED BY '..VACC' TO DEFINE THE ACCESSS
;	PRIVELEGES REQUIRED TO PERFORM A GIVEN OPERATION, SPECIFI-
;	CALLY:
;		BIT 4:	USER MUST HAVE DELETE PRIVELEGE
;		BIT 5:	USER MUST HAVE EXTEND PRIVELEGE
;		BIT 6:	USER MUST HAVE WRITE PRIVELEGE
;		BIT 7:	USER MUST HAVE READ PRIVELEGE
;
;	SETTING ONE OF THE ABOVE BITS STATES, IN EFFECT, THAT
;	THE USER MAY NOT PERFORM A GIVEN OPERATION UNLESS HE
;	HAS THE APPROPRIATE ACCESS RIGHTS.
;	ACCESS RIGHTS ARE DEFINED BY THE APPROPRIATE ENTRY IN THE
;	VOLUME CONTROL BLOCK.
;
;
DISPCH:	.WORD	0		; NO SEND/REQUESTS PERFORMED
	.WORD	0		;
MINFN:	.BYTE	0,0		;++001
	.WORD	EXPFNS		; EXPRESS FUNCTIONS
;
	.BYTE	010,142		;
	.WORD	ILLFNC		; ILLEGAL FUNCTION -- WRITE
;
	.BYTE	010,041		;
	.WORD	CRREAD		; READ LOGICAL
;
	.BYTE	020,140		;
	.WORD	ATTCH		; ATTACH CARD READER.
;
	.BYTE	020,140
	.WORD	DETACH		; DETACH THE READER
;
	.BYTE	010,000		;
	.WORD	ILLFNC		; ILLEGAL FUNCTION -- CONTROL
;
	.BYTE	0,0		;
	.WORD	ILLFNC		; ILLEGAL FUNCTION -- UNDEFINED.
;
	.BYTE	0,0		;
	.WORD	ILLFNC		; ILLEGAL FUNCTION -- UNDEFINED
;
	.BYTE	0,0		;
	.WORD	ILLFNC		; ILLEGAL FUNCTION -- UNDEFINED
;
	.BYTE	140,140		;
	.WORD	ILLFNC		; ILLEGAL FUNCTION -- FIND
;
	.BYTE	0,0		;
	.WORD	ILLFNC		; ILLEGAL FUNCTION -- UNDEFINED
;
	.BYTE	140,140		;
	.WORD	ILLFNC		; ILLEGAL FUNCTION -- REMOVE
;
	.BYTE	140,140		;
	.WORD	ILLFNC		; ILLEGAL FUNCTION -- ENTER
;
	.BYTE	140,141		; REQUIRES READ PRIVELEDGE.
	.WORD	CRNOP		; NO ACTION REQUIRED -- ACCESS FOR READ
;
	.BYTE	140,143		; REQUIRES READ/WRITE PRIVLEDGES.
	.WORD	CRNOP		; NO ACTION REQUIRED -- ACCESS FOR READ/WRITE
;
	.BYTE	140,147		; REQUIRES READ/WRITE/EXTEND PRIVLEDGES.
	.WORD	CRNOP		; NO ACTION -- READ/WRITE/EXTEND ACCESS
;
	.BYTE	100,140		;
	.WORD	CRNOP		; NO ACTION REQUIRED -- DEACCESS
;
	.BYTE	100,041		; REQUIRES READ PRIVLEDGES
	.WORD	CRREAD		; READ VIRTUAL = READ LOGICAL
;
MAXFN:
;

	.SBTTL	EXPRESS REQUEST PROCESSING
;
;+
; EXPRESS REQUESTS ARE PROCESSED HERE. THESE ARE THREE IN NUMBER
; AND CONSIST OF 'KILL', 'FLUSH' AND HANDLER 'EXIT'.
;
;
;
;	KILL ABORTS ANY TRANSFERS IN PROGRESS FOR THE REQUESTOR,
; THEN SETS UP HIS REQUEST NODE TO LOOK LIKE 'FLUSH' AND PURGES
; HIS REQUESTS FROM THE QUEUE VIA A CALL TO ..FLSH.
;
;
;	I/O 'FLUSH' IS USED TO ELIMINATE REQUESTS FOR ANY USER
; AND IS THEREFORE ONLY VALID WHEN ISSUED BY THE EXEC. AS IMPLIED ABOVE
; I/O FLUSH REQUIRES AN RNA SET UP AS FOLLOWS:
;	PARAM0:	ATL NODE ADDRESS; TASK TO BE FLUSHED(VICTIM).
;	PARAM1:	STD ADDRESS(VICTIM)
;	PARAM2:	PUD POINTER
;
;
;	EXIT IS ISSUED BY THE EXECUTIVE AND CAUSES THE
; HANDLER TO TERMINATE ANY I/O IN PROGRESS AND EXIT THE
; SYSTEM GRACEFULLY.
;
;
;-
;  ON ENTRY:
;
; 	R1= RNA ADDRESS (REQUESTOR)
; 	R2= ADDRESS OF PUD POINTER
;
EXPFNS:
	BIT	R.FC(R1),#IQ.Q	; MAKE SURE WE GOT HERE VIA EXPRESS QUEUE.
	BEQ	ILLF1J		; NO,
	CMP	R.FC(R1),#IO.KIL	; KILL SUBFUNCTION ?
	BNE	CRFLSH		; NO, CHECK FOR FLUSH.
;
	MOV	R.AT(R1),R3	;
	MOV	R3,R.PB(R1)	; ATL ADDRESS-THIS TASK
	MOV	R.TD(R1),R.PB+2(R1)	; STD ADDRESS
	MOV	(R2),R.PB+4(R1)	; PUD ADDRESS
	BR	FLSHTK		; FLUSH THE TASK
;
; THIS CODE PERFORMS USER VALIDATION PRIOR TO PERFORMING THE FLUSH
; SPECIFICALLY, IT FIRST CHECKS TO SEE THAT THE REQUESTOR
; IS THE EXEC.
;
CRFLSH:
	CMP	R.FC(R1),#IO.RDN	; I/O RUNDOWN ?
	BNE	CRHEXT		; NO, CHECK FOR HANDLER EXIT.
	TST	R.AT(R1)	; EXEC REQUEST ?
	BNE	ILLF1J		; NO, NOT ALLOWED.
	MOV	R.PB(R1),R3	; OK. GET ATL OF VICTIM.
;
; COMMON CODE FOR FLUSH AND KILL FUNCTIONS:
;
;	THIS ROUTINE DETACHES THE VICTIM IF NECESSARY AND
; CHECKS TO SEE IF HE WAS DOING I/O. IF SO, THE ROUTINE
; CALLS SETIOD TO FAKE AN I/O COMPLETION EVENT SO 'IODONE'
; WILL BE CALLED WITHOUT WAITING FOR AN INTERRUPT FROM
; THE READER. IODONE WILL INSPECT THE ABORT FLAG, WHICH IS
; SET HERE, AND WILL TERMINATE THE TRANSFER WITH -15 ERROR
; RETURN AND RELEASE THE NODE.
;
;	FINALLY, ..FLSH IS CALLED TO PURGE THE QUEUE OF ANY
; REQUESTS MADE BY THE VICTIM.
;
;
;
;		ENTER WITH:
;		R1=RNA ADDRESS (REQUESTOR)
;		R2=ADDRESS OF PUD POINTER
;		R3=ATL ADDRESS OF VICTIM
;
; CODE HERE IS COMMON TO BOTH FLUSH AND KILL FUNCTIONS
;
FLSHTK:
	MOV	2(R2),R4	; GET RNA OF LAST NORMAL REQ.
	BEQ	FLEXT		; NONE PENDING, CONTINUE.
	CMP	R3,R.AT(R4)	; SEE IF VICTIM WAS DOING I/O.
	BNE	FLEXT		; NO, JUST FLUSH.
	BISB	#CR.ABT,CRSTAT	; YES, SET FLAG TO PREVENT DATA XFER.
;
	CLRB	R.FN(R4)	; CANCEL FLAG ON I/O DONE
	CLR	R.AE(R4)	; AND AST (VICTIM).
;
;
	CALL	SETIOD		; CALL THIS ROUTINE TO FAKE AN INTERRUPT.
;
FLEXT:
	CALL	..FLSH		; FLUSH THIS USER
	JMP	GOODIO		; FINISH THIS REQUEST

;+
;
; EXIT REQUEST:
;
; THIS CODE IS ENTERED WHEN THE HANDLER HAS BEEN INSTRUCTED
;  TO EXIT THE SYSTEM. EXIT IS ONLY LEGAL WHEN ISSUED BY THE EXEC.
; THE ROUTINE TERMINATES ANY NORMAL REQUEST IN PROGRESS WITH AN
; ERROR CODE OF -2, RETURNS ALL NODES TO THE POOL(VIA ..IODN), AND
; TRANSFERS CONTROL TO THE EXIT ROUTINES FOR FINAL CLEANUP.
;

; 	ON ENTRY:
; 		R1=RNA
; 		R2=PUD POINTER
;-
;
;
CRHEXT:
	CMP	R.FC(R1),#IO.UNL	; EXIT REQUEST ?
	BNE	ILLF1J		; NO, ILLEGAL.
;
	TST	R.AT(R1)	; EXEC REQUEST ?
	BNE	ILLF1J		; ITS A NO-NO!
	CLR	@#CRS		; TAKE DEVICE OFF INTERRUPTS.
	CLR	R2		; ADJUST UNITY DECREMENT
	MOV	#IS.SUC,R3		; SUCCESS FOR THIS REQUEST
	CLR	R4		; '0' DATA TRANSFERRED.
	CALL	..IODN		; FINISH THIS REQUEST
	MOV	CRUIT2,R1	; ANY NORMAL REQUESTS IN PROGRESS?
	BEQ	LASTEX		; NO,
	MOV	#IE.IFC,R3	; TOO BAD, FLAG AS ERROR.
	CLR	R4		; 'DEVICE CHARACTERISTICS'
	CALL	..IODN		;
LASTEX:	JMP	CREXT1		;

;
;
; ERROR ROUTINE BRANCH POINTS.
;
ILLF1J:	JMP	ILLFNC		; ILLEGAL FUNCTION CODE
;
ILLA1J:	JMP	ILLATD		; ILLEGAL-ALREADY ATTACHED
;
ILLN1J:	JMP	ILLNAT		; ILLEGAL-NOT ATTACHED
;
ILLP1J:	JMP	ILLPRM		; ILLEGAL PARAMETERS
;
ILLE1J:	JMP	ILLEOF		; ILLEGAL-END OF FILE.
;
ILLS1J:	JMP	ILLSPC		; BUFFER SPEC ERROR

	.SBTTL	NORMAL REQUEST PROCESSING
;
;  COME HERE TO ATTACH THE DEVICE
; 	R1=RNA
; 	R2=PUD POINTER
;
ATTCH:
	CALL	..ATUN		; TRY TO ATTACH
	BCS	ILLA1J		; CAN'T ATTACH-RETURN ERROR
	BR	DETEX		;++002 RETURN SUCCESS
;
;  DETACH THIS USER HERE
;  ENTER WITH:
; 	R1=RNA
; 	R2=PUD POINTER
DETACH:
	CALL	..DTUN		; TRY TO DETACH
	BCS	ILLN1J		; NEVER WAS ATTACHED
DETEX:				;++002 REF LABEL
	JMP	GOODIO		; MADE IT

	.SBTTL	READ REQUEST PROCESSING
;
;	READ REQUESTS ARE PROCESSED HERE. ON ENTRY, THE USER'S
; NODE IS EXPECTED TO CONTAIN THE FOLLOWING:
;	PARAM0:		BUFFER ADDRESS
;	PARAM1:		BYTE COUNT
;
;	ALPHANUMERIC READING IS ALWAYS INITIATED IN THE DEFAULT
; MODE UNLESS THE USER IS ATTACHED. IN THAT EVENT, ONLY ONE
; MODE CARD IS REQUIRED PER CARD FILE.
;
;	THE END OF FILE CARD MUST TERMINATE EACH DECK OF CARDS
; READ.
;
;
;	ON ENTRY R1=RNA
;
;
CRREAD:
	MOV	R.PB(R1),R2	; GET BUFFER ADDRESS (VIRTUAL)
	MOV	R.PB+2(R1),R3	; AND TRANSFER AMOUNT
	BEQ	ILLS1J		; ZERO TRANSFER ILLEGAL.
	CLR	R5		; SET TRANSFER DIRECTION
	CALL	..VXFR		; VALI DATE THIS TRANSFER
	BCS	ILLP1J		; CAN'T ACCESS THIS BUFFER
;
; OTHERWISE.....
;
5$:	ASH	#-4,R4		; SETUP ADDRESS PLUS OFFSET
	ASHC	#12,R4		;
	ASH	#-12,R5		;
	BIC	#177700,R5	; CLEAR OUT THE GARBAGE.
	ADD	#60000,R5		; SET TO ACCESS ASR 3
	MOV	R5,USBFPT	; SAVE POINTER
	MOV	R3,UBYTCT	; AND COUNT
	MOV	R3,USBTRQ	; SAVE FOR TRANSFER COMPLETION
	BICB	#77,R3		; TRUNCATE TO MULTIPLE OF 32.
	ADD	#100,R3		; ACCOUNT FOR EXCESS.
;
	ASH	#2,R3		; SET IN POSITION FOR PLF.
	BISB	#6,R3		; SET FOR R/W
	MOV	R3,-(SP)	; PDR STATUS ALL SET
	MOV	R4,-(SP)	; BASE ADDRESS FOR....
	CALL	..SPD3		; SWAPPING ASR'S
	CMP	(SP)+,(SP)+	; CLEAN UP THE STACK, DON'T WANT PREVIOUS SETTIN
	MOV	#CRSIZE,BFLNTH	; SET UP FOR FULL C/C OF DATA
	BICB	#CR.BIN,CRSTAT	; CLEAR BINARY MODE
;
	MOVB	R.FC(R1),R4	; PICK UP SUB-FUNCTION BITS.
	BICB	#^C<CR.BIN>,R4 ; ISOLATE MODE BIT
;
	.IF NDF	BINARY
	BNE	ILLF1J		; ILLEGAL FOR THIS VERSION.
	.ENDC
;
	.IF DF	BINARY		;
	BEQ	10$
	MOV	#CRSIZB,BFLNTH	; SET COUNT FOR BINARY READ.
	.ENDC
;
10$:	BISB	R4,CRSTAT	; -THEN SET MODE
;
;  SETUP INITIAL CONDITIONS
;
	BICB	#DF.OFF,CRSTAT	; DEFAULT 'OFF' CONDITIONS
;
;  STARTUP READER
;
GOREAD:
	INC	ACTIVE		;+008 INDICATE READ ORDER ACTIVE
	BIT	#CR.FLN,@#CRS	; CHECK FOR OFFLINE CONDITION
	BEQ	10$		; OK, START READ
;
	JMP	CRERR2		; ERROR CONDTION -- SEND APPRORIATE MESSAGE
10$:
	MOVB	#1,EOFCNT	; SET END OF FILE COUNT
	.IF DF	BINARY		;
	BITB	#CR.BIN,CRSTAT ; WHAT MODE
	BEQ	15$	; ALPHA -- LOOK FOR EOF IN CC 1 ONLY
;
	MOVB	#10,EOFCNT	; OTHERWISE LOOK IN CC 1 - 8
15$:
;
	MOVB	EOFCNT,EOFSW	; SET TO FLAG EOF ON CC1 OR CC 1-8
	.ENDC
	CLRB	CCOL		; CLEAR COLUMN COUNT
	MOV	BFLNTH,IHBFCT	; SET HANDLER BUFFER COUNT
	MOV	#.CRBUF+60000,IHBFPT ;++002 ISR RUNS UNDER KERNEL ASR 3
	CLRB	ISSTAT		; CLEAR ISR FLAGS.
	BISB	#CR.UND,CRSTAT	; SET READER UNDERWAY
	MOV	#CR.GO,@#CRS	; AND GO!
	JMP	CRPOLL

	.SBTTL	I/O COMPLETION PROCESSING
;	THIS ROUTINE IS ENTERED WHENEVER THE I/O DONE EVENT
; FLAG IS SET. ITS MAIN PURPOSE IS TO TRANSFER DATA TO THE
; USER AFTER PERFORMING ANY NECCESSARY CODE CONVERSIONS.
;	ADDITIONAL FUNCTIONS CONSIST OF ERROR DETECTION AND RECOVERY
; AND CONTROL CARD PROCESSING.
;
;
;
IODONE:
	MOV	CRUIT1,R0	; GET PUD POINTER,
;
; NOW CLEAR I/O DONE AND MARK-TIME EVENT FLAGS.
;
	MOV	#<DV.DNE!DV.MTM>,R1	; FETCH THE FLAGS
	CALL	..CLEF		; CLEAR THEM
;
	BICB	#CR.UND,CRSTAT	; CLEAR UNDERWAY FLAG
	BITB	#CR.ABT,CRSTAT	; ABORT IN PROGRESS?
	BEQ	10$		; DO NORMAL PROCESSING
	BICB	#CR.ABT,CRSTAT	; CLEAR ABORT FLAG
	MOV	#MARKOF,-(SP)	; CANCEL ANY MARK-TIME REQUESTS IN PROG.
	EMT	377
	JMP	ILLABT		; GIVE ILLEGAL FUNCTION ERROR-EXIT.
;
10$:	BITB	#IH.ERR,ISSTAT	; ANY ERRORS?
	BEQ	15$		; NO, CONTINUE
	BICB	#IH.ERR,ISSTAT	; CLEAR THE ERROR FLAG
	TSTB	EOFCNT		; WAS THE LAST CARD E-O-F
	BEQ	22$		;++002 YES, IGNORE ERROR, FLAG EOF
	JMP	CRERR3		; OTHERWISE  GO COMPLAIN.
15$:
	BITB	#IH.NLN,ISSTAT	; READER TO ONLINE?
	BEQ	20$		; NO EXCEPTIONAL H.W. COND., DO NORMAL PROCESSIN
	TST	RECOGN		;*** 007 - SPOOLER ALREADY ACTIVE??
	BNE	17$		;*** 004 - YES GO PROCESS
	TST	ACTIVE		;+008 CARD READ ORDER IN PROGRESS
	BNE	17$		;+008 YES--PROCESS
	CALL	SPLTST		;*** 004 - GO REQUEST SPOOLER!!!
	JMP	CRPOLL		;*** 004 - BACK TO POLL ROUTINE
17$:
	MOV	#MARKOF,-(SP)	; CANCEL MARK-TIME REQUEST.
	EMT	377		;
	BICB	#IH.NLN,ISSTAT	; CLEAR THE FLAG
	BR	IOEX2		; INITIATE NEXT READ TO COMPLETE RECOVERY.
20$:
	TSTB	EOFCNT		; TEST FOR END OF FILE
	BNE	PROCES		; OK - EOF NOT SEEN.
22$:
	TST	EOFDET		;*** 004 - SECOND SUCCESIVE EOF?
	BNE	23$		;*** 004 - YES - CLEAR SPOOLER ACTIVE FLAG
	INC	EOFDET		;*** 004 - SET FIRST EOF DETECTED
	BR	24$
23$:
	CLR	RECOGN		;*** 004 - INDICATE SPOOLER NOT ACTIVE
24$:
	.IF	NDF,NOASCI
;******NEW****** GCE/RCA
; RETURNS TO ASCII MODE (FULL CHAR SET) ON RECEIPT OF ENDFILE
; (DOES NOT MODIFY BINARY)
	;GCE/ RCA******
	INC ASCMD	;GETS IN TROUBLE ON 65536 EOF'S (UNLIKELY)
	BISB	#AMODE,CRDFLT	;SET DEFAULT 026/029 TOO
	BISB	#AMODE,CRSTAT
	;GCE/ RCA******
	.ENDC	;THAT'S ALL TO THE CHANGE
	JMP	ILLEOF		; RETURN END-OF-FILE ERROR
;
;  SEE IF BINARY DATA IS TO BE PROCESSED.
;
PROCES:
	.IF DF	BINARY
MVBIN:
	BITB	#CR.BIN,CRSTAT	; READING IN BINARY?
	BEQ	IOASCI		; NO, ASCII
	CALL	SETMOV		; SETUP FOR THIS TRANSFER
;
25$:
	BIT	#1,R2		;++002 ON WORD BOUNDARY
	BNE	27$		; NO, JUST TRANSFER.
	SWAB	(R2)		; SWAP FIRST
27$:
	MOVB	(R2)+,(R3)+	; TRANSMIT DATA TO THIS USER
	SOB	R4,25$		;
	BR	GOODIO		; RETURN SUCCESS
	.ENDC
;
;  ASCII PROCESSING
;
IOASCI:
;
;  CHECK FOR SPECIAL CARDS
;
	CLR	EOFDET		;*** 004 - CLEAR END OF FILE DETECTED
	MOV	CCOL1,R5	; FIRST COLUMN READ
30$:
	.IF NDF	ONLY29&ONLY26
	CMP	R5,#CR026	; 026 WANTED?
	BNE	35$		; TRY OTHERS
	BICB	#CR.MDE,CRSTAT	; YES, SET IT UP
	.IF	NDF,NOASCI
	;GCE/ RCA******
	CLR	ASCMD		;026 OR 029 MODE IMPLIES NOT ASCII
	;GCE/ RCA******
	.ENDC
	BR	IOEX2		; READ MORE CARDS
;
35$:
	CMP	R5,#CR029	; HOW ABOUT 029.
	.IF	DF,NOASCI
	BNE	MVASCI		;++002 IF NE NO
	.IFF
	;GCE/ RCA******
	BNE	40$		;TEST ASCII MODE
	CLR	ASCMD		;OR FLAG NOT AS APPROPRIATE
	;GCE/ RCA******
	.ENDC
	BISB	#CR.MDE,CRSTAT	; OK, SET IT UP
	BR	IOEX2		; READ MORE CARDS.
	.IF	NDF,NOASCI
	;GCE/ RCA******
40$:	CMP	R5,#CRASC	;ASCII CTL CARD?
	BNE	MVASCI		;NO, TEXT.
	INC	ASCMD		;YES, FLAG IN ASCII MODE
	BR	IOEX2		;GET NEW CARD
	;GCE/ RCA******
	.ENDC

	.ENDC

;
;  ....REGULAR ASCII-TRANSLATE
MVASCI:
	CALL SETMOV		; SETUP FOR THIS TRANSFER
	.IF NDF	ONLY29
	MOV	#.TT026,R5	;++002 ASSUME 026 MODE FIRST
	.ENDC
;
	.IF NDF	ONLY26&ONLY29
	BITB	#CR.MDE,CRSTAT	; WHAT MODE?
	BEQ	60$		; 026-ALREADY SETUP
	.ENDC
;
	.IF NDF	ONLY26
	MOV	#.TT029,R5	;++002 WANT 029 INSTEAD
	.ENDC
60$:
	.IF	NDF,NOASCI
	;GCE/ RCA******
	TST	ASCMD		;IN ASCII READIN MODE?
	BEQ	63$		;NO, DO 026 OR 029 AS USUAL
62$:	MOVB	(R2)+,R1	;YES. GET BYTES OF DATA FROM CARD
	BIC	#177400,R1	;REMOVE THE DAMNED SIGN EXTENSION!!!!
	MOVB	ASCTBL(R1),(R3)+	;COPY TO USER BUFFER FROM
				;TRANSLATION TABLE
	SOB	R4,62$	;DO ALL BYTES
	BR	GOODIO		;SAY IT WORKED.
63$:
	;GCE/ RCA******
	.ENDC
	CALL	.CRMOV		;++002 TRANSLATE AND MOVE DATA
	BR	GOODIO		;++002 EXIT

	.PSECT	$$CRMV,OVR

;
;  ROUTINE CONVERTS AND MOVES CARD DATA TO USERS AREA
; 	ON ENTRY:
; 		R2=POINTER TO HANDLERS BUFFER
; 		R3=POINTER TO USERS BUFFER
; 		R4=NO. OF BYTES TO MOVE
;		R5=TRANSLATION TABLE POINTER.
;
;
.CRMOV::
MOVSEM:
	MOVB	(R2)+,R1	; GET A COLUMN OF DATA
	MOV	#104,R0		; TO TEST FOR SPECIAL CASES
	CMPB	#240,R1		; RPG SPECIAL?
	BEQ	STORSM		; YES, STORE IN USERS AREA
	INC	R0		; SET FOR...
	CMPB	#140,R1		; RPG SPECIAL?
	BEQ	STORSM		; YES
;
;
	MOVB	R1,R0		; EXTEND SIGN
	BPL	70$		; COL 12 NOT PUNCHED
	ADD	#340,R0		; SET INDEX .GE. 140 IF C/C 12 PRESENT
	MOV	R0,R1		; SET TO COUNT DOWN ON ZONE PUNCHES
70$:
	SUB	#40,R1		; DECREMENT COUNT OF ZONE PUNCHES
	BMI	75$		; NONE LEFT, FETCH THE CHARACTER.
;
	SUB	#17,R0		; SUBTRACT 21 AND STRIP ZONE.
	BR	70$		; LOOP UNTIL ALL ZONE PUNCHES ARE ELIMINATED
75$:
STORSM:
	CMP	R0,#105		;++002 VERIFY INDEX WITHIN TABLE LIMITS
	BLOS	10$		;++002 IF LOS YES
	CLR	R0		;++002 FORCE A BLANK
10$:
	ADD	R5,R0		; CALCULATE TABLE ADDRESS.
	MOVB	(R0),(R3)+	; STORE BYTE IN USER BUFFER
	SOB	R4,MOVSEM	; CONTINUE UNTIL BYTE COUNT EXHAUSTED.
	RETURN			;++002 EXIT

	.PSECT



	.SBTTL	TERMINATE REQUEST PROCESSING
;
; COME HERE TO SEND SUCCES INDICATION.
;
.CRFIN::			; GLOBAL ENTRY POINT
CRNOP:
GOODIO:
	MOV	#IS.SUC,R3		; SUCCESS
	BR	IOEX3
;
; COME HERE WHEN MORE INPUT IS NEEDED TO FILL THIS REQUEST.
;
IOEX2:	JMP	GOREAD	; RESTART CARD READER.

;
; ERROR RETURNS:
;
ILLABT:	MOV	#IE.ABO,R3	; ABORT REQUEST
	BR	IOEX3
;
ILLPRM:	MOV	#IE.BAD,R3	; BAD PARAMETERS.
	BR	IOEX3
;
ILLFNC:	MOV	#IE.IFC,R3	; BAD FUNCTION CODE.
	BR	IOEX3
;
ILLDNR:	MOV	#IE.DNR,R3	; DEVICE NOT READY.
	BR	IOEX3
;
ILLSPC:	MOV	#IE.SPC,R3	; PART OF BUFFER OUT OF USER SPACE.
	BR	IOEX3
;
ILLNAT:	MOV	#IE.DNA,R3	; DEVICE NOT ATTACHED.
	BR	IOEX3
;
ILLATD:	MOV	#IE.DAA,R3	; DEVICE ALREADY ATTACHED.
	BR	IOEX3
;
ILLEOF:	MOV	#IE.EOF,R3	; ILLEGAL END OF FILE
	CLR	ACTIVE		;*** 004 EOF - RESET ACTIVE FLAG
	MOV	#CR.NBL,@#CRS	;*** 004 ENABLE INTERRUPTS
	BR	IOEX3
;
ILLOVF:	MOV	#IE.DAO,R3	; DATA OVERFLOW
	BR	IOEX3
;
ILLPRI:MOV	#IE.PRI,R3	; PRIVELEGE VIOLATION
	BR	IOEX3

;
; DATA TRANSFERS ARE TERMINATED HERE.  ENTER WITH
; SUCCESS INDICATOR IN R3. IF R3 IS POSITIVE, THE ROUTINE WILL
; PLACE THE NUMBER OF BYTES READ IN R4 FOR INSERTION IN WORD 2
; OF THE IO STATUS BLOCK. OTHERWISE R4 CONTAINS THE DEVICE
; CHARACTERISTICS WORD.
;
IOEX3:
	MOV	UBYTCT,R4	;++002 FETCH BYTE COUNT
	TST	R3		; WHAT STATUS?
	BPL	IOEX4		; GOOD TRANSFER, TERMINATE.
	CLR	R4		; FAILED, GET CHARACTERISTICS.
	BIC	#177400,R3	; CLEAR HI- BYTE.
;
IOEX4:
	MOV	RNAP,R5		; GET NORMAL/EXPRESS INDICATOR.
	ASL	R5		; SET FOR WORD DISPLACEMENT.
	MOV	CRUIT2(R5),R1	; GET NODE ADDRESS.
	BEQ	IOEX5		; NOTHING TO RETURN, JUST EXIT.
	CLR	R2		; SET FUDGE FACTOR FOR UNITY DECREMENT.
	CALL	..IODN		; RETURN THIS NODE, GIVE COMPLETION
				; STATUS TO USER.
	CLR	CRUIT2(R5)	; RE-ENABLE DEQUING.
IOEX5:
	JMP	CRPOLL		; RESUME POLLING.

;
;
; THIS SUBROUTINE COMPUTES THE AMOUNT OF DATA TO BE TRANSFERRED TO
; THE USER
;
; INPUTS:
;
; 	'UBYTRQ' = NUMBER OF BYTES REQUESTED BY USER
;	'BFLNTH' = MAXIMUM NUMBER OF BYTES IN HANDLER'S BUFFER
;
; OUTPUTS:
;
;	R2:	POINTER TO HANDLER'S BUFFER
;	R3:	POINTER TO USER'S BUFFER
;	R4:	NUMBER OF BYTES TO TRANSFER
;
SETMOV:
	MOV	#.CRBUF,R2	;++002 FETCH POINTER TO HANDLER BUFFER
	MOV	USBTRQ,R4	;++002 NUMBER OF BYTES REQUESTED
	MOV	BFLNTH,R1	;++002 MAXIMUM BYTE COUNT
	MOVB	CRSTAT,R0	;++002 FETCH HANDLER STATUS
	CMP	R1,R4		;++002 COMPARE COUNT VS BYTES REQUESTED
	BHIS	30$		;++002 REQUEST SMALLER
	MOV	R1,R4		;++002 COUNT SMALLER
30$:
	MOV	R4,UBYTCT	;++002 SAVE FOR TRANSFER COMPLETION
	MOV	USBFPT,R3	;++002 FETCH POINTER TO USER BUFFER
	RETURN			;++002 EXIT


	.SBTTL	HARDWARE ERROR REPORTING
;
;	THIS ROUTINE CONSISTS OF THREE ENTRY POINTS:
;
;	CRERR2 TO REPORT A "NOT READY" CONDITION
;
;	CRERR3 TO REPORT AN ERROR ENCOUNTERED ON ISSUING A "READ"
;
;	CRERR1 TO MAKE ANOTHER REPORT IF THE LAST DETECTED ERROR PERSISTS
;
;  IN ALL CASES, THE READER IS CONNECTED TO THE INTERR-
; UPT LINE TO ALLOW THE RESET BUTTON TO GENERATE AN INTERRUPT.
; THIS ACTION SETS THE 'READER TO ONLINE' STATUS BIT
; IN THE HARDWARE REGISTER TO INFORM THE PROGRAM THAT THE PROBLEM
; HAS BEEN CORRECTED.
;	TO INSURE CORRECTIVE ACTION, THE ROUTINE ISSUES A MARK-
; TIME DIRECTIVE WITH AN INTERVAL OF ONE MINUTE, USING EVENT FLAG
; 4. SHOULD THE TIME-OUT OCCUR, CRERR1 WILL BE ENTERED TO RE-GENERATE
; THE MESSAGE.
; 	IF 'QIO' FAILS, THE REQUEST IS TERMINATED WITH
; AN ERROR MESSAGE OF '-3'(DEVICE NOT READY).
;
;
CRERR1:
	MOV	CRUIT1,R0
	MOV	#DV.MTM,R1	; FETCH THE EVENT FLAG
	CALL	..CLEF		; AND CLEAR IT
	TSTB	ERRFL		; CHECK FOR TYPE OF MESSAGE TO BE SENT
	BEQ	CRER31		; SEND READ ERROR MESSAGE
	BR	CRER21		; OTHERWISE SEND 'DEVICE NOT READY'.
CRERR2:
	MOVB	#-1,ERRFL	; NOT READY ERROR
CRER21:
	MOV	#CRQIO,-(SP)	; QIO DPB
	BR	SNDNRM		;
;
CRERR3:
	CLRB	ERRFL		; CLEAR FLAG FOR READ ERROR
CRER31:
	MOV	#CRQIO1,-(SP) ; READ ERROR MESSAGE
SNDNRM:
	EMT	377
	MOV	#LPBUF1,BUFF1	;*** 004 RESTORE ERROR MESSAGE BUFFER ADDRESS
	MOV	#BUFSZ1,BUF1SZ	;*** 004 RESTORE ERROR MESSAGE SIZE
	BCS	ILLDNR		; CAN'T DO IT, SEND 'DEVICE NOT READY'
				; TO REQUESTOR AND EXIT.
10$:	BIT	#CR.BSY,@#CRS	; +009 INSURE THE CARD READER IS NOT
	BNE	10$		; +009 ACTIVELY ENGAGED IN READING CARDS
	BISB	#CR.UND,CRSTAT	; SET 'UNDERWAY FLAG
	BIS	#CR.NBL,@#CRS	; ALLOW READER TO INTERRUPT.
	MOV	#CRMKTM,-(SP)	; THEN MARK TIME FOR ONE MINUTE.
	JMP	CRIDLE

	.SBTTL	INTERRUPT SERVICE ROUTINE
;+
; INTERRUPT SERVICE ROUTINE:
;	ALL READER INTERRUPTS ARE SERVICED HERE. THE SERVICE
;	ROUTINE DOES MINIMAL  DATA PROCESSING. LEAVING THE
;	BULK OF THE WORK FOR THE HANDLER AT TASK LEVEL.
;	HOWEVER, BINARY DATA IS PACKED HERE BEFORE BEING
;	PLACED IN THE HANDLER'S BUFFER. ASCII DATA IS MERELY
;	FETCHED IN COMPRESSED FORM FROM CRB2 AND STORED.
;		ADDITIONAL PROCESSING CONSISTS OF END-OF-FILE
;	DETECTION, SAVING CARD COLUMN 1 CONTENTS, AND DETECTING
;	EXCEPTIONAL HARWARE CONDITIONS (IE. 'ERROR', 'ONLINE' OR
;	'CARD DONE'). THE ROUTINE MAKES NO ATTEMPT TO
;	DISTINGUISH BETWEEN THESE CONDITIONS BUT  SAVES THE
;	FLAGS FOR TASK LEVEL PROCESSING AND DECLARES A SIGNIFICANT EVENT
;	(EFN #3 IS SET).
;-
;
;
CRISR:
	MOV	R0,-(SP)	; SAVE THE REGISTERS
	MOV	R1,-(SP)	;
	MOV	R2,-(SP)	;
	MOVB	@#CRS+1,R0	; GET HW EXCEPTIONAL COND. FLAGS
	BICB	#^C<CR.EXC>,R0	; SEE IF ANY EXIST
	BNE	ISREX1		; DECLARE SIGNIFICANT EVENT IS SO
;
	MOV	@#CRB1,-(SP)	; SAVE CARD IMAGE BUFFER
	MOV	@#CRB2,R0	;FETCH COMPRESSED BUFFER.
	MOVB	CCOL,R1	; GET COLUMN COUNT
	BNE	10$		; NOT CC 1
	MOV	(SP),CCOL1	; SAVE, MAY BE SPECIAL CHARACTER.
10$:
	CMPB	R1,EOFSW		; PAST C/C FOR EOF
	BGE	20$		; .......
	CMP	(SP),#CREOF	; NO, CHECK FOR END-OF-FILE.
	BNE	20$		;
	DECB	EOFCNT		; DECREMENT COUNT
20$:
	MOV	IHBFPT,R2	; HANDLER'S BUFFER POINTER.
	.IF DF	BINARY		;
	BITB	#CR.BIN,CRSTAT	; BINARY READ?
	BEQ	PUTASC		; MOVE COMPRESSED DATA
	BIT	#1,R1		; ODD COLUMN
	BNE	25$		;
	ASL	(SP)		; NO, MOVE TO HIGH BYTE.
	ASL	(SP)		; .......
	ASL	(SP)		;
	ASL	(SP)		; .......
	CLRB	(R2)+		; MAKE NEXT INST. MOVE BYTE.
25$:
	BISB	1(SP),-1(R2)	; SET HIGH BYTE...
	MOVB	(SP),(R2)+	; THEN LOW.
	BR	ISREX2		; THEN EXIT
	.ENDC
;
;
PUTASC:
	MOVB	R0,(R2)+	; STORE COMPRESSED CARD IMAGE.
ISREX2:
	TST	(SP)+		; FIX THE STACK
	INCB	CCOL		; BUMP COLUMN COUNT.
	MOV	R2,IHBFPT	; SAVE POINTER.
	BR	ISREX0		; EXIT
ISREX1:
	BISB	R0,ISSTAT	; SET ISR STATUS
	CALL	SETIOD		; TAKE READER OFF INTERRUPTS, SET EFN.
ISREX0:
	MOV	(SP)+,R2	; RESTOR THE REGISTERS
	MOV	(SP)+,R1	; ......
	MOV	(SP)+,R0	; ......
CREXSR:	JMP	@#..INTX	; EXIT SERVICE ROUTINE
;

	.SBTTL	POWER RECOVERY AST SERVICE
;+
; POWER RECOVERY AST SERVICE ROUTINE:
;	THE FOLLOWING CODE IS ENTERED ON A POWER RECOVERY EVENT.
; THE ROUTINE CHECKS TO DETERMINE IF A READ IS UNDERWAY AND,
; IF SO, FAKES AN INTERRUPT WITH THE ERROR FLAG SET.
;-

PWRRCV:
	BIC	#CR.NBL,@#CRS		; TAKE READER OFF INTERRUPTS
	BIT	#CR.UND,CRSTAT		; READER BUSY ?
	BEQ	11$		; NO, EXIT
	BISB	#IH.ERR,ISSTAT		; YES, FAKE A HW ERROR.
9$:
	CALL	SETIOD			; DECLARE SIG. EVENT, SET EFN 3.
;
10$:	MOV	#EXAST,-(SP)		; EXIT AST DPB POINTER
	EMT	377		; ISSUE THE DIRECTIVE.
	HALT			; SHOULD NEVER GET HERE EITHER
11$:
	BIT	#CR.FLN,@#CRS	;*** 004 READER READY?
	BNE	12$		;*** 004 NO - SKIP OVER
	TST	RECOGN		;*** 004 ALREADY RECOGNIZED?
	BNE	12$		;*** 004 YES - SKIP OVER
	MOVB	@#CRS+1,ISSTAT	;*** 004 STATUS INTO BUFFER
	BR	9$		;*** 004 TO SET EVENT FLAG
12$:	BIS	#CR.NBL,@#CRS	;*** 004 ENABLE INTERRUPTS
	BR	10$		;*** 004 TO EXIT
;


;
; THE FOLLOWING ROUTINE REMOVES THE READER FROM THE INTERRUPT SYSTEM,
; AND CALLS '..STEF' TO SET THE I/O DONE EVENT FLAG AND DECLARE A SIGNI-
; FICANT EVENT. NOTE THAT THIS ROUTINE MUST BE RE-ENTRANT.
;
SETIOD:
	MOV	R0,-(SP)
	MOV	R1,-(SP)	; SAVE PERTINENT REGISTERS.
	CLR	@#CRS		; TAKE DEVICE OFF INTERRUPTS.
	MOV	#DV.DNE,R1	; GET EVENT FLAG.
	MOV	CRUIT1,R0	; AND PUD POINTER
	CALL	@#..STEF	; DECLARE A SIGNIFICANT EVENT, SET EF.
	MOV	(SP)+,R1	; RESTORE THE REGISTERS
	MOV	(SP)+, R0	;
	RETURN			; EXIT

	.SBTTL	START UP INPUT SPOOLER
SPLTST:
	BIT	#CR.FLN,@#CRS	;*** 004 READER READY?
	BNE	20$		;*** 004 NO THEN NO REQUEST FOR SPOOLER
	TST	RECOGN		;*** 004 SPOOLER ALREADY ACTIVE
	BNE	20$		;*** 004 IF SO BYPASS INVOKING SPOOLER
	MOV	CRUIT1,R0	;*** 004 PICK UP PUD ADDRESS
	BIT	#FD.OSP,U.C1(R0);*** 004 CHECK FOR DEVICE SET SPOOLED
	BEQ	20$		;*** 004 IF NOT - DO NOT INVOKE SPOOLER
	CLR	EOFDET		;+008 RESET THE EOF DETECTOR
	DIR$	#SENDOR		;***004 SEND REQUEST TO SPOOLER
	INC	RECOGN		;*** 004 INDICATE SPOOLER ACTIVE
	BCC	20$		;*** 004 CHECK FOR ERROR ON SEND/REQUEST
	MOV	#LPBUF2,BUFF1	;*** 004 COMPLAIN ABOUT BAD SEND/REQUEST
	MOV	#BUF2SZ,BUF1SZ	;*** 004 PUT IN THE BUFFER ADDRESS AND SIZE
	CLR	RECOGN		;*** 004 CLEAR RECOGNITION FLAG
	INC	NOTINS		;*** 004 INHIBIT SPLTST POLLS
	TST	(SP)+		;*** 004 FIX THE STACK
	JMP	CRER31		;*** 004 OUTPUT THE MESSAGE
20$:
	MOV	#MARKOF,-(SP)	;*** 004 CANCEL ANY POSSIBLE MARK
	EMT	377		;*** 004 TIME DIRECTIVE
	RETURN			;*** 004 BACK TO CALLER
SPLBUF:	.ASCII	/CR/		;*** 004 DEVICE NAME
	.WORD	.UNIT		;*** 004 UNIT NUMBER
ACTIVE:	.WORD	0		;*** 004 FLAG TO INDICATE READER ACTIVE
RECOGN:	.WORD	0		;*** 004 FLAG TO INDICATE SPOOLER ACTIVE
NOTINS:	.WORD	0		;*** 004 FLAG TO INDICATE SPOOLER NOT INSTALLED
EOFDET:	.WORD	0		;*** 004 FLAG TO INDICATE END OF FILE
				;*** 004 NOTE: REST OF BUFFER DEFAULTS
SENDOR:	SDRQ$	SPL...,,,,,SPLBUF;*** 004 SEND REQUEST DIRECTIVE
				;DO NOT DISTURB THE ORDER OF ABOVE CONSTANTS

	.SBTTL	DATA PARAMETER BLOCKS
;
;
; DPB'S
;
EXTDPB:	.BYTE	51.,1		; EXIT
;
EXAST:	.BYTE	115.,1		;EXIT AST.
;
CRMKTM:	.BYTE	23.,5		; MARKTIME DPB.
	.WORD	4		; EVENT FLAG 4
	.WORD	1		; ONE MINUTE
	.WORD	3		; UNITS = MINUTES
	.WORD	0		; NO AST
;
MARKOF:	.BYTE	27.,1		; CANCEL MARK-TIME.
;
;
PWRAST:	.BYTE	109.,2		; SET POWER RECOVERY AST.
	.WORD	PWRRCV		; AST ROUTINE ADDRESS.
;
WAIT4M:	.BYTE	43.,3		; WAIT-FOR MULTIPLE FLAGS.
	.WORD	0		; SET 0
WFORFL:	.WORD	DV.DNE!DV.MTM	; FLAGS 1-4 (EVENTUALLY).
;
WF234:	.BYTE	43.,3.		; WAIT-FOR FLAGS 2,3, 4
	.WORD	0		; SET 0
WFRXNM:	.WORD	DV.DNE!DV.MTM	; FLAGS 2,3,4 (AFTER INIT)
;
;
; SEND THIS MESSAGE IF DEVICE WAS OFFLINE BEFORE COMMANDED READ.
;
CRQIO:	QIO$	IO.WVB,LUN,0,,,,<LPBUF,BUFSZ,40>
;
LPBUF:	.ASCII	/*** CR0 -- NOT READY/
BUFSZ=.-LPBUF
;
	.EVEN
;
;
; SEND THIS MESSAGE IF LAST READ WAS BAD
CRQIO1:	QIO$	IO.WVB,LUN,0,,,,<LPBUF1,BUFSZ1,40>
	BUFF1=CRQIO1+Q.IOPL
	BUF1SZ=CRQIO1+Q.IOPL+2
;
;
LPBUF1:	.ASCII	/*** CR0 -- READ FAILURE, CHECK HARDWARE STATUS/
BUFSZ1=.-LPBUF1
	.EVEN
LPBUF2:	.ASCII	/*** CR0 -- SPL TASK NOT INSTALLED/
	BUF2SZ=.-LPBUF2
	.EVEN

	.SBTTL	CONVERSION TABLES
	.IF	NDF,NOASCI
	;GCE/ RCA******
	.PSECT	$$TTAS,OVR
ASCTBL::
	;BYTE TABLE TO TRANSLATE CARD CODES TO ASCII.
	.BYTE	40,61,62,63,64,65,66,67	;0-7
	.BYTE	70,134,':,'#,'@,'','=,'"	;10-17
	.BYTE	71,0,26,0,0,36,0,4	;20-27
	.BYTE	0,0,0,0,24,25,0,32	;30-37
	.BYTE	60,57,'S,'T,'U,'V,'W,'X	;40-47
	.BYTE	'Y,0,'\,',,'%,'_,'>,'?	;50-57
	.BYTE	'Z,0,34,0,0,12,27,33	;60-67
	.BYTE	0,0,0,0,0,5,6,7		;70-77
	.BYTE	'-,'J,'K,'L,'M,'N,'O,'P	;100-107
	.BYTE	'Q,0,'],'$,'*,'),';,'^	;110-117
	.BYTE	'R,21,22,0,0,0,10,0	;120-127
	.BYTE	30,0,0,0,0,0,0,0	;130-137
	.BYTE	175,176,163,164,165,166,167,170	;140-147
	.BYTE	171,0,0,0,0,0,0,0	;150-157
	.BYTE	172,0,0,0,0,0,0,0	;160-167
	.BYTE	0,0,0,0,0,0,0,0		;170-177
	.BYTE	'&,'A,'B,'C,'D,'E,'F,'G	;200-207
	.BYTE	'H,0,'[,'.,'<,'(,'+,'!	;210-217
	.BYTE	'I,1,2,3,0,11,0,177	;220-227
	.BYTE	0,0,0,13,14,15,16,17	;230-237
	.BYTE	173,141,142,143,144,145,146,147	;240-247
	.BYTE	150,0,0,0,0,0,0,0	;250-257
	.BYTE	151,0,0,0,0,0,0,0	;260-267
	.BYTE	0,0,0,0,0,0,0,0		;270-277
	.BYTE	174,152,153,154,155,156,157,160	;300-307
	.BYTE	161,0,0,0,0,0,0,0	;310-317
	.BYTE	162,0,0,0,0,0,0,0	;320-327
	.BYTE	0,20,0,0,0,0,0,0	;330-337
	.BYTE	0,0,0,0,0,0,0,0	;340-347
	.BYTE	0,0,0,0,0,0,0,0		;350-357
	.BYTE	0,0,0,0,0,0,0,0		;360-367
	.BYTE	0,0,0,0,0,0,0,0		;370-377
	.EVEN
	.WORD	0,0	;JUST IN CASE...
	;GCE/ RCA******
	.ENDC

	.PSECT	$$TT29,OVR

.TT029::			;++002 REF. LABEL
;
; NON-PARITY ASCII CONVERSION TABLE FOR 029 PUNCH
	.IF NDF	ONLY26
	.BYTE	40		;++002 SPACE
	.BYTE 61		; 1
	.BYTE 62		; 2
	.BYTE 63		; 3
	.BYTE 64		; 4
	.BYTE 65		; 5
	.BYTE 66		; 6
	.BYTE 67		; 7
	.BYTE 70		; 8
	.BYTE 40		; EMPTY
	.BYTE 72		; :
	.BYTE 43		; #
	.BYTE 100		; @
	.BYTE 47		; '
	.BYTE 75		; =
	.BYTE 42		; "
	.BYTE 71		; 9
;
	.BYTE 60		; 0
	.BYTE 57		; /
	.BYTE 123		; S
	.BYTE 124		; T
	.BYTE 125		; U
	.BYTE 126		; V
	.BYTE 127		; W
	.BYTE 130		; X
	.BYTE 131		; Y
	.BYTE 40		; EMPTY
	.BYTE 134		; \
	.BYTE 54		; ,
	.BYTE 45		; %
	.BYTE 137		; _
	.BYTE 76		; >
	.BYTE 77		; ?
	.BYTE 132		; Z
;

	.BYTE 55		; -
	.BYTE 112		; J
	.BYTE 113		; K
	.BYTE 114		; L
	.BYTE 115		; M
	.BYTE 116		; N
	.BYTE 117		; O
	.BYTE 120		; P
	.BYTE 121		; Q
	.BYTE 40		; EMPTY
	.BYTE 135		; ]
	.BYTE 44		; $
	.BYTE 52		; *
	.BYTE 51		; )
	.BYTE 73		; ;
	.BYTE 136		; ^
	.BYTE 122		; R
;
	.BYTE 46		; &
	.BYTE 101		; A
	.BYTE 102		; B
	.BYTE 103		; C
	.BYTE 104		; D
	.BYTE 105		; E
	.BYTE 106		; F
	.BYTE 107		; G
	.BYTE 110		; H
	.BYTE 40		; EMPTY
	.BYTE 133		; [
	.BYTE 56		; .
	.BYTE 74		; <
	.BYTE 50		; (
	.BYTE 53		; +
	.BYTE 41		; !
	.BYTE 111		; I
	.BYTE 173		; LEFT CURLY BRACKET
	.BYTE 175		; RIGHT CURLY BRACKET
	.ENDC
	.EVEN

	.PSECT	$$TT30

.TT29L::

	.PSECT

; NON-PARITY ASCII CONVERSION TABLE FOR 026 PUNCH:

	.PSECT	$$TT26,OVR

.TT026::			;++002 REF LABEL

	.IF NDF	ONLY29

	.BYTE	40		;++002 SPACE
	.BYTE 61		; 1
	.BYTE 62		; 2
	.BYTE 63		; 3
	.BYTE 64		; 4
	.BYTE 65		; 5
	.BYTE 66		; 6
	.BYTE 67		; 7
	.BYTE 70		; 8
	.BYTE 40		; EMPTY
	.BYTE 137		; _
	.BYTE 75		; =
	.BYTE 100		; @
	.BYTE 136		; ^
	.BYTE 47		; '
	.BYTE 134		; \
	.BYTE 71		; 9
;
	.BYTE 60		; 0
	.BYTE 57		; /
	.BYTE 123		; S
	.BYTE 124		; T
	.BYTE 125		; U
	.BYTE 126		; V
	.BYTE 127		; W
	.BYTE 130		; X
	.BYTE 131		; Y
	.BYTE 40		; EMPTY
	.BYTE 73		; ;
	.BYTE 54		; ,
	.BYTE 50		; (
	.BYTE 42		; "
	.BYTE 43		; #
	.BYTE 45		; %
	.BYTE 132		; Z
;

	.BYTE 55		; -
	.BYTE 112		; J
	.BYTE 113		; K
	.BYTE 114		; L
	.BYTE 115		; M
	.BYTE 116		; N
	.BYTE 117		; O
	.BYTE 120		; P
	.BYTE 121		; Q
	.BYTE 40		; EMPTY
	.BYTE 72		; :
	.BYTE 44		; $
	.BYTE 52		; *
	.BYTE 133		; [
	.BYTE 76		; >
	.BYTE 46		; &
	.BYTE 122		; R
;
	.BYTE 53		; +
	.BYTE 101		; A
	.BYTE 102		; B
	.BYTE 103		; C
	.BYTE 104		; D
	.BYTE 105		; E
	.BYTE 106		; F
	.BYTE 107		; G
	.BYTE 110		; H
	.BYTE 40		; EMPTY
	.BYTE 77		; ?
	.BYTE 56		; .
	.BYTE 51		; )
	.BYTE 135		; ]
	.BYTE 74		; <
	.BYTE 41		; !
	.BYTE 111		; I
	.BYTE 173		; LEFT CURLY BRACKET
	.BYTE 175		; RIGHT CURLY BRACKET
	.ENDC

	.EVEN

	.PSECT	$$TT27
.TT26L::

	.PSECT



	.PSECT	$$CRBF,OVR

	.EVEN
;  INTERNAL BUFFER
	.IF NDF	BINARY
.CRBUF::
	.BLKB	CRSIZE
	.ENDC
;
	.IF DF	BINARY
.CRBUF::
	.BLKB	CRSIZB
	.ENDC
	.WORD	0		;+009 EXTRA WORD TO ACCOMODATE 81 OR
				;+009 82 BYTE TRANSFERS FROM THE DEVICE
	.EVEN

	.PSECT

	.END	CRINIT