[linux-2.6-block.git] / drivers / staging / comedi / drivers / comedi_test.c

/*
    comedi/drivers/comedi_test.c

    Generates fake waveform signals that can be read through
    the command interface.  It does _not_ read from any board;
    it just generates deterministic waveforms.
    Useful for various testing purposes.

    Copyright (C) 2002 Joachim Wuttke <Joachim.Wuttke@icn.siemens.de>
    Copyright (C) 2002 Frank Mori Hess <fmhess@users.sourceforge.net>

    COMEDI - Linux Control and Measurement Device Interface
    Copyright (C) 2000 David A. Schleef <ds@schleef.org>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
*/
/*
Driver: comedi_test
Description: generates fake waveforms
Author: Joachim Wuttke <Joachim.Wuttke@icn.siemens.de>, Frank Mori Hess
  <fmhess@users.sourceforge.net>, ds
Devices:
Status: works
Updated: Sat, 16 Mar 2002 17:34:48 -0800

This driver is mainly for testing purposes, but can also be used to
generate sample waveforms on systems that don't have data acquisition
hardware.

Configuration options:
  [0] - Amplitude in microvolts for fake waveforms (default 1 volt)
  [1] - Period in microseconds for fake waveforms (default 0.1 sec)

Generates a sawtooth wave on channel 0, square wave on channel 1, additional
waveforms could be added to other channels (currently they return flatline
zero volts).

*/

#include <linux/module.h>
#include "../comedidev.h"

#include <asm/div64.h>

#include "comedi_fc.h"
#include <linux/timer.h>
#include <linux/ktime.h>

#define N_CHANS 8

enum waveform_state_bits {
	WAVEFORM_AI_RUNNING = 0
};

/* Data unique to this driver */
struct waveform_private {
	struct timer_list timer;
	ktime_t last;	/* time last timer interrupt occurred */
	unsigned int uvolt_amplitude;	/* waveform amplitude in microvolts */
	unsigned long usec_period;	/* waveform period in microseconds */
	unsigned long usec_current;	/* current time (mod waveform period) */
	unsigned long usec_remainder;	/* usec since last scan */
	unsigned long state_bits;
	unsigned int scan_period;	/* scan period in usec */
	unsigned int convert_period;	/* conversion period in usec */
	unsigned int ao_loopbacks[N_CHANS];
};

/* 1000 nanosec in a microsec */
static const int nano_per_micro = 1000;

/* fake analog input ranges */
static const struct comedi_lrange waveform_ai_ranges = {
	2, {
		BIP_RANGE(10),
		BIP_RANGE(5)
	}
};

static unsigned short fake_sawtooth(struct comedi_device *dev,
				    unsigned int range_index,
				    unsigned long current_time)
{
	struct waveform_private *devpriv = dev->private;
	struct comedi_subdevice *s = dev->read_subdev;
	unsigned int offset = s->maxdata / 2;
	u64 value;
	const struct comedi_krange *krange =
	    &s->range_table->range[range_index];
	u64 binary_amplitude;

	binary_amplitude = s->maxdata;
	binary_amplitude *= devpriv->uvolt_amplitude;
	do_div(binary_amplitude, krange->max - krange->min);

	current_time %= devpriv->usec_period;
	value = current_time;
	value *= binary_amplitude * 2;
	do_div(value, devpriv->usec_period);
	value -= binary_amplitude;	/* get rid of sawtooth's dc offset */

	return offset + value;
}

static unsigned short fake_squarewave(struct comedi_device *dev,
				      unsigned int range_index,
				      unsigned long current_time)
{
	struct waveform_private *devpriv = dev->private;
	struct comedi_subdevice *s = dev->read_subdev;
	unsigned int offset = s->maxdata / 2;
	u64 value;
	const struct comedi_krange *krange =
	    &s->range_table->range[range_index];
	current_time %= devpriv->usec_period;

	value = s->maxdata;
	value *= devpriv->uvolt_amplitude;
	do_div(value, krange->max - krange->min);

	if (current_time < devpriv->usec_period / 2)
		value *= -1;

	return offset + value;
}

static unsigned short fake_flatline(struct comedi_device *dev,
				    unsigned int range_index,
				    unsigned long current_time)
{
	return dev->read_subdev->maxdata / 2;
}

/* generates a different waveform depending on what channel is read */
static unsigned short fake_waveform(struct comedi_device *dev,
				    unsigned int channel, unsigned int range,
				    unsigned long current_time)
{
	enum {
		SAWTOOTH_CHAN,
		SQUARE_CHAN,
	};
	switch (channel) {
	case SAWTOOTH_CHAN:
		return fake_sawtooth(dev, range, current_time);
	case SQUARE_CHAN:
		return fake_squarewave(dev, range, current_time);
	default:
		break;
	}

	return fake_flatline(dev, range, current_time);
}

/*
   This is the background routine used to generate arbitrary data.
   It should run in the background; therefore it is scheduled by
   a timer mechanism.
*/
static void waveform_ai_interrupt(unsigned long arg)
{
	struct comedi_device *dev = (struct comedi_device *)arg;
	struct waveform_private *devpriv = dev->private;
	struct comedi_subdevice *s = dev->read_subdev;
	struct comedi_async *async = s->async;
	struct comedi_cmd *cmd = &async->cmd;
	unsigned int i, j;
	/* all times in microsec */
	unsigned long elapsed_time;
	unsigned int num_scans;
	ktime_t now;

	/* check command is still active */
	if (!test_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits))
		return;

	now = ktime_get();

	elapsed_time = ktime_to_us(ktime_sub(now, devpriv->last));
	devpriv->last = now;
	num_scans =
	    (devpriv->usec_remainder + elapsed_time) / devpriv->scan_period;
	devpriv->usec_remainder =
	    (devpriv->usec_remainder + elapsed_time) % devpriv->scan_period;

	num_scans = comedi_nscans_left(s, num_scans);
	for (i = 0; i < num_scans; i++) {
		for (j = 0; j < cmd->chanlist_len; j++) {
			unsigned short sample;

			sample = fake_waveform(dev, CR_CHAN(cmd->chanlist[j]),
					       CR_RANGE(cmd->chanlist[j]),
					       devpriv->usec_current +
						   i * devpriv->scan_period +
						   j * devpriv->convert_period);
			comedi_buf_write_samples(s, &sample, 1);
		}
	}

	devpriv->usec_current += elapsed_time;
	devpriv->usec_current %= devpriv->usec_period;

	if (cmd->stop_src == TRIG_COUNT && async->scans_done >= cmd->stop_arg)
		async->events |= COMEDI_CB_EOA;
	else
		mod_timer(&devpriv->timer, jiffies + 1);

	comedi_handle_events(dev, s);
}

static int waveform_ai_cmdtest(struct comedi_device *dev,
			       struct comedi_subdevice *s,
			       struct comedi_cmd *cmd)
{
	int err = 0;
	unsigned int arg;

	/* Step 1 : check if triggers are trivially valid */

	err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
	err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
	err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW | TRIG_TIMER);
	err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
	err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);

	if (err)
		return 1;

	/* Step 2a : make sure trigger sources are unique */

	err |= cfc_check_trigger_is_unique(cmd->convert_src);
	err |= cfc_check_trigger_is_unique(cmd->stop_src);

	/* Step 2b : and mutually compatible */

	if (err)
		return 2;

	/* Step 3: check if arguments are trivially valid */

	err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);

	if (cmd->convert_src == TRIG_NOW)
		err |= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);

	if (cmd->scan_begin_src == TRIG_TIMER) {
		err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
						 nano_per_micro);
		if (cmd->convert_src == TRIG_TIMER)
			err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
					cmd->convert_arg * cmd->chanlist_len);
	}

	err |= cfc_check_trigger_arg_min(&cmd->chanlist_len, 1);
	err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);

	if (cmd->stop_src == TRIG_COUNT)
		err |= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
	else	/* TRIG_NONE */
		err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);

	if (err)
		return 3;

	/* step 4: fix up any arguments */

	if (cmd->scan_begin_src == TRIG_TIMER) {
		arg = cmd->scan_begin_arg;
		/* round to nearest microsec */
		arg = nano_per_micro *
		      ((arg + (nano_per_micro / 2)) / nano_per_micro);
		err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
	}
	if (cmd->convert_src == TRIG_TIMER) {
		arg = cmd->convert_arg;
		/* round to nearest microsec */
		arg = nano_per_micro *
		      ((arg + (nano_per_micro / 2)) / nano_per_micro);
		err |= cfc_check_trigger_arg_is(&cmd->convert_arg, arg);
	}

	if (err)
		return 4;

	return 0;
}

static int waveform_ai_cmd(struct comedi_device *dev,
			   struct comedi_subdevice *s)
{
	struct waveform_private *devpriv = dev->private;
	struct comedi_cmd *cmd = &s->async->cmd;

	if (cmd->flags & CMDF_PRIORITY) {
		dev_err(dev->class_dev,
			"commands at RT priority not supported in this driver\n");
		return -1;
	}

	devpriv->scan_period = cmd->scan_begin_arg / nano_per_micro;

	if (cmd->convert_src == TRIG_NOW)
		devpriv->convert_period = 0;
	else	/* TRIG_TIMER */
		devpriv->convert_period = cmd->convert_arg / nano_per_micro;

	devpriv->last = ktime_get();
	devpriv->usec_current =
		((u32)ktime_to_us(devpriv->last)) % devpriv->usec_period;
	devpriv->usec_remainder = 0;

	devpriv->timer.expires = jiffies + 1;
	/* mark command as active */
	smp_mb__before_atomic();
	set_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits);
	smp_mb__after_atomic();
	add_timer(&devpriv->timer);
	return 0;
}

static int waveform_ai_cancel(struct comedi_device *dev,
			      struct comedi_subdevice *s)
{
	struct waveform_private *devpriv = dev->private;

	/* mark command as no longer active */
	clear_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits);
	smp_mb__after_atomic();
	/* cannot call del_timer_sync() as may be called from timer routine */
	del_timer(&devpriv->timer);
	return 0;
}

static int waveform_ai_insn_read(struct comedi_device *dev,
				 struct comedi_subdevice *s,
				 struct comedi_insn *insn, unsigned int *data)
{
	struct waveform_private *devpriv = dev->private;
	int i, chan = CR_CHAN(insn->chanspec);

	for (i = 0; i < insn->n; i++)
		data[i] = devpriv->ao_loopbacks[chan];

	return insn->n;
}

static int waveform_ao_insn_write(struct comedi_device *dev,
				  struct comedi_subdevice *s,
				  struct comedi_insn *insn, unsigned int *data)
{
	struct waveform_private *devpriv = dev->private;
	int i, chan = CR_CHAN(insn->chanspec);

	for (i = 0; i < insn->n; i++)
		devpriv->ao_loopbacks[chan] = data[i];

	return insn->n;
}

static int waveform_attach(struct comedi_device *dev,
			   struct comedi_devconfig *it)
{
	struct waveform_private *devpriv;
	struct comedi_subdevice *s;
	int amplitude = it->options[0];
	int period = it->options[1];
	int i;
	int ret;

	devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
	if (!devpriv)
		return -ENOMEM;

	/* set default amplitude and period */
	if (amplitude <= 0)
		amplitude = 1000000;	/* 1 volt */
	if (period <= 0)
		period = 100000;	/* 0.1 sec */

	devpriv->uvolt_amplitude = amplitude;
	devpriv->usec_period = period;

	ret = comedi_alloc_subdevices(dev, 2);
	if (ret)
		return ret;

	s = &dev->subdevices[0];
	dev->read_subdev = s;
	/* analog input subdevice */
	s->type = COMEDI_SUBD_AI;
	s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
	s->n_chan = N_CHANS;
	s->maxdata = 0xffff;
	s->range_table = &waveform_ai_ranges;
	s->len_chanlist = s->n_chan * 2;
	s->insn_read = waveform_ai_insn_read;
	s->do_cmd = waveform_ai_cmd;
	s->do_cmdtest = waveform_ai_cmdtest;
	s->cancel = waveform_ai_cancel;

	s = &dev->subdevices[1];
	dev->write_subdev = s;
	/* analog output subdevice (loopback) */
	s->type = COMEDI_SUBD_AO;
	s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
	s->n_chan = N_CHANS;
	s->maxdata = 0xffff;
	s->range_table = &waveform_ai_ranges;
	s->insn_write = waveform_ao_insn_write;

	/* Our default loopback value is just a 0V flatline */
	for (i = 0; i < s->n_chan; i++)
		devpriv->ao_loopbacks[i] = s->maxdata / 2;

	init_timer(&devpriv->timer);
	devpriv->timer.function = waveform_ai_interrupt;
	devpriv->timer.data = (unsigned long)dev;

	dev_info(dev->class_dev,
		 "%s: %i microvolt, %li microsecond waveform attached\n",
		 dev->board_name,
		 devpriv->uvolt_amplitude, devpriv->usec_period);

	return 0;
}

static void waveform_detach(struct comedi_device *dev)
{
	struct waveform_private *devpriv = dev->private;

	if (devpriv)
		del_timer_sync(&devpriv->timer);
}

static struct comedi_driver waveform_driver = {
	.driver_name	= "comedi_test",
	.module		= THIS_MODULE,
	.attach		= waveform_attach,
	.detach		= waveform_detach,
};
module_comedi_driver(waveform_driver);

MODULE_AUTHOR("Comedi http://www.comedi.org");
MODULE_DESCRIPTION("Comedi low-level driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
498460eb JW	1	/*
	2	comedi/drivers/comedi_test.c
	3
	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.
	8
	9	Copyright (C) 2002 Joachim Wuttke <Joachim.Wuttke@icn.siemens.de>
	10	Copyright (C) 2002 Frank Mori Hess <fmhess@users.sourceforge.net>
	11
	12	COMEDI - Linux Control and Measurement Device Interface
	13	Copyright (C) 2000 David A. Schleef <ds@schleef.org>
	14
	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.
	19
	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.
641f064e	24	*/
498460eb JW	25	/*
	26	Driver: comedi_test
	27	Description: generates fake waveforms
	28	Author: Joachim Wuttke <Joachim.Wuttke@icn.siemens.de>, Frank Mori Hess
	29	<fmhess@users.sourceforge.net>, ds
	30	Devices:
	31	Status: works
	32	Updated: Sat, 16 Mar 2002 17:34:48 -0800
	33
	34	This driver is mainly for testing purposes, but can also be used to
	35	generate sample waveforms on systems that don't have data acquisition
	36	hardware.
	37
	38	Configuration options:
	39	[0] - Amplitude in microvolts for fake waveforms (default 1 volt)
	40	[1] - Period in microseconds for fake waveforms (default 0.1 sec)
	41
	42	Generates a sawtooth wave on channel 0, square wave on channel 1, additional
	43	waveforms could be added to other channels (currently they return flatline
	44	zero volts).
	45
	46	*/
	47
ce157f80	48	#include <linux/module.h>
498460eb JW	49	#include "../comedidev.h"
	50
	51	#include <asm/div64.h>
	52
	53	#include "comedi_fc.h"
de4545cd	54	#include <linux/timer.h>
dd28153b	55	#include <linux/ktime.h>
498460eb	56
498460eb JW	57	#define N_CHANS 8
498460eb JW	58
73e0e4df IA	59	enum waveform_state_bits {
	60	WAVEFORM_AI_RUNNING = 0
	61	};
	62
498460eb	63	/* Data unique to this driver */
8c49292f	64	struct waveform_private {
498460eb	65	struct timer_list timer;
dd28153b	66	ktime_t last; /* time last timer interrupt occurred */
1be0e3ed GKH	67	unsigned int uvolt_amplitude; /* waveform amplitude in microvolts */
1be0e3ed GKH	68	unsigned long usec_period; /* waveform period in microseconds */
ae6eee39 IA	69	unsigned long usec_current; /* current time (mod waveform period) */
ae6eee39 IA	70	unsigned long usec_remainder; /* usec since last scan */
73e0e4df	71	unsigned long state_bits;
1be0e3ed GKH	72	unsigned int scan_period; /* scan period in usec */
1be0e3ed GKH	73	unsigned int convert_period; /* conversion period in usec */
790c5541	74	unsigned int ao_loopbacks[N_CHANS];
8c49292f	75	};
498460eb	76
1be0e3ed GKH	77	/* 1000 nanosec in a microsec */
	78	static const int nano_per_micro = 1000;
	79
	80	/* fake analog input ranges */
9ced1de6	81	static const struct comedi_lrange waveform_ai_ranges = {
c7b51165 HS	82	2, {
	83	BIP_RANGE(10),
	84	BIP_RANGE(5)
	85	}
498460eb JW	86	};
498460eb JW	87
8bd48c9e IA	88	static unsigned short fake_sawtooth(struct comedi_device *dev,
	89	unsigned int range_index,
	90	unsigned long current_time)
0eb0f278	91	{
f1e5aa75	92	struct waveform_private *devpriv = dev->private;
0eb0f278 HS	93	struct comedi_subdevice *s = dev->read_subdev;
	94	unsigned int offset = s->maxdata / 2;
	95	u64 value;
	96	const struct comedi_krange *krange =
	97	&s->range_table->range[range_index];
	98	u64 binary_amplitude;
	99
	100	binary_amplitude = s->maxdata;
	101	binary_amplitude *= devpriv->uvolt_amplitude;
	102	do_div(binary_amplitude, krange->max - krange->min);
	103
	104	current_time %= devpriv->usec_period;
	105	value = current_time;
	106	value = binary_amplitude 2;
	107	do_div(value, devpriv->usec_period);
	108	value -= binary_amplitude; /* get rid of sawtooth's dc offset */
	109
	110	return offset + value;
	111	}
	112
8bd48c9e IA	113	static unsigned short fake_squarewave(struct comedi_device *dev,
	114	unsigned int range_index,
	115	unsigned long current_time)
0eb0f278	116	{
f1e5aa75	117	struct waveform_private *devpriv = dev->private;
0eb0f278 HS	118	struct comedi_subdevice *s = dev->read_subdev;
	119	unsigned int offset = s->maxdata / 2;
	120	u64 value;
	121	const struct comedi_krange *krange =
	122	&s->range_table->range[range_index];
	123	current_time %= devpriv->usec_period;
	124
	125	value = s->maxdata;
	126	value *= devpriv->uvolt_amplitude;
	127	do_div(value, krange->max - krange->min);
	128
	129	if (current_time < devpriv->usec_period / 2)
	130	value *= -1;
	131
	132	return offset + value;
	133	}
	134
8bd48c9e IA	135	static unsigned short fake_flatline(struct comedi_device *dev,
	136	unsigned int range_index,
	137	unsigned long current_time)
0eb0f278 HS	138	{
	139	return dev->read_subdev->maxdata / 2;
	140	}
	141
	142	/* generates a different waveform depending on what channel is read */
8bd48c9e IA	143	static unsigned short fake_waveform(struct comedi_device *dev,
	144	unsigned int channel, unsigned int range,
	145	unsigned long current_time)
0eb0f278 HS	146	{
	147	enum {
	148	SAWTOOTH_CHAN,
	149	SQUARE_CHAN,
	150	};
	151	switch (channel) {
	152	case SAWTOOTH_CHAN:
	153	return fake_sawtooth(dev, range, current_time);
0eb0f278 HS	154	case SQUARE_CHAN:
0eb0f278 HS	155	return fake_squarewave(dev, range, current_time);
0eb0f278 HS	156	default:
	157	break;
	158	}
	159
	160	return fake_flatline(dev, range, current_time);
	161	}
	162
498460eb JW	163	/*
	164	This is the background routine used to generate arbitrary data.
	165	It should run in the background; therefore it is scheduled by
	166	a timer mechanism.
	167	*/
	168	static void waveform_ai_interrupt(unsigned long arg)
	169	{
0a85b6f0	170	struct comedi_device dev = (struct comedi_device )arg;
f1e5aa75	171	struct waveform_private *devpriv = dev->private;
24051247 HS	172	struct comedi_subdevice *s = dev->read_subdev;
24051247 HS	173	struct comedi_async *async = s->async;
ea6d0d4c	174	struct comedi_cmd *cmd = &async->cmd;
498460eb	175	unsigned int i, j;
1be0e3ed	176	/* all times in microsec */
498460eb JW	177	unsigned long elapsed_time;
498460eb JW	178	unsigned int num_scans;
dd28153b	179	ktime_t now;
498460eb	180
73e0e4df IA	181	/* check command is still active */
	182	if (!test_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits))
	183	return;
	184
dd28153b	185	now = ktime_get();
498460eb	186
dd28153b	187	elapsed_time = ktime_to_us(ktime_sub(now, devpriv->last));
498460eb JW	188	devpriv->last = now;
498460eb JW	189	num_scans =
0a85b6f0	190	(devpriv->usec_remainder + elapsed_time) / devpriv->scan_period;
498460eb	191	devpriv->usec_remainder =
0a85b6f0	192	(devpriv->usec_remainder + elapsed_time) % devpriv->scan_period;
498460eb	193
f5345d45	194	num_scans = comedi_nscans_left(s, num_scans);
498460eb JW	195	for (i = 0; i < num_scans; i++) {
498460eb JW	196	for (j = 0; j < cmd->chanlist_len; j++) {
0642c94b	197	unsigned short sample;
33bd00ef	198
0642c94b IA	199	sample = fake_waveform(dev, CR_CHAN(cmd->chanlist[j]),
	200	CR_RANGE(cmd->chanlist[j]),
	201	devpriv->usec_current +
	202	i * devpriv->scan_period +
	203	j * devpriv->convert_period);
88f9662a	204	comedi_buf_write_samples(s, &sample, 1);
498460eb	205	}
498460eb JW	206	}
	207
	208	devpriv->usec_current += elapsed_time;
	209	devpriv->usec_current %= devpriv->usec_period;
	210
f5345d45	211	if (cmd->stop_src == TRIG_COUNT && async->scans_done >= cmd->stop_arg)
ea4f72b2 IA	212	async->events \|= COMEDI_CB_EOA;
ea4f72b2 IA	213	else
498460eb	214	mod_timer(&devpriv->timer, jiffies + 1);
498460eb	215
24051247	216	comedi_handle_events(dev, s);
498460eb JW	217	}
498460eb JW	218
0a85b6f0 MT	219	static int waveform_ai_cmdtest(struct comedi_device *dev,
0a85b6f0 MT	220	struct comedi_subdevice *s,
ea6d0d4c	221	struct comedi_cmd *cmd)
498460eb JW	222	{
498460eb JW	223	int err = 0;
b2ef4813	224	unsigned int arg;
498460eb	225
27020ffe	226	/* Step 1 : check if triggers are trivially valid */
498460eb	227
27020ffe HS	228	err \|= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
	229	err \|= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
	230	err \|= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW \| TRIG_TIMER);
	231	err \|= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
	232	err \|= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT \| TRIG_NONE);
498460eb JW	233
	234	if (err)
	235	return 1;
	236
27020ffe	237	/* Step 2a : make sure trigger sources are unique */
498460eb	238
27020ffe HS	239	err \|= cfc_check_trigger_is_unique(cmd->convert_src);
	240	err \|= cfc_check_trigger_is_unique(cmd->stop_src);
	241
	242	/* Step 2b : and mutually compatible */
498460eb JW	243
	244	if (err)
	245	return 2;
	246
df5daff8 HS	247	/* Step 3: check if arguments are trivially valid */
	248
	249	err \|= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
	250
	251	if (cmd->convert_src == TRIG_NOW)
	252	err \|= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);
498460eb	253
498460eb	254	if (cmd->scan_begin_src == TRIG_TIMER) {
df5daff8 HS	255	err \|= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
	256	nano_per_micro);
	257	if (cmd->convert_src == TRIG_TIMER)
	258	err \|= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
	259	cmd->convert_arg * cmd->chanlist_len);
498460eb JW	260	}
498460eb JW	261
df5daff8 HS	262	err \|= cfc_check_trigger_arg_min(&cmd->chanlist_len, 1);
	263	err \|= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
	264
	265	if (cmd->stop_src == TRIG_COUNT)
	266	err \|= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
	267	else /* TRIG_NONE */
	268	err \|= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
498460eb JW	269
	270	if (err)
	271	return 3;
	272
	273	/* step 4: fix up any arguments */
	274
	275	if (cmd->scan_begin_src == TRIG_TIMER) {
b2ef4813	276	arg = cmd->scan_begin_arg;
1be0e3ed	277	/* round to nearest microsec */
b2ef4813 HS	278	arg = nano_per_micro *
	279	((arg + (nano_per_micro / 2)) / nano_per_micro);
	280	err \|= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
498460eb JW	281	}
498460eb JW	282	if (cmd->convert_src == TRIG_TIMER) {
b2ef4813	283	arg = cmd->convert_arg;
1be0e3ed	284	/* round to nearest microsec */
b2ef4813 HS	285	arg = nano_per_micro *
	286	((arg + (nano_per_micro / 2)) / nano_per_micro);
	287	err \|= cfc_check_trigger_arg_is(&cmd->convert_arg, arg);
498460eb JW	288	}
	289
	290	if (err)
	291	return 4;
	292
	293	return 0;
	294	}
	295
0a85b6f0 MT	296	static int waveform_ai_cmd(struct comedi_device *dev,
0a85b6f0 MT	297	struct comedi_subdevice *s)
498460eb	298	{
f1e5aa75	299	struct waveform_private *devpriv = dev->private;
ea6d0d4c	300	struct comedi_cmd *cmd = &s->async->cmd;
498460eb	301
51d66b29	302	if (cmd->flags & CMDF_PRIORITY) {
b8de3cc4 HS	303	dev_err(dev->class_dev,
b8de3cc4 HS	304	"commands at RT priority not supported in this driver\n");
498460eb JW	305	return -1;
	306	}
	307
498460eb JW	308	devpriv->scan_period = cmd->scan_begin_arg / nano_per_micro;
	309
	310	if (cmd->convert_src == TRIG_NOW)
	311	devpriv->convert_period = 0;
f45cc79a	312	else /* TRIG_TIMER */
498460eb	313	devpriv->convert_period = cmd->convert_arg / nano_per_micro;
498460eb	314
dd28153b SA	315	devpriv->last = ktime_get();
	316	devpriv->usec_current =
	317	((u32)ktime_to_us(devpriv->last)) % devpriv->usec_period;
498460eb JW	318	devpriv->usec_remainder = 0;
	319
	320	devpriv->timer.expires = jiffies + 1;
73e0e4df IA	321	/* mark command as active */
	322	smp_mb__before_atomic();
	323	set_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits);
	324	smp_mb__after_atomic();
498460eb JW	325	add_timer(&devpriv->timer);
	326	return 0;
	327	}
	328
0a85b6f0 MT	329	static int waveform_ai_cancel(struct comedi_device *dev,
0a85b6f0 MT	330	struct comedi_subdevice *s)
498460eb	331	{
f1e5aa75 HS	332	struct waveform_private *devpriv = dev->private;
f1e5aa75 HS	333
73e0e4df IA	334	/* mark command as no longer active */
	335	clear_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits);
	336	smp_mb__after_atomic();
	337	/* cannot call del_timer_sync() as may be called from timer routine */
	338	del_timer(&devpriv->timer);
498460eb JW	339	return 0;
	340	}
	341
0a85b6f0 MT	342	static int waveform_ai_insn_read(struct comedi_device *dev,
0a85b6f0 MT	343	struct comedi_subdevice *s,
90035c08	344	struct comedi_insn insn, unsigned int data)
498460eb	345	{
f1e5aa75	346	struct waveform_private *devpriv = dev->private;
498460eb JW	347	int i, chan = CR_CHAN(insn->chanspec);
	348
	349	for (i = 0; i < insn->n; i++)
	350	data[i] = devpriv->ao_loopbacks[chan];
	351
	352	return insn->n;
	353	}
	354
0a85b6f0 MT	355	static int waveform_ao_insn_write(struct comedi_device *dev,
0a85b6f0 MT	356	struct comedi_subdevice *s,
90035c08	357	struct comedi_insn insn, unsigned int data)
498460eb	358	{
f1e5aa75	359	struct waveform_private *devpriv = dev->private;
498460eb JW	360	int i, chan = CR_CHAN(insn->chanspec);
	361
	362	for (i = 0; i < insn->n; i++)
	363	devpriv->ao_loopbacks[chan] = data[i];
	364
	365	return insn->n;
	366	}
90f703d3	367
0eb0f278 HS	368	static int waveform_attach(struct comedi_device *dev,
	369	struct comedi_devconfig *it)
	370	{
f1e5aa75	371	struct waveform_private *devpriv;
0eb0f278 HS	372	struct comedi_subdevice *s;
	373	int amplitude = it->options[0];
	374	int period = it->options[1];
	375	int i;
8b6c5694	376	int ret;
0eb0f278	377
0bdab509	378	devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
c34fa261 HS	379	if (!devpriv)
c34fa261 HS	380	return -ENOMEM;
0eb0f278 HS	381
	382	/* set default amplitude and period */
	383	if (amplitude <= 0)
	384	amplitude = 1000000; /* 1 volt */
	385	if (period <= 0)
	386	period = 100000; /* 0.1 sec */
	387
	388	devpriv->uvolt_amplitude = amplitude;
	389	devpriv->usec_period = period;
	390
8b6c5694 HS	391	ret = comedi_alloc_subdevices(dev, 2);
	392	if (ret)
	393	return ret;
0eb0f278	394
713e5c35	395	s = &dev->subdevices[0];
0eb0f278 HS	396	dev->read_subdev = s;
	397	/* analog input subdevice */
	398	s->type = COMEDI_SUBD_AI;
	399	s->subdev_flags = SDF_READABLE \| SDF_GROUND \| SDF_CMD_READ;
b1da4943 HS	400	s->n_chan = N_CHANS;
b1da4943 HS	401	s->maxdata = 0xffff;
0eb0f278 HS	402	s->range_table = &waveform_ai_ranges;
	403	s->len_chanlist = s->n_chan * 2;
	404	s->insn_read = waveform_ai_insn_read;
	405	s->do_cmd = waveform_ai_cmd;
	406	s->do_cmdtest = waveform_ai_cmdtest;
	407	s->cancel = waveform_ai_cancel;
	408
713e5c35	409	s = &dev->subdevices[1];
0eb0f278 HS	410	dev->write_subdev = s;
	411	/* analog output subdevice (loopback) */
	412	s->type = COMEDI_SUBD_AO;
ef49d832	413	s->subdev_flags = SDF_WRITABLE \| SDF_GROUND;
b1da4943 HS	414	s->n_chan = N_CHANS;
b1da4943 HS	415	s->maxdata = 0xffff;
0eb0f278	416	s->range_table = &waveform_ai_ranges;
0eb0f278	417	s->insn_write = waveform_ao_insn_write;
0eb0f278 HS	418
	419	/* Our default loopback value is just a 0V flatline */
	420	for (i = 0; i < s->n_chan; i++)
	421	devpriv->ao_loopbacks[i] = s->maxdata / 2;
	422
9254c841	423	init_timer(&devpriv->timer);
0eb0f278 HS	424	devpriv->timer.function = waveform_ai_interrupt;
	425	devpriv->timer.data = (unsigned long)dev;
	426
9ac6eb40	427	dev_info(dev->class_dev,
9254c841 NS	428	"%s: %i microvolt, %li microsecond waveform attached\n",
	429	dev->board_name,
	430	devpriv->uvolt_amplitude, devpriv->usec_period);
9ac6eb40 HS	431
9ac6eb40 HS	432	return 0;
0eb0f278 HS	433	}
0eb0f278 HS	434
484ecc95	435	static void waveform_detach(struct comedi_device *dev)
0eb0f278	436	{
f1e5aa75 HS	437	struct waveform_private *devpriv = dev->private;
	438
	439	if (devpriv)
73e0e4df	440	del_timer_sync(&devpriv->timer);
0eb0f278 HS	441	}
0eb0f278 HS	442
0eb0f278 HS	443	static struct comedi_driver waveform_driver = {
	444	.driver_name = "comedi_test",
	445	.module = THIS_MODULE,
	446	.attach = waveform_attach,
	447	.detach = waveform_detach,
0eb0f278 HS	448	};
	449	module_comedi_driver(waveform_driver);
	450
90f703d3 AT	451	MODULE_AUTHOR("Comedi http://www.comedi.org");
	452	MODULE_DESCRIPTION("Comedi low-level driver");
	453	MODULE_LICENSE("GPL");