![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ramtek.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 ramtek.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: /* dr.c 4.10 82/05/18 */
2:
3: #include "rtk.h"
4: #if NRTK > 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/drreg.h"
28:
29: #define DR_GO 01
30: #define DR_FNCT1 02
31: #define DR_GIE 010
32: #define DR_IE 0100
33: #define DR_ATTN 0200
34: #define DR_CYCLE 0400
35: #define DR_NEX 00400000
36: #define DR_GRY 04000
37: #define DR_GIR 020000
38: #define DR_ERROR 01000000
39:
40: char label[] = "Change the size";
41: int rtkprobe(),rtkattach(),rtkdgo(),rtkintr();
42: int drstrategy(),drstart();
43: struct uba_ctlr *rtkminfo[NRTK];
44: struct uba_device *rtkdinfo[NRTK];
45: struct uba_ctlr drctlr[NRTK]; /* rtkminfo points to this */
46: u_short rtkstd[] = { 0172466, 0}; /* used to be
47: u_short rtkstd[] = { 0172410,0172430,0172450,0172470,0 }; */
48: struct uba_driver rtkdriver =
49: { rtkprobe,0,rtkattach,rtkdgo,rtkstd,"rtk",rtkdinfo,"rtk",rtkminfo };
50:
51: #define ui_open ui_type
52: struct buf drbuf[NRTK];
53: struct buf drutab[NRTK];
54:
55: /*ARGSUSED*/
56: rtkprobe(reg)
57: caddr_t reg;
58: {
59: register int br,cvec;
60:
61: #ifdef LINT
62: br = 0; cvec = br; br = cvec;
63: #endif
64: printf("rtkprobe entered.\n");
65:
66: /* There seems to be no way to make this vile animal
67: interrupt, so we cheat... */
68:
69: br = 0x15;
70: cvec = 0210;
71: }
72:
73: rtkattach(ui)
74: register struct uba_device *ui;
75: {
76: register struct uba_ctlr *um;
77: register int unit;
78:
79: unit = ui->ui_unit;
80:
81: um = &drctlr[unit];
82: rtkminfo[unit] = um;
83: ui->ui_ctlr = unit;
84: ui->ui_mi = um;
85: um->um_driver = ui->ui_driver;
86: um->um_ctlr = unit;
87: um->um_ubanum = ui->ui_ubanum;
88: um->um_alive = 1;
89: um->um_intr = ui->ui_intr;
90: um->um_addr = ui->ui_addr;
91: um->um_hd = ui->ui_hd;
92: }
93:
94: rtkopen(dev)
95: dev_t dev;
96: {
97: register int unit;
98:
99: unit = minor(dev);
100: if((unit >= NRTK) || (rtkdinfo[unit]->ui_open)) {
101: u.u_error = ENXIO;
102: return;
103: }
104: rtkdinfo[unit]->ui_open++;
105: }
106:
107: rtkclose(dev)
108: dev_t dev;
109: {
110: register int unit;
111:
112: rtkdinfo[minor(dev)]->ui_open = 0;
113: }
114:
115: rtkread(dev)
116: dev_t dev;
117: {
118: register int unit = minor(dev);
119:
120: physio(drstrategy,&drbuf[unit],dev,B_READ,minphys);
121: }
122:
123: rtkwrite(dev)
124: dev_t dev;
125: {
126: register int unit = minor(dev);
127:
128: physio(drstrategy,&drbuf[unit],dev,B_WRITE,minphys);
129: }
130:
131: /*
132: * Due to the fact the drstrategy routine is called only by rtkread
133: * and rtkwrite via physio, there will only be one transaction in each
134: * DR11-B's queue at any time. Therefore, one can just tack the given
135: * buffer header pointer on at the end of the queue, and call drstart.
136: */
137: drstrategy(bp)
138: register struct buf *bp;
139: {
140: register struct uba_device *ui;
141: register struct uba_ctlr *um;
142: register struct buf *dp;
143: dev_t unit;
144:
145: spl5();
146: unit = minor(bp->b_dev); /* chose a DR11-B */
147: ui = rtkdinfo[unit];
148: um = ui->ui_mi; /* get ctlr ptr */
149: dp = &drutab[unit];
150: dp->b_actf = bp;
151: dp->b_actl = bp;
152: bp->av_forw = NULL;
153: um->um_tab.b_actf = dp;
154: um->um_tab.b_actl = dp;
155:
156: drstart(um);
157: spl0();
158: }
159:
160: drstart(um)
161: register struct uba_ctlr *um;
162: {
163: register struct buf *bp,*dp;
164: register struct drdevice *draddr;
165: int cmd;
166:
167: dp = um->um_tab.b_actf;
168: bp = dp->b_actf;
169:
170: um->um_tab.b_active++;
171: draddr = (struct drdevice *)um->um_addr;
172: draddr->drwc = -bp->b_bcount / sizeof (short);
173: if(bp->b_flags & B_READ)
174: cmd = DR_IE|DR_FNCT1;
175: else
176: cmd = DR_IE;
177: um->um_cmd = cmd|DR_GO;
178: draddr->drcs = cmd;
179: DELAY(10);
180: (void) ubago(rtkdinfo[minor(bp->b_dev)]);
181: }
182:
183: rtkioctl() {}
184: drreset() {}
185: rtkdgo(um)
186: struct uba_ctlr *um;
187: {
188: register struct drdevice *draddr = (struct drdevice *)um->um_addr;
189:
190: draddr->drba = um->um_ubinfo;
191: draddr->drcs = um->um_cmd|((um->um_ubinfo>>12)&0x30);
192: }
193: rtkintr(dr11)
194: register dr11;
195: {
196: register struct buf *bp,*dp;
197: register struct drdevice *draddr;
198: register struct uba_ctlr *um;
199:
200: um = rtkminfo[dr11];
201:
202: if(um->um_tab.b_active == 0)
203: return;
204:
205: dp = um->um_tab.b_actf;
206: bp = dp->b_actf;
207: draddr = (struct drdevice *)um->um_addr;
208:
209: if((draddr->drcs&0100000) && draddr->drwc && (draddr->drba == 0)) {
210: draddr->drcs = um->um_cmd|(((um->um_ubinfo>>12)+1)&0x30);
211: return;
212: }
213:
214: um->um_tab.b_active = 0;
215: um->um_tab.b_errcnt = 0;
216: um->um_tab.b_actf = dp->b_forw;
217: dp->b_errcnt = 0;
218: dp->b_active = 0;
219: bp->b_resid = (-draddr->drwc * sizeof(short));
220: ubadone(um);
221: iodone(bp);
222: }
223: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.