![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ova.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba|
Return to ova.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba |
1.1 root 1: /* ova.c 4.23 90/02/17 */
2:
3: #include "va.h"
4: #if NVA > 0
5: /*
6: * Varian printer plotter
7: */
8: #include "../sys/param.h"
9: #include "../sys/user.h"
10: #include "../sys/buf.h"
11: #include "../sys/systm.h"
12: #include "../sys/map.h"
13: #include "../sys/pte.h"
14: #include "../sys/vcmd.h"
15: #include "../sys/uio.h"
16:
17: #include "../vaxuba/ubareg.h"
18: #include "../vaxuba/ubavar.h"
19:
20: unsigned minvaph();
21:
22: #define VAPRI (PZERO-1)
23:
24: struct vadevice {
25: u_short vaba; /* buffer address */
26: short vawc; /* word count (2's complement) */
27: union {
28: short Vacsw; /* control status as word */
29: struct { /* control status as bytes */
30: char Vacsl;
31: char Vacsh;
32: } vacsr;
33: } vacs;
34: short vadata; /* programmed i/o data buffer */
35: };
36:
37: #define vacsw vacs.Vacsw
38: #define vacsh vacs.vacsr.Vacsh
39: #define vacsl vacs.vacsr.Vacsl
40:
41: /* vacsw bits */
42: #define VA_ERROR 0100000 /* some error has occurred */
43: #define VA_NPRTIMO 0001000 /* DMA timeout error */
44: #define VA_NOTREADY 0000400 /* something besides NPRTIMO */
45: #define VA_DONE 0000200
46: #define VA_IENABLE 0000100 /* interrupt enable */
47: #define VA_DMAGO 0000010 /* DMA go bit */
48: #define VA_SUPPLIESLOW 0000004
49: #define VA_BOTOFFORM 0000002
50: #define VA_BYTEREVERSE 0000001 /* reverse byte order in words */
51:
52: /* vacsh command bytes */
53: #define VAPLOT 0000340
54: #define VAPRINT 0000100
55: #define VAPRINTPLOT 0000160
56: #define VAAUTOSTEP 0000244
57: #define VANOAUTOSTEP 0000045
58: #define VAFORMFEED 0000263
59: #define VASLEW 0000265
60: #define VASTEP 0000064
61:
62: struct va_softc {
63: char sc_openf;
64: char sc_busy;
65: int sc_state;
66: int sc_wc;
67: struct buf *sc_bp;
68: int sc_ubinfo;
69: } va_softc[NVA];
70:
71: #define VAUNIT(dev) (minor(dev))
72:
73: struct buf rvabuf[NVA];
74:
75: int vaprobe(), vaattach();
76: struct uba_device *vadinfo[NVA];
77: u_short vastd[] = { 0764000, 0 };
78: struct uba_driver vadriver =
79: { vaprobe, 0, vaattach, 0, vastd, "va", vadinfo };
80:
81: vaprobe(reg)
82: caddr_t reg;
83: {
84: register int br, cvec; /* value-result */
85: register struct vadevice *vaaddr = (struct vadevice *)reg;
86:
87: #ifdef lint
88: br = 0; cvec = br; br = cvec;
89: vaintr(0);
90: #endif
91: vaaddr->vacsl = VA_IENABLE;
92: vaaddr->vaba = 0;
93: vaaddr->vacsh = VAPLOT;
94: #ifndef VARIANGOBIT
95: vaaddr->vacsl = 0;
96: #endif
97: vaaddr->vawc = -1;
98: DELAY(100000);
99: vaaddr->vacsl = 0;
100: return (sizeof (struct vadevice));
101: }
102:
103: /*ARGSUSED*/
104: vaattach(ui)
105: struct uba_device *ui;
106: {
107:
108: }
109:
110: vaopen(dev)
111: dev_t dev;
112: {
113: register struct va_softc *sc;
114: register struct vadevice *vaaddr;
115: register struct uba_device *ui;
116: int error;
117:
118: if (VAUNIT(dev) >= NVA || (sc = &va_softc[minor(dev)])->sc_openf ||
119: (ui = vadinfo[VAUNIT(dev)]) == 0 || ui->ui_alive == 0)
120: return (ENXIO);
121: vaaddr = (struct vadevice *)ui->ui_addr;
122: sc->sc_openf = 1;
123: vaaddr->vawc = 0;
124: sc->sc_wc = 0;
125: sc->sc_state = 0;
126: vaaddr->vacsl = VA_IENABLE;
127: vatimo(dev);
128: error = vacmd(dev, VPRINT);
129: if (error)
130: vaclose(dev);
131: return (error);
132: }
133:
134: vastrategy(bp)
135: register struct buf *bp;
136: {
137: register int e;
138: register struct va_softc *sc = &va_softc[VAUNIT(bp->b_dev)];
139: register struct uba_device *ui = vadinfo[VAUNIT(bp->b_dev)];
140: register struct vadevice *vaaddr = (struct vadevice *)ui->ui_addr;
141:
142: (void) spl4();
143: while (sc->sc_busy)
144: sleep((caddr_t)sc, VAPRI);
145: sc->sc_busy = 1;
146: sc->sc_bp = bp;
147: sc->sc_ubinfo = ubasetup(ui->ui_ubanum, bp, UBA_NEEDBDP);
148: if (e = vawait(bp->b_dev))
149: goto brkout;
150: sc->sc_wc = -(bp->b_bcount/2);
151: vastart(bp->b_dev);
152: e = vawait(bp->b_dev);
153: sc->sc_wc = 0;
154: if (sc->sc_state & VPRINTPLOT) {
155: sc->sc_state = (sc->sc_state & ~VPRINTPLOT) | VPLOT;
156: vaaddr->vacsh = VAAUTOSTEP;
157: e |= vawait(bp->b_dev);
158: }
159: (void) spl0();
160: brkout:
161: ubarelse(ui->ui_ubanum, &sc->sc_ubinfo);
162: sc->sc_bp = 0;
163: sc->sc_busy = 0;
164: if (e)
165: bp->b_flags |= B_ERROR;
166: iodone(bp);
167: wakeup((caddr_t)sc);
168: }
169:
170: int vablock = 16384;
171:
172: unsigned
173: minvaph(bp)
174: struct buf *bp;
175: {
176:
177: if (bp->b_bcount > vablock)
178: bp->b_bcount = vablock;
179: }
180:
181: /*ARGSUSED*/
182: vawrite(dev, uio)
183: dev_t dev;
184: struct uio *uio;
185: {
186:
187: if (VAUNIT(dev) > NVA)
188: return (ENXIO);
189: return (physio(vastrategy, &rvabuf[VAUNIT(dev)], dev, B_WRITE,
190: minvaph, uio));
191: }
192:
193: vawait(dev)
194: dev_t dev;
195: {
196: register struct vadevice *vaaddr =
197: (struct vadevice *)vadinfo[VAUNIT(dev)]->ui_addr;
198: register int e;
199:
200: while (((e = vaaddr->vacsw) & (VA_DONE|VA_ERROR)) == 0)
201: sleep((caddr_t)&va_softc[VAUNIT(dev)], VAPRI);
202: if (e & VA_NPRTIMO)
203: printf("va%d: npr timeout\n", VAUNIT(dev));
204: return (e & VA_ERROR);
205: }
206:
207: vastart(dev)
208: dev_t;
209: {
210: register struct va_softc *sc = &va_softc[VAUNIT(dev)];
211: register struct vadevice *vaaddr =
212: (struct vadevice *)vadinfo[VAUNIT(dev)]->ui_addr;
213:
214: if (sc->sc_wc == 0)
215: return;
216: vaaddr->vaba = sc->sc_ubinfo;
217: #ifndef VARIANGOBIT
218: vaaddr->vacsl = (sc->sc_ubinfo >> 12) & 0x30;
219: #else
220: vaaddr->vacsl = (sc->sc_ubinfo >> 12) & 0x30 | VA_IENABLE | VA_DMAGO;
221: #endif
222: vaaddr->vawc = sc->sc_wc;
223: }
224:
225: /*ARGSUSED*/
226: vaioctl(dev, cmd, data, flag)
227: register caddr_t data;
228: {
229: register int vcmd;
230: register struct va_softc *sc = &va_softc[VAUNIT(dev)];
231:
232: switch (cmd) {
233:
234: case VGETSTATE:
235: *(int *)data = sc->sc_state;
236: break;
237:
238: case VSETSTATE:
239: return (vacmd(dev, *(int *)data));
240: break;
241:
242: default:
243: return (ENOTTY);
244: }
245: return (0);
246: }
247:
248: vacmd(dev, vcmd)
249: dev_t dev;
250: int vcmd;
251: {
252: register struct va_softc *sc = &va_softc[VAUNIT(dev)];
253: register struct vadevice *vaaddr =
254: (struct vadevice *)vadinfo[VAUNIT(dev)]->ui_addr;
255: int error = 0;
256:
257: (void) spl4();
258: (void) vawait(dev);
259: switch (vcmd) {
260:
261: case VPLOT:
262: /* Must turn on plot AND autostep modes. */
263: vaaddr->vacsh = VAPLOT;
264: if (vawait(dev))
265: error = EIO;
266: vaaddr->vacsh = VAAUTOSTEP;
267: break;
268:
269: case VPRINT:
270: vaaddr->vacsh = VAPRINT;
271: break;
272:
273: case VPRINTPLOT:
274: vaaddr->vacsh = VAPRINTPLOT;
275: break;
276: }
277: sc->sc_state = (sc->sc_state & ~(VPLOT|VPRINT|VPRINTPLOT)) | vcmd;
278: if (vawait(dev))
279: error = EIO;
280: (void) spl0();
281: return (error);
282: }
283:
284: vatimo(dev)
285: dev_t dev;
286: {
287: register struct va_softc *sc = &va_softc[VAUNIT(dev)];
288:
289: if (sc->sc_openf)
290: timeout(vatimo, (caddr_t)dev, hz/10);
291: vaintr(dev);
292: }
293:
294: /*ARGSUSED*/
295: vaintr(dev)
296: dev_t dev;
297: {
298: register struct va_softc *sc = &va_softc[VAUNIT(dev)];
299:
300: wakeup((caddr_t)sc);
301: }
302:
303: vaclose(dev)
304: dev_t dev;
305: {
306: register struct va_softc *sc = &va_softc[VAUNIT(dev)];
307: register struct vadevice *vaaddr =
308: (struct vadevice *)vadinfo[VAUNIT(dev)]->ui_addr;
309:
310: sc->sc_openf = 0;
311: sc->sc_busy = 0;
312: sc->sc_state = 0;
313: sc->sc_ubinfo = 0;
314: vaaddr->vacsl = 0;
315: }
316:
317: vareset(uban)
318: int uban;
319: {
320: register int va11;
321: register struct uba_device *ui;
322: register struct va_softc *sc = va_softc;
323: register struct vadevice *vaaddr;
324:
325: for (va11 = 0; va11 < NVA; va11++, sc++) {
326: if ((ui = vadinfo[va11]) == 0 || ui->ui_alive == 0 ||
327: ui->ui_ubanum != uban || sc->sc_openf == 0)
328: continue;
329: printf(" va%d", va11);
330: vaaddr = (struct vadevice *)ui->ui_addr;
331: vaaddr->vacsl = VA_IENABLE;
332: if (sc->sc_state & VPLOT) {
333: vaaddr->vacsh = VAPLOT;
334: DELAY(10000);
335: vaaddr->vacsh = VAAUTOSTEP;
336: } else if (sc->sc_state & VPRINTPLOT)
337: vaaddr->vacsh = VPRINTPLOT;
338: else
339: vaaddr->vacsh = VAPRINTPLOT;
340: DELAY(10000);
341: if (sc->sc_busy == 0)
342: continue;
343: sc->sc_ubinfo = ubasetup(ui->ui_ubanum, sc->sc_bp, UBA_NEEDBDP);
344: sc->sc_wc = -(sc->sc_bp->b_bcount/2);
345: vastart(sc->sc_bp->b_dev);
346: }
347: }
348:
349: vaselect()
350: {
351:
352: return (1);
353: }
354: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.