![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to eikonix.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 eikonix.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: /* dr.c 4.10 82/05/18 */
2:
3: #include "ekx.h"
4: #if NEKX > 0
5: /*
6: * UNIBUS DR11-B driver for various graphical systems,.
7: * TS
8: */
9:
10: #include "../h/param.h"
11: #include "../h/systm.h"
12: #include "../h/cpu.h"
13: #include "../h/nexus.h"
14: #include "../h/dk.h"
15: #include "../h/buf.h"
16: #include "../h/conf.h"
17: #include "../h/dir.h"
18: #include "../h/user.h"
19: #include "../h/map.h"
20: #include "../h/pte.h"
21: #include "../h/mtpr.h"
22: #include "../h/vm.h"
23: #include "../h/ubavar.h"
24: #include "../h/ubareg.h"
25: #include "../h/cmap.h"
26:
27: #include "../h/ekcmd.h"
28:
29: struct ekdevice{
30: u_short ekgc;
31: u_short ekdc;
32: u_short ekgs;
33: u_short ekds;
34: short ekwc;
35: u_short ekba;
36: u_short ekcs;
37: u_short ekdata;
38: };
39: struct ekctl {
40: u_short mode;
41: u_short dma_device;
42: u_short device;
43: u_short state;
44: } ek[NEKX];
45: #define EK_GO 01
46: #define EK_FCTN 016
47: #define EK_12BIT 0
48: #define EK_12BITST 04
49: #define EK_8BIT 02
50: #define EK_8BITST 06
51: #define EK_DARK 0
52: #define EK_GAIN 02
53: #define EK_HTST 010
54: #define EK_GTST 012
55: #define EK_X1617 060
56: #define EK_IE 0100
57: #define EK_READY 0200
58: #define EK_DIR 0400
59: #define EK_ODEV 01000
60: #define EK_OVER 02000
61: #define EK_ATTN 020000
62: #define EK_NEX 040000
63: #define EK_ERROR 0100000
64:
65: int ekxprobe(),ekxattach(),ekxdgo(),ekxintr();
66: int ekstrategy(),ekstart();
67: struct uba_ctlr *ekxminfo[NEKX];
68: struct uba_device *ekxdinfo[NEKX];
69: struct uba_ctlr ekctlr[NEKX]; /* ekxminfo points to this */
70: u_short ekxstd[] = { 0163700, 0};
71: struct uba_driver ekxdriver =
72: { ekxprobe,0,ekxattach,ekxdgo,ekxstd,"ekx",ekxdinfo,"ekx",ekxminfo };
73:
74: #define ui_open ui_type
75: struct buf ekbuf[NEKX];
76: struct buf ekutab[NEKX];
77: int ct1, ct2, ct3, ct4, ct5, ct6, ct7, ct8, ct9, ct10, ct11;
78: short sekgs, sekds, sekcs;
79: unsigned short sekwc;
80:
81: /*ARGSUSED*/
82: ekxprobe(reg)
83: caddr_t reg;
84: {
85: register int br,cvec;
86:
87: #ifdef LINT
88: br = 0; cvec = br; br = cvec;
89: #endif
90:
91: /* There seems to be no way to make this vile animal
92: interrupt, so we cheat... */
93:
94: br = 0x15;
95: cvec = 0270;
96: }
97:
98: ekxattach(ui)
99: register struct uba_device *ui;
100: {
101: register struct uba_ctlr *um;
102: register int unit;
103:
104: unit = ui->ui_unit;
105:
106: um = &ekctlr[unit];
107: ekxminfo[unit] = um;
108: ui->ui_ctlr = unit;
109: ui->ui_mi = um;
110: um->um_driver = ui->ui_driver;
111: um->um_ctlr = unit;
112: um->um_ubanum = ui->ui_ubanum;
113: um->um_alive = 1;
114: um->um_intr = ui->ui_intr;
115: um->um_addr = ui->ui_addr;
116: um->um_hd = ui->ui_hd;
117: }
118:
119: ekxopen(dev)
120: dev_t dev;
121: {
122: register int unit;
123:
124: ct1 = ct2 = ct3 = ct4 = ct5 = 0;
125: ct6 = ct7 = ct8 = ct9 = 0;
126: ct10 = ct11 = 0;
127: unit = minor(dev);
128: if((unit >= NEKX) || (ekxdinfo[unit]->ui_open)) {
129: u.u_error = ENXIO;
130: return;
131: }
132: ekxdinfo[unit]->ui_open++;
133: }
134:
135: ekxclose(dev)
136: dev_t dev;
137: {
138: register int unit;
139:
140: ekxdinfo[minor(dev)]->ui_open = 0;
141: }
142:
143: ekxread(dev)
144: dev_t dev;
145: {
146: register int unit = minor(dev);
147:
148: ct1++;
149: physio(ekstrategy,&ekbuf[unit],dev,B_READ,minphys);
150: ct2++;
151: }
152:
153: ekxwrite(dev)
154: dev_t dev;
155: {
156: register int unit = minor(dev);
157:
158: physio(ekstrategy,&ekbuf[unit],dev,B_WRITE,minphys);
159: }
160:
161: /*
162: * Due to the fact the ekstrategy routine is called only by ekxread
163: * and ekxwrite via physio, there will only be one transaction in each
164: * DR11-B's queue at any time. Therefore, one can just tack the given
165: * buffer header pointer on at the end of the queue, and call ekstart.
166: */
167: ekstrategy(bp)
168: register struct buf *bp;
169: {
170: register struct uba_device *ui;
171: register struct uba_ctlr *um;
172: register struct buf *dp;
173: register int s;
174: struct ekdevice *draddr;
175: dev_t unit;
176:
177: ct3++;
178: unit = minor(bp->b_dev); /* chose a DR11-B */
179: ui = ekxdinfo[unit];
180: um = ui->ui_mi; /* get ctlr ptr */
181: dp = &ekutab[unit];
182: s = spl5();
183: dp->b_actf = bp;
184: dp->b_actl = bp;
185: bp->av_forw = NULL;
186: um->um_tab.b_actf = dp;
187: um->um_tab.b_actl = dp;
188:
189: ekstart(um);
190: splx(s);
191: switch(tsleep((caddr_t)bp, PRIBIO+1, 20)) {
192: case TS_OK:
193: break;
194: case TS_SIG: /* not supposed to happen*/
195: case TS_TIME:
196: draddr = (struct ekdevice *)um->um_addr;
197: sekgs = draddr->ekgs;
198: sekds = draddr->ekds;
199: sekwc = draddr->ekwc;
200: sekcs = draddr->ekcs;
201: printf("gs %o ds %o wc %o cs %o\n",sekgs, sekds, sekwc, sekcs);
202: printf("ct1 %o ct2 %o ct3 %o ct4 %o ct5 %o ct6 %o\n",ct1,ct2,ct3,ct4,ct5,ct6);
203: printf("ct7 %o ct8 %o ct9 %o ct10 %o ct11 %o\n",ct7,ct8,ct9,ct10,ct11);
204: bp->b_flags |= B_DONE | B_ERROR;
205: s = spl6();
206: ekxintr(unit);
207: splx(s);
208: }
209: }
210:
211: ekstart(um)
212: register struct uba_ctlr *um;
213: {
214: register struct buf *bp,*dp;
215: register struct ekdevice *draddr;
216: register struct ekctl *ekp;
217: int cmd;
218:
219: dp = um->um_tab.b_actf;
220: bp = dp->b_actf;
221: ekp = &ek[minor(bp->b_dev)];
222:
223: um->um_tab.b_active++;
224: draddr = (struct ekdevice *)um->um_addr;
225: draddr->ekwc = -bp->b_bcount / sizeof (short);
226: if(bp->b_flags & B_READ)
227: cmd = EK_IE|EK_DIR|ekp->mode;
228: else
229: cmd = EK_IE|ekp->dma_device;
230: um->um_cmd = cmd|EK_GO;
231: ct4++;
232: draddr->ekcs = cmd;
233: ct5++;
234: DELAY(10);
235: if( ubago(ekxdinfo[minor(bp->b_dev)])== 0)
236: printf("ubago returned 0\n");
237: }
238:
239: ekxioctl(dev, cmd, arg)
240: dev_t dev;
241: int cmd;
242: register caddr_t arg;
243: {
244: register struct ekctl *ekp = &ek[minor(dev)];
245: register struct uba_device *ui = ekxdinfo[minor(dev)];
246: register struct ekdevice *draddr = (struct ekdevice *)ui->ui_addr;
247: u_short realcmd;
248:
249: if( (cmd != EKGS) && (cmd != EKDMA)){
250: if(copyin(arg, (caddr_t)&realcmd, sizeof(realcmd))){
251: u.u_error = EFAULT;
252: return;
253: }
254: }
255: switch(cmd){
256: case EKGC:
257: draddr->ekgc = realcmd;
258: return;
259: case EKDC:
260: draddr->ekdc = realcmd;
261: return;
262: case EKGS:
263: realcmd = draddr->ekgs;
264: break;
265: case EKDS:
266: draddr->ekdc = EKDC_READ|realcmd;
267: realcmd = draddr->ekds;
268: break;
269: case EKMOD:
270: ek->mode = realcmd & EK_FCTN;
271: return;
272: case EKDEV:
273: ek->dma_device = realcmd & EK_FCTN;
274: return;
275: default:
276: u.u_error = ENXIO;
277: return;
278: }
279: if(copyout((caddr_t)&realcmd, arg, sizeof(realcmd)))
280: u.u_error = EFAULT;
281: }
282: ekreset() {}
283: ekxdgo(um)
284: struct uba_ctlr *um;
285: {
286: register struct ekdevice *draddr = (struct ekdevice *)um->um_addr;
287:
288: ct6++;
289: draddr->ekba = um->um_ubinfo;
290: draddr->ekcs = um->um_cmd|((um->um_ubinfo>>12)&EK_X1617);
291: ct7++;
292: }
293: ekxintr(dr11)
294: register dr11;
295: {
296: register struct buf *bp,*dp;
297: register struct ekdevice *draddr;
298: register struct uba_ctlr *um;
299: register int stat;
300:
301: ct8++;
302: um = ekxminfo[dr11];
303:
304: if(um->um_tab.b_active == 0)
305: return;
306:
307: if(ekxdinfo[dr11]->ui_open == 0)
308: return;
309: dp = um->um_tab.b_actf;
310: bp = dp->b_actf;
311: draddr = (struct ekdevice *)um->um_addr;
312: stat = draddr->ekcs;
313:
314: if(stat & EK_ODEV){
315: ct11++;
316: }
317:
318: /*should check stat&EK_OVER for retry*/
319: if((stat&EK_ERROR) && draddr->ekwc && (draddr->ekba == 0)) {
320: draddr->ekcs = um->um_cmd|(((um->um_ubinfo>>12)+1)&EK_X1617);
321: ct10++;
322: }
323:
324: um->um_tab.b_active = 0;
325: um->um_tab.b_errcnt = 0;
326: um->um_tab.b_actf = dp->b_forw;
327: dp->b_errcnt = 0;
328: dp->b_active = 0;
329: bp->b_resid = (-draddr->ekwc * sizeof(short));
330: ubadone(um);
331: iodone(bp);
332: ct9++;
333: }
334: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.