![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vp.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 vp.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / 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: * @(#)vp.c 7.4 (Berkeley) 4/3/90
7: */
8:
9: #include "vp.h"
10: #if NVP > 0
11: /*
12: * Versatec matrix printer/plotter
13: * dma interface driver
14: *
15: * SETUP NOTES:
16: * Set up both print and plot interrupts to go through the same vector
17: * (or kludge probe to reset second vector to first;
18: * default 174/200 is already handled).
19: * Give the address of the plcsr register in the config specification
20: */
21: #include "machine/pte.h"
22:
23: #include "param.h"
24: #include "user.h"
25: #include "buf.h"
26: #include "systm.h"
27: #include "map.h"
28: #include "ioctl.h"
29: #include "vcmd.h"
30: #include "uio.h"
31: #include "kernel.h"
32:
33: #include "ubavar.h"
34: #include "ubareg.h"
35:
36: unsigned minvpph();
37:
38: #define VPPRI (PZERO-1)
39:
40: struct vpdevice {
41: short plbcr;
42: short pbxaddr;
43: short prbcr;
44: u_short pbaddr;
45: short plcsr;
46: short plbuf;
47: short prcsr;
48: u_short prbuf;
49: };
50:
51: #define VP_ERROR 0100000
52: #define VP_DTCINTR 0040000
53: #define VP_DMAACT 0020000
54: #define VP_READY 0000200
55: #define VP_IENABLE 0000100
56: #define VP_TERMCOM 0000040
57: #define VP_FFCOM 0000020
58: #define VP_EOTCOM 0000010
59: #define VP_CLRCOM 0000004
60: #define VP_RESET 0000002
61: #define VP_SPP 0000001
62:
63: struct vp_softc {
64: int sc_state;
65: int sc_count;
66: int sc_bufp;
67: struct buf *sc_bp;
68: int sc_ubinfo;
69: } vp_softc[NVP];
70:
71: /* sc_state bits */
72: #define VPSC_BUSY 0001000
73: #define VPSC_MODE 0000700
74: #define VPSC_SPP 0000400
75: #define VPSC_PLOT 0000200
76: #define VPSC_PRINT 0000100
77: #define VPSC_CMNDS 0000076
78: #define VPSC_OPEN 0000001
79:
80: struct uba_device *vpdinfo[NVP];
81:
82: #define VPUNIT(dev) (minor(dev))
83:
84: struct buf rvpbuf[NVP];
85:
86: int vpprobe(), vpattach();
87: struct uba_device *vpdinfo[NVP];
88: u_short vpstd[] = { 0777500, 0 };
89: struct uba_driver vpdriver =
90: { vpprobe, 0, vpattach, 0, vpstd, "vp", vpdinfo };
91:
92: vpprobe(reg)
93: caddr_t reg;
94: {
95: register int br, cvec; /* value-result */
96: register struct vpdevice *vpaddr = (struct vpdevice *)(reg-010);
97:
98: #ifdef lint
99: br = 0; cvec = br; br = cvec;
100: vpintr(0);
101: #endif
102: vpaddr->prcsr = VP_IENABLE|VP_DTCINTR;
103: vpaddr->pbaddr = 0;
104: vpaddr->pbxaddr = 0;
105: vpaddr->prbcr = 1;
106: DELAY(10000);
107: vpaddr->prcsr = 0;
108: /* GET INTERRUPT AT SECOND VECTOR BUT WANT FIRST */
109: if (cvec == 0200) {
110: printf("vp reset vec from 200 to 174\n");
111: cvec = 0174;
112: }
113: return (sizeof (struct vpdevice));
114: }
115:
116: /*ARGSUSED*/
117: vpattach(ui)
118: struct uba_device *ui;
119: {
120:
121: ui->ui_addr -= 010;
122: ui->ui_physaddr -= 010;
123: }
124:
125: vpopen(dev)
126: dev_t dev;
127: {
128: register struct vp_softc *sc;
129: register struct vpdevice *vpaddr;
130: register struct uba_device *ui;
131:
132: if (VPUNIT(dev) >= NVP ||
133: ((sc = &vp_softc[minor(dev)])->sc_state&VPSC_OPEN) ||
134: (ui = vpdinfo[VPUNIT(dev)]) == 0 || ui->ui_alive == 0)
135: return (ENXIO);
136: vpaddr = (struct vpdevice *)ui->ui_addr;
137: sc->sc_state = VPSC_OPEN|VPSC_PRINT | VP_CLRCOM|VP_RESET;
138: sc->sc_count = 0;
139: vpaddr->prcsr = VP_IENABLE|VP_DTCINTR;
140: vptimo(dev);
141: while (sc->sc_state & VPSC_CMNDS) {
142: (void) spl4();
143: if (vpwait(dev)) {
144: (void) vpclose(dev);
145: return (EIO);
146: }
147: vpstart(dev);
148: (void) spl0();
149: }
150: return (0);
151: }
152:
153: vpstrategy(bp)
154: register struct buf *bp;
155: {
156: register int e;
157: register struct vp_softc *sc = &vp_softc[VPUNIT(bp->b_dev)];
158: register struct uba_device *ui = vpdinfo[VPUNIT(bp->b_dev)];
159: register struct vpdevice *vpaddr = (struct vpdevice *)ui->ui_addr;
160:
161: (void) spl4();
162: while (sc->sc_state & VPSC_BUSY)
163: sleep((caddr_t)sc, VPPRI);
164: sc->sc_state |= VPSC_BUSY;
165: sc->sc_bp = bp;
166: sc->sc_ubinfo = ubasetup(ui->ui_ubanum, bp, UBA_NEEDBDP);
167: if (e = vpwait(bp->b_dev))
168: goto brkout;
169: sc->sc_count = bp->b_bcount;
170: vpstart(bp->b_dev);
171: while (((sc->sc_state&VPSC_PLOT) ? vpaddr->plcsr : vpaddr->prcsr) & VP_DMAACT)
172: sleep((caddr_t)sc, VPPRI);
173: sc->sc_count = 0;
174: if ((sc->sc_state&VPSC_MODE) == VPSC_SPP)
175: sc->sc_state = (sc->sc_state &~ VPSC_MODE) | VPSC_PLOT;
176: (void) spl0();
177: brkout:
178: ubarelse(ui->ui_ubanum, &sc->sc_ubinfo);
179: sc->sc_state &= ~VPSC_BUSY;
180: sc->sc_bp = 0;
181: if (e)
182: bp->b_flags |= B_ERROR;
183: iodone(bp);
184: wakeup((caddr_t)sc);
185: }
186:
187: int vpblock = 16384;
188:
189: unsigned
190: minvpph(bp)
191: struct buf *bp;
192: {
193:
194: if (bp->b_bcount > vpblock)
195: bp->b_bcount = vpblock;
196: }
197:
198: /*ARGSUSED*/
199: vpwrite(dev, uio)
200: dev_t dev;
201: struct uio *uio;
202: {
203:
204: if (VPUNIT(dev) >= NVP)
205: return (ENXIO);
206: return (physio(vpstrategy, &rvpbuf[VPUNIT(dev)], dev, B_WRITE,
207: minvpph, uio));
208: }
209:
210: vpwait(dev)
211: dev_t dev;
212: {
213: register struct vpdevice *vpaddr =
214: (struct vpdevice *)vpdinfo[VPUNIT(dev)]->ui_addr;
215: register struct vp_softc *sc = &vp_softc[VPUNIT(dev)];
216: register int e;
217:
218: for (;;) {
219: e = (sc->sc_state & VPSC_PLOT) ? vpaddr->plcsr : vpaddr->prcsr;
220: if (e & (VP_READY|VP_ERROR))
221: break;
222: sleep((caddr_t)sc, VPPRI);
223: }
224: /* I WISH I COULD TELL WHETHER AN ERROR INDICATED AN NPR TIMEOUT */
225: return (e & VP_ERROR);
226: }
227:
228: vpstart(dev)
229: dev_t;
230: {
231: register struct vp_softc *sc = &vp_softc[VPUNIT(dev)];
232: register struct vpdevice *vpaddr =
233: (struct vpdevice *)vpdinfo[VPUNIT(dev)]->ui_addr;
234: short bit;
235:
236: if (sc->sc_count) {
237: vpaddr->pbaddr = sc->sc_ubinfo;
238: vpaddr->pbxaddr = (sc->sc_ubinfo>>12)&0x30;
239: if (sc->sc_state & (VPSC_PRINT|VPSC_SPP))
240: vpaddr->prbcr = sc->sc_count;
241: else
242: vpaddr->plbcr = sc->sc_count;
243: return;
244: }
245: for (bit = 1; bit != 0; bit <<= 1)
246: if (sc->sc_state&bit&VPSC_CMNDS) {
247: vpaddr->plcsr |= bit;
248: sc->sc_state &= ~bit;
249: return;
250: }
251: }
252:
253: /*ARGSUSED*/
254: vpioctl(dev, cmd, data, flag)
255: dev_t dev;
256: int cmd;
257: register caddr_t data;
258: int flag;
259: {
260: register struct vp_softc *sc = &vp_softc[VPUNIT(dev)];
261: register struct vpdevice *vpaddr =
262: (struct vpdevice *)vpdinfo[VPUNIT(dev)]->ui_addr;
263:
264: switch (cmd) {
265:
266: case VGETSTATE:
267: *(int *)data = sc->sc_state;
268: return (0);
269:
270: case VSETSTATE:
271: sc->sc_state =
272: (sc->sc_state & ~VPSC_MODE) |
273: ((*(int *)data) & (VPSC_MODE|VPSC_CMNDS));
274: break;
275:
276: default:
277: return (ENOTTY);
278: }
279: (void) spl4();
280: (void) vpwait(dev);
281: if (sc->sc_state&VPSC_SPP)
282: vpaddr->plcsr |= VP_SPP;
283: else
284: vpaddr->plcsr &= ~VP_SPP;
285: sc->sc_count = 0;
286: while (sc->sc_state & VPSC_CMNDS) {
287: (void) vpwait(dev);
288: vpstart(dev);
289: }
290: (void) spl0();
291: return (0);
292: }
293:
294: vptimo(dev)
295: dev_t dev;
296: {
297: register struct vp_softc *sc = &vp_softc[VPUNIT(dev)];
298:
299: if (sc->sc_state&VPSC_OPEN)
300: timeout(vptimo, (caddr_t)dev, hz/10);
301: vpintr(dev);
302: }
303:
304: /*ARGSUSED*/
305: vpintr(dev)
306: dev_t dev;
307: {
308: register struct vp_softc *sc = &vp_softc[VPUNIT(dev)];
309:
310: wakeup((caddr_t)sc);
311: }
312:
313: vpclose(dev)
314: dev_t dev;
315: {
316: register struct vp_softc *sc = &vp_softc[VPUNIT(dev)];
317: register struct vpdevice *vpaddr =
318: (struct vpdevice *)vpdinfo[VPUNIT(dev)]->ui_addr;
319:
320: sc->sc_state = 0;
321: sc->sc_count = 0;
322: vpaddr->plcsr = 0;
323: return (0);
324: }
325:
326: vpreset(uban)
327: int uban;
328: {
329: register int vp11;
330: register struct uba_device *ui;
331: register struct vp_softc *sc = vp_softc;
332: register struct vpdevice *vpaddr;
333:
334: for (vp11 = 0; vp11 < NVP; vp11++, sc++) {
335: if ((ui = vpdinfo[vp11]) == 0 || ui->ui_alive == 0 ||
336: ui->ui_ubanum != uban || (sc->sc_state&VPSC_OPEN) == 0)
337: continue;
338: printf(" vp%d", vp11);
339: vpaddr = (struct vpdevice *)ui->ui_addr;
340: vpaddr->prcsr = VP_IENABLE|VP_DTCINTR;
341: if ((sc->sc_state & VPSC_BUSY) == 0)
342: continue;
343: sc->sc_ubinfo = 0;
344: sc->sc_count = sc->sc_bp->b_bcount;
345: vpstart(sc->sc_bp->b_dev);
346: }
347: }
348:
349: vpselect()
350: {
351: return (1);
352: }
353: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.