NU.MAC Ethernet port handler source code file for system generation for UNIBUS processors (DEUNA and DELUA controllers) - DEC RT-11 PDP-11 Ethernet Network Device Driver; see https://supratim-sanyal.blogspot.com/2021/12/rt-11-on-pdp-1145-adventures-running.html

NU.MAC

.MCALL	.MODULE
.MODULE	NU,VERSION=15,COMMENT=<DEUNA Port Handler>,AUDIT=NO

;                   COPYRIGHT 1989, 1990, 1991 BY
;           DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;                        ALL RIGHTS RESERVED
;
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED
;ONLY  IN  ACCORDANCE  WITH  THE TERMS  OF  SUCH  LICENSE AND WITH THE
;INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR  ANY OTHER
;COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
;OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE  SOFTWARE  IS HEREBY
;TRANSFERRED.
;
;THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE  WITHOUT NOTICE
;AND  SHOULD  NOT  BE  CONSTRUED AS  A COMMITMENT BY DIGITAL EQUIPMENT
;CORPORATION.
;
;DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF ITS
;SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY DIGITAL.








	.SBTTL	CONDITIONAL ASSEMBLY SUMMARY








	NI$UNA	= 1
	.INCLUDE "SRC:NI.MAC"








	.SBTTL	DEUNA Port Handler Edit History








	.SBTTL	DEUNA Port Handler Definitions
	.AUDIT	.NI
	.AUDIT	.NU
	.MCALL	.ADDR,	.ASSUM,	.BR
	.MCALL	.WAIT
	.MCALL	.MRKT,	.CMKT
	.MCALL	.READC
	.IIF NDF RBUFCT	RBUFCT = 6.
	RBUFSZ	=: 1600.
	XBUFCT	=: 1
	XBUFSZ	=: 1600.
	UDBBSZ	=: <32.*2>
	EMEMSZ	= <<RBUFCT*RBUFSZ>+<XBUFCT*XBUFSZ>+UDBBSZ>/2
	EMEMSZ	= <EMEMSZ+<KTGRAN-1>>/KTGRAN
	.Assume RBUFCT GE 1 MESSAGE=<Too few receive buffers defined>
	.Assume XBUFCT EQ 1 MESSAGE=<No support for multiple transmit buffers>
	MXPUMR	==: 7
	RUMRCT	==: <<RBUFCT*RBUFSZ>+XBUFSZ+UDBBSZ+17777>/2&77777/10000+1
	.Assume	RUMRCT LE MXPUMR MESSAGE=<Too many UMR's required>
	.MACRO	BEQ.	DST,?LOC
	BNE	LOC
	JMP	DST
LOC:
	.ENDM
	.MACRO	BNE.	DST,?LOC
	BEQ	LOC
	JMP	DST
LOC:
	.ENDM
	BLOCK0 	=: 0
	BLOCK1	=: 1000








	.SBTTL	DEUNA Port Handler Device Definitions
	UN$CS0	=: 0
	UN$CS1	=: 2
	UN$CS2	=: 4
	UN$CS3	=: 6
	C0.SEI	=: 100000
	C0.CEI	=: 040000
	C0.RXI	=: 020000
	C0.TXI	=: 010000
	C0.DNI	=: 004000
	C0.BUI	=: 002000
	C0.FEI	=: 001000
	C0.SCI	=: 000400
	C0.IS	=: 000200
	C0.IE	=: 000100
	C0.RSE	=: 000040
	C0.CMK	=: 000017
	PC.NOP	=: 00
	PC.GP	=: 01
	PC.GC	=: 02
	PC.ST	=: 03
	PC.STA	=: 04
	PC.BOO	=: 05
	PC.PD	=: 10
	PC.HLT	=: 16
	PC.STO	=: 17
	C1.XOK	=: 100000
	C1.COK	=: 040000
	C1.EMK	=: 037400
	C1.TMO	=: 000200
	C1.DID	=: 000160
	C1.SMK	=: 000017
	PS.RES	=: 00
	PS.PL	=: 01
	PS.RDY	=: 02
	PS.RUN	=: 03
	PS.UH	=: 05
	PS.NH	=: 06
	PS.NUH	=: 07
	PS.PH	=: 10
	PS.SL	=: 17








	.SBTTL	DEUNA Port Handler Data Structure Definitions
	PCB.F0	=: 0
	PCB.F1	=: 1
	PCB.F2	=: 2
	PCB.F4	=: 4
	PCB.F6	=: 6
	PCB.SZ	=: 10
	PF.NOP	=: 00
	PF.LSM	=: 01
	PF.RDA	=: 02
	PF.RPA	=: 04
	PF.WPA	=: 05
	PF.RMA	=: 06
	PF.WMA	=: 07
	PF.RRF	=: 10
	PF.WRF	=: 11
	PF.RC	=: 12
	PF.RCC	=: 13
	PF.RM	=: 14
	PF.WM	=: 15
	PF.RS	=: 16
	PF.RSC	=: 17
	PF.DIM	=: 20
	PF.LIM	=: 21
	PF.RID	=: 22
	PF.WID	=: 23
	PF.RLA	=: 24
	PF.WLA	=: 25
	F2.PM	=: 100000
	F2.AM	=: 040000
	F2.DDC	=: 020000
	F2.TPE	=: 010000
	F2.ECT	=: 004000
	F2.DMM	=: 001000
	F2.ILM	=: 000100
	F2.DTC	=: 000010
	F2.LOP	=: 000004
	F2.HDM	=: 000001
	F2.ES	=: 100000
	F2.ME	=: 040000
	F2.BBL	=: 020000
	F2.CTE	=: 010000
	F2.TE	=: 004000
	F2.RRE	=: 001000
	F2.TRE	=: 000400
	F2.PAT	=: 000200
	F2.RMO	=: 000100
	F2.RMK	=: 000077
	TD.LEN	=: 0
	TD.ADL	=: 2
	TD.ADH	=: 4
	TD.STA	=: 6
	TD.ESZ	=: 10
	AH.OWN	=: 100000
	AH.ERS	=: 040000
	AH.MAT	=: 020000
	AH.MRT	=: 010000
	AH.ONE	=: 004000
	AH.DEF	=: 002000
	AH.STP	=: 001000
	AH.ENP	=: 000400
	AH.HOM	=: 000003
	ST.BLE	=: 100000
	ST.UTO	=: 040000
	ST.UF	=: 020000
	ST.LCO	=: 010000
 	ST.LCA	=: 004000
	ST.RTY	=: 002000
	ST.TDR	=: 001777
	RD.LEN	=: 0
	RD.ADL	=: 2
	RD.ADH	=: 4
	RD.STA	=: 6
	RD.ESZ	=: 10
	AH.FE	=: 020000
	AH.OVF	=: 010000
	AH.CRC	=: 004000
	ST.NCH	=: 020000
	ST.OE	=: 010000
	ST.LMK	=: 007777








	.SBTTL	DEUNA Port Handler Installation Code
	.ENABL	LSB
	.DRINS	NI
	BR	10$
5$:	SEC
	RETURN
10$:	MOV	R0,-(SP)
	.WAIT	#0
	MOV	(SP)+,R0
	.IF EQ TIM$IT
	BCC	5$
	.IFF
	BCS	20$
	CLRB	SEMTCH
	MOV	@R3,HNDBLK
	.ENDC
20$:	MOV	#INSOVR/2,R3
	JMP	GETOVR
	.DSABL	LSB
	.Assume . LE 400 MESSAGE=<INSTALL code too large>








	.SBTTL	DEUNA Port Handler Set Options
	.DRSET	CSR,	160000,		O.CSR,	OCT
	.DRSET	VECTOR,	500,		O.VEC,	OCT
	.DRSET	SHOW,	O.SHOW/2,	GETOVR








	.SBTTL	DEUNA Port Handler Set Code
O.CSR:	CMP	R0,R3
	BLO	O.ERR
	MOV	R0,INSCSR
	MOV	R0,DISCSR
	MOV	R0,NICSR
	BR	O.NORM
O.VEC:	CMP	R0,R3
	BHIS	O.ERR
	MOV	R0,NISTRT
	MOV	R0,NIVEC
	BR	O.NORM








	.SBTTL	DEUNA Port Handler Set/Install Code Overlay Handler
	.ENABL	LSB
GETBK1:	MOV	#O.EXIT/2,R3
	SWAB	R3
	MOV	#1,SEMTBK
	BR	5$
GETOVR:	CMPB	-(R3),-(R3)
	NOP
	.Assume	. EQ GETOVR+4 MESSAGE=<NO entry out of place>
	CMPB	(R3)+,(R3)+
	SWAB	R3
	MOVB	R3,SEMTBK
5$:
HNDBLK =: .+2
	ADD	#.-.,SEMTBK
	.ADDR	#BLOCK1,R5,PUSH
	MOV	R5,SEMTBF
	MOV	(SP)+,R5
	JSR	R0,10$
SEMTCH:	 .BYTE	17
SEMTFN:	 .BYTE	10
SEMTBK:	 .BLKW
SEMTBF:	 .BLKW
	 .WORD	256.
	 .WORD	0
10$:	.READC	CODE=NOSET
	MOV	(SP)+,R0
	BCS	O.ERR
	CLRB	R3
	SWAB	R3
	ASL	R3
	ADD	SEMTBF,R3
	CMP	SEMTBK,#1
	BNE	20$
	ADD	#<BLOCK0-BLOCK1>,R3
20$:
	JMP	@R3
	.DSABL	LSB
O.NORM:	TST	(PC)+
O.ERR:	SEC
	RETURN
O.EXIT:	ROR	R2
	RETURN
	.Assume . LE 1000 MESSAGE=<SET code too large>








	.SBTTL	LOAD	- DEUNA Port Handler LOAD Code
	.SBTTL	UNLOAD	- DEUNA Port Handler UNLOAD Code
	.PSECT	SETOVR
LOAD::
	MOV	@#SYSPTR,R4
	MOV	P1EXT(R4),R4
	MOV	@R5,R5
	MOV	R5,-(SP)
	ADD	#<NINAME-NILQE>,R5
	CALL	FINDGR(R4)
	MOV	(SP)+,R5
	MOV	GR.ADR(R1),<NIXADR-NILQE>(R5)
	MOV	R5,R4
	ADD	#<FQELEM-NILQE>,R4
	MOV	#20000,Q$BUFF(R4)
	MOV	R5,R2
	MOV	<NIXADR-NILQE>(R2),Q$PAR(R4)
	ADD	#<RBFMTB-NILQE>,R2
	MOV	#RBUFCT,R3
10$:	MOV	Q$BUFF(R4),(R2)+
	MOV	Q$PAR(R4),(R2)+
	ADD	#RBUFSZ,Q$BUFF(R4)
	CALL	<FIXPAR-NILQE>(R5)
	SOB	R3,10$
	.Assume	XBFMTB EQ RBFMTB+<<RBUFCT*2>*2>
	MOV	Q$BUFF(R4),(R2)+
	MOV	Q$PAR(R4),(R2)+
	ADD	#XBUFSZ,Q$BUFF(R4)
	CALL	<FIXPAR-NILQE>(R5)
	.Assume	UDBMTB EQ XBFMTB+<<XBUFCT*2>*2>
	MOV	Q$BUFF(R4),(R2)+
	MOV	Q$PAR(R4),@R2
	MOV	#<RUMRCT-1>,R0
	CLR	R1
	BISB	<NIXADR-NILQE>(R5),R1
	SWAB	R1
	CLR	R2
	BISB	<NIXADR+1-NILQE>(R5),R2
	ROR	R2
	ROR	R1
	ROR	R2
	ROR	R1
	MOV	@#SYSPTR,R3
	MOV	$H2UB(R3),R3
	MOV	R5,R4
	ADD	#<NUHNAM-NILQE>,R4
	CALL	UBALL
	BCS	60$
	MOV	R5,R0
	ADD	#<RBFATB-NILQE>,R0
	MOV	R3,-(SP)
	MOV	#RBUFCT,R3
20$:	MOV	R1,(R0)+
	MOV	R2,(R0)+
	ADD	#RBUFSZ,R1
	ADC	R2
	SOB	R3,20$
	MOV	(SP)+,R3
	.Assume	XBFADD EQ RBFATB+<<RBUFCT*2>*2>
	MOV	R1,(R0)+
	MOV	R2,(R0)+
	ADD	#XBUFSZ,R1
	ADC	R2
	.Assume	UDBADD EQ XBFADD+<<XBUFCT*2>*2>
	MOV	R1,(R0)+
	MOV	R2,@R0
	MOV	#1,R0
	MOV	R5,R1
	ADD	#<PCB-NILQE>,R1
	CLR	R2
	MOV	R5,R4
	ADD	#<NULNAM-NILQE>,R4
	CALL	UBALL
	BCS	40$
	MOV	R5,R0
	ADD	#<PCBADD-NILQE>,R0
	MOV	R1,(R0)+
	MOV	R2,(R0)+
	ADD	#<RCVBDL-PCB>,R1
	ADC	R2
	.Assume	RBDLAD EQ <PCBADD+<2*2>>
	MOV	R1,(R0)+
	MOV	R2,(R0)+
	ADD	#<XMTBDL-RCVBDL>,R1
	ADC	R2
	.Assume	XBDLAD EQ <RBDLAD+<2*2>>
	MOV	R1,(R0)+
	MOV	R2,@R0
	MOV	<NICSR-NILQE>(R5),R0
	MOV	<PCBADD-NILQE>(R5),UN$CS2(R0)
	MOV	<PCBADD+2-NILQE>(R5),UN$CS3(R0)
	.Assume	UN$CS0 EQ 0
	MOVB	#PC.GP,@R0
	CALL	LWAIT
	MOV	#PF.RDA,<PCB+PCB.F0-NILQE>(R5)
	.Assume	UN$CS0 EQ 0
	MOVB	#PC.GC,@R0
	CALL	LWAIT
	MOV	#PF.WPA,<PCB+PCB.F0-NILQE>(R5)
	.Assume	UN$CS0 EQ 0
	MOVB	#PC.GC,@R0
	CALL	LWAIT
	MOV	R5,R0
	ADD	#<PCB+PCB.F2-NILQE>,R0
	MOV	R5,R1
	ADD	#<NIPHAD-NILQE>,R1
	MOV	#6.,R2
30$:	MOVB	(R0)+,(R1)+
	SOB	R2,30$
	MOV	<NICSR-NILQE>(R5),R0
	MOV	#PF.RS,<PCB+PCB.F0-NILQE>(R5)
	.Assume	UN$CS0 EQ 0
	MOVB	#PC.GC,@R0
	CALL	LWAIT
	CLR	<MAXMLT-NILQE>(R5)
	MOVB	<PCB+PCB.F4-NILQE>(R5),<MAXMLT-NILQE>(R5)
	BR	50$
40$:	CALL	UNLOAD
	BR	60$
50$:	TST	(PC)+
60$:	SEC
	RETURN
UBALL:	MOV	R3,-(SP)
	MOV	R5,-(SP)
	CALL	UB.ALL(R3)
	MOV	(SP)+,R5
	MOV	(SP)+,R3
	RETURN
UNLOAD::
	MOV	@#SYSPTR,R3
	MOV	$H2UB(R3),R3
	MOV	@R5,R1
	ADD	#<NUHNAM-NILQE>,R1
	MOV	R3,-(SP)
	CALL	UB.RLS(R3)
	MOV	(SP)+,R3
	MOV	@R5,R1
	ADD	#<NULNAM-NILQE>,R1
	CALL	UB.RLS(R3)
	CLC
	RETURN
LWAIT:
	.Assume UN$CS0 EQ 0
	.Assume C0.IS EQ 200
	TSTB	@R0
	BPL	LWAIT
	MOVB	UN$CS0+1(R0),UN$CS0+1(R0)
	RETURN
	.ASSUME <. - LODOVR> LE 1000 MESSAGE=<LOAD overlay overflow>








	.SBTTL	INIT	- OnceOnly Initialization Code
	.PSECT	NIDVR
INIT:	MOV	@#SYSPTR,R0
	MOV	P1EXT(R0),R0
	ADD	#BLKMOV,R0
	MOV	R0,$BLKMV
	CLC
	RETURN








	.SBTTL	ENABLE	- Enables Interrupts
	.PSECT	NIDVR
ENABLE:	CALL	RESRNG
	MOV	#-1,XMITFG
	MOV	#-1,RECVFG
	MOV	NICSR,R0
	.Assume	UN$CS0 EQ 0
	MOVB	#PC.STA,@R0
	CALL	ISWAIT
	MOV	UN$CS1(R0),-(SP)
	BIC	#^C<C1.SMK>,(SP)
	CMP	(SP)+,#PS.RUN
	BNE	10$
	.Assume	UN$CS0 EQ 0
	MOVB	#<C0.IE!PC.NOP>,@R0
	TST	(PC)+
10$:	SEC
	RETURN








	.SBTTL	DISABL	- Disable Interrupts
	.PSECT	NIDVR
DISABL:	MOV	NICSR,R0
	.Assume UN$CS0 EQ 0
	MOVB	#PC.NOP,@R0
	.Assume UN$CS0 EQ 0
	MOVB	#PC.STO,@R0
	CALL	ISWAIT
	RETURN








	.SBTTL	RESRNG	- Reset Ring Structures
	.ENABL	LSB
RESRNG:	CALL	SAV30
	CALL	SAVPAR
	.ADDR	#RCVBDL,R1
	.ADDR	#RBFATB,R2
	MOV	#RBUFCT,R3
10$:
	.Assume	RD.LEN EQ 0
	MOV	#RBUFSZ,(R1)
	MOV	(R2)+,RD.ADL(R1)
	MOV	(R2)+,R0
	BIS	#AH.OWN,R0
	MOV	R0,RD.ADH(R1)
	CLR	RD.STA(R1)
	ADD	#RD.ESZ,R1
	SOB	R3,10$
	CLR	RCVIDX
	.Assume	XMTBDL EQ RCVBDL+<RBUFCT*RD.ESZ>
	.Assume	XBFADD EQ RBFATB+<<RBUFCT*2>*2>
	MOV	(R2)+,TD.ADL(R1)
	MOV	@R2,TD.ADH(R1)
	MOV	UDBMTB+2,@#KISAR1
	MOV	UDBMTB,R0
	MOV	XBDLAD,(R0)+
	MOVB	XBDLAD+2,(R0)+
	MOVB	#<TD.ESZ/2>,(R0)+
	MOV	#XBUFCT,(R0)+
	MOV	RBDLAD,(R0)+
	MOVB	RBDLAD+2,(R0)+
	MOVB	#<RD.ESZ/2>,(R0)+
	MOV	#RBUFCT,(R0)+
	MOV	UDBADD,PCB+PCB.F2
	MOV	UDBADD+2,PCB+PCB.F4
	MOV	#PF.WRF,PCB+PCB.F0
	MOV	NICSR,R0
	.Assume	UN$CS0 EQ 0
	MOVB	#PC.GC,@R0
	CALL	ISWAIT
	RETURN
	.DSABL	LSB








	.SBTTL	SETUP	- Update Address Filtering
	.PSECT	NIDVR
	.ENABL	LSB
SETUP:	CALL	SAV30
	CALL	SAVPAR
	MOV	UDBMTB+2,@#KISAR1
	MOV	UDBMTB,R1
	.ADDR	#NIBROD,R0
	MOV	#UA.TSZ+1,R2
	CLR	R3
10$:	MOV	(R0)+,-(SP)
	BIS	(R0)+,(SP)
	BIS	(R0)+,(SP)+
	BEQ	20$
	SUB	#UA.ESZ,R0
	MOV	(R0)+,(R1)+
	MOV	(R0)+,(R1)+
	MOV	(R0)+,(R1)+
	INC	R3
	CMPB	R3,MAXMLT
	BGT	50$
20$:	DEC	R2
	BGT	10$
	MOV	UDBADD,PCB+PCB.F2
	MOVB	UDBADD+2,R5
	SWAB	R3
	BIS	R3,R5
	MOV	R5,PCB+PCB.F4
	MOV	#PF.WMA,PCB+PCB.F0
	MOV	NICSR,R0
	.Assume	UN$CS0 EQ 0
	MOVB	#PC.NOP,@R0
	.Assume	UN$CS0 EQ 0
	MOVB	#PC.GC,@R0
	CALL	ISWAIT
	CLR	R5
	TST	NIPMFG
	BEQ	30$
	BIS	#F2.PM,R5
30$:	TST	NIAMFG
	BEQ	40$
	BIS	#F2.AM,R5
40$:	BIS	#<F2.DMM!F2.HDM>,R5
	MOV	R5,PCB+PCB.F2
	MOV	#PF.WM,PCB+PCB.F0
	.Assume	UN$CS0 EQ 0
	MOVB	#PC.GC,@R0
	CALL	ISWAIT
	.Assume	UN$CS0 EQ 0
	MOVB	#<C0.IE!PC.NOP>,@R0
	.Assume	UN$CS0 EQ 0
	MOVB	#<C0.IE!PC.PD>,@R0
	TST	(PC)+
50$:	SEC
	RETURN
	.DSABL	LSB








	.SBTTL	ISWAIT	- Wait for Command Completion
ISWAIT:
	.Assume	UN$CS0 EQ 0
	.Assume C0.IS EQ 200
	TSTB	@R0
	BPL	ISWAIT
	MOVB	UN$CS0+1(R0),UN$CS0+1(R0)
	RETURN








	.SBTTL	NUABRT	- Port Handler Abort Code
	.PSECT	NIDVR
NUABRT:	CALLR	NIABRT








	.SBTTL	NIINT	- Interrupt Entry Point
	.PSECT	NIDVR
	.ENABL	LSB
	.DRAST	NI,NI$PRI,NUABRT
	MOV	NICSR,R5
	.Assume UN$CS0 EQ 0
	MOV	(R5),R4
	MOVB	UN$CS0+1(R5),UN$CS0+1(R5)
	BIT	#C0.RXI,R4
	BEQ	20$
	CALL	NUIINT
20$:	BIT	#C0.TXI,R4
	BEQ	30$
	CALL	NUOINT
30$:	BIT	#C0.BUI,R4
	BEQ	40$
	.Assume	UN$CS0 EQ 0
	MOVB	#<C0.IE!PC.PD>,(R5)
40$:	RETURN
	.DSABL	LSB








	.SBTTL	NUIINT	- Routine to Process Receive Interrupts
	.PSECT	NIDVR
	.ENABL	LSB
NUIINT:	TST	NIQCHG
	BNE.	160$
RECV:	INC	RECVFG
	BNE.	160$
	CALL	SAV30
	CALL	SAVPAR
	MOV	R4,-(SP)
	MOV	R5,-(SP)
10$:	CALL	GETADR
	BIT	#AH.OWN,RD.ADH(R1)
	BNE.	150$
	BIT	#AH.ERS,RD.ADH(R1)
	BNE.	130$
	MOV	NIICQE,R4
	BEQ.	130$
	TST	NIPMFG
	BNE	110$
	MOV	RCVIDX,R2
	ASL	R2
	ASL	R2
	.ADDR	#RBFMTB,R2,ADD
	MOV	(R2)+,R0
	MOV	(R2)+,@#KISAR1
	.ADDR	#NIUPT,R3
	MOV	R3,-(SP)
	MOV	#UP.TSZ,R2
20$:
	.Assume	UO.ESZ EQ UP.ESZ
	TST	NIUOT-NIUPT(R3)
	BEQ	30$
	CMP	EF.TYP(R0),(R3)
	BEQ	40$
30$:	TST	(R3)+
	DEC	R2
	BGT	20$
	TST	(SP)+
	BR	130$
40$:	MOV	R3,R2
	SUB	(SP)+,R3
	.Assume	UP.ESZ EQ 2
	ASR	R3
	.Assume	UO.ESZ EQ UP.ESZ
	ADD	#NIUOT-NIUPT,R2
	.Assume	UO.JOB EQ 0
	.Assume	UO.OFG EQ 1
	TST	(R2)
	BEQ	130$
	BIT	#1,EF.DST(R0)
	BEQ	90$
	.ADDR	#NUADDR,R4
	MOV	R4,-(SP)
	MOV	R3,-(SP)
	.ADDR	#NIPHAD,R3
	MOV	#<UA.ESZ/2>*2,R5
50$:	MOV	(R3)+,(R4)+
	DEC	R5
	BGT	50$
	MOV	(SP)+,R3
	MUL	#UA.ESZ,R3
	.ADDR	#NIUAT,R3,ADD
	MOV	#<UA.ESZ/2>,R5
60$:	MOV	(R3)+,(R4)+
	DEC	R5
	BGT	60$
	MOV	(SP)+,R3
	MOV	#3,R4
70$:	CMP	EF.DST+4(R0),4(R3)
	BNE	80$
	CMP	EF.DST+2(R0),2(R3)
	BNE	80$
	.Assume	EF.DST EQ 0
	CMP	(R0),(R3)
	BEQ	90$
80$:	ADD	#UA.ESZ,R3
	DEC	R4
	BGT	70$
	BR	130$
90$:	.ADDR	#NIICQE-Q$LINK,R4
100$:	MOV	Q$LINK(R4),R4
	BEQ	130$
	CMPB	(R2),Q$UNIT(R4)
	BNE	100$
110$:	MOV	RD.STA(R1),R5
	BIC	#^C<ST.LMK>,R5
	SUB	#4,R5
	MOV	R5,-(SP)
	ADD	#2,Q$BUFF(R4)
	CALL	@$PTWRD
	SUB	#4,Q$BUFF(R4)
	INC	R5
	ASR	R5
	MOV	Q$WCNT(R4),R2
	SUB	#2,R2
	CMP	R5,R2
	BLE	120$
	MOV	#RC.TRU,-(SP)
	CALL	@$PTWRD
	SUB	#2,Q$BUFF(R4)
	BIS	#HDERR$,@Q$CSW(R4)
	MOV	R2,R5
120$:	MOV	RCVIDX,R2
	ASL	R2
	ASL	R2
	.ADDR	#RBFMTB,R2,ADD
	MOV	2(R2),R1
	MOV	(R2),R2
	MOV	Q$PAR(R4),R3
	MOV	R4,-(SP)
	MOV	Q$BUFF(R4),R4
	ADD	#4,R4
	CALL	@$BLKMV
	MOV	(SP)+,R4
	CALL	NIIDEQ
130$:	CALL	GETADR
	CLR	RD.STA(R1)
	MOVB	#<AH.OWN/400>,RD.ADH+1(R1)
	MOV	RCVIDX,R1
	INC	R1
	CMP	R1,#RBUFCT
	BLT	140$
	SUB	#RBUFCT,R1
140$:	MOV	R1,RCVIDX
	JMP	10$
150$:	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	#-1,RECVFG
160$:	RETURN
	.DSABL	LSB








	.SBTTL	GETADR	- Get Buffer Descriptor Address
GETADR:	MOV	RCVIDX,R1
	MUL	#RD.ESZ,R1
	.ADDR	#RCVBDL,R1,ADD
	RETURN








	.SBTTL	NUOINT	- Routine to Process Transmit Interrupts
	.PSECT	NIDVR
	.ENABL	LSB
NUOINT:	CALL	SAV30
	CALL	SAVPAR
	MOV	R4,-(SP)
	MOV	R5,-(SP)
	.ADDR	#XMTBDL,R5
	MOV	#-1,XMITFG
	MOV	NIOCQE,R4
	BEQ	70$
	MOV	Q$LINK(R4),NIOCQE
	CLR	Q$LINK(R4)
	BIT	#AH.ERS,TD.ADH(R5)
	BEQ	40$
	BIT	#ST.LCA,TD.STA(R5)
	BEQ	10$
	MOV	#<SC.WCC*400+RC.XMT>,-(SP)
	BR	30$
10$:	BIT	#ST.RTY,TD.STA(R5)
	BEQ	20$
	MOV	#<SC.WEC*400+RC.XMT>,-(SP)
	BR	30$
20$:	MOV	#<RC.XMT>,-(SP)
	.BR	30$
30$:	BIS	#HDERR$,@Q$CSW(R4)
	CALL	@$PTWRD
40$:	CALL	NIFIN
	BR	50$
XMIT:	CALL	SAV30
	CALL	SAVPAR
	MOV	R4,-(SP)
	MOV	R5,-(SP)
50$:	TST	NOQCHG
	BNE	70$
	MOV	NIOCQE,R4
	BEQ	70$
	INC	XMITFG
	BNE	70$
	MOV	Q$PAR(R4),@#KISAR1
	MOV	Q$BUFF(R4),R2
	ADD	#<4+EF.SRC>,R2
	MOV	(R2),-(SP)
	BIS	2(R2),(SP)
	BIS	4(R2),(SP)+
	BNE	60$
	.ADDR	#NIPHAD,R1
	MOV	(R1)+,(R2)+
	MOV	(R1)+,(R2)+
	MOV	(R1)+,(R2)+
60$:	MOV	Q$PAR(R4),R1
	MOV	Q$BUFF(R4),R2
	ADD	#4,R2
	MOV	Q$WCNT(R4),R5
	SUB	#2,R5
	MOV	R5,-(SP)
	MOV	XBFMTB+2,R3
	MOV	XBFMTB,R4
	CALL	@$BLKMV
	.ADDR	#XMTBDL,R0
	ASL	(SP)
	.ASSUME	TD.LEN EQ 0
	MOV	(SP)+,@R0
	CLR	TD.STA(R0)
	MOVB	#<<AH.OWN!AH.STP!AH.ENP>/400>,TD.ADH+1(R0)
	MOVB	#<C0.IE!PC.PD>,@NICSR
70$:	MOV	(SP)+,R5
	MOV	(SP)+,R4
	RETURN
	.DSABL	LSB








	.SBTTL	Port Handler Inpure Data Area
	.PSECT	NIDAT
NINAME:	.WORD	NI$HND
	.RAD50	/$  /
$BLKMV:	.BLKW
PCB:	.WORD	PF.RDA
	.WORD	0,0,0
RBFMTB:	.BLKW	<RBUFCT*2>
XBFMTB:	.BLKW	2
UDBMTB:	.BLKW	2
RBFATB:	.BLKW	<RBUFCT*2>
XBFADD:	.BLKW	2
UDBADD:	.BLKW	2
PCBADD:	.BLKW	2
RBDLAD:	.BLKW	2
XBDLAD:	.BLKW	2
RCVBDL:	.BLKB	<RBUFCT*RD.ESZ>
XMTBDL:	.BLKB	TD.ESZ
RCVIDX:	.BLKW
RECVFG:	.WORD	-1
XMITFG:	.WORD	-1
FQELEM:	.BLKW	6
NUADDR:	.BLKW	3*UA.ESZ
NUFBLK:	.WORD	0,0,0,0
MAXMLT:	.WORD	0
NUHNAM:	.RAD50	/NUH/
NULNAM:	.RAD50	/NUL/








	.SBTTL	Installation code overlay
	.PSECT	SETOVR
	. = LODOVR + 1000
	OVRBK0 =: .
	.ENABL	LSB
INSOVR:	MOV	@#SYSPTR,R1
	BIT	#<PROS$!QBUS$>,CONFG2(R1)
	BNE.	I.ERR
	MOV	<OVRBK0-BLOCK1>+INSCSR,R2
	.Assume	UN$CS0 EQ 0
	MOV	#C0.RSE,@R2
10$:
	.IF NE TIM$IT
	CLR	ITMOFG
	.ADDR	#ITAREA+10,R0
	MOV	#177000+NI$COD,-(R0)
	.ADDR	#ITCOMP,-(SP)
	MOV	(SP)+,-(R0)
	.ADDR	#ITTBLK,-(SP)
	MOV	(SP)+,-(R0)
	MOV	#<22*400>,-(R0)
	.MRKT	CODE=NOSET
	BCS	I.ERR
	.ENDC
20$:
	CMP	@R2,#<C0.SCI!C0.IS>
	BEQ	I.ERR
	.Assume	UN$CS0 EQ 0
	BIT	#C0.DNI,@R2
	.IF EQ TIM$IT
	BEQ	20$
	.IFF
	BNE	30$
	TST	ITMOFG
	BEQ	20$
	BR	I.ERR
	.ENDC
30$:
	.IF NE TIM$IT
	.ADDR	#ITAREA+6,R0
	CLR	-(R0)
	MOV	#177000+NI$COD,-(R0)
	MOV	#<23*400>,-(R0)
	.CMKT	CODE=NOSET
	BCS	I.ERR
	.ENDC
	MOVB	UN$CS0+1(R2),UN$CS0+1(R2)
	MOVB	UN$CS1(R2),-(SP)
	BIC	#^C<C1.SMK>,(SP)
	CMPB	(SP)+,#PS.RDY
	BNE	I.ERR
	ASL	#100000
	BCC	40$
	.Assume UN$CS0 EQ 0
	MOVB	#PC.ST,@R2
	BR 	10$
40$:	MOV	P1EXT(R1),R0
50$:	.ADDR	#NUNAME,R5
	CALL	FINDGR(R0)
	BCS	70$
	MOV	R1,-(SP)
	BIT	#GR.NRF,GR.STA(R1)
	BNE	60$
	MOV	GR.SIZ(R1),R2
	MOV	GR.ADR(R1),R1
	CALL	XDEALC(R0)
60$:	CLR	@(SP)+
	BR	50$
70$:	MOV	@#SYSPTR,R1
	MOV	MEMPTR(R1),R0
	ADD	R1,R0
	MOV	CORPTX(R0),R0
	ADD	R1,R0
	CLR	-(SP)
	MOV	#-1,-(SP)
80$:	CMP	(R0),#-1
	BEQ	110$
	TST	(R0)
	BEQ	100$
	CMP	(R0),#EMEMSZ
	BLO	100$
	MOV	2(R0),-(SP)
	ADD	#EMEMSZ,(SP)
	CMP	(SP)+,#10000
	BHI	100$
90$:	CMP	(R0),(SP)
	BHIS	100$
	MOV	R0,2(SP)
	MOV	(R0),(SP)
100$:	ADD	#4,R0
	BR	80$
110$:	TST	(R0)+
	MOV	R0,R2
	TST	(SP)+
	MOV	(SP)+,R0
	BEQ	I.ERR
120$:	CMP	(R2),#-1
	BEQ	I.ERR
	TST	(R2)
	BEQ	130$
	ADD	#GR.ESZ,R2
	BR	120$
130$:	MOV	#EMEMSZ,(R2)+
	SUB	#EMEMSZ,(R0)+
	MOV	(R0),(R2)+
	ADD	#EMEMSZ,(R0)
	MOV	#GR.PVT,(R2)+
	MOV	NUNAME,(R2)+
	MOV	NUNAME+2,(R2)+
I.NORM:	TST	(PC)+
I.ERR:	SEC
	RETURN
NUNAME:	.WORD	NI$HND
	.RAD50	/$  /
	.IF NE TIM$IT
ITCOMP:	MOV	SP,ITMOFG
	RETURN
ITMOFG:	.WORD	0
ITTBLK:	.WORD	0,16.*60.
ITAREA:	.BLKW	4
	.ENDC
	.DSABL	LSB
	.Assume <.-OVRBK0> LE 1000 MESSAGE=<INSTALL overlay overflow>








	.SBTTL	Set Code Overlay
	.PSECT	SETOVR
	. = OVRBK0 + 1000
	OVRBK1 =: .
	.MCALL	.DSTAT,	.LOOKU,	.SPFUN
	.MCALL	.TRPSE,	.PRINT,	.TTYOU
	.MCALL	.CLOSE,	.PURGE
	..DSTA	=: 342
	..LKUP	=: 375
	..SPFN	=: 375
	.ENABL	LSB
O.SHOW:	.ADDR	#OVRBK1,R0
	ADD	R0,LKAREA+2
	ADD	R0,SPAREA+4
	.ADDR	#DBLK,R0
	.ADDR	#DSAREA+1,-(SP)
	EMT	..DSTA
	BCS	10$
	TST	DSAREA+4
	BEQ	10$
	CALL	DEVTYP
	.PURGE	#0
	.ADDR	#LKAREA,R0
	EMT	..LKUP
	BCS	S.ERR
	.ADDR	#SPAREA,R0
	EMT	..SPFN
	ROL	-(SP)
	.ADDR	#SPAREA,R0
	CLR	SPAREA+2
	EMT	..SPFN
	.PURGE	#0
	ROR	(SP)+
	BCS	S.ERR
	BR	20$
10$:	.ADDR	#TSAREA,R0
	.ADDR	#NUNXM,R1
	.TRPSE	R0,R1
	MOV	<OVRBK1-BLOCK1>+INSCSR,R0
	TST	@R0
	NOP
	BCS	S.ERR
	CALL	DEVTYP
	.ADDR	#SPCB,R1
	MOV	R1,UN$CS2(R0)
	CLR	UN$CS3(R0)
	.Assume UN$CS0 EQ 0
	MOVB	#PC.GP,@R0
	CALL	SWAIT
	MOV	#PF.RDA,SPCB+PCB.F0
	.Assume UN$CS0 EQ 0
	MOVB	#PC.GC,@R0
	CALL	SWAIT
20$:	.ADDR	#M.PADD,R0
	.PRINT
	.ADDR	#SPCB+PCB.F2,R1
	MOV	#6.,R2
	BR	40$
30$:	.TTYOU	#'-
40$:	MOVB	(R1)+,-(SP)
	MOVB	(SP),R0
	ASR	R0
	ASR	R0
	ASR	R0
	ASR	R0
	BIC	#^C<17>,R0
	.ADDR	#HEX,R0,ADD
	.TTYOU	@R0
	MOVB	(SP)+,R0
	BIC	#^C<17>,R0
	.ADDR	#HEX,R0,ADD
	.TTYOU	@R0
	DEC	R2
	BGT	30$
	.ADDR	#M.CRLF,R0
	.PRINT
S.NORM:	TST	(PC)+
S.ERR:	SEC
	ROL	R2
	JMP	<OVRBK1-BLOCK1>+GETBK1
	.DSABL	LSB
DEVTYP:	MOV	R0,-(SP)
	MOV	<OVRBK1-BLOCK1>+INSCSR,R0
	MOV	UN$CS1(R0),R0
	BIC	#^C<C1.DID>,R0
	BNE	10$
	.ADDR	#M.DEUN,R0
	BR	20$
10$:	.ADDR	#M.DELU,R0
20$:	.PRINT
	MOV	(SP)+,R0
	RETURN
NUNXM:	BIS	#1,2(SP)
	RTI
SWAIT:
	.Assume UN$CS0 EQ 0
	.Assume C0.IS EQ 200
	TSTB	@R0
	BPL	SWAIT
	MOVB	UN$CS0+1(R0),UN$CS0+1(R0)
	RETURN
DBLK:	.WORD	NI$HND
	.WORD	0,0,0
DSAREA:	.BLKW	4
LKAREA:	.BYTE	0
	.BYTE	1
	.WORD	DBLK-OVRBK1
	.WORD	0
SPAREA:	.BYTE	0
	.BYTE	32
	.WORD	1
	.WORD	SPCB-OVRBK1
	.WORD	0
	.BYTE	377,SP.POR
	.WORD	0
SPCB:	.WORD	PF.RDA
	.WORD	0,0,0
TSAREA:	.BLKW	2
M.DEUN:	.ASCII	/DEUNA, /<200>
M.DELU:	.ASCII	/DELUA, /<200>
M.PADD:	.ASCII	/Station address = /<200>
M.CRLF:	.BYTE	0
HEX:	.ASCII	/0123456789ABCDEF/
	.EVEN
	.ASSUME <.-OVRBK1> LE 1000 MESSAGE=<SET overlay overflow>








	.END