2 * Comedi driver for CIO-DAS16/M1
3 * Author: Frank Mori Hess, based on code from the das16 driver.
4 * Copyright (C) 2001 Frank Mori Hess <fmhess@users.sourceforge.net>
6 * COMEDI - Linux Control and Measurement Device Interface
7 * Copyright (C) 2000 David A. Schleef <ds@schleef.org>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
22 * Description: CIO-DAS16/M1
23 * Author: Frank Mori Hess <fmhess@users.sourceforge.net>
24 * Devices: [Measurement Computing] CIO-DAS16/M1 (das16m1)
27 * This driver supports a single board - the CIO-DAS16/M1. As far as I know,
28 * there are no other boards that have the same register layout. Even the
29 * CIO-DAS16/M1/16 is significantly different.
31 * I was _barely_ able to reach the full 1 MHz capability of this board, using
32 * a hard real-time interrupt (set the TRIG_RT flag in your struct comedi_cmd
33 * and use rtlinux or RTAI). The board can't do dma, so the bottleneck is
34 * pulling the data across the ISA bus. I timed the interrupt handler, and it
35 * took my computer ~470 microseconds to pull 512 samples from the board. So
36 * at 1 Mhz sampling rate, expect your CPU to be spending almost all of its
37 * time in the interrupt handler.
39 * This board has some unusual restrictions for its channel/gain list. If the
40 * list has 2 or more channels in it, then two conditions must be satisfied:
41 * (1) - even/odd channels must appear at even/odd indices in the list
42 * (2) - the list must have an even number of entries.
44 * Configuration options:
45 * [0] - base io address
46 * [1] - irq (optional, but you probably want it)
48 * irq can be omitted, although the cmd interface will not work without it.
51 #include <linux/module.h>
52 #include <linux/slab.h>
53 #include <linux/interrupt.h>
54 #include "../comedidev.h"
57 #include "comedi_8254.h"
59 #define DAS16M1_SIZE2 8
61 #define FIFO_SIZE 1024 /* 1024 sample fifo */
64 * Register map (dev->iobase)
66 #define DAS16M1_AI_REG 0x00 /* 16-bit register */
67 #define DAS16M1_AI_TO_CHAN(x) (((x) >> 0) & 0xf)
68 #define DAS16M1_AI_TO_SAMPLE(x) (((x) >> 4) & 0xfff)
69 #define DAS16M1_CS_REG 0x02
70 #define DAS16M1_CS_EXT_TRIG BIT(0)
71 #define DAS16M1_CS_OVRUN BIT(5)
72 #define DAS16M1_CS_IRQDATA BIT(7)
73 #define DAS16M1_DI_REG 0x03
74 #define DAS16M1_DO_REG 0x03
75 #define DAS16M1_CLR_INTR_REG 0x04
76 #define DAS16M1_INTR_CTRL_REG 0x05
77 #define DAS16M1_INTR_CTRL_PACER(x) (((x) & 0x3) << 0)
78 #define DAS16M1_INTR_CTRL_PACER_EXT DAS16M1_INTR_CTRL_PACER(2)
79 #define DAS16M1_INTR_CTRL_PACER_INT DAS16M1_INTR_CTRL_PACER(3)
80 #define DAS16M1_INTR_CTRL_PACER_MASK DAS16M1_INTR_CTRL_PACER(3)
81 #define DAS16M1_INTR_CTRL_IRQ(x) (((x) & 0x7) << 4)
82 #define DAS16M1_INTR_CTRL_INTE BIT(7)
83 #define DAS16M1_Q_ADDR_REG 0x06
84 #define DAS16M1_Q_REG 0x07
85 #define DAS16M1_Q_CHAN(x) (((x) & 0x7) << 0)
86 #define DAS16M1_Q_RANGE(x) (((x) & 0xf) << 4)
87 #define DAS16M1_8254_FIRST 0x8
88 #define DAS16M1_8254_SECOND 0xc
89 #define DAS16M1_82C55 0x400
90 #define DAS16M1_8254_THIRD 0x404
92 static const struct comedi_lrange range_das16m1 = {
106 struct das16m1_private_struct {
107 struct comedi_8254 *counter;
108 unsigned int intr_ctrl;
109 unsigned int adc_count;
110 u16 initial_hw_count;
111 unsigned short ai_buffer[FIFO_SIZE];
112 unsigned long extra_iobase;
115 static void das16m1_ai_set_queue(struct comedi_device *dev,
116 unsigned int *chanspec, unsigned int len)
120 for (i = 0; i < len; i++) {
121 unsigned int chan = CR_CHAN(chanspec[i]);
122 unsigned int range = CR_RANGE(chanspec[i]);
124 outb(i, dev->iobase + DAS16M1_Q_ADDR_REG);
125 outb(DAS16M1_Q_CHAN(chan) | DAS16M1_Q_RANGE(range),
126 dev->iobase + DAS16M1_Q_REG);
130 static void munge_sample_array(unsigned short *array, unsigned int num_elements)
134 for (i = 0; i < num_elements; i++)
135 array[i] = DAS16M1_AI_TO_SAMPLE(array[i]);
138 static int das16m1_ai_check_chanlist(struct comedi_device *dev,
139 struct comedi_subdevice *s,
140 struct comedi_cmd *cmd)
144 if (cmd->chanlist_len == 1)
147 if ((cmd->chanlist_len % 2) != 0) {
148 dev_dbg(dev->class_dev,
149 "chanlist must be of even length or length 1\n");
153 for (i = 0; i < cmd->chanlist_len; i++) {
154 unsigned int chan = CR_CHAN(cmd->chanlist[i]);
156 if ((i % 2) != (chan % 2)) {
157 dev_dbg(dev->class_dev,
158 "even/odd channels must go have even/odd chanlist indices\n");
166 static int das16m1_cmd_test(struct comedi_device *dev,
167 struct comedi_subdevice *s, struct comedi_cmd *cmd)
171 /* Step 1 : check if triggers are trivially valid */
173 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
174 err |= comedi_check_trigger_src(&cmd->scan_begin_src, TRIG_FOLLOW);
175 err |= comedi_check_trigger_src(&cmd->convert_src,
176 TRIG_TIMER | TRIG_EXT);
177 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
178 err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
183 /* Step 2a : make sure trigger sources are unique */
185 err |= comedi_check_trigger_is_unique(cmd->start_src);
186 err |= comedi_check_trigger_is_unique(cmd->convert_src);
187 err |= comedi_check_trigger_is_unique(cmd->stop_src);
189 /* Step 2b : and mutually compatible */
194 /* Step 3: check if arguments are trivially valid */
196 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
198 if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */
199 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
201 if (cmd->convert_src == TRIG_TIMER)
202 err |= comedi_check_trigger_arg_min(&cmd->convert_arg, 1000);
204 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
207 if (cmd->stop_src == TRIG_COUNT)
208 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
210 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
215 /* step 4: fix up arguments */
217 if (cmd->convert_src == TRIG_TIMER) {
218 unsigned int arg = cmd->convert_arg;
220 comedi_8254_cascade_ns_to_timer(dev->pacer, &arg, cmd->flags);
221 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
227 /* Step 5: check channel list if it exists */
228 if (cmd->chanlist && cmd->chanlist_len > 0)
229 err |= das16m1_ai_check_chanlist(dev, s, cmd);
237 static int das16m1_cmd_exec(struct comedi_device *dev,
238 struct comedi_subdevice *s)
240 struct das16m1_private_struct *devpriv = dev->private;
241 struct comedi_async *async = s->async;
242 struct comedi_cmd *cmd = &async->cmd;
245 /* set software count */
246 devpriv->adc_count = 0;
249 * Initialize lower half of hardware counter, used to determine how
250 * many samples are in fifo. Value doesn't actually load into counter
251 * until counter's next clock (the next a/d conversion).
253 comedi_8254_set_mode(devpriv->counter, 1, I8254_MODE2 | I8254_BINARY);
254 comedi_8254_write(devpriv->counter, 1, 0);
257 * Remember current reading of counter so we know when counter has
258 * actually been loaded.
260 devpriv->initial_hw_count = comedi_8254_read(devpriv->counter, 1);
262 das16m1_ai_set_queue(dev, cmd->chanlist, cmd->chanlist_len);
264 /* enable interrupts and set internal pacer counter mode and counts */
265 devpriv->intr_ctrl &= ~DAS16M1_INTR_CTRL_PACER_MASK;
266 if (cmd->convert_src == TRIG_TIMER) {
267 comedi_8254_update_divisors(dev->pacer);
268 comedi_8254_pacer_enable(dev->pacer, 1, 2, true);
269 devpriv->intr_ctrl |= DAS16M1_INTR_CTRL_PACER_INT;
270 } else { /* TRIG_EXT */
271 devpriv->intr_ctrl |= DAS16M1_INTR_CTRL_PACER_EXT;
274 /* set control & status register */
277 * If we are using external start trigger (also board dislikes having
278 * both start and conversion triggers external simultaneously).
280 if (cmd->start_src == TRIG_EXT && cmd->convert_src != TRIG_EXT)
281 byte |= DAS16M1_CS_EXT_TRIG;
283 outb(byte, dev->iobase + DAS16M1_CS_REG);
285 /* clear interrupt */
286 outb(0, dev->iobase + DAS16M1_CLR_INTR_REG);
288 devpriv->intr_ctrl |= DAS16M1_INTR_CTRL_INTE;
289 outb(devpriv->intr_ctrl, dev->iobase + DAS16M1_INTR_CTRL_REG);
294 static int das16m1_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
296 struct das16m1_private_struct *devpriv = dev->private;
298 /* disable interrupts and pacer */
299 devpriv->intr_ctrl &= ~(DAS16M1_INTR_CTRL_INTE |
300 DAS16M1_INTR_CTRL_PACER_MASK);
301 outb(devpriv->intr_ctrl, dev->iobase + DAS16M1_INTR_CTRL_REG);
306 static int das16m1_ai_eoc(struct comedi_device *dev,
307 struct comedi_subdevice *s,
308 struct comedi_insn *insn,
309 unsigned long context)
313 status = inb(dev->iobase + DAS16M1_CS_REG);
314 if (status & DAS16M1_CS_IRQDATA)
319 static int das16m1_ai_rinsn(struct comedi_device *dev,
320 struct comedi_subdevice *s,
321 struct comedi_insn *insn, unsigned int *data)
326 das16m1_ai_set_queue(dev, &insn->chanspec, 1);
328 for (n = 0; n < insn->n; n++) {
331 /* clear interrupt */
332 outb(0, dev->iobase + DAS16M1_CLR_INTR_REG);
333 /* trigger conversion */
334 outb(0, dev->iobase + DAS16M1_AI_REG);
336 ret = comedi_timeout(dev, s, insn, das16m1_ai_eoc, 0);
340 val = inw(dev->iobase + DAS16M1_AI_REG);
341 data[n] = DAS16M1_AI_TO_SAMPLE(val);
347 static int das16m1_di_rbits(struct comedi_device *dev,
348 struct comedi_subdevice *s,
349 struct comedi_insn *insn, unsigned int *data)
353 bits = inb(dev->iobase + DAS16M1_DI_REG) & 0xf;
360 static int das16m1_do_wbits(struct comedi_device *dev,
361 struct comedi_subdevice *s,
362 struct comedi_insn *insn,
365 if (comedi_dio_update_state(s, data))
366 outb(s->state, dev->iobase + DAS16M1_DO_REG);
373 static void das16m1_handler(struct comedi_device *dev, unsigned int status)
375 struct das16m1_private_struct *devpriv = dev->private;
376 struct comedi_subdevice *s;
377 struct comedi_async *async;
378 struct comedi_cmd *cmd;
382 s = dev->read_subdev;
386 /* figure out how many samples are in fifo */
387 hw_counter = comedi_8254_read(devpriv->counter, 1);
389 * Make sure hardware counter reading is not bogus due to initial
390 * value not having been loaded yet.
392 if (devpriv->adc_count == 0 &&
393 hw_counter == devpriv->initial_hw_count) {
397 * The calculation of num_samples looks odd, but it uses the
398 * following facts. 16 bit hardware counter is initialized with
399 * value of zero (which really means 0x1000). The counter
400 * decrements by one on each conversion (when the counter
401 * decrements from zero it goes to 0xffff). num_samples is a
402 * 16 bit variable, so it will roll over in a similar fashion
403 * to the hardware counter. Work it out, and this is what you
406 num_samples = -hw_counter - devpriv->adc_count;
408 /* check if we only need some of the points */
409 if (cmd->stop_src == TRIG_COUNT) {
410 if (num_samples > cmd->stop_arg * cmd->chanlist_len)
411 num_samples = cmd->stop_arg * cmd->chanlist_len;
413 /* make sure we dont try to get too many points if fifo has overrun */
414 if (num_samples > FIFO_SIZE)
415 num_samples = FIFO_SIZE;
416 insw(dev->iobase, devpriv->ai_buffer, num_samples);
417 munge_sample_array(devpriv->ai_buffer, num_samples);
418 comedi_buf_write_samples(s, devpriv->ai_buffer, num_samples);
419 devpriv->adc_count += num_samples;
421 if (cmd->stop_src == TRIG_COUNT) {
422 if (devpriv->adc_count >= cmd->stop_arg * cmd->chanlist_len) {
423 /* end of acquisition */
424 async->events |= COMEDI_CB_EOA;
429 * This probably won't catch overruns since the card doesn't generate
430 * overrun interrupts, but we might as well try.
432 if (status & DAS16M1_CS_OVRUN) {
433 async->events |= COMEDI_CB_ERROR;
434 dev_err(dev->class_dev, "fifo overflow\n");
437 comedi_handle_events(dev, s);
440 static int das16m1_poll(struct comedi_device *dev, struct comedi_subdevice *s)
445 /* prevent race with interrupt handler */
446 spin_lock_irqsave(&dev->spinlock, flags);
447 status = inb(dev->iobase + DAS16M1_CS_REG);
448 das16m1_handler(dev, status);
449 spin_unlock_irqrestore(&dev->spinlock, flags);
451 return comedi_buf_n_bytes_ready(s);
454 static irqreturn_t das16m1_interrupt(int irq, void *d)
457 struct comedi_device *dev = d;
459 if (!dev->attached) {
460 dev_err(dev->class_dev, "premature interrupt\n");
463 /* prevent race with comedi_poll() */
464 spin_lock(&dev->spinlock);
466 status = inb(dev->iobase + DAS16M1_CS_REG);
468 if ((status & (DAS16M1_CS_IRQDATA | DAS16M1_CS_OVRUN)) == 0) {
469 dev_err(dev->class_dev, "spurious interrupt\n");
470 spin_unlock(&dev->spinlock);
474 das16m1_handler(dev, status);
476 /* clear interrupt */
477 outb(0, dev->iobase + DAS16M1_CLR_INTR_REG);
479 spin_unlock(&dev->spinlock);
483 static int das16m1_irq_bits(unsigned int irq)
512 static int das16m1_attach(struct comedi_device *dev,
513 struct comedi_devconfig *it)
515 struct das16m1_private_struct *devpriv;
516 struct comedi_subdevice *s;
519 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
523 ret = comedi_request_region(dev, it->options[0], 0x10);
526 /* Request an additional region for the 8255 */
527 ret = __comedi_request_region(dev, dev->iobase + DAS16M1_82C55,
531 devpriv->extra_iobase = dev->iobase + DAS16M1_82C55;
533 /* only irqs 2, 3, 4, 5, 6, 7, 10, 11, 12, 14, and 15 are valid */
534 if ((1 << it->options[1]) & 0xdcfc) {
535 ret = request_irq(it->options[1], das16m1_interrupt, 0,
536 dev->board_name, dev);
538 dev->irq = it->options[1];
541 dev->pacer = comedi_8254_init(dev->iobase + DAS16M1_8254_SECOND,
542 I8254_OSC_BASE_10MHZ, I8254_IO8, 0);
546 devpriv->counter = comedi_8254_init(dev->iobase + DAS16M1_8254_FIRST,
548 if (!devpriv->counter)
551 ret = comedi_alloc_subdevices(dev, 4);
555 s = &dev->subdevices[0];
557 s->type = COMEDI_SUBD_AI;
558 s->subdev_flags = SDF_READABLE | SDF_DIFF;
560 s->maxdata = (1 << 12) - 1;
561 s->range_table = &range_das16m1;
562 s->insn_read = das16m1_ai_rinsn;
564 dev->read_subdev = s;
565 s->subdev_flags |= SDF_CMD_READ;
566 s->len_chanlist = 256;
567 s->do_cmdtest = das16m1_cmd_test;
568 s->do_cmd = das16m1_cmd_exec;
569 s->cancel = das16m1_cancel;
570 s->poll = das16m1_poll;
573 s = &dev->subdevices[1];
575 s->type = COMEDI_SUBD_DI;
576 s->subdev_flags = SDF_READABLE;
579 s->range_table = &range_digital;
580 s->insn_bits = das16m1_di_rbits;
582 s = &dev->subdevices[2];
584 s->type = COMEDI_SUBD_DO;
585 s->subdev_flags = SDF_WRITABLE;
588 s->range_table = &range_digital;
589 s->insn_bits = das16m1_do_wbits;
591 s = &dev->subdevices[3];
593 ret = subdev_8255_init(dev, s, NULL, DAS16M1_82C55);
597 /* initialize digital output lines */
598 outb(0, dev->iobase + DAS16M1_DO_REG);
600 /* set the interrupt level */
601 devpriv->intr_ctrl = DAS16M1_INTR_CTRL_IRQ(das16m1_irq_bits(dev->irq));
602 outb(devpriv->intr_ctrl, dev->iobase + DAS16M1_INTR_CTRL_REG);
607 static void das16m1_detach(struct comedi_device *dev)
609 struct das16m1_private_struct *devpriv = dev->private;
612 if (devpriv->extra_iobase)
613 release_region(devpriv->extra_iobase, DAS16M1_SIZE2);
614 kfree(devpriv->counter);
616 comedi_legacy_detach(dev);
619 static struct comedi_driver das16m1_driver = {
620 .driver_name = "das16m1",
621 .module = THIS_MODULE,
622 .attach = das16m1_attach,
623 .detach = das16m1_detach,
625 module_comedi_driver(das16m1_driver);
627 MODULE_AUTHOR("Comedi http://www.comedi.org");
628 MODULE_DESCRIPTION("Comedi low-level driver");
629 MODULE_LICENSE("GPL");