![[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] / 41BSD / 4.0.upgrade / sys / dev|
Return to flp.c CVS log | Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev |
1.1 root 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
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.