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>
58 enum waveform_state_bits {
59 WAVEFORM_AI_RUNNING = 0
62 /* Data unique to this driver */
63 struct waveform_private {
64 struct timer_list timer;
65 ktime_t last; /* time last timer interrupt occurred */
66 unsigned int uvolt_amplitude; /* waveform amplitude in microvolts */
67 unsigned int usec_period; /* waveform period in microseconds */
68 unsigned int usec_current; /* current time (mod waveform period) */
69 unsigned long usec_remainder; /* usec since last scan */
70 unsigned long state_bits;
71 unsigned int scan_period; /* scan period in usec */
72 unsigned int convert_period; /* conversion period in usec */
73 unsigned int ao_loopbacks[N_CHANS];
76 /* fake analog input ranges */
77 static const struct comedi_lrange waveform_ai_ranges = {
84 static unsigned short fake_sawtooth(struct comedi_device *dev,
85 unsigned int range_index,
86 unsigned int current_time)
88 struct waveform_private *devpriv = dev->private;
89 struct comedi_subdevice *s = dev->read_subdev;
90 unsigned int offset = s->maxdata / 2;
92 const struct comedi_krange *krange =
93 &s->range_table->range[range_index];
96 binary_amplitude = s->maxdata;
97 binary_amplitude *= devpriv->uvolt_amplitude;
98 do_div(binary_amplitude, krange->max - krange->min);
100 value = current_time;
101 value *= binary_amplitude * 2;
102 do_div(value, devpriv->usec_period);
104 /* get rid of sawtooth's dc offset and clamp value */
105 if (value < binary_amplitude) {
106 value = 0; /* negative saturation */
108 value -= binary_amplitude;
109 if (value > s->maxdata)
110 value = s->maxdata; /* positive saturation */
116 static unsigned short fake_squarewave(struct comedi_device *dev,
117 unsigned int range_index,
118 unsigned int current_time)
120 struct waveform_private *devpriv = dev->private;
121 struct comedi_subdevice *s = dev->read_subdev;
122 unsigned int offset = s->maxdata / 2;
124 const struct comedi_krange *krange =
125 &s->range_table->range[range_index];
128 value *= devpriv->uvolt_amplitude;
129 do_div(value, krange->max - krange->min);
131 /* get one of two values for square-wave and clamp */
132 if (current_time < devpriv->usec_period / 2) {
134 value = 0; /* negative saturation */
136 value = offset - value;
139 if (value > s->maxdata)
140 value = s->maxdata; /* positive saturation */
146 static unsigned short fake_flatline(struct comedi_device *dev,
147 unsigned int range_index,
148 unsigned int current_time)
150 return dev->read_subdev->maxdata / 2;
153 /* generates a different waveform depending on what channel is read */
154 static unsigned short fake_waveform(struct comedi_device *dev,
155 unsigned int channel, unsigned int range,
156 unsigned int current_time)
164 return fake_sawtooth(dev, range, current_time);
166 return fake_squarewave(dev, range, current_time);
171 return fake_flatline(dev, range, current_time);
175 * This is the background routine used to generate arbitrary data.
176 * It should run in the background; therefore it is scheduled by
179 static void waveform_ai_interrupt(unsigned long arg)
181 struct comedi_device *dev = (struct comedi_device *)arg;
182 struct waveform_private *devpriv = dev->private;
183 struct comedi_subdevice *s = dev->read_subdev;
184 struct comedi_async *async = s->async;
185 struct comedi_cmd *cmd = &async->cmd;
187 /* all times in microsec */
188 unsigned long elapsed_time;
189 unsigned int num_scans;
192 /* check command is still active */
193 if (!test_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits))
198 elapsed_time = ktime_to_us(ktime_sub(now, devpriv->last));
201 (devpriv->usec_remainder + elapsed_time) / devpriv->scan_period;
202 devpriv->usec_remainder =
203 (devpriv->usec_remainder + elapsed_time) % devpriv->scan_period;
205 num_scans = comedi_nscans_left(s, num_scans);
206 for (i = 0; i < num_scans; i++) {
207 unsigned long scan_remain_period = devpriv->scan_period;
209 for (j = 0; j < cmd->chanlist_len; j++) {
210 unsigned short sample;
212 if (devpriv->usec_current >= devpriv->usec_period)
213 devpriv->usec_current %= devpriv->usec_period;
214 sample = fake_waveform(dev, CR_CHAN(cmd->chanlist[j]),
215 CR_RANGE(cmd->chanlist[j]),
216 devpriv->usec_current);
217 comedi_buf_write_samples(s, &sample, 1);
218 devpriv->usec_current += devpriv->convert_period;
219 scan_remain_period -= devpriv->convert_period;
221 devpriv->usec_current += scan_remain_period;
223 if (devpriv->usec_current >= devpriv->usec_period)
224 devpriv->usec_current %= devpriv->usec_period;
226 if (cmd->stop_src == TRIG_COUNT && async->scans_done >= cmd->stop_arg)
227 async->events |= COMEDI_CB_EOA;
229 mod_timer(&devpriv->timer, jiffies + 1);
231 comedi_handle_events(dev, s);
234 static int waveform_ai_cmdtest(struct comedi_device *dev,
235 struct comedi_subdevice *s,
236 struct comedi_cmd *cmd)
239 unsigned int arg, limit;
241 /* Step 1 : check if triggers are trivially valid */
243 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW);
244 err |= comedi_check_trigger_src(&cmd->scan_begin_src,
245 TRIG_FOLLOW | TRIG_TIMER);
246 err |= comedi_check_trigger_src(&cmd->convert_src,
247 TRIG_NOW | TRIG_TIMER);
248 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
249 err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
254 /* Step 2a : make sure trigger sources are unique */
256 err |= comedi_check_trigger_is_unique(cmd->convert_src);
257 err |= comedi_check_trigger_is_unique(cmd->stop_src);
259 /* Step 2b : and mutually compatible */
261 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
262 err |= -EINVAL; /* scan period would be 0 */
267 /* Step 3: check if arguments are trivially valid */
269 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
271 if (cmd->convert_src == TRIG_NOW) {
272 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, 0);
273 } else { /* cmd->convert_src == TRIG_TIMER */
274 if (cmd->scan_begin_src == TRIG_FOLLOW) {
275 err |= comedi_check_trigger_arg_min(&cmd->convert_arg,
280 if (cmd->scan_begin_src == TRIG_FOLLOW) {
281 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
282 } else { /* cmd->scan_begin_src == TRIG_TIMER */
283 err |= comedi_check_trigger_arg_min(&cmd->scan_begin_arg,
287 err |= comedi_check_trigger_arg_min(&cmd->chanlist_len, 1);
288 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
291 if (cmd->stop_src == TRIG_COUNT)
292 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
293 else /* cmd->stop_src == TRIG_NONE */
294 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
299 /* step 4: fix up any arguments */
301 if (cmd->convert_src == TRIG_TIMER) {
302 /* round convert_arg to nearest microsecond */
303 arg = cmd->convert_arg;
305 rounddown(UINT_MAX, (unsigned int)NSEC_PER_USEC));
306 arg = NSEC_PER_USEC * DIV_ROUND_CLOSEST(arg, NSEC_PER_USEC);
307 if (cmd->scan_begin_arg == TRIG_TIMER) {
308 /* limit convert_arg to keep scan_begin_arg in range */
309 limit = UINT_MAX / cmd->scan_end_arg;
310 limit = rounddown(limit, (unsigned int)NSEC_PER_SEC);
311 arg = min(arg, limit);
313 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
316 if (cmd->scan_begin_src == TRIG_TIMER) {
317 /* round scan_begin_arg to nearest microsecond */
318 arg = cmd->scan_begin_arg;
320 rounddown(UINT_MAX, (unsigned int)NSEC_PER_USEC));
321 arg = NSEC_PER_USEC * DIV_ROUND_CLOSEST(arg, NSEC_PER_USEC);
322 if (cmd->convert_src == TRIG_TIMER) {
323 /* but ensure scan_begin_arg is large enough */
324 arg = max(arg, cmd->convert_arg * cmd->scan_end_arg);
326 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
335 static int waveform_ai_cmd(struct comedi_device *dev,
336 struct comedi_subdevice *s)
338 struct waveform_private *devpriv = dev->private;
339 struct comedi_cmd *cmd = &s->async->cmd;
341 if (cmd->flags & CMDF_PRIORITY) {
342 dev_err(dev->class_dev,
343 "commands at RT priority not supported in this driver\n");
347 if (cmd->convert_src == TRIG_NOW)
348 devpriv->convert_period = 0;
349 else /* cmd->convert_src == TRIG_TIMER */
350 devpriv->convert_period = cmd->convert_arg / NSEC_PER_USEC;
352 if (cmd->scan_begin_src == TRIG_FOLLOW) {
353 devpriv->scan_period = devpriv->convert_period *
355 } else { /* cmd->scan_begin_src == TRIG_TIMER */
356 devpriv->scan_period = cmd->scan_begin_arg / NSEC_PER_USEC;
359 devpriv->last = ktime_get();
360 devpriv->usec_current =
361 ((u32)ktime_to_us(devpriv->last)) % devpriv->usec_period;
362 devpriv->usec_remainder = 0;
364 devpriv->timer.expires = jiffies + 1;
365 /* mark command as active */
366 smp_mb__before_atomic();
367 set_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits);
368 smp_mb__after_atomic();
369 add_timer(&devpriv->timer);
373 static int waveform_ai_cancel(struct comedi_device *dev,
374 struct comedi_subdevice *s)
376 struct waveform_private *devpriv = dev->private;
378 /* mark command as no longer active */
379 clear_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits);
380 smp_mb__after_atomic();
381 /* cannot call del_timer_sync() as may be called from timer routine */
382 del_timer(&devpriv->timer);
386 static int waveform_ai_insn_read(struct comedi_device *dev,
387 struct comedi_subdevice *s,
388 struct comedi_insn *insn, unsigned int *data)
390 struct waveform_private *devpriv = dev->private;
391 int i, chan = CR_CHAN(insn->chanspec);
393 for (i = 0; i < insn->n; i++)
394 data[i] = devpriv->ao_loopbacks[chan];
399 static int waveform_ao_insn_write(struct comedi_device *dev,
400 struct comedi_subdevice *s,
401 struct comedi_insn *insn, unsigned int *data)
403 struct waveform_private *devpriv = dev->private;
404 int i, chan = CR_CHAN(insn->chanspec);
406 for (i = 0; i < insn->n; i++)
407 devpriv->ao_loopbacks[chan] = data[i];
412 static int waveform_attach(struct comedi_device *dev,
413 struct comedi_devconfig *it)
415 struct waveform_private *devpriv;
416 struct comedi_subdevice *s;
417 int amplitude = it->options[0];
418 int period = it->options[1];
422 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
426 /* set default amplitude and period */
428 amplitude = 1000000; /* 1 volt */
430 period = 100000; /* 0.1 sec */
432 devpriv->uvolt_amplitude = amplitude;
433 devpriv->usec_period = period;
435 ret = comedi_alloc_subdevices(dev, 2);
439 s = &dev->subdevices[0];
440 dev->read_subdev = s;
441 /* analog input subdevice */
442 s->type = COMEDI_SUBD_AI;
443 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
446 s->range_table = &waveform_ai_ranges;
447 s->len_chanlist = s->n_chan * 2;
448 s->insn_read = waveform_ai_insn_read;
449 s->do_cmd = waveform_ai_cmd;
450 s->do_cmdtest = waveform_ai_cmdtest;
451 s->cancel = waveform_ai_cancel;
453 s = &dev->subdevices[1];
454 dev->write_subdev = s;
455 /* analog output subdevice (loopback) */
456 s->type = COMEDI_SUBD_AO;
457 s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
460 s->range_table = &waveform_ai_ranges;
461 s->insn_write = waveform_ao_insn_write;
463 /* Our default loopback value is just a 0V flatline */
464 for (i = 0; i < s->n_chan; i++)
465 devpriv->ao_loopbacks[i] = s->maxdata / 2;
467 setup_timer(&devpriv->timer, waveform_ai_interrupt,
470 dev_info(dev->class_dev,
471 "%s: %u microvolt, %u microsecond waveform attached\n",
473 devpriv->uvolt_amplitude, devpriv->usec_period);
478 static void waveform_detach(struct comedi_device *dev)
480 struct waveform_private *devpriv = dev->private;
483 del_timer_sync(&devpriv->timer);
486 static struct comedi_driver waveform_driver = {
487 .driver_name = "comedi_test",
488 .module = THIS_MODULE,
489 .attach = waveform_attach,
490 .detach = waveform_detach,
492 module_comedi_driver(waveform_driver);
494 MODULE_AUTHOR("Comedi http://www.comedi.org");
495 MODULE_DESCRIPTION("Comedi low-level driver");
496 MODULE_LICENSE("GPL");