![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to va.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba|
Return to va.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba |
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: * @(#)va.c 7.1 (Berkeley) 6/5/86
7: */
8:
9: #include "va.h"
10: #if NVA > 0
11: /*
12: * Varian printer plotter
13: */
14: #include "../machine/pte.h"
15:
16: #include "param.h"
17: #include "dir.h"
18: #include "user.h"
19: #include "buf.h"
20: #include "systm.h"
21: #include "map.h"
22: #include "ioctl.h"
23: #include "vcmd.h"
24: #include "uio.h"
25: #include "kernel.h"
26:
27: #include "ubareg.h"
28: #include "ubavar.h"
29:
30: int vadebug = 0;
31: #define dprintf if(vadebug)printf
32:
33: unsigned minvaph();
34:
35: #define VAPRI (PZERO-1)
36:
37: struct vadevice {
38: u_short vaba; /* buffer address */
39: short vawc; /* word count (2's complement) */
40: union {
41: short Vacsw; /* control status as word */
42: struct { /* control status as bytes */
43: char Vacsl;
44: char Vacsh;
45: } vacsr;
46: } vacs;
47: short vadata; /* programmed i/o data buffer */
48: };
49:
50: #define vacsw vacs.Vacsw
51: #define vacsh vacs.vacsr.Vacsh
52: #define vacsl vacs.vacsr.Vacsl
53:
54: /* vacsw bits */
55: #define VA_ERROR 0100000 /* some error has occurred */
56: #define VA_NPRTIMO 0001000 /* DMA timeout error */
57: #define VA_NOTREADY 0000400 /* something besides NPRTIMO */
58: #define VA_DONE 0000200
59: #define VA_IENABLE 0000100 /* interrupt enable */
60: #define VA_DMAGO 0000010 /* DMA go bit */
61: #define VA_DMAGO 0000010 /* DMA go bit */
62: #define VA_SUPPLIESLOW 0000004
63: #define VA_BOTOFFORM 0000002
64: #define VA_BYTEREVERSE 0000001 /* reverse byte order in words */
65:
66: /* vacsh command bytes */
67: #define VAPLOT 0000340
68: #define VAPRINT 0000100
69: #define VAPRINTPLOT 0000160
70: #define VAAUTOSTEP 0000244
71: #define VANOAUTOSTEP 0000045
72: #define VAFORMFEED 0000263
73: #define VASLEW 0000265
74: #define VASTEP 0000064
75:
76: struct va_softc {
77: u_char sc_openf; /* exclusive open flag */
78: u_char sc_iostate; /* kind of I/O going on */
79: #define VAS_IDLE 0 /* no I/O, free */
80: #define VAS_PIO 1 /* programmed I/O */
81: #define VAS_DMA 2 /* DMA, block pio */
82: #define VAS_WANT 4 /* wakeup when iostate changes */
83: short sc_tocnt; /* time out counter */
84: short sc_info; /* csw passed from vaintr */
85: int sc_state; /* print/plot state of device */
86: } va_softc[NVA];
87:
88: #define VAUNIT(dev) (minor(dev))
89:
90: struct buf rvabuf[NVA];
91:
92: int vaprobe(), vaslave(), vaattach(), vadgo();
93: struct uba_device *vadinfo[NVA];
94: struct uba_ctlr *vaminfo[NVA];
95: struct buf vabhdr[NVA];
96: u_short vastd[] = { 0764000, 0 };
97: struct uba_driver vadriver =
98: { vaprobe, vaslave, vaattach, vadgo, vastd, "vz", vadinfo, "va", vaminfo };
99:
100: vaprobe(reg)
101: caddr_t reg;
102: {
103: register int br, cvec; /* value-result */
104: register struct vadevice *vaaddr = (struct vadevice *)reg;
105:
106: #ifdef lint
107: br = 0; cvec = br; br = cvec;
108: vaintr(0);
109: #endif
110: #ifndef UCBVAX
111: vaaddr->vacsl = VA_IENABLE;
112: vaaddr->vaba = 0;
113: vaaddr->vacsh = VAPLOT;
114: vaaddr->vacsl = VA_IENABLE|VA_DMAGO;
115: vaaddr->vawc = -1;
116: DELAY(10000);
117: vaaddr->vacsl = 0;
118: vaaddr->vawc = 0;
119: #else
120: br=0x14;
121: cvec=0170;
122: #endif
123: return (sizeof (struct vadevice));
124: }
125:
126: /*ARGSUSED*/
127: vaslave(ui, reg)
128: struct uba_device *ui;
129: caddr_t reg;
130: {
131:
132: ui->ui_dk = 0;
133: return (ui->ui_unit <= 0);
134: }
135:
136: /*ARGSUSED*/
137: vaattach(ui)
138: struct uba_device *ui;
139: {
140:
141: ui->ui_mi->um_tab.b_actf = &vabhdr[ui->ui_unit];
142: }
143:
144: vaopen(dev)
145: dev_t dev;
146: {
147: register struct va_softc *sc;
148: register struct vadevice *vaaddr;
149: register struct uba_device *ui;
150: int error;
151: int unit = VAUNIT(dev);
152:
153: if (unit >= NVA || (sc = &va_softc[unit])->sc_openf ||
154: (ui = vadinfo[unit]) == 0 || ui->ui_alive == 0)
155: return (ENXIO);
156: vaaddr = (struct vadevice *)ui->ui_addr;
157: sc->sc_openf = 1;
158: vaaddr->vawc = 0;
159: sc->sc_state = 0;
160: sc->sc_tocnt = 0;
161: sc->sc_iostate = VAS_IDLE;
162: vaaddr->vacsl = VA_IENABLE;
163: vatimo(dev);
164: error = vacmd(dev, VPRINT);
165: if (error)
166: vaclose(dev);
167: return (error);
168: }
169:
170: vastrategy(bp)
171: register struct buf *bp;
172: {
173: register struct uba_device *ui;
174: register struct uba_ctlr *um;
175: int s;
176:
177: dprintf("vastrategy(%x)\n", bp);
178: ui = vadinfo[VAUNIT(bp->b_dev)];
179: if (ui == 0 || ui->ui_alive == 0) {
180: bp->b_flags |= B_ERROR;
181: iodone(bp);
182: return;
183: }
184: s = spl4();
185: um = ui->ui_mi;
186: bp->b_actf = NULL;
187: if (um->um_tab.b_actf->b_actf == NULL)
188: um->um_tab.b_actf->b_actf = bp;
189: else {
190: printf("bp = 0x%x, um->um_tab.b_actf->b_actf = 0x%x\n",
191: bp, um->um_tab.b_actf->b_actf);
192: panic("vastrategy");
193: um->um_tab.b_actf->b_actl->b_forw = bp;
194: }
195: um->um_tab.b_actf->b_actl = bp;
196: bp = um->um_tab.b_actf;
197: dprintf("vastrategy: bp=%x actf=%x active=%d\n",
198: bp, bp->b_actf, bp->b_active);
199: if (bp->b_actf && bp->b_active == 0)
200: (void) vastart(um);
201: splx(s);
202: }
203:
204: int vablock = 16384;
205:
206: unsigned
207: minvaph(bp)
208: struct buf *bp;
209: {
210:
211: if (bp->b_bcount > vablock)
212: bp->b_bcount = vablock;
213: }
214:
215: /*ARGSUSED*/
216: vawrite(dev, uio)
217: dev_t dev;
218: struct uio *uio;
219: {
220:
221: if (VAUNIT(dev) > NVA)
222: return (ENXIO);
223: return (physio(vastrategy, &rvabuf[VAUNIT(dev)], dev, B_WRITE,
224: minvaph, uio));
225: }
226:
227: vastart(um)
228: register struct uba_ctlr *um;
229: {
230: struct buf *bp;
231: struct vadevice *vaaddr;
232: register struct va_softc *sc;
233: int unit;
234:
235: dprintf("vastart(%x), bp=%x\n", um, um->um_tab.b_actf->b_actf);
236: if ((bp = um->um_tab.b_actf->b_actf) == NULL)
237: return;
238: unit = VAUNIT(bp->b_dev);
239: sc = &va_softc[unit];
240: sc->sc_tocnt = 0;
241: while (sc->sc_iostate&VAS_PIO) {
242: sc->sc_iostate |= VAS_WANT;
243: sleep((caddr_t)&sc->sc_iostate, VAPRI);
244: }
245: sc->sc_iostate |= VAS_DMA;
246: vaaddr = (struct vadevice *)um->um_addr;
247: vaaddr->vacsl = 0;
248: vaaddr->vawc = -(bp->b_bcount / 2);
249: um->um_cmd = VA_DMAGO | VA_IENABLE;
250: (void) ubago(vadinfo[unit]);
251: }
252:
253: vadgo(um)
254: register struct uba_ctlr *um;
255: {
256: register struct vadevice *vaaddr = (struct vadevice *)um->um_addr;
257: register struct buf *bp;
258:
259: bp = um->um_tab.b_actf;
260: va_softc[VAUNIT(bp->b_actf->b_dev)].sc_tocnt = 0;
261: bp->b_active++;
262: vaaddr->vaba = um->um_ubinfo;
263: vaaddr->vacsl = ((um->um_ubinfo >> 12) & 0x30) | um->um_cmd;
264: }
265:
266: /*ARGSUSED*/
267: vaioctl(dev, cmd, data, flag)
268: register caddr_t data;
269: {
270: register struct va_softc *sc = &va_softc[VAUNIT(dev)];
271:
272: switch (cmd) {
273:
274: case VGETSTATE:
275: *(int *)data = sc->sc_state;
276: break;
277:
278: case VSETSTATE:
279: return (vacmd(dev, *(int *)data));
280:
281: default:
282: return (ENOTTY);
283: }
284: return (0);
285: }
286:
287: vacmd(dev, vcmd)
288: dev_t dev;
289: int vcmd;
290: {
291: register struct va_softc *sc = &va_softc[VAUNIT(dev)];
292: int error = 0;
293: int s, cmd;
294:
295: s = spl4();
296: while (sc->sc_iostate&VAS_DMA) {
297: sc->sc_iostate |= VAS_WANT;
298: sleep((caddr_t)&sc->sc_iostate, VAPRI);
299: }
300: sc->sc_iostate |= VAS_PIO;
301: sc->sc_tocnt = 0;
302: cmd = 0;
303: switch (vcmd) {
304:
305: case VPLOT:
306: /* Must turn on plot AND autostep modes. */
307: if (vadopio(dev, VAPLOT))
308: error = EIO;
309: cmd = VAAUTOSTEP;
310: break;
311:
312: case VPRINT:
313: cmd = VAPRINT;
314: break;
315:
316: case VPRINTPLOT:
317: cmd = VAPRINTPLOT;
318: break;
319: }
320: sc->sc_state = (sc->sc_state & ~(VPLOT|VPRINT|VPRINTPLOT)) | vcmd;
321: if (cmd && vadopio(dev, cmd))
322: error = EIO;
323: sc->sc_iostate &= ~VAS_PIO;
324: if (sc->sc_iostate&VAS_WANT) {
325: sc->sc_iostate &= ~VAS_WANT;
326: wakeup((caddr_t)&sc->sc_iostate);
327: }
328: splx(s);
329: return (error);
330: }
331:
332: vadopio(dev, cmd)
333: dev_t dev;
334: int cmd;
335: {
336: register struct vadevice *vaaddr =
337: (struct vadevice *)vaminfo[VAUNIT(dev)]->um_addr;
338: register struct va_softc *sc = &va_softc[VAUNIT(dev)];
339:
340: sc->sc_info = 0;
341: vaaddr->vacsh = cmd;
342: while ((sc->sc_info&(VA_DONE|VA_ERROR)) == 0)
343: sleep((caddr_t)&sc->sc_info, VAPRI);
344: return (sc->sc_info&VA_ERROR);
345: }
346:
347: vatimo(dev)
348: dev_t dev;
349: {
350: register struct va_softc *sc = &va_softc[VAUNIT(dev)];
351:
352: if (sc->sc_openf)
353: timeout(vatimo, (caddr_t)dev, hz/2);
354: if (++sc->sc_tocnt < 2)
355: return;
356: sc->sc_tocnt = 0;
357: dprintf("vatimo: calling vaintr\n");
358: vaintr(dev);
359: }
360:
361: /*ARGSUSED*/
362: vaintr(dev)
363: dev_t dev;
364: {
365: register struct uba_ctlr *um;
366: struct vadevice *vaaddr;
367: struct buf *bp;
368: register int unit = VAUNIT(dev), e;
369: register struct va_softc *sc = &va_softc[unit];
370:
371: um = vaminfo[unit];
372: vaaddr = (struct vadevice *)um->um_addr;
373: e = vaaddr->vacsw;
374: dprintf("vaintr: um=0x%x, e=0x%x, b_active %d\n",
375: um, e, um->um_tab.b_actf->b_active);
376: if ((e&(VA_DONE|VA_ERROR)) == 0)
377: return;
378: vaaddr->vacsl = 0;
379: if ((e&VA_ERROR) && (e&VA_NPRTIMO))
380: printf("va%d: npr timeout\n", unit);
381: if (sc->sc_iostate&VAS_PIO) {
382: sc->sc_info = e;
383: wakeup((caddr_t)&sc->sc_info);
384: return;
385: }
386: if (um->um_tab.b_actf->b_active) {
387: bp = um->um_tab.b_actf->b_actf;
388: if (e&VA_ERROR)
389: bp->b_flags |= B_ERROR;
390: if (sc->sc_state&VPRINTPLOT) {
391: sc->sc_state = (sc->sc_state & ~VPRINTPLOT) | VPLOT;
392: vaaddr->vacsh = VAAUTOSTEP;
393: return;
394: }
395: ubadone(um);
396: um->um_tab.b_actf->b_active = 0;
397: um->um_tab.b_actf->b_actf = bp->b_forw;
398: bp->b_active = 0;
399: bp->b_errcnt = 0;
400: bp->b_resid = 0;
401: iodone(bp);
402: }
403: if (um->um_tab.b_actf->b_actf == 0) {
404: sc->sc_iostate &= ~VAS_DMA;
405: if (sc->sc_iostate&VAS_WANT) {
406: sc->sc_iostate &= ~VAS_WANT;
407: wakeup((caddr_t)&sc->sc_iostate);
408: }
409: return;
410: }
411: if (um->um_tab.b_actf->b_active == 0)
412: vastart(um);
413: }
414:
415: vaclose(dev)
416: dev_t dev;
417: {
418: register struct va_softc *sc = &va_softc[VAUNIT(dev)];
419: register struct vadevice *vaaddr =
420: (struct vadevice *)vadinfo[VAUNIT(dev)]->ui_addr;
421:
422: sc->sc_openf = 0;
423: sc->sc_state = 0;
424: if (sc->sc_iostate != VAS_IDLE)
425: wakeup((caddr_t)&sc->sc_iostate);
426: sc->sc_iostate = VAS_IDLE;
427: vaaddr->vacsl = 0;
428: vaaddr->vawc = 0;
429: }
430:
431: vareset(uban)
432: int uban;
433: {
434: register int va11;
435: register struct uba_ctlr *um;
436: register struct vadevice *vaaddr;
437: register struct va_softc *sc;
438:
439: for (va11 = 0; va11 < NVA; va11++, sc++) {
440: if ((um = vaminfo[va11]) == 0 || um->um_ubanum != uban ||
441: um->um_alive == 0)
442: continue;
443: sc = &va_softc[um->um_ctlr];
444: if (sc->sc_openf == 0)
445: continue;
446: printf(" va%d", va11);
447: vaaddr = (struct vadevice *)um->um_addr;
448: vaaddr->vacsl = VA_IENABLE;
449: if (sc->sc_state & VPLOT) {
450: vaaddr->vacsh = VAPLOT;
451: DELAY(10000);
452: vaaddr->vacsh = VAAUTOSTEP;
453: } else if (sc->sc_state & VPRINTPLOT)
454: vaaddr->vacsh = VPRINTPLOT;
455: else
456: vaaddr->vacsh = VAPRINTPLOT;
457: DELAY(10000);
458: sc->sc_iostate = VAS_IDLE;
459: um->um_tab.b_actf->b_active = 0;
460: um->um_tab.b_actf->b_actf = um->um_tab.b_actf->b_actl = 0;
461: if (um->um_ubinfo) {
462: printf("<%d>", (um->um_ubinfo >> 28) & 0xf);
463: um->um_ubinfo = 0;
464: }
465: (void) vastart(um);
466: }
467: }
468:
469: vaselect()
470: {
471:
472: return (1);
473: }
474: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.