1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42#include <linux/interrupt.h>
43#include "../comedidev.h"
44
45#include <linux/ioport.h>
46#include <linux/delay.h>
47
48#define DT2814_SIZE 2
49
50#define DT2814_CSR 0
51#define DT2814_DATA 1
52
53
54
55
56
57#define DT2814_FINISH 0x80
58#define DT2814_ERR 0x40
59#define DT2814_BUSY 0x20
60#define DT2814_ENB 0x10
61#define DT2814_CHANMASK 0x0f
62
63static int dt2814_attach(struct comedi_device *dev,
64 struct comedi_devconfig *it);
65static int dt2814_detach(struct comedi_device *dev);
66static struct comedi_driver driver_dt2814 = {
67 .driver_name = "dt2814",
68 .module = THIS_MODULE,
69 .attach = dt2814_attach,
70 .detach = dt2814_detach,
71};
72
73static int __init driver_dt2814_init_module(void)
74{
75 return comedi_driver_register(&driver_dt2814);
76}
77
78static void __exit driver_dt2814_cleanup_module(void)
79{
80 comedi_driver_unregister(&driver_dt2814);
81}
82
83module_init(driver_dt2814_init_module);
84module_exit(driver_dt2814_cleanup_module);
85
86static irqreturn_t dt2814_interrupt(int irq, void *dev);
87
88struct dt2814_private {
89
90 int ntrig;
91 int curadchan;
92};
93
94#define devpriv ((struct dt2814_private *)dev->private)
95
96#define DT2814_TIMEOUT 10
97#define DT2814_MAX_SPEED 100000
98
99static int dt2814_ai_insn_read(struct comedi_device *dev,
100 struct comedi_subdevice *s,
101 struct comedi_insn *insn, unsigned int *data)
102{
103 int n, i, hi, lo;
104 int chan;
105 int status = 0;
106
107 for (n = 0; n < insn->n; n++) {
108 chan = CR_CHAN(insn->chanspec);
109
110 outb(chan, dev->iobase + DT2814_CSR);
111 for (i = 0; i < DT2814_TIMEOUT; i++) {
112 status = inb(dev->iobase + DT2814_CSR);
113 printk(KERN_INFO "dt2814: status: %02x\n", status);
114 udelay(10);
115 if (status & DT2814_FINISH)
116 break;
117 }
118 if (i >= DT2814_TIMEOUT) {
119 printk(KERN_INFO "dt2814: status: %02x\n", status);
120 return -ETIMEDOUT;
121 }
122
123 hi = inb(dev->iobase + DT2814_DATA);
124 lo = inb(dev->iobase + DT2814_DATA);
125
126 data[n] = (hi << 4) | (lo >> 4);
127 }
128
129 return n;
130}
131
132static int dt2814_ns_to_timer(unsigned int *ns, unsigned int flags)
133{
134 int i;
135 unsigned int f;
136
137
138
139 f = 10000;
140 for (i = 0; i < 8; i++) {
141 if ((2 * (*ns)) < (f * 11))
142 break;
143 f *= 10;
144 }
145
146 *ns = f;
147
148 return i;
149}
150
151static int dt2814_ai_cmdtest(struct comedi_device *dev,
152 struct comedi_subdevice *s, struct comedi_cmd *cmd)
153{
154 int err = 0;
155 int tmp;
156
157
158
159 tmp = cmd->start_src;
160 cmd->start_src &= TRIG_NOW;
161 if (!cmd->start_src || tmp != cmd->start_src)
162 err++;
163
164 tmp = cmd->scan_begin_src;
165 cmd->scan_begin_src &= TRIG_TIMER;
166 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
167 err++;
168
169 tmp = cmd->convert_src;
170 cmd->convert_src &= TRIG_NOW;
171 if (!cmd->convert_src || tmp != cmd->convert_src)
172 err++;
173
174 tmp = cmd->scan_end_src;
175 cmd->scan_end_src &= TRIG_COUNT;
176 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
177 err++;
178
179 tmp = cmd->stop_src;
180 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
181 if (!cmd->stop_src || tmp != cmd->stop_src)
182 err++;
183
184 if (err)
185 return 1;
186
187
188
189
190
191 if (cmd->stop_src != TRIG_TIMER && cmd->stop_src != TRIG_EXT)
192 err++;
193
194 if (err)
195 return 2;
196
197
198
199 if (cmd->start_arg != 0) {
200 cmd->start_arg = 0;
201 err++;
202 }
203 if (cmd->scan_begin_arg > 1000000000) {
204 cmd->scan_begin_arg = 1000000000;
205 err++;
206 }
207 if (cmd->scan_begin_arg < DT2814_MAX_SPEED) {
208 cmd->scan_begin_arg = DT2814_MAX_SPEED;
209 err++;
210 }
211 if (cmd->scan_end_arg != cmd->chanlist_len) {
212 cmd->scan_end_arg = cmd->chanlist_len;
213 err++;
214 }
215 if (cmd->stop_src == TRIG_COUNT) {
216 if (cmd->stop_arg < 2) {
217 cmd->stop_arg = 2;
218 err++;
219 }
220 } else {
221
222 if (cmd->stop_arg != 0) {
223 cmd->stop_arg = 0;
224 err++;
225 }
226 }
227
228 if (err)
229 return 3;
230
231
232
233 tmp = cmd->scan_begin_arg;
234 dt2814_ns_to_timer(&cmd->scan_begin_arg, cmd->flags & TRIG_ROUND_MASK);
235 if (tmp != cmd->scan_begin_arg)
236 err++;
237
238 if (err)
239 return 4;
240
241 return 0;
242}
243
244static int dt2814_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
245{
246 struct comedi_cmd *cmd = &s->async->cmd;
247 int chan;
248 int trigvar;
249
250 trigvar =
251 dt2814_ns_to_timer(&cmd->scan_begin_arg,
252 cmd->flags & TRIG_ROUND_MASK);
253
254 chan = CR_CHAN(cmd->chanlist[0]);
255
256 devpriv->ntrig = cmd->stop_arg;
257 outb(chan | DT2814_ENB | (trigvar << 5), dev->iobase + DT2814_CSR);
258
259 return 0;
260
261}
262
263static int dt2814_attach(struct comedi_device *dev, struct comedi_devconfig *it)
264{
265 int i, irq;
266 int ret;
267 struct comedi_subdevice *s;
268 unsigned long iobase;
269
270 iobase = it->options[0];
271 printk(KERN_INFO "comedi%d: dt2814: 0x%04lx ", dev->minor, iobase);
272 if (!request_region(iobase, DT2814_SIZE, "dt2814")) {
273 printk(KERN_ERR "I/O port conflict\n");
274 return -EIO;
275 }
276 dev->iobase = iobase;
277 dev->board_name = "dt2814";
278
279 outb(0, dev->iobase + DT2814_CSR);
280 udelay(100);
281 if (inb(dev->iobase + DT2814_CSR) & DT2814_ERR) {
282 printk(KERN_ERR "reset error (fatal)\n");
283 return -EIO;
284 }
285 i = inb(dev->iobase + DT2814_DATA);
286 i = inb(dev->iobase + DT2814_DATA);
287
288 irq = it->options[1];
289#if 0
290 if (irq < 0) {
291 save_flags(flags);
292 sti();
293 irqs = probe_irq_on();
294
295 outb(0, dev->iobase + DT2814_CSR);
296
297 udelay(100);
298
299 irq = probe_irq_off(irqs);
300 restore_flags(flags);
301 if (inb(dev->iobase + DT2814_CSR) & DT2814_ERR)
302 printk(KERN_DEBUG "error probing irq (bad)\n");
303
304
305 i = inb(dev->iobase + DT2814_DATA);
306 i = inb(dev->iobase + DT2814_DATA);
307 }
308#endif
309 dev->irq = 0;
310 if (irq > 0) {
311 if (request_irq(irq, dt2814_interrupt, 0, "dt2814", dev)) {
312 printk(KERN_WARNING "(irq %d unavailable)\n", irq);
313 } else {
314 printk(KERN_INFO "( irq = %d )\n", irq);
315 dev->irq = irq;
316 }
317 } else if (irq == 0) {
318 printk(KERN_WARNING "(no irq)\n");
319 } else {
320#if 0
321 printk(KERN_DEBUG "(probe returned multiple irqs--bad)\n");
322#else
323 printk(KERN_WARNING "(irq probe not implemented)\n");
324#endif
325 }
326
327 ret = alloc_subdevices(dev, 1);
328 if (ret < 0)
329 return ret;
330
331 ret = alloc_private(dev, sizeof(struct dt2814_private));
332 if (ret < 0)
333 return ret;
334
335 s = dev->subdevices + 0;
336 dev->read_subdev = s;
337 s->type = COMEDI_SUBD_AI;
338 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
339 s->n_chan = 16;
340 s->len_chanlist = 1;
341 s->insn_read = dt2814_ai_insn_read;
342 s->do_cmd = dt2814_ai_cmd;
343 s->do_cmdtest = dt2814_ai_cmdtest;
344 s->maxdata = 0xfff;
345 s->range_table = &range_unknown;
346
347 return 0;
348}
349
350static int dt2814_detach(struct comedi_device *dev)
351{
352 printk(KERN_INFO "comedi%d: dt2814: remove\n", dev->minor);
353
354 if (dev->irq)
355 free_irq(dev->irq, dev);
356
357 if (dev->iobase)
358 release_region(dev->iobase, DT2814_SIZE);
359
360 return 0;
361}
362
363static irqreturn_t dt2814_interrupt(int irq, void *d)
364{
365 int lo, hi;
366 struct comedi_device *dev = d;
367 struct comedi_subdevice *s;
368 int data;
369
370 if (!dev->attached) {
371 comedi_error(dev, "spurious interrupt");
372 return IRQ_HANDLED;
373 }
374
375 s = dev->subdevices + 0;
376
377 hi = inb(dev->iobase + DT2814_DATA);
378 lo = inb(dev->iobase + DT2814_DATA);
379
380 data = (hi << 4) | (lo >> 4);
381
382 if (!(--devpriv->ntrig)) {
383 int i;
384
385 outb(0, dev->iobase + DT2814_CSR);
386
387
388
389 for (i = 0; i < DT2814_TIMEOUT; i++) {
390 if (inb(dev->iobase + DT2814_CSR) & DT2814_FINISH)
391 break;
392 }
393 inb(dev->iobase + DT2814_DATA);
394 inb(dev->iobase + DT2814_DATA);
395
396 s->async->events |= COMEDI_CB_EOA;
397 }
398 comedi_event(dev, s);
399 return IRQ_HANDLED;
400}
401
402MODULE_AUTHOR("Comedi http://www.comedi.org");
403MODULE_DESCRIPTION("Comedi low-level driver");
404MODULE_LICENSE("GPL");
405
