.NLIST	TOC
	.TITLE	NULACP - NULL ACP
	.SBTTL	NULACP - TITLE PAGE
	.IDENT	/V02.00/
;
; ************************************************************************
;                                                                        *
; 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.  *
;									 *
; ************************************************************************
;
; NULL ACP TASK. THIS ACP DOES NOTHING USEFUL. IT MEARLY DEMONSTRATES SOME
; OF THE BASIC FEATURES OF ACP'S AND CAN SERVE AS A BASIS FOR IMPLEMENTATION
; OF A USER-WRITTEN ACP.
;
; VERSION:	V02.00
;
; AUTHOR:	R.W. STAMERJOHN	MAPC	03-DEC-79
;
; MODIFICATION HISTORY:
;
;	V01.00	RWS	03-DEC-79	INITIAL VERSION
;
;	V02.00	RWS	07-APR-80	UPDATE TO MATCH ACP MANUAL

	.SBTTL	NULACP - DECLARATIONS
	.DSABL	GBL
;
; MACRO LIBRARY CALLS:
;
;	SYMBOLIC DEFINITION.
;
	.MCALL	PKTDF$			;DEFINE I/O PACKET OFFSETS
	PKTDF$
	.MCALL	TCBDF$			;DEFINE TCB OFFSETS
	TCBDF$
	.MCALL	UCBDF$			;DEFINE UCB OFFSETS
	UCBDF$
;
;	DIRECTIVES.
;
	.MCALL	EXIT$S			;EXIT TASK
	.MCALL	QIOW$S			;ISSUE I/O AND WAIT
;
;	OTHER MACROS.
;
	.MCALL	CALLR			;CALL ROUTINE AND EXIT
;
; GLOBAL DECLARATIONS:
;
;	MODULE ENTRY POINTS.
;
	.GLOBL	NULACP			;TASK ENTRY POINT
;
; GLOBAL REFERENCES:
;
;	EXECUTIVE REFERENCES.
;
	.GLOBL	$ALOCB			;(CORAL) ALLOCATE CORE BLOCK
	.GLOBL	$BLXIO			;(BFCTL)  TRANSFER BLOCK
	.GLOBL	$DEACB			;(CORAL)  DEALLOCATE CORE BLOCK
	.GLOBL	$IOFIN			;(IOSUB)  FINISH I/O REQUESTS
	.GLOBL	$QINSF			;(QUEUE)  INSERT ENTRY IN QUEUE
	.GLOBL	$QRMVF			;(QUEUE)  REMOVE ENTRY FROM QUEUE
	.GLOBL	$RELOC			;(IOSUB)  RELOCATE BUFFER
	.GLOBL	$STPCT			;(REQSB)  STOP CURRENT TASK
	.GLOBL	$TKTCB			;(SYSCM)  CURRENT TASK TCB
;
;	OTHER REFERENCES
;
	.GLOBL	IO.WVB			;WRITE VIRTUAL BLOCK
	.GLOBL	IS.SUC			;SUCCESS FUNCTION RETURN
	.GLOBL	IE.ABO			;ABORTED FUNCTION RETURN
	.GLOBL	IE.IFC			;ILLEGAL FUNCTION RETURN
	.GLOBL	IE.NDR			;NO POOL FUNCTION RETURN
;
; LOCAL SYMBOLS:
;
TTYLUN=1				;TTY OUTPUT LUN
TTYFLG=1				;TTY OUTPUT EFN
;
; LOCAL (RO) DATA:
;
;	FUNCTION DISPATCH TABLE
;
DSPTBL:	.WORD	IO.MOU,ACPMOU		;MOUNT DEVICE
	.WORD	IO.DMO,ACPDMO		;DISMOUNT DEVICE
	.WORD	IO.CLN,ACPABO		;ABORT  PROCESS
	.WORD	IX.CRE,ACPCRE		;CREATE PROCESS
	.WORD	IX.CLO,ACPCLO		;CLOSE  PROCESS
	.WORD	IX.PUT,ACPPUT		;OUTPUT TO PROCESS
	.WORD	IX.GET,ACPGET		;INPUT FROM PROCESS
	.WORD	IX.CTL,ACPCTL		;PROCESS CONTROL
	.WORD	0,ACPDON		;EOT
;
;	MESSAGES.
;
	.NLIST	BEX
CREMSG:	.ASCIZ	/IX.CRE RECEIVED/
CLOMSG:	.ASCIZ	/IX.CLO RECEIVED/
PUTMSG:	.ASCIZ	/IX.PUT RECEIVED/
GETMSG:	.ASCIZ	/IX.PUT RECEIVED/
CTLMSG:	.ASCIZ	/IX.CTL RECEIVED/
ABOMSG:	.ASCIZ	/IO.CLN RECEIVED/
MOUMSG:	.ASCIZ	/IO.MOU RECEIVED/
DMOMSG:	.ASCIZ	/IO.DMO RECEIVED/
MDMMSG:	.ASCIZ	/DEVICE DISMOUNT COMPLETE/
INIMSG:	.ASCIZ	/NULACP TASK STARTUP/
XITMSG:	.ASCIZ	/NULACP TASK EXIT/
QBFMSG:	.ASCIZ	/QUICK BROWN FOX/
QBFSIZ=.-QBFMSG
	.LIST	BEX
	.EVEN
;
; LOCAL (RW) DATA:
;
ENABLE:	.WORD	0			;MOUNTED VOLUME COUNT
BUFFER:	.BLKB	132.			;GENERAL PURPOSE BUFFER
BUFSIZ=.-BUFFER

	.SBTTL	NULACP * TASK ENTRY
;
;+
; THIS ROUTINE IS THE MAIN LOOP FOR THE ACP. THE RECEIVE QUEUE IS
; CHECKED. IF AN ENTRY IS FOUND, THE APPROPRIATE SERVICE ROUTINE IS
; CALLED, OTHERWISE, THE TASK IS PUT TO SLEEP.
;
; INPUT:
;
;	STARTED AT TASK ENTRY. THE LOOP IS REPEATED WHENEVER THE ACP
;	IS WAKEN FROM THE 'STOP' STATE OR AN INTERNAL PROCESS REACHES
;	A STOPPING POINT.
;
; OUTPUT:
;
;	WHEN WORK IS DEQUEUED, THE CORRECT PROCESSING ROUTINE IS CALLED
;	WITH THE FOLLOWING REGISTERS:
;
;		R3 = ADDRESS OF DEQUEUED ENTRY
;		R5 = UCB ADDRESS
;
; NOTES:
;
;	WHEN THE ACP TASK IS STARTED, THE INITIALIZATION ROUTINE IS
;	CALLED. THIS ROUTINE RETURNS ONLY IF INITIALIZATION SUCCEEDS,
;	OTHERWISE IT EXITS THE TASK. 
;
;	WHEN A PROCESS FINISHES, A CHECK IS MADE TO SEE IF THE UNIT IS
;	BEING DISMOUNTED. IF SO, THE DISMOUNT PROCESSOR IS CALLED.
;
;	A PROCESSING ROUTINE MUST PRESERVE R5 (UCB ADDRESS).
;
; REGISTERS:	USES N.A.	SAVES N.A.
;
; CALLS:	ACPINI,$QRMVF,$STPCT,ACPMDM,PROCESSING ROUTINE
;-
;
NULACP::				;REF. LABEL
;
; GO PERFORM THE INITIALZATION PROCESS.
;
	CALL	ACPINI			;INITIALIZE ACP
;
; ENTER SYSTEM STATE AND CHECK RECEIVE QUEUE.
;
1000$:	CLR	R1			;MARK NOTHING DEQUED
	SYSTEM	2000$			;;ENTER SYSTEM STATE
	MOV	$TKTCB,R0		;;GET OUR TCB ADDRESS
	ADD	#T.RCVL,R0		;;POINT TO RECEIVE QUEUE LISTHEAD
	CALL	$QRMVF			;;REMOVE QUEUE ENTRY
	BCS	1100$			;; IF CS - NO ENTRY, STOP
	MOV	R1,S.R1(SP)		;;RETURN PACKET ADDRESS
	RETURN				;;RETURN TO TASK STATE
;
; STOP TASK. WHEN WOKE, RETURN TO TASK STATE.
;
1100$:	CALLR	$STPCT			;;STOP CURRENT TASK (US)
;
; IF NO ENTRY DEQUED,  CHECK FOR DISMOUNT.
;
2000$:	MOV	R1,R3			;WAS ENTRY FOUND?
	BEQ	1000$			; IF EQ - NO, CONTINUE LOOP
;
; DISPATCH ON I/O FUNCTION AND CALL PROCESSING ROUTINE.
;
	MOV	I.UCB(R3),R5		;GET UCB ADDRESS
	MOV	#IE.IFC,R0		;PRESET IE.IFC ERROR
	MOV	#DSPTBL,R1		;GET PROCESSING TABLE
3000$:	TST	(R1)			;ARE WE AT END OF TABLE?
	BEQ	3100$			; IF EQ - YES, ILLEGAL FUNCTION
	CMP	(R1),I.FCN(R3)		;IS THIS CORRECT ENTRY?
	BEQ	3100$			; IF EQ - YES, PROCESS FUNCTION
	ADD	#4,R1			;BUMP TABLE ADDRESS
	BR	3000$			;CHECK NEXT ENTRY
3100$:	CALL	@2(R1)			;CALL PROCESSING ROUTINE
;
; WHEN FINISHED, CHECK FOR DISMOUNT PENDING.
;
4000$:	BITB	#US.MDM,U.STS(R5)	;IS A DISMOUNT PENDING?
	BEQ	1000$			; IF EQ - NO, LOOP THROUGH QUEUES
	CALL	ACPMDM			;TRY TO COMPLETE DISMOUNT
	BR	1000$			; NO LUCK - LOOP THROUGH QUEUE

	.SBTTL	NULINI * ACP INITIALIZATION
;
;+
; THIS ROUTINE INITIALIZES THE ACP. ALL THIS ACP REQUIRES IS THE
; STARTUP MESSAGE TO BE OUTPUT.
;
; INPUT:
;
;	CALLED AT TASK ENTRY.
;
; OUTPUT:
;
;	MESSAGE OUTPUT TO EFFECT TASK STARTED.
;
; REGISTERS:	USES	R0-R5	SAVES	R0-R5
;
; CALLS:	OUTASZ
;-
;
ACPINI:	MOV	#INIMSG,R1		;GET STARTUP MESSAGE
	CALL	OUTASZ			;OUTPUT MESSAGE
	CLR	ENABLE			;CLEAR ENABLED COUNT
	RETURN				;RETURN TO CALLER

	.SBTTL	ACPCRE * IX.CRE PROCESSING
;
;+
; THIS ROUTINE PROCESS THE IX.CRE FUNCTION. A WINDOW IS CREATED,
; THE PROCESS IS COUNTED, AND THE FUNCTION RETURNED.
;
; INPUT:
;
;	R3 = I/O PACKET ADDRESS
;	R5 = UCB ADDRESS
;
; OUTPUT:
;
;	WINDOW CREATED AND PACKET RETURNED.
;
; NOTES:
;
;	AN IX.CRE FUNCTION HAS THE FOLLOWING USER I/O PARAMETERS.
;
;		P1 - ZERO (0)
;		P2 - ZERO (0)
;		P3 - ZERO (0)
;		P4 - ZERO (0)
;		P5 - ACCESS PARAMETER (0-3)
;		P6 - ZERO (0)
;
;	THE FORMAT OF THE IX.CRE PARAMETERS WHEN THE PACKET IS DEQUEUED
;	BY THE ACP IS AS FOLLOWS ( THE REFORMATING IS DONE BY THE NULL
;	ACP DEVICE DRIVER):
;
;		I.PRM+00 - ZERO (0)
;		I.PRM+02 - ZERO (0)
;		I.PRM+04 - ZERO (0)
;		I.PRM+06 - ZERO (0)
;		I.PRM+10 - ZERO (0)
;		I.PRM+12 - ZERO (0)
;		I.PRM+14 - ACCESS PARAMETER
;		I.PRM+16 - ZERO (0)
;
; REGISTERS:	USES R0-R5	SAVES R5
;
; CALLS:	ACPDON,OUTASZ
;-
;
ACPCRE:	MOV	#CREMSG,R1		;GET MESSAGE ADDRESS
	CALL	OUTASZ			;OUTPUT MESSAGE
;
; CREATE A WINDOW AND STORE ADDRESS.
;
	MOV	#W$SIZE,R1		;GET SIZE OF WINDOW
	CLR	R0			;CLEAR WINDOW ADDRESS
	SYSTEM	2000$			;;ENTER SYSTEM STATE
	CALL	$ALOCB			;;ALLOCATE CORE BLOCK
	BCS	1000$			;; IC CS - NO POOL
	MOV	R0,S.R0(SP)		;;RETURN BLOCK ADDRESS
1000$:	RETURN				;;EXIT SYSTEM STATE

2000$:	TST	R0			;WAS BLOCK ALLOCATED
	BEQ	3010$			; IF EQ - NO, RETURN IE.NDR
	BIS	R0,@I.LN2(R3)		;STORE WINDOW ADDRESS
	MOV	I.PRM+14(R3),W$PRIV(R0)	;STORE ACCESS PARAMETERS
	INC	@U.VCB(R5)			;INCREMENT PROCESS COUNT
;
; SET STATUS AND RETURN I/O FUNCTION.
;
	MOV	#IS.SUC,R0		;SET SUCCESS
	BR	3020$			; CONTINUE
3010$:	MOV	#IE.NDR,R0		;SET IE.NDR ERROR
3020$:	CALLR	ACPDON			;FINISH PACKET AND RETURN

	.SBTTL	ACPCLO * IX.CLO PROCESSING
;
;+
; THIS ROUTINE PROCESS THE IX.CLO FUNCTION. THE WINDOW IS DESTROYED
; THE PROCESS COUNT IS DECREMENTED, AND THE FUNCTION RETURNED.
;
; INPUT:
;
;	R3 = I/O PACKET ADDRESS
;	R5 = UCB ADDRESS
;
; OUTPUT:
;
;	WINDOW DESTROYED AND PACKET RETURNED.
;
; NOTES:
;
;	AN IX.CLO FUNCTION HAS THE FOLLOWING I/O PARAMETERS.
;
;		P1 - ZERO (0)
;		P2 - ZERO (0)
;		P3 - ZERO (0)
;		P4 - ZERO (0)
;		P5 - ZERO (0)
;		P6 - ZERO (0)
;
;	THE FORMAT OF THE IX.CLO PARAMETERS WHEN THE PACKET IS DEQUEUED
;	BY THE ACP IS AS FOLLOWS ( THE REFORMATING IS DONE BY THE NULL
;	ACP DEVICE DRIVER):
;
;		I.PRM+00 - ZERO (0)
;		I.PRM+02 - ZERO (0)
;		I.PRM+04 - ZERO (0)
;		I.PRM+06 - ZERO (0)
;		I.PRM+10 - ZERO (0)
;		I.PRM+12 - ZERO (0)
;		I.PRM+14 - ZERO (0)
;		I.PRM+16 - ZERO (0)
;
; REGISTERS:	USES R0-R5	SAVES R5
;
; CALLS:	ACPDON,OUTASZ
;-
;
ACPCLO:	MOV	#CLOMSG,R1		;GET MESSAGE ADDRESS
	CALL	OUTASZ			;OUTPUT MESSAGE
;
; RETURN WINDOW AND ZERO ADDRESS.
;
	MOV	#W$SIZE,R1		;GET SIZE OF WINDOW
	MOV	@I.LN2(R3),R0		;GET WINDOW ADDRESS
	BIC	#1,R0			;CLEAR LOCK BIT
	SYSTEM	1000$			;;ENTER SYSTEM STATE
	CALLR	$DEACB			;;DEALLOCATE CORE BLOCK

1000$:	BIC	#177776,@I.LN2(R3)	;CLEAR WINDOW ADDRESS
	DEC	@U.VCB(R5)			;DECREMENT PROCESS COUNT

;
; SET STATUS AND RETURN I/O FUNCTION.
;
	MOV	#IS.SUC,R0		;SET SUCCESS
	CALLR	ACPDON			;FINISH PACKET AND RETURN

	.SBTTL	ACPPUT * IX.PUT PROCESSING
;
;+
; THIS ROUTINE PROCESS THE IX.PUT FUNCTION. THE USER DATA BLOCK
; IS OUTPUT TO THE TERMINAL.
;
; INPUT:
;
;	R3 = I/O PACKET ADDRESS
;	R5 = UCB ADDRESS
;
; OUTPUT:
;
;	USER DATA BUFFER OUTPUT.
;
; NOTES:
;
;	AN IX.PUT FUNCTION HAS THE FOLLOWING I/O PARAMETERS.
;
;		P1 - OUTPUT BUFFER ADDRESS
;		P2 - OUTPUT BUFFER SIZE (BYTES)
;		P3 - ZERO (0)
;		P4 - ZERO (0)
;		P5 - ZERO (0)
;		P6 - ZERO (0)
;
;	THE FORMAT OF THE IX.PUT PARAMETERS WHEN THE PACKET IS DEQUEUED
;	BY THE ACP IS AS FOLLOWS ( THE REFORMATING IS DONE BY THE NULL
;	ACP DEVICE DRIVER):
;
;		I.PRM+00 - OUTPUT BUFFER MAPPING BIAS
;		I.PRM+02 - OUTPUT BUFFER APR6 DISPLACEMENT
;		I.PRM+04 - OUTPUT BUFFER SIZE (BYTES)
;		I.PRM+06 - ZERO (0)
;		I.PRM+10 - ZERO (0)
;		I.PRM+12 - ZERO (0)
;		I.PRM+14 - ZERO (0)
;		I.PRM+16 - ZERO (0)
;
; REGISTERS:	USES R0-R5	SAVES R5
;
; CALLS:	ACPALT,OUTASZ,OUTASC,GETBLK
;-
;
ACPPUT:	MOV	#PUTMSG,R1		;GET MESSAGE ADDRESS
	CALL	OUTASZ			;OUTPUT MESSAGE
;
; COPY USER DATA BUFFER AND OUTPUT TO TERMINAL.
;
	MOV	I.PRM+4(R3),R0		;GET BUFFER SIZE
	CMP	#BUFSIZ,R0		;IS BUFFER TOO LARGE?
	BHIS	1000$			; IF HIS - NO
	MOV	#BUFSIZ,R0		;SET MAXIMUM BUFFER
1000$:	MOV	R0,-(SP)		;SAVE SIZE
	MOV	#BUFFER,R1		;SET BUFFER ADDRESS
	MOV	R3,R2			;COPY PACKET ADDRESS
	ADD	#I.PRM,R2		;GET ADDRESS OF DOUBLEWORD
	CALL	GETBLK			;GET USER BUFFER
	CALL	OUTASC			;OUTPUT TO TERMINAL
;
; SET SUCCESS AND RETURN PACKET
;
	MOV	#IS.SUC,R0		;SET SUCCESS FUNCTION
	MOV	(SP)+,R1		;SET SIZE OF DATA TRANSFER
	CALLR	ACPALT			;FINISH PACKET AND RETURN

	.SBTTL	ACPGET * IX.GET PROCESSING
;
;+
; THIS ROUTINE PROCESS THE IX.GET FUNCTION. THE USER DATA BLOCK
; IS FILLED WITH QUICK BROWN FOX MESSAGE.
;
; INPUT:
;
;	R3 = I/O PACKET ADDRESS
;	R5 = UCB ADDRESS
;
; OUTPUT:
;
;	USER DATA BUFFER OUTPUT.
;
; NOTES:
;
;	AN IX.GET FUNCTION HAS THE FOLLOWING I/O PARAMETERS.
;
;		P1 - ZERO (0)
;		P2 - ZERO (0)
;		P3 - INPUT BUFFER ADDRESS
;		P4 - INPUT BUFFER SIZE (BYTES)
;		P5 - ZERO (0)
;		P6 - ZERO (0)
;
;	THE FORMAT OF THE IX.GET PARAMETERS WHEN THE PACKET IS DEQUEUED
;	BY THE ACP IS AS FOLLOWS ( THE REFORMATING IS DONE BY THE NULL
;	ACP DEVICE DRIVER):
;
;		I.PRM+00 - ZERO (0)
;		I.PRM+02 - ZERO (0)
;		I.PRM+04 - ZERO (0)
;		I.PRM+06 - INPUT BUFFER MAPPING BIAS
;		I.PRM+10 - INPUT BUFFER APR6 DISPLACEMENT
;		I.PRM+12 - INPUT BUFFER SIZE (BYTES)
;		I.PRM+14 - ZERO (0)
;		I.PRM+16 - ZERO (0)
;
; REGISTERS:	USES R0-R5	SAVES R5
;
; CALLS:	ACPALT,OUTASZ,RTNBLK
;-
;
ACPGET:	MOV	#GETMSG,R1		;GET MESSAGE ADDRESS
	CALL	OUTASZ			;OUTPUT MESSAGE
;
; COPY QUICK BROWN FOX MESSAGE TO USER BUFFER.
;
	MOV	I.PRM+12(R3),R0		;GET BUFFER SIZE
	CMP	#QBFSIZ,R0		;IS BUFFER TOO LARGE?
	BHIS	1000$			; IF HIS - NO
	MOV	#QBFSIZ,R0		;SET MAXIMUM BUFFER
1000$:	MOV	R0,-(SP)		;SAVE SIZE
	MOV	#QBFMSG,R1		;SET BUFFER ADDRESS
	MOV	R3,R2			;COPY PACKET ADDRESS
	ADD	#I.PRM+6,R2		;GET ADDRESS OF DOUBLEWORD
	CALL	RTNBLK			;SET USER BUFFER
;
; SET SUCCESS AND RETURN PACKET
;
	MOV	#IS.SUC,R0		;SET SUCCESS FUNCTION
	MOV	(SP)+,R1		;SET SECONDARY STATUS
	CALLR	ACPALT			;FINISH PACKET AND RETURN

	.SBTTL	ACPCTL - IX.CTL PROCESSING
;
;+
; THIS ROUTINE PROCESS THE IX.CTL FUNCTION. THIS FUNCTION CHANGES THE
; ACCESS VALUE IN THE WINDOW.
;
; INPUT:
;
;	R3 = I/O PACKET ADDRESS
;	R5 = UCB ADDRESS
;
; OUTPUT:
;
;	ACCESS PARAMETER CHANGED
;
; NOTES:
;
;	AN IX.CTL FUNCTION HAS THE FOLLOWING I/O PARAMETERS.
;
;		P1 - ZERO (0)
;		P2 - ZERO (0)
;		P3 - ZERO (0)
;		P4 - ZERO (0)
;		P5 - ACCESS PARAMETER (0-3)
;		P6 - ZERO (0)
;
;	THE FORMAT OF THE IX.CTL PARAMETERS WHEN THE PACKET IS DEQUEUED
;	BY THE ACP IS AS FOLLOWS ( THE REFORMATING IS DONE BY THE NULL
;	ACP DEVICE DRIVER):
;
;		I.PRM+00 - ZERO (0)
;		I.PRM+02 - ZERO (0)
;		I.PRM+04 - ZERO (0)
;		I.PRM+06 - ZERO (0)
;		I.PRM+10 - ZERO (0)
;		I.PRM+12 - ZERO (0)
;		I.PRM+14 - ACCESS PARAMETER
;		I.PRM+16 - ZERO (0)
;
; REGISTERS:	USES R0-R5	SAVES R5
;
; CALLS:	ACPDON,OUTASZ
;-
;
ACPCTL:	MOV	#CTLMSG,R1		;GET MESSAGE ADDRESS
	CALL	OUTASZ			;OUTPUT MESSAGE
;
; SET NEW ACCESS FLAGS IN WINDOW BLOCK
;
	MOV	@I.LN2(R3),R0		;GET WINDOW BLOCK ADDRESS
	BIC	#1,R0			;CLEAR THE LOCK BIT
	MOV	I.PRM+14(R3),W$PRIV(R0)	;SET ACCESS FLAGS
;
; SET SUCCESS AND RETURN PACKET
;
	MOV	#IS.SUC,R0		;SET SUCCESS FUNCTION
	CALLR	ACPDON			;FINISH PACKET AND RETURN

	.SBTTL	ACPABO * IO.CLN PROCESSING
;
;+
; THIS ROUTINE PROCESS THE IO.CLN FUNCTION. THE WINDOW IS DESTROYED
; THE PROCESS COUNT IS DECREMENTED, AND THE FUNCTION RETURNED.
;
; INPUT:
;
;	R3 = I/O PACKET ADDRESS
;	R5 = UCB ADDRESS
;
; OUTPUT:
;
;	WINDOW DESTROYED AND PACKET RETURNED.
;
; REGISTERS:	USES R0-R5	SAVES R5
;
; CALLS:	ACPDON,OUTASZ
;-
;
ACPABO:	MOV	#ABOMSG,R1		;GET MESSAGE ADDRESS
	CALL	OUTASZ			;OUTPUT MESSAGE
;
; RETURN WINDOW AND ZERO ADDRESS.
;
	MOV	#W$SIZE,R1		;GET SIZE OF WINDOW
	MOV	@I.LN2(R3),R0		;GET WINDOW ADDRESS
	BIC	#1,R0			;CLEAR LOCK BIT
	SYSTEM	1000$			;;ENTER SYSTEM STATE
	CALL	$DEACB			;;DEALLOCATE CORE BLOCK
	RETURN				;;EXIT SYSTEM STATE

1000$:	BIC	#177776,@I.LN2(R3)	;CLEAR WINDOW ADDRESS
	DEC	@U.VCB(R5)			;DECREMENT PROCESS COUNT

;
; SET STATUS AND RETURN I/O FUNCTION.
;
	MOV	#IS.SUC,R0		;SET SUCCESS
	CALLR	ACPDON			;FINISH PACKET AND RETURN

	.SBTTL	ACPMOU * IO.MOU PROCESSING
;
;+
; THIS ROUTINE PROCESSES THE IO.MOU FUNCTION. THE ROUTINE EXPECTS THE
; FUNCTION TO BE ISSUED BY THE SAMPLE ...ENA TASK.
;
; INPUT:
;
;	R3 = I/O PACKET ADDRESS
;	R5 = UCB ADDRESS
;
; OUTPUT:
;
;	UNIT ENABLED FOR ACP I/O.
;
; NOTES:
;
;	AN IO.MOU FUNCTION IS CONSTRUCTED BY THE ...ENA TASK. THE
;	FOLLOWING I/O PARAMETERS ARE ASSUMED.
;
;		I.PRM+00 - ADDRESS OF SYSTEM BUFFER WITH OPTION STRING
;		I.PRM+02 - SIZE OF SYSTEM BUFFER
;
; REGISTERS:	USES R0-R5	SAVES NONE
;
; CALLS:	$IOFIN,$DEACB,OUTASC,OUTASZ,ACPDON
;-
ACPMOU:					;REF. LABEL
;
; CHECK THAT ACP IS BEING STARTED PROPERLY, I.E. BY ...ENA
;
	TST	R5			;WAS UCB SPECIFIED?
	BEQ	2998$			; IF EQ - NO UCB, ERROR
	TST	U.VCB(R5)		;IS A VCB SPECIFIED?
	BNE	3000$			; IF NE - OK, CONTINUE
;
; DECLARE FATAL ACP ERROR AND EXIT.
;
2998$:	MOV	#IE.ABO,R0		;SET ERROR CODE
	CLR	R1			;CLEAR SECONDARY CODE
	SYSTEM	2999$			;;ENTER SYSTEM STATE
	CALL	$IOFIN			;;RETURN I/O PACKET
2999$:	RETURN				;;EXIT SYSTEM STATE AND ROUTINE
;
; ENABLE DEVICE.
;
3000$:	MOV	#MOUMSG,R1		;GET MOUNT MESSAGE
	CALL	OUTASZ			;OUTPUT MESSAGE
	MOV	I.PRM+0(R3),R1		;IS THERE A PARAMETER BUFFER
	BEQ	3100$			; IF EQ - NO, SKIP
	MOV	I.PRM+2(R3),R0		;GET SIZE OF BUFFER
	CALL	OUTASC			;OUTPUT ASCII TEXT

	MOV	I.PRM+0(R3),R0		;GET PARAMETER BUFFER ADDRESS
	MOV	I.PRM+2(R3),R1		;GET SIZE OF BUFFER
	SYSTEM	3100$			;;ENTER SYSTEM STATE
	CALLR	$DEACB			;;DEALLOCATE BUFFER

3100$:	BICB	#US.MNT,U.STS(R5)	;MARK VOLUME MOUNTED
	INC	ENABLE			;COUNT VOLUME MOUNTED
	MOV	#IS.SUC,R0		;SET SUCCESS
	CALLR	ACPDON			;FINISH FUNCTION AND RETURN

	.SBTTL	ACPDMO * IO.DMO PROCESSING
;
;+
; THIS ROUTINE PROCESS THE IO.DMO REQUEST. IT RETURNS THE FUNCTION TO
; ...DIS AND FALLS INTO ACPMDM.
;
; INPUT:
;
;	R3 = I/O PACKET ADDRESS
;	R5 = UCB ADDRESS
;
; OUTPUT:
;
;	I/O PACKET RETURNED WITH SUCCESS CODE.
; NOTES:
;
;	THE IO.DMO USES A SYSTEM BUFFER FOR PARAMETER PASSING LIKE IO.MOU.
;
;	CODE FALLS INTO ROUTINE ON NEXT PAGE.
;
; REGISTERS:	USES R0-R5	SAVES R5
;
; CALLS:	OUTASC,OUTASZ,$DEACB,ACPDON
;-
;
ACPDMO:	MOV	#DMOMSG,R1		;GET MESSAGE ADDRESS
	CALL	OUTASZ			;OUTPUT MESSAGE

	MOV	I.PRM+0(R3),R1		;IS THERE A PARAMETER BUFFER
	BEQ	1000$			; IF EQ - NO, SKIP
	MOV	I.PRM+2(R3),R0		;GET SIZE OF BUFFER
	CALL	OUTASC			;OUTPUT ASCII TEXT

	MOV	I.PRM+0(R3),R0		;GET PARAMETER BUFFER ADDRESS
	MOV	I.PRM+2(R3),R1		;GET SIZE OF BUFFER
	SYSTEM	1000$			;;ENTER SYSTEM STATE
	CALLR	$DEACB			;;DEALLOCATE BUFFER
;
; RETURN DISMOUNT PACKET TO ...DIS.
;
1000$:	MOV	#IS.SUC&377,R0		;SET FUNCTION RETURN CODE
	CALL	ACPDON			;RETURN I/O FUNCTION
;
; FALL INTO ACPMDM CODE. CHECK IF DISMOUNT AND ACP EXIT ARE ALLOWED.
;

	.SBTTL	ACPMDM * CHECK IF DISMOUNT LEGAL
;
;+
; THIS ROUTINE CHECKS IF ALL ACTIVITY ON THE DEVICE IS ENDED AND
; COMPLETES THE DISMOUNT. WHEN ALL UNITS ARE DISMOUNTED, THE TASK
; EXITS
;
; INPUT:
;
;	R5 = UCB ADDRESS
;
; OUTPUT:
;
;	IF UNIT ACTIVITY COMPLETED, UNIT DISMOUNTED
;
;	IF ALL DISMOUNTS COMPLETED, TASK EXITS
;
; NOTES:
;
;	THE ROUTINE ASSUMES THE CALLER DESIRES DISMOUNTING, I.E., US.MDM IS
;	SET IN THE UCB.
;
; REGISTERS:	USES R0-R5	SAVES R5
;
; CALLS:	$DEACB
;-
;
ACPMDM:	TST	@U.VCB(R5)		;ARE ANY TRANSACTIONS IN PROGRESS?
	BEQ	1000$			; IF EQ - NO, EXIT
	RETURN				;RETURN TO CALLER
;
; OUTPUT DISMOUNTING MESSAGE AND EXIT.
;
1000$:	MOV	#MDMMSG,R1		;GET DISMOUNT COMPLETE MESSAGE
	CALL	OUTASZ			;OUTPUT MESSAGE
	MOV	U.VCB(R5),R0		;GET VCB ADDRESS
	MOV	#V$SIZE,R1		;GET LENGTH
	SYSTEM	2000$			;;ENTER SYSTEM STATE
	CALL	$DEACB			;;DEALLOCATE VCB
	CLR	U.VCB(R5)		;;MARK NO VCB
	CLR	U.ACP(R5)		;;MARK NO ACP
	BICB	#US.MDM,U.STS(R5)	;;CLEAR MARKED FOR DISMOUNT
	BISB	#US.MNT,U.STS(R5)	;;SET VOLUME NOT MOUNTED
	DEC	ENABLE			;;COUNT VOLUME DISMOUNTED
	RETURN				;;EXIT SYSTEM STATE
;
; CHECK IF ALL UNITS DISMOUNTED.
;
2000$:	TST	ENABLE			;ARE ALL UNITS DISABLED?
	BEQ	3000$			; IF EQ - YES, EXIT
	RETURN				;RETURN TO CALLER
;
; OUTPUT EXIT MESSAGE AND EXIT.
;
3000$:	MOV	#XITMSG,R1		;GET TASK EXIT MESSAGE
	CALL	OUTASZ			;OUTPUT MESSAGE
	EXIT$S				;EXIT TASK

	.SBTTL	ACPDON * FINISH I/O PACKET
;
;+
; THIS ROUTINE COMPLETES I/O PACKET PROCESSING. THE I/O FUNCTION IS
; RETURNED, THE TRANSACTION COUNT DECREMENTED, AND THE WINDOW UNLOCKED.
;
; INPUT:
;
;	R0 = I/O STATUS CODE
;	R1 = SECONDARY STATUS (IF ACPALT)
;	R3 = I/O PACKET ADDRESS
;	R5 = UCB ADDRESS
;
; OUTPUT:
;
;	PACKET RETURNED.
;
; REGISTERS:	USES R0-R5	SAVES R5
;
; CALLS:	$IOFIN
;-
;
ACPDON:	CLR	R1			;CLEAR SECONDARY STATUS

ACPALT:	SYSTEM	1000$			;;ENTER SYSTEM STATE
	CLR	I.PRM+16(R3)		;;MAKE SURE 8TH PARMETER ZERO
	BIC	#1,@I.LN2(R3)		;;CLEAR LOCK BIT
	DEC	@U.VCB(R5)		;;DECREMENT TRANSACTION COUNT
	CALL	$IOFIN			;;FINISH I/O PACKET
1000$:	RETURN				;;RETURN FROM SYSTEM AND ROUTINE

	.SBTTL	OUTAS? * OUTPUT MESSAGE
;
;+
; THIS ROUTINE OUTPUTS AN ASCII/ASCIZ MESSAGE.
;
; INPUT:
;
;	R1 = MESSAGE ADDRESS
;	R0 = MESSAGE SIZE (OUTASC)
;
; OUTPUT:
;
;	MESSAGE OUTPUT.
;
; REGISTERS:	USES R0-R5	SAVES R5
;
;-
;
OUTASZ:	MOV	#-1,R0			;INITIALIZE COUNTER
	MOV	R1,R2			;COPY MESSAGE ADDRESS
1000$:	INC	R0			;COUNT BYTE
	TSTB	(R2)+			;IS THIS END
	BNE	1000$			; IF NE - NO LOOP

OUTASC:	QIOW$S	#IO.WVB,#TTYLUN,#TTYFLG,,,,<R1,R0,#40>
	RETURN

	.SBTTL	GETBLK * MOVE BLOCK OF DATA FROM TASK
;
;+
; THIS ROUTINE MOVES THE SPECIFIED DATA BLOCK FROM THE SPECIFY USER
; DATA BUFFER (USING APR6 RELOCATED ADDRESS) TO DAPACP.
;
; INPUT:
;
;	R0 = SIZE OF DATA BLOCK (IN BYTES)
;	R1 = DESTINATION DATA ADDRESS
;	R2 = POINTER TO DOUBLEWORD APR6 BIAS,
;	     SOURCE DISPLACEMENT
;
; OUTPUT:
;
;	DATA MOVED TO SPECIFIED DESTINATION AT SYSTEM STATE.
;
; REGISTERS:	USES R0-R5	SAVES R0-R5
;
; CALLS:	$BLXIO,$RELOC
;-
;
GETBLK:	SYSTEM	1000$			;;ENTER SYSTEM STATE
	MOV	R0,-(SP)		;;SAVE MOVE SIZE
	MOV	R2,-(SP)		;;SAVE SOURCE DOUBLEWORD ADDRESS
	MOV	R1,R0			;;COPY DESTINATION ADDRESS
	CALL	$RELOC			;;RELOCATE DESINATION ADDRESS
	MOV	R1,R3			;;COPY DESTINATION APR6 BIAS
	MOV	R2,R4			;;COPY DESTINATION DISPLACEMENT
	MOV	(SP)+,R0		;;GET SOURCE DOUBLEWORD
	MOV	(R0)+,R1		;;GET SOURCE APR6 BIAS
	MOV	(R0)+,R2		;;GET SOURCE DISPLACEMENT
	SUB	#20000,R2		;;CONVERT TO APR5 DISPLACEMENT
	MOV	(SP)+,R0		;;GET MOVE SIZE
	CALL	$BLXIO			;;MOVE DATA AND RETURN TO USER STATE
1000$:	RETURN				;;RETURN TO USER STATE AND CALLER

	.SBTTL	RTNBLK * MOVE BLOCK OF DATA TO TASK
;
;+
; THIS ROUTINE MOVES THE SPECIFIED DATA BLOCK TO THE SPECIFY USER
; DATA BUFFER (USING APR6 RELOCATED ADDRESS).
;
; INPUT:
;
;	R0 = SIZE OF DATA BLOCK (IN BYTES)
;	R1 = SOURCE DATA ADDRESS
;	R2 = POINTER TO DOUBLEWORD APR6 BIAS,
;	     DESTINATION DISPLACEMENT
;
; OUTPUT:
;
;	DATA MOVED TO SPECIFIED DESTINATION AT SYSTEM STATE.
;
; REGISTERS:	USES R0-R5	SAVES R0-R5
;
; CALLS:	$BLXIO,$RELOC
;-
;
RTNBLK:	SYSTEM	1000$			;;ENTER SYSTEM STATE
	MOV	(R2)+,R3		;;GET APR6 BIAS
	MOV	(R2)+,R4		;;GET DESTINATION DISPLACEMENT
	MOV	R0,-(SP)		;;SAVE MOVE SIZE
	MOV	R1,R0			;;COPY SOURCE ADDRESS
	CALL	$RELOC			;;RELOCATE SOURCE ADDRESS
	SUB	#20000,R2		;;CONVERT TO APR5 DISPLACEMENT
	MOV	(SP)+,R0		;;GET MOVE SIZE
	CALL	$BLXIO			;;MOVE DATA AND RETURN TO USER STATE
1000$:	RETURN				;;RETURN TO USER STATE AND CALLER

	.END	NULACP