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