[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

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 ai_count;		/* number of conversions remaining */
	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;
	bool stopping = false;

	/* 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;

	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);
			comedi_buf_write_samples(s, &sample, 1);
		}
	}

	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;
	/* 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) */
	70	unsigned long usec_remainder; /* usec since last scan */
	71	unsigned long ai_count; /* number of conversions remaining */
73e0e4df	72	unsigned long state_bits;
1be0e3ed GKH	73	unsigned int scan_period; /* scan period in usec */
1be0e3ed GKH	74	unsigned int convert_period; /* conversion period in usec */
790c5541	75	unsigned int ao_loopbacks[N_CHANS];
8c49292f	76	};
498460eb	77
1be0e3ed GKH	78	/* 1000 nanosec in a microsec */
	79	static const int nano_per_micro = 1000;
	80
	81	/* fake analog input ranges */
9ced1de6	82	static const struct comedi_lrange waveform_ai_ranges = {
c7b51165 HS	83	2, {
	84	BIP_RANGE(10),
	85	BIP_RANGE(5)
	86	}
498460eb JW	87	};
498460eb JW	88
8bd48c9e IA	89	static unsigned short fake_sawtooth(struct comedi_device *dev,
	90	unsigned int range_index,
	91	unsigned long current_time)
0eb0f278	92	{
f1e5aa75	93	struct waveform_private *devpriv = dev->private;
0eb0f278 HS	94	struct comedi_subdevice *s = dev->read_subdev;
	95	unsigned int offset = s->maxdata / 2;
	96	u64 value;
	97	const struct comedi_krange *krange =
	98	&s->range_table->range[range_index];
	99	u64 binary_amplitude;
	100
	101	binary_amplitude = s->maxdata;
	102	binary_amplitude *= devpriv->uvolt_amplitude;
	103	do_div(binary_amplitude, krange->max - krange->min);
	104
	105	current_time %= devpriv->usec_period;
	106	value = current_time;
	107	value = binary_amplitude 2;
	108	do_div(value, devpriv->usec_period);
	109	value -= binary_amplitude; /* get rid of sawtooth's dc offset */
	110
	111	return offset + value;
	112	}
	113
8bd48c9e IA	114	static unsigned short fake_squarewave(struct comedi_device *dev,
	115	unsigned int range_index,
	116	unsigned long current_time)
0eb0f278	117	{
f1e5aa75	118	struct waveform_private *devpriv = dev->private;
0eb0f278 HS	119	struct comedi_subdevice *s = dev->read_subdev;
	120	unsigned int offset = s->maxdata / 2;
	121	u64 value;
	122	const struct comedi_krange *krange =
	123	&s->range_table->range[range_index];
	124	current_time %= devpriv->usec_period;
	125
	126	value = s->maxdata;
	127	value *= devpriv->uvolt_amplitude;
	128	do_div(value, krange->max - krange->min);
	129
	130	if (current_time < devpriv->usec_period / 2)
	131	value *= -1;
	132
	133	return offset + value;
	134	}
	135
8bd48c9e IA	136	static unsigned short fake_flatline(struct comedi_device *dev,
	137	unsigned int range_index,
	138	unsigned long current_time)
0eb0f278 HS	139	{
	140	return dev->read_subdev->maxdata / 2;
	141	}
	142
	143	/* generates a different waveform depending on what channel is read */
8bd48c9e IA	144	static unsigned short fake_waveform(struct comedi_device *dev,
	145	unsigned int channel, unsigned int range,
	146	unsigned long current_time)
0eb0f278 HS	147	{
	148	enum {
	149	SAWTOOTH_CHAN,
	150	SQUARE_CHAN,
	151	};
	152	switch (channel) {
	153	case SAWTOOTH_CHAN:
	154	return fake_sawtooth(dev, range, current_time);
0eb0f278 HS	155	case SQUARE_CHAN:
0eb0f278 HS	156	return fake_squarewave(dev, range, current_time);
0eb0f278 HS	157	default:
	158	break;
	159	}
	160
	161	return fake_flatline(dev, range, current_time);
	162	}
	163
498460eb JW	164	/*
	165	This is the background routine used to generate arbitrary data.
	166	It should run in the background; therefore it is scheduled by
	167	a timer mechanism.
	168	*/
	169	static void waveform_ai_interrupt(unsigned long arg)
	170	{
0a85b6f0	171	struct comedi_device dev = (struct comedi_device )arg;
f1e5aa75	172	struct waveform_private *devpriv = dev->private;
24051247 HS	173	struct comedi_subdevice *s = dev->read_subdev;
24051247 HS	174	struct comedi_async *async = s->async;
ea6d0d4c	175	struct comedi_cmd *cmd = &async->cmd;
498460eb	176	unsigned int i, j;
1be0e3ed	177	/* all times in microsec */
498460eb JW	178	unsigned long elapsed_time;
498460eb JW	179	unsigned int num_scans;
dd28153b	180	ktime_t now;
ea4f72b2	181	bool stopping = false;
498460eb	182
73e0e4df IA	183	/* check command is still active */
	184	if (!test_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits))
	185	return;
	186
dd28153b	187	now = ktime_get();
498460eb	188
dd28153b	189	elapsed_time = ktime_to_us(ktime_sub(now, devpriv->last));
498460eb JW	190	devpriv->last = now;
498460eb JW	191	num_scans =
0a85b6f0	192	(devpriv->usec_remainder + elapsed_time) / devpriv->scan_period;
498460eb	193	devpriv->usec_remainder =
0a85b6f0	194	(devpriv->usec_remainder + elapsed_time) % devpriv->scan_period;
498460eb	195
ea4f72b2 IA	196	if (cmd->stop_src == TRIG_COUNT) {
ea4f72b2 IA	197	unsigned int remaining = cmd->stop_arg - devpriv->ai_count;
33bd00ef	198
ea4f72b2 IA	199	if (num_scans >= remaining) {
	200	/* about to finish */
	201	num_scans = remaining;
	202	stopping = true;
	203	}
	204	}
	205
498460eb JW	206	for (i = 0; i < num_scans; i++) {
498460eb JW	207	for (j = 0; j < cmd->chanlist_len; j++) {
0642c94b	208	unsigned short sample;
33bd00ef	209
0642c94b IA	210	sample = fake_waveform(dev, CR_CHAN(cmd->chanlist[j]),
	211	CR_RANGE(cmd->chanlist[j]),
	212	devpriv->usec_current +
	213	i * devpriv->scan_period +
	214	j * devpriv->convert_period);
88f9662a	215	comedi_buf_write_samples(s, &sample, 1);
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	227
24051247	228	comedi_handle_events(dev, s);
498460eb JW	229	}
498460eb JW	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	{
498460eb JW	235	int err = 0;
b2ef4813	236	unsigned int arg;
498460eb	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) {
b2ef4813	288	arg = cmd->scan_begin_arg;
1be0e3ed	289	/* round to nearest microsec */
b2ef4813 HS	290	arg = nano_per_micro *
	291	((arg + (nano_per_micro / 2)) / nano_per_micro);
	292	err \|= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
498460eb JW	293	}
498460eb JW	294	if (cmd->convert_src == TRIG_TIMER) {
b2ef4813	295	arg = cmd->convert_arg;
1be0e3ed	296	/* round to nearest microsec */
b2ef4813 HS	297	arg = nano_per_micro *
	298	((arg + (nano_per_micro / 2)) / nano_per_micro);
	299	err \|= cfc_check_trigger_arg_is(&cmd->convert_arg, arg);
498460eb JW	300	}
	301
	302	if (err)
	303	return 4;
	304
	305	return 0;
	306	}
	307
0a85b6f0 MT	308	static int waveform_ai_cmd(struct comedi_device *dev,
0a85b6f0 MT	309	struct comedi_subdevice *s)
498460eb	310	{
f1e5aa75	311	struct waveform_private *devpriv = dev->private;
ea6d0d4c	312	struct comedi_cmd *cmd = &s->async->cmd;
498460eb	313
51d66b29	314	if (cmd->flags & CMDF_PRIORITY) {
b8de3cc4 HS	315	dev_err(dev->class_dev,
b8de3cc4 HS	316	"commands at RT priority not supported in this driver\n");
498460eb JW	317	return -1;
	318	}
	319
498460eb JW	320	devpriv->ai_count = 0;
	321	devpriv->scan_period = cmd->scan_begin_arg / nano_per_micro;
	322
	323	if (cmd->convert_src == TRIG_NOW)
	324	devpriv->convert_period = 0;
f45cc79a	325	else /* TRIG_TIMER */
498460eb	326	devpriv->convert_period = cmd->convert_arg / nano_per_micro;
498460eb	327
dd28153b SA	328	devpriv->last = ktime_get();
	329	devpriv->usec_current =
	330	((u32)ktime_to_us(devpriv->last)) % devpriv->usec_period;
498460eb JW	331	devpriv->usec_remainder = 0;
	332
	333	devpriv->timer.expires = jiffies + 1;
73e0e4df IA	334	/* mark command as active */
	335	smp_mb__before_atomic();
	336	set_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits);
	337	smp_mb__after_atomic();
498460eb JW	338	add_timer(&devpriv->timer);
	339	return 0;
	340	}
	341
0a85b6f0 MT	342	static int waveform_ai_cancel(struct comedi_device *dev,
0a85b6f0 MT	343	struct comedi_subdevice *s)
498460eb	344	{
f1e5aa75 HS	345	struct waveform_private *devpriv = dev->private;
f1e5aa75 HS	346
73e0e4df IA	347	/* mark command as no longer active */
	348	clear_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits);
	349	smp_mb__after_atomic();
	350	/* cannot call del_timer_sync() as may be called from timer routine */
	351	del_timer(&devpriv->timer);
498460eb JW	352	return 0;
	353	}
	354
0a85b6f0 MT	355	static int waveform_ai_insn_read(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	data[i] = devpriv->ao_loopbacks[chan];
	364
	365	return insn->n;
	366	}
	367
0a85b6f0 MT	368	static int waveform_ao_insn_write(struct comedi_device *dev,
0a85b6f0 MT	369	struct comedi_subdevice *s,
90035c08	370	struct comedi_insn insn, unsigned int data)
498460eb	371	{
f1e5aa75	372	struct waveform_private *devpriv = dev->private;
498460eb JW	373	int i, chan = CR_CHAN(insn->chanspec);
	374
	375	for (i = 0; i < insn->n; i++)
	376	devpriv->ao_loopbacks[chan] = data[i];
	377
	378	return insn->n;
	379	}
90f703d3	380
0eb0f278 HS	381	static int waveform_attach(struct comedi_device *dev,
	382	struct comedi_devconfig *it)
	383	{
f1e5aa75	384	struct waveform_private *devpriv;
0eb0f278 HS	385	struct comedi_subdevice *s;
	386	int amplitude = it->options[0];
	387	int period = it->options[1];
	388	int i;
8b6c5694	389	int ret;
0eb0f278	390
0bdab509	391	devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
c34fa261 HS	392	if (!devpriv)
c34fa261 HS	393	return -ENOMEM;
0eb0f278 HS	394
	395	/* set default amplitude and period */
	396	if (amplitude <= 0)
	397	amplitude = 1000000; /* 1 volt */
	398	if (period <= 0)
	399	period = 100000; /* 0.1 sec */
	400
	401	devpriv->uvolt_amplitude = amplitude;
	402	devpriv->usec_period = period;
	403
8b6c5694 HS	404	ret = comedi_alloc_subdevices(dev, 2);
	405	if (ret)
	406	return ret;
0eb0f278	407
713e5c35	408	s = &dev->subdevices[0];
0eb0f278 HS	409	dev->read_subdev = s;
	410	/* analog input subdevice */
	411	s->type = COMEDI_SUBD_AI;
	412	s->subdev_flags = SDF_READABLE \| SDF_GROUND \| SDF_CMD_READ;
b1da4943 HS	413	s->n_chan = N_CHANS;
b1da4943 HS	414	s->maxdata = 0xffff;
0eb0f278 HS	415	s->range_table = &waveform_ai_ranges;
	416	s->len_chanlist = s->n_chan * 2;
	417	s->insn_read = waveform_ai_insn_read;
	418	s->do_cmd = waveform_ai_cmd;
	419	s->do_cmdtest = waveform_ai_cmdtest;
	420	s->cancel = waveform_ai_cancel;
	421
713e5c35	422	s = &dev->subdevices[1];
0eb0f278 HS	423	dev->write_subdev = s;
	424	/* analog output subdevice (loopback) */
	425	s->type = COMEDI_SUBD_AO;
ef49d832	426	s->subdev_flags = SDF_WRITABLE \| SDF_GROUND;
b1da4943 HS	427	s->n_chan = N_CHANS;
b1da4943 HS	428	s->maxdata = 0xffff;
0eb0f278	429	s->range_table = &waveform_ai_ranges;
0eb0f278	430	s->insn_write = waveform_ao_insn_write;
0eb0f278 HS	431
	432	/* Our default loopback value is just a 0V flatline */
	433	for (i = 0; i < s->n_chan; i++)
	434	devpriv->ao_loopbacks[i] = s->maxdata / 2;
	435
9254c841	436	init_timer(&devpriv->timer);
0eb0f278 HS	437	devpriv->timer.function = waveform_ai_interrupt;
	438	devpriv->timer.data = (unsigned long)dev;
	439
9ac6eb40	440	dev_info(dev->class_dev,
9254c841 NS	441	"%s: %i microvolt, %li microsecond waveform attached\n",
	442	dev->board_name,
	443	devpriv->uvolt_amplitude, devpriv->usec_period);
9ac6eb40 HS	444
9ac6eb40 HS	445	return 0;
0eb0f278 HS	446	}
0eb0f278 HS	447
484ecc95	448	static void waveform_detach(struct comedi_device *dev)
0eb0f278	449	{
f1e5aa75 HS	450	struct waveform_private *devpriv = dev->private;
	451
	452	if (devpriv)
73e0e4df	453	del_timer_sync(&devpriv->timer);
0eb0f278 HS	454	}
0eb0f278 HS	455
0eb0f278 HS	456	static struct comedi_driver waveform_driver = {
	457	.driver_name = "comedi_test",
	458	.module = THIS_MODULE,
	459	.attach = waveform_attach,
	460	.detach = waveform_detach,
0eb0f278 HS	461	};
	462	module_comedi_driver(waveform_driver);
	463
90f703d3 AT	464	MODULE_AUTHOR("Comedi http://www.comedi.org");
	465	MODULE_DESCRIPTION("Comedi low-level driver");
	466	MODULE_LICENSE("GPL");