![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ik.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 ik.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: * @(#)ik.c 7.1 (Berkeley) 6/5/86
7: */
8:
9: #include "ik.h"
10: #if NIK > 0
11: /*
12: * Ikonas Frame Buffer Interface -- Bill Reeves.
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 "uio.h"
23: #include "ioctl.h"
24:
25: #include "ubareg.h"
26: #include "ubavar.h"
27: #include "ikreg.h"
28:
29: #define IKBUSY 01
30: #define IKDMAPRI (PZERO-1)
31: #define IKWAITPRI (PZERO+1)
32:
33: int ikprobe(), ikattach(), ikintr();
34: struct uba_device *ikdinfo[NIK];
35: u_short ikstd[] = { 0772460, 0000000, 0 };
36: struct uba_driver ikdriver =
37: { ikprobe, 0, ikattach, 0, ikstd, "ik", ikdinfo, 0, 0 };
38:
39: struct ik_softc {
40: char ik_open;
41: short ik_uid;
42: short ik_state;
43: int ik_ubinfo;
44: int ik_count;
45: struct buf *ik_bp;
46: int ik_bufp;
47: int ik_icnt;
48: } ik_softc[NIK];
49:
50: int ikstrategy();
51: u_int ikminphys();
52: struct buf rikbuf[NIK];
53:
54: #define IKUNIT(dev) (minor(dev))
55:
56: ikprobe(reg)
57: caddr_t reg;
58: {
59: register int br, cvec; /* value-result */
60: register struct ikdevice *ikaddr = (struct ikdevice *) reg;
61:
62: #ifdef lint
63: br = 0; cvec = br; br = cvec;
64: ikintr(0);
65: #endif
66: ikaddr->ik_istat = 0;
67: ikaddr->ik_xaddr = 0;
68: ikaddr->ik_yaddr = 0;
69: ikaddr->ik_ustat = IK_IENABLE | IK_GO;
70: DELAY(10000);
71: ikaddr->ik_ustat = 0;
72: return (sizeof (struct ikdevice));
73: }
74:
75: /*ARGSUSED*/
76: ikattach(ui)
77: struct uba_device *ui;
78: {
79:
80: }
81:
82: ikopen(dev)
83: dev_t dev;
84: {
85: register struct ik_softc *ikp;
86: register struct uba_device *ui;
87:
88: if (IKUNIT(dev) >= NIK || (ikp = &ik_softc[minor(dev)])->ik_open ||
89: (ui = ikdinfo[IKUNIT(dev)]) == 0 || ui->ui_alive == 0)
90: return (ENXIO);
91: ikp->ik_open = 1;
92: ikp->ik_icnt = 0;
93: ikp->ik_state = 0;
94: ikp->ik_uid = u.u_uid;
95: maptouser(ui->ui_addr);
96: return (0);
97: }
98:
99: ikclose(dev)
100: dev_t dev;
101: {
102:
103: ik_softc[minor(dev)].ik_open = 0;
104: ik_softc[minor(dev)].ik_state = 0;
105: unmaptouser(ikdinfo[IKUNIT(dev)]->ui_addr);
106: }
107:
108: ikread(dev, uio)
109: dev_t dev;
110: struct uio *uio;
111: {
112: register int unit = IKUNIT(dev);
113:
114: if (unit >= NIK)
115: return (ENXIO);
116: return (physio(ikstrategy, &rikbuf[unit], dev, B_READ, ikminphys, uio));
117: }
118:
119: ikwrite(dev, uio)
120: dev_t dev;
121: struct uio *uio;
122: {
123: register int unit = IKUNIT(dev);
124:
125: if (unit >= NIK)
126: return (ENXIO);
127: return (physio(ikstrategy, &rikbuf[unit], dev, B_WRITE, ikminphys, uio));
128: }
129:
130: u_int
131: ikminphys(bp)
132: register struct buf *bp;
133: {
134:
135: if (bp->b_bcount > 65536) /* may be able to do twice as much */
136: bp->b_bcount = 65536;
137: }
138:
139: ikstrategy(bp)
140: register struct buf *bp;
141: {
142: register struct ik_softc *ikp = &ik_softc[IKUNIT(bp->b_dev)];
143: register struct uba_device *ui;
144:
145: if (IKUNIT(bp->b_dev) >= NIK || (ui = ikdinfo[IKUNIT(bp->b_dev)]) == 0
146: || ui->ui_alive == 0)
147: goto bad;
148: (void) spl5();
149: while (ikp->ik_state & IKBUSY)
150: sleep((caddr_t)ikp, IKDMAPRI+1);
151: ikp->ik_state |= IKBUSY;
152: ikp->ik_bp = bp;
153: ikp->ik_ubinfo = ubasetup(ui->ui_ubanum, bp, UBA_NEEDBDP);
154: ikp->ik_bufp = ikp->ik_ubinfo & 0x3ffff;
155: ikp->ik_count = -(bp->b_bcount>>1); /* its a word count */
156: ikstart(ui);
157: while (ikp->ik_state&IKBUSY)
158: sleep((caddr_t)ikp, IKDMAPRI);
159: ikp->ik_count = 0;
160: ikp->ik_bufp = 0;
161: (void) spl0();
162: ubarelse(ui->ui_ubanum, &ikp->ik_ubinfo);
163: ikp->ik_bp = 0;
164: iodone(bp);
165: wakeup((caddr_t)ikp);
166: return;
167: bad:
168: bp->b_flags |= B_ERROR;
169: iodone(bp);
170: return;
171: }
172:
173: ikstart(ui)
174: register struct uba_device *ui;
175: {
176: register int istat;
177: register struct ikdevice *ikaddr = (struct ikdevice *) ui->ui_addr;
178: register struct ik_softc *ikp = &ik_softc[IKUNIT(ui->ui_unit)];
179:
180: istat = ikaddr->ik_istat|DMAENABLE;
181: ikaddr->ik_istat = istat;
182: ikaddr->ik_wc = ikp->ik_count;
183: ikaddr->ik_ubaddr = ikp->ik_bufp;
184: ikaddr->ik_ustat = IK_GO|IK_IENABLE|((ikp->ik_bufp>>12)&060);
185: }
186:
187: /*ARGSUSED*/
188: ikioctl(dev, cmd, data, flag)
189: dev_t dev;
190: int cmd;
191: register caddr_t data;
192: int flag;
193: {
194: register struct uba_device *ui = ikdinfo[IKUNIT(dev)];
195: register struct ik_softc *ikp;
196:
197: switch (cmd) {
198:
199: case IKIOGETADDR:
200: *(caddr_t *)data = ui->ui_addr;
201: break;
202:
203: case IKIOWAITINT:
204: ikp = &ik_softc[IKUNIT(dev)];
205: ikp->ik_state |= IKBUSY;
206: while (ikp->ik_state&IKBUSY)
207: sleep((caddr_t)ikp, IKWAITPRI);
208: break;
209:
210: default:
211: return (ENOTTY);
212: }
213: return (0);
214: }
215:
216: /*ARGSUSED*/
217: ikintr(dev)
218: dev_t dev;
219: {
220: register struct ikdevice *ikaddr =
221: (struct ikdevice *) ikdinfo[IKUNIT(dev)]->ui_addr;
222: register struct ik_softc *ikp = &ik_softc[IKUNIT(dev)];
223:
224: ikp->ik_icnt++;
225: if (ikp->ik_state&IKBUSY) {
226: ikaddr->ik_ustat = 0;
227: ikp->ik_state &= ~IKBUSY;
228: wakeup((caddr_t)ikp);
229: }
230: }
231:
232: ikreset(uban)
233: int uban;
234: {
235: register int i;
236: register struct uba_device *ui;
237: register struct ik_softc *ikp = ik_softc;
238:
239: for (i = 0; i < NIK; i++, ikp++) {
240: if ((ui = ikdinfo[i]) == 0 || ui->ui_alive == 0 ||
241: ui->ui_ubanum != uban || ikp->ik_open == 0)
242: continue;
243: printf(" ik%d", i);
244: if ((ikp->ik_state&IKBUSY) == 0)
245: continue;
246: ikp->ik_ubinfo =
247: ubasetup(ui->ui_ubanum, ikp->ik_bp, UBA_NEEDBDP);
248: ikp->ik_count = -(ikp->ik_bp->b_bcount/2);
249: ikstart(ui);
250: }
251: }
252: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.