[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 "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);
		break;
	case SQUARE_CHAN:
		return fake_squarewave(dev, range, current_time);
		break;
	default:
		break;
	}

	return fake_flatline(dev, range, current_time);
}

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

	do_gettimeofday(&now);

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

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

	for (i = 0; i < num_scans; i++) {
		for (j = 0; j < cmd->chanlist_len; j++) {
			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;
	int tmp;

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

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

	if (err)
		return 1;

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

	err |= cfc_check_trigger_is_unique(cmd->convert_src);
	err |= cfc_check_trigger_is_unique(cmd->stop_src);

	/* Step 2b : and mutually compatible */

	if (err)
		return 2;

	/* Step 3: check if arguments are trivially valid */

	err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);

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

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

	err |= cfc_check_trigger_arg_min(&cmd->chanlist_len, 1);
	err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);

	if (cmd->stop_src == TRIG_COUNT)
		err |= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
	else	/* TRIG_NONE */
		err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);

	if (err)
		return 3;

	/* step 4: fix up any arguments */

	if (cmd->scan_begin_src == TRIG_TIMER) {
		tmp = cmd->scan_begin_arg;
		/* round to nearest microsec */
		cmd->scan_begin_arg =
		    nano_per_micro * ((tmp +
				       (nano_per_micro / 2)) / nano_per_micro);
		if (tmp != cmd->scan_begin_arg)
			err++;
	}
	if (cmd->convert_src == TRIG_TIMER) {
		tmp = cmd->convert_arg;
		/* round to nearest microsec */
		cmd->convert_arg =
		    nano_per_micro * ((tmp +
				       (nano_per_micro / 2)) / nano_per_micro);
		if (tmp != cmd->convert_arg)
			err++;
	}

	if (err)
		return 4;

	return 0;
}

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

	if (cmd->flags & TRIG_RT) {
		comedi_error(dev,
			     "commands at RT priority not supported in this driver");
		return -1;
	}

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

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

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

	devpriv->timer.expires = jiffies + 1;
	add_timer(&devpriv->timer);
	return 0;
}

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

	del_timer_sync(&devpriv->timer);
	return 0;
}

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

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

	return insn->n;
}

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

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

	return insn->n;
}

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

	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->len_chanlist = s->n_chan * 2;
	s->insn_write = waveform_ao_insn_write;
	s->do_cmd = NULL;
	s->do_cmdtest = NULL;
	s->cancel = NULL;

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

	init_timer(&(devpriv->timer));
	devpriv->timer.function = waveform_ai_interrupt;
	devpriv->timer.data = (unsigned long)dev;

	dev_info(dev->class_dev,
		"%s: %i microvolt, %li microsecond waveform attached\n",
		dev->board_name,
		devpriv->uvolt_amplitude, devpriv->usec_period);

	return 0;
}

static void waveform_detach(struct comedi_device *dev)
{
	struct waveform_private *devpriv = dev->private;

	if (devpriv)
		waveform_ai_cancel(dev, dev->read_subdev);
}

static struct comedi_driver waveform_driver = {
	.driver_name	= "comedi_test",
	.module		= THIS_MODULE,
	.attach		= waveform_attach,
	.detach		= waveform_detach,
};
module_comedi_driver(waveform_driver);

MODULE_AUTHOR("Comedi http://www.comedi.org");
MODULE_DESCRIPTION("Comedi low-level driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
498460eb JW	1	/*
	2	comedi/drivers/comedi_test.c
	3
	4	Generates fake waveform signals that can be read through
	5	the command interface. It does _not_ read from any board;
	6	it just generates deterministic waveforms.
	7	Useful for various testing purposes.
	8
	9	Copyright (C) 2002 Joachim Wuttke <Joachim.Wuttke@icn.siemens.de>
	10	Copyright (C) 2002 Frank Mori Hess <fmhess@users.sourceforge.net>
	11
	12	COMEDI - Linux Control and Measurement Device Interface
	13	Copyright (C) 2000 David A. Schleef <ds@schleef.org>
	14
	15	This program is free software; you can redistribute it and/or modify
	16	it under the terms of the GNU General Public License as published by
	17	the Free Software Foundation; either version 2 of the License, or
	18	(at your option) any later version.
	19
	20	This program is distributed in the hope that it will be useful,
	21	but WITHOUT ANY WARRANTY; without even the implied warranty of
	22	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	23	GNU General Public License for more details.
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 = {
498460eb JW	77	2,
498460eb JW	78	{
0a85b6f0 MT	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);
	150	break;
	151	case SQUARE_CHAN:
	152	return fake_squarewave(dev, range, current_time);
	153	break;
	154	default:
	155	break;
	156	}
	157
	158	return fake_flatline(dev, range, current_time);
	159	}
	160
498460eb JW	161	/*
	162	This is the background routine used to generate arbitrary data.
	163	It should run in the background; therefore it is scheduled by
	164	a timer mechanism.
	165	*/
	166	static void waveform_ai_interrupt(unsigned long arg)
	167	{
0a85b6f0	168	struct comedi_device dev = (struct comedi_device )arg;
f1e5aa75	169	struct waveform_private *devpriv = dev->private;
d163679c	170	struct comedi_async *async = dev->read_subdev->async;
ea6d0d4c	171	struct comedi_cmd *cmd = &async->cmd;
498460eb	172	unsigned int i, j;
1be0e3ed	173	/* all times in microsec */
498460eb JW	174	unsigned long elapsed_time;
	175	unsigned int num_scans;
	176	struct timeval now;
ea4f72b2	177	bool stopping = false;
498460eb JW	178
	179	do_gettimeofday(&now);
	180
	181	elapsed_time =
0a85b6f0 MT	182	1000000 * (now.tv_sec - devpriv->last.tv_sec) + now.tv_usec -
0a85b6f0 MT	183	devpriv->last.tv_usec;
498460eb JW	184	devpriv->last = now;
498460eb JW	185	num_scans =
0a85b6f0	186	(devpriv->usec_remainder + elapsed_time) / devpriv->scan_period;
498460eb	187	devpriv->usec_remainder =
0a85b6f0	188	(devpriv->usec_remainder + elapsed_time) % devpriv->scan_period;
498460eb JW	189	async->events = 0;
498460eb JW	190
ea4f72b2 IA	191	if (cmd->stop_src == TRIG_COUNT) {
	192	unsigned int remaining = cmd->stop_arg - devpriv->ai_count;
	193	if (num_scans >= remaining) {
	194	/* about to finish */
	195	num_scans = remaining;
	196	stopping = true;
	197	}
	198	}
	199
498460eb JW	200	for (i = 0; i < num_scans; i++) {
498460eb JW	201	for (j = 0; j < cmd->chanlist_len; j++) {
0642c94b IA	202	unsigned short sample;
	203	sample = fake_waveform(dev, CR_CHAN(cmd->chanlist[j]),
	204	CR_RANGE(cmd->chanlist[j]),
	205	devpriv->usec_current +
	206	i * devpriv->scan_period +
	207	j * devpriv->convert_period);
	208	cfc_write_to_buffer(dev->read_subdev, sample);
498460eb	209	}
498460eb JW	210	}
498460eb JW	211
ea4f72b2	212	devpriv->ai_count += i;
498460eb JW	213	devpriv->usec_current += elapsed_time;
	214	devpriv->usec_current %= devpriv->usec_period;
	215
ea4f72b2 IA	216	if (stopping)
	217	async->events \|= COMEDI_CB_EOA;
	218	else
498460eb	219	mod_timer(&devpriv->timer, jiffies + 1);
498460eb JW	220
	221	comedi_event(dev, dev->read_subdev);
	222	}
	223
0a85b6f0 MT	224	static int waveform_ai_cmdtest(struct comedi_device *dev,
0a85b6f0 MT	225	struct comedi_subdevice *s,
ea6d0d4c	226	struct comedi_cmd *cmd)
498460eb JW	227	{
	228	int err = 0;
	229	int tmp;
	230
27020ffe	231	/* Step 1 : check if triggers are trivially valid */
498460eb	232
27020ffe HS	233	err \|= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
	234	err \|= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
	235	err \|= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW \| TRIG_TIMER);
	236	err \|= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
	237	err \|= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT \| TRIG_NONE);
498460eb JW	238
	239	if (err)
	240	return 1;
	241
27020ffe	242	/* Step 2a : make sure trigger sources are unique */
498460eb	243
27020ffe HS	244	err \|= cfc_check_trigger_is_unique(cmd->convert_src);
	245	err \|= cfc_check_trigger_is_unique(cmd->stop_src);
	246
	247	/* Step 2b : and mutually compatible */
498460eb JW	248
	249	if (err)
	250	return 2;
	251
df5daff8 HS	252	/* Step 3: check if arguments are trivially valid */
	253
	254	err \|= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
	255
	256	if (cmd->convert_src == TRIG_NOW)
	257	err \|= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);
498460eb	258
498460eb	259	if (cmd->scan_begin_src == TRIG_TIMER) {
df5daff8 HS	260	err \|= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
	261	nano_per_micro);
	262	if (cmd->convert_src == TRIG_TIMER)
	263	err \|= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
	264	cmd->convert_arg * cmd->chanlist_len);
498460eb JW	265	}
498460eb JW	266
df5daff8 HS	267	err \|= cfc_check_trigger_arg_min(&cmd->chanlist_len, 1);
	268	err \|= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
	269
	270	if (cmd->stop_src == TRIG_COUNT)
	271	err \|= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
	272	else /* TRIG_NONE */
	273	err \|= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
498460eb JW	274
	275	if (err)
	276	return 3;
	277
	278	/* step 4: fix up any arguments */
	279
	280	if (cmd->scan_begin_src == TRIG_TIMER) {
	281	tmp = cmd->scan_begin_arg;
1be0e3ed	282	/* round to nearest microsec */
498460eb	283	cmd->scan_begin_arg =
0a85b6f0 MT	284	nano_per_micro * ((tmp +
0a85b6f0 MT	285	(nano_per_micro / 2)) / nano_per_micro);
498460eb JW	286	if (tmp != cmd->scan_begin_arg)
	287	err++;
	288	}
	289	if (cmd->convert_src == TRIG_TIMER) {
	290	tmp = cmd->convert_arg;
1be0e3ed	291	/* round to nearest microsec */
498460eb	292	cmd->convert_arg =
0a85b6f0 MT	293	nano_per_micro * ((tmp +
0a85b6f0 MT	294	(nano_per_micro / 2)) / nano_per_micro);
498460eb JW	295	if (tmp != cmd->convert_arg)
	296	err++;
	297	}
	298
	299	if (err)
	300	return 4;
	301
	302	return 0;
	303	}
	304
0a85b6f0 MT	305	static int waveform_ai_cmd(struct comedi_device *dev,
0a85b6f0 MT	306	struct comedi_subdevice *s)
498460eb	307	{
f1e5aa75	308	struct waveform_private *devpriv = dev->private;
ea6d0d4c	309	struct comedi_cmd *cmd = &s->async->cmd;
498460eb JW	310
	311	if (cmd->flags & TRIG_RT) {
	312	comedi_error(dev,
0a85b6f0	313	"commands at RT priority not supported in this driver");
498460eb JW	314	return -1;
	315	}
	316
498460eb JW	317	devpriv->ai_count = 0;
	318	devpriv->scan_period = cmd->scan_begin_arg / nano_per_micro;
	319
	320	if (cmd->convert_src == TRIG_NOW)
	321	devpriv->convert_period = 0;
	322	else if (cmd->convert_src == TRIG_TIMER)
	323	devpriv->convert_period = cmd->convert_arg / nano_per_micro;
	324	else {
	325	comedi_error(dev, "bug setting conversion period");
	326	return -1;
	327	}
	328
	329	do_gettimeofday(&devpriv->last);
	330	devpriv->usec_current = devpriv->last.tv_usec % devpriv->usec_period;
	331	devpriv->usec_remainder = 0;
	332
	333	devpriv->timer.expires = jiffies + 1;
	334	add_timer(&devpriv->timer);
	335	return 0;
	336	}
	337
0a85b6f0 MT	338	static int waveform_ai_cancel(struct comedi_device *dev,
0a85b6f0 MT	339	struct comedi_subdevice *s)
498460eb	340	{
f1e5aa75 HS	341	struct waveform_private *devpriv = dev->private;
f1e5aa75 HS	342
0653bed6	343	del_timer_sync(&devpriv->timer);
498460eb JW	344	return 0;
	345	}
	346
0a85b6f0 MT	347	static int waveform_ai_insn_read(struct comedi_device *dev,
0a85b6f0 MT	348	struct comedi_subdevice *s,
90035c08	349	struct comedi_insn insn, unsigned int data)
498460eb	350	{
f1e5aa75	351	struct waveform_private *devpriv = dev->private;
498460eb JW	352	int i, chan = CR_CHAN(insn->chanspec);
	353
	354	for (i = 0; i < insn->n; i++)
	355	data[i] = devpriv->ao_loopbacks[chan];
	356
	357	return insn->n;
	358	}
	359
0a85b6f0 MT	360	static int waveform_ao_insn_write(struct comedi_device *dev,
0a85b6f0 MT	361	struct comedi_subdevice *s,
90035c08	362	struct comedi_insn insn, unsigned int data)
498460eb	363	{
f1e5aa75	364	struct waveform_private *devpriv = dev->private;
498460eb JW	365	int i, chan = CR_CHAN(insn->chanspec);
	366
	367	for (i = 0; i < insn->n; i++)
	368	devpriv->ao_loopbacks[chan] = data[i];
	369
	370	return insn->n;
	371	}
90f703d3	372
0eb0f278 HS	373	static int waveform_attach(struct comedi_device *dev,
	374	struct comedi_devconfig *it)
	375	{
f1e5aa75	376	struct waveform_private *devpriv;
0eb0f278 HS	377	struct comedi_subdevice *s;
	378	int amplitude = it->options[0];
	379	int period = it->options[1];
	380	int i;
8b6c5694	381	int ret;
0eb0f278	382
0bdab509	383	devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
c34fa261 HS	384	if (!devpriv)
c34fa261 HS	385	return -ENOMEM;
0eb0f278 HS	386
	387	/* set default amplitude and period */
	388	if (amplitude <= 0)
	389	amplitude = 1000000; /* 1 volt */
	390	if (period <= 0)
	391	period = 100000; /* 0.1 sec */
	392
	393	devpriv->uvolt_amplitude = amplitude;
	394	devpriv->usec_period = period;
	395
8b6c5694 HS	396	ret = comedi_alloc_subdevices(dev, 2);
	397	if (ret)
	398	return ret;
0eb0f278	399
713e5c35	400	s = &dev->subdevices[0];
0eb0f278 HS	401	dev->read_subdev = s;
	402	/* analog input subdevice */
	403	s->type = COMEDI_SUBD_AI;
	404	s->subdev_flags = SDF_READABLE \| SDF_GROUND \| SDF_CMD_READ;
b1da4943 HS	405	s->n_chan = N_CHANS;
b1da4943 HS	406	s->maxdata = 0xffff;
0eb0f278 HS	407	s->range_table = &waveform_ai_ranges;
	408	s->len_chanlist = s->n_chan * 2;
	409	s->insn_read = waveform_ai_insn_read;
	410	s->do_cmd = waveform_ai_cmd;
	411	s->do_cmdtest = waveform_ai_cmdtest;
	412	s->cancel = waveform_ai_cancel;
	413
713e5c35	414	s = &dev->subdevices[1];
0eb0f278 HS	415	dev->write_subdev = s;
	416	/* analog output subdevice (loopback) */
	417	s->type = COMEDI_SUBD_AO;
	418	s->subdev_flags = SDF_WRITEABLE \| SDF_GROUND;
b1da4943 HS	419	s->n_chan = N_CHANS;
b1da4943 HS	420	s->maxdata = 0xffff;
0eb0f278 HS	421	s->range_table = &waveform_ai_ranges;
	422	s->len_chanlist = s->n_chan * 2;
	423	s->insn_write = waveform_ao_insn_write;
	424	s->do_cmd = NULL;
	425	s->do_cmdtest = NULL;
	426	s->cancel = NULL;
	427
	428	/* Our default loopback value is just a 0V flatline */
	429	for (i = 0; i < s->n_chan; i++)
	430	devpriv->ao_loopbacks[i] = s->maxdata / 2;
	431
	432	init_timer(&(devpriv->timer));
	433	devpriv->timer.function = waveform_ai_interrupt;
	434	devpriv->timer.data = (unsigned long)dev;
	435
9ac6eb40 HS	436	dev_info(dev->class_dev,
	437	"%s: %i microvolt, %li microsecond waveform attached\n",
	438	dev->board_name,
	439	devpriv->uvolt_amplitude, devpriv->usec_period);
	440
	441	return 0;
0eb0f278 HS	442	}
0eb0f278 HS	443
484ecc95	444	static void waveform_detach(struct comedi_device *dev)
0eb0f278	445	{
f1e5aa75 HS	446	struct waveform_private *devpriv = dev->private;
	447
	448	if (devpriv)
0eb0f278	449	waveform_ai_cancel(dev, dev->read_subdev);
0eb0f278 HS	450	}
0eb0f278 HS	451
0eb0f278 HS	452	static struct comedi_driver waveform_driver = {
	453	.driver_name = "comedi_test",
	454	.module = THIS_MODULE,
	455	.attach = waveform_attach,
	456	.detach = waveform_detach,
0eb0f278 HS	457	};
	458	module_comedi_driver(waveform_driver);
	459
90f703d3 AT	460	MODULE_AUTHOR("Comedi http://www.comedi.org");
	461	MODULE_DESCRIPTION("Comedi low-level driver");
	462	MODULE_LICENSE("GPL");