[unix-history] / .ref-Research-V6 / usr / sys / dmr / ht.c

#
/*
 */

/*
 * TJU16 tape driver
 */

#include "../param.h"
#include "../buf.h"
#include "../conf.h"
#include "../user.h"

struct {
	int	htcs1;
	int	htwc;
	int	htba;
	int	htfc;
	int	htcs2;
	int	htds;
	int	hter;
	int	htas;
	int	htck;
	int	htdb;
	int	htmr;
	int	htdt;
	int	htsn;
	int	httc;
	int	htbae;	/* 11/70 bus extension */
};

struct	devtab	httab;
struct	buf	rhtbuf;

#define	NUNIT	8

char	h_openf[NUNIT];
char	*h_blkno[NUNIT];
char	*h_nxrec[NUNIT];

#define	HTADDR	0172440

#define	GO	01
#define	NOP	0
#define	WEOF	026
#define	SFORW	030
#define	SREV	032
#define	ERASE	024
#define	REW	06
#define	CLR	010
#define	P800	01300		/* 800 + pdp11 mode */
#define	P1600	02300		/* 1600 + pdp11 mode */
#define	IENABLE	0100
#define	CRDY	0200
#define	EOF	04
#define	DRY	0200
#define	MOL	010000
#define	PIP	020000
#define	ERR	040000

#define	SSEEK	1
#define	SIO	2

htopen(dev, flag)
{
	register unit;

	unit = dev.d_minor&077;
	if (unit >= NUNIT || h_openf[unit])
		u.u_error = ENXIO;
	else {
		h_openf[unit]++;
		h_blkno[unit] = 0;
		h_nxrec[unit] = 65535;
		hcommand(dev, NOP);
	}
}

htclose(dev, flag)
{
	register int unit;

	unit = dev.d_minor&077;
	h_openf[unit] = 0;
	if (flag) {
		hcommand(dev, WEOF);
		hcommand(dev, WEOF);
	}
	hcommand(dev, REW);
}

hcommand(dev, com)
{
	register unit;
	extern lbolt;

	unit = dev.d_minor;
	while (httab.d_active || (HTADDR->htcs1 & CRDY)==0)
		sleep(&lbolt, 1);
	HTADDR->htcs2 = (unit>>3)&07;
	while((HTADDR->htds&DRY) == 0)
		sleep(&lbolt, 1);
	if(unit >= 64)
		HTADDR->httc = P800 | (unit&07); else
		HTADDR->httc = P1600 | (unit&07);
	while((HTADDR->htds&(MOL|PIP)) != MOL)
		sleep(&lbolt, 1);
	HTADDR->htcs1 = com | GO;
}

htstrategy(abp)
struct buf *abp;
{
	register struct buf *bp;
	register char **p;

	bp = abp;
	p = &h_nxrec[bp->b_dev.d_minor&077];
	if (*p <= bp->b_blkno) {
		if (*p < bp->b_blkno) {
			bp->b_flags =| B_ERROR;
			iodone(bp);
			return;
		}
		if (bp->b_flags&B_READ) {
			clrbuf(bp);
			iodone(bp);
			return;
		}
	}
	if ((bp->b_flags&B_READ)==0)
		*p = bp->b_blkno + 1;
	bp->av_forw = 0;
	spl5();
	if (httab.d_actf==0)
		httab.d_actf = bp;
	else
		httab.d_actl->av_forw = bp;
	httab.d_actl = bp;
	if (httab.d_active==0)
		htstart();
	spl0();
}

htstart()
{
	register struct buf *bp;
	register int unit;
	register char *blkno;

    loop:
	if ((bp = httab.d_actf) == 0)
		return;
	unit = bp->b_dev.d_minor;
	HTADDR->htcs2 = (unit>>3)&07;
	if(unit >= 64)
		HTADDR->httc = P800 | (unit&07); else
		HTADDR->httc = P1600 | (unit&07);
	unit =& 077;
	blkno = h_blkno[unit];
	if (h_openf[unit] < 0 || (HTADDR->htcs1 & CRDY)==0) {
		bp->b_flags =| B_ERROR;
		httab.d_actf = bp->av_forw;
		iodone(bp);
		goto loop;
	}
	if (blkno != bp->b_blkno) {
		httab.d_active = SSEEK;
		if (blkno < bp->b_blkno) {
			HTADDR->htfc = blkno - bp->b_blkno;
			HTADDR->htcs1 = SFORW|IENABLE|GO;
		} else {
			if (bp->b_blkno == 0)
				HTADDR->htcs1 = REW|IENABLE|GO;
			else {
				HTADDR->htfc = bp->b_blkno - blkno;
				HTADDR->htcs1 = SREV|IENABLE|GO;
			}
		}
		return;
	}
	httab.d_active = SIO;
	rhstart(bp, &HTADDR->htfc, bp->b_wcount<<1, &HTADDR->htbae);
}

htintr()
{
	register struct buf *bp;
	register int unit;

	if ((bp = httab.d_actf)==0)
		return;
	unit = bp->b_dev.d_minor&077;
	if (HTADDR->htcs1 & ERR) {
/*
		deverror(bp, HTADDR->hter, 0);
 */
		if(HTADDR->htds&EOF) {
			if(bp != &rhtbuf && h_openf[unit])
				h_openf[unit] = -1;
		}
		HTADDR->htcs1 = ERR|CLR|GO;
		if ((HTADDR->htds&DRY)!=0 && httab.d_active==SIO) {
			if (++httab.d_errcnt < 10) {
				h_blkno[unit]++;
				httab.d_active = 0;
				htstart();
				return;
			}
		}
		bp->b_flags =| B_ERROR;
		httab.d_active = SIO;
	}
	if (httab.d_active == SIO) {
		httab.d_errcnt = 0;
		h_blkno[unit]++;
		httab.d_actf = bp->av_forw;
		httab.d_active = 0;
		iodone(bp);
		bp->b_resid = HTADDR->htfc;
	} else
		h_blkno[unit] = bp->b_blkno;
	htstart();
}

htread(dev)
{
	htphys(dev);
	physio(htstrategy, &rhtbuf, dev, B_READ);
	u.u_count = -rhtbuf.b_resid;
}

htwrite(dev)
{
	htphys(dev);
	physio(htstrategy, &rhtbuf, dev, B_WRITE);
	u.u_count = 0;
}

htphys(dev)
{
	register unit, a;

	unit = dev.d_minor;
	a = lshift(u.u_offset, -9);
	h_blkno[unit] = a;
	h_nxrec[unit] = ++a;
}
Commit	Line	Data
8f1d4458 DR	1	#
	2	/*
	3	*/
	4
	5	/*
	6	* TJU16 tape driver
	7	*/
	8
	9	#include "../param.h"
	10	#include "../buf.h"
	11	#include "../conf.h"
	12	#include "../user.h"
	13
	14	struct {
	15	int htcs1;
	16	int htwc;
	17	int htba;
	18	int htfc;
	19	int htcs2;
	20	int htds;
	21	int hter;
	22	int htas;
	23	int htck;
	24	int htdb;
	25	int htmr;
	26	int htdt;
	27	int htsn;
	28	int httc;
	29	int htbae; /* 11/70 bus extension */
	30	};
	31
	32	struct devtab httab;
	33	struct buf rhtbuf;
	34
	35	#define NUNIT 8
	36
	37	char h_openf[NUNIT];
	38	char *h_blkno[NUNIT];
	39	char *h_nxrec[NUNIT];
	40
	41	#define HTADDR 0172440
	42
	43	#define GO 01
	44	#define NOP 0
	45	#define WEOF 026
	46	#define SFORW 030
	47	#define SREV 032
	48	#define ERASE 024
	49	#define REW 06
	50	#define CLR 010
	51	#define P800 01300 /* 800 + pdp11 mode */
	52	#define P1600 02300 /* 1600 + pdp11 mode */
	53	#define IENABLE 0100
	54	#define CRDY 0200
	55	#define EOF 04
	56	#define DRY 0200
	57	#define MOL 010000
	58	#define PIP 020000
	59	#define ERR 040000
	60
	61	#define SSEEK 1
	62	#define SIO 2
	63
	64	htopen(dev, flag)
65	{
66	register unit;
67
68	unit = dev.d_minor&077;
69	if (unit >= NUNIT \|\| h_openf[unit])
70	u.u_error = ENXIO;
71	else {
72	h_openf[unit]++;
73	h_blkno[unit] = 0;
74	h_nxrec[unit] = 65535;
75	hcommand(dev, NOP);
76	}
77	}
78
79	htclose(dev, flag)
80	{
81	register int unit;
82
83	unit = dev.d_minor&077;
84	h_openf[unit] = 0;
85	if (flag) {
86	hcommand(dev, WEOF);
87	hcommand(dev, WEOF);
88	}
89	hcommand(dev, REW);
90	}
91
92	hcommand(dev, com)
93	{
94	register unit;
95	extern lbolt;
96
97	unit = dev.d_minor;
98	while (httab.d_active \|\| (HTADDR->htcs1 & CRDY)==0)
99	sleep(&lbolt, 1);
100	HTADDR->htcs2 = (unit>>3)&07;
101	while((HTADDR->htds&DRY) == 0)
102	sleep(&lbolt, 1);
103	if(unit >= 64)
104	HTADDR->httc = P800 \| (unit&07); else
105	HTADDR->httc = P1600 \| (unit&07);
106	while((HTADDR->htds&(MOL\|PIP)) != MOL)
107	sleep(&lbolt, 1);
108	HTADDR->htcs1 = com \| GO;
109	}
110
111	htstrategy(abp)
112	struct buf *abp;
113	{
114	register struct buf *bp;
115	register char **p;
116
117	bp = abp;
118	p = &h_nxrec[bp->b_dev.d_minor&077];
119	if (*p <= bp->b_blkno) {
120	if (*p < bp->b_blkno) {
121	bp->b_flags =\| B_ERROR;
122	iodone(bp);
123	return;
124	}
125	if (bp->b_flags&B_READ) {
126	clrbuf(bp);
127	iodone(bp);
128	return;
129	}
130	}
131	if ((bp->b_flags&B_READ)==0)
132	*p = bp->b_blkno + 1;
133	bp->av_forw = 0;
134	spl5();
135	if (httab.d_actf==0)
136	httab.d_actf = bp;
137	else
138	httab.d_actl->av_forw = bp;
139	httab.d_actl = bp;
140	if (httab.d_active==0)
141	htstart();
142	spl0();
143	}
144
145	htstart()
146	{
147	register struct buf *bp;
148	register int unit;
149	register char *blkno;
150
151	loop:
152	if ((bp = httab.d_actf) == 0)
153	return;
154	unit = bp->b_dev.d_minor;
155	HTADDR->htcs2 = (unit>>3)&07;
156	if(unit >= 64)
157	HTADDR->httc = P800 \| (unit&07); else
158	HTADDR->httc = P1600 \| (unit&07);
159	unit =& 077;
160	blkno = h_blkno[unit];
161	if (h_openf[unit] < 0 \|\| (HTADDR->htcs1 & CRDY)==0) {
162	bp->b_flags =\| B_ERROR;
163	httab.d_actf = bp->av_forw;
164	iodone(bp);
165	goto loop;
166	}
167	if (blkno != bp->b_blkno) {
168	httab.d_active = SSEEK;
169	if (blkno < bp->b_blkno) {
170	HTADDR->htfc = blkno - bp->b_blkno;
171	HTADDR->htcs1 = SFORW\|IENABLE\|GO;
172	} else {
173	if (bp->b_blkno == 0)
174	HTADDR->htcs1 = REW\|IENABLE\|GO;
175	else {
176	HTADDR->htfc = bp->b_blkno - blkno;
177	HTADDR->htcs1 = SREV\|IENABLE\|GO;
178	}
179	}
180	return;
181	}
182	httab.d_active = SIO;
183	rhstart(bp, &HTADDR->htfc, bp->b_wcount<<1, &HTADDR->htbae);
184	}
185
186	htintr()
187	{
188	register struct buf *bp;
189	register int unit;
190
191	if ((bp = httab.d_actf)==0)
192	return;
193	unit = bp->b_dev.d_minor&077;
194	if (HTADDR->htcs1 & ERR) {
195	/*
196	deverror(bp, HTADDR->hter, 0);
197	*/
198	if(HTADDR->htds&EOF) {
199	if(bp != &rhtbuf && h_openf[unit])
200	h_openf[unit] = -1;
201	}
202	HTADDR->htcs1 = ERR\|CLR\|GO;
203	if ((HTADDR->htds&DRY)!=0 && httab.d_active==SIO) {
204	if (++httab.d_errcnt < 10) {
205	h_blkno[unit]++;
206	httab.d_active = 0;
207	htstart();
208	return;
209	}
210	}
211	bp->b_flags =\| B_ERROR;
212	httab.d_active = SIO;
213	}
214	if (httab.d_active == SIO) {
215	httab.d_errcnt = 0;
216	h_blkno[unit]++;
217	httab.d_actf = bp->av_forw;
218	httab.d_active = 0;
219	iodone(bp);
220	bp->b_resid = HTADDR->htfc;
221	} else
222	h_blkno[unit] = bp->b_blkno;
223	htstart();
224	}
225
226	htread(dev)
227	{
228	htphys(dev);
229	physio(htstrategy, &rhtbuf, dev, B_READ);
230	u.u_count = -rhtbuf.b_resid;
231	}
232
233	htwrite(dev)
234	{
235	htphys(dev);
236	physio(htstrategy, &rhtbuf, dev, B_WRITE);
237	u.u_count = 0;
238	}
239
240	htphys(dev)
241	{
242	register unit, a;
243
244	unit = dev.d_minor;
245	a = lshift(u.u_offset, -9);
246	h_blkno[unit] = a;
247	h_nxrec[unit] = ++a;
248	}