2 * comedi/drivers/comedi_test.c
4 * Generates fake waveform signals that can be read through
5 * the command interface. It does _not_ read from any board;
6 * it just generates deterministic waveforms.
7 * Useful for various testing purposes.
9 * Copyright (C) 2002 Joachim Wuttke <Joachim.Wuttke@icn.siemens.de>
10 * Copyright (C) 2002 Frank Mori Hess <fmhess@users.sourceforge.net>
12 * COMEDI - Linux Control and Measurement Device Interface
13 * Copyright (C) 2000 David A. Schleef <ds@schleef.org>
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
28 * Description: generates fake waveforms
29 * Author: Joachim Wuttke <Joachim.Wuttke@icn.siemens.de>, Frank Mori Hess
30 * <fmhess@users.sourceforge.net>, ds
33 * Updated: Sat, 16 Mar 2002 17:34:48 -0800
35 * This driver is mainly for testing purposes, but can also be used to
36 * generate sample waveforms on systems that don't have data acquisition
39 * Configuration options:
40 * [0] - Amplitude in microvolts for fake waveforms (default 1 volt)
41 * [1] - Period in microseconds for fake waveforms (default 0.1 sec)
43 * Generates a sawtooth wave on channel 0, square wave on channel 1, additional
44 * waveforms could be added to other channels (currently they return flatline
48 #include <linux/module.h>
49 #include "../comedidev.h"
51 #include <asm/div64.h>
53 #include <linux/timer.h>
54 #include <linux/ktime.h>
55 #include <linux/jiffies.h>
59 /* Data unique to this driver */
60 struct waveform_private {
61 struct timer_list ai_timer; /* timer for AI commands */
62 u64 ai_convert_time; /* time of next AI conversion in usec */
63 unsigned int wf_amplitude; /* waveform amplitude in microvolts */
64 unsigned int wf_period; /* waveform period in microseconds */
65 unsigned int wf_current; /* current time in waveform period */
66 unsigned int ai_scan_period; /* AI scan period in usec */
67 unsigned int ai_convert_period; /* AI conversion period in usec */
68 struct timer_list ao_timer; /* timer for AO commands */
69 u64 ao_last_scan_time; /* time of previous AO scan in usec */
70 unsigned int ao_scan_period; /* AO scan period in usec */
71 unsigned short ao_loopbacks[N_CHANS];
74 /* fake analog input ranges */
75 static const struct comedi_lrange waveform_ai_ranges = {
82 static unsigned short fake_sawtooth(struct comedi_device *dev,
83 unsigned int range_index,
84 unsigned int current_time)
86 struct waveform_private *devpriv = dev->private;
87 struct comedi_subdevice *s = dev->read_subdev;
88 unsigned int offset = s->maxdata / 2;
90 const struct comedi_krange *krange =
91 &s->range_table->range[range_index];
94 binary_amplitude = s->maxdata;
95 binary_amplitude *= devpriv->wf_amplitude;
96 do_div(binary_amplitude, krange->max - krange->min);
99 value *= binary_amplitude * 2;
100 do_div(value, devpriv->wf_period);
102 /* get rid of sawtooth's dc offset and clamp value */
103 if (value < binary_amplitude) {
104 value = 0; /* negative saturation */
106 value -= binary_amplitude;
107 if (value > s->maxdata)
108 value = s->maxdata; /* positive saturation */
114 static unsigned short fake_squarewave(struct comedi_device *dev,
115 unsigned int range_index,
116 unsigned int current_time)
118 struct waveform_private *devpriv = dev->private;
119 struct comedi_subdevice *s = dev->read_subdev;
120 unsigned int offset = s->maxdata / 2;
122 const struct comedi_krange *krange =
123 &s->range_table->range[range_index];
126 value *= devpriv->wf_amplitude;
127 do_div(value, krange->max - krange->min);
129 /* get one of two values for square-wave and clamp */
130 if (current_time < devpriv->wf_period / 2) {
132 value = 0; /* negative saturation */
134 value = offset - value;
137 if (value > s->maxdata)
138 value = s->maxdata; /* positive saturation */
144 static unsigned short fake_flatline(struct comedi_device *dev,
145 unsigned int range_index,
146 unsigned int current_time)
148 return dev->read_subdev->maxdata / 2;
151 /* generates a different waveform depending on what channel is read */
152 static unsigned short fake_waveform(struct comedi_device *dev,
153 unsigned int channel, unsigned int range,
154 unsigned int current_time)
162 return fake_sawtooth(dev, range, current_time);
164 return fake_squarewave(dev, range, current_time);
169 return fake_flatline(dev, range, current_time);
173 * This is the background routine used to generate arbitrary data.
174 * It should run in the background; therefore it is scheduled by
177 static void waveform_ai_timer(unsigned long arg)
179 struct comedi_device *dev = (struct comedi_device *)arg;
180 struct waveform_private *devpriv = dev->private;
181 struct comedi_subdevice *s = dev->read_subdev;
182 struct comedi_async *async = s->async;
183 struct comedi_cmd *cmd = &async->cmd;
185 unsigned int nsamples;
186 unsigned int time_increment;
188 now = ktime_to_us(ktime_get());
189 nsamples = comedi_nsamples_left(s, UINT_MAX);
191 while (nsamples && devpriv->ai_convert_time < now) {
192 unsigned int chanspec = cmd->chanlist[async->cur_chan];
193 unsigned short sample;
195 sample = fake_waveform(dev, CR_CHAN(chanspec),
196 CR_RANGE(chanspec), devpriv->wf_current);
197 if (comedi_buf_write_samples(s, &sample, 1) == 0)
199 time_increment = devpriv->ai_convert_period;
200 if (async->scan_progress == 0) {
201 /* done last conversion in scan, so add dead time */
202 time_increment += devpriv->ai_scan_period -
203 devpriv->ai_convert_period *
206 devpriv->wf_current += time_increment;
207 if (devpriv->wf_current >= devpriv->wf_period)
208 devpriv->wf_current %= devpriv->wf_period;
209 devpriv->ai_convert_time += time_increment;
213 if (cmd->stop_src == TRIG_COUNT && async->scans_done >= cmd->stop_arg) {
214 async->events |= COMEDI_CB_EOA;
216 if (devpriv->ai_convert_time > now)
217 time_increment = devpriv->ai_convert_time - now;
220 mod_timer(&devpriv->ai_timer,
221 jiffies + usecs_to_jiffies(time_increment));
225 comedi_handle_events(dev, s);
228 static int waveform_ai_cmdtest(struct comedi_device *dev,
229 struct comedi_subdevice *s,
230 struct comedi_cmd *cmd)
233 unsigned int arg, limit;
235 /* Step 1 : check if triggers are trivially valid */
237 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW);
238 err |= comedi_check_trigger_src(&cmd->scan_begin_src,
239 TRIG_FOLLOW | TRIG_TIMER);
240 err |= comedi_check_trigger_src(&cmd->convert_src,
241 TRIG_NOW | TRIG_TIMER);
242 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
243 err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
248 /* Step 2a : make sure trigger sources are unique */
250 err |= comedi_check_trigger_is_unique(cmd->convert_src);
251 err |= comedi_check_trigger_is_unique(cmd->stop_src);
253 /* Step 2b : and mutually compatible */
255 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
256 err |= -EINVAL; /* scan period would be 0 */
261 /* Step 3: check if arguments are trivially valid */
263 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
265 if (cmd->convert_src == TRIG_NOW) {
266 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, 0);
267 } else { /* cmd->convert_src == TRIG_TIMER */
268 if (cmd->scan_begin_src == TRIG_FOLLOW) {
269 err |= comedi_check_trigger_arg_min(&cmd->convert_arg,
274 if (cmd->scan_begin_src == TRIG_FOLLOW) {
275 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
276 } else { /* cmd->scan_begin_src == TRIG_TIMER */
277 err |= comedi_check_trigger_arg_min(&cmd->scan_begin_arg,
281 err |= comedi_check_trigger_arg_min(&cmd->chanlist_len, 1);
282 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
285 if (cmd->stop_src == TRIG_COUNT)
286 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
287 else /* cmd->stop_src == TRIG_NONE */
288 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
293 /* step 4: fix up any arguments */
295 if (cmd->convert_src == TRIG_TIMER) {
296 /* round convert_arg to nearest microsecond */
297 arg = cmd->convert_arg;
299 rounddown(UINT_MAX, (unsigned int)NSEC_PER_USEC));
300 arg = NSEC_PER_USEC * DIV_ROUND_CLOSEST(arg, NSEC_PER_USEC);
301 if (cmd->scan_begin_arg == TRIG_TIMER) {
302 /* limit convert_arg to keep scan_begin_arg in range */
303 limit = UINT_MAX / cmd->scan_end_arg;
304 limit = rounddown(limit, (unsigned int)NSEC_PER_SEC);
305 arg = min(arg, limit);
307 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
310 if (cmd->scan_begin_src == TRIG_TIMER) {
311 /* round scan_begin_arg to nearest microsecond */
312 arg = cmd->scan_begin_arg;
314 rounddown(UINT_MAX, (unsigned int)NSEC_PER_USEC));
315 arg = NSEC_PER_USEC * DIV_ROUND_CLOSEST(arg, NSEC_PER_USEC);
316 if (cmd->convert_src == TRIG_TIMER) {
317 /* but ensure scan_begin_arg is large enough */
318 arg = max(arg, cmd->convert_arg * cmd->scan_end_arg);
320 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
329 static int waveform_ai_cmd(struct comedi_device *dev,
330 struct comedi_subdevice *s)
332 struct waveform_private *devpriv = dev->private;
333 struct comedi_cmd *cmd = &s->async->cmd;
334 unsigned int first_convert_time;
337 if (cmd->flags & CMDF_PRIORITY) {
338 dev_err(dev->class_dev,
339 "commands at RT priority not supported in this driver\n");
343 if (cmd->convert_src == TRIG_NOW)
344 devpriv->ai_convert_period = 0;
345 else /* cmd->convert_src == TRIG_TIMER */
346 devpriv->ai_convert_period = cmd->convert_arg / NSEC_PER_USEC;
348 if (cmd->scan_begin_src == TRIG_FOLLOW) {
349 devpriv->ai_scan_period = devpriv->ai_convert_period *
351 } else { /* cmd->scan_begin_src == TRIG_TIMER */
352 devpriv->ai_scan_period = cmd->scan_begin_arg / NSEC_PER_USEC;
356 * Simulate first conversion to occur at convert period after
357 * conversion timer starts. If scan_begin_src is TRIG_FOLLOW, assume
358 * the conversion timer starts immediately. If scan_begin_src is
359 * TRIG_TIMER, assume the conversion timer starts after the scan
362 first_convert_time = devpriv->ai_convert_period;
363 if (cmd->scan_begin_src == TRIG_TIMER)
364 first_convert_time += devpriv->ai_scan_period;
365 devpriv->ai_convert_time = ktime_to_us(ktime_get()) +
368 /* Determine time within waveform period at time of conversion. */
369 wf_current = devpriv->ai_convert_time;
370 devpriv->wf_current = do_div(wf_current, devpriv->wf_period);
373 * Schedule timer to expire just after first conversion time.
374 * Seem to need an extra jiffy here, otherwise timer expires slightly
377 devpriv->ai_timer.expires =
378 jiffies + usecs_to_jiffies(devpriv->ai_convert_period) + 1;
379 add_timer(&devpriv->ai_timer);
383 static int waveform_ai_cancel(struct comedi_device *dev,
384 struct comedi_subdevice *s)
386 struct waveform_private *devpriv = dev->private;
389 /* Assume we were called from the timer routine itself. */
390 del_timer(&devpriv->ai_timer);
392 del_timer_sync(&devpriv->ai_timer);
397 static int waveform_ai_insn_read(struct comedi_device *dev,
398 struct comedi_subdevice *s,
399 struct comedi_insn *insn, unsigned int *data)
401 struct waveform_private *devpriv = dev->private;
402 int i, chan = CR_CHAN(insn->chanspec);
404 for (i = 0; i < insn->n; i++)
405 data[i] = devpriv->ao_loopbacks[chan];
411 * This is the background routine to handle AO commands, scheduled by
414 static void waveform_ao_timer(unsigned long arg)
416 struct comedi_device *dev = (struct comedi_device *)arg;
417 struct waveform_private *devpriv = dev->private;
418 struct comedi_subdevice *s = dev->write_subdev;
419 struct comedi_async *async = s->async;
420 struct comedi_cmd *cmd = &async->cmd;
423 unsigned int scans_avail = 0;
425 /* determine number of scan periods since last time */
426 now = ktime_to_us(ktime_get());
427 scans_since = now - devpriv->ao_last_scan_time;
428 do_div(scans_since, devpriv->ao_scan_period);
432 /* determine scans in buffer, limit to scans to do this time */
433 scans_avail = comedi_nscans_left(s, 0);
434 if (scans_avail > scans_since)
435 scans_avail = scans_since;
437 /* skip all but the last scan to save processing time */
438 if (scans_avail > 1) {
439 unsigned int skip_bytes, nbytes;
442 comedi_samples_to_bytes(s, cmd->scan_end_arg *
444 nbytes = comedi_buf_read_alloc(s, skip_bytes);
445 comedi_buf_read_free(s, nbytes);
446 comedi_inc_scan_progress(s, nbytes);
447 if (nbytes < skip_bytes) {
448 /* unexpected underrun! (cancelled?) */
449 async->events |= COMEDI_CB_OVERFLOW;
453 /* output the last scan */
454 for (i = 0; i < cmd->scan_end_arg; i++) {
455 unsigned int chan = CR_CHAN(cmd->chanlist[i]);
457 if (comedi_buf_read_samples(s,
461 /* unexpected underrun! (cancelled?) */
462 async->events |= COMEDI_CB_OVERFLOW;
466 /* advance time of last scan */
467 devpriv->ao_last_scan_time +=
468 (u64)scans_avail * devpriv->ao_scan_period;
471 if (cmd->stop_src == TRIG_COUNT && async->scans_done >= cmd->stop_arg) {
472 async->events |= COMEDI_CB_EOA;
473 } else if (scans_avail < scans_since) {
474 async->events |= COMEDI_CB_OVERFLOW;
476 unsigned int time_inc = devpriv->ao_last_scan_time +
477 devpriv->ao_scan_period - now;
479 mod_timer(&devpriv->ao_timer,
480 jiffies + usecs_to_jiffies(time_inc));
484 comedi_handle_events(dev, s);
487 static int waveform_ao_inttrig_start(struct comedi_device *dev,
488 struct comedi_subdevice *s,
489 unsigned int trig_num)
491 struct waveform_private *devpriv = dev->private;
492 struct comedi_async *async = s->async;
493 struct comedi_cmd *cmd = &async->cmd;
495 if (trig_num != cmd->start_arg)
498 async->inttrig = NULL;
500 devpriv->ao_last_scan_time = ktime_to_us(ktime_get());
501 devpriv->ao_timer.expires =
502 jiffies + usecs_to_jiffies(devpriv->ao_scan_period);
503 add_timer(&devpriv->ao_timer);
508 static int waveform_ao_cmdtest(struct comedi_device *dev,
509 struct comedi_subdevice *s,
510 struct comedi_cmd *cmd)
515 /* Step 1 : check if triggers are trivially valid */
517 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_INT);
518 err |= comedi_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
519 err |= comedi_check_trigger_src(&cmd->convert_src, TRIG_NOW);
520 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
521 err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
526 /* Step 2a : make sure trigger sources are unique */
528 err |= comedi_check_trigger_is_unique(cmd->stop_src);
530 /* Step 2b : and mutually compatible */
535 /* Step 3: check if arguments are trivially valid */
537 err |= comedi_check_trigger_arg_min(&cmd->scan_begin_arg,
539 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, 0);
540 err |= comedi_check_trigger_arg_min(&cmd->chanlist_len, 1);
541 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
543 if (cmd->stop_src == TRIG_COUNT)
544 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
545 else /* cmd->stop_src == TRIG_NONE */
546 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
551 /* step 4: fix up any arguments */
553 /* round scan_begin_arg to nearest microsecond */
554 arg = cmd->scan_begin_arg;
555 arg = min(arg, rounddown(UINT_MAX, (unsigned int)NSEC_PER_USEC));
556 arg = NSEC_PER_USEC * DIV_ROUND_CLOSEST(arg, NSEC_PER_USEC);
557 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
565 static int waveform_ao_cmd(struct comedi_device *dev,
566 struct comedi_subdevice *s)
568 struct waveform_private *devpriv = dev->private;
569 struct comedi_cmd *cmd = &s->async->cmd;
571 if (cmd->flags & CMDF_PRIORITY) {
572 dev_err(dev->class_dev,
573 "commands at RT priority not supported in this driver\n");
577 devpriv->ao_scan_period = cmd->scan_begin_arg / NSEC_PER_USEC;
578 s->async->inttrig = waveform_ao_inttrig_start;
582 static int waveform_ao_cancel(struct comedi_device *dev,
583 struct comedi_subdevice *s)
585 struct waveform_private *devpriv = dev->private;
587 s->async->inttrig = NULL;
589 /* Assume we were called from the timer routine itself. */
590 del_timer(&devpriv->ao_timer);
592 del_timer_sync(&devpriv->ao_timer);
597 static int waveform_ao_insn_write(struct comedi_device *dev,
598 struct comedi_subdevice *s,
599 struct comedi_insn *insn, unsigned int *data)
601 struct waveform_private *devpriv = dev->private;
602 int i, chan = CR_CHAN(insn->chanspec);
604 for (i = 0; i < insn->n; i++)
605 devpriv->ao_loopbacks[chan] = data[i];
610 static int waveform_attach(struct comedi_device *dev,
611 struct comedi_devconfig *it)
613 struct waveform_private *devpriv;
614 struct comedi_subdevice *s;
615 int amplitude = it->options[0];
616 int period = it->options[1];
620 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
624 /* set default amplitude and period */
626 amplitude = 1000000; /* 1 volt */
628 period = 100000; /* 0.1 sec */
630 devpriv->wf_amplitude = amplitude;
631 devpriv->wf_period = period;
633 ret = comedi_alloc_subdevices(dev, 2);
637 s = &dev->subdevices[0];
638 dev->read_subdev = s;
639 /* analog input subdevice */
640 s->type = COMEDI_SUBD_AI;
641 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
644 s->range_table = &waveform_ai_ranges;
645 s->len_chanlist = s->n_chan * 2;
646 s->insn_read = waveform_ai_insn_read;
647 s->do_cmd = waveform_ai_cmd;
648 s->do_cmdtest = waveform_ai_cmdtest;
649 s->cancel = waveform_ai_cancel;
651 s = &dev->subdevices[1];
652 dev->write_subdev = s;
653 /* analog output subdevice (loopback) */
654 s->type = COMEDI_SUBD_AO;
655 s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
658 s->range_table = &waveform_ai_ranges;
659 s->len_chanlist = s->n_chan;
660 s->insn_write = waveform_ao_insn_write;
661 s->insn_read = waveform_ai_insn_read; /* do same as AI insn_read */
662 s->do_cmd = waveform_ao_cmd;
663 s->do_cmdtest = waveform_ao_cmdtest;
664 s->cancel = waveform_ao_cancel;
666 /* Our default loopback value is just a 0V flatline */
667 for (i = 0; i < s->n_chan; i++)
668 devpriv->ao_loopbacks[i] = s->maxdata / 2;
670 setup_timer(&devpriv->ai_timer, waveform_ai_timer, (unsigned long)dev);
671 setup_timer(&devpriv->ao_timer, waveform_ao_timer, (unsigned long)dev);
673 dev_info(dev->class_dev,
674 "%s: %u microvolt, %u microsecond waveform attached\n",
676 devpriv->wf_amplitude, devpriv->wf_period);
681 static void waveform_detach(struct comedi_device *dev)
683 struct waveform_private *devpriv = dev->private;
686 del_timer_sync(&devpriv->ai_timer);
687 del_timer_sync(&devpriv->ao_timer);
691 static struct comedi_driver waveform_driver = {
692 .driver_name = "comedi_test",
693 .module = THIS_MODULE,
694 .attach = waveform_attach,
695 .detach = waveform_detach,
697 module_comedi_driver(waveform_driver);
699 MODULE_AUTHOR("Comedi http://www.comedi.org");
700 MODULE_DESCRIPTION("Comedi low-level driver");
701 MODULE_LICENSE("GPL");