.TITLE	ACPOPN - IQ.OPN PROCESSING
	.SBTTL	ACPOPN - TITLE PAGE
	.IDENT	/V01.00/
;
; VERSION:	V01.00
;
; AUTHOR:	C.T. MICKELSON
;		GOODYEAR AEROSPACE CORPORATION
;		AKRON, OHIO 44315
;
; MODIFICATION HISTORY:
;
;	V01.00	CTM	01-DEC-82	ORIGINAL VERSION
;
; THIS ROUTINE PROCESSES THE IQ.OPN FUNCTION. A WINDOW BLOCK IS CREATED,
; A BLOCK OF POOL ALLOCATED FOR STORING HARDWARE CONTROL PARAMETERS,
; THE STAGING MEMORY MANAGER ALGORITHM EXECUTED, ADDITIONAL DATA STORED
; IN POOL, A FORTRAN CALLING SEQUENCE BUILT IN THE WINDOW,
; THE PROCESS IS COUNTED, AND THE FUNCTION RETURNED.
;
; INPUT:
;
;	R3 = IO PACKET ADDRESS
;	R5 = UCB ADDRESS
;
; OUTPUT:
;
;	SEE ABOVE EXPLANATION
;
; NOTES:
;
;	AN IQ.OPN FUNCTION HAS THE FOLLOWING USER IO PARAMETERS.
;
;	P1 - PDP-11 VIRTUAL CHANNEL DESCRIPTOR (VCD) VIRTUAL ADDRESS
;	P2 - VCD LENGTH IN BYTES
;	P3 - VIRTUAL CHANNEL NUMBER, NUMBER OF BUFFERS, NUMBER OF MOVES
;	P4 - NUMBER OF DIMENSIONS
;	P5 - PDP-11 STAGER BUFFER STATUS BLOCK VIRTUAL ADDRESS
;	P6 - STAGER BUFFER STATUS BLOCK LENGTH IN BYTES
;
;	THE FORMAT OF THE IQ.OPN PARAMETERS WHEN THE PACKET IS DEQUEUED
;	BY THE ACP IS AS FOLLOWS (THE REFORMATTING IS DONE BY THE MPP
;	DEVICE DRIVER):
;
;	I.PRM(R3) - VCD RELOCATION BIAS
;	 +02	  - VCD KAPR6 VIRTUAL ADDRESS
;	 +04	  - VCD LENGTH IN BYTES
;	 +06	  - VIRTUAL CHANNEL NUMBER, NUMBER OF BUFFERS, NUMBER OF MOVES
;	 +10	  - NUMBER OF DIMENSIONS
;	 +12	  - STAGER BUFFER STATUS BLOCK RELOCATION BIAS
;	 +14	  - STAGER BUFFER STATUS BLOCK KAPR 6 VIRTUAL ADDRESS
;	 +16	  - STAGER BUFFER STATUS BLOCK LENGTH IN BYTES
;
; REGISTERS:	USES R0-R5	SAVES R3,R5
;
; CALLS:	ACPDON,ACPPRC,$ALOCB,$DEACB
;
	.PAGE
	.SBTTL	ACPOPN - DECLARATIONS
	.DSABL	GBL
;
; MACRO LIBRARY CALLS:
;
;	SYMBOLS
;
	.MCALL	DRERR$,IOERR$,PKTDF$,UCBDF$
	DRERR$			;DEFINE DIRECTIVE ERROR CODE SYMBOLICS
	IOERR$			;DEFINE IO ERROR CODE SYMBOLICS
	PKTDF$			;DEFINE IO PACKET SYMBOLICS
	UCBDF$			;DEFINE UNIT CONTROL BLOCK SYMBOLICS
;
;	DIRECTIVES
;
;
;	OTHER MACROS
;
	.MCALL	CALL		;CALL SUBROUTINE
	.MCALL	CALLR		;CALL SUBROUTINE AND EXIT CALLER
;
; PSECT DEFINITIONS
;
	.PSECT	$CODE1,RO,I,REL,CON,LCL
	.PSECT	$PDATA,RO,D,REL,CON,LCL
	.PSECT	$VARS,RW,D,REL,CON,LCL
	.PSECT	SMMDAT,RW,D,REL,OVR,GBL
;
; GLOBAL DECLARATIONS
;
;	ACPOPN MODULE ENTRY POINTS
;
	.GLOBL	ACPOPN		;MODULE ENTRY POINT
;
; GLOBAL REFERENCES
;
;	SMMACP SUBROUTINES
;
	.GLOBL	ACPPRC		;STAGING MEMORY MANAGER ALGORITHM DRIVER
	.GLOBL	ACPDON		;FINISH IO REQUEST ROUTINE
	.GLOBL	ALLOST		;ALLOCATE STAGING MEMORY BUFFER ROUTINE
	.GLOBL	BITMAP		;STAGING MEMORY ALLOCATION BITMAP ADDRESS
	.GLOBL	RTNBLK		;RETURN DATA TO USER BUFFER
;
;	EXECUTIVE REFERENCES
;
	.GLOBL	$ALOCB
	.GLOBL	$DEACB
;
;	DEVICE DRIVER SYMBOL TABLE REFERENCES
;
;
;	OTHER REFERENCES
;
	.GLOBL	NMOVE		;NUMBER OF MOVES THRU STAGER
	.GLOBL	BASCNT		;NUMBER OF BASE ADDRESS ADJUSTMENT DIMENSIONS
	.GLOBL	RECSIZ		;RECORD SIZE IN BITS
	.GLOBL	BASADR		;STAGER BASE ADDRESS FOR EACH MOVE
	.GLOBL	BASWGT		;ADJUSTMENT WEIGHT FOR EACH ADJUSTMENT DIMENSION
	.GLOBL	BASLEN		;LENGTH OF EACH ADJUSTMENT DIMENSION
;
; LOCAL SYMBOLS
;
	.PAGE
;
; LOCAL (RO) DATA:
;
	.PSECT	$PDATA
BITLEN:	.WORD	BTLENG		;LENGTH OF MEMORY ALLOCATION BITMAP
BITGRN:	.WORD	BTGRAN		;GRANULARITY OF BITMAP
;
; LOCAL (RW) DATA:
;
	.PSECT	$VARS
STWDS:	.BLKW	2		;WORDS PER STGR BUFFER
PRCPAR:	.WORD	3		;ACPPRC SUBROUTINE CALLING SEQUENCE
	.WORD	0		;FILLED IN WITH IO PACKET ADDRESS
	.WORD	0		;FILLED IN WITH CONTROL PARAMETER BUFFER ADDRESS
	.WORD	STWDS
ALOPAR:	.WORD	7		;ALLOST SUBROUTINE CALLING SEQUENCE
	.WORD	BITMAP
	.WORD	BITLEN
	.WORD	BITGRN
	.WORD	STSBSB		;STAGER ADDRESS ADDRESS
	.WORD	STSBSB+10	;BUFFER LENGTH ADDRESS
	.WORD	0		;NBUFF ADDRESS FILLED IN PRIOR TO CALL
	.WORD	STSBSB+4	;TOTAL ALLOCATION ADDRESS
STSBSB:	.WORD	0,0		;STAGER BUFFER ADDRESS
	.WORD	0,0		;TOTAL STAGER ALLOCATION
	.WORD	0,0		;BUFFER LENGTH
LNSBSB=.-STSBSB
	.PAGE
	.SBTTL	ACPOPN - SUBROUTINE BODY
	.PSECT	$CODE1
	.ENABL	LSB
ACPOPN::
;
; CREATE A WINDOW BLOCK
;
	MOV	#W$SIZE,R1	;GET SIZE OF WINDOW
	CLR	R0		;CLEAR WINDOW ADDRESS
	SYSTEM	20$		;;ENTER SYSTEM STATE
	CALL	$ALOCB		;;ALLOCATE CORE BLOCK
	BCS	10$		;;IF CS - NO POOL
	MOV	R0,S.R0(SP)	;;RETURN BLOCK ADDRESS
10$:
	RETURN			;;EXIT SYSTEM STATE
20$:
	MOV	R0,R4		;SAVE WINDOW ADDRESS, IF ALLOCATED
	BNE	21$		;IF NE - CONTINUE
	JMP	580$		;ELSE, RETURN IE.NDR
21$:
;
; CREATE HARDWARE CONTROL PARAMETER BLOCK
;
	MOVB	I.PRM+7(R3),R1	;GET BUFFERS AND MOVES FROM IO PACKET
	ASH	#-4,R1		;SHIFT MOVES DOWN
	BIC	#^C<17>,R1	;SAVE MOVES VALUE
	MUL	#CTLENG,R1	;MULTIPLY BY BYTES PER MOVE
	CLR	R0		;CLEAR BLOCK ADDRESS
	SYSTEM	40$		;;ENTER SYSTEM STATE
	CALL	$ALOCB		;;ALLOCATE CORE BLOCK
	BCS	30$		;;IF CS - NO POOL
	MOV	R0,S.R0(SP)	;;RETURN BLOCK ADDRESS
	MOV	R1,S.R1(SP)	;;RETURN BLOCK LENGTH
30$:
	RETURN			;;EXIT SYSTEM STATE
40$:
	MOV	R0,W$AOUT(R4)	;SAVE OUTPUT BLOCK ADDRESS
	BNE	41$		;IF ALLOCATED, CONTINUE
	JMP	570$		;ELSE, RELEASE WINDOW AND RETURN IE.NDR
41$:
	MOV	R1,W$OUTP(R4)	;SAVE ALLOCATED BLOCK LENGTH
;
; FILL IN CALLING SEQUENCE FOR ACPPRC
;
	MOV	R0,PRCPAR+4	;SET OUTPUT DATA BLOCK ADDRESS
	MOV	R3,PRCPAR+2	;SET IO PACKET ADDRESS
;
; CLEAR HARDWARE CONTROL BLOCK
;
	ASR	R1		;CONVERT BYTE COUNT TO WORD COUNT
45$:
	CLR	(R0)+		;CLEAR A WORD
	SOB	R1,45$		;COUNT AND DO NEXT
;
; FILL IN WINDOW BLOCK CALLING SEQUENCE ADDRESSES
;
	MOV	R4,R0		;POINT TO BOTTOM OF WINDOW BLOCK
	MOV	R4,R1		;POINT AT CALLING SEQUENCE BLOCK
	ADD	#W$NPAR,R1
	MOV	#NPAR,(R1)+	;SET NUMBER OF PARAMETERS IN SEQUENCE
	MOV	#4,R2		;SET UP FOR NEXT FOUR PARAMETERS
50$:
	TST	(R0)+		;BUMP TO NEXT WINDOW ADDRESS
	MOV	R0,(R1)+	;STORE NEXT ADDRESS IN WINDOW BLOCK
	SOB	R2,50$		;COUNT AND DO NEXT PARAMETER
	MOV	#2,R2		;SET UP FOR NEXT TWO PARAMETERS
60$:
	TST	(R0)+		;BUMP TO NEXT WINDOW ADDRESS
	MOV	R0,(R1)+	;STORE NEXT ADDRESS IN WINDOW BLOCK
	TST	(R0)+		;LEAVE ROOM FOR INTEGER*4
	SOB	R2,60$
;
; SET UP TO CALL STAGING MEMORY MANAGER
;
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)
	MOV	#PRCPAR,R5	;SET UP CALLING SEQUENCE FOR ACPPRC
	CALL	ACPPRC		;DO STAGER ALGORITHM
	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	TST	R0		;TEST FUNCTION RETURN FROM ACPPRC
	BPL	65$		;IF POSITIVE, OK, CONTINUE
	JMP	530$		;ELSE, ERROR, CLEAN UP AND EXIT
65$:
	MOV	I.PRM+6(R3),R0	;GET VCN, BUFFER, MOVES PARAMETER FROM QIO
	MOV	R0,-(SP)	;SAVE IT FOR NOW
	BIC	#^C<377>,R0	;MASK VCN IN LOW BYTE
	MOV	R0,W$VCN(R4)	;SAVE VCN IN WINDOW
	MOV	(SP)+,R0	;RESTORE PARAMETER FROM STACK
	SWAB	R0		;BUFFERS, MOVES TO LOW BYTE
	BIC	#^C<17>,R0	;SAVE NUMBER OF BUFFERS
	MOV	R0,W$NBUF(R4)	;IN WINDOW
	MOV	W$ANBF(R4),ALOPAR+14 ;FILL ADDRESS OF NBUFF INTO ALLOST CALL
;
; STORE NUMBER OF WORDS IN STAGER BUFFER IN WINDOW AND STATUS BLOCK
;
	MOV	STWDS,R0
	MOV	R0,W$STBL(R4)
	MOV	R0,STSBSB+10
	MOV	STWDS+2,R0
	MOV	R0,W$STBL+2(R4)
	MOV	R0,STSBSB+12
;
; ALLOCATE STAGER MEMORY BUFFER SPACE
;
	MOV	R3,-(SP)	;SAVE IO PACKET ADDRESS
	MOV	R4,-(SP)	;SAVE WINDOW BLOCK ADDRESS
	MOV	R5,-(SP)	;SAVE UCB ADDRESS
	MOV	#ALOPAR,R5	;SET UP CALL TO ALLOCATE MEMORY
	CALL	ALLOST		;ALLOCATE VIRTUAL CHANNEL BUFFER
	MOV	(SP)+,R5	;RESTORE REGISTERS
	MOV	(SP)+,R4
	MOV	(SP)+,R3
;
; RETURN STAGER BUFFER STATUS TO USER PROGRAM
;
	MOV	R0,-(SP)	;SAVE ALLOCATION FUNCTION RESULT
	MOV	#LNSBSB,R0	;SET BYTE LENGTH OF TRANSFER
	MOV	#STSBSB,R1	;POINT TO STAGER BUFFER STATUS BLOCK
	MOV	R3,R2		;POINT TO USER BUFFER ADDRESS DOUBLEWORD
	ADD	#I.PRM+12,R2
	CALL	RTNBLK		;RETURN STATUS TO USER
;
; CHECK IF BUFFER SPACE ALLOCATED SUCCESSFULLY
;
	MOV	(SP)+,R0	;RESTORE ALLOCATION FUNCTION RESULT
	BPL	68$		;CONTINUE IF SUCCESSFUL
	JMP	530$		;ELSE, DELETE VIRTUAL CHANNEL STRUCTURES
68$:
	MOV	STSBSB,W$STBA(R4) ;STORE STAGER BUFFER ADDRESS IN WINDOW
	MOV	STSBSB+2,W$STBA+2(R4)
	MOV	NMOVE,R0	;GET NUMBER OF MOVES
	MOV	R0,W$NMOV(R4)	;SAVE IN WINDOW
;
; FIND MAXIMUM NUMBER OF ADJUSTABLE DIMENSIONS
;
	CLR	R1		;INITIALIZE MAXIMUM
	MOV	#BASCNT,R2	;POINT AT LIST IN COMMON
70$:
	CMP	R1,(R2)		;TEST FOR MAXIMUM
	BGE	80$		;IF STILL LARGEST, CONTINUE
	MOV	(R2),R1		;ELSE, SET NEW MAXIMUM
80$:
	TST	(R2)+		;POINT TO NEXT ENTRY
	SOB	R0,70$		;COUNT AND DO NEXT
	MOV	R1,W$VDIM(R4)	;STORE VARIBLE DIMENSION COUNT IN WINDOW
;
; CALCULATE SIZE OF SUPPLEMENTARY POOL REQUIRED
;
	MUL	#8.,R1		;COMPUTE BYTES PER DIMENSION * VDIM
	ADD	#10.,R1		;ADD ADDITIONAL BYTES PER MOVE
	MUL	NMOVE,R1	;MULTIPLY BY NUMBER OF MOVES
;
; ALLOCATE SUPPLEMENTARY POOL BLOCK
;
;	NOTE R0 ALREADY CLEAR
;
	SYSTEM	100$		;;ENTER SYSTEM STATE
	CALL	$ALOCB		;;ALLOCATE CORE BLOCK
	BCS	90$		;;IF CS - NO POOL
	MOV	R0,S.R0(SP)	;;RETURN BLOCK ADDRESS
	MOV	R1,S.R1(SP)	;;RETURN BLOCK LENGTH
90$:
	RETURN			;;EXIT SYSTEM STATE
100$:
	MOV	R0,W$AREC(R4)	;SAVE SUPPLEMENTARY BLOCK ADDRESS, IF ALLOCATED
	BEQ	520$		;IF EQ - NO, RELEASE BLOCK, WINDOW, RETURN IE.NDR
	MOV	R1,W$SUPP(R4)	;SAVE BLOCK LENGTH IN WINDOW
	MOV	W$NMOV(R4),-(SP) ;GET NUMBER OF MOVES TO STACK
;
; MOVE RECSIZ(1-NMOVE) TO POOL
;
	MOV	(SP),R1		;COPY NUMBER OF MOVES INTO REGISTER
	MOV	#RECSIZ,R2	;SET UP TO MOVE RECSIZ ARRAY TO POOL BLOCK
110$:
	MOV	(R2)+,(R0)+	;MOVE AN ENTRY
	MOV	(R2)+,(R0)+	;INTEGER*4 ENTRY
	SOB	R1,110$		;COUNT AND DO NEXT
;
; MOVE BASADR(1-NMOVE) TO POOL
;
	MOV	R0,W$AADR(R4)	;SAVE ADDRESS OF BASADR ARRAY IN POOL
	MOV	(SP),R1		;COPY NUMBER OF MOVES INTO REGISTER
	MOV	#BASADR,R2	;SET UP TO MOVE BASADR ARRAY TO POOL BLOCK
120$:
	MOV	(R2)+,(R0)+	;MOVE AN ENTRY
	MOV	(R2)+,(R0)+	;INTEGER*4 ENTRY
	SOB	R1,120$		;COUNT AND DO NEXT
;
; MOVE BASCNT(1-NMOVE) TO POOL
;
	MOV	R0,W$ACNT(R4)	;SAVE ADDRESS OF BASCNT ARRAY IN POOL
	MOV	(SP),R1		;COPY NUMBER OF MOVES INTO REGISTER
	MOV	#BASCNT,R2	;SET UP TO MOVE BASCNT ARRAY TO POOL BLOCK
130$:
	MOV	(R2)+,(R0)+	;MOVE AN ENTRY
	SOB	R1,130$		;COUNT AND DO NEXT
;
; INITIALIZE BASWGT, BASLEN, AND BASCUR ADDRESS PARAMETERS IF VDIM = 0
;
	MOV	#-1,R1
	MOV	R1,W$AWGT(R4)	;ASSUME NO VARIABLE DIMENSIONS
	MOV	R1,W$ALEN(R4)
	MOV	R1,W$ACUR(R4)
	MOV	R1,W$APKT(R4)	;INIT IO PACKET ADDRESS AS WELL
	TST	W$VDIM(R4)	;TEST IF ANY VARIABLE DIMENSIONS
	BEQ	200$		;IF ZERO - NONE, SKIP; ELSE, CONTINUE
;
; MOVE BASWGT(1-VDIM,1-NMOVE) TO POOL
;
	MOV	R0,W$AWGT(R4)	;SAVE ADDRESS OF BASWGT ARRAY IN POOL
	MOV	(SP),-(SP)	;DUPLICATE NMOVE ON STACK
	MOV	#BASWGT,-(SP)	;SET UP TO MOVE BASWGT ARRAY TO POOL BLOCK
140$:
	MOV	(SP),R2		;SET BASE ADDRESS OF CURRENT ARRAY COLUMN
	MOV	W$VDIM(R4),R1	;GET NUMBER OF DIMENSIONS TO MOVE
150$:
	MOV	(R2)+,(R0)+	;MOVE AN ENTRY
	MOV	(R2)+,(R0)+	;INTEGER*4 ENTRY
	SOB	R1,150$		;COUNT AND DO NEXT
	ADD	#4*NADJMX,(SP)	;POINT TO NEXT COLUMN OF ARRAY
	DEC	2(SP)		;COUNT THIS COLUMN
	BNE	140$		;DO NEXT COLUMN
;
; MOVE BASLEN(1-VDIM,1-NMOVE) TO POOL
;
	MOV	R0,W$ALEN(R4)	;SAVE ADDRESS OF BASLEN ARRAY IN POOL
	MOV	4(SP),2(SP)	;DUPLICATE NMOVE
	MOV	#BASLEN,(SP)	;SET UP TO MOVE BASLEN ARRAY TO POOL BLOCK
160$:
	MOV	(SP),R2		;SET BASE ADDRESS OF CURRENT ARRAY COLUMN
	MOV	W$VDIM(R4),R1	;GET NUMBER OF DIMENSIONS TO MOVE
170$:
	MOV	(R2)+,(R0)+	;MOVE AN ENTRY
	SOB	R1,170$		;COUNT AND DO NEXT
	ADD	#2*NADJMX,(SP)	;POINT TO NEXT COLUMN OF ARRAY
	DEC	2(SP)		;COUNT THIS COLUMN
	BNE	160$		;DO NEXT COLUMN
;
; INITIALIZE BASCUR(1-VDIM,1-NMOVE) IN POOL
;
	MOV	R0,W$ACUR(R4)	;SAVE ADDRESS OF BASCUR ARRAY IN POOL
	MOV	4(SP),2(SP)	;DUPLICATE NMOVE
180$:
	MOV	W$VDIM(R4),R1	;GET NUMBER OF DIMENSIONS TO INITIALIZE
190$:
	CLR	(R0)+		;CLEAR AN ENTRY
	SOB	R1,190$		;COUNT AND DO NEXT
	DEC	2(SP)		;COUNT THIS COLUMN
	BNE	180$		;DO NEXT COLUMN
;
; DONE BUILDING SUPPLEMENTARY POOL DATA STRUCTURE
;
	ADD	#4,SP		;CLEAN THE STACK OF ADDRESS AND NMOVE COPY
200$:
	TST	(SP)+		;CLEAN OFF FIRST NMOVE VALUE
;
; LINK NEW WINDOW INTO PROCESS CHAIN
;
	MOV	@I.LN2(R3),R0	;LINK NEW WINDOW TO LIST
	BIC	#1,R0		;CLEAR LOCK BIT
	MOV	R0,(R4)		;POINT NEW BLOCK TO OLD
	BIC	#^C<1>,@I.LN2(R3) ;CLEAR OLD WINDOW ADDRESS
	BIS	R4,@I.LN2(R3)	;SET NEW WINDOW ADDRESS, WITH SAME LOCK BIT
	INC	@U.VCB(R5)	;INCREMENT PROCESS COUNT
;
; SET STATUS AND RETURN IO FUNCTION
;
	MOV	#IS.SUC&377,R0	;SET SUCCESSFUL STATUS
	BR	590$		;GO CLEAN UP FUNCTION
520$:
	MOV	#IE.NDR&377,R0	;SET NO POOL ERROR
	BR	540$		;CONTINUE IN COMMON CODE
530$:
	SWAB	R0		;GET ALGORITHM ERROR TO UPPER BYTE
	BIC	#377,R0		;CLEAR LOW BYTE
	BIS	#IE.ABO&377,R0	;SET ABORT ERROR CODE
540$:
	MOV	R0,-(SP)	;SAVE FINAL IO STATUS
	MOV	W$AOUT(R4),R0	;RELEASE OUTPUT PARAMETER BLOCK
	MOV	W$OUTP(R4),R1	;GET BLOCK LENGTH
	SYSTEM	550$		;;ENTER SYSTEM STATE
	CALLR	$DEACB		;;DEALLOCATE CORE BLOCK
550$:
	MOV	R4,R0		;RELEASE WINDOW BLOCK
	MOV	#W$SIZE,R1	;SET BLOCK LENGTH
	SYSTEM	560$		;;ENTER SYSTEM STATE
	CALLR	$DEACB		;;DEALLOCATE CORE BLOCK
560$:
	MOV	(SP)+,R0	;GET FINAL IO STATUS
	BR	590$		;RETURN IO FUNCTION
570$:
	MOV	R4,R0		;RELEASE THE WINDOW BLOCK
	MOV	#W$SIZE,R1	;SET BLOCK LENGTH
	SYSTEM	580$		;;ENTER SYSTEM STATE
	CALLR	$DEACB		;;DEALLOCATE CORE BLOCK
580$:
	MOV	#IE.NDR&377,R0	;SET IE.NDR ERROR
590$:
	CALLR	ACPDON		;FINISH PACKET AND RETURN
	.DSABL	LSB
	.END