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