[deliverable/linux.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.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

************************************************************************/
/*
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 "../comedidev.h"

#include <asm/div64.h>

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

#define N_CHANS 8

/* Data unique to this driver */
struct waveform_private {
	struct timer_list timer;
	struct timeval last;	/* time at which 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 (modulo waveform period) */
	unsigned long usec_remainder;	/* usec since last scan; */
	unsigned long ai_count;	/* number of conversions remaining */
	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 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 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 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 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);
		break;
	case SQUARE_CHAN:
		return fake_squarewave(dev, range, current_time);
		break;
	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_async *async = dev->read_subdev->async;
	struct comedi_cmd *cmd = &async->cmd;
	unsigned int i, j;
	/* all times in microsec */
	unsigned long elapsed_time;
	unsigned int num_scans;
	struct timeval now;
	bool stopping = false;

	do_gettimeofday(&now);

	elapsed_time =
	    1000000 * (now.tv_sec - devpriv->last.tv_sec) + now.tv_usec -
	    devpriv->last.tv_usec;
	devpriv->last = now;
	num_scans =
	    (devpriv->usec_remainder + elapsed_time) / devpriv->scan_period;
	devpriv->usec_remainder =
	    (devpriv->usec_remainder + elapsed_time) % devpriv->scan_period;
	async->events = 0;

	if (cmd->stop_src == TRIG_COUNT) {
		unsigned int remaining = cmd->stop_arg - devpriv->ai_count;
		if (num_scans >= remaining) {
			/* about to finish */
			num_scans = remaining;
			stopping = true;
		}
	}

	for (i = 0; i < num_scans; i++) {
		for (j = 0; j < cmd->chanlist_len; j++) {
			cfc_write_to_buffer(dev->read_subdev,
					    fake_waveform(dev,
							  CR_CHAN(cmd->
								  chanlist[j]),
							  CR_RANGE(cmd->
								   chanlist[j]),
							  devpriv->
							  usec_current +
							  i *
							  devpriv->scan_period +
							  j *
							  devpriv->
							  convert_period));
		}
	}

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

	if (stopping)
		async->events |= COMEDI_CB_EOA;
	else
		mod_timer(&devpriv->timer, jiffies + 1);

	comedi_event(dev, dev->read_subdev);
}

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

	/* 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) {
		tmp = cmd->scan_begin_arg;
		/* round to nearest microsec */
		cmd->scan_begin_arg =
		    nano_per_micro * ((tmp +
				       (nano_per_micro / 2)) / nano_per_micro);
		if (tmp != cmd->scan_begin_arg)
			err++;
	}
	if (cmd->convert_src == TRIG_TIMER) {
		tmp = cmd->convert_arg;
		/* round to nearest microsec */
		cmd->convert_arg =
		    nano_per_micro * ((tmp +
				       (nano_per_micro / 2)) / nano_per_micro);
		if (tmp != cmd->convert_arg)
			err++;
	}

	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 & TRIG_RT) {
		comedi_error(dev,
			     "commands at RT priority not supported in this driver");
		return -1;
	}

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

	if (cmd->convert_src == TRIG_NOW)
		devpriv->convert_period = 0;
	else if (cmd->convert_src == TRIG_TIMER)
		devpriv->convert_period = cmd->convert_arg / nano_per_micro;
	else {
		comedi_error(dev, "bug setting conversion period");
		return -1;
	}

	do_gettimeofday(&devpriv->last);
	devpriv->usec_current = devpriv->last.tv_usec % devpriv->usec_period;
	devpriv->usec_remainder = 0;

	devpriv->timer.expires = jiffies + 1;
	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;

	del_timer_sync(&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;

	dev->board_name = dev->driver->driver_name;

	devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
	if (!devpriv)
		return -ENOMEM;
	dev->private = devpriv;

	/* 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_WRITEABLE | SDF_GROUND;
	s->n_chan = N_CHANS;
	s->maxdata = 0xffff;
	s->range_table = &waveform_ai_ranges;
	s->len_chanlist = s->n_chan * 2;
	s->insn_write = waveform_ao_insn_write;
	s->do_cmd = NULL;
	s->do_cmdtest = NULL;
	s->cancel = NULL;

	/* 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)
		waveform_ai_cancel(dev, dev->read_subdev);
}

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