[unix-history] / sys / dev / flp.c

/*	flp.c	4.5	81/03/08	*/

#if VAX780
#include "../h/flp.h"
#include "../h/param.h"
#include "../h/systm.h"
#include "../h/conf.h"
#include "../h/dir.h"
#include "../h/user.h"
#include "../h/mtpr.h"
#include "../h/buf.h"
#include "../h/cons.h"
#include "../h/cpu.h"

struct {
	short	fl_state;		/* open and busy flags */
	short	fl_active;		/* driver state flag */
	struct	buf *fl_buf;		/* buffer we're using */
	unsigned char *fl_xaddr;	/* transfer address */
	short	fl_errcnt;
} fltab;

/*ARGSUSED*/
flopen(dev, flag)
	dev_t dev;
	int flag;
{
	struct buf *geteblk();

#if VAX750
	if (cpu != VAX_780) {
		u.u_error = ENXIO;
		return;
	}
#endif
	if (fltab.fl_state != 0) {
		u.u_error = ENXIO;
		return;
	}
	fltab.fl_state = FL_OPEN;
	fltab.fl_buf = geteblk();
	fltab.fl_active = FL_IDLE;
}

/*ARGSUSED*/
flclose(dev, flag)
	dev_t dev;
	int flag;
{

	brelse(fltab.fl_buf);
	fltab.fl_state = 0;
}

flstrategy(rw)
	int rw;
{
	register struct buf *bp;
	register unsigned i;

	/*
	 * Assume one block read/written for each call - 
	 * and enforce this by checking for block size of 128.
	 * Use the b_blkno field to address
	 * physical, 128-byte blocks (u.u_offset/128).
	 * This is checked for validity, and is further interpreted as:
	 *
	 *	track# * (sectors/track) + sector #
	 */
	if (u.u_count == 0) 
		return;
	(void) spl4();
	while (fltab.fl_state & FL_BUSY)
		sleep((caddr_t)&fltab, PRIBIO);
	fltab.fl_state |= FL_BUSY;
	(void) spl0();

	bp = fltab.fl_buf;
	while ((i = min(RXBYSEC, u.u_count)) != 0) {
		bp->b_blkno = u.u_offset>>7;
		if (bp->b_blkno >= MAXSEC || (u.u_offset & 0177) != 0) {
			/* block number out of range */
			/* or offset in middle of block */
			u.u_error = ENXIO;
			break;	
		}
		if (rw == B_WRITE) {
			iomove(bp->b_un.b_addr, i, B_WRITE);
			if (u.u_error != 0)
				break;
		}
		bp->b_flags = rw;
		(void) spl4(); 
		flstart();
		while ((bp->b_flags & B_DONE) == 0)
			sleep((caddr_t)bp, PRIBIO);	
		(void) spl0();
		if (bp->b_flags & B_ERROR) {
			u.u_error = EIO;
			break;
		}
		if (rw == B_READ) {
			iomove(bp->b_un.b_addr, i, B_READ);
			if (u.u_error != 0)
				break;
		}
	}
	u.u_count = bp->b_resid;
	fltab.fl_state &= ~FL_BUSY;
	wakeup((caddr_t)&fltab);
}

/*ARGSUSED*/
flread(dev)
	dev_t dev;
{

	flstrategy(B_READ);
}

/*ARGSUSED*/
flwrite(dev)
	dev_t dev;
{

	flstrategy(B_WRITE);
}

flstart()
{
	register struct buf *bp;

	bp = fltab.fl_buf;
	fltab.fl_active = FL_MAND;
	fltab.fl_errcnt = 0;
	fltab.fl_xaddr = (unsigned char *) bp->b_un.b_addr;
	bp->b_resid = 0;
	bp->b_bcount = RXBYSEC; /* always transfer a full sector */

	if ((mfpr(TXCS) & TXCS_RDY) == 0)
		/* not ready to receive order */
		return;
	/*
	 * Wake up floppy LSI software with command
	 */
	fltab.fl_active = FL_SEC;
	if ((bp->b_flags&B_READ) == B_READ)
		mtpr(TXDB, FL_RS);
	else
		mtpr(TXDB, FL_WS);
}

/*
 * See if we want to transmit something
 * to the floppy - and do it
 */
conxfl()
{
	register int databyte;
	register struct buf *bp;

	bp = fltab.fl_buf;
	switch (fltab.fl_active) {

	case FL_MAND:		/* send command */
		if ((bp->b_flags&B_READ) == B_READ)
			mtpr(TXDB,FL_RS);
		else
			mtpr(TXDB,  FL_WS);
		fltab.fl_active = FL_SEC;
		break;

	case FL_SEC:		/* send sector address */
		databyte = (int)bp->b_blkno % RXSTRK + 1;
		mtpr(TXDB, FL_DATA | databyte);
		fltab.fl_active = FL_TRACK;
		break;

	case FL_TRACK:		/* send track address */
		databyte = (int)bp->b_blkno / RXSTRK;
		mtpr(TXDB , FL_DATA | databyte);
		if ((bp->b_flags&B_READ) == B_READ)
			/* prepare to receive complete */
			fltab.fl_active = FL_COM;
		else
			/* prepare to send data */
			fltab.fl_active = FL_DAX;
		break;

	case FL_DAX:
		databyte = *(fltab.fl_xaddr++);
		mtpr(TXDB, FL_DATA | databyte);
		if (--bp->b_bcount == 0)
			fltab.fl_active = FL_COM;
		break;

	case FL_CAN:		/* give cancel order */
		mtpr(TXDB, FL_CANCEL);
		if (++fltab.fl_errcnt <= FLERRS) {
			/* If error count permits, retry order */
			fltab.fl_active = FL_MAND;
			bp->b_bcount = RXBYSEC;
			fltab.fl_xaddr = (unsigned char *) bp->b_un.b_addr;
		} else {
			/*
			 * We're really stupid today - call it an
			 * error and give up
			 */
			bp->b_flags |= B_ERROR | B_DONE;
			bp->b_resid = -RXBYSEC;
			fltab.fl_active = FL_IDLE;
			wakeup((caddr_t)bp);
		}
	}
}

cnrfl(c)
	int c;
{
	register int datum;
	register struct buf *bp;

	datum = c;
	bp = fltab.fl_buf;
	if (datum == FL_PERR) {
		/*
		 * Got a protocol error - cancel the
		 * current function and try again if error count isn't
		 * too great.  First, though, make sure that an actual
		 * transaction is in progress (so a spurious error from
		 * the LSI won't screw us up too much!
		 */
		if (fltab.fl_active != FL_IDLE)
			fltab.fl_active = FL_CAN;
	} else switch(fltab.fl_active ) {

	case FL_DAR:		/* expecting a datum */
		if ((c&RXDB_ID) != FL_DATA)
			goto error;
		*(fltab.fl_xaddr++) = (c & RXDB_DATA);
		if (--bp->b_bcount==0) {
			fltab.fl_active = FL_IDLE;
			bp->b_flags |= B_DONE;
			wakeup((caddr_t)bp);
		}
		break;

	case FL_COM:		/* expecting a "function complete" */
		if ((c&RXDB_ID)!= FL_FFC || (c&FL_ERR) == FL_ERR){
error:
			bp->b_flags |= B_ERROR | B_DONE;
			bp->b_resid = -bp->b_bcount;
			fltab.fl_active = FL_IDLE;
			wakeup((caddr_t)bp);
		} else if ((bp->b_flags&B_READ) == B_READ)
			/* got function complete, now get data */
			fltab.fl_active = FL_DAR;
		else {
			/* got function complete on write - finish up */
			fltab.fl_active = FL_IDLE;
			bp->b_flags |= B_DONE;
				wakeup((caddr_t)bp);
		}
		break;
	}
}
#endif
Commit	Line	Data
01395141 C	1	/* flp.c 4.5 81/03/08 */
	2
	3	#if VAX780
	4	#include "../h/flp.h"
	5	#include "../h/param.h"
	6	#include "../h/systm.h"
	7	#include "../h/conf.h"
	8	#include "../h/dir.h"
	9	#include "../h/user.h"
	10	#include "../h/mtpr.h"
	11	#include "../h/buf.h"
	12	#include "../h/cons.h"
	13	#include "../h/cpu.h"
	14
	15	struct {
	16	short fl_state; /* open and busy flags */
	17	short fl_active; /* driver state flag */
	18	struct buf fl_buf; / buffer we're using */
	19	unsigned char fl_xaddr; / transfer address */
	20	short fl_errcnt;
	21	} fltab;
	22
	23	/ARGSUSED/
	24	flopen(dev, flag)
	25	dev_t dev;
	26	int flag;
	27	{
	28	struct buf *geteblk();
	29
	30	#if VAX750
	31	if (cpu != VAX_780) {
	32	u.u_error = ENXIO;
	33	return;
	34	}
	35	#endif
	36	if (fltab.fl_state != 0) {
	37	u.u_error = ENXIO;
	38	return;
	39	}
	40	fltab.fl_state = FL_OPEN;
	41	fltab.fl_buf = geteblk();
	42	fltab.fl_active = FL_IDLE;
	43	}
	44
	45	/ARGSUSED/
	46	flclose(dev, flag)
	47	dev_t dev;
	48	int flag;
	49	{
	50
	51	brelse(fltab.fl_buf);
	52	fltab.fl_state = 0;
	53	}
	54
	55	flstrategy(rw)
	56	int rw;
	57	{
	58	register struct buf *bp;
	59	register unsigned i;
	60
	61	/*
	62	* Assume one block read/written for each call -
	63	* and enforce this by checking for block size of 128.
	64	* Use the b_blkno field to address
65	* physical, 128-byte blocks (u.u_offset/128).
66	* This is checked for validity, and is further interpreted as:
67	*
68	* track# * (sectors/track) + sector #
69	*/
70	if (u.u_count == 0)
71	return;
72	(void) spl4();
73	while (fltab.fl_state & FL_BUSY)
74	sleep((caddr_t)&fltab, PRIBIO);
75	fltab.fl_state \|= FL_BUSY;
76	(void) spl0();
77
78	bp = fltab.fl_buf;
79	while ((i = min(RXBYSEC, u.u_count)) != 0) {
80	bp->b_blkno = u.u_offset>>7;
81	if (bp->b_blkno >= MAXSEC \|\| (u.u_offset & 0177) != 0) {
82	/* block number out of range */
83	/* or offset in middle of block */
84	u.u_error = ENXIO;
85	break;
86	}
87	if (rw == B_WRITE) {
88	iomove(bp->b_un.b_addr, i, B_WRITE);
89	if (u.u_error != 0)
90	break;
91	}
92	bp->b_flags = rw;
93	(void) spl4();
94	flstart();
95	while ((bp->b_flags & B_DONE) == 0)
96	sleep((caddr_t)bp, PRIBIO);
97	(void) spl0();
98	if (bp->b_flags & B_ERROR) {
99	u.u_error = EIO;
100	break;
101	}
102	if (rw == B_READ) {
103	iomove(bp->b_un.b_addr, i, B_READ);
104	if (u.u_error != 0)
105	break;
106	}
107	}
108	u.u_count = bp->b_resid;
109	fltab.fl_state &= ~FL_BUSY;
110	wakeup((caddr_t)&fltab);
111	}
112
113	/ARGSUSED/
114	flread(dev)
115	dev_t dev;
116	{
117
118	flstrategy(B_READ);
119	}
120
121	/ARGSUSED/
122	flwrite(dev)
123	dev_t dev;
124	{
125
126	flstrategy(B_WRITE);
127	}
128
129	flstart()
130	{
131	register struct buf *bp;
132
133	bp = fltab.fl_buf;
134	fltab.fl_active = FL_MAND;
135	fltab.fl_errcnt = 0;
136	fltab.fl_xaddr = (unsigned char *) bp->b_un.b_addr;
137	bp->b_resid = 0;
138	bp->b_bcount = RXBYSEC; /* always transfer a full sector */
139
140	if ((mfpr(TXCS) & TXCS_RDY) == 0)
141	/* not ready to receive order */
142	return;
143	/*
144	* Wake up floppy LSI software with command
145	*/
146	fltab.fl_active = FL_SEC;
147	if ((bp->b_flags&B_READ) == B_READ)
148	mtpr(TXDB, FL_RS);
149	else
150	mtpr(TXDB, FL_WS);
151	}
152
153	/*
154	* See if we want to transmit something
155	* to the floppy - and do it
156	*/
157	conxfl()
158	{
159	register int databyte;
160	register struct buf *bp;
161
162	bp = fltab.fl_buf;
163	switch (fltab.fl_active) {
164
165	case FL_MAND: /* send command */
166	if ((bp->b_flags&B_READ) == B_READ)
167	mtpr(TXDB,FL_RS);
168	else
169	mtpr(TXDB, FL_WS);
170	fltab.fl_active = FL_SEC;
171	break;
172
173	case FL_SEC: /* send sector address */
174	databyte = (int)bp->b_blkno % RXSTRK + 1;
175	mtpr(TXDB, FL_DATA \| databyte);
176	fltab.fl_active = FL_TRACK;
177	break;
178
179	case FL_TRACK: /* send track address */
180	databyte = (int)bp->b_blkno / RXSTRK;
181	mtpr(TXDB , FL_DATA \| databyte);
182	if ((bp->b_flags&B_READ) == B_READ)
183	/* prepare to receive complete */
184	fltab.fl_active = FL_COM;
185	else
186	/* prepare to send data */
187	fltab.fl_active = FL_DAX;
188	break;
189
190	case FL_DAX:
191	databyte = *(fltab.fl_xaddr++);
192	mtpr(TXDB, FL_DATA \| databyte);
193	if (--bp->b_bcount == 0)
194	fltab.fl_active = FL_COM;
195	break;
196
197	case FL_CAN: /* give cancel order */
198	mtpr(TXDB, FL_CANCEL);
199	if (++fltab.fl_errcnt <= FLERRS) {
200	/* If error count permits, retry order */
201	fltab.fl_active = FL_MAND;
202	bp->b_bcount = RXBYSEC;
203	fltab.fl_xaddr = (unsigned char *) bp->b_un.b_addr;
204	} else {
205	/*
206	* We're really stupid today - call it an
207	* error and give up
208	*/
209	bp->b_flags \|= B_ERROR \| B_DONE;
210	bp->b_resid = -RXBYSEC;
211	fltab.fl_active = FL_IDLE;
212	wakeup((caddr_t)bp);
213	}
214	}
215	}
216
217	cnrfl(c)
218	int c;
219	{
220	register int datum;
221	register struct buf *bp;
222
223	datum = c;
224	bp = fltab.fl_buf;
225	if (datum == FL_PERR) {
226	/*
227	* Got a protocol error - cancel the
228	* current function and try again if error count isn't
229	* too great. First, though, make sure that an actual
230	* transaction is in progress (so a spurious error from
231	* the LSI won't screw us up too much!
232	*/
233	if (fltab.fl_active != FL_IDLE)
234	fltab.fl_active = FL_CAN;
235	} else switch(fltab.fl_active ) {
236
237	case FL_DAR: /* expecting a datum */
238	if ((c&RXDB_ID) != FL_DATA)
239	goto error;
240	*(fltab.fl_xaddr++) = (c & RXDB_DATA);
241	if (--bp->b_bcount==0) {
242	fltab.fl_active = FL_IDLE;
243	bp->b_flags \|= B_DONE;
244	wakeup((caddr_t)bp);
245	}
246	break;
247
248	case FL_COM: /* expecting a "function complete" */
249	if ((c&RXDB_ID)!= FL_FFC \|\| (c&FL_ERR) == FL_ERR){
250	error:
251	bp->b_flags \|= B_ERROR \| B_DONE;
252	bp->b_resid = -bp->b_bcount;
253	fltab.fl_active = FL_IDLE;
254	wakeup((caddr_t)bp);
255	} else if ((bp->b_flags&B_READ) == B_READ)
256	/* got function complete, now get data */
257	fltab.fl_active = FL_DAR;
258	else {
259	/* got function complete on write - finish up */
260	fltab.fl_active = FL_IDLE;
261	bp->b_flags \|= B_DONE;
262	wakeup((caddr_t)bp);
263	}
264	break;
265	}
266	}
267	#endif