![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ad.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxuba|
Return to ad.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / 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: * @(#)ad.c 7.2 (Berkeley) 5/12/87
7: */
8:
9: #include "ad.h"
10: #if NAD > 0
11: /*
12: * Data translation AD converter interface -- Bill Reeves
13: */
14: #include "../machine/pte.h"
15:
16: #include "param.h"
17: #include "ioctl.h"
18: #include "dir.h"
19: #include "user.h"
20: #include "buf.h"
21: #include "systm.h"
22: #include "map.h"
23:
24: #include "ubareg.h"
25: #include "ubavar.h"
26: #include "adreg.h"
27:
28: #define ADBUSY 01
29: #define ADWAITPRI (PZERO+1)
30:
31: int adprobe(), adattach();
32: struct uba_device *addinfo[NAD];
33: u_short adstd[] = { 0770400, 0000000, 0 };
34: struct uba_driver addriver =
35: { adprobe, 0, adattach, 0, adstd, "ad", addinfo, 0, 0 };
36:
37: struct ad {
38: char ad_open;
39: short int ad_uid;
40: short int ad_state;
41: short int ad_softcsr;
42: short int ad_softdata;
43: short int ad_chan;
44: int ad_icnt;
45: int ad_loop;
46: } ad[NAD];
47:
48: #define ADUNIT(dev) (minor(dev))
49:
50: adprobe(reg)
51: caddr_t reg;
52: {
53: register int br, cvec; /* value-result */
54: register struct addevice *adaddr = (struct addevice *) reg;
55:
56: adaddr->ad_csr = AD_IENABLE | AD_START;
57: DELAY(40000);
58: adaddr->ad_csr = 0;
59: return (sizeof (struct addevice));
60: }
61:
62: /*ARGSUSED*/
63: adattach(ui)
64: struct uba_device *ui;
65: {
66:
67: }
68:
69: adopen(dev)
70: dev_t dev;
71: {
72: register struct ad *adp;
73: register struct uba_device *ui;
74:
75: if (ADUNIT(dev) >= NAD || (adp = &ad[ADUNIT(dev)])->ad_open ||
76: (ui = addinfo[ADUNIT(dev)]) == 0 || ui->ui_alive == 0)
77: return (ENXIO);
78: adp->ad_open = 1;
79: adp->ad_icnt = 0;
80: adp->ad_state = 0;
81: adp->ad_uid = u.u_uid;
82: return (0);
83: }
84:
85: adclose(dev)
86: dev_t dev;
87: {
88:
89: ad[ADUNIT(dev)].ad_open = 0;
90: ad[ADUNIT(dev)].ad_state = 0;
91: }
92:
93: /*ARGSUSED*/
94: adioctl(dev, cmd, addr, flag)
95: dev_t dev;
96: register caddr_t addr;
97: {
98: register struct addevice *adaddr =
99: (struct addevice *) addinfo[ADUNIT(dev)]->ui_addr;
100: register struct uba_device *ui = addinfo[ADUNIT(dev)];
101: register struct ad *adp;
102: register int i;
103: short int chan;
104:
105: switch (cmd) {
106:
107: case ADIOSCHAN:
108: adp = &ad[ADUNIT(dev)];
109: adp->ad_chan = (*(int *)addr)<<8;
110: break;
111:
112: case ADIOGETW:
113: adp = &ad[ADUNIT(dev)];
114: spl6();
115: adaddr->ad_csr = adp->ad_chan;
116: i = 1000;
117: while (i-- > 0 && (adaddr->ad_csr&037400) != adp->ad_chan) {
118: adp->ad_loop++;
119: adaddr->ad_csr = adp->ad_chan;
120: }
121: adp->ad_state |= ADBUSY;
122: adaddr->ad_csr |= AD_IENABLE|AD_START;
123: while (adp->ad_state&ADBUSY)
124: sleep((caddr_t)adp, ADWAITPRI);
125: spl0();
126: *(int *)addr = adp->ad_softdata;
127: break;
128:
129: default:
130: return (ENOTTY); /* Not a legal ioctl cmd. */
131: }
132: return (0);
133: }
134:
135: /*ARGSUSED*/
136: adintr(dev)
137: dev_t dev;
138: {
139: register struct addevice *adaddr =
140: (struct addevice *) addinfo[ADUNIT(dev)]->ui_addr;
141: register struct ad *adp = &ad[ADUNIT(dev)];
142:
143: adp->ad_icnt++;
144: adp->ad_softcsr = adaddr->ad_csr;
145: adp->ad_softdata = adaddr->ad_data;
146: if(adp->ad_state&ADBUSY) {
147: adp->ad_state &= ~ADBUSY;
148: wakeup((caddr_t)adp);
149: }
150: }
151:
152: adreset(uban)
153: int uban;
154: {
155: register int i;
156: register struct uba_device *ui;
157: register struct ad *adp = ad;
158: register struct addevice *adaddr;
159:
160: for(i = 0; i < NAD; i++, adp++) {
161: if((ui = addinfo[i]) == 0 || ui->ui_alive == 0 ||
162: ui->ui_ubanum != uban || adp->ad_open == 0)
163: continue;
164: printf(" ad%d", i);
165: if(adp->ad_state&ADBUSY == 0)
166: continue;
167: adaddr = (struct addevice *) ui->ui_addr;
168: adaddr->ad_csr = 0;
169: adaddr->ad_csr = adp->ad_chan|AD_IENABLE|AD_START;
170: }
171: }
172: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.