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