![[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] / 42BSD / sys / vax|
Return to flp.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / vax |
1.1 root 1: /* flp.c 6.1 83/07/29 */
2:
3: #if VAX780
4: #include "../h/param.h"
5: #include "../h/systm.h"
6: #include "../h/conf.h"
7: #include "../h/dir.h"
8: #include "../h/user.h"
9: #include "../h/buf.h"
10: #include "../h/uio.h"
11:
12: #include "../vax/cons.h"
13: #include "../vax/cpu.h"
14: #include "../vax/flp.h"
15: #include "../vax/mtpr.h"
16:
17: struct {
18: short fl_state; /* open and busy flags */
19: short fl_active; /* driver state flag */
20: struct buf *fl_buf; /* buffer we're using */
21: unsigned char *fl_xaddr; /* transfer address */
22: short fl_errcnt;
23: } fltab;
24:
25: /*ARGSUSED*/
26: flopen(dev, flag)
27: dev_t dev;
28: int flag;
29: {
30: struct buf *geteblk();
31:
32: #if VAX750
33: if (cpu != VAX_780)
34: return (ENXIO);
35: #endif
36: if (fltab.fl_state != 0)
37: return (ENXIO);
38: fltab.fl_state = FL_OPEN;
39: fltab.fl_buf = geteblk(512);
40: fltab.fl_active = FL_IDLE;
41: return (0);
42: }
43:
44: /*ARGSUSED*/
45: flclose(dev, flag)
46: dev_t dev;
47: int flag;
48: {
49:
50: brelse(fltab.fl_buf);
51: fltab.fl_state = 0;
52: }
53:
54: floperation(rw, uio)
55: enum uio_rw rw;
56: struct uio *uio;
57: {
58: register struct buf *bp;
59: register int i;
60: int error;
61:
62: /*
63: * Assume one block read/written for each call -
64: * and enforce this by checking for block size of 128.
65: * Use the b_blkno field to address
66: * physical, 128-byte blocks (u.u_offset/128).
67: * This is checked for validity, and is further interpreted as:
68: *
69: * track# * (sectors/track) + sector #
70: */
71: if (uio->uio_resid == 0)
72: return (0);
73: (void) spl4();
74: while (fltab.fl_state & FL_BUSY)
75: sleep((caddr_t)&fltab, PRIBIO);
76: fltab.fl_state |= FL_BUSY;
77: (void) spl0();
78:
79: bp = fltab.fl_buf;
80: error = 0;
81: while ((i = imin(RXBYSEC, uio->uio_resid)) > 0) {
82: bp->b_blkno = uio->uio_offset>>7;
83: if (bp->b_blkno >= MAXSEC || (uio->uio_offset & 0177) != 0)
84: return (ENXIO);
85: if (rw == UIO_WRITE) {
86: error = uiomove(bp->b_un.b_addr, i, UIO_WRITE, uio);
87: if (error)
88: break;
89: }
90: bp->b_flags = rw == UIO_WRITE ? B_WRITE : B_READ;
91: (void) spl4();
92: flstart();
93: while ((bp->b_flags & B_DONE) == 0)
94: sleep((caddr_t)bp, PRIBIO);
95: (void) spl0();
96: if (bp->b_flags & B_ERROR) {
97: error = EIO;
98: break;
99: }
100: if (rw == UIO_READ) {
101: error = uiomove(bp->b_un.b_addr, i, UIO_READ, uio);
102: if (error)
103: break;
104: }
105: }
106: fltab.fl_state &= ~FL_BUSY;
107: wakeup((caddr_t)&fltab);
108: return (error);
109: }
110:
111: /*ARGSUSED*/
112: flread(dev, uio)
113: dev_t dev;
114: struct uio *uio;
115: {
116:
117: return (floperation(UIO_READ, uio));
118: }
119:
120: /*ARGSUSED*/
121: flwrite(dev, uio)
122: dev_t dev;
123: struct uio *uio;
124: {
125:
126: return (floperation(UIO_WRITE, uio));
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
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.