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#include <linux/module.h>
39#include <linux/delay.h>
40#include <linux/interrupt.h>
41
42#include "../comedidev.h"
43
44#include "comedi_fc.h"
45#include "8253.h"
46
47
48
49
50#define PCL711_TIMER_BASE 0x00
51#define PCL711_AI_LSB_REG 0x04
52#define PCL711_AI_MSB_REG 0x05
53#define PCL711_AI_MSB_DRDY (1 << 4)
54#define PCL711_AO_LSB_REG(x) (0x04 + ((x) * 2))
55#define PCL711_AO_MSB_REG(x) (0x05 + ((x) * 2))
56#define PCL711_DI_LSB_REG 0x06
57#define PCL711_DI_MSB_REG 0x07
58#define PCL711_INT_STAT_REG 0x08
59#define PCL711_INT_STAT_CLR (0 << 0)
60#define PCL711_AI_GAIN_REG 0x09
61#define PCL711_AI_GAIN(x) (((x) & 0xf) << 0)
62#define PCL711_MUX_REG 0x0a
63#define PCL711_MUX_CHAN(x) (((x) & 0xf) << 0)
64#define PCL711_MUX_CS0 (1 << 4)
65#define PCL711_MUX_CS1 (1 << 5)
66#define PCL711_MUX_DIFF (PCL711_MUX_CS0 | PCL711_MUX_CS1)
67#define PCL711_MODE_REG 0x0b
68#define PCL711_MODE_DEFAULT (0 << 0)
69#define PCL711_MODE_SOFTTRIG (1 << 0)
70#define PCL711_MODE_EXT (2 << 0)
71#define PCL711_MODE_EXT_IRQ (3 << 0)
72#define PCL711_MODE_PACER (4 << 0)
73#define PCL711_MODE_PACER_IRQ (6 << 0)
74#define PCL711_MODE_IRQ(x) (((x) & 0x7) << 4)
75#define PCL711_SOFTTRIG_REG 0x0c
76#define PCL711_SOFTTRIG (0 << 0)
77#define PCL711_DO_LSB_REG 0x0d
78#define PCL711_DO_MSB_REG 0x0e
79
80static const struct comedi_lrange range_pcl711b_ai = {
81 5, {
82 BIP_RANGE(5),
83 BIP_RANGE(2.5),
84 BIP_RANGE(1.25),
85 BIP_RANGE(0.625),
86 BIP_RANGE(0.3125)
87 }
88};
89
90static const struct comedi_lrange range_acl8112hg_ai = {
91 12, {
92 BIP_RANGE(5),
93 BIP_RANGE(0.5),
94 BIP_RANGE(0.05),
95 BIP_RANGE(0.005),
96 UNI_RANGE(10),
97 UNI_RANGE(1),
98 UNI_RANGE(0.1),
99 UNI_RANGE(0.01),
100 BIP_RANGE(10),
101 BIP_RANGE(1),
102 BIP_RANGE(0.1),
103 BIP_RANGE(0.01)
104 }
105};
106
107static const struct comedi_lrange range_acl8112dg_ai = {
108 9, {
109 BIP_RANGE(5),
110 BIP_RANGE(2.5),
111 BIP_RANGE(1.25),
112 BIP_RANGE(0.625),
113 UNI_RANGE(10),
114 UNI_RANGE(5),
115 UNI_RANGE(2.5),
116 UNI_RANGE(1.25),
117 BIP_RANGE(10)
118 }
119};
120
121struct pcl711_board {
122 const char *name;
123 int n_aichan;
124 int n_aochan;
125 int maxirq;
126 const struct comedi_lrange *ai_range_type;
127};
128
129static const struct pcl711_board boardtypes[] = {
130 {
131 .name = "pcl711",
132 .n_aichan = 8,
133 .n_aochan = 1,
134 .ai_range_type = &range_bipolar5,
135 }, {
136 .name = "pcl711b",
137 .n_aichan = 8,
138 .n_aochan = 1,
139 .maxirq = 7,
140 .ai_range_type = &range_pcl711b_ai,
141 }, {
142 .name = "acl8112hg",
143 .n_aichan = 16,
144 .n_aochan = 2,
145 .maxirq = 15,
146 .ai_range_type = &range_acl8112hg_ai,
147 }, {
148 .name = "acl8112dg",
149 .n_aichan = 16,
150 .n_aochan = 2,
151 .maxirq = 15,
152 .ai_range_type = &range_acl8112dg_ai,
153 },
154};
155
156struct pcl711_private {
157 unsigned int divisor1;
158 unsigned int divisor2;
159};
160
161static void pcl711_ai_set_mode(struct comedi_device *dev, unsigned int mode)
162{
163
164
165
166
167
168
169
170
171 if (mode == PCL711_MODE_EXT_IRQ || mode == PCL711_MODE_PACER_IRQ)
172 mode |= PCL711_MODE_IRQ(dev->irq);
173
174 outb(mode, dev->iobase + PCL711_MODE_REG);
175}
176
177static unsigned int pcl711_ai_get_sample(struct comedi_device *dev,
178 struct comedi_subdevice *s)
179{
180 unsigned int val;
181
182 val = inb(dev->iobase + PCL711_AI_MSB_REG) << 8;
183 val |= inb(dev->iobase + PCL711_AI_LSB_REG);
184
185 return val & s->maxdata;
186}
187
188static int pcl711_ai_cancel(struct comedi_device *dev,
189 struct comedi_subdevice *s)
190{
191 outb(PCL711_INT_STAT_CLR, dev->iobase + PCL711_INT_STAT_REG);
192 pcl711_ai_set_mode(dev, PCL711_MODE_SOFTTRIG);
193 return 0;
194}
195
196static irqreturn_t pcl711_interrupt(int irq, void *d)
197{
198 struct comedi_device *dev = d;
199 struct comedi_subdevice *s = dev->read_subdev;
200 struct comedi_cmd *cmd = &s->async->cmd;
201 unsigned int data;
202
203 if (!dev->attached) {
204 dev_err(dev->class_dev, "spurious interrupt\n");
205 return IRQ_HANDLED;
206 }
207
208 data = pcl711_ai_get_sample(dev, s);
209
210 outb(PCL711_INT_STAT_CLR, dev->iobase + PCL711_INT_STAT_REG);
211
212 comedi_buf_write_samples(s, &data, 1);
213
214 if (cmd->stop_src == TRIG_COUNT &&
215 s->async->scans_done >= cmd->stop_arg)
216 s->async->events |= COMEDI_CB_EOA;
217
218 comedi_handle_events(dev, s);
219
220 return IRQ_HANDLED;
221}
222
223static void pcl711_set_changain(struct comedi_device *dev,
224 struct comedi_subdevice *s,
225 unsigned int chanspec)
226{
227 unsigned int chan = CR_CHAN(chanspec);
228 unsigned int range = CR_RANGE(chanspec);
229 unsigned int aref = CR_AREF(chanspec);
230 unsigned int mux = 0;
231
232 outb(PCL711_AI_GAIN(range), dev->iobase + PCL711_AI_GAIN_REG);
233
234 if (s->n_chan > 8) {
235
236 if (aref == AREF_DIFF) {
237 chan &= 0x7;
238 mux |= PCL711_MUX_DIFF;
239 } else {
240 if (chan < 8)
241 mux |= PCL711_MUX_CS0;
242 else
243 mux |= PCL711_MUX_CS1;
244 }
245 }
246 outb(mux | PCL711_MUX_CHAN(chan), dev->iobase + PCL711_MUX_REG);
247}
248
249static int pcl711_ai_eoc(struct comedi_device *dev,
250 struct comedi_subdevice *s,
251 struct comedi_insn *insn,
252 unsigned long context)
253{
254 unsigned int status;
255
256 status = inb(dev->iobase + PCL711_AI_MSB_REG);
257 if ((status & PCL711_AI_MSB_DRDY) == 0)
258 return 0;
259 return -EBUSY;
260}
261
262static int pcl711_ai_insn_read(struct comedi_device *dev,
263 struct comedi_subdevice *s,
264 struct comedi_insn *insn,
265 unsigned int *data)
266{
267 int ret;
268 int i;
269
270 pcl711_set_changain(dev, s, insn->chanspec);
271
272 pcl711_ai_set_mode(dev, PCL711_MODE_SOFTTRIG);
273
274 for (i = 0; i < insn->n; i++) {
275 outb(PCL711_SOFTTRIG, dev->iobase + PCL711_SOFTTRIG_REG);
276
277 ret = comedi_timeout(dev, s, insn, pcl711_ai_eoc, 0);
278 if (ret)
279 return ret;
280
281 data[i] = pcl711_ai_get_sample(dev, s);
282 }
283
284 return insn->n;
285}
286
287static int pcl711_ai_cmdtest(struct comedi_device *dev,
288 struct comedi_subdevice *s, struct comedi_cmd *cmd)
289{
290 struct pcl711_private *devpriv = dev->private;
291 int err = 0;
292 unsigned int arg;
293
294
295
296 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
297 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
298 TRIG_TIMER | TRIG_EXT);
299 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
300 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
301 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
302
303 if (err)
304 return 1;
305
306
307
308 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
309 err |= cfc_check_trigger_is_unique(cmd->stop_src);
310
311
312
313 if (err)
314 return 2;
315
316
317
318 err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
319
320 if (cmd->scan_begin_src == TRIG_EXT) {
321 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
322 } else {
323#define MAX_SPEED 1000
324 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
325 MAX_SPEED);
326 }
327
328 err |= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);
329 err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
330
331 if (cmd->stop_src == TRIG_COUNT)
332 err |= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
333 else
334 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
335
336 if (err)
337 return 3;
338
339
340
341 if (cmd->scan_begin_src == TRIG_TIMER) {
342 arg = cmd->scan_begin_arg;
343 i8253_cascade_ns_to_timer(I8254_OSC_BASE_2MHZ,
344 &devpriv->divisor1,
345 &devpriv->divisor2,
346 &arg, cmd->flags);
347 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
348 }
349
350 if (err)
351 return 4;
352
353 return 0;
354}
355
356static void pcl711_ai_load_counters(struct comedi_device *dev)
357{
358 struct pcl711_private *devpriv = dev->private;
359 unsigned long timer_base = dev->iobase + PCL711_TIMER_BASE;
360
361 i8254_set_mode(timer_base, 0, 1, I8254_MODE2 | I8254_BINARY);
362 i8254_set_mode(timer_base, 0, 2, I8254_MODE2 | I8254_BINARY);
363
364 i8254_write(timer_base, 0, 1, devpriv->divisor1);
365 i8254_write(timer_base, 0, 2, devpriv->divisor2);
366}
367
368static int pcl711_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
369{
370 struct comedi_cmd *cmd = &s->async->cmd;
371
372 pcl711_set_changain(dev, s, cmd->chanlist[0]);
373
374 if (cmd->scan_begin_src == TRIG_TIMER) {
375 pcl711_ai_load_counters(dev);
376 outb(PCL711_INT_STAT_CLR, dev->iobase + PCL711_INT_STAT_REG);
377 pcl711_ai_set_mode(dev, PCL711_MODE_PACER_IRQ);
378 } else {
379 pcl711_ai_set_mode(dev, PCL711_MODE_EXT_IRQ);
380 }
381
382 return 0;
383}
384
385static void pcl711_ao_write(struct comedi_device *dev,
386 unsigned int chan, unsigned int val)
387{
388 outb(val & 0xff, dev->iobase + PCL711_AO_LSB_REG(chan));
389 outb((val >> 8) & 0xff, dev->iobase + PCL711_AO_MSB_REG(chan));
390}
391
392static int pcl711_ao_insn_write(struct comedi_device *dev,
393 struct comedi_subdevice *s,
394 struct comedi_insn *insn,
395 unsigned int *data)
396{
397 unsigned int chan = CR_CHAN(insn->chanspec);
398 unsigned int val = s->readback[chan];
399 int i;
400
401 for (i = 0; i < insn->n; i++) {
402 val = data[i];
403 pcl711_ao_write(dev, chan, val);
404 }
405 s->readback[chan] = val;
406
407 return insn->n;
408}
409
410static int pcl711_di_insn_bits(struct comedi_device *dev,
411 struct comedi_subdevice *s,
412 struct comedi_insn *insn,
413 unsigned int *data)
414{
415 unsigned int val;
416
417 val = inb(dev->iobase + PCL711_DI_LSB_REG);
418 val |= (inb(dev->iobase + PCL711_DI_MSB_REG) << 8);
419
420 data[1] = val;
421
422 return insn->n;
423}
424
425static int pcl711_do_insn_bits(struct comedi_device *dev,
426 struct comedi_subdevice *s,
427 struct comedi_insn *insn,
428 unsigned int *data)
429{
430 unsigned int mask;
431
432 mask = comedi_dio_update_state(s, data);
433 if (mask) {
434 if (mask & 0x00ff)
435 outb(s->state & 0xff, dev->iobase + PCL711_DO_LSB_REG);
436 if (mask & 0xff00)
437 outb((s->state >> 8), dev->iobase + PCL711_DO_MSB_REG);
438 }
439
440 data[1] = s->state;
441
442 return insn->n;
443}
444
445static int pcl711_attach(struct comedi_device *dev, struct comedi_devconfig *it)
446{
447 const struct pcl711_board *board = dev->board_ptr;
448 struct pcl711_private *devpriv;
449 struct comedi_subdevice *s;
450 int ret;
451
452 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
453 if (!devpriv)
454 return -ENOMEM;
455
456 ret = comedi_request_region(dev, it->options[0], 0x10);
457 if (ret)
458 return ret;
459
460 if (it->options[1] && it->options[1] <= board->maxirq) {
461 ret = request_irq(it->options[1], pcl711_interrupt, 0,
462 dev->board_name, dev);
463 if (ret == 0)
464 dev->irq = it->options[1];
465 }
466
467 ret = comedi_alloc_subdevices(dev, 4);
468 if (ret)
469 return ret;
470
471
472 s = &dev->subdevices[0];
473 s->type = COMEDI_SUBD_AI;
474 s->subdev_flags = SDF_READABLE | SDF_GROUND;
475 if (board->n_aichan > 8)
476 s->subdev_flags |= SDF_DIFF;
477 s->n_chan = board->n_aichan;
478 s->maxdata = 0xfff;
479 s->range_table = board->ai_range_type;
480 s->insn_read = pcl711_ai_insn_read;
481 if (dev->irq) {
482 dev->read_subdev = s;
483 s->subdev_flags |= SDF_CMD_READ;
484 s->len_chanlist = 1;
485 s->do_cmdtest = pcl711_ai_cmdtest;
486 s->do_cmd = pcl711_ai_cmd;
487 s->cancel = pcl711_ai_cancel;
488 }
489
490
491 s = &dev->subdevices[1];
492 s->type = COMEDI_SUBD_AO;
493 s->subdev_flags = SDF_WRITABLE;
494 s->n_chan = board->n_aochan;
495 s->maxdata = 0xfff;
496 s->range_table = &range_bipolar5;
497 s->insn_write = pcl711_ao_insn_write;
498
499 ret = comedi_alloc_subdev_readback(s);
500 if (ret)
501 return ret;
502
503
504 s = &dev->subdevices[2];
505 s->type = COMEDI_SUBD_DI;
506 s->subdev_flags = SDF_READABLE;
507 s->n_chan = 16;
508 s->maxdata = 1;
509 s->range_table = &range_digital;
510 s->insn_bits = pcl711_di_insn_bits;
511
512
513 s = &dev->subdevices[3];
514 s->type = COMEDI_SUBD_DO;
515 s->subdev_flags = SDF_WRITABLE;
516 s->n_chan = 16;
517 s->maxdata = 1;
518 s->range_table = &range_digital;
519 s->insn_bits = pcl711_do_insn_bits;
520
521
522 pcl711_ao_write(dev, 0, 0x0);
523 pcl711_ao_write(dev, 1, 0x0);
524
525 return 0;
526}
527
528static struct comedi_driver pcl711_driver = {
529 .driver_name = "pcl711",
530 .module = THIS_MODULE,
531 .attach = pcl711_attach,
532 .detach = comedi_legacy_detach,
533 .board_name = &boardtypes[0].name,
534 .num_names = ARRAY_SIZE(boardtypes),
535 .offset = sizeof(struct pcl711_board),
536};
537module_comedi_driver(pcl711_driver);
538
539MODULE_AUTHOR("Comedi http://www.comedi.org");
540MODULE_DESCRIPTION("Comedi driver for PCL-711 compatible boards");
541MODULE_LICENSE("GPL");
542
