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. | |
24 | ||
25 | You should have received a copy of the GNU General Public License | |
26 | along with this program; if not, write to the Free Software | |
27 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
28 | ||
29 | ************************************************************************/ | |
30 | /* | |
31 | Driver: comedi_test | |
32 | Description: generates fake waveforms | |
33 | Author: Joachim Wuttke <Joachim.Wuttke@icn.siemens.de>, Frank Mori Hess | |
34 | <fmhess@users.sourceforge.net>, ds | |
35 | Devices: | |
36 | Status: works | |
37 | Updated: Sat, 16 Mar 2002 17:34:48 -0800 | |
38 | ||
39 | This driver is mainly for testing purposes, but can also be used to | |
40 | generate sample waveforms on systems that don't have data acquisition | |
41 | hardware. | |
42 | ||
43 | Configuration options: | |
44 | [0] - Amplitude in microvolts for fake waveforms (default 1 volt) | |
45 | [1] - Period in microseconds for fake waveforms (default 0.1 sec) | |
46 | ||
47 | Generates a sawtooth wave on channel 0, square wave on channel 1, additional | |
48 | waveforms could be added to other channels (currently they return flatline | |
49 | zero volts). | |
50 | ||
51 | */ | |
52 | ||
53 | #include "../comedidev.h" | |
54 | ||
55 | #include <asm/div64.h> | |
56 | ||
57 | #include "comedi_fc.h" | |
de4545cd | 58 | #include <linux/timer.h> |
498460eb JW |
59 | |
60 | /* Board descriptions */ | |
8c49292f | 61 | struct waveform_board { |
498460eb JW |
62 | const char *name; |
63 | int ai_chans; | |
64 | int ai_bits; | |
65 | int have_dio; | |
8c49292f | 66 | }; |
498460eb JW |
67 | |
68 | #define N_CHANS 8 | |
69 | ||
8c49292f | 70 | static const struct waveform_board waveform_boards[] = { |
498460eb | 71 | { |
0a85b6f0 MT |
72 | .name = "comedi_test", |
73 | .ai_chans = N_CHANS, | |
74 | .ai_bits = 16, | |
75 | .have_dio = 0, | |
76 | }, | |
498460eb JW |
77 | }; |
78 | ||
8c49292f | 79 | #define thisboard ((const struct waveform_board *)dev->board_ptr) |
498460eb JW |
80 | |
81 | /* Data unique to this driver */ | |
8c49292f | 82 | struct waveform_private { |
498460eb | 83 | struct timer_list timer; |
25985edc | 84 | struct timeval last; /* time at which last timer interrupt occurred */ |
1be0e3ed GKH |
85 | unsigned int uvolt_amplitude; /* waveform amplitude in microvolts */ |
86 | unsigned long usec_period; /* waveform period in microseconds */ | |
0a85b6f0 | 87 | unsigned long usec_current; /* current time (modulo waveform period) */ |
1be0e3ed GKH |
88 | unsigned long usec_remainder; /* usec since last scan; */ |
89 | unsigned long ai_count; /* number of conversions remaining */ | |
90 | unsigned int scan_period; /* scan period in usec */ | |
91 | unsigned int convert_period; /* conversion period in usec */ | |
92 | unsigned timer_running:1; | |
790c5541 | 93 | unsigned int ao_loopbacks[N_CHANS]; |
8c49292f GKH |
94 | }; |
95 | #define devpriv ((struct waveform_private *)dev->private) | |
498460eb | 96 | |
0a85b6f0 MT |
97 | static int waveform_attach(struct comedi_device *dev, |
98 | struct comedi_devconfig *it); | |
71b5f4f1 | 99 | static int waveform_detach(struct comedi_device *dev); |
139dfbdf | 100 | static struct comedi_driver driver_waveform = { |
0a85b6f0 MT |
101 | .driver_name = "comedi_test", |
102 | .module = THIS_MODULE, | |
103 | .attach = waveform_attach, | |
104 | .detach = waveform_detach, | |
105 | .board_name = &waveform_boards[0].name, | |
106 | .offset = sizeof(struct waveform_board), | |
107 | .num_names = ARRAY_SIZE(waveform_boards), | |
498460eb JW |
108 | }; |
109 | ||
7114a280 AT |
110 | static int __init driver_waveform_init_module(void) |
111 | { | |
112 | return comedi_driver_register(&driver_waveform); | |
113 | } | |
114 | ||
115 | static void __exit driver_waveform_cleanup_module(void) | |
116 | { | |
117 | comedi_driver_unregister(&driver_waveform); | |
118 | } | |
119 | ||
120 | module_init(driver_waveform_init_module); | |
121 | module_exit(driver_waveform_cleanup_module); | |
498460eb | 122 | |
0a85b6f0 MT |
123 | static int waveform_ai_cmdtest(struct comedi_device *dev, |
124 | struct comedi_subdevice *s, | |
ea6d0d4c | 125 | struct comedi_cmd *cmd); |
0a85b6f0 MT |
126 | static int waveform_ai_cmd(struct comedi_device *dev, |
127 | struct comedi_subdevice *s); | |
128 | static int waveform_ai_cancel(struct comedi_device *dev, | |
129 | struct comedi_subdevice *s); | |
130 | static int waveform_ai_insn_read(struct comedi_device *dev, | |
131 | struct comedi_subdevice *s, | |
90035c08 | 132 | struct comedi_insn *insn, unsigned int *data); |
0a85b6f0 MT |
133 | static int waveform_ao_insn_write(struct comedi_device *dev, |
134 | struct comedi_subdevice *s, | |
90035c08 | 135 | struct comedi_insn *insn, unsigned int *data); |
71b5f4f1 | 136 | static short fake_sawtooth(struct comedi_device *dev, unsigned int range, |
0a85b6f0 | 137 | unsigned long current_time); |
71b5f4f1 | 138 | static short fake_squarewave(struct comedi_device *dev, unsigned int range, |
1be0e3ed | 139 | unsigned long current_time); |
0a85b6f0 MT |
140 | static short fake_flatline(struct comedi_device *dev, unsigned int range, |
141 | unsigned long current_time); | |
71b5f4f1 | 142 | static short fake_waveform(struct comedi_device *dev, unsigned int channel, |
0a85b6f0 | 143 | unsigned int range, unsigned long current_time); |
1be0e3ed GKH |
144 | |
145 | /* 1000 nanosec in a microsec */ | |
146 | static const int nano_per_micro = 1000; | |
147 | ||
148 | /* fake analog input ranges */ | |
9ced1de6 | 149 | static const struct comedi_lrange waveform_ai_ranges = { |
498460eb JW |
150 | 2, |
151 | { | |
0a85b6f0 MT |
152 | BIP_RANGE(10), |
153 | BIP_RANGE(5), | |
154 | } | |
498460eb JW |
155 | }; |
156 | ||
157 | /* | |
158 | This is the background routine used to generate arbitrary data. | |
159 | It should run in the background; therefore it is scheduled by | |
160 | a timer mechanism. | |
161 | */ | |
162 | static void waveform_ai_interrupt(unsigned long arg) | |
163 | { | |
0a85b6f0 | 164 | struct comedi_device *dev = (struct comedi_device *)arg; |
d163679c | 165 | struct comedi_async *async = dev->read_subdev->async; |
ea6d0d4c | 166 | struct comedi_cmd *cmd = &async->cmd; |
498460eb | 167 | unsigned int i, j; |
1be0e3ed | 168 | /* all times in microsec */ |
498460eb JW |
169 | unsigned long elapsed_time; |
170 | unsigned int num_scans; | |
171 | struct timeval now; | |
172 | ||
173 | do_gettimeofday(&now); | |
174 | ||
175 | elapsed_time = | |
0a85b6f0 MT |
176 | 1000000 * (now.tv_sec - devpriv->last.tv_sec) + now.tv_usec - |
177 | devpriv->last.tv_usec; | |
498460eb JW |
178 | devpriv->last = now; |
179 | num_scans = | |
0a85b6f0 | 180 | (devpriv->usec_remainder + elapsed_time) / devpriv->scan_period; |
498460eb | 181 | devpriv->usec_remainder = |
0a85b6f0 | 182 | (devpriv->usec_remainder + elapsed_time) % devpriv->scan_period; |
498460eb JW |
183 | async->events = 0; |
184 | ||
185 | for (i = 0; i < num_scans; i++) { | |
186 | for (j = 0; j < cmd->chanlist_len; j++) { | |
187 | cfc_write_to_buffer(dev->read_subdev, | |
0a85b6f0 MT |
188 | fake_waveform(dev, |
189 | CR_CHAN(cmd-> | |
190 | chanlist[j]), | |
191 | CR_RANGE(cmd-> | |
192 | chanlist[j]), | |
193 | devpriv-> | |
194 | usec_current + | |
195 | i * | |
196 | devpriv->scan_period + | |
197 | j * | |
198 | devpriv-> | |
199 | convert_period)); | |
498460eb JW |
200 | } |
201 | devpriv->ai_count++; | |
202 | if (cmd->stop_src == TRIG_COUNT | |
0a85b6f0 | 203 | && devpriv->ai_count >= cmd->stop_arg) { |
498460eb JW |
204 | async->events |= COMEDI_CB_EOA; |
205 | break; | |
206 | } | |
207 | } | |
208 | ||
209 | devpriv->usec_current += elapsed_time; | |
210 | devpriv->usec_current %= devpriv->usec_period; | |
211 | ||
212 | if ((async->events & COMEDI_CB_EOA) == 0 && devpriv->timer_running) | |
213 | mod_timer(&devpriv->timer, jiffies + 1); | |
214 | else | |
215 | del_timer(&devpriv->timer); | |
216 | ||
217 | comedi_event(dev, dev->read_subdev); | |
218 | } | |
219 | ||
0a85b6f0 MT |
220 | static int waveform_attach(struct comedi_device *dev, |
221 | struct comedi_devconfig *it) | |
498460eb | 222 | { |
34c43922 | 223 | struct comedi_subdevice *s; |
498460eb JW |
224 | int amplitude = it->options[0]; |
225 | int period = it->options[1]; | |
1be0e3ed | 226 | int i; |
498460eb JW |
227 | |
228 | dev->board_name = thisboard->name; | |
229 | ||
8c49292f | 230 | if (alloc_private(dev, sizeof(struct waveform_private)) < 0) |
498460eb JW |
231 | return -ENOMEM; |
232 | ||
1be0e3ed | 233 | /* set default amplitude and period */ |
498460eb | 234 | if (amplitude <= 0) |
1be0e3ed | 235 | amplitude = 1000000; /* 1 volt */ |
498460eb | 236 | if (period <= 0) |
1be0e3ed | 237 | period = 100000; /* 0.1 sec */ |
498460eb JW |
238 | |
239 | devpriv->uvolt_amplitude = amplitude; | |
240 | devpriv->usec_period = period; | |
241 | ||
498460eb JW |
242 | dev->n_subdevices = 2; |
243 | if (alloc_subdevices(dev, dev->n_subdevices) < 0) | |
244 | return -ENOMEM; | |
245 | ||
246 | s = dev->subdevices + 0; | |
247 | dev->read_subdev = s; | |
248 | /* analog input subdevice */ | |
249 | s->type = COMEDI_SUBD_AI; | |
250 | s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ; | |
251 | s->n_chan = thisboard->ai_chans; | |
252 | s->maxdata = (1 << thisboard->ai_bits) - 1; | |
253 | s->range_table = &waveform_ai_ranges; | |
254 | s->len_chanlist = s->n_chan * 2; | |
255 | s->insn_read = waveform_ai_insn_read; | |
256 | s->do_cmd = waveform_ai_cmd; | |
257 | s->do_cmdtest = waveform_ai_cmdtest; | |
258 | s->cancel = waveform_ai_cancel; | |
259 | ||
260 | s = dev->subdevices + 1; | |
261 | dev->write_subdev = s; | |
262 | /* analog output subdevice (loopback) */ | |
263 | s->type = COMEDI_SUBD_AO; | |
264 | s->subdev_flags = SDF_WRITEABLE | SDF_GROUND; | |
265 | s->n_chan = thisboard->ai_chans; | |
266 | s->maxdata = (1 << thisboard->ai_bits) - 1; | |
267 | s->range_table = &waveform_ai_ranges; | |
268 | s->len_chanlist = s->n_chan * 2; | |
269 | s->insn_write = waveform_ao_insn_write; | |
e0639d76 GKH |
270 | s->do_cmd = NULL; |
271 | s->do_cmdtest = NULL; | |
272 | s->cancel = NULL; | |
1be0e3ed GKH |
273 | |
274 | /* Our default loopback value is just a 0V flatline */ | |
275 | for (i = 0; i < s->n_chan; i++) | |
276 | devpriv->ao_loopbacks[i] = s->maxdata / 2; | |
498460eb JW |
277 | |
278 | init_timer(&(devpriv->timer)); | |
279 | devpriv->timer.function = waveform_ai_interrupt; | |
280 | devpriv->timer.data = (unsigned long)dev; | |
281 | ||
1be0e3ed | 282 | printk(KERN_INFO "comedi%d: comedi_test: " |
0a85b6f0 MT |
283 | "%i microvolt, %li microsecond waveform attached\n", dev->minor, |
284 | devpriv->uvolt_amplitude, devpriv->usec_period); | |
498460eb JW |
285 | return 1; |
286 | } | |
287 | ||
71b5f4f1 | 288 | static int waveform_detach(struct comedi_device *dev) |
498460eb JW |
289 | { |
290 | printk("comedi%d: comedi_test: remove\n", dev->minor); | |
291 | ||
1be0e3ed | 292 | if (dev->private) |
498460eb | 293 | waveform_ai_cancel(dev, dev->read_subdev); |
498460eb JW |
294 | |
295 | return 0; | |
296 | } | |
297 | ||
0a85b6f0 MT |
298 | static int waveform_ai_cmdtest(struct comedi_device *dev, |
299 | struct comedi_subdevice *s, | |
ea6d0d4c | 300 | struct comedi_cmd *cmd) |
498460eb JW |
301 | { |
302 | int err = 0; | |
303 | int tmp; | |
304 | ||
305 | /* step 1: make sure trigger sources are trivially valid */ | |
306 | ||
307 | tmp = cmd->start_src; | |
308 | cmd->start_src &= TRIG_NOW; | |
309 | if (!cmd->start_src || tmp != cmd->start_src) | |
310 | err++; | |
311 | ||
312 | tmp = cmd->scan_begin_src; | |
313 | cmd->scan_begin_src &= TRIG_TIMER; | |
314 | if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) | |
315 | err++; | |
316 | ||
317 | tmp = cmd->convert_src; | |
318 | cmd->convert_src &= TRIG_NOW | TRIG_TIMER; | |
319 | if (!cmd->convert_src || tmp != cmd->convert_src) | |
320 | err++; | |
321 | ||
322 | tmp = cmd->scan_end_src; | |
323 | cmd->scan_end_src &= TRIG_COUNT; | |
324 | if (!cmd->scan_end_src || tmp != cmd->scan_end_src) | |
325 | err++; | |
326 | ||
327 | tmp = cmd->stop_src; | |
328 | cmd->stop_src &= TRIG_COUNT | TRIG_NONE; | |
329 | if (!cmd->stop_src || tmp != cmd->stop_src) | |
330 | err++; | |
331 | ||
332 | if (err) | |
333 | return 1; | |
334 | ||
1be0e3ed GKH |
335 | /* |
336 | * step 2: make sure trigger sources are unique and mutually compatible | |
337 | */ | |
498460eb JW |
338 | |
339 | if (cmd->convert_src != TRIG_NOW && cmd->convert_src != TRIG_TIMER) | |
340 | err++; | |
341 | if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) | |
342 | err++; | |
343 | ||
344 | if (err) | |
345 | return 2; | |
346 | ||
347 | /* step 3: make sure arguments are trivially compatible */ | |
348 | ||
349 | if (cmd->start_arg != 0) { | |
350 | cmd->start_arg = 0; | |
351 | err++; | |
352 | } | |
353 | if (cmd->convert_src == TRIG_NOW) { | |
354 | if (cmd->convert_arg != 0) { | |
355 | cmd->convert_arg = 0; | |
356 | err++; | |
357 | } | |
358 | } | |
359 | if (cmd->scan_begin_src == TRIG_TIMER) { | |
360 | if (cmd->scan_begin_arg < nano_per_micro) { | |
361 | cmd->scan_begin_arg = nano_per_micro; | |
362 | err++; | |
363 | } | |
364 | if (cmd->convert_src == TRIG_TIMER && | |
0a85b6f0 MT |
365 | cmd->scan_begin_arg < |
366 | cmd->convert_arg * cmd->chanlist_len) { | |
498460eb | 367 | cmd->scan_begin_arg = |
0a85b6f0 | 368 | cmd->convert_arg * cmd->chanlist_len; |
498460eb JW |
369 | err++; |
370 | } | |
371 | } | |
1be0e3ed GKH |
372 | /* |
373 | * XXX these checks are generic and should go in core if not there | |
374 | * already | |
375 | */ | |
498460eb JW |
376 | if (!cmd->chanlist_len) { |
377 | cmd->chanlist_len = 1; | |
378 | err++; | |
379 | } | |
380 | if (cmd->scan_end_arg != cmd->chanlist_len) { | |
381 | cmd->scan_end_arg = cmd->chanlist_len; | |
382 | err++; | |
383 | } | |
384 | ||
385 | if (cmd->stop_src == TRIG_COUNT) { | |
386 | if (!cmd->stop_arg) { | |
387 | cmd->stop_arg = 1; | |
388 | err++; | |
389 | } | |
390 | } else { /* TRIG_NONE */ | |
391 | if (cmd->stop_arg != 0) { | |
392 | cmd->stop_arg = 0; | |
393 | err++; | |
394 | } | |
395 | } | |
396 | ||
397 | if (err) | |
398 | return 3; | |
399 | ||
400 | /* step 4: fix up any arguments */ | |
401 | ||
402 | if (cmd->scan_begin_src == TRIG_TIMER) { | |
403 | tmp = cmd->scan_begin_arg; | |
1be0e3ed | 404 | /* round to nearest microsec */ |
498460eb | 405 | cmd->scan_begin_arg = |
0a85b6f0 MT |
406 | nano_per_micro * ((tmp + |
407 | (nano_per_micro / 2)) / nano_per_micro); | |
498460eb JW |
408 | if (tmp != cmd->scan_begin_arg) |
409 | err++; | |
410 | } | |
411 | if (cmd->convert_src == TRIG_TIMER) { | |
412 | tmp = cmd->convert_arg; | |
1be0e3ed | 413 | /* round to nearest microsec */ |
498460eb | 414 | cmd->convert_arg = |
0a85b6f0 MT |
415 | nano_per_micro * ((tmp + |
416 | (nano_per_micro / 2)) / nano_per_micro); | |
498460eb JW |
417 | if (tmp != cmd->convert_arg) |
418 | err++; | |
419 | } | |
420 | ||
421 | if (err) | |
422 | return 4; | |
423 | ||
424 | return 0; | |
425 | } | |
426 | ||
0a85b6f0 MT |
427 | static int waveform_ai_cmd(struct comedi_device *dev, |
428 | struct comedi_subdevice *s) | |
498460eb | 429 | { |
ea6d0d4c | 430 | struct comedi_cmd *cmd = &s->async->cmd; |
498460eb JW |
431 | |
432 | if (cmd->flags & TRIG_RT) { | |
433 | comedi_error(dev, | |
0a85b6f0 | 434 | "commands at RT priority not supported in this driver"); |
498460eb JW |
435 | return -1; |
436 | } | |
437 | ||
438 | devpriv->timer_running = 1; | |
439 | devpriv->ai_count = 0; | |
440 | devpriv->scan_period = cmd->scan_begin_arg / nano_per_micro; | |
441 | ||
442 | if (cmd->convert_src == TRIG_NOW) | |
443 | devpriv->convert_period = 0; | |
444 | else if (cmd->convert_src == TRIG_TIMER) | |
445 | devpriv->convert_period = cmd->convert_arg / nano_per_micro; | |
446 | else { | |
447 | comedi_error(dev, "bug setting conversion period"); | |
448 | return -1; | |
449 | } | |
450 | ||
451 | do_gettimeofday(&devpriv->last); | |
452 | devpriv->usec_current = devpriv->last.tv_usec % devpriv->usec_period; | |
453 | devpriv->usec_remainder = 0; | |
454 | ||
455 | devpriv->timer.expires = jiffies + 1; | |
456 | add_timer(&devpriv->timer); | |
457 | return 0; | |
458 | } | |
459 | ||
0a85b6f0 MT |
460 | static int waveform_ai_cancel(struct comedi_device *dev, |
461 | struct comedi_subdevice *s) | |
498460eb JW |
462 | { |
463 | devpriv->timer_running = 0; | |
464 | del_timer(&devpriv->timer); | |
465 | return 0; | |
466 | } | |
467 | ||
71b5f4f1 | 468 | static short fake_sawtooth(struct comedi_device *dev, unsigned int range_index, |
0a85b6f0 | 469 | unsigned long current_time) |
498460eb | 470 | { |
34c43922 | 471 | struct comedi_subdevice *s = dev->read_subdev; |
498460eb JW |
472 | unsigned int offset = s->maxdata / 2; |
473 | u64 value; | |
0a85b6f0 MT |
474 | const struct comedi_krange *krange = |
475 | &s->range_table->range[range_index]; | |
498460eb JW |
476 | u64 binary_amplitude; |
477 | ||
478 | binary_amplitude = s->maxdata; | |
479 | binary_amplitude *= devpriv->uvolt_amplitude; | |
480 | do_div(binary_amplitude, krange->max - krange->min); | |
481 | ||
482 | current_time %= devpriv->usec_period; | |
483 | value = current_time; | |
484 | value *= binary_amplitude * 2; | |
485 | do_div(value, devpriv->usec_period); | |
1be0e3ed | 486 | value -= binary_amplitude; /* get rid of sawtooth's dc offset */ |
498460eb JW |
487 | |
488 | return offset + value; | |
489 | } | |
0a85b6f0 MT |
490 | |
491 | static short fake_squarewave(struct comedi_device *dev, | |
492 | unsigned int range_index, | |
493 | unsigned long current_time) | |
498460eb | 494 | { |
34c43922 | 495 | struct comedi_subdevice *s = dev->read_subdev; |
498460eb JW |
496 | unsigned int offset = s->maxdata / 2; |
497 | u64 value; | |
0a85b6f0 MT |
498 | const struct comedi_krange *krange = |
499 | &s->range_table->range[range_index]; | |
498460eb JW |
500 | current_time %= devpriv->usec_period; |
501 | ||
502 | value = s->maxdata; | |
503 | value *= devpriv->uvolt_amplitude; | |
504 | do_div(value, krange->max - krange->min); | |
505 | ||
506 | if (current_time < devpriv->usec_period / 2) | |
507 | value *= -1; | |
508 | ||
509 | return offset + value; | |
510 | } | |
511 | ||
71b5f4f1 | 512 | static short fake_flatline(struct comedi_device *dev, unsigned int range_index, |
0a85b6f0 | 513 | unsigned long current_time) |
498460eb JW |
514 | { |
515 | return dev->read_subdev->maxdata / 2; | |
516 | } | |
517 | ||
1be0e3ed | 518 | /* generates a different waveform depending on what channel is read */ |
71b5f4f1 | 519 | static short fake_waveform(struct comedi_device *dev, unsigned int channel, |
0a85b6f0 | 520 | unsigned int range, unsigned long current_time) |
498460eb JW |
521 | { |
522 | enum { | |
523 | SAWTOOTH_CHAN, | |
524 | SQUARE_CHAN, | |
525 | }; | |
526 | switch (channel) { | |
527 | case SAWTOOTH_CHAN: | |
528 | return fake_sawtooth(dev, range, current_time); | |
529 | break; | |
530 | case SQUARE_CHAN: | |
531 | return fake_squarewave(dev, range, current_time); | |
532 | break; | |
533 | default: | |
534 | break; | |
535 | } | |
536 | ||
537 | return fake_flatline(dev, range, current_time); | |
538 | } | |
539 | ||
0a85b6f0 MT |
540 | static int waveform_ai_insn_read(struct comedi_device *dev, |
541 | struct comedi_subdevice *s, | |
90035c08 | 542 | struct comedi_insn *insn, unsigned int *data) |
498460eb JW |
543 | { |
544 | int i, chan = CR_CHAN(insn->chanspec); | |
545 | ||
546 | for (i = 0; i < insn->n; i++) | |
547 | data[i] = devpriv->ao_loopbacks[chan]; | |
548 | ||
549 | return insn->n; | |
550 | } | |
551 | ||
0a85b6f0 MT |
552 | static int waveform_ao_insn_write(struct comedi_device *dev, |
553 | struct comedi_subdevice *s, | |
90035c08 | 554 | struct comedi_insn *insn, unsigned int *data) |
498460eb JW |
555 | { |
556 | int i, chan = CR_CHAN(insn->chanspec); | |
557 | ||
558 | for (i = 0; i < insn->n; i++) | |
559 | devpriv->ao_loopbacks[chan] = data[i]; | |
560 | ||
561 | return insn->n; | |
562 | } | |
90f703d3 AT |
563 | |
564 | MODULE_AUTHOR("Comedi http://www.comedi.org"); | |
565 | MODULE_DESCRIPTION("Comedi low-level driver"); | |
566 | MODULE_LICENSE("GPL"); |