Google
 

Trailing-Edge - PDP-10 Archives - BB-F494Z-DD_1986 - 10,7/rx2ser.mac
There are 7 other files named rx2ser.mac in the archive. Click here to see a list.
	Title	RX2SER -- RX20 Floppy Diskette Service for KS10s V006

	Subttl	Timothe Litt 11-NOV-85

	Search	F,S

	$RELOC
	$HIGH

	VRX2SR==:005		;For GLOB

;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
;  OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
.CPYRT<1982,1986>
;COPYRIGHT (c) 1982,1983,1986 BY
;DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;ALL RIGHTS RESERVED.


	ENTRY	RX2SER
RX2SER::

	;Device dependent bits in S

	S.SID1==Z(1B6)		;Set if side 1 selected, clear if side 0
	S.OPRA==Z(1B7)		;Set if OPR action requested at interrupt level

	S.2SID==1B29		;Media is 2 sided
	S.2DEN==1B28		;Double density mode
	S.PHYS==1B27		;Use physical I/O (Inhibit interleaving)
	S.DELD==1B26		;Write deleted data/deleted data detected
	S.WPS==1B24		;Use WPS-8 interleave mode

	;The RX02 has several funny attributes:
	; - It supports 2 densitys, each with a different sector size
	; - The sector size is non-standard
	; - It is addressed in 2 ways -- Interleaved and Physical
	; - The hardware numbers sectors starting with 1, not 0
	; - Data is buffered in a silo (FIFO), then NPRed to memory
	;
	;In physical I/O mode, the RX02 has 77 tracks/side, 26 sectors/track.
	;In interleaved-11 mode, the RX02 has 76 tracks/side, 26 sectors/track.
	;In interleaved-8 mode, the RX02 has 74 tracks/side, 26 sectors/track.
	;
	;In single density mode, a sector is 128 (PDP-11) bytes
	;In double density mode, a sector is 256 (PDP-11) bytes
	;
	;Interleaved mode is a software invention, not a hardware function.
	;Because the RX02 is so slow, each track is divided into even and
	;odd sectors.  LBNs are numbered so that for each track, the odd
	;sectors are used first, then the even sectors on consecutive
	;revolutions.  The skipped sectors allow time for the CPU to empty
	;the silo, and request the next transfer to be the next higher LBN
	;without wasting a whole revolution.  In addition, LBNs are skewed
	;from 1 track to the next.  This skew is to allow for the time needed
	;to seek 1 track, without losing a whole revolution.  The track-track
	;skew is 6 sectors(11 mode), 0 sectors (8 mode).  
	;Track 0 is reserved to ANSI standardization.
	;
	;These parameters should not be modified to ensure 11 compatibility.
	SUBTTL	Table of contents

;		TABLE OF CONTENTS FOR RX2SER -- RX20 Service for KS10s
;
;
;			   SECTION			      PAGE
;    1. Table of contents.....................................   2
;    2. RX211 Hardware bit definitions........................   3
;    3. RX20 Device dispatch table............................   4
;    4. DDB Field definitions.................................   5
;    5. UUOCON interface
;         5.1   Device initialization.........................   6
;         5.2   Obtain buffer size............................   7
;         5.3   Buffered input................................   8
;         5.4   Buffered output...............................   9
;         5.5   USETI/USETO & RELEAS UUOs.....................  10
;         5.6   DEVOP. UUO....................................  11
;    6. Interrupt service.....................................  14
;    7. Interrupt service
;         7.1   Read complete.................................  15
;         7.2   Silo empty....................................  16
;         7.3   Silo full.....................................  17
;         7.4   Write complete................................  18
;         7.5   Read extended status complete.................  19
;         7.6   Set density complete..........................  20
;         7.7   Error processing..............................  21
;    8. Queued I/O processing
;         8.1   Enqueue DDB for Kontroller....................  23
;         8.2   Advance queue and start I/O...................  24
;    9. Utility routines
;         9.1   Fill and empty buffer.........................  25
;         9.2   Wait for TR...................................  26
;         9.3   Setup for INPUT and OUTPUT....................  27
;         9.4   Fixup IOWD for IO mode........................  28
;         9.5   UBA mapping...................................  29
;         9.6   Set up W and U................................  30
;         9.7   Sector addressing.............................  31
	SUBTTL	RX211 Hardware bit definitions

	;CSR bits
	RX2CS==0		;Offset of CSR
	ERR==100000		;Error
	INIT==40000		;Initialize ctl
	EXAD==30000		;Extended bus address
	 EADLSH==-4		;;Amount to shift address to get EXAD bits
	RX02==04000		;RX02 (rather than RX01) controller
	SIDE2==1000		;Use second side of floppy
	DEN==000400		;Set for double density
	TR==0000200		;Transfer -- RXDB needs data
	INTENB==100		;Interrupt enable
	DONE==00040		;Done
	UNIT==00020		;Use unit 1, not 0
	 FCNFIL==1		;;Fill buffer (all FCNs include GO)
	 FCNMT==03		;;MT buffer
	 FCNWR==05		;;Write sector
	 FCNRD==07		;;Read sector
	 FCNSD==11		;;Set media density (format)
	 FCNES==13		;;Read Error Status
	 FCNWD==15		;;Write sector with deleted data mark
	 FCNXS==17		;;Read extended status

	;RX2ES bits
	RX2ES==2		;Offset of Error and Status A
	NXM==04000		;NXM during NPR
	WCOV==2000		;Word count overflow
	USEL==400		;Unit 1 was selected
	RDY==0200		;Drive ready
	DEL==0100		;Deleted data was read
	UDEN==040		;Unit double density selected
	DENERR==020		;Density error
	ACLOW==10		;Power failing
	INTDON==4		;Init done
	%2SIDE==2		;2 sided media
	CRCERR==1		;CRC error

	RX2SA==2		;Sector Address register offset
	 ;;Values 1-32(8)
	RX2TA==2		;Track Address register offset
	 ;;Values 0-114(8)
	RX2WC==2		;Word Count register offset
	 ;;Values 0-100(8) Single density
	 ;;Values 0-200(8) Double density
	RX2BA==2		;Bus Address register offset
	SUBTTL	RX20 Device dispatch table

	JRST	RX2ONL		;(-5) See if on-line
	JRST	RX2DVP		;(-4) DEVOP. UUO
	JRST	RX2SIZ		;(-3) Get buffer size
	JRST	RX2INI		;(-2) Once only
	JRST	RX2HNG		;(-1) Hung timer expired
RX2DSP::JRST	RX2REL		;(0) RELEASE - output
	JRST	RX2CLS		;(1) CLOSE
	JRST	RX2OUT		;(2) OUTPUT
	JRST	RX2INP		;(3) INPUT
	JRST	RX2ENT		;(4) ENTER
	JRST	RX2LKP		;(5) LOOKUP
	JRST	RX2DMO		;(6) Dump mode OUTPUT
	JRST	RX2DMI		;(7) Dump mode INPUT
	JRST	RX2USO		;(10) USETO
	JRST	RX2USI		;(11) USETI
	JRST	RX2GTF		;(12) UGETF
	JRST	RX2REN		;(13) RENAME
	JRST	RX2ICL		;(14) CLOSE input
	JRST	RX2CLR		;(15) UTPCLR
	JRST	RX2MTP		;(16) MTAPE

	;Temp defns for null routines
	RX2ONL==CPOPJ##
	RX2HNG==CPOPJ##
	RX2CLS==CPOPJ##
	RX2ENT==CPOPJ1##
	RX2LKP==CPOPJ1##
	RX2DMO==CPOPJ##
	RX2DMI==CPOPJ##
	RX2GTF==CPOPJ##
	RX2REN==CPOPJ##
	RX2ICL==CPOPJ##
	RX2CLR==CPOPJ##
	RX2MTP==CPOPJ##
	SUBTTL	DDB Field definitions

	;Define symbolic offsets for DEVRXQ words
	QLINK==DEVRXQ##+0	;LH - Next DDB in KON queue
				;RH - Unibus address of start of buffer
	QCSR==DEVRXQ##+1	;LH - CSR for transfer; RH - Data buffer # 1
	QFCN==DEVRXQ##+2	;LH - Data buffer # 2; RH - function & retry
	QMAP==DEVRXQ##+3	;LH - UBA Mapping register # 1; RH - #2

	;Byte pointers into the DDB

DEYFCN:	POINT	4,QFCN(F),21	;Function (state) of RX
	 F..IDL==0		;;Idle
	 F..RD== 1		;;Read
	 F..WR== 2		;;Write & write deleted
	 F..FIL==3		;;Fill buffer
	 F..MT== 4		;;Empty buffer
	 F..SMD==5		;;Set media density
	 F..RES==6		;;Read error status
	 F..RXS==7		;;Read extended status
DEYTRY:	POINT	4,QFCN(F),25	;Retry counter
DEYCSC:	POINT	2,QFCN(F),27	;Number of parameters to stuff in data CSR
DEYSCT:	POINT	2,QFCN(F),29	;Number of sectors left in transfer - 1
DEYUUO:	POINT	3,QFCN(F),32	;Type of UUO in progress
	 U..IDL==0		;;Idle (none)
	 U..BR== 1		;;Buffered input
	 U..BW== 2		;;Buffered output
	 U..SD== 3		;;Set density
	 U..DR== 4		;;Dump input
	 U..DW== 5		;;Dump output
DEYUNT:	POINT	1,DEVRXS##(W),18 ;Active unit number
	SUBTTL	UUOCON interface -- Device initialization

RX2INI:	LDB	T2,PUNIT##	;Get unit number
	JUMPN	T2,CPOPJ1##	;If not Kontroller, forget it
	MOVE	T1,DEVRXC##(F)	;Get EXP address of control
	PUSHJ	P,UBGOOD##	;Alive?
	JRST	CPOPJ1##	;No, forget it
	MOVE	T1,DEVRXC##(F)	;Get CSR address
	RDIO	T1,RX2CS(T1)	;Read CSR
	TRNN	T1,RX02		;Is it an RX02?
	 JRST	CPOPJ1##	;No, don't set up a vector
				;If device is used, CPU will halt with Illegal
				;interrupt instruction.
	HRRZ	T1,DEVRXV##(F)	;Get vector address
	LSH	T1,-2		;Convert bytes to 10 words
	HLRZ	T2,DEVRXC##(F)	;Get UBA number
	ADD	T1,.EPVIT##-1(T2) ;Find address in table
	MOVE	T2,DEVRXJ##(F)	;Get interrupt instruction
	MOVEM	T2,(T1)		;Store in vector table
	JRST	CPOPJ1##	;Return to SYSINI
	SUBTTL	UUOCON interface -- Obtain buffer size

	;Since UUOCON only calls us on OPEN, and remembers the result,
	;a simple user error probably will be to expect WPS mode buffer
	;size, but do OPEN with IO.WPS clear.

RX2SIZ:	MOVEI	T1,<^D128/4>	;Start with size of single density sector
	TRNE	M,S.2DEN	;If double density mode
	 ASH	T1,1		; sector is twice as big
	TRNE	M,S.WPS		;If in WPS mode
	 JRST	[IMULI	T1,3	; we use three sectors of whatever size
		 AOJA	T1,CPOPJ##] ;Account for buffer size word
	TRNN	M,S.PHYS	;If logical IO (and not WPS)
	 MOVEI	T1,200		; Must use full size buffer
	AOJA	T1,CPOPJ##	;Done
	SUBTTL	UUOCON interface -- Buffered input

RX2INP:	TLZ	S,IO		;Of course, I think UUOCON should do this...
	PUSHJ	P,STUWFZ	;Set up U & W and clear retry counter
	MOVSI	T1,DVOFLN	;Off-line bit
	TLZN	S,S.OPRA	;Opr action requested at interrupt level?
	 TDNE	T1,DEVCHR(F)	; or off-line?
	JRST	TELUSR		;Yes, go tell user
RDNXBF:	MOVEI	T1,@DEVIAD(F)	;Get address of buffer
	PUSHJ	P,IOWFIX	;Turn buffer address into real IOWD
	PUSHJ	P,UBAMAP	;Compute UBA mapping
	MOVEI	T1,U..BR	;Doing a buffered read
	DPB	T1,DEYUUO	;Store for error recovery
RDNXTB:	HRRZ	T1,DEVRXI##(F)	;Get next logical block for input
	PUSHJ	P,TRSET		;Set up for transfer
RDNXTS:	HRLM	T1,DEVRXI##(F)	;Save sector number for later
	MOVEI	T2,F..RD	;Get read data function
	MOVEI	T4,INTENB!FCNRD	;Set up read sector function
WRSET:	DPB	T2,DEYFCN	;Store as current
	PUSHJ	P,TRKSEC	;Get track and sector
	 JRST	[TRO	S,IOBKTL;Set block too large error
		 JRST	ERRXI1]	;and exit
	HRLM	T1,QFCN(F)	;Save track
	HRL	T2,T4		;Get function bits
	LDB	T1,PUNIT##	;Get unit number
	SKIPE	T1		;If not zero
	 TLO	T2,UNIT		; set unit 1
	TRNE	S,S.2DEN	;Double density?
	 TLO	T2,DEN		;Yes
	TLZE	S,S.SID1	;Use head 1 ?
	 TLO	T2,SIDE2	;Yes, tell RX02
	MOVEM	T2,QCSR(F)	;Set up RX2CS and RX2TA
	MOVEI	T1,2		;Parameters to load
	DPB	T1,DEYCSC	;Save for ENQDDB
	TRO	S,IOACT		;Set IOACT (so we won't move)
	MOVEM	S,DEVIOS(F)	; ...
	PJRST	ENQDDB		;Queue DDB and return

TELUSR:	MOVEM	S,DEVIOS(F)	;Update DDB
	PUSHJ	P,HNGSTP##	;Bitch, bitch, bitch
	TLNN	S,IO		;Doing input?
	 JRST	RX2INP		;Yes, try again
	JRST	RX2OUT		;No, try output
	SUBTTL	UUOCON interface -- Buffered output

RX2OUT:	TLO	S,IO		;Do UUOCON's work
	PUSHJ	P,STUWFZ	;Set up U & W and clear retry counter
	MOVSI	T1,DVOFLN	;Off-line bit
	TLZN	S,S.OPRA	;Opr action requested at interrupt level?
	 TDNE	T1,DEVCHR(F)	; or off-line?
	JRST	TELUSR		;Yes, go tell user
WRNXBF:	MOVEI	T1,@DEVOAD(F)	;Get address of buffer
	PUSHJ	P,IOWFIX	;Turn buffer address into real IOWD
	PUSHJ	P,UBAMAP	;Compute UBA mapping
	MOVEI	T1,U..BW	;Doing a buffered write
	DPB	T1,DEYUUO	;Store for error recovery
	TRO	S,IOACT		;Set IOACT here
	MOVEM	S,DEVIOS(F)	;So mapping sticks
WRNXTB:	HRRZ	T1,DEVRXO##(F)	;Get LBN for transfer
	PUSHJ	P,TRSET		;Set up for transfer
WRNXTS:	HRLM	T1,DEVRXO##(F)	;Save sector number
	HRRZ	T1,QLINK(F)	;Get 11 address
	LSH	T1,EADLSH	;Shift for high bits
	ANDI	T1,EXAD		;Only those
	IORI	T1,INTENB!FCNFIL ;Add in the fill buffer
	MOVEI	T2,F..FIL	;Get fill function
	PJRST	SETFMT		;Go fill the silo
	SUBTTL	UUOCON interface -- USETI/USETO & RELEAS UUOs

RX2USI:	MOVEI	U,DEVRXI##(F)	;Point to input block number
	TDZA	S,[XWD IOEND,IODEND] ;Zero the EOF bits
RX2USO:	 MOVEI	U,DEVRXO##(F)	;Point to output block number
	;PUSHJ	P,WAIT1##	;Wait for I/O to stop(UUOCON does this)
	HRRM	M,0(U)		;Store arg as next block to read/write
	PJRST	STOIOS##	;Store S in case USETI

RX2REL:	;PUSHJ	P,WAIT1##	;Wait for I/O to stop(UUOCON does this)
	TLZ	S,S.SID1!S.OPRA	;Clear our working bits
	SETZM	DEVRXI##(F)	;Reset to block 0
	SETZM	DEVRXO##(F)	;...
	SETZM	DEVFIL(F)	;Clear any LOOKUP/ENTER info
	HRRZS	DEVEXT(F)
	SETZM	DEVPPN(F)
	HLLZS	QFCN(F)		;Clear unit status
	PJRST	STOIOS##	;Store S and return
	SUBTTL	UUOCON interface -- DEVOP. UUO

	;Here with F:= DDB, T1:= Function code

RX2DVP:	MOVSI	T2,-RX2DVL	;Set up AOBJN pointer
RX2DV1:	HLRZ	T3,RX2DVT(T2)	;Get function code
	HRRZ	T4,RX2DVT(T2)	;and dispatch address
	CAMN	T1,T3		;Do they match?
	 PJRST	(T4)		;Yes, do the function
	AOBJN	T2,RX2DV1	;No, check rest of table
	PJRST	ECOD2##		;Illegal function for RX20

	;DEVOP. dispatch table -- XWD Fcn,,Routine

RX2DVT:	XWD	1,DVPRXS	;Read extended status
	XWD	11,DVPFMT	;Format a disk (using load LP20 RAM fcn!)
	RX2DVL==.-RX2DVT	;Size of table
	;DEVOP. Read extended status function
	;MOVE	ac,[Len,,addr]
	;DEVOP.	ac,
	; error return
	;Normal return
	;
	;Addr:	EXP	.DFRXS (= 1)
	;	SIXBIT	/Device/ (or channel # or UDX)
	;	BLOCK	2		;8 bytes of status returned here
	;
	;The usual DEVOP. errors apply

DVPRXS:	PUSHJ	P,STUWFZ	;Set up U & W and clear retry counter
	TRNE	S,IOACT		;Is IO ACTive?
	 JRST	ECOD1##		;Yes, silly user
	TLZ	S,IO		;This is "input"
	TRZ	S,IODERR!IODTER	;And errors haven't happened yet
	HRRZ	T1,M		;Get address -1 of buffer
	HRLI	T1,-^D<8/4>	;For 8 bytes of status
	PUSHJ	P,UBAMAP	;Set up mapping for IO
	HRLZ	T2,QLINK(F)	;Get 11 address of transfer
	LSH	T2,EADLSH	;Position for CSR
	TLZ	T2,^-EXAD	;Clear all but high 2 bits
	TLO	T2,INTENB!FCNXS	;Set the function
	HRR	T2,QLINK(F)	;First param is low 16 bits
	MOVEI	T1,U..SD	;Pretend UUO is set density
	MOVEI	T3,F..RXS	;Interrupt function is read status
	JRST	DVDOI1		;Go do the IO
	;DEVOP. Format function
	;MOVE	ac,[Len,,addr]
	;DEVOP.	ac,
	; error return
	;Normal return
	;
	;Addr:	EXP	.DFFMT (= 11)
	;	SIXBIT	/Device/ (or channel # or UDX)
	;	SIXBIT /SINGLE/ or SIXBIT /DOUBLE/
	;
	;The usual DEVOP. errors apply

DVPFMT:	PUSHJ	P,STUWFZ	;Set up U & W and clear retry counter
	MOVSI	T1,DVOFLN	;Off-line bit
	TLNN	S,S.OPRA	;Opr action requested at interrupt level?
	 TDNE	T1,DEVCHR(F)	; or off-line?
	JRST	ECOD7##		;Yes, return off-line error
	PUSHJ	P,GETWR1##	;Get next user word (type of format)
	 PJRST	RTM1##		;Address check!
	CAME	T1,[SIXBIT .SINGLE.] ;Want single density?
	 CAMN	T1,[SIXBIT .DOUBLE.] ;Or double?
	CAIA			;Good, continue
	 PJRST	ECOD3##		;Value out of range error
	TRNE	S,IOACT		;Is I/O active?
	 JRST	ECOD1##		;Yes, return no privs.  (Very dumb user!)
	TLO	S,IO		;This is output
	TRZ	S,IODERR!IODTER	;No errors so far
	CAME	T1,[SIXBIT .SINGLE.] ;Single density format?
	 TROA	S,S.2DEN	;No, set double
	TRZ	S,S.2DEN	;Yes, set single
	MOVSI	T2,INTENB!FCNSD	;Get function bits
	LDB	T1,PUNIT##	;Get unit number
	SKIPE	T1		;If not zero
	 TLO	T2,UNIT		; set unit 1
	TRNE	S,S.2DEN	;Double density?
	 TLO	T2,DEN		;Yes
	TRO	T2,"I"		;Approve the "I"nitialization
	SETZM	QMAP(F)		;No UBA mapping
	MOVEI	T1,U..SD	;Get "Set density" state
	MOVEI	T3,F..SMD	;Set Media Density function
DVDOI1:	MOVEM	T2,QCSR(F)	;Set up RX2CS and RX2DB
	DPB	T1,DEYUUO	;Store as current UUO
	DPB	T3,DEYFCN	;Save as unit status
	MOVEI	T1,1		;Parameter to load
	DPB	T1,DEYCSC	;Save for ENQDDB
DVDOIO:	TRO	S,IOACT		;Set IOACT so we know when its done
	MOVEM	S,DEVIOS(F)	; ...
	PUSHJ	P,ENQDDB	;Queue DDB
	;Note that in 7.01 field image, the DEVOP. code doesn't ensure
	;that this job has the device INITed.  If you don't, you will hang
	;in IOW at the call to WAIT1 because SETIOD doesn't have PJOBN set up
	PUSHJ	P,WAIT1##	;Wait for the I/O to complete
	HRRZ	T1,S		;Copy the final status (Yes, WAIT1 updates it)
	TRNE	T1,IODERR!IODTER ;Errors detected?
	 PJRST	ECOD6##		;Yes, "Not initialized" error
	PJRST	STOTC1##	;No, return S in AC
	SUBTTL	Interrupt service

RX2INT::MOVE	W,F		;Save KON pointer
	HLRZ	F,DEVRXS##(W)	;Get DDB pointer
	SKIPN	F		;Paranoia
RX2STP:	STOPCD	CPOPJ##,STOP,RX2,;++RX2SER fouled up
	LDB	T3,DEYFCN	;Get function in progress
	JUMPE	T3,RX2STP	;If none, error
	LDB	T1,DEYUNT	;Get Kontroller's unit number
	LDB	T2,PUNIT##	;And that of the DDB
	CAME	T1,T2		;They better match
	 JSP	T1,RX2STP	;++ They don't, don't make things worse
	MOVE	S,DEVIOS(F)	;Set up S
	MOVE	U,DEVRXC##(W)	;Set up CSR
	RDIO	T1,RX2CS(U)	;Read CSR
	RDIO	T2,RX2ES(U)	;and Error register
	HRL	T1,T2		;Combine
	MOVEM	T1,DEVSTS(F)	;Save for analysis
	PJRST	@[JRST	RD.INT	;Dispatch on state
		  JRST	WR.INT
		  JRST	FL.INT
		  JRST	MT.INT
		  JRST	SM.INT
		  JRST	RS.INT
		  JRST	RX.INT]-1(T3)	;As we know it

	;**********Temp until use found for fcns
	RS.INT==RX2STP		;Read status
	SUBTTL	Interrupt service -- Read complete

	;Here on a Read Complete interrupt

RD.INT:	TRNE	T1,ERR		;Error detected?
	 JRST	ERROR		;Yes, see if we should retry
	TLNE	T1,DEL		;Deleted data present?
	 TROA	S,S.DELD	;Yes, remember it
	TRZ	S,S.DELD	;No, remember that
	MOVEM	S,DEVIOS(F)	;Tell user
	HRRZ	T1,QLINK(F)	;Get 11 address
	LSH	T1,EADLSH	;Shift for high bits
	ANDI	T1,EXAD		;Only those
	IORI	T1,INTENB!FCNMT	;Add in Empty buffer
	MOVEI	T2,F..MT	;Get empty function
	PJRST	SETFMT		;Setup for empty buffer
	SUBTTL	Interrupt service -- Silo empty

MT.INT:	TRNE	T1,ERR		;Error detected?
	 JRST	ERROR		;Yes, see if we can recover
	LDB	T2,DEYSCT	;Get sectors to go
	SOJL	T2,RDDONE	;1 fewer
	DPB	T2,DEYSCT	;Update for next time
	HRRZ	T1,QCSR(F)	;Get word count from this transfer
	ASH	T1,1		;Make into a byte count
	ADDM	T1,QLINK(F)	;Bump address for next transfer
	HLRZ	T1,DEVRXI##(F)	;Get last sector transferred
	AOJA	T1,RDNXTS	;Go read the next one

	;Here when read is complete for all sectors of transfer

RDDONE:	PUSHJ	P,FREKON	;Free the kontroller in case someone else waiting
	AOS	DEVRXI##(F)	;Bump USETI counter to next block
	PUSHJ	P,SVEUF##	;Make job addressable
	MOVEI	T2,^D128/4	;Number of 10 words/single density sector
	TRNE	S,S.2DEN	;Double density?
	 ASH	T2,1		;Yes, double the 10 words
	TRNE	S,S.PHYS	;If physical IO
	 JRST	RDDON1		;Use size of a sector
	TRNN	S,S.WPS		;If not WPS mode
	 SKIPA	T2,[EXP	200]	; use standard logical block size
	IMULI	T2,3		;WPS mode, use 3 sectors
RDDON1:	MOVEI	T1,@DEVIAD(F)	;Get address of buffer control block
	EXCTUU	<HRRM	T2,1(T1)> ;Save actual word count in buffer
	PUSHJ	P,ADVBFF##	;Advance buffer ring
	 JRST	ERRXI1		;No more buffers, shut down
	PUSHJ	P,SETIOD##	;Signal buffer is available
	JRST	RDNXBF		;And go read next buffer
	SUBTTL	Interrupt service -- Silo full

FL.INT:	TRNE	T1,ERR		;Error detected?
	 JRST	ERROR		;Yes, see if we can recover
	HLRZ	T1,DEVRXO##(F)	;Get sector for transfer
	MOVEI	T4,INTENB!FCNWR	;Write sector function
	TRNE	S,S.DELD	;Wants deleted data mark?
	 MOVEI	T4,INTENB!FCNWD	;Yes, give correct command
	MOVEI	T2,F..WR	;Get write data function
	JRST	WRSET		;Go start the write
	SUBTTL	Interrupt service -- Write complete

WR.INT:	TRNE	T1,ERR		;Error detected?
	 JRST	ERROR		;Yes, see if we can recover
	LDB	T2,DEYSCT	;Get sectors to go
	SOJL	T2,WRDONE	;1 fewer
	DPB	T2,DEYSCT	;Update for next time
	MOVEI	T1,^D128	;Get single density byte count
	TRNE	S,S.2DEN	;Double density?
	 ASH	T1,1		;Yes, double it
	ADDM	T1,QLINK(F)	;Bump address for next transfer
	HLRZ	T1,DEVRXO##(F)	;Get last sector transfered
	AOJA	T1,WRNXTS	;Go do the next one

	;Here when write is complete for all sectors of transfer

WRDONE:	PUSHJ	P,FREKON	;Free kontroller in case of others
	AOS	DEVRXO##(F)	;Bump USETO counter to next LBN
	PUSHJ	P,SVEUF##	;Make the job addressable
	PUSHJ	P,ADVBFE##	;Advance the buffer ring
	 JRST	ERRXI1		;No more data, shut down
	PUSHJ	P,SETIOD##	;Signal a buffer can be refilled
	JRST	WRNXBF		;And go write the next one
	SUBTTL	Interrupt service -- Read extended status complete

	;Here when extended status interrupt happens

RX.INT:	;PJRST	SM.INT		;Treat exactly as set density
	SUBTTL	Interrupt service -- Set density complete

	;Here when Format interrupt happens

SM.INT:	TRNN	T1,ERR		;Any errors?
	 PJRST	ERRXI1		;No, restart UUO level code
	PUSHJ	P,ERRCHK	;Yes, see if retrys left
	 JRST	ERROR2		;No, record the error
	PJRST	STRTIO		;OK to retry, just restart I/O
	SUBTTL	Interrupt service -- Error processing

	;Here when the RX has detected an error
	;Note that we may be either at interrupt or UUO level

ERROR:	MOVE	T1,DEVSTS(F)	;Get error status back
	PUSHJ	P,ERRCHK	;See if retrys left
	 JRST	ERROR1		;None left, declare hard error
	LDB	T4,DEYUUO	;Get function in progress
	TLNN	T1,CRCERR	;CRC error?
	 TLNN	T1,WCOV!DENERR	; No, not WC overflow or density error?
	JRST	RETRY		;Yes, just retry function
	TLNE	T1,UDEN		;Is diskette double density?
	 TROA	S,S.2DEN	;Yes, retry that way (and tell user)
	TRZ	S,S.2DEN	;No, retry in single density
	TLNE	T1,%2SIDE	;Two sided diskette?
	 TROA	S,S.2SID	;Yes, tell user
	TRZ	S,S.2SID	;No, tell user
	PUSHJ	P,SVEUF##	;Must make job addressable
				;since buffer size changed
	TLNE	S,IO		;If output
	 JRST	WRNXBF		;Restart
	JRST	RDNXBF		;Recompute transfer size & do it all over again
ERROR1:	TLNE	T1,RDY		;Drive ready?
	 TLNE	T1,ACLOW	;Yes, is subsystem ready?
	JRST	SETOPR		;No, user ? OPR action requested
ERROR2:	TLNE	T1,CRCERR	;CRC error?
	 TROA	S,IODTER	;Yes, set data error
ERRXIT:	TRO	S,IODERR	;No, set device error
ERRXI1:	PUSHJ	P,SETIOD##	;Restart user
	PUSHJ	P,CLRACT##	;and clear IOACTive
	PJRST	FREKON		;Check Kontroller queue and dismiss

SETOPR:	MOVSI	T1,DVOFLN	;Set offline status
	IORM	T1,DEVCHR(F)	;for UUOCON
	TRO	S,IODERR	;Set device error
	TLO	S,S.OPRA	;and request OPR action
	PUSHJ	P,DEVERR##	; ... later
	PJRST	FREKON		;Release the Kontroller and dismiss
	;Routine to increment the retry counter
	;skips if any left, otherwise returns normally

ERRCHK:	MOVEI	T2,DEPDER	;Get retry disabled bit
	TDNE	T2,DEVSTA(F)	;Did user specify no retrys?
	 POPJ	P,		;Yes, don't
	LDB	T2,DEYTRY	;Get retry counter
	SKIPN	T2		;First retry?
	 AOS	DEVHCW(F)	;Yes, count a soft error
	AOS	T2		;bump by one
	CAILE	T2,^D10		;Done enough?
	 SETZ	T2,		;yes, stop
	DPB	T2,DEYTRY	;Store new count
	JUMPN	T2,CPOPJ1##	;If still trying, skip
	SOS	DEVHCW(F)	;Hard error, count down soft errors
	MOVSI	T2,1		;Now, ...
	ADDM	T2,DEVHCW(F)	;count up the hard ones
	POPJ	P,		;Return hard error

	;Routine to initiate a retry for error recovery

RETRY:	LDB	T1,DEYUUO	;Get the UUO in progress
	JRST	@[JRST	RX2STP	;;Nothing
		  JRST	RT.BR	;;Buffered read
		  JRST	RT.BW	;;Buffered write
		  JRST	RX2STP	;;Set density
		  JRST	RT.DR	;;Dump read
		  JRST	RT.DW](T1) ;Dump write

RT.BR:	HLRZ	T1,DEVRXI##(F)	;Get sector to read
	JRST	RDNXTS		;Re-read it

RT.BW:	HLRZ	T1,DEVRXO##(F)	;Get sector to write (Must refill silo since
	JRST	WRNXTS		;power fail in RX could invalidate it)

RT.DR:		;Should delete these 3 lines if not supporting dump io
RT.DW:
	STOPCD	CPOPJ,DEBUG,RXX	;Unimplimented error recovery
	SUBTTL	Queued I/O processing -- Enqueue DDB for Kontroller


;Routine to enqueue the current DDB for the Kontroller
;Assumes that we are ready to start IO

ENQDDB:	PIOFF			;Prevent races
	PUSHJ	P,ENQDDI	;Now act as though at interrupt level
	 JRST	ENQDD2		;Can't start IO now, some one else is there
	PION			;Restore PI
	PJRST	STRTIO		;and start IO

ENQDD2:	PION			;Restore PI
	POPJ	P,		;and return to caller

ENQDDI:	HLRZ	T1,DEVRXS##(W)	;Get current queue header
	CAIN	T1,0(F)		;Us?
	 PJRST	CPOPJ1##	;Yes, don't foul the queue
	HRRZS	QLINK(F)	;Clear previous link
	JUMPE	T1,[HRLM  F,DEVRXS##(W)	;We're first
		    PJRST CPOPJ1##]  ;So start IO now
ENQDD1:	HLRZ	T2,QLINK(T1)	;Point to next DDB in queue
	JUMPE	T2,[HRLM  F,QLINK(T1) ;Reached end, link this in
		    POPJ  P,]	;I/O is now deferred
	MOVE	T1,T2		;Point to next DDB
	JRST	ENQDD1		;Loop for end
	SUBTTL	Queued I/O processing -- Advance queue and start I/O

	;Routine to free the Kontroller at end of unit I/O

FREKON:	PUSH	P,F		;Save F for caller
	PUSH	P,S
	PUSHJ	P,QUECHK	;Free up the controller if we had it
	POP	P,S
	PJRST	FPOPJ##		; (any pending I/O for other units started)

QUECHK:	HLRZ	T1,DEVRXS##(W)	;Get queue header
	CAIE	T1,0(F)		;Are we it?
	 POPJ	P,		;No, don't touch it
	HLRZ	F,QLINK(F)	;Point to next DDB in queue
	HRLM	F,DEVRXS##(W)	;It's now the first one
	JUMPN	F,STRTI0	;If someone there, start I/O
	WRIO	F,@DEVRXC##(W)	;Otherwise, disable interrupts
	POPJ	P,		;and return

	;Entry to start IO for current DDB
	;requires current DDB to be first on Q

STRTI0:	MOVE	S,DEVIOS(F)	;Get correct S
STRTIO:	TRO	S,IOACT		;Set IOACT
	PUSHJ	P,STOIOS##	; and start hung timer (SETACT clears IOW)
	LDB	T1,PUNIT##	;Get unit number of this DDB
	DPB	T1,DEYUNT	;Save as number of active unit
	MOVE	T1,QMAP(F)	;Get UBA mapping register contents for this XFR
	MOVE	T2,DEVRXM##(W)	;Get IO address of UBA map
	WRIO	T1,1(T2)	;Setup map for second page
	MOVSS	T1		;Get contents for first page
	WRIO	T1,0(T2)	;Set it up
	HLRZ	T1,QCSR(F)	;Get CSR contents for command
	WRIO	T1,RX2CS(U)	;Give the command
	MOVE	T4,[POINT 18,QCSR(F),17] ;Set up byte pointer to contents
	LDB	T3,DEYCSC	;Get CSR count
SETPAR:	JUMPE	T3,CPOPJ##	;Return if done with parameters
	PUSHJ	P,TRWAIT	;Wait for signal to TRansfer
	 JRST	[PUSHJ	P,ERRCHK ;Any retrys left?
		  JRST	ERRXIT	;No, give up
		 JRST	STRTIO]	;Yes, try again
	ILDB	T1,T4		;Get parameter
	WRIO	T1,RX2BA(U)	;Write it to RX02
	SOJA	T3,SETPAR	;Loop till done
	SUBTTL	Utility routines -- Fill and empty buffer

	;Routine to do setup for Fill and Empty buffer functions
	;Fills in CSR with DENSITY, UNIT bits
	;Sets up command queue in DDB
	;Starts IO
	;expects EXAD bits and INTENB!xxFCN in T1
	;expects interrupt dispatch code in T2

SETFMT:	TRNE	S,S.2DEN	;Double density?
	 TRO	T1,DEN		;Yes, tell RX02
	DPB	T2,DEYFCN	;Set interrupt dispatch function
	LDB	T2,PUNIT##	;Get unit number
	SKIPE	T2		;If not unit zero
	 TRO	T1,UNIT		; set unit 1
	HRLZM	T1,QCSR(F)	;Save command in queue
	MOVEI	T1,^D128/2	;Word count for single density
	TRNE	S,S.2DEN	;Double density?
	 ASH	T1,1		;Yes, double it
	HRRM	T1,QCSR(F)	;Save WC in queue
	HRRZ	T1,QLINK(F)	;Get low order 11 address
	HRLM	T1,QFCN(F)	;Store it in queue too
	MOVEI	T1,2		;Get number of parameters
	DPB	T1,DEYCSC	;Set that in queue
	JRST	ENQDDB		;Enqueue (for fill) and start the IO
	SUBTTL	Utility routines -- Wait for TR

;Routine to wait for TR or error
;Call with W:=KON DDB; U:=CSR address
;CPOPJ if error, CPOPJ1 if TR

TRWAIT:	MOVEI	T2,2000		;Set timeout, just in case
TRWAT1:	RDIO	T1,RX2CS(U)	;Read CSR
	TRNE	T1,TR		;TR set yet?
	 JRST	CPOPJ1##	;Yes, return success
	TRNN	T1,ERR!DONE	;Error?
	 SOJG	T2,TRWAT1	;No, keep looking
	RDIO	T2,RX2ES(U)	;Get error status
	HRL	T1,T2		;Combine
	MOVEM	T1,DEVSTS(F)	;Save for analysis
	POPJ	P,		;Error or timeout
	SUBTTL	Utility routines -- Setup for INPUT and OUTPUT

TRSET:	MOVEI	T2,3		;Assume 4 sectors/block
	TRNE	S,S.2DEN	;Unless double density
	 LSH	T2,-1		;In which case, 2 sectors/block
	TRNE	S,S.WPS		;WPS uses three sectors/block
	 MOVEI	T2,2		;Thus
	TRNE	S,S.PHYS	;But physical I/O
	 MOVEI	T2,0		;Provides only 1 sector/block
	DPB	T2,DEYSCT	;Save number of sectors - 1 in transfer
	PJRST	BLKCVT		;Convert LBN to sector
	SUBTTL	Utility routines -- Fixup IOWD for IO mode

	;Routine to turn a buffer address into an IOWD, allowing for IO mode

IOWFIX:	HRLI	T1,-<^D128/4>	;Set word count for a single density sector
	TRNE	S,S.2DEN	;Unless double density
	 HRLI	T1,-<^D256/4>	; in which case use that (10) word count
	TRNE	S,S.PHYS	;If physical IO, we got it right
	 AOJA	T1,CPOPJ##	;So make real IOWD and return
	HRLI	T1,-200		;Logical IO, assume normal size
	TRNN	S,S.WPS		;WPS mode?
	 AOJA	T1,CPOPJ##	;No, we got it right
	HRLI	T1,-<^D128/4>*3	;Yes, assume single density 3 sectors
	TRNE	S,S.2DEN	;Right?
	 HRLI	T1,-<^D256/4>*3	;No, double density WPS (!)
	AOJA	T1,CPOPJ##	;Done
	SUBTTL	Utility routines -- UBA mapping

	;Routine to compute UBA mapping for an IOWD

UBAMAP:	HLRE	T2,T1		;Get word count
	MOVNS	T2		;Make positive
	HRRZI	T1,1(T1)	;Point to first address of buffer
	PUSHJ	P,UADRCK##	;See if it's legal for IO (May call PFH)
	EXCTUX	<MAP T3,@T1>	;Convert to a physical address
	 TLNN	T3,(1B1)	;Error if hard page fail
	TLNN	T3,(1B3!1B4)	;OK if modified or writable
	 JRST	ADRERR##	;Not accessible or not writable or hard PF
	TLZ	T3,777776	;Clear junk bits
	ADDI	T1,-1(T2)	;Point T1 to last word in buffer
	ROT	T3,-^D9		;Get page number of first page
	TRO	T3,UNBD18!UNBVBT;Set 16 bit mode, valid
	HRLZM	T3,QMAP(F)	;This will be the mapping
	ROT	T3,^D9		;Get word number back
	LSH	T3,2		;Make into byte address
	ANDI	T3,777B33	;Byte offset into page only
	ADD	T3,DEVRXE##(W)	;Compute start of transfer
	HRRM	T3,QLINK(F)	;Save for STRTIO
	PUSHJ	P,UADRCK##	;Be sure end of buffer is in low seg
	EXCTUX	<MAP T1,@T1>	;Find address of end of buffer
	 TLNN	T1,(1B1)	;Error if hard page fail
	TLNN	T1,(1B3!1B4)	;OK if modified or writable
	 JRST	ADRERR##	;Not accessible or not writable or hard PF
	TLZ	T1,777776	;Clear junk
	LSH	T1,-^D9		;Get page number
	TRO	T1,UNBD18!UNBVBT;Set 16 bit mode, valid
	HRRM	T1,QMAP(F)	;This is the other mapping
	POPJ	P,		;Done
	SUBTTL	Utility routines -- Set up W and U

	;Coroutine to setup W and U from F

STUWFZ:	SETZ	T1,		;Get a zero
	DPB	T1,DEYTRY	;Clear the retry counter
SETUWF:	EXCH	U,(P)		;Save U, get PC
	PUSH	P,W		;Save W
	MOVEM	U,1(P)		;Save PC of caller
	MOVEI	W,RXADDB##	;Point to first RX02 DDB
SETUW1:	MOVE	T1,DEVNAM(F)	;Get name of current DDB
	XOR	T1,DEVNAM(W)	;Compare
	TLNE	T1,777700	;At least RX?
	 JSP	T1,RX2STP	;No, die
	TLNE	T1,77		;Is controller right?
	 JRST	[HLRZ	W,DEVSER(W) ;No, go to next
		 JRST	SETUW1]	;and loop till find it
	MOVE	U,DEVRXC##(W)	;Point to CSR
	PUSHJ	P,@1(P)		;Call caller (again)
	 JRST	.+2		;Pass non-skip along
	AOS	-2(P)		;Skip
	POP	P,W		;Restore W
	PJRST	UPOPJ##		;and U
	SUBTTL	Utility routines -- Sector addressing

;Subroutine to convert LBNs to logical sector format
;
;Call:	T1/	LBN from user
;	PUSHJ	P,BLKCVT	(To convert LBN)
;	Only return		(T1/logical sector to start I/O with)

BLKCVT:	TRNE	S,S.PHYS	;Physical I/O?
	 POPJ	P,		;Yes, already a sector number
	TRNE	S,S.WPS		;WPS mode?
	 JRST	[IMULI	T1,3	;Yes, any sector = 1/3 block
		 POPJ	P,]	;Done
	ASH	T1,1		;Logical I/O - Double density sector = 1/2 block
	TRNN	S,S.2DEN	;Double density?
	 ASH	T1,1		;No, single density sector is 1/4 block
	POPJ	P,		;Return first logical sector of block
;Subroutine to convert logical sectors to track/sector format
;
;Call:	T1/	logical sector number (Sector # block)
;	PUSHJ	P,TRKSEC	(To convert sector)
;	 Illegal sector number
;	Sector number ok
;
;On success, S has the head select bit set, T1/ Track
;T2/ Sector
;
;Uses T1-3

TRKSEC:	IDIVI	T1,^D26		;T1/ Track, T2/ Sector
	TRNE	S,S.WPS		;If WPS mode
	 JRST	TRKSCW		;This is all different
	CAIGE	T1,^D76		;On side 2?
	 JRST	TRKSC2		;No, must be ok
	TRNN	S,S.PHYS	;Physical I/O?
	 JRST	[SUBI	T1,^D76	;No, logical uses 76 tracks/side
		 JRST	TRKSC1]	;See if legal
	CAIN	T1,^D76		;Exactly 76?
	 JRST	TRKSC2		;Yes, physical uses 77 tracks/side
	SUBI	T1,^D77		;No, convert to side 2 address
TRKSC1:	TRNN	S,S.2SID	;2 Sided media?
	 POPJ	P,		;No, illegal sector number
	TLOA	S,S.SID1	;Yes, use head 1
TRKSC2:	 TLZ	S,S.SID1	;Here when address is on side 0
	TRNE	S,S.PHYS	;Physical?
	 JRST	TRKSC3		;Yes, skip interleave
	ASH	T2,1		;Sector _ Sector * 2
	CAIL	T2,^D<13*2>	;In second 1/2 track?
	 AOJ	T2,		;Yes, use odd sector
	MOVE	T3,T1		;Copy track number
	IMULI	T3,6		;Compute track-track skew
	ADD	T2,T3		;Offset
	IDIVI	T2,^D26		;Modulo 26
	MOVE	T2,T3		;Skewed and interleaved sector in T2
	AOJ	T1,		;Logical tracks start with 1 (but not phys...)
TRKSC3:	AOJ	T2,		;Sectors are always based on 1
	CAIG	T1,^D77		;Track too big?
	 CAILE	T2,^D26		;Or sector too big?
	POPJ	P,		;Yes, error
	JRST	CPOPJ1##	;No, all set
	;Here for WPS mode conversion

TRKSCW:	TRNE	S,S.PHYS	;Physical and WPS
	 POPJ	P,		;Is illegal
	CAIG	T1,^D74-1	;On side 2?
	 JRST	TRKSW1		;No
	SUBI	T1,^D74		;Yes, adjust for side 1
	CAIG	T1,^D74-1	;Still too big?
	 TRNN	S,S.2SID	;No, 2 sided media?
	POPJ	P,		;Illegal track number
	TLOA	S,S.SID1	;Legal, select head 1
TRKSW1:	 TLZ	S,S.SID1	;Select head 0
	IMULI	T2,3		;Interleave by 3 sectors
	IDIVI	T2,^D26		;MOD 26
	AOS	T2,T3		;Sectors start at one
	AOJA	T1,CPOPJ1##	;Fix track and skip

	END