[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.
*/
/*
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>

#define N_CHANS 8

/* Data unique to this driver */
struct waveform_private {
	struct timer_list timer;
	struct timeval 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 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 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_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;

	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++) {
			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);
			cfc_write_to_buffer(dev->read_subdev, sample);
		}
	}

	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;
	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 & TRIG_RT) {
		dev_err(dev->class_dev,
			"commands at RT priority not supported in this driver\n");
		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	/* TRIG_TIMER */
		devpriv->convert_period = cmd->convert_arg / nano_per_micro;

	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;

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