[deliverable/linux.git] / drivers / staging / comedi / drivers / comedi_test.c

/*
    comedi/drivers/comedi_test.c

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

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

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

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

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

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

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

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

*/

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

#include <asm/div64.h>

#include "comedi_fc.h"
#include <linux/timer.h>

#define N_CHANS 8

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

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

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

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

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

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

	return offset + value;
}

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

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

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

	return offset + value;
}

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

/* generates a different waveform depending on what channel is read */
static unsigned short fake_waveform(struct comedi_device *dev,
				    unsigned int channel, unsigned int range,
				    unsigned long current_time)
{
	enum {
		SAWTOOTH_CHAN,
		SQUARE_CHAN,
	};
	switch (channel) {
	case SAWTOOTH_CHAN:
		return fake_sawtooth(dev, range, current_time);
		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 = {
c7b51165 HS	77	2, {
	78	BIP_RANGE(10),
	79	BIP_RANGE(5)
	80	}
498460eb JW	81	};
498460eb JW	82
8bd48c9e IA	83	static unsigned short fake_sawtooth(struct comedi_device *dev,
	84	unsigned int range_index,
	85	unsigned long current_time)
0eb0f278	86	{
f1e5aa75	87	struct waveform_private *devpriv = dev->private;
0eb0f278 HS	88	struct comedi_subdevice *s = dev->read_subdev;
	89	unsigned int offset = s->maxdata / 2;
	90	u64 value;
	91	const struct comedi_krange *krange =
	92	&s->range_table->range[range_index];
	93	u64 binary_amplitude;
	94
	95	binary_amplitude = s->maxdata;
	96	binary_amplitude *= devpriv->uvolt_amplitude;
	97	do_div(binary_amplitude, krange->max - krange->min);
	98
	99	current_time %= devpriv->usec_period;
	100	value = current_time;
	101	value = binary_amplitude 2;
	102	do_div(value, devpriv->usec_period);
	103	value -= binary_amplitude; /* get rid of sawtooth's dc offset */
	104
	105	return offset + value;
	106	}
	107
8bd48c9e IA	108	static unsigned short fake_squarewave(struct comedi_device *dev,
	109	unsigned int range_index,
	110	unsigned long current_time)
0eb0f278	111	{
f1e5aa75	112	struct waveform_private *devpriv = dev->private;
0eb0f278 HS	113	struct comedi_subdevice *s = dev->read_subdev;
	114	unsigned int offset = s->maxdata / 2;
	115	u64 value;
	116	const struct comedi_krange *krange =
	117	&s->range_table->range[range_index];
	118	current_time %= devpriv->usec_period;
	119
	120	value = s->maxdata;
	121	value *= devpriv->uvolt_amplitude;
	122	do_div(value, krange->max - krange->min);
	123
	124	if (current_time < devpriv->usec_period / 2)
	125	value *= -1;
	126
	127	return offset + value;
	128	}
	129
8bd48c9e IA	130	static unsigned short fake_flatline(struct comedi_device *dev,
	131	unsigned int range_index,
	132	unsigned long current_time)
0eb0f278 HS	133	{
	134	return dev->read_subdev->maxdata / 2;
	135	}
	136
	137	/* generates a different waveform depending on what channel is read */
8bd48c9e IA	138	static unsigned short fake_waveform(struct comedi_device *dev,
	139	unsigned int channel, unsigned int range,
	140	unsigned long current_time)
0eb0f278 HS	141	{
	142	enum {
	143	SAWTOOTH_CHAN,
	144	SQUARE_CHAN,
	145	};
	146	switch (channel) {
	147	case SAWTOOTH_CHAN:
	148	return fake_sawtooth(dev, range, current_time);
	149	break;
	150	case SQUARE_CHAN:
	151	return fake_squarewave(dev, range, current_time);
	152	break;
	153	default:
	154	break;
	155	}
	156
	157	return fake_flatline(dev, range, current_time);
	158	}
	159
498460eb JW	160	/*
	161	This is the background routine used to generate arbitrary data.
	162	It should run in the background; therefore it is scheduled by
	163	a timer mechanism.
	164	*/
	165	static void waveform_ai_interrupt(unsigned long arg)
	166	{
0a85b6f0	167	struct comedi_device dev = (struct comedi_device )arg;
f1e5aa75	168	struct waveform_private *devpriv = dev->private;
d163679c	169	struct comedi_async *async = dev->read_subdev->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;
	174	unsigned int num_scans;
	175	struct timeval now;
ea4f72b2	176	bool stopping = false;
498460eb JW	177
	178	do_gettimeofday(&now);
	179
	180	elapsed_time =
0a85b6f0 MT	181	1000000 * (now.tv_sec - devpriv->last.tv_sec) + now.tv_usec -
0a85b6f0 MT	182	devpriv->last.tv_usec;
498460eb JW	183	devpriv->last = now;
498460eb JW	184	num_scans =
0a85b6f0	185	(devpriv->usec_remainder + elapsed_time) / devpriv->scan_period;
498460eb	186	devpriv->usec_remainder =
0a85b6f0	187	(devpriv->usec_remainder + elapsed_time) % devpriv->scan_period;
498460eb JW	188	async->events = 0;
498460eb JW	189
ea4f72b2 IA	190	if (cmd->stop_src == TRIG_COUNT) {
	191	unsigned int remaining = cmd->stop_arg - devpriv->ai_count;
	192	if (num_scans >= remaining) {
	193	/* about to finish */
	194	num_scans = remaining;
	195	stopping = true;
	196	}
	197	}
	198
498460eb JW	199	for (i = 0; i < num_scans; i++) {
498460eb JW	200	for (j = 0; j < cmd->chanlist_len; j++) {
0642c94b IA	201	unsigned short sample;
	202	sample = fake_waveform(dev, CR_CHAN(cmd->chanlist[j]),
	203	CR_RANGE(cmd->chanlist[j]),
	204	devpriv->usec_current +
	205	i * devpriv->scan_period +
	206	j * devpriv->convert_period);
	207	cfc_write_to_buffer(dev->read_subdev, sample);
498460eb	208	}
498460eb JW	209	}
498460eb JW	210
ea4f72b2	211	devpriv->ai_count += i;
498460eb JW	212	devpriv->usec_current += elapsed_time;
	213	devpriv->usec_current %= devpriv->usec_period;
	214
ea4f72b2 IA	215	if (stopping)
	216	async->events \|= COMEDI_CB_EOA;
	217	else
498460eb	218	mod_timer(&devpriv->timer, jiffies + 1);
498460eb JW	219
	220	comedi_event(dev, dev->read_subdev);
	221	}
	222
0a85b6f0 MT	223	static int waveform_ai_cmdtest(struct comedi_device *dev,
0a85b6f0 MT	224	struct comedi_subdevice *s,
ea6d0d4c	225	struct comedi_cmd *cmd)
498460eb JW	226	{
	227	int err = 0;
	228	int tmp;
	229
27020ffe	230	/* Step 1 : check if triggers are trivially valid */
498460eb	231
27020ffe HS	232	err \|= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
	233	err \|= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
	234	err \|= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW \| TRIG_TIMER);
	235	err \|= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
	236	err \|= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT \| TRIG_NONE);
498460eb JW	237
	238	if (err)
	239	return 1;
	240
27020ffe	241	/* Step 2a : make sure trigger sources are unique */
498460eb	242
27020ffe HS	243	err \|= cfc_check_trigger_is_unique(cmd->convert_src);
	244	err \|= cfc_check_trigger_is_unique(cmd->stop_src);
	245
	246	/* Step 2b : and mutually compatible */
498460eb JW	247
	248	if (err)
	249	return 2;
	250
df5daff8 HS	251	/* Step 3: check if arguments are trivially valid */
	252
	253	err \|= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
	254
	255	if (cmd->convert_src == TRIG_NOW)
	256	err \|= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);
498460eb	257
498460eb	258	if (cmd->scan_begin_src == TRIG_TIMER) {
df5daff8 HS	259	err \|= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
	260	nano_per_micro);
	261	if (cmd->convert_src == TRIG_TIMER)
	262	err \|= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
	263	cmd->convert_arg * cmd->chanlist_len);
498460eb JW	264	}
498460eb JW	265
df5daff8 HS	266	err \|= cfc_check_trigger_arg_min(&cmd->chanlist_len, 1);
	267	err \|= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
	268
	269	if (cmd->stop_src == TRIG_COUNT)
	270	err \|= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
	271	else /* TRIG_NONE */
	272	err \|= cfc_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) {
	280	tmp = cmd->scan_begin_arg;
1be0e3ed	281	/* round to nearest microsec */
498460eb	282	cmd->scan_begin_arg =
0a85b6f0 MT	283	nano_per_micro * ((tmp +
0a85b6f0 MT	284	(nano_per_micro / 2)) / nano_per_micro);
498460eb JW	285	if (tmp != cmd->scan_begin_arg)
	286	err++;
	287	}
	288	if (cmd->convert_src == TRIG_TIMER) {
	289	tmp = cmd->convert_arg;
1be0e3ed	290	/* round to nearest microsec */
498460eb	291	cmd->convert_arg =
0a85b6f0 MT	292	nano_per_micro * ((tmp +
0a85b6f0 MT	293	(nano_per_micro / 2)) / nano_per_micro);
498460eb JW	294	if (tmp != cmd->convert_arg)
	295	err++;
	296	}
	297
	298	if (err)
	299	return 4;
	300
	301	return 0;
	302	}
	303
0a85b6f0 MT	304	static int waveform_ai_cmd(struct comedi_device *dev,
0a85b6f0 MT	305	struct comedi_subdevice *s)
498460eb	306	{
f1e5aa75	307	struct waveform_private *devpriv = dev->private;
ea6d0d4c	308	struct comedi_cmd *cmd = &s->async->cmd;
498460eb JW	309
	310	if (cmd->flags & TRIG_RT) {
	311	comedi_error(dev,
0a85b6f0	312	"commands at RT priority not supported in this driver");
498460eb JW	313	return -1;
	314	}
	315
498460eb JW	316	devpriv->ai_count = 0;
	317	devpriv->scan_period = cmd->scan_begin_arg / nano_per_micro;
	318
	319	if (cmd->convert_src == TRIG_NOW)
	320	devpriv->convert_period = 0;
	321	else if (cmd->convert_src == TRIG_TIMER)
	322	devpriv->convert_period = cmd->convert_arg / nano_per_micro;
	323	else {
	324	comedi_error(dev, "bug setting conversion period");
	325	return -1;
	326	}
	327
	328	do_gettimeofday(&devpriv->last);
	329	devpriv->usec_current = devpriv->last.tv_usec % devpriv->usec_period;
	330	devpriv->usec_remainder = 0;
	331
	332	devpriv->timer.expires = jiffies + 1;
	333	add_timer(&devpriv->timer);
	334	return 0;
	335	}
	336
0a85b6f0 MT	337	static int waveform_ai_cancel(struct comedi_device *dev,
0a85b6f0 MT	338	struct comedi_subdevice *s)
498460eb	339	{
f1e5aa75 HS	340	struct waveform_private *devpriv = dev->private;
f1e5aa75 HS	341
0653bed6	342	del_timer_sync(&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;
	417	s->subdev_flags = SDF_WRITEABLE \| SDF_GROUND;
b1da4943 HS	418	s->n_chan = N_CHANS;
b1da4943 HS	419	s->maxdata = 0xffff;
0eb0f278 HS	420	s->range_table = &waveform_ai_ranges;
	421	s->len_chanlist = s->n_chan * 2;
	422	s->insn_write = waveform_ao_insn_write;
	423	s->do_cmd = NULL;
	424	s->do_cmdtest = NULL;
	425	s->cancel = NULL;
	426
	427	/* Our default loopback value is just a 0V flatline */
	428	for (i = 0; i < s->n_chan; i++)
	429	devpriv->ao_loopbacks[i] = s->maxdata / 2;
	430
	431	init_timer(&(devpriv->timer));
	432	devpriv->timer.function = waveform_ai_interrupt;
	433	devpriv->timer.data = (unsigned long)dev;
	434
9ac6eb40 HS	435	dev_info(dev->class_dev,
	436	"%s: %i microvolt, %li microsecond waveform attached\n",
	437	dev->board_name,
	438	devpriv->uvolt_amplitude, devpriv->usec_period);
	439
	440	return 0;
0eb0f278 HS	441	}
0eb0f278 HS	442
484ecc95	443	static void waveform_detach(struct comedi_device *dev)
0eb0f278	444	{
f1e5aa75 HS	445	struct waveform_private *devpriv = dev->private;
	446
	447	if (devpriv)
0eb0f278	448	waveform_ai_cancel(dev, dev->read_subdev);
0eb0f278 HS	449	}
0eb0f278 HS	450
0eb0f278 HS	451	static struct comedi_driver waveform_driver = {
	452	.driver_name = "comedi_test",
	453	.module = THIS_MODULE,
	454	.attach = waveform_attach,
	455	.detach = waveform_detach,
0eb0f278 HS	456	};
	457	module_comedi_driver(waveform_driver);
	458
90f703d3 AT	459	MODULE_AUTHOR("Comedi http://www.comedi.org");
	460	MODULE_DESCRIPTION("Comedi low-level driver");
	461	MODULE_LICENSE("GPL");