.TITLE	CAM$BLIB BASIC CAMAC ACCESS PROCEDURE MODULE
	.IDENT	'V03-001'

	.LIBRARY	/SYS$LIBRARY:LIB/		; SYSTEM MACRO LIBRARY
	.LIBRARY	/CAMDEF/			; CAMAC MACRO LIBRARY
	.SBTTL	CAMAC ACCESS LIBRARY HEADER

;************************************************************************
;
;	CAMAC ACCESS PROCEDURE LIBRARY FOR THE VAX-11/780
;	CAMAC SYSTEM
;
;***************************************************************

;+++
;
; FACILITY
;	OAK RIDGE NATIONAL LABORATORY
;	FUSION ENERGY DIVISION
;	TOKAMAK SECTION
;
; ABSTRACT
;
;	This library contains a collection of procedures
;	designed to support access to the VAX CAMAC system
;	developed for the ORNL Fusion Energy Division VAX-11/780
;	computer system(s). These procedures are designed to 
;	conform to VAX linkage conventions and as such should
;	be callable from any VAX supported high-level language.
;	Specifically, this library contains the following procedures:
;
;	CAM$CSTATE
;	-Alter default CAMAC system states for the
;	 on an image by image basis,
;	CAM$ASSIGN
;	-Assign a key value to a specific CAMAC module,
;	CAM$DASSGN
;	-Release a CAMAC module key assignment,
;	CAM$PIO(W)
;	-Perform a single-action CAMAC request(programmed I/O),
;	CAM$QSCAN(W)
;	-Perform a CAMAC Q-Scan mode transaction,
;	CAM$QSTOP(W)
;	-Perform a CAMAC Q-Stop mode transaction,
;	CAM$STOP(W)
;	-Perform a CAMAC Stop mode transaction,
;	CAM$QREP(W)
;	-Perform a CAMAC Q-Repeat mode transaction.
;
;
;	A brief synopsis of each access procedure is included
;	in the preamble for that procedure.
;
; AUTHOR
;	E. T. Blair
;
; REVISION HISTORY
;	V02-000, E.T. Blair,12-AUG-1982
;	Modified CAMAC access procedures performing QIO(W) system services
;	to provide analogous entry points,i.e. CAM$XXX and CAM$XXXW calls
;	with consistent argument lists for both calls. In V01 the determination
;	as to whether a call was wait/proceed mode was based on the argument
;	list parameters specified, however, this approach posed some problems
;	when attempting to perform CAMAC calls from PASCAL.
;
;	V02-001,E.T. Blair,12-AUG-1982
;	Made changes to documentation in several procedure preambles
;	to correct errors and clarify intent. Also, changed argument
;	format for CAM$CSTATE(arguments XSTATE and QSTATE) from
;	bytes to words to accomodate use of existing mask definitions
;	in the CAMAC macro library.
;
;
;	V02-002,E.T. Blair,25-AUG-1982
;	Made change to CAM$CSTATE to force update of the process information
;	maintained in the CIB for each call to CAM$CSTATE. This provides a
;	simple means of updating this information if the process happens to
;	change some privilege, etc. without creating a separate access call
;	to perform the update.
;
;	V02-003, E.T. Blair,8-SEP-1982
;	Incorporated changes to optimize the access procedures. An internal
;	routine was added to generate the CAMAC RTB. Also, modifications to
;	support the parallel highway were added.
;
;	V03-000, E.T. Blair,10-NOV-1982
;	Incorporated CAMAC procedure to support Q-Repeat mode for the KS 2053
;	CAMAC interface.
;
;	V03-001, E.T. Blair,5-JAN-1983
;	Added .LIBRARY directives for MACRO libraries required to assemble
;	this module. Also, changed CAMAC data structure MACROs for
;	$CAMIODEF, $SHREGS and $PHREGS. New equivalent structures are
;	$KSIODEF and $KSREGS.
;---
	.SBTTL	SYSTEM AND CAMAC DEFS

	$DSCDEF					; DESCRIPTOR STRUC/CODES
	$JPIDEF					; JOB/PROCESS INFORMATION CODES
	$PRVDEF					; PROCESS PRIVILEGES
	$SSDEF					; SYSTEM STATUS DEFINITIONS
	$KSIODEF				; CAMAC I/O FUNCTION CODES
	$KSREGS					; KS 2051 REGISTER DEFS
	$RTBDEF					; REGISTER TEMPLATE BLOCK STRUC
	$IOSBDEF				; CAMAC I/O STATUS BLOCK STRUC
	$LSTDEF					; KS 2050 LIST MODE DEFS
	$CIBDEF					; CAMAC IMAGE BLOCK STRUC
	$CRPDEF					; CAMAC REQUEST PACKET STRUC
	$LISDEF					; EXECUTE LIST HEADER STRUC
	$CMAPDEF				; CRATE/CHANNEL MAP DEF
	$KEYDEF					; CAMAC MODULE KEY STRUC
	.PAGE
	.SBTTL	CAMAC PROCEDURE VECTOR SECTION

	.PSECT	CAM$VEC,PIC,SHR,NOWRT,EXE

;++
; CAMAC PROCEDURE TRANSFER VECTOR PROGRAM SECTION
;
;--

	PROCVEC	CAM$CSTATE				; CAMAC IMAGE CONTROL PROCEDURE

	PROCVEC	CAM$ASSIGN			; MODULE KEY ASSIGNMENT

	PROCVEC	CAM$DASSGN			; RELEASE MODULE KEY ASSIGNMENT

	PROCVEC	CAM$PIOW			; PROGRAMMED I/O(WAIT)

	PROCVEC	CAM$PIO				; PROGRAMMED I/O REQUEST

	PROCVEC	CAM$QSCANW			; Q-SCAN/STOP ON WORD COUNT(WAIT)

	PROCVEC	CAM$QSCAN			; Q-SCAN/STOP ON WORD COUNT

	PROCVEC	CAM$QSTOPW			; Q-STOP/STOP ON WORD COUNT(WAIT)

	PROCVEC	CAM$QSTOP			; Q-STOP/STOP ON WORD COUNT

	PROCVEC	CAM$STOPW			; STOP ON WORD COUNT(WAIT)

	PROCVEC	CAM$STOP			; STOP ON WORD COUNT

	PROCVEC	CAM$QREPW			; Q-REPEAT/STOP ON WORD COUNT(WAIT)

	PROCVEC	CAM$QREP			; Q-REPEAT/STOP ON WORD COUNT
	.PAGE
	.SBTTL	CAM$CSTATE, SET CAMAC IMAGE BLOCK DATA
	.ENABL	LSB
	.PSECT	CAM$CODE,PIC,SHR,NOWRT

;+++
;
;	Procedure:
;	CAM$CSTATE(EFN[,XSTATE][,QSTATE][,MEM])
;
;	Description:
;	This procedure provides a means to define the default
;	values for the parameters specified in the procedure
;	argument list. A description of each parameter, it's
;	function and permissible values is given below:
;
;	Parameter: EFN
;
;	Function:
;	Allows the user to define the default process local event flag to be
;	utilized by the CAMAC access procedures for synchronizing I/O 
;	completion on all non-proceed I/O calls(i.e. any call to a CAMAC access
;	procedure that does not include the optional 'proceed I/O' parameters).
;	This value initially defaults to local event flag 0.
;
;	Value:
;	Any legal process local event flag number.
;
;	Parameter: XSTATE
;
;	Function:
;	Allows the user to influence the logic equation used by the
;	CAMAC branch driver in the determination of 'ERROR'/'NORMAL'
;	termination of a programmed I/O(PIO) or a list PIO operation.
;	This value initially defaults to 'CAM$_XI'.
;
;	Values:
;	CAM$XI-Ignores CAMAC X response in the determination of
;		ERROR status from the CAMAC branch driver.
;	CAM$_XE-Opposite of CAM$_XI.
;
;	Parameter: QSTATE
;
;	Function:
;	Allows the user to influence the logic equation used by the
;	CAMAC branch driver in the determination of 'ERROR'/
;	'NORMAL' termination of a programmed I/O(PIO) or a list
;	PIO operation. This value initially defaults to 'CAM$_QDC'.
;
;	Values:
;	CAM$_QDC-Ignores CAMAC Q response in the determination of
;		ERROR status from the CAMAC interface.
;	CAM$_QNE-CAMAC Q response not expected. If received, the CAMAC
;		interface terminates with ERROR status on PIO and list PIO
;		operations.
;	CAM$_QE-CAMAC Q response expected. If not received, the CAMAC
;		interface terminates with ERROR status on PIO and list PIO
;		operations.
;
;	Parameter: MEM
;
;	Function:
;	Allows the user to change the default memory format state for
;	a given image. The memory format used determines whether 16 or
;	24 bit CAMAC data transfer operations are performed. This value 
;	initially defaults to '16' bit mode.
;
;	Values:
;	16-Sets default memory format to '16' bit format(1 CAMAC transfer =
;		1 word).
;	24-Sets default memory format to '24' bit format(1 CAMAC transfer =
;		2 words).
;
;	Parameters:
;	EFN- value of the process local event flag to be used by CAMAC
;		access procedures as default,
;	XSTATE- address of a word containing one of the symbolic values
;		CAM$_XI,CAM$_XE,
;	QSTATE- address of a word containing one of the symbolic values
;		CAM$_QDC, CAM$_QE, CAM$_QNE,
;	MEM- address of a byte containing one of the values 16 or 24.
;
;	Return Status:
;	SS$_NORMAL
;		Successful completion of item request.
;	SS$_INSFARG
;		Not enough arguments supplied.
;	SS$_BADPARAM
;		Invalid parameter specified.
;
;---

;
; PROCEDURE LOCAL DATA
;
CST_NARGS	= 0				; ARGUMENT COUNT
CST_EFN		= 4				; EVENT FLAG VALUE
CST_XSTATE	= 8				; XSTATE ARGUMENT
CST_QSTATE	= 12				; QSTATE ARGUMENT
CST_MEM		= 16				; MEM FORMAT
CST_MINARGS	= 1				; MIN ARG COUNT
CST_MAXARGS	= 4				; MAX ARG COUNT


	.ENTRY	CAM$CSTATE,^M<R11>

	MOVAB	G^CAM_CIB,R11			; GET CIB ADDRESS
	CMPB	CST_NARGS(AP),#CST_MINARGS	; LESS THAN MIN ARGS SPECIFIED?
	BGEQ	10$				; IF GREATER OR EQUAL, CONTINUE
	MOVZWL	#SS$_INSFARG,R0			; NOT ENOUGH ARGS STATUS
	RET					; RETURN TO CALLER
10$:
	CASEB	CST_NARGS(AP),#CST_MINARGS,-	; HANDLE ARGUMENTS BY CASE
		#CST_MAXARGS
20$:
	.WORD	CST_THRU_EFN-20$		; PARAMETERS THRU EVENT FLAG
	.WORD	CST_THRU_XSTATE-20$		; PARAMETERS THRU XSTATE
	.WORD	CST_THRU_QSTATE-20$		; PARAMETERS THRU QSTATE
	.WORD	CST_THRU_MEM-20$		; PARAMETERS THRU MEM FORMAT

	MOVZWL	#SS$_TOOMUCHDATA,R0		; SET ERROR STATUS
	RET					; RETURN TO CALLER

CST_THRU_MEM:
	TSTL	CST_MEM(AP)			; NULL PARAMETER SPECIFIED?
	BEQL	CST_THRU_QSTATE			; IF SO, GO CHECK NEXT
	CMPB	@CST_MEM(AP),#16		; '16' FORMAT SPECIFIED?
	BNEQ	30$				; IF NOT, GO CHECK '24'
	BISW	#CSTS_M_M16,CIB_W_CSTS(R11)	; SET CAMAC STATE FOR '16'
	BRB	CST_THRU_QSTATE			; CONTINUE
30$:
	CMPB	@CST_MEM(AP),#24		; '24' FORMAT SPECIFIED?
	BNEQ	40$				; IF NOT, DECLARE ERROR
	BICW	#CSTS_M_M16,CIB_W_CSTS(R11)	; SET CAMAC STATE FOR '24'
	BRB	CST_THRU_QSTATE
40$:
	MOVZWL	#SS$_BADPARAM,R0		; INDICATE ERROR
	BRB	90$				; ABORT CALL
CST_THRU_QSTATE:
	TSTL	CST_QSTATE(AP)			; NULL PARAMETER SPECIFIED?
	BEQL	CST_THRU_XSTATE			; IF 0, ASSUME SO
	BISW	@CST_QSTATE(AP),-		; MASK Q STATE INTO
		CIB_W_CSTS(R11)			; CIB CAMAC STATE WORD
CST_THRU_XSTATE:
	TSTL	CST_XSTATE(AP)			; NULL PARAMETER SPECIFIED?
	BEQL	CST_THRU_EFN			; IF 0, ASSUME SO
	BISW	@CST_XSTATE,-			; MASK X STATE INTO CIB
		CIB_W_CSTS(R11)			; CAMAC STATE WORD
CST_THRU_EFN:
	MOVB	CST_EFN(AP),CIB_B_EFN(R11)	; COPY USER EFN TO CIB
	JSB	G^CAM_GETJIB			; UPDATE JPI ITEMS IN CIB
90$:
	RET					; RETURN TO CALLER
	.DSABL	LSB
	.PAGE
	.SBTTL	CAM$ASSIGN, CAMAC KEY ASSIGNMENT PROCEDURE
	.ENABL	LSB

;+++
;
;	Procedure:
;	CAM$ASSIGN(%DESCR(MODULE_NAME),KEY)
;
;	Description:
;	This procedure performs a CAMAC key(I/O channel)
;	assignment to the specified CAMAC logical module.
;	The logical module name is translated recursively
;	and must eventually translate to a physical module
;	name from the SYSTEM logical name table unless the
;	calling process has SYSNAM privilege. Upon verification
;	of physical module name syntax and UIC access to the
;	module, a VAX I/O channel is assigned to the CAMAC 
;	unit specified in the physical module name and the
;	key is encoded for return to the caller.
;
;	Parameters:
;	MODULE_NAME- address of a CHARACTER variable containing an ASCII 
;		character string identifying the CAMAC module to be referenced,
;	KEY- address of a longword to receive the encoded key value
;		to be used for subsequent CAMAC I/O calls,
;
;	Return Status:
;	SS$_NORMAL
;		Service normally completed. Key value is valid.
;	SS$_BADPARAM
;		Invalid/illegal parameter was passed on the call.
;	(See SYS$ASSIGN system service for additional status return).
;
;---

;
; PROCEDURE LOCAL DATA
;
ASG_NARGS	= 0				; ARGUMENT COUNT
ASG_MOD		= 4				; MODULE NAME
ASG_KEY		= 8				; KEY VALUE(OUTPUT)
ASG_MINARGS	= 2				; MIN ARG COUNT
ASG_MAXARGS	= 2				; MAX ARG COUNT
ASG_K_DSBMSK	= 0				; DEFAULT DSBMASK VALUE

	.ENTRY	CAM$ASSIGN,^M<R2,R3,R4,R5,R10,R11>

	MOVAB	G^CAM_CIB,R11			; GET CIB ADDRESS
	BBS	#PSTS_V_JIBV,-			; TEST IF JIB VALID
		CIB_L_PSTS(R11),40$		; IF SET, CONTINUE
	JSB	G^CAM_GETJIB			; ELSE, GET JIB INFO
40$:
	CMPB	ASG_NARGS(AP),-			; TEST MIN ALLOWABLE ARGS
		#ASG_MINARGS
	BGEQ	10$				; IF SUFFICIENT, CONTINUE
	MOVZWL	#SS$_INSFARG,R0			; RETURN INSUFFICIENT ARGS
	RET					; RETURN TO CALLER
10$:
	CMPB	ASG_NARGS(AP),-			; CHECK MAX ARG COUNT
		#ASG_MAXARGS
	BLEQ	20$				; CONTINUE IF NOT TOO MANY
	MOVZWL	#SS$_TOOMUCHDATA,R0		; SET ERROR STATUS
	RET					; ABORT CALL
20$:
	ALOSTAK	#CRP_K_LENGTH,R10		; GET STACK SPACE FOR CRP
	JSB	G^CAM_INITCRP			; INITIALIZE CRP
	BISW	#CRPS_M_KEYED,CRP_W_STS(R10)	; SET KEYED ACCESS FLAG
	MOVL	ASG_MOD(AP),R1			; GET ADDRESS OF MODULE DESCRIPTOR
	JSB	G^CAM_GETMDB			; GET CAMAC MODULE DATA
	BLBC	R0,90$				; IF FAILURE, EXIT HERE
	BBS	#PRV$V_SYSNAM,-			; PROCESS HAVE SYSNAM PRIV?
		CIB_Q_CPRIV(R11),70$		; IF SO, SKIP TEST
	CMPB	CRP_B_RTAB(R10),#0		; TRANSLATE FROM SYS TABLE?
	BEQL	70$				; IF SO, CONTINUE
	MOVZWL	#SS$_NOPRIV,R0			; NO PRIV FOR OPERATION
	BRB	90$				; ABORT HERE
70$:
	JSB	G^CAM_ECODKEY			; ENCODE MODULE KEY VALUE
	MOVL	R0,@ASG_KEY(AP)			; RETURN KEY VALUE TO CALLER
	MOVZWL	#SS$_NORMAL,R0			; SET NORMAL STATUS
90$:
	RET					; RETURN TO CALLER
	.DSABL	LSB
	.PAGE
	.SBTTL	CAM$DASSGN, CAMAC KEY DEASSIGNMENT PROCEDURE
	.ENABL	LSB

;+++
;
;	Procedure:
;	CAM$DASSGN(KEY)
;
;	Description:
;	This procedure releases a CAMAC key assignment previously
;	assigned via the CAM$ASSIGN function call. The VAX I/O
;	channel associated with the specified key value is
;	deassigned when the reference count associated with the
;	CAMAC Support Unit becomes 0.
;
;	Parameters:
;	KEY- address of a longword integer containing the encoded
;		key value.
;
;	Return Status:
;	SS$_NORMAL
;		Request successfully completed.
;	SS$_BADPARAM
;		Illegal/invalid parameter passed on call.
;	See SYS$DEASSGN system service for additional status).
;
;---

;
; PROCEDURE LOCAL DATA
;
DAG_NARGS	= 0				; ARGUMENT COUNT
DAG_KEY		= 4				; KEY VALUE(OUTPUT)
DAG_MINARGS	= 1				; MIN ARG COUNT
DAG_MAXARGS	= 1				; MAX ARG COUNT

	.ENTRY	CAM$DASSGN,^M<R2,R3,R4,R5,R10,R11>

	MOVAB	G^CAM_CIB,R11			; GET CIB ADDRESS
	BBS	#PSTS_V_JIBV,-			; TEST IF JIB VALID
		CIB_L_PSTS(R11),40$		; IF SET, CONTINUE
	JSB	G^CAM_GETJIB			; ELSE, GET JIB INFO
40$:
	CMPB	DAG_NARGS(AP),-			; TEST MIN ALLOWABLE ARGS
		#DAG_MINARGS
	BGEQ	10$				; IF SUFFICIENT, CONTINUE
	MOVZWL	#SS$_INSFARG,R0			; RETURN INSUFFICIENT ARGS
	RET					; RETURN TO CALLER
10$:
	CMPB	DAG_NARGS(AP),-			; CHECK MAX ARG LIMIT
		#DAG_MAXARGS
	BLEQ	20$				; IF LESS OR EQUAL, CONTINUE
	MOVZWL	#SS$_TOOMUCHDATA,R0		; SET ERROR STATUS
	RET					; RETURN TO CALER
20$:
	ALOSTAK	#CRP_K_LENGTH,R10		; GET STACK SPACE FOR CRP
	JSB	G^CAM_INITCRP			; INITIALIZE CRP
	BISW	#CRPS_M_KEYED,CRP_W_STS(R10)	; SET KEYED ACCESS FLAG
	MOVL	@DAG_KEY(AP),R1			; GET VALUE OF MODULE KEY
	JSB	G^CAM_DCODKEY			; DECODE KEY VALUE
						; FIELDS OF CRP RECEIVE DATA
	BLBC	R0,90$				; IF FAILURE, ABORT HERE
	JSB	G^CAM_RELCHAN			; RELEASE CAMAC CHANNEL
	MOVZWL	#SS$_NORMAL,R0			; SET NORMAL STATUS
90$:
	RET					; RETURN TO CALLER
	.DSABL	LSB
	.PAGE
	.SBTTL	CAM$PIO(W), CAMAC PROGRAMMED I/O(SINGLE-ACTION)
	.ENABL	LSB

;+++
;
;	Procedure:
;
;	CAM$PIO(W)(%DESCR(MODULE_NAME),A,F[,DATA][,MEM]][,IOSB]
;			[,EFN][,AST][,ASTPRM])
;		Or
;
;	CAM$PIO(W)(%DESCR(KEY),A,F,[,DATA][,MEM][,IOSB]
;			[,EFN][,AST][,ASTPRM])
;
;	Description:
;	This procedure performs a single-action CAMAC I/O request.
;	The specified CAMAC module name is translated into the
;	appropriate controller, crate and station addresses.
;	If the keyed access format is used, the key must correspond
;	to a CAMAC module previously connected via the CAM$ASSIGN
;	function call. The CAMAC data buffer is not required for
;	calls performing CAMAC control functions(8 <= F <= 15 or
;	24 <= F <= 31. If the I/O status block parameter is specified,
;	it is used to receive the status from the CAMAC I/O request.
;	If the memory format control parameter is specified,
;	the value determines whether 16 bits of data is transferred
;	(MEM=16) or 24 bits of data is transferred(MEM=24). If
;	not specified, the CIB memory format specifier is used.
;
;	If the proceed mode call(CAM$PIO) is used, control returns
;	 to the caller as soon as the CAMAC request is queued to 
;	the system. If the wait mode call(CAM$PIOW) is used, control 
;	is returned to the calling program only when the CAMAC I/O 
;	is complete. 
;
;	The I/O synchronization parameters(EFN, AST and ASTP) are used
;	in the same manner as their counterparts in the QIO and QIOW
;	system services. See the VAX System Services Reference Manual
;	for further discussion if needed.
;
;
;	Parameters:
;	MODULE_NAME- address of a CHARACTER variable containing an ASCII 
;		character string identifying the CAMAC module to be referenced,
;	KEY- address of a longword descriptor for the key value
;		previously computed for the CAMAC module via
;		calling the procedure CAM$ASSIGN,
;	A- address of a byte containing CAMAC subaddress,
;	F- address of a byte containing CAMAC function code,
;	DATA- address of a long word containing CAMAC write
;		data or that will receive CAMAC read data. Not 
;		required for CAMAC control functions,
;	MEM- address of a byte containing the memory format for
;		the CAMAC transaction(MEM=16; MEM=24). If not
;		specified, the current CIB memory format specifier
;		is used.
;	IOSB- address of a quadword buffer to receive I/O completion
;		status from the CAMAC request.
;
;	Optional I/O Synchronization Parameters:
;	EFN- value specifying the number of a local event flag
;		to be set upon I/O completion. If not specified, the
;		default process event flag from the CAMAC image block
;		is used,
;	AST- address of an AST procedure to receive an I/O completion
;		AST,
;	ASTPRM- address of a longword containing a parameter to
;		be passed to the specified AST procedure.
;
;	Return Status:
;
;---

;
; PROCEDURE LOCAL DATA
;
PIO_NARGS	= 0				; ARGUMENT COUNT
PIO_MOD		= 4				; MODULE DESCRIPTOR
PIO_A		= 8				; SUBADDRESS OFFSET
PIO_F		= 12				; FUNCTION CODE
PIO_DATA	= 16				; DATA BUFFER(OPTIONAL)
PIO_MEM		= 20				; MEMORY FORMAT
PIO_IOSB	= 24				; IOSB BUFFER
PIO_EFN		= 28				; EVENT FLAG VALUE
PIO_AST		= 32				; AST PROCEDURE
PIO_ASTP	= 36				; AST PARM VALUE
PIO_MINARGS	= 3				; MINIMUM NUMBER OF ARGS
PIO_MAXARGS	= 9				; MAX NUMBER OF ARGS


;
;	WAIT MODE ENTRY POINT
;
	.ENTRY	CAM$PIOW,^M<R2,R3,R4,R5,R9,R10,R11>

	MNEGL	#1,R9				; SET WAIT MODE INDICATOR
	BRB	CAM_PIO				; JOIN COMMON FLOW

;
;	PROCEED MODE ENTRY POINT
;
	.ENTRY	CAM$PIO,^M<R2,R3,R4,R5,R9,R10,R11>

	CLRL	R9				; RESET WAIT MODE INDICATOR

CAM_PIO:					; COMMON PIO FLOW
	MOVAB	G^CAM_CIB,R11			; GET ADDRESS OFCAMAC IMAGE BLOCK
	BBS	#PSTS_V_JIBV,-			; IS JIB INFO VALID?
		CIB_L_PSTS(R11),10$		; IF SO, CONTINUE WITH IT
	JSB	G^CAM_GETJIB			; ELSE, GET NEW JIB/PCB INFO
10$:
	CMPB	PIO_NARGS(AP),-			; CHECK AGANIST MIN ARG COUNT
		#PIO_MINARGS
	BGEQ	20$				; IF SUFFICIENT, CONTINUE
	MOVL	#SS$_INSFARG,R0			; SET INSUFF ARGS STATUS
	BRW	90$				; EXIT ROUTINE
20$:
	ALOSTAK	#CRP_K_LENGTH,R10		; ALLOCATE CRP ON STACK
	JSB	G^CAM_INITCRP			; INITIALIZE CRP
	INSV	R9,#CRPS_V_WAIT,#CRPS_S_WAIT,-	; INSERT WAIT/PROCEED FLAG
		CRP_W_STS(R10)			; INTO CRP STATUS
	MOVW	CIB_W_CSTS(R11),-		; COPY CIB CAMAC STATE TO
		CRP_W_CSTS(R10)			; CRP CAMAC STATUS WORD
	MOVL	PIO_MOD(AP),R1			; ADDRESS OF MODULE DESCRIPTOR
	JSB	G^CAM_MODULE			; GET MODULE PARAMETERS
	BLBS	R0,120$				; SUCCESS? CONTINUE IF SO.
	BRW	90$				; EXIT ROUTINE IF NOT
120$:
	MOVB	#0,CRP_B_MODE(R10)		; SET CAMAC MODE
	MOVB	@PIO_A(AP),CRP_B_A(R10)		; COPY CAMAC SUBADDRESS
	MOVB	@PIO_F(AP),CRP_B_F(R10)		; AND FUNCTION CODE
	MOVAB	CRP_L_QIOL(R10),R9		; USE R9 FOR QIO LIST POINTER
	MOVZBL	#QIO$_NARGS,(R9)		; SET QIO ARG COUNT
	MOVZBL	CIB_B_EFN(R11),-		; USE DEFAULT EFN
		QIO$_EFN(R9)
	MOVAB	CIB_Q_IOSB(R11),-		; DEFAULT TO CIB IOSB
		QIO$_IOSB(R9)
	MOVZWL	CRP_W_CHAN(R10),-		; SAVE VMS CHANNEL NUMBER
		QIO$_CHAN(R9)
	MOVZWL	#IO$_CAMIO,-			; QIO FUNCTION CODE
		QIO$_FUNC(R9)
	CASEB	PIO_NARGS(AP),-			; HANDLE PARAMETERS BY CASE
		#PIO_MINARGS,-
		#PIO_MAXARGS
30$:
	.WORD	PIO_THRU_F-30$			; PARAMETERS THRU F
	.WORD	PIO_THRU_DATA-30$		; PARAMETERS THRU DATA
	.WORD	PIO_THRU_MEM-30$		; PARAMETERS THRU MEM
	.WORD	PIO_THRU_IOSB-30$		; PARAMETERS THRU IOSB
	.WORD	PIO_THRU_EFN-30$		; PARAMETERS THRU EFN
	.WORD	PIO_THRU_AST-30$		; PARAMETERS THRU AST ADR
	.WORD	PIO_THRU_ASTP-30$		; PARAMETERS THRU AST PARM

	MOVZWL	#SS$_TOOMUCHDATA,R0		; TOO MANY PARAMETERS
	BRW	90$				; EXIT ROUTINE

PIO_THRU_ASTP:
	MOVL	PIO_ASTP(AP),-			; COPY AST PARM TO QIO
		QIO$_ASTPRM(R9)			; PARM LIST
PIO_THRU_AST:
	MOVL	PIO_AST(AP),-			; COPY AST PROC ADDRESS
		QIO$_ASTADR(R9)			; TO QIO PARM LIST
PIO_THRU_EFN:
	MOVZBL	PIO_EFN(AP),-			; COPY EVENT FLAG NUMB TO
		QIO$_EFN(R9)			; QIO PARM LIST
PIO_THRU_IOSB:
	TSTL	PIO_IOSB(AP)			; CHECK FOR VALID IOSB
	BEQL	PIO_THRU_MEM			; IF 0, NULL PARAMETER
	MOVL	PIO_IOSB(AP),-			; ELSE, ASSUME VALID IOSB
		QIO$_IOSB(R9)			; ADDRESS FOR QIO
PIO_THRU_MEM:
	TSTL	PIO_MEM(AP)			; CHECK IF MEM SPECIFIED
	BEQL	PIO_THRU_DATA			; IF 0, NULL PARAMETER
	BICW	#CSTS_M_M16,-			; CLEAR M16 BIT
		CRP_W_CSTS(R10)			; IN CRP CAMAC STATUS WORD
	CMPB	@PIO_MEM(AP),#24		; CHECK FOR '24' FORMAT
	BEQL	PIO_THRU_DATA			; IF MATCH, DONE
	BISW	#CSTS_M_M16,-			; SET M16 BIT 
		CRP_W_CSTS(R10)			; IN CRP CAMAC STATUS WORD
	CMPB	@PIO_MEM(AP),#16		; CHECK FOR '16' FORMAT
	BEQL	PIO_THRU_DATA			; IF MATCH, DONE
	MOVZWL	#SS$_BADPARAM,R0		; SET BAD PARAMETER
	BRW	90$				; EXIT ROUTINE
PIO_THRU_DATA:
	TSTL	PIO_DATA(AP)			; CHECK IF DATA SPECIFIED
	BEQL	PIO_THRU_F			; IF 0, NULL PARAMETER
	MOVL	PIO_DATA(AP),-			; IF NOT 0, ASSUME BUFFER ADDR
		QIO$_P2(R9)			; FOR QIO
PIO_THRU_F:
	IFCAMCT	CRP_B_F(R10),40$		; IF CAMAC CONTROL, SKIP
	TSTL	QIO$_P2(R9)			; CHECK FOR VALID BUFFER
	BNEQ	40$				; IF NOT 0, ASSUME VALID
	MOVZWL	#SS$_INSFARG,R0			; INSUFFICIENT ARGS
	BRW	90$				; EXIT ROUTINE
40$:
	BSBW	CAM_BLDRTB			; BUILD CAMAC RTB
	MOVAB	CRP_Q_RTB(R10),-		; ADDRESS OF RTB AS QIO P1
		QIO$_P1(R9)
	BBC	#CRPS_V_WAIT,-			; CHECK IF WAIT/PROCEED
		CRP_W_STS(R10),80$		; IF 'WAIT' CLEAR, RETURN
	$QIOW_G	(R9)				; ISSUE QIO+WAIT CALL
	BRW	90$				; RETURN ON COMPLETION
80$:
	$QIO_G	(R9)				; ISSUE QIO CALL
	
90$:
	RET					; RETURN FROM PROCEDURE CALL
	.DSABL	LSB
	.PAGE
	.SBTTL	CAM$QSCAN(W), CAMAC Q-SCAN/STOP ON WORD COUNT PROCEDURE
	.ENABL	LSB

;+++
;
;	Procedure:
;	CAM$QSCAN(W)(%DESCR(MODULE_NAME),A,F,COUNT,DATA[,MEM][,IOSB]
;		[,EFN],[,AST][,ASTPRM])
;		Or
;	CAM$QSCAN(W)(%DESCR(KEY),A,F,COUNT,DATA[,MEM][,IOSB]
;		[,EFN],[,AST][,ASTPRM])
;
;	Description:
;	This procedure performs a CAMAC subaddress/address
;	scan utilizing the Q-scan technique to control the
;	incrementing of the CAMAC subaddress and address
;	utilized on successive repetitions of the specified
;	CAMAC function code. The scan starts initially at the
;	specified subaddress(A). The initial station number
;	is determined from the specified module name(for direct
;	module reference calls) or from the key value(for keyed
;	access calls). To utilize the keyed access mode, the
;	key value must first be generated by a call to the
;	CAM$ASSIGN function. In all cases, the transaction
;	terminates when the transfer count(COUNT) is exhausted
;	or when an anomolous condition is detected. If the I/O
;	status block parameter is specified, the status of the
;	CAMAC I/O request is returned in specified quadword buffer.
;	If not, a quadword buffer in the CAMAC image block is used.
;
;	If the proceed mode call(CAM$QSCAN) is used, control returns
;	 to the caller as soon as the CAMAC request is queued to 
;	the system. If the wait mode call(CAM$QSCANW) is used, control 
;	is returned to the calling program only when the CAMAC I/O 
;	is complete. 
;
;	The I/O synchronization parameters(EFN, AST and ASTP) are used
;	in the same manner as their counterparts in the QIO and QIOW
;	system services. See the VAX System Services Reference Manual
;	for further discussion if needed.
;
;	Parameters:
;	MODULE_NAME- address of a CHARACTER variable containing an ASCII 
;		character string identifying the CAMAC module to be referenced,
;	KEY- address of a longword descriptor for the key value
;		previously computed for the CAMAC module via
;		calling the procedure CAM$ASSIGN,
;	A- address of a byte containing CAMAC subaddress,
;	F- address of a byte containing CAMAC function code,
;	DATA- address of data buffer that contains CAMAC write data
;		or that will receive CAMAC read data.
;	COUNT- address of a word containing the CAMAC transfer
;		count(in units of the memory format).
;	MEM- address of a byte containing memory format for the
;		CAMAC transaction(MEM=16; MEM=24). If not specified,
;		the current CIB memory format specifier is used,
;	IOSB- address of a quadword buffer to receive I/O completion
;		status from the CAMAC request.
;
;	Optional I/O Synchronization Parameters:
;	EFN- value specifying the number of a local event flag
;		to be set upon I/O completion. If not specified, the
;		default process event flag from the CAMAC image block
;		is used,
;	AST- address of an AST procedure to receive an I/O completion
;		AST,
;	ASTPRM- address of a longword containing a parameter to
;		be passed to the specified AST procedure.
;
;
;	Return Status:
;
;---

;
; PROCEDURE LOCAL DATA
;
QSC_NARGS	= 0				; ARGUMENT COUNT
QSC_MOD		= 4				; MODULE NAME/KEY VALUE
QSC_A		= 8				; SUBADDRESS
QSC_F		= 12				; FUNCTION CODE
QSC_COUNT	=16				; TRANSFER COUNT
QSC_DATA	= 20				; DATA BUFFER
QSC_MEM		=24				; MEMORY FORMAT(OPTIONAL)
QSC_IOSB	= 28				; IOSB OFFSET
QSC_EFN		= 32				; EVENT FLAG VALUE
QSC_AST		= 36				; AST ADDRESS
QSC_ASTP	= 40				; AST PARAMETER
QSC_MINARGS	= 5				; MINIMUM ARG COUNT
QSC_MAXARGS	= 10				; MAX ARG COUNT


;
;	WAIT MODE ENTRY POINT
;
	.ENTRY	CAM$QSCANW,^M<R2,R3,R4,R5,R9,R10,R11>

	MNEGL	#1,R9				; SET WAIT MODE INDICATOR
	BRB	CAM_QSCAN			; JOIN COMMON FLOW

;
;	PROCEED MODE ENTRY POINT
;

	.ENTRY	CAM$QSCAN,^M<R2,R3,R4,R5,R9,R10,R11>

	CLRL	R9				; RESET WAIT MODE FLAG

CAM_QSCAN:					; COMMON QSCAN FLOW
	MOVAB	G^CAM_CIB,R11			; GET ADDRESS OF CAMAC IMAGE BLOCK
	BBS	#PSTS_V_JIBV,-			; IS JIB INFO VALID?
		CIB_L_PSTS(R11),10$		; IF SO, CONTINUE WITH IT
	JSB	G^CAM_GETJIB			; ELSE, GET NEW JIB/PCB INFO
10$:
	CMPB	QSC_NARGS(AP),-			; CHECK AGANIST MIN ARG COUNT
		#QSC_MINARGS
	BGEQ	20$				; IF SUFFICIENT, CONTINUE
	MOVL	#SS$_INSFARG,R0			; SET INSUFF ARGS STATUS
	BRW	90$				; EXIT ROUTINE
20$:
	ALOSTAK	#CRP_K_LENGTH,R10		; ALLOCATE CRP ON STACK
	JSB	G^CAM_INITCRP			; INITIALIZE CRP
	INSV	R9,#CRPS_V_WAIT,#CRPS_S_WAIT,-	; INSERT WAIT/PROCEED FLAG
		CRP_W_STS(R10)			; INTO CRP STATUS
	MOVW	CIB_W_CSTS(R11),-		; COPY CIB CAMAC STATE TO
		CRP_W_CSTS(R10)			; CRP CAMAC STATUS WORD
	MOVL	QSC_MOD(AP),R1			; ADDRESS OF MODULE DESCRIPTOR
	JSB	G^CAM_MODULE			; GET MODULE PARAMETERS
	BLBS	R0,120$				; SUCCESS? CONTINUE IF SO.
	BRW	90$				; EXIT ROUTINE IF NOT
120$:
	MOVB	#1,CRP_B_MODE(R10)		; SET CAMAC MODE
	MOVB	@QSC_A(AP),CRP_B_A(R10)		; COPY CAMAC SUBADDRESS
	MOVB	@QSC_F(AP),CRP_B_F(R10)		; COPY CAMAC FUNCTION CODE
	MOVAB	CRP_L_QIOL(R10),R9		; USE R9 FOR QIO LIST POINTER
	MOVZBL	#QIO$_NARGS,(R9)		; SET QIO ARG COUNT
	MOVZBL	CIB_B_EFN(R11),-		; USE DEFAULT EFN
		QIO$_EFN(R9)
	MOVAB	CIB_Q_IOSB(R11),-		; DEFAULT TO CIB IOSB
		QIO$_IOSB(R9)
	MOVZWL	CRP_W_CHAN(R10),-		; SAVE VMS CHANNEL NUMBER
		QIO$_CHAN(R9)
	MOVZWL	#IO$_CAMIO,-			; QIO FUNCTION CODE
		QIO$_FUNC(R9)
	MOVL	QSC_DATA(AP),-			; SAVE DATA BUFFER ADDR
		QIO$_P2(R9)			; IN QIO LIST
	MOVZWL	@QSC_COUNT(AP),R0		; GET TRANSFER COUNT
	ASHL	#2,R0,R0			; CONVERT TO BYTE COUNT
						; FOR '24' BIT FORMAT
	BBC	#CSTS_V_M16,-			; CHECK CRP MEM STATE
		CRP_W_CSTS(R10),50$		; IF '16', SKIP
	ASHL	#-1,R0,R0			; CHANGE TO BYTE COUNT FOR
						; '16' BIT FORMAT
50$:
	MOVZWL	R0,QIO$_P3(R9)			; SAVE BCNT IN QIO LIST
	CASEB	QSC_NARGS(AP),-			; HANDLE PARAMETERS BY CASE
		#QSC_MINARGS,-
		#QSC_MAXARGS
30$:
	.WORD	QSC_THRU_DATA-30$		; PARAMETERS THRU DATA
	.WORD	QSC_THRU_MEM-30$		; PARAMETERS THRU MEM
	.WORD	QSC_THRU_IOSB-30$		; PARAMETERS THRU IOSB
	.WORD	QSC_THRU_EFN-30$		; PARAMETERS THRU EFN
	.WORD	QSC_THRU_AST-30$		; PARAMETERS THRU AST ADR
	.WORD	QSC_THRU_ASTP-30$		; PARAMETERS THRU AST PARM

	MOVZWL	#SS$_TOOMUCHDATA,R0		; TOO MANY PARAMETERS
	BRW	90$				; EXIT ROUTINE

QSC_THRU_ASTP:
	MOVL	QSC_ASTP(AP),-			; COPY AST PARM TO QIO
		QIO$_ASTPRM(R9)			; PARM LIST
QSC_THRU_AST:
	MOVL	QSC_AST(AP),-			; COPY AST PROC ADDRESS
		QIO$_ASTADR(R9)			; TO QIO PARM LIST
QSC_THRU_EFN:
	MOVZBL	QSC_EFN(AP),-			; COPY EVENT FLAG NUMB TO
		QIO$_EFN(R9)			; QIO PARM LIST
QSC_THRU_IOSB:
	TSTL	QSC_IOSB(AP)			; CHECK FOR VALID IOSB
	BEQL	QSC_THRU_MEM			; IF 0, NULL PARAMETER
	MOVL	QSC_IOSB(AP),-			; ELSE, ASSUME VALID IOSB
		QIO$_IOSB(R9)			; ADDRESS FOR QIO
QSC_THRU_MEM:
	TSTL	QSC_MEM(AP)			; CHECK IF MEM SPECIFIED
	BEQL	QSC_THRU_DATA			; IF 0, NULL PARAMETER
	MOVZWL	@QSC_COUNT(AP),R0		; GET TRANSFER COUNT
	ASHL	#2,R0,R0			; CONVERT TO BYTE COUNT FOR
						; '24' BIT FORMAT
	BICW	#CSTS_M_M16,-			; CLEAR '16' MEM FORMAT
		CRP_W_CSTS(R10)
	CMPB	@QSC_MEM(AP),#24		; CHECK FOR '24' FORMAT
	BEQL	60$				; IF MATCH, DONE
	ASHL	#-1,R0,R0			; CHANGE TO BYTE COUNT FOR
						; '16' BIT FORMAT
	BISW	#CSTS_M_M16,-			; SET CRP M16 FLAG
		CRP_W_CSTS(R10)
	CMPB	@QSC_MEM(AP),#16		; CHECK FOR '16' FORMAT
	BEQL	60$				; IF MATCH, DONE
	MOVZWL	#SS$_BADPARAM,R0		; SET BAD PARAMETER
	BRW	90$				; EXIT ROUTINE
60$:
	MOVZWL	R0,QIO$_P3(R9)			; SAVE BCNT IN QIO LIST
QSC_THRU_DATA:
	BSBW	CAM_BLDRTB			; BUILD CAMAC RTB
	MOVAB	CRP_Q_RTB(R10),-		; ADDRESS OF RTB AS QIO P1
		QIO$_P1(R9)
	BBC	#CRPS_V_WAIT,-			; CHECK IF WAIT/PROCEED
		CRP_W_STS(R10),80$		; IF 'WAIT' CLEAR, RETURN
	$QIOW_G	(R9)				; ISSUE QIO+WAIT CALL
	BRW	90$				; RETURN ON COMPLETION
80$:
	$QIO_G	(R9)				; ISSUE QIO CALL
	
90$:
	RET					; RETURN FROM PROCEDURE CALL
	.DSABL	LSB
	.PAGE
	.SBTTL	CAM$QSTOP(W), CAMAC Q-STOP/STOP ON WORD COUNT PROCEDURE
	.ENABL	LSB

;+++
;
;	Procedure:
;	CAM$QSTOP(W)(%DESCR(MODULE_NAME),A,F,COUNT,DATA[,MEM][,IOSB]
;		[,EFN][,AST][,ASTPRM])
;		Or
;	CAM$QSTOP(W)(%DESCR(KEY),A,F,COUNT,DATA[,MEM][,IOSB]
;		[,EFN][,AST][,ASTPRM])
;
;	Description:
;	This procedure performs a CAMAC block transfer utilizing
;	the Q-stop technique for controlling successive references
;	to a given CAMAC module using a fixed subaddress and
;	function code. A Q-stop transaction terminates when
;	the referenced module returns a Q=0 response or the
;	specified transfer count(COUNT) is exhausted or an
;	anomolous condition is detected. If the I/O status block parameter
;	is specified, the status of the CAMAC I/O operation is
;	returned in that quadword buffer. If not, a quadword 
;	in the CAMAC image block is used to receive the status.
;
;	If the proceed mode call(CAM$QSTOP) is used, control returns
;	 to the caller as soon as the CAMAC request is queued to 
;	the system. If the wait mode call(CAM$QSTOPW) is used, control 
;	is returned to the calling program only when the CAMAC I/O 
;	is complete. 
;
;	The I/O synchronization parameters(EFN, AST and ASTP) are used
;	in the same manner as their counterparts in the QIO and QIOW
;	system services. See the VAX System Services Reference Manual
;	for further discussion if needed.
;
;	Parameters:
;	MODULE_NAME- address of a CHARACTER variable containing an ASCII 
;	character string identifying the CAMAC module to be referenced,
;	KEY- address of a longword descriptor for the key value
;		previously computed for the CAMAC module via
;		calling the procedure CAM$ASSIGN,
;	A- address of a byte containing CAMAC subaddress,
;	F- address of a byte containing CAMAC function code,
;	DATA- address of data buffer that contains CAMAC write data
;		or that will receive CAMAC read data.
;	COUNT- address of a word containing the CAMAC transfer
;		count(in units of the memory format).
;	MEM- address of a byte containing memory format for the
;		CAMAC transaction(MEM=16; MEM=24). If not specified,
;		the current CIB memory format specifier is used.
;	IOSB- address of a quadword buffer to receive I/O completion
;		status from the CAMAC request.
;
;	Optional I/O Synchronization Parameters:
;	EFN- value specifying the number of a local event flag
;		to be set upon I/O completion. If not specified, the
;		default process event flag from the CAMAC image block
;		is used,
;	AST- address of an AST procedure to receive an I/O completion
;		AST,
;	ASTPRM- address of a longword containing a parameter to
;		be passed to the specified AST procedure.
;
;
;	Return Status:
;
;---


;
; PROCEDURE LOCAL DATA
;
QST_NARGS	= 0				; ARGUMENT COUNT
QST_MOD		= 4				; MODULE NAME/KEY VALUE
QST_A		= 8				; SUBADDRESS
QST_F		= 12				; FUNCTION CODE
QST_COUNT	= 16				; TRANSFER COUNT
QST_DATA	= 20				; DATA BUFFER
QST_MEM		= 24				; MEMORY FORMAT(OPTIONAL)
QST_IOSB	= 28				; IOSB OFFSET
QST_EFN		= 32				; EVENT FLAG VALUE
QST_AST		= 36				; AST PROCEDURE ADDRESS
QST_ASTP	= 40				; AST PARAMETER VALUE
QST_MINARGS	= 5				; MINIMUM ARG COUNT
QST_MAXARGS	= 10				; MAXIMUM ARG COUNT


;
;	WAIT MODE ENTRY POINT
;
	.ENTRY	CAM$QSTOPW,^M<R2,R3,R4,R5,R9,R10,R11>

	MNEGL	#1,R9				; SET WAIT MODE INDICATOR
	BRB	CAM_QSTOP			; JOIN COMMON FLOW

;
;	PROCEED MODE ENTRY POINT
;

	.ENTRY	CAM$QSTOP,^M<R2,R3,R4,R5,R9,R10,R11>

	CLRL	R9				; RESET WAIT MODE INDICATOR

CAM_QSTOP:					; COMMON QSTOP FLOW
	MOVAB	G^CAM_CIB,R11			; GET CAMAC IMAGE BLOCK ADDRESS
	BBS	#PSTS_V_JIBV,-			; IS JIB INFO VALID?
		CIB_L_PSTS(R11),10$		; IF SO, CONTINUE WITH IT
	JSB	G^CAM_GETJIB			; ELSE, GET NEW JIB/PCB INFO
10$:
	CMPB	QST_NARGS(AP),-			; CHECK AGANIST MIN ARG COUNT
		#QST_MINARGS
	BGEQ	20$				; IF SUFFICIENT, CONTINUE
	MOVL	#SS$_INSFARG,R0			; SET INSUFF ARGS STATUS
	BRW	90$				; EXIT ROUTINE
20$:
	ALOSTAK	#CRP_K_LENGTH,R10		; ALLOCATE CRP ON STACK
	JSB	G^CAM_INITCRP			; INITIALIZE CRP
	INSV	R9,#CRPS_V_WAIT,#CRPS_S_WAIT,-	; INSERT WAIT/PROCEED FLAG
		CRP_W_STS(R10)			; INTO CRP STATUS
	MOVW	CIB_W_CSTS(R11),-		; COPY CIB CAMAC STATE TO
		CRP_W_CSTS(R10)			; CRP CAMAC STATUS WORD
	MOVL	QST_MOD(AP),R1			; ADDRESS OF MODULE DESCRIPTOR
	JSB	G^CAM_MODULE			; GET MODULE PARAMETERS
	BLBS	R0,120$				; SUCCESS? CONTINUE IF SO.
	BRW	90$				; EXIT ROUTINE IF NOT
120$:
	MOVB	#2,CRP_B_MODE(R10)		; SET CAMAC MODE
	MOVB	@QST_A(AP),CRP_B_A(R10)		; COPY CAMAC SUBADDRESS
	MOVB	@QST_F(AP),CRP_B_F(R10)		; COPY CAMAC FUNCTION
	MOVAB	CRP_L_QIOL(R10),R9		; USE R9 FOR QIO LIST POINTER
	MOVZBL	#QIO$_NARGS,(R9)		; SET QIO ARG COUNT
	MOVZBL	CIB_B_EFN(R11),-		; USE DEFAULT EFN
		QIO$_EFN(R9)
	MOVAB	CIB_Q_IOSB(R11),-		; DEFAULT TO CIB IOSB
		QIO$_IOSB(R9)
	MOVZWL	CRP_W_CHAN(R10),-		; SAVE VMS CHANNEL NUMBER
		QIO$_CHAN(R9)
	MOVZWL	#IO$_CAMIO,-			; QIO FUNCTION CODE
		QIO$_FUNC(R9)
	MOVL	QST_DATA(AP),-			; SAVE DATA BUFFER ADDR
		QIO$_P2(R9)			; IN QIO LIST
	MOVZWL	@QST_COUNT(AP),R0		; GET TRANSFER COUNT
	ASHL	#2,R0,R0			; CONVERT TO BYTE COUNT
						; FOR '24' BIT FORMAT
	BBC	#CSTS_V_M16,-			; CHECK CRP MEM STATE
		CRP_W_CSTS(R10),50$		; IF '16', SKIP
	ASHL	#-1,R0,R0			; CHANGE TO BYTE COUNT FOR
						; '16' BIT FORMAT
50$:
	MOVZWL	R0,QIO$_P3(R9)			; SAVE BCNT IN QIO LIST
	CASEB	QST_NARGS(AP),-			; HANDLE PARAMETERS BY CASE
		#QST_MINARGS,-
		#QST_MAXARGS
30$:
	.WORD	QST_THRU_DATA-30$		; PARAMETERS THRU DATA
	.WORD	QST_THRU_MEM-30$		; PARAMETERS THRU MEM
	.WORD	QST_THRU_IOSB-30$		; PARAMETERS THRU IOSB
	.WORD	QST_THRU_EFN-30$		; PARAMETERS THRU EFN
	.WORD	QST_THRU_AST-30$		; PARAMETERS THRU AST ADR
	.WORD	QST_THRU_ASTP-30$		; PARAMETERS THRU AST PARM

	MOVZWL	#SS$_TOOMUCHDATA,R0		; TOO MANY PARAMETERS
	BRW	90$				; EXIT ROUTINE

QST_THRU_ASTP:
	MOVL	QST_ASTP(AP),-			; COPY AST PARM TO QIO
		QIO$_ASTPRM(R9)			; PARM LIST
QST_THRU_AST:
	MOVL	QST_AST(AP),-			; COPY AST PROC ADDRESS
		QIO$_ASTADR(R9)			; TO QIO PARM LIST
QST_THRU_EFN:
	MOVZBL	QST_EFN(AP),-			; COPY EVENT FLAG NUMB TO
		QIO$_EFN(R9)			; QIO PARM LIST
QST_THRU_IOSB:
	TSTL	QST_IOSB(AP)			; CHECK FOR VALID IOSB
	BEQL	QST_THRU_MEM			; IF 0, NULL PARAMETER
	MOVL	QST_IOSB(AP),-			; ELSE, ASSUME VALID IOSB
		QIO$_IOSB(R9)			; ADDRESS FOR QIO
QST_THRU_MEM:
	TSTL	QST_MEM(AP)			; CHECK IF MEM SPECIFIED
	BEQL	QST_THRU_DATA			; IF 0, NULL PARAMETER
	MOVZWL	@QST_COUNT(AP),R0		; GET TRANSFER COUNT
	ASHL	#2,R0,R0			; CONVERT TO BYTE COUNT FOR
						; '24' BIT FORMAT
	BICW	#CSTS_M_M16,-			; CLEAR '16' MEM FORMAT
		CRP_W_CSTS(R10)
	CMPB	@QST_MEM(AP),#24		; CHECK FOR '24' FORMAT
	BEQL	60$				; IF MATCH, DONE
	ASHL	#-1,R0,R0			; CHANGE TO BYTE COUNT FOR
						; '16' BIT FORMAT
	BISW	#CSTS_M_M16,-			; SET CRP M16 FLAG
		CRP_W_CSTS(R10)
	CMPB	@QST_MEM(AP),#16		; CHECK FOR '16' FORMAT
	BEQL	60$				; IF MATCH, DONE
	MOVZWL	#SS$_BADPARAM,R0		; SET BAD PARAMETER
	BRW	90$				; EXIT ROUTINE
60$:
	MOVZWL	R0,QIO$_P3(R9)			; SAVE BCNT IN QIO LIST
QST_THRU_DATA:
	BSBW	CAM_BLDRTB			; BUILD CAMAC RTB
	MOVAB	CRP_Q_RTB(R10),-		; ADDRESS OF RTB AS QIO P1
		QIO$_P1(R9)
	BBC	#CRPS_V_WAIT,-			; CHECK IF WAIT/PROCEED
		CRP_W_STS(R10),80$		; IF 'WAIT' CLEAR, RETURN
	$QIOW_G	(R9)				; ISSUE QIO+WAIT CALL
	BRW	90$				; RETURN ON COMPLETION
80$:
	$QIO_G	(R9)				; ISSUE QIO CALL
	
90$:
	RET					; RETURN FROM PROCEDURE CALL
	.DSABL	LSB
	RET					; RETURN TO CALLER
	.DSABL	LSB
	.PAGE
	.SBTTL	CAM$STOP(W), CAMAC STOP ON WORD COUNT PROCEDURE
	.ENABL	LSB

;+++
;
;	Procedure:
;	CAM$STOP(W)(%DESCR(MODULE_NAME),A,F,COUNT,DATA[,MEM][,IOSB]
;		[,EFN][,AST][,ASTPRM])
;
;		Or
;	CAM$STOP(W)(%DESCR(KEY),A,F,COUNT,DATA,[,MEM][,IOSB]
;		[,EFN][,AST][,ASTPRM])
;
;	Description:
;	This procedure performs a CAMAC block transfer utilizing
;	only the specified transfer count(COUNT) to control the
;	number of times the specified CAMAC module is referenced
;	using a fixed subaddress(A) and function code(F). The
;	transaction terminates when either the transfer count is
;	exhausted or an anomolous condition is detected.
;	If the I/O status block parameter is specified, the
;	status of the CAMAC I/O operation is returned to that
;	quadword buffer. If not, the status is returned to a
;	quadword buffer in the CAMAC image block.
;
;	If the proceed mode call(CAM$STOP) is used, control returns
;	 to the caller as soon as the CAMAC request is queued to 
;	the system. If the wait mode call(CAM$STOPW) is used, control 
;	is returned to the calling program only when the CAMAC I/O 
;	is complete. 
;
;	The I/O synchronization parameters(EFN, AST and ASTP) are used
;	in the same manner as their counterparts in the QIO and QIOW
;	system services. See the VAX System Services Reference Manual
;	for further discussion if needed.
;
;
;	Parameters:
;	MODULE_NAME- address of a CHARACTER variable containing an ASCII 
;		character string identifying the CAMAC module to be referenced,
;	KEY- address of a longword descriptor for the key value
;		previously computed for the CAMAC module via
;		calling the procedure CAM$ASSIGN,
;	A- address of a byte containing CAMAC subaddress,
;	F- address of a byte containing CAMAC function code,
;	DATA- address of data buffer that contains CAMAC write data
;		or that will receive CAMAC read data.
;	COUNT- address of a word containing the CAMAC transfer
;		count(in units of the memory format).
;	MEM- address of a byte containing memory format for the
;		CAMAC transaction(MEM=16; MEM=24). If not specified,
;		the current CIB memory format specifier is used,
;	IOSB- address of a quadword buffer to receive I/O completion
;		status from the CAMAC request.
;
;	Optional I/O Synchronization Parameters:
;	EFN- value specifying the number of a local event flag
;		to be set upon I/O completion. If not specified, the
;		default process event flag from the CAMAC image block
;		is used,
;	AST- address of an AST procedure to receive an I/O completion
;		AST,
;	ASTPRM- address of a longword containing a parameter to
;		be passed to the specified AST procedure.
;
;
;	Return Status:
;
;---


;
; PROCEDURE LOCAL DATA
;
STP_NARGS	= 0				; ARGUMENT COUNT
STP_MOD		= 4				; MODULE NAME/KEY VALUE
STP_A		= 8				; SUBADDRESS
STP_F		= 12				; FUNCTION CODE
STP_COUNT	= 16				; TRANSFER COUNT
STP_DATA	= 20				; DATA BUFFER
STP_MEM		= 24				; MEMORY FORMAT(OPTIONAL)
STP_IOSB	= 28				; IOSB OFFSET
STP_EFN		= 32				; EVENT FLAG VALUE
STP_AST		= 36				; AST PROCEDURE ADDRESS
STP_ASTP	= 40				; AST PARAMETER VALUE

STP_MINARGS	= 5				; MIN ARG COUNT
STP_MAXARGS	= 10				; MAX ARG COUNT

;
;	WAIT MODE ENTRY POINT
;
	.ENTRY	CAM$STOPW,^M<R2,R3,R4,R5,R9,R10,R11>

	MNEGL	#1,R9				; SET WAIT MODE INDICATOR
	BRB	CAM_STOP			; JOIN COMMON FLOW

;
;	PROCEED MODE ENTRY POINT
;
	.ENTRY	CAM$STOP,^M<R2,R3,R4,R5,R9,R10,R11>

	CLRL	R9				; RESET WAIT MODE INDICATOR

CAM_STOP:					; COMMON STOP FLOW
	MOVAB	G^CAM_CIB,R11			; GET CAMAC IMAGE BLOCK ADDRESS
	BBS	#PSTS_V_JIBV,-			; IS JIB INFO VALID?
		CIB_L_PSTS(R11),10$		; IF SO, CONTINUE WITH IT
	JSB	G^CAM_GETJIB			; ELSE, GET NEW JIB/PCB INFO
10$:
	CMPB	STP_NARGS(AP),-			; CHECK AGANIST MIN ARG COUNT
		#STP_MINARGS
	BGEQ	20$				; IF SUFFICIENT, CONTINUE
	MOVL	#SS$_INSFARG,R0			; SET INSUFF ARGS STATUS
	BRW	90$				; EXIT ROUTINE
20$:
	ALOSTAK	#CRP_K_LENGTH,R10		; ALLOCATE CRP ON STACK
	JSB	G^CAM_INITCRP			; INITIALIZE CRP
	INSV	R9,#CRPS_V_WAIT,#CRPS_S_WAIT,-	; INSERT WAIT/PROCEED FLAG
		CRP_W_STS(R10)			; INTO CRP STATUS
	MOVW	CIB_W_CSTS(R11),-		; COPY CIB CAMAC STATE TO
		CRP_W_CSTS(R10)			; CRP CAMAC STATUS WORD
	MOVL	STP_MOD(AP),R1			; ADDRESS OF MODULE DESCRIPTOR
	JSB	G^CAM_MODULE			; GET MODULE PARAMETERS
	BLBS	R0,120$				; SUCCESS? CONTINUE IF SO.
	BRW	90$				; EXIT ROUTINE IF NOT
120$:
	MOVB	#3,CRP_B_MODE(R10)		; SET CAMAC MODE
	MOVB	@STP_A(AP),CRP_B_A(R10)		; COPY CAMAC SUBADDRESS
	MOVB	@STP_F(AP),CRP_B_F(R10)		; COPY CAMAC FUNCTION CODE
	MOVAB	CRP_L_QIOL(R10),R9		; USE R9 FOR QIO LIST POINTER
	MOVZBL	#QIO$_NARGS,(R9)		; SET QIO ARG COUNT
	MOVZBL	CIB_B_EFN(R11),-		; USE DEFAULT EFN
		QIO$_EFN(R9)
	MOVAB	CIB_Q_IOSB(R11),-		; DEFAULT TO CIB IOSB
		QIO$_IOSB(R9)
	MOVZWL	CRP_W_CHAN(R10),-		; SAVE VMS CHANNEL NUMBER
		QIO$_CHAN(R9)
	MOVZWL	#IO$_CAMIO,-			; QIO FUNCTION CODE
		QIO$_FUNC(R9)
	MOVL	STP_DATA(AP),-			; SAVE DATA BUFFER ADDR
		QIO$_P2(R9)			; IN QIO LIST
	MOVZWL	@STP_COUNT(AP),R0		; GET TRANSFER COUNT
	ASHL	#2,R0,R0			; CONVERT TO BYTE COUNT
						; FOR '24' BIT FORMAT
	BBC	#CSTS_V_M16,-			; CHECK CRP MEM STATE
		CRP_W_CSTS(R10),50$		; IF '16', SKIP
	ASHL	#-1,R0,R0			; CHANGE TO BYTE COUNT FOR
						; '16' BIT FORMAT
50$:
	MOVZWL	R0,QIO$_P3(R9)			; SAVE BCNT IN QIO LIST
	CASEB	STP_NARGS(AP),-			; HANDLE PARAMETERS BY CASE
		#STP_MINARGS,-
		#STP_MAXARGS
30$:
	.WORD	STP_THRU_DATA-30$		; PARAMETERS THRU DATA
	.WORD	STP_THRU_MEM-30$		; PARAMETERS THRU MEM
	.WORD	STP_THRU_IOSB-30$		; PARAMETERS THRU IOSB
	.WORD	STP_THRU_EFN-30$		; PARAMETERS THRU EFN
	.WORD	STP_THRU_AST-30$		; PARAMETERS THRU AST ADR
	.WORD	STP_THRU_ASTP-30$		; PARAMETERS THRU AST PARM

	MOVZWL	#SS$_TOOMUCHDATA,R0		; TOO MANY PARAMETERS
	BRW	90$				; EXIT ROUTINE

STP_THRU_ASTP:
	MOVL	STP_ASTP(AP),-			; COPY AST PARM TO QIO
		QIO$_ASTPRM(R9)			; PARM LIST
STP_THRU_AST:
	MOVL	STP_AST(AP),-			; COPY AST PROC ADDRESS
		QIO$_ASTADR(R9)			; TO QIO PARM LIST
STP_THRU_EFN:
	MOVZBL	STP_EFN(AP),-			; COPY EVENT FLAG NUMB TO
		QIO$_EFN(R9)			; QIO PARM LIST
STP_THRU_IOSB:
	TSTL	STP_IOSB(AP)			; CHECK FOR VALID IOSB
	BEQL	STP_THRU_MEM			; IF 0, NULL PARAMETER
	MOVL	STP_IOSB(AP),-			; ELSE, ASSUME VALID IOSB
		QIO$_IOSB(R9)			; ADDRESS FOR QIO
STP_THRU_MEM:
	TSTL	STP_MEM(AP)			; CHECK IF MEM SPECIFIED
	BEQL	STP_THRU_DATA			; IF 0, NULL PARAMETER
	MOVZWL	@STP_COUNT(AP),R0		; GET TRANSFER COUNT
	ASHL	#2,R0,R0			; CONVERT TO BYTE COUNT FOR
						; '24' BIT FORMAT
	BICW	#CSTS_M_M16,-			; CLEAR '16' MEM FORMAT
		CRP_W_CSTS(R10)
	CMPB	@STP_MEM(AP),#24		; CHECK FOR '24' FORMAT
	BEQL	60$				; IF MATCH, DONE
	ASHL	#-1,R0,R0			; CHANGE TO BYTE COUNT FOR
						; '16' BIT FORMAT
	BISW	#CSTS_M_M16,-			; SET CRP M16 FLAG
		CRP_W_CSTS(R10)
	CMPB	@STP_MEM(AP),#16		; CHECK FOR '16' FORMAT
	BEQL	60$				; IF MATCH, DONE
	MOVZWL	#SS$_BADPARAM,R0		; SET BAD PARAMETER
	BRW	90$				; EXIT ROUTINE
60$:
	MOVZWL	R0,QIO$_P3(R9)			; SAVE BCNT IN QIO LIST
STP_THRU_DATA:
	BSBW	CAM_BLDRTB			; BUILD CAMAC RTB
	MOVAB	CRP_Q_RTB(R10),-		; ADDRESS OF RTB AS QIO P1
		QIO$_P1(R9)
	BBC	#CRPS_V_WAIT,-			; CHECK IF WAIT/PROCEED
		CRP_W_STS(R10),80$		; IF 'WAIT' CLEAR, RETURN
	$QIOW_G	(R9)				; ISSUE QIO+WAIT CALL
	BRW	90$				; RETURN ON COMPLETION
80$:
	$QIO_G	(R9)				; ISSUE QIO CALL
	
90$:
	RET					; RETURN FROM PROCEDURE CALL
	.DSABL	LSB
	.PAGE
	.SBTTL	CAM$QREP(W), CAMAC Q-REPEAT PROCEDURE
	.ENABL	LSB

;+++
;
;	Procedure:
;	CAM$QREP(W)(%DESCR(MODULE_NAME),A,F,COUNT,DATA[,MEM][,IOSB]
;		[,EFN][,AST][,ASTPRM])
;
;		Or
;	CAM$QREP(W)(%DESCR(KEY),A,F,COUNT,DATA,[,MEM][,IOSB]
;		[,EFN][,AST][,ASTPRM])
;
;	Description:
;	This procedure performs a CAMAC block transfer utilizing
;	the module Q response to determine when the module has
;	responded with valid data or is ready to accept data. 
;	A Q response of 0 indicates valid data was not transmitted or
;	data was not accepted by the module. No DMA store/fetch 
;	operation is initiated and the A and F(and possibly data) are
;	repeated to the module. A Q response of 1 indicates
;	valid data was transmitted or data was accepted by the module.
;	Data is	stored/fetched and the A and F are repeated again.
;	The transaction terminates when (1) the specified transfer 
;	count(COUNT) is exhausted, (2) when the device driver software
;	timeout is exhausted or (3) an anomolous condition is
;	detected during the CAMAC transaction.

;	If the I/O status block parameter is specified, the
;	status of the CAMAC I/O operation is returned to that
;	quadword buffer. If not, the status is returned to a
;	quadword buffer in the CAMAC image block.
;
;	If the proceed mode call(CAM$QREP) is used, control returns
;	 to the caller as soon as the CAMAC request is queued to 
;	the system. If the wait mode call(CAM$QREPW) is used, control 
;	is returned to the calling program only when the CAMAC I/O 
;	is complete. 
;
;	The I/O synchronization parameters(EFN, AST and ASTP) are used
;	in the same manner as their counterparts in the QIO and QIOW
;	system services. See the VAX System Services Reference Manual
;	for further discussion if needed.
;
;
;	Parameters:
;	MODULE_NAME- address of a CHARACTER variable containing an ASCII 
;		character string identifying the CAMAC module to be referenced,
;	KEY- address of a longword descriptor for the key value
;		previously computed for the CAMAC module via
;		calling the procedure CAM$ASSIGN,
;	A- address of a byte containing CAMAC subaddress,
;	F- address of a byte containing CAMAC function code,
;	DATA- address of data buffer that contains CAMAC write data
;		or that will receive CAMAC read data.
;	COUNT- address of a word containing the CAMAC transfer
;		count(in units of the memory format).
;	MEM- address of a byte containing memory format for the
;		CAMAC transaction(MEM=16; MEM=24). If not specified,
;		the current CIB memory format specifier is used,
;	IOSB- address of a quadword buffer to receive I/O completion
;		status from the CAMAC request.
;
;	Optional I/O Synchronization Parameters:
;	EFN- value specifying the number of a local event flag
;		to be set upon I/O completion. If not specified, the
;		default process event flag from the CAMAC image block
;		is used,
;	AST- address of an AST procedure to receive an I/O completion
;		AST,
;	ASTPRM- address of a longword containing a parameter to
;		be passed to the specified AST procedure.
;
;
;	Return Status:
;
;---


;
; PROCEDURE LOCAL DATA
;
QRP_NARGS	= 0				; ARGUMENT COUNT
QRP_MOD		= 4				; MODULE NAME/KEY VALUE
QRP_A		= 8				; SUBADDRESS
QRP_F		= 12				; FUNCTION CODE
QRP_COUNT	= 16				; TRANSFER COUNT
QRP_DATA	= 20				; DATA BUFFER
QRP_MEM		= 24				; MEMORY FORMAT(OPTIONAL)
QRP_IOSB	= 28				; IOSB OFFSET
QRP_EFN		= 32				; EVENT FLAG VALUE
QRP_AST		= 36				; AST PROCEDURE ADDRESS
QRP_ASTP	= 40				; AST PARAMETER VALUE

QRP_MINARGS	= 5				; MIN ARG COUNT
QRP_MAXARGS	= 10				; MAX ARG COUNT

;
;	WAIT MODE ENTRY POINT
;
	.ENTRY	CAM$QREPW,^M<R2,R3,R4,R5,R9,R10,R11>

	MNEGL	#1,R9				; SET WAIT MODE INDICATOR
	BRB	CAM_QREP			; JOIN COMMON FLOW

;
;	PROCEED MODE ENTRY POINT
;
	.ENTRY	CAM$QREP,^M<R2,R3,R4,R5,R9,R10,R11>

	CLRL	R9				; RESET WAIT MODE INDICATOR

CAM_QREP:					; COMMON STOP FLOW
	MOVAB	G^CAM_CIB,R11			; GET CAMAC IMAGE BLOCK ADDRESS
	BBS	#PSTS_V_JIBV,-			; IS JIB INFO VALID?
		CIB_L_PSTS(R11),10$		; IF SO, CONTINUE WITH IT
	JSB	G^CAM_GETJIB			; ELSE, GET NEW JIB/PCB INFO
10$:
	CMPB	QRP_NARGS(AP),-			; CHECK AGANIST MIN ARG COUNT
		#QRP_MINARGS
	BGEQ	20$				; IF SUFFICIENT, CONTINUE
	MOVL	#SS$_INSFARG,R0			; SET INSUFF ARGS STATUS
	BRW	90$				; EXIT ROUTINE
20$:
	ALOSTAK	#CRP_K_LENGTH,R10		; ALLOCATE CRP ON STACK
	JSB	G^CAM_INITCRP			; INITIALIZE CRP
	INSV	R9,#CRPS_V_WAIT,#CRPS_S_WAIT,-	; INSERT WAIT/PROCEED FLAG
		CRP_W_STS(R10)			; INTO CRP STATUS
	MOVW	CIB_W_CSTS(R11),-		; COPY CIB CAMAC STATE TO
		CRP_W_CSTS(R10)			; CRP CAMAC STATUS WORD
	MOVL	QRP_MOD(AP),R1			; ADDRESS OF MODULE DESCRIPTOR
	JSB	G^CAM_MODULE			; GET MODULE PARAMETERS
	BLBS	R0,120$				; SUCCESS? CONTINUE IF SO.
	BRW	90$				; EXIT ROUTINE IF NOT
120$:
	MOVB	#8,CRP_B_MODE(R10)		; SET CAMAC MODE
	MOVB	@QRP_A(AP),CRP_B_A(R10)		; COPY CAMAC SUBADDRESS
	MOVB	@QRP_F(AP),CRP_B_F(R10)		; COPY CAMAC FUNCTION CODE
	MOVAB	CRP_L_QIOL(R10),R9		; USE R9 FOR QIO LIST POINTER
	MOVZBL	#QIO$_NARGS,(R9)		; SET QIO ARG COUNT
	MOVZBL	CIB_B_EFN(R11),-		; USE DEFAULT EFN
		QIO$_EFN(R9)
	MOVAB	CIB_Q_IOSB(R11),-		; DEFAULT TO CIB IOSB
		QIO$_IOSB(R9)
	MOVZWL	CRP_W_CHAN(R10),-		; SAVE VMS CHANNEL NUMBER
		QIO$_CHAN(R9)
	MOVZWL	#IO$_CAMIO,-			; QIO FUNCTION CODE
		QIO$_FUNC(R9)
	MOVL	QRP_DATA(AP),-			; SAVE DATA BUFFER ADDR
		QIO$_P2(R9)			; IN QIO LIST
	MOVZWL	@QRP_COUNT(AP),R0		; GET TRANSFER COUNT
	ASHL	#2,R0,R0			; CONVERT TO BYTE COUNT
						; FOR '24' BIT FORMAT
	BBC	#CSTS_V_M16,-			; CHECK CRP MEM STATE
		CRP_W_CSTS(R10),50$		; IF '16', SKIP
	ASHL	#-1,R0,R0			; CHANGE TO BYTE COUNT FOR
						; '16' BIT FORMAT
50$:
	MOVZWL	R0,QIO$_P3(R9)			; SAVE BCNT IN QIO LIST
	CASEB	QRP_NARGS(AP),-			; HANDLE PARAMETERS BY CASE
		#QRP_MINARGS,-
		#QRP_MAXARGS
30$:
	.WORD	QRP_THRU_DATA-30$		; PARAMETERS THRU DATA
	.WORD	QRP_THRU_MEM-30$		; PARAMETERS THRU MEM
	.WORD	QRP_THRU_IOSB-30$		; PARAMETERS THRU IOSB
	.WORD	QRP_THRU_EFN-30$		; PARAMETERS THRU EFN
	.WORD	QRP_THRU_AST-30$		; PARAMETERS THRU AST ADR
	.WORD	QRP_THRU_ASTP-30$		; PARAMETERS THRU AST PARM

	MOVZWL	#SS$_TOOMUCHDATA,R0		; TOO MANY PARAMETERS
	BRW	90$				; EXIT ROUTINE

QRP_THRU_ASTP:
	MOVL	QRP_ASTP(AP),-			; COPY AST PARM TO QIO
		QIO$_ASTPRM(R9)			; PARM LIST
QRP_THRU_AST:
	MOVL	QRP_AST(AP),-			; COPY AST PROC ADDRESS
		QIO$_ASTADR(R9)			; TO QIO PARM LIST
QRP_THRU_EFN:
	MOVZBL	QRP_EFN(AP),-			; COPY EVENT FLAG NUMB TO
		QIO$_EFN(R9)			; QIO PARM LIST
QRP_THRU_IOSB:
	TSTL	QRP_IOSB(AP)			; CHECK FOR VALID IOSB
	BEQL	QRP_THRU_MEM			; IF 0, NULL PARAMETER
	MOVL	QRP_IOSB(AP),-			; ELSE, ASSUME VALID IOSB
		QIO$_IOSB(R9)			; ADDRESS FOR QIO
QRP_THRU_MEM:
	TSTL	QRP_MEM(AP)			; CHECK IF MEM SPECIFIED
	BEQL	QRP_THRU_DATA			; IF 0, NULL PARAMETER
	MOVZWL	@QRP_COUNT(AP),R0		; GET TRANSFER COUNT
	ASHL	#2,R0,R0			; CONVERT TO BYTE COUNT FOR
						; '24' BIT FORMAT
	BICW	#CSTS_M_M16,-			; CLEAR '16' MEM FORMAT
		CRP_W_CSTS(R10)
	CMPB	@QRP_MEM(AP),#24		; CHECK FOR '24' FORMAT
	BEQL	60$				; IF MATCH, DONE
	ASHL	#-1,R0,R0			; CHANGE TO BYTE COUNT FOR
						; '16' BIT FORMAT
	BISW	#CSTS_M_M16,-			; SET CRP M16 FLAG
		CRP_W_CSTS(R10)
	CMPB	@QRP_MEM(AP),#16		; CHECK FOR '16' FORMAT
	BEQL	60$				; IF MATCH, DONE
	MOVZWL	#SS$_BADPARAM,R0		; SET BAD PARAMETER
	BRW	90$				; EXIT ROUTINE
60$:
	MOVZWL	R0,QIO$_P3(R9)			; SAVE BCNT IN QIO LIST
QRP_THRU_DATA:
	BSBW	CAM_BLDRTB			; BUILD CAMAC RTB
	MOVAB	CRP_Q_RTB(R10),-		; ADDRESS OF RTB AS QIO P1
		QIO$_P1(R9)
	BBC	#CRPS_V_WAIT,-			; CHECK IF WAIT/PROCEED
		CRP_W_STS(R10),80$		; IF 'WAIT' CLEAR, RETURN
	$QIOW_G	(R9)				; ISSUE QIO+WAIT CALL
	BRW	90$				; RETURN ON COMPLETION
80$:
	$QIO_G	(R9)				; ISSUE QIO CALL
	
90$:
	RET					; RETURN FROM PROCEDURE CALL
	.DSABL	LSB
	.PAGE
	.SBTTL	CAM_BLDRTB, BUILD CAMAC REGISTER TEMPLATE BLOCK
	.ENABL	LSB
;++
;
; CAM_BLDRTB: BUILD CAMAC RTB FROM CAMAC MODULE DATA FOUND IN THE
;	CAMAC REQUEST PACKET(CRP).
;
; Inputs:
;	R10	- address of the CRP.
;
; Outputs:
;	RTB fields of CRP,
;--

CAM_BLDRTB:

	ASSUME	RTB_K_LENGTH,EQ,8
	CLRQ	CRP_Q_RTB(R10)			; ZERO CRP RTB
	MOVAB	CRP_Q_RTB(R10),R1		; GET RTB BASE ADDR
;
;	BUILD CTR TEMPLATE
;
	ASSUME	SCT_V_QDC,EQ,PCT_V_QDC
	ASSUME	SCT_S_QDC,EQ,PCT_S_QDC
	ASSUME	SCT_V_M,EQ,PCT_V_M
	ASSUME	SCT_S_M,EQ,PCT_S_M
	EXTZV	#CSTS_V_QDC,#CSTS_S_QDC,-
		CRP_W_CSTS(R10),R0		; GET QDC STATE FROM CRP
	INSV	R0,#SCT_V_QDC,#SCT_S_QDC,-	; INSERT INTO CTR
		RTB_W_CTR(R1)
	INSV	CRP_B_MODE(R10),#SCT_V_M,-	; INSERT MODE FIELD
		#SCT_S_M,RTB_W_CTR(R1)
;
;	BUILD CMR TEMPLATE
;
	EXTZV	#CSTS_V_QNE,#CSTS_S_QNE,-
		CRP_W_CSTS(R10),R0		; GET QNE STATE
	INSV	R0,#CMR_V_QNE,#CMR_S_QNE,-	; INSERT IN CMD REG
		RTB_W_CMR(R1)
	EXTZV	#CSTS_V_XI,#CSTS_S_XI,-
		CRP_W_CSTS(R10),R0		; GET XI STATE
	INSV	R0,#CMR_V_XI,#CMR_S_XI,-	; INSERT INTO CMD REG
		RTB_W_CMR(R1)
	INSV	CRP_B_N(R10),#CMR_V_N,-		; INSERT STATION NUMBER
		#CMR_S_N,RTB_W_CMR(R1)
	INSV	CRP_B_A(R10),#CMR_V_A,-		; INSERT SUBADDRESS
		#CMR_S_A,RTB_W_CMR(R1)
	INSV	CRP_B_F(R10),#CMR_V_F,-		; INSERT FUNCTION CODE
		#CMR_S_F,RTB_W_CMR(R1)
;
;	BUILD CRATE/DATA HIGH TEMPLATE
;
	EXTZV	#CSTS_V_M16,#CSTS_S_M16,-
		CRP_W_CSTS(R10),R0		; GET MEM FORMAT BIT(16/24)
	INSV	R0,#CDH_V_16,#CDH_S_16,-	; INSERT MEM FORMAT BIT
		RTB_W_CDH(R1)			; INTO CDH TEMPLATE
	INSV	CRP_B_C(R10),#CDH_V_C,-		; INSERT CRATE NUMBER
		#CDH_S_C,RTB_W_CDH(R1)
	RSB					; RETURN TO CALLER
	.DSABL	LSB
	.PAGE
	.END