[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>
#include <linux/ktime.h>

#define N_CHANS 8

/* 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 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_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;
	bool stopping = false;

	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;

	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(s, 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_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->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;

	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;
	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>
dd28153b	55	#include <linux/ktime.h>
498460eb	56
498460eb JW	57	#define N_CHANS 8
498460eb JW	58
498460eb	59	/* Data unique to this driver */
8c49292f	60	struct waveform_private {
498460eb	61	struct timer_list timer;
dd28153b	62	ktime_t last; /* time last timer interrupt occurred */
1be0e3ed GKH	63	unsigned int uvolt_amplitude; /* waveform amplitude in microvolts */
1be0e3ed GKH	64	unsigned long usec_period; /* waveform period in microseconds */
ae6eee39 IA	65	unsigned long usec_current; /* current time (mod waveform period) */
	66	unsigned long usec_remainder; /* usec since last scan */
	67	unsigned long ai_count; /* number of conversions remaining */
1be0e3ed GKH	68	unsigned int scan_period; /* scan period in usec */
1be0e3ed GKH	69	unsigned int convert_period; /* conversion period in usec */
790c5541	70	unsigned int ao_loopbacks[N_CHANS];
8c49292f	71	};
498460eb	72
1be0e3ed GKH	73	/* 1000 nanosec in a microsec */
	74	static const int nano_per_micro = 1000;
	75
	76	/* fake analog input ranges */
9ced1de6	77	static const struct comedi_lrange waveform_ai_ranges = {
c7b51165 HS	78	2, {
	79	BIP_RANGE(10),
	80	BIP_RANGE(5)
	81	}
498460eb JW	82	};
498460eb JW	83
8bd48c9e IA	84	static unsigned short fake_sawtooth(struct comedi_device *dev,
	85	unsigned int range_index,
	86	unsigned long current_time)
0eb0f278	87	{
f1e5aa75	88	struct waveform_private *devpriv = dev->private;
0eb0f278 HS	89	struct comedi_subdevice *s = dev->read_subdev;
	90	unsigned int offset = s->maxdata / 2;
	91	u64 value;
	92	const struct comedi_krange *krange =
	93	&s->range_table->range[range_index];
	94	u64 binary_amplitude;
	95
	96	binary_amplitude = s->maxdata;
	97	binary_amplitude *= devpriv->uvolt_amplitude;
	98	do_div(binary_amplitude, krange->max - krange->min);
	99
	100	current_time %= devpriv->usec_period;
	101	value = current_time;
	102	value = binary_amplitude 2;
	103	do_div(value, devpriv->usec_period);
	104	value -= binary_amplitude; /* get rid of sawtooth's dc offset */
	105
	106	return offset + value;
	107	}
	108
8bd48c9e IA	109	static unsigned short fake_squarewave(struct comedi_device *dev,
	110	unsigned int range_index,
	111	unsigned long current_time)
0eb0f278	112	{
f1e5aa75	113	struct waveform_private *devpriv = dev->private;
0eb0f278 HS	114	struct comedi_subdevice *s = dev->read_subdev;
	115	unsigned int offset = s->maxdata / 2;
	116	u64 value;
	117	const struct comedi_krange *krange =
	118	&s->range_table->range[range_index];
	119	current_time %= devpriv->usec_period;
	120
	121	value = s->maxdata;
	122	value *= devpriv->uvolt_amplitude;
	123	do_div(value, krange->max - krange->min);
	124
	125	if (current_time < devpriv->usec_period / 2)
	126	value *= -1;
	127
	128	return offset + value;
	129	}
	130
8bd48c9e IA	131	static unsigned short fake_flatline(struct comedi_device *dev,
	132	unsigned int range_index,
	133	unsigned long current_time)
0eb0f278 HS	134	{
	135	return dev->read_subdev->maxdata / 2;
	136	}
	137
	138	/* generates a different waveform depending on what channel is read */
8bd48c9e IA	139	static unsigned short fake_waveform(struct comedi_device *dev,
	140	unsigned int channel, unsigned int range,
	141	unsigned long current_time)
0eb0f278 HS	142	{
	143	enum {
	144	SAWTOOTH_CHAN,
	145	SQUARE_CHAN,
	146	};
	147	switch (channel) {
	148	case SAWTOOTH_CHAN:
	149	return fake_sawtooth(dev, range, current_time);
0eb0f278 HS	150	case SQUARE_CHAN:
0eb0f278 HS	151	return fake_squarewave(dev, range, current_time);
0eb0f278 HS	152	default:
	153	break;
	154	}
	155
	156	return fake_flatline(dev, range, current_time);
	157	}
	158
498460eb JW	159	/*
	160	This is the background routine used to generate arbitrary data.
	161	It should run in the background; therefore it is scheduled by
	162	a timer mechanism.
	163	*/
	164	static void waveform_ai_interrupt(unsigned long arg)
	165	{
0a85b6f0	166	struct comedi_device dev = (struct comedi_device )arg;
f1e5aa75	167	struct waveform_private *devpriv = dev->private;
24051247 HS	168	struct comedi_subdevice *s = dev->read_subdev;
24051247 HS	169	struct comedi_async *async = s->async;
ea6d0d4c	170	struct comedi_cmd *cmd = &async->cmd;
498460eb	171	unsigned int i, j;
1be0e3ed	172	/* all times in microsec */
498460eb JW	173	unsigned long elapsed_time;
498460eb JW	174	unsigned int num_scans;
dd28153b	175	ktime_t now;
ea4f72b2	176	bool stopping = false;
498460eb	177
dd28153b	178	now = ktime_get();
498460eb	179
dd28153b	180	elapsed_time = ktime_to_us(ktime_sub(now, devpriv->last));
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);
24051247	206	cfc_write_to_buffer(s, 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	218
24051247	219	comedi_handle_events(dev, s);
498460eb JW	220	}
498460eb JW	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	304
51d66b29	305	if (cmd->flags & CMDF_PRIORITY) {
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	318
dd28153b SA	319	devpriv->last = ktime_get();
	320	devpriv->usec_current =
	321	((u32)ktime_to_us(devpriv->last)) % devpriv->usec_period;
498460eb JW	322	devpriv->usec_remainder = 0;
	323
	324	devpriv->timer.expires = jiffies + 1;
	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
0653bed6	334	del_timer_sync(&devpriv->timer);
498460eb JW	335	return 0;
	336	}
	337
0a85b6f0 MT	338	static int waveform_ai_insn_read(struct comedi_device *dev,
0a85b6f0 MT	339	struct comedi_subdevice *s,
90035c08	340	struct comedi_insn insn, unsigned int data)
498460eb	341	{
f1e5aa75	342	struct waveform_private *devpriv = dev->private;
498460eb JW	343	int i, chan = CR_CHAN(insn->chanspec);
	344
	345	for (i = 0; i < insn->n; i++)
	346	data[i] = devpriv->ao_loopbacks[chan];
	347
	348	return insn->n;
	349	}
	350
0a85b6f0 MT	351	static int waveform_ao_insn_write(struct comedi_device *dev,
0a85b6f0 MT	352	struct comedi_subdevice *s,
90035c08	353	struct comedi_insn insn, unsigned int data)
498460eb	354	{
f1e5aa75	355	struct waveform_private *devpriv = dev->private;
498460eb JW	356	int i, chan = CR_CHAN(insn->chanspec);
	357
	358	for (i = 0; i < insn->n; i++)
	359	devpriv->ao_loopbacks[chan] = data[i];
	360
	361	return insn->n;
	362	}
90f703d3	363
0eb0f278 HS	364	static int waveform_attach(struct comedi_device *dev,
	365	struct comedi_devconfig *it)
	366	{
f1e5aa75	367	struct waveform_private *devpriv;
0eb0f278 HS	368	struct comedi_subdevice *s;
	369	int amplitude = it->options[0];
	370	int period = it->options[1];
	371	int i;
8b6c5694	372	int ret;
0eb0f278	373
0bdab509	374	devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
c34fa261 HS	375	if (!devpriv)
c34fa261 HS	376	return -ENOMEM;
0eb0f278 HS	377
	378	/* set default amplitude and period */
	379	if (amplitude <= 0)
	380	amplitude = 1000000; /* 1 volt */
	381	if (period <= 0)
	382	period = 100000; /* 0.1 sec */
	383
	384	devpriv->uvolt_amplitude = amplitude;
	385	devpriv->usec_period = period;
	386
8b6c5694 HS	387	ret = comedi_alloc_subdevices(dev, 2);
	388	if (ret)
	389	return ret;
0eb0f278	390
713e5c35	391	s = &dev->subdevices[0];
0eb0f278 HS	392	dev->read_subdev = s;
	393	/* analog input subdevice */
	394	s->type = COMEDI_SUBD_AI;
	395	s->subdev_flags = SDF_READABLE \| SDF_GROUND \| SDF_CMD_READ;
b1da4943 HS	396	s->n_chan = N_CHANS;
b1da4943 HS	397	s->maxdata = 0xffff;
0eb0f278 HS	398	s->range_table = &waveform_ai_ranges;
	399	s->len_chanlist = s->n_chan * 2;
	400	s->insn_read = waveform_ai_insn_read;
	401	s->do_cmd = waveform_ai_cmd;
	402	s->do_cmdtest = waveform_ai_cmdtest;
	403	s->cancel = waveform_ai_cancel;
	404
713e5c35	405	s = &dev->subdevices[1];
0eb0f278 HS	406	dev->write_subdev = s;
	407	/* analog output subdevice (loopback) */
	408	s->type = COMEDI_SUBD_AO;
	409	s->subdev_flags = SDF_WRITEABLE \| SDF_GROUND;
b1da4943 HS	410	s->n_chan = N_CHANS;
b1da4943 HS	411	s->maxdata = 0xffff;
0eb0f278	412	s->range_table = &waveform_ai_ranges;
0eb0f278	413	s->insn_write = waveform_ao_insn_write;
0eb0f278 HS	414
	415	/* Our default loopback value is just a 0V flatline */
	416	for (i = 0; i < s->n_chan; i++)
	417	devpriv->ao_loopbacks[i] = s->maxdata / 2;
	418
9254c841	419	init_timer(&devpriv->timer);
0eb0f278 HS	420	devpriv->timer.function = waveform_ai_interrupt;
	421	devpriv->timer.data = (unsigned long)dev;
	422
9ac6eb40	423	dev_info(dev->class_dev,
9254c841 NS	424	"%s: %i microvolt, %li microsecond waveform attached\n",
	425	dev->board_name,
	426	devpriv->uvolt_amplitude, devpriv->usec_period);
9ac6eb40 HS	427
9ac6eb40 HS	428	return 0;
0eb0f278 HS	429	}
0eb0f278 HS	430
484ecc95	431	static void waveform_detach(struct comedi_device *dev)
0eb0f278	432	{
f1e5aa75 HS	433	struct waveform_private *devpriv = dev->private;
	434
	435	if (devpriv)
0eb0f278	436	waveform_ai_cancel(dev, dev->read_subdev);
0eb0f278 HS	437	}
0eb0f278 HS	438
0eb0f278 HS	439	static struct comedi_driver waveform_driver = {
	440	.driver_name = "comedi_test",
	441	.module = THIS_MODULE,
	442	.attach = waveform_attach,
	443	.detach = waveform_detach,
0eb0f278 HS	444	};
	445	module_comedi_driver(waveform_driver);
	446
90f703d3 AT	447	MODULE_AUTHOR("Comedi http://www.comedi.org");
	448	MODULE_DESCRIPTION("Comedi low-level driver");
	449	MODULE_LICENSE("GPL");