![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bpd.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 bpd.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: #include "bpd.h"
2: #if NBPD > 0
3:
4: /*
5: * BIT-PAD DEVICE DRIVER
6: */
7:
8: #include "../h/param.h"
9: #include "../h/dir.h"
10: #include "../h/user.h"
11: #include "../h/proc.h"
12: #include "../h/ioctl.h"
13: #include "../h/buf.h"
14: #include "../h/systm.h"
15: #include "../h/map.h"
16: #include "../h/pte.h"
17: #include "../h/ubavar.h"
18: #include "../h/ubareg.h"
19:
20:
21: #define RIE 0100
22: #define DTR 02
23: #define RTS 04
24: #define SYNC 0100
25: #define DMASK 077
26: #define ERROR 060000
27: #define CMOD 01
28: #define STRM 02
29: #define CURON 03
30: #define POINT 04
31: #define NOPLOT 05
32: #define REPLOT 06
33: #define SLPRI PZERO+1
34:
35: struct bpddevice{
36: short rcs;
37: short rdb;
38: short tcs;
39: short tdb;
40: };
41:
42: struct bpdparam{
43: int bpd_x; /*bitpad x address*/
44: int bpd_y; /*bitpad y address*/
45: int bpd_cflags; /*bitpad buttons*/
46: int bpd_tx; /*temp x address*/
47: int bpd_ty; /*temp y address*/
48: int bpd_tflags; /*temp buttons*/
49: int bpd_curx; /*current x screen cursor*/
50: int bpd_cury; /*current y screen cursor*/
51: int bpd_bn; /*byte no. - for sequencing*/
52: int bpd_open; /*device open flag*/
53: int bpd_stream; /*stream flag*/
54: int bpd_cursor; /*cursor enable flag*/
55: int bpd_noplot; /*noplot mode hack*/
56: int bpd_on; /*set if bit-pad running*/
57: int bpd_ubad; /*physical unibus address for dma's*/
58: } bpdsoft[NBPD];
59:
60: char curs_data[512]; /*buffer for cursor dma transfers*/
61:
62: int bpdprobe(),bpdattach();
63:
64: struct uba_device *bpdinfo[NBPD];
65: u_short bpdstd[]= {0176510,0176520,0};
66:
67: struct uba_driver bpddriver =
68: {bpdprobe,0,bpdattach,0,bpdstd,"bpd",bpdinfo};
69:
70: bpdprobe(reg) /*called by autoconfig(4) - fake an interrupt*/
71: caddr_t reg;{
72: register int br,cvec;
73: br=0x15;
74: switch((int)(reg)&070){
75: case 010: cvec=0410; break;
76: case 020: cvec=0420; break;
77: }
78: return(1);
79: }
80:
81: bpdattach(ui) /*driver initialization*/
82: struct uba_dev *ui;{
83:
84: }
85:
86: bpdopen(dev)
87: dev_t dev;{
88: register struct bpddevice *bpp;
89: register struct uba_device *ui;
90: register struct bpdparam *bpds;
91: if(minor(dev)>=NBPD){
92: u.u_error=ENXIO; /*device does not exist*/
93: return;
94: }
95: bpds= &bpdsoft[minor(dev)];
96: ui=bpdinfo[minor(dev)];
97: if((bpds->bpd_open)||(ui==0)||(ui->ui_alive==0)){
98: u.u_error=ENXIO; /*device already open or not really present*/
99: return;
100: }
101: bpp=(struct bpddevice *)(ui->ui_addr);
102: bpds->bpd_open++; /*flag device as open*/
103: bpds->bpd_on++; /*flag device as on*/
104: bpds->bpd_stream=bpds->bpd_cursor=bpds->bpd_x=bpds->bpd_y=bpds->bpd_cflags=0;
105: bpp->tcs=0; /*output interrupt off*/
106: bpp->rcs= RTS|DTR; /*set up modem controls*/
107: bpp->tdb= 'L'; /*set to 35 samples/sec. stream*/
108: bpp->rcs= RIE|DTR|RTS; /*enable receive interrupts*/
109: }
110:
111: bpdclose(dev)
112: dev_t dev;{
113: register struct bpddevice *bpp;
114: register struct uba_device *ui;
115: register struct bpdparam *bpds;
116: ui=bpdinfo[minor(dev)];
117: bpp=(struct bpddevice *)(ui->ui_addr);
118: bpds= &bpdsoft[minor(dev)];
119: bpp->rcs= 0; /*turn interrupts off*/
120: bpds->bpd_stream=bpds->bpd_open=0;
121: }
122:
123: bpdintr(dev) dev_t dev;
124: {
125: register struct uba_device *ui = bpdinfo[minor(dev)];
126: register struct bpddevice *bpp = (struct bpddevice *)(ui->ui_addr);
127: register struct bpdparam *bpds = &bpdsoft[minor(dev)];
128: int dx, dy;
129:
130: if(bpp->rdb & ERROR)
131: { bpds->bpd_bn= -1;
132: return;
133: }
134: if(bpp->rdb & SYNC) bpds->bpd_bn=1;
135: if(bpds->bpd_bn < 0) return;
136: switch(bpds->bpd_bn)
137: { case 1: bpds->bpd_tflags = (int)(bpp->rdb&DMASK);
138: break;
139: case 2: bpds->bpd_tx = (int)(bpp->rdb&DMASK);
140: break;
141: case 3: bpds->bpd_tx += (int)((bpp->rdb&DMASK)<<6);
142: break;
143: case 4: bpds->bpd_ty = (int)(bpp->rdb&DMASK);
144: break;
145: case 5: bpds->bpd_ty += (int)((bpp->rdb&DMASK)<<6);
146: if(bpds->bpd_tflags != bpds->bpd_cflags) wakeup(bpds);
147: if((bpds->bpd_cursor)&&(bpds->bpd_on))
148: { if(bpds->bpd_tx<bpds->bpd_x)
149: bpds->bpd_curx=(bpds->bpd_tx+1)/2;
150: else if(bpds->bpd_tx>bpds->bpd_x)
151: bpds->bpd_curx=(bpds->bpd_tx)/2;
152: if(bpds->bpd_ty<bpds->bpd_y)
153: bpds->bpd_cury=(bpds->bpd_ty+1)/2;
154: else if(bpds->bpd_ty>bpds->bpd_y)
155: bpds->bpd_cury=(bpds->bpd_ty)/2;
156:
157: if (!bpds->bpd_noplot)
158: {
159: dx = bpds->bpd_x - bpds->bpd_tx;
160: if(dx < 0) dx = -dx;
161: dy = bpds->bpd_y - bpds->bpd_ty;
162: if(dy < 0) dy = -dy;
163: if(dx > 1 || dy > 1)
164: omcur(dev,bpds->bpd_curx,bpds->bpd_cury);
165: }
166: }
167: bpds->bpd_x=bpds->bpd_tx;
168: bpds->bpd_y=bpds->bpd_ty;
169: bpds->bpd_cflags=bpds->bpd_tflags;
170: bpds->bpd_bn=0;
171: break;
172: }
173: bpds->bpd_bn++;
174: }
175:
176: bpdioctl(dev,cmd,addr,flag)
177: dev_t dev;
178: caddr_t addr;{
179: register struct bpddevice *bpp;
180: register struct uba_device *ui;
181: register struct bpdparam *bpds;
182: char c;
183: ui=bpdinfo[minor(dev)];
184: bpp=(struct bpddevice *)(ui->ui_addr);
185: bpds= &bpdsoft[minor(dev)];
186: switch(cmd){
187: case CMOD: /*send char. to change mode*/
188: c=fubyte(addr)&0177;
189: bpds->bpd_on=(c=='S')?0:1;
190: bpp->tdb=(short)c;
191: break;
192: case STRM: /*put driver into stream mode*/
193: bpds->bpd_stream=1;
194: break;
195: case CURON: /*turn cursor on*/
196: bpds->bpd_cursor=1;
197: break;
198: case POINT: /*turn off stream mode*/
199: bpds->bpd_stream=0;
200: break;
201: case NOPLOT: /*track without plotting on device*/
202: bpds->bpd_noplot=1;
203: break;
204: case REPLOT:
205: bpds->bpd_noplot=0;
206: break;
207: }
208: }
209:
210: bpdread(dev)
211: dev_t dev;{
212: register struct bpdparam *bpds;
213: register *dp= (int *)(u.u_base);
214: bpds= &bpdsoft[minor(dev)];
215: if(bpds->bpd_stream==0){
216: while(bpds->bpd_cflags) sleep(bpds,SLPRI); /*wait for buttons up*/
217: while(!(bpds->bpd_cflags)) sleep(bpds,SLPRI); /*wait for button down*/
218: }
219: suword(dp++,bpds->bpd_x);
220: suword(dp++,bpds->bpd_y);
221: suword(dp,bpds->bpd_cflags);
222: u.u_base=(caddr_t)dp;
223: u.u_count=0;
224: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.