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

/*
    comedi/drivers/comedi_test.c

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

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

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

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

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

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

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

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

*/

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

#include <asm/div64.h>

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

#define N_CHANS 8

enum waveform_state_bits {
	WAVEFORM_AI_RUNNING = 0
};

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

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

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

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

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

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

	return offset + value;
}

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

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

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

	return offset + value;
}

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

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

	return fake_flatline(dev, range, current_time);
}

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

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

	now = ktime_get();

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

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

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

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

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

	comedi_handle_events(dev, s);
}

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

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

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

	if (err)
		return 1;

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

	err |= comedi_check_trigger_is_unique(cmd->convert_src);
	err |= comedi_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 |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);

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

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

	err |= comedi_check_trigger_arg_min(&cmd->chanlist_len, 1);
	err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
					   cmd->chanlist_len);

	if (cmd->stop_src == TRIG_COUNT)
		err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
	else	/* TRIG_NONE */
		err |= comedi_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 |= comedi_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 |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
	}

	if (err)
		return 4;

	return 0;
}

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

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

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

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

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

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

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

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

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

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

	return insn->n;
}

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

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

	return insn->n;
}

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

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

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

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

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

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

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

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

	setup_timer(&devpriv->timer, waveform_ai_interrupt,
		    (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
de4545cd	53	#include <linux/timer.h>
dd28153b	54	#include <linux/ktime.h>
498460eb	55
498460eb JW	56	#define N_CHANS 8
498460eb JW	57
73e0e4df IA	58	enum waveform_state_bits {
	59	WAVEFORM_AI_RUNNING = 0
	60	};
	61
498460eb	62	/* Data unique to this driver */
8c49292f	63	struct waveform_private {
498460eb	64	struct timer_list timer;
dd28153b	65	ktime_t last; /* time 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 */
ae6eee39 IA	68	unsigned long usec_current; /* current time (mod waveform period) */
ae6eee39 IA	69	unsigned long usec_remainder; /* usec since last scan */
73e0e4df	70	unsigned long state_bits;
1be0e3ed GKH	71	unsigned int scan_period; /* scan period in usec */
1be0e3ed GKH	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 = {
c7b51165 HS	81	2, {
	82	BIP_RANGE(10),
	83	BIP_RANGE(5)
	84	}
498460eb JW	85	};
498460eb JW	86
8bd48c9e IA	87	static unsigned short fake_sawtooth(struct comedi_device *dev,
	88	unsigned int range_index,
	89	unsigned long current_time)
0eb0f278	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
8bd48c9e IA	112	static unsigned short fake_squarewave(struct comedi_device *dev,
	113	unsigned int range_index,
	114	unsigned long current_time)
0eb0f278	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
8bd48c9e IA	134	static unsigned short fake_flatline(struct comedi_device *dev,
	135	unsigned int range_index,
	136	unsigned long current_time)
0eb0f278 HS	137	{
	138	return dev->read_subdev->maxdata / 2;
	139	}
	140
	141	/* generates a different waveform depending on what channel is read */
8bd48c9e IA	142	static unsigned short fake_waveform(struct comedi_device *dev,
	143	unsigned int channel, unsigned int range,
	144	unsigned long current_time)
0eb0f278 HS	145	{
	146	enum {
	147	SAWTOOTH_CHAN,
	148	SQUARE_CHAN,
	149	};
	150	switch (channel) {
	151	case SAWTOOTH_CHAN:
	152	return fake_sawtooth(dev, range, current_time);
0eb0f278 HS	153	case SQUARE_CHAN:
0eb0f278 HS	154	return fake_squarewave(dev, range, current_time);
0eb0f278 HS	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;
24051247 HS	171	struct comedi_subdevice *s = dev->read_subdev;
24051247 HS	172	struct comedi_async *async = s->async;
ea6d0d4c	173	struct comedi_cmd *cmd = &async->cmd;
498460eb	174	unsigned int i, j;
1be0e3ed	175	/* all times in microsec */
498460eb JW	176	unsigned long elapsed_time;
498460eb JW	177	unsigned int num_scans;
dd28153b	178	ktime_t now;
498460eb	179
73e0e4df IA	180	/* check command is still active */
	181	if (!test_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits))
	182	return;
	183
dd28153b	184	now = ktime_get();
498460eb	185
dd28153b	186	elapsed_time = ktime_to_us(ktime_sub(now, devpriv->last));
498460eb JW	187	devpriv->last = now;
498460eb JW	188	num_scans =
0a85b6f0	189	(devpriv->usec_remainder + elapsed_time) / devpriv->scan_period;
498460eb	190	devpriv->usec_remainder =
0a85b6f0	191	(devpriv->usec_remainder + elapsed_time) % devpriv->scan_period;
498460eb	192
f5345d45	193	num_scans = comedi_nscans_left(s, num_scans);
498460eb JW	194	for (i = 0; i < num_scans; i++) {
498460eb JW	195	for (j = 0; j < cmd->chanlist_len; j++) {
0642c94b	196	unsigned short sample;
33bd00ef	197
0642c94b IA	198	sample = fake_waveform(dev, CR_CHAN(cmd->chanlist[j]),
	199	CR_RANGE(cmd->chanlist[j]),
	200	devpriv->usec_current +
	201	i * devpriv->scan_period +
	202	j * devpriv->convert_period);
88f9662a	203	comedi_buf_write_samples(s, &sample, 1);
498460eb	204	}
498460eb JW	205	}
	206
	207	devpriv->usec_current += elapsed_time;
	208	devpriv->usec_current %= devpriv->usec_period;
	209
f5345d45	210	if (cmd->stop_src == TRIG_COUNT && async->scans_done >= cmd->stop_arg)
ea4f72b2 IA	211	async->events \|= COMEDI_CB_EOA;
ea4f72b2 IA	212	else
498460eb	213	mod_timer(&devpriv->timer, jiffies + 1);
498460eb	214
24051247	215	comedi_handle_events(dev, s);
498460eb JW	216	}
498460eb JW	217
0a85b6f0 MT	218	static int waveform_ai_cmdtest(struct comedi_device *dev,
0a85b6f0 MT	219	struct comedi_subdevice *s,
ea6d0d4c	220	struct comedi_cmd *cmd)
498460eb JW	221	{
498460eb JW	222	int err = 0;
b2ef4813	223	unsigned int arg;
498460eb	224
27020ffe	225	/* Step 1 : check if triggers are trivially valid */
498460eb	226
61f76970 IA	227	err \|= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW);
	228	err \|= comedi_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
	229	err \|= comedi_check_trigger_src(&cmd->convert_src,
	230	TRIG_NOW \| TRIG_TIMER);
	231	err \|= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
	232	err \|= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT \| TRIG_NONE);
498460eb JW	233
	234	if (err)
	235	return 1;
	236
27020ffe	237	/* Step 2a : make sure trigger sources are unique */
498460eb	238
61f76970 IA	239	err \|= comedi_check_trigger_is_unique(cmd->convert_src);
61f76970 IA	240	err \|= comedi_check_trigger_is_unique(cmd->stop_src);
27020ffe HS	241
27020ffe HS	242	/* Step 2b : and mutually compatible */
498460eb JW	243
	244	if (err)
	245	return 2;
	246
df5daff8 HS	247	/* Step 3: check if arguments are trivially valid */
df5daff8 HS	248
61f76970	249	err \|= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
df5daff8 HS	250
df5daff8 HS	251	if (cmd->convert_src == TRIG_NOW)
61f76970	252	err \|= comedi_check_trigger_arg_is(&cmd->convert_arg, 0);
498460eb	253
498460eb	254	if (cmd->scan_begin_src == TRIG_TIMER) {
61f76970 IA	255	err \|= comedi_check_trigger_arg_min(&cmd->scan_begin_arg,
	256	nano_per_micro);
	257	if (cmd->convert_src == TRIG_TIMER) {
	258	err \|= comedi_check_trigger_arg_min(&cmd->
	259	scan_begin_arg,
	260	cmd->convert_arg *
	261	cmd->chanlist_len);
	262	}
498460eb JW	263	}
498460eb JW	264
61f76970 IA	265	err \|= comedi_check_trigger_arg_min(&cmd->chanlist_len, 1);
	266	err \|= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
	267	cmd->chanlist_len);
df5daff8 HS	268
df5daff8 HS	269	if (cmd->stop_src == TRIG_COUNT)
61f76970	270	err \|= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
df5daff8	271	else /* TRIG_NONE */
61f76970	272	err \|= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
498460eb JW	273
	274	if (err)
	275	return 3;
	276
	277	/* step 4: fix up any arguments */
	278
	279	if (cmd->scan_begin_src == TRIG_TIMER) {
b2ef4813	280	arg = cmd->scan_begin_arg;
1be0e3ed	281	/* round to nearest microsec */
b2ef4813 HS	282	arg = nano_per_micro *
b2ef4813 HS	283	((arg + (nano_per_micro / 2)) / nano_per_micro);
61f76970	284	err \|= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
498460eb JW	285	}
498460eb JW	286	if (cmd->convert_src == TRIG_TIMER) {
b2ef4813	287	arg = cmd->convert_arg;
1be0e3ed	288	/* round to nearest microsec */
b2ef4813 HS	289	arg = nano_per_micro *
b2ef4813 HS	290	((arg + (nano_per_micro / 2)) / nano_per_micro);
61f76970	291	err \|= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
498460eb JW	292	}
	293
	294	if (err)
	295	return 4;
	296
	297	return 0;
	298	}
	299
0a85b6f0 MT	300	static int waveform_ai_cmd(struct comedi_device *dev,
0a85b6f0 MT	301	struct comedi_subdevice *s)
498460eb	302	{
f1e5aa75	303	struct waveform_private *devpriv = dev->private;
ea6d0d4c	304	struct comedi_cmd *cmd = &s->async->cmd;
498460eb	305
51d66b29	306	if (cmd->flags & CMDF_PRIORITY) {
b8de3cc4 HS	307	dev_err(dev->class_dev,
b8de3cc4 HS	308	"commands at RT priority not supported in this driver\n");
498460eb JW	309	return -1;
	310	}
	311
498460eb JW	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;
73e0e4df IA	325	/* mark command as active */
	326	smp_mb__before_atomic();
	327	set_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits);
	328	smp_mb__after_atomic();
498460eb JW	329	add_timer(&devpriv->timer);
	330	return 0;
	331	}
	332
0a85b6f0 MT	333	static int waveform_ai_cancel(struct comedi_device *dev,
0a85b6f0 MT	334	struct comedi_subdevice *s)
498460eb	335	{
f1e5aa75 HS	336	struct waveform_private *devpriv = dev->private;
f1e5aa75 HS	337
73e0e4df IA	338	/* mark command as no longer active */
	339	clear_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits);
	340	smp_mb__after_atomic();
	341	/* cannot call del_timer_sync() as may be called from timer routine */
	342	del_timer(&devpriv->timer);
498460eb JW	343	return 0;
	344	}
	345
0a85b6f0 MT	346	static int waveform_ai_insn_read(struct comedi_device *dev,
0a85b6f0 MT	347	struct comedi_subdevice *s,
90035c08	348	struct comedi_insn insn, unsigned int data)
498460eb	349	{
f1e5aa75	350	struct waveform_private *devpriv = dev->private;
498460eb JW	351	int i, chan = CR_CHAN(insn->chanspec);
	352
	353	for (i = 0; i < insn->n; i++)
	354	data[i] = devpriv->ao_loopbacks[chan];
	355
	356	return insn->n;
	357	}
	358
0a85b6f0 MT	359	static int waveform_ao_insn_write(struct comedi_device *dev,
0a85b6f0 MT	360	struct comedi_subdevice *s,
90035c08	361	struct comedi_insn insn, unsigned int data)
498460eb	362	{
f1e5aa75	363	struct waveform_private *devpriv = dev->private;
498460eb JW	364	int i, chan = CR_CHAN(insn->chanspec);
	365
	366	for (i = 0; i < insn->n; i++)
	367	devpriv->ao_loopbacks[chan] = data[i];
	368
	369	return insn->n;
	370	}
90f703d3	371
0eb0f278 HS	372	static int waveform_attach(struct comedi_device *dev,
	373	struct comedi_devconfig *it)
	374	{
f1e5aa75	375	struct waveform_private *devpriv;
0eb0f278 HS	376	struct comedi_subdevice *s;
	377	int amplitude = it->options[0];
	378	int period = it->options[1];
	379	int i;
8b6c5694	380	int ret;
0eb0f278	381
0bdab509	382	devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
c34fa261 HS	383	if (!devpriv)
c34fa261 HS	384	return -ENOMEM;
0eb0f278 HS	385
	386	/* set default amplitude and period */
	387	if (amplitude <= 0)
	388	amplitude = 1000000; /* 1 volt */
	389	if (period <= 0)
	390	period = 100000; /* 0.1 sec */
	391
	392	devpriv->uvolt_amplitude = amplitude;
	393	devpriv->usec_period = period;
	394
8b6c5694 HS	395	ret = comedi_alloc_subdevices(dev, 2);
	396	if (ret)
	397	return ret;
0eb0f278	398
713e5c35	399	s = &dev->subdevices[0];
0eb0f278 HS	400	dev->read_subdev = s;
	401	/* analog input subdevice */
	402	s->type = COMEDI_SUBD_AI;
	403	s->subdev_flags = SDF_READABLE \| SDF_GROUND \| SDF_CMD_READ;
b1da4943 HS	404	s->n_chan = N_CHANS;
b1da4943 HS	405	s->maxdata = 0xffff;
0eb0f278 HS	406	s->range_table = &waveform_ai_ranges;
	407	s->len_chanlist = s->n_chan * 2;
	408	s->insn_read = waveform_ai_insn_read;
	409	s->do_cmd = waveform_ai_cmd;
	410	s->do_cmdtest = waveform_ai_cmdtest;
	411	s->cancel = waveform_ai_cancel;
	412
713e5c35	413	s = &dev->subdevices[1];
0eb0f278 HS	414	dev->write_subdev = s;
	415	/* analog output subdevice (loopback) */
	416	s->type = COMEDI_SUBD_AO;
ef49d832	417	s->subdev_flags = SDF_WRITABLE \| SDF_GROUND;
b1da4943 HS	418	s->n_chan = N_CHANS;
b1da4943 HS	419	s->maxdata = 0xffff;
0eb0f278	420	s->range_table = &waveform_ai_ranges;
0eb0f278	421	s->insn_write = waveform_ao_insn_write;
0eb0f278 HS	422
	423	/* Our default loopback value is just a 0V flatline */
	424	for (i = 0; i < s->n_chan; i++)
	425	devpriv->ao_loopbacks[i] = s->maxdata / 2;
	426
9a9bdd68 AM	427	setup_timer(&devpriv->timer, waveform_ai_interrupt,
9a9bdd68 AM	428	(unsigned long)dev);
0eb0f278	429
9ac6eb40	430	dev_info(dev->class_dev,
9254c841 NS	431	"%s: %i microvolt, %li microsecond waveform attached\n",
	432	dev->board_name,
	433	devpriv->uvolt_amplitude, devpriv->usec_period);
9ac6eb40 HS	434
9ac6eb40 HS	435	return 0;
0eb0f278 HS	436	}
0eb0f278 HS	437
484ecc95	438	static void waveform_detach(struct comedi_device *dev)
0eb0f278	439	{
f1e5aa75 HS	440	struct waveform_private *devpriv = dev->private;
	441
	442	if (devpriv)
73e0e4df	443	del_timer_sync(&devpriv->timer);
0eb0f278 HS	444	}
0eb0f278 HS	445
0eb0f278 HS	446	static struct comedi_driver waveform_driver = {
	447	.driver_name = "comedi_test",
	448	.module = THIS_MODULE,
	449	.attach = waveform_attach,
	450	.detach = waveform_detach,
0eb0f278 HS	451	};
	452	module_comedi_driver(waveform_driver);
	453
90f703d3 AT	454	MODULE_AUTHOR("Comedi http://www.comedi.org");
	455	MODULE_DESCRIPTION("Comedi low-level driver");
	456	MODULE_LICENSE("GPL");