![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / dev|
Return to cv.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: #include "cv.h"
2: #if NCV > 0
3: /*
4: * Raster Technologies Color Video Interface -- Rob Pike
5: * Model One 20 with Option Card, on DR-11/W
6: */
7:
8: #include "../h/param.h"
9: #include "../h/dir.h"
10: #include "../h/user.h"
11: #include "../h/buf.h"
12: #include "../h/systm.h"
13: #include "../h/pte.h"
14: #include "../h/map.h"
15: #include "../h/ioctl.h"
16: #include "../h/ubareg.h"
17: #include "../h/ubavar.h"
18:
19: struct cvdevice {
20: short wcr; /* Unibus word count reg */
21: u_short bar; /* Unibus address register */
22: u_short csr; /* Unibus status/command reg */
23: u_short idr; /* Input Data Register */
24: };
25: #define eir csr /* Error and Information Register */
26: #define odr idr /* Output Data Register */
27:
28: /*
29: * Unibus status/command register bits
30: */
31:
32: #define GO 0000001
33: #define IENABLE 0000100
34: #define READY 0000200
35: #define MAINT 0010000
36: #define ERROR 0100000
37:
38: /*
39: * Function codes
40: */
41: #define WR_IMAGE (1<<1)
42: #define WR_CMD (4<<1)
43: #define WR_RLE (5<<1)
44: #define RD_CMD (7<<1)
45: #define RD_IMAGE (3<<1)
46: #define FUNCMASK (7<<1)
47: #define TOGGLE (8<<1) /* toggle between X and WR_CMD, WR_CMD first */
48:
49: /*
50: * IOCTL
51: */
52: #define CVSETDMA (('c'<<8)|1)
53:
54: #define BUSY 01
55: #define DMAPRI (PZERO-1)
56: #define WAITPRI (PZERO+1)
57:
58: int cvprobe(), cvattach(), cvintr();
59: struct uba_device *cvdinfo[NCV];
60: u_short cvstd[] = { 0772410, 0000000, 0 };
61: struct uba_driver cvdriver = {
62: cvprobe, 0, cvattach, 0, cvstd, "cv", cvdinfo, 0, 0
63: };
64:
65: struct cvsoftc {
66: char open;
67: short uid;
68: short state;
69: int ubinfo;
70: int count;
71: struct buf *bp;
72: int bufp;
73: int icnt;
74: short dmamode;
75: short func;
76: } cvsoftc[NCV];
77:
78: int cvstrategy();
79: u_int cvminphys();
80: struct buf rcvbuf[NCV];
81:
82: #define UNIT(dev) (minor(dev))
83:
84: cvprobe(reg)
85: caddr_t reg;
86: {
87: register int br, cvec; /* value-result */
88: register struct cvdevice *cvaddr = (struct cvdevice *) reg;
89:
90: #ifdef lint
91: br = 0; cvec = br; br = cvec;
92: cvintr(0);
93: #endif
94: cvaddr->csr = IENABLE;
95: cvaddr->odr = 0x0707; /* clear screen, force interrupt */
96: DELAY(10000);
97: cvaddr->csr = 0;
98: /* KLUDGE */
99: br=0x15;
100: cvec=0124;
101: return (sizeof (struct cvdevice));
102: }
103:
104: /*ARGSUSED*/
105: cvattach(ui)
106: struct uba_device *ui;
107: {
108:
109: }
110:
111: cvopen(dev)
112: dev_t dev;
113: {
114: register struct cvsoftc *cvp;
115: register struct uba_device *ui;
116:
117: if (UNIT(dev) >= NCV || (cvp = &cvsoftc[minor(dev)])->open ||
118: (ui = cvdinfo[UNIT(dev)]) == 0 || ui->ui_alive == 0)
119: u.u_error = EBUSY;
120: else {
121: cvp->open = 1;
122: cvp->icnt = 0;
123: cvp->state = 0;
124: cvp->uid = u.u_uid;
125: cvp->dmamode = -1;
126: }
127: }
128:
129: cvclose(dev)
130: dev_t dev;
131: {
132:
133: cvsoftc[minor(dev)].open = 0;
134: cvsoftc[minor(dev)].state = 0;
135: }
136:
137: cvread(dev, uio)
138: dev_t dev;
139: struct uio *uio;
140: {
141: register int unit = UNIT(dev);
142:
143: if (unit >= NCV)
144: return (ENXIO);
145: return (physio(cvstrategy, &rcvbuf[unit], dev, B_READ, cvminphys, uio));
146: }
147:
148: cvwrite(dev, uio)
149: dev_t dev;
150: struct uio *uio;
151: {
152: register int unit = UNIT(dev);
153:
154: if (unit >= NCV)
155: return (ENXIO);
156: return (physio(cvstrategy, &rcvbuf[unit], dev, B_WRITE, cvminphys, uio));
157: }
158:
159: u_int
160: cvminphys(bp)
161: register struct buf *bp;
162: {
163:
164: if (bp->b_bcount > 65536) /* may be able to do twice as much */
165: bp->b_bcount = 65536;
166: }
167:
168: cvstrategy(bp)
169: register struct buf *bp;
170: {
171: register struct cvsoftc *cvp = &cvsoftc[UNIT(bp->b_dev)];
172: register struct uba_device *ui;
173:
174: if (UNIT(bp->b_dev) >= NCV || (ui = cvdinfo[UNIT(bp->b_dev)]) == 0
175: || ui->ui_alive == 0)
176: goto bad;
177: (void) spl5();
178: while (cvp->state & BUSY)
179: sleep((caddr_t)cvp, DMAPRI+1);
180: cvp->state |= BUSY;
181: cvp->bp = bp;
182: if(bp->b_bcount<=0 || (bp->b_bcount&1) ||
183: ((int)bp->b_un.b_addr&1) || cvp->dmamode<0){
184: u.u_error = EINVAL;
185: goto bad;
186: }
187: cvp->ubinfo = ubasetup(ui->ui_ubanum, bp, UBA_NEEDBDP);
188: cvp->bufp = cvp->ubinfo & 0x3ffff;
189: cvp->count = -(bp->b_bcount>>1); /* it's a word count */
190: cvstart(ui);
191: if(tsleep((caddr_t)cvp, DMAPRI+1, 15) != TS_OK){
192: register struct cvdevice *cvaddr = (struct cvdevice *) ui->ui_addr;
193: bp->b_flags |= B_ERROR;
194: /* stop the dma */
195: cvslam(cvaddr);
196: cvaddr->wcr=0xFFFF; /* gently; -1 first... */
197: cvaddr->wcr=0x0000; /* then zero */
198: /* reset device */
199: cvslam(cvaddr);
200: /* fake an interrupt to clear software status */
201: cvintr(UNIT(bp->b_dev));
202: }
203: cvp->count = 0;
204: cvp->bufp = 0;
205: (void) spl0();
206: ubarelse(ui->ui_ubanum, &cvp->ubinfo);
207: cvp->bp = 0;
208: iodone(bp);
209: wakeup((caddr_t)cvp);
210: return;
211: bad:
212: cvp->state &= ~BUSY;
213: bp->b_flags |= B_ERROR;
214: iodone(bp);
215: return;
216: }
217:
218: cvslam(cvaddr)
219: register struct cvdevice *cvaddr;
220: {
221: register i;
222: cvaddr->csr=MAINT;
223: for(i=0; i<10; i++)
224: ;
225: cvaddr->csr=0;
226: for(i=0; i<10; i++)
227: ;
228: }
229: cvstart(ui)
230: register struct uba_device *ui;
231: {
232: register int csr;
233: register struct cvdevice *cvaddr = (struct cvdevice *) ui->ui_addr;
234: register struct cvsoftc *cvp = &cvsoftc[UNIT(ui->ui_unit)];
235:
236: if((cvp->dmamode&TOGGLE) && cvp->func!=WR_CMD)
237: cvp->func = WR_CMD;
238: else
239: cvp->func = cvp->dmamode&~TOGGLE;
240: csr = IENABLE|((cvp->bufp>>12)&060) | cvp->func;
241: cvaddr->wcr = cvp->count;
242: cvaddr->bar = cvp->bufp;
243: cvaddr->csr = csr; /* No GO bit; let function codes settle */
244: cvaddr->csr = csr|GO;
245: }
246:
247: /*ARGSUSED*/
248: cvioctl(dev, cmd, data)
249: dev_t dev;
250: int cmd;
251: register caddr_t data;
252: {
253: register struct uba_device *ui = cvdinfo[UNIT(dev)];
254: register struct cvsoftc *cvp = &cvsoftc[UNIT(dev)];
255: int fmt;
256:
257: switch (cmd) {
258: case CVSETDMA: /* set DMA mode */
259: if (copyin(data, (caddr_t)&fmt, sizeof(fmt))) {
260: u.u_error = EFAULT;
261: goto out;
262: }
263: switch (fmt&~TOGGLE) {
264: case WR_IMAGE:
265: case WR_CMD:
266: case WR_RLE:
267: case RD_CMD:
268: case RD_IMAGE:
269: cvp->dmamode = cvp->func = fmt;
270: cvp->func &= ~TOGGLE;
271: break;
272: default:
273: u.u_error = EINVAL;
274: }
275: goto out;
276:
277: default:
278: return (ENOTTY);
279: }
280: out:
281: return u.u_error;
282: }
283:
284: /*ARGSUSED*/
285: cvintr(dev)
286: dev_t dev;
287: {
288: register struct cvdevice *cvaddr =
289: (struct cvdevice *) cvdinfo[UNIT(dev)]->ui_addr;
290: register struct cvsoftc *cvp = &cvsoftc[UNIT(dev)];
291: register csr;
292:
293: cvp->icnt++;
294: if (cvp->state&BUSY) {
295: csr = cvaddr->csr;
296: if(csr & ERROR){
297: cvaddr->eir |= ERROR;
298: printf("cv: CSR %x EIR %x\n", csr, cvaddr->eir);
299: }
300: cvaddr->csr = csr&~FUNCMASK;
301: cvp->state &= ~BUSY;
302: wakeup((caddr_t)cvp);
303: }
304: }
305:
306: cvreset(uban)
307: int uban;
308: {
309: register int i;
310: register struct uba_device *ui;
311: register struct cvsoftc *cvp = cvsoftc;
312: #ifdef untried
313: for (i = 0; i < NCV; i++, cvp++) {
314: if ((ui = cvdinfo[i]) == 0 || ui->ui_alive == 0 ||
315: ui->ui_ubanum != uban || cvp->open == 0)
316: continue;
317: printf(" cv%d", i);
318: if ((cvp->state&CVBUSY) == 0)
319: continue;
320: cvp->ubinfo =
321: ubasetup(ui->ui_ubanum, cvp->bp, UBA_NEEDBDP);
322: cvp->count = -(cvp->bp->b_bcount/2);
323: cvstart(ui);
324: }
325: #endif
326: }
327: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.