Commit | Line | Data |
---|---|---|
498460eb | 1 | /* |
cbad8cf4 IA |
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 | */ | |
498460eb | 25 | |
498460eb | 26 | /* |
cbad8cf4 IA |
27 | * Driver: comedi_test |
28 | * Description: generates fake waveforms | |
29 | * Author: Joachim Wuttke <Joachim.Wuttke@icn.siemens.de>, Frank Mori Hess | |
30 | * <fmhess@users.sourceforge.net>, ds | |
31 | * Devices: | |
32 | * Status: works | |
33 | * Updated: Sat, 16 Mar 2002 17:34:48 -0800 | |
34 | * | |
35 | * This driver is mainly for testing purposes, but can also be used to | |
36 | * generate sample waveforms on systems that don't have data acquisition | |
37 | * hardware. | |
38 | * | |
39 | * Configuration options: | |
40 | * [0] - Amplitude in microvolts for fake waveforms (default 1 volt) | |
41 | * [1] - Period in microseconds for fake waveforms (default 0.1 sec) | |
42 | * | |
43 | * Generates a sawtooth wave on channel 0, square wave on channel 1, additional | |
44 | * waveforms could be added to other channels (currently they return flatline | |
45 | * zero volts). | |
46 | */ | |
498460eb | 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 |
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; |
66d4da80 | 65 | u64 ai_last_scan_time; /* time of last AI scan in usec */ |
1be0e3ed | 66 | unsigned int uvolt_amplitude; /* waveform amplitude in microvolts */ |
21ec1bf7 IA |
67 | unsigned int usec_period; /* waveform period in microseconds */ |
68 | unsigned int usec_current; /* current time (mod waveform period) */ | |
73e0e4df | 69 | unsigned long state_bits; |
1be0e3ed GKH |
70 | unsigned int scan_period; /* scan period in usec */ |
71 | unsigned int convert_period; /* conversion period in usec */ | |
790c5541 | 72 | unsigned int ao_loopbacks[N_CHANS]; |
8c49292f | 73 | }; |
498460eb | 74 | |
1be0e3ed | 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 | }; |
82 | ||
8bd48c9e IA |
83 | static unsigned short fake_sawtooth(struct comedi_device *dev, |
84 | unsigned int range_index, | |
21ec1bf7 | 85 | unsigned int 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 | ||
0eb0f278 HS |
99 | value = current_time; |
100 | value *= binary_amplitude * 2; | |
101 | do_div(value, devpriv->usec_period); | |
19e86985 IA |
102 | value += offset; |
103 | /* get rid of sawtooth's dc offset and clamp value */ | |
104 | if (value < binary_amplitude) { | |
105 | value = 0; /* negative saturation */ | |
106 | } else { | |
107 | value -= binary_amplitude; | |
108 | if (value > s->maxdata) | |
109 | value = s->maxdata; /* positive saturation */ | |
110 | } | |
0eb0f278 | 111 | |
19e86985 | 112 | return value; |
0eb0f278 HS |
113 | } |
114 | ||
8bd48c9e IA |
115 | static unsigned short fake_squarewave(struct comedi_device *dev, |
116 | unsigned int range_index, | |
21ec1bf7 | 117 | unsigned int current_time) |
0eb0f278 | 118 | { |
f1e5aa75 | 119 | struct waveform_private *devpriv = dev->private; |
0eb0f278 HS |
120 | struct comedi_subdevice *s = dev->read_subdev; |
121 | unsigned int offset = s->maxdata / 2; | |
122 | u64 value; | |
123 | const struct comedi_krange *krange = | |
124 | &s->range_table->range[range_index]; | |
0eb0f278 HS |
125 | |
126 | value = s->maxdata; | |
127 | value *= devpriv->uvolt_amplitude; | |
128 | do_div(value, krange->max - krange->min); | |
129 | ||
19e86985 IA |
130 | /* get one of two values for square-wave and clamp */ |
131 | if (current_time < devpriv->usec_period / 2) { | |
132 | if (offset < value) | |
133 | value = 0; /* negative saturation */ | |
134 | else | |
135 | value = offset - value; | |
136 | } else { | |
137 | value += offset; | |
138 | if (value > s->maxdata) | |
139 | value = s->maxdata; /* positive saturation */ | |
140 | } | |
0eb0f278 | 141 | |
19e86985 | 142 | return value; |
0eb0f278 HS |
143 | } |
144 | ||
8bd48c9e IA |
145 | static unsigned short fake_flatline(struct comedi_device *dev, |
146 | unsigned int range_index, | |
21ec1bf7 | 147 | unsigned int current_time) |
0eb0f278 HS |
148 | { |
149 | return dev->read_subdev->maxdata / 2; | |
150 | } | |
151 | ||
152 | /* generates a different waveform depending on what channel is read */ | |
8bd48c9e IA |
153 | static unsigned short fake_waveform(struct comedi_device *dev, |
154 | unsigned int channel, unsigned int range, | |
21ec1bf7 | 155 | unsigned int current_time) |
0eb0f278 HS |
156 | { |
157 | enum { | |
158 | SAWTOOTH_CHAN, | |
159 | SQUARE_CHAN, | |
160 | }; | |
161 | switch (channel) { | |
162 | case SAWTOOTH_CHAN: | |
163 | return fake_sawtooth(dev, range, current_time); | |
0eb0f278 HS |
164 | case SQUARE_CHAN: |
165 | return fake_squarewave(dev, range, current_time); | |
0eb0f278 HS |
166 | default: |
167 | break; | |
168 | } | |
169 | ||
170 | return fake_flatline(dev, range, current_time); | |
171 | } | |
172 | ||
498460eb | 173 | /* |
cbad8cf4 IA |
174 | * This is the background routine used to generate arbitrary data. |
175 | * It should run in the background; therefore it is scheduled by | |
176 | * a timer mechanism. | |
177 | */ | |
498460eb JW |
178 | static void waveform_ai_interrupt(unsigned long arg) |
179 | { | |
0a85b6f0 | 180 | struct comedi_device *dev = (struct comedi_device *)arg; |
f1e5aa75 | 181 | struct waveform_private *devpriv = dev->private; |
24051247 HS |
182 | struct comedi_subdevice *s = dev->read_subdev; |
183 | struct comedi_async *async = s->async; | |
ea6d0d4c | 184 | struct comedi_cmd *cmd = &async->cmd; |
498460eb | 185 | unsigned int i, j; |
498460eb JW |
186 | unsigned long elapsed_time; |
187 | unsigned int num_scans; | |
498460eb | 188 | |
73e0e4df IA |
189 | /* check command is still active */ |
190 | if (!test_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits)) | |
191 | return; | |
192 | ||
66d4da80 IA |
193 | elapsed_time = ktime_to_us(ktime_get()) - devpriv->ai_last_scan_time; |
194 | num_scans = elapsed_time / devpriv->scan_period; | |
498460eb | 195 | |
f5345d45 | 196 | num_scans = comedi_nscans_left(s, num_scans); |
498460eb | 197 | for (i = 0; i < num_scans; i++) { |
66d4da80 | 198 | unsigned int scan_remain_period = devpriv->scan_period; |
8fa8a260 | 199 | |
498460eb | 200 | for (j = 0; j < cmd->chanlist_len; j++) { |
0642c94b | 201 | unsigned short sample; |
33bd00ef | 202 | |
8fa8a260 IA |
203 | if (devpriv->usec_current >= devpriv->usec_period) |
204 | devpriv->usec_current %= devpriv->usec_period; | |
0642c94b IA |
205 | sample = fake_waveform(dev, CR_CHAN(cmd->chanlist[j]), |
206 | CR_RANGE(cmd->chanlist[j]), | |
8fa8a260 | 207 | devpriv->usec_current); |
88f9662a | 208 | comedi_buf_write_samples(s, &sample, 1); |
8fa8a260 IA |
209 | devpriv->usec_current += devpriv->convert_period; |
210 | scan_remain_period -= devpriv->convert_period; | |
498460eb | 211 | } |
8fa8a260 | 212 | devpriv->usec_current += scan_remain_period; |
66d4da80 | 213 | devpriv->ai_last_scan_time += devpriv->scan_period; |
498460eb | 214 | } |
8fa8a260 IA |
215 | if (devpriv->usec_current >= devpriv->usec_period) |
216 | devpriv->usec_current %= devpriv->usec_period; | |
498460eb | 217 | |
f5345d45 | 218 | if (cmd->stop_src == TRIG_COUNT && async->scans_done >= cmd->stop_arg) |
ea4f72b2 IA |
219 | async->events |= COMEDI_CB_EOA; |
220 | else | |
498460eb | 221 | mod_timer(&devpriv->timer, jiffies + 1); |
498460eb | 222 | |
24051247 | 223 | comedi_handle_events(dev, s); |
498460eb JW |
224 | } |
225 | ||
0a85b6f0 MT |
226 | static int waveform_ai_cmdtest(struct comedi_device *dev, |
227 | struct comedi_subdevice *s, | |
ea6d0d4c | 228 | struct comedi_cmd *cmd) |
498460eb JW |
229 | { |
230 | int err = 0; | |
5afdcad2 | 231 | unsigned int arg, limit; |
498460eb | 232 | |
27020ffe | 233 | /* Step 1 : check if triggers are trivially valid */ |
498460eb | 234 | |
61f76970 | 235 | err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW); |
783ddaeb IA |
236 | err |= comedi_check_trigger_src(&cmd->scan_begin_src, |
237 | TRIG_FOLLOW | TRIG_TIMER); | |
61f76970 IA |
238 | err |= comedi_check_trigger_src(&cmd->convert_src, |
239 | TRIG_NOW | TRIG_TIMER); | |
240 | err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT); | |
241 | err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE); | |
498460eb JW |
242 | |
243 | if (err) | |
244 | return 1; | |
245 | ||
27020ffe | 246 | /* Step 2a : make sure trigger sources are unique */ |
498460eb | 247 | |
61f76970 IA |
248 | err |= comedi_check_trigger_is_unique(cmd->convert_src); |
249 | err |= comedi_check_trigger_is_unique(cmd->stop_src); | |
27020ffe HS |
250 | |
251 | /* Step 2b : and mutually compatible */ | |
498460eb | 252 | |
783ddaeb IA |
253 | if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW) |
254 | err |= -EINVAL; /* scan period would be 0 */ | |
255 | ||
498460eb JW |
256 | if (err) |
257 | return 2; | |
258 | ||
df5daff8 HS |
259 | /* Step 3: check if arguments are trivially valid */ |
260 | ||
61f76970 | 261 | err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0); |
df5daff8 | 262 | |
783ddaeb | 263 | if (cmd->convert_src == TRIG_NOW) { |
61f76970 | 264 | err |= comedi_check_trigger_arg_is(&cmd->convert_arg, 0); |
783ddaeb IA |
265 | } else { /* cmd->convert_src == TRIG_TIMER */ |
266 | if (cmd->scan_begin_src == TRIG_FOLLOW) { | |
267 | err |= comedi_check_trigger_arg_min(&cmd->convert_arg, | |
268 | NSEC_PER_USEC); | |
269 | } | |
270 | } | |
498460eb | 271 | |
783ddaeb IA |
272 | if (cmd->scan_begin_src == TRIG_FOLLOW) { |
273 | err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, 0); | |
274 | } else { /* cmd->scan_begin_src == TRIG_TIMER */ | |
275 | err |= comedi_check_trigger_arg_min(&cmd->scan_begin_arg, | |
276 | NSEC_PER_USEC); | |
277 | } | |
498460eb | 278 | |
61f76970 IA |
279 | err |= comedi_check_trigger_arg_min(&cmd->chanlist_len, 1); |
280 | err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg, | |
281 | cmd->chanlist_len); | |
df5daff8 HS |
282 | |
283 | if (cmd->stop_src == TRIG_COUNT) | |
61f76970 | 284 | err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1); |
783ddaeb | 285 | else /* cmd->stop_src == TRIG_NONE */ |
61f76970 | 286 | err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0); |
498460eb JW |
287 | |
288 | if (err) | |
289 | return 3; | |
290 | ||
291 | /* step 4: fix up any arguments */ | |
292 | ||
498460eb | 293 | if (cmd->convert_src == TRIG_TIMER) { |
5afdcad2 | 294 | /* round convert_arg to nearest microsecond */ |
b2ef4813 | 295 | arg = cmd->convert_arg; |
5afdcad2 IA |
296 | arg = min(arg, |
297 | rounddown(UINT_MAX, (unsigned int)NSEC_PER_USEC)); | |
298 | arg = NSEC_PER_USEC * DIV_ROUND_CLOSEST(arg, NSEC_PER_USEC); | |
783ddaeb IA |
299 | if (cmd->scan_begin_arg == TRIG_TIMER) { |
300 | /* limit convert_arg to keep scan_begin_arg in range */ | |
301 | limit = UINT_MAX / cmd->scan_end_arg; | |
302 | limit = rounddown(limit, (unsigned int)NSEC_PER_SEC); | |
303 | arg = min(arg, limit); | |
304 | } | |
61f76970 | 305 | err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg); |
498460eb JW |
306 | } |
307 | ||
783ddaeb IA |
308 | if (cmd->scan_begin_src == TRIG_TIMER) { |
309 | /* round scan_begin_arg to nearest microsecond */ | |
310 | arg = cmd->scan_begin_arg; | |
311 | arg = min(arg, | |
312 | rounddown(UINT_MAX, (unsigned int)NSEC_PER_USEC)); | |
313 | arg = NSEC_PER_USEC * DIV_ROUND_CLOSEST(arg, NSEC_PER_USEC); | |
314 | if (cmd->convert_src == TRIG_TIMER) { | |
315 | /* but ensure scan_begin_arg is large enough */ | |
316 | arg = max(arg, cmd->convert_arg * cmd->scan_end_arg); | |
317 | } | |
318 | err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, arg); | |
5afdcad2 | 319 | } |
5afdcad2 | 320 | |
498460eb JW |
321 | if (err) |
322 | return 4; | |
323 | ||
324 | return 0; | |
325 | } | |
326 | ||
0a85b6f0 MT |
327 | static int waveform_ai_cmd(struct comedi_device *dev, |
328 | struct comedi_subdevice *s) | |
498460eb | 329 | { |
f1e5aa75 | 330 | struct waveform_private *devpriv = dev->private; |
ea6d0d4c | 331 | struct comedi_cmd *cmd = &s->async->cmd; |
66d4da80 | 332 | u64 usec_current; |
498460eb | 333 | |
51d66b29 | 334 | if (cmd->flags & CMDF_PRIORITY) { |
b8de3cc4 HS |
335 | dev_err(dev->class_dev, |
336 | "commands at RT priority not supported in this driver\n"); | |
498460eb JW |
337 | return -1; |
338 | } | |
339 | ||
498460eb JW |
340 | if (cmd->convert_src == TRIG_NOW) |
341 | devpriv->convert_period = 0; | |
783ddaeb | 342 | else /* cmd->convert_src == TRIG_TIMER */ |
87f64803 | 343 | devpriv->convert_period = cmd->convert_arg / NSEC_PER_USEC; |
498460eb | 344 | |
783ddaeb IA |
345 | if (cmd->scan_begin_src == TRIG_FOLLOW) { |
346 | devpriv->scan_period = devpriv->convert_period * | |
347 | cmd->scan_end_arg; | |
348 | } else { /* cmd->scan_begin_src == TRIG_TIMER */ | |
349 | devpriv->scan_period = cmd->scan_begin_arg / NSEC_PER_USEC; | |
350 | } | |
351 | ||
66d4da80 IA |
352 | devpriv->ai_last_scan_time = ktime_to_us(ktime_get()); |
353 | /* Determine time within waveform period. */ | |
354 | usec_current = devpriv->ai_last_scan_time; | |
355 | devpriv->usec_current = do_div(usec_current, devpriv->usec_period); | |
498460eb JW |
356 | |
357 | devpriv->timer.expires = jiffies + 1; | |
73e0e4df IA |
358 | /* mark command as active */ |
359 | smp_mb__before_atomic(); | |
360 | set_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits); | |
361 | smp_mb__after_atomic(); | |
498460eb JW |
362 | add_timer(&devpriv->timer); |
363 | return 0; | |
364 | } | |
365 | ||
0a85b6f0 MT |
366 | static int waveform_ai_cancel(struct comedi_device *dev, |
367 | struct comedi_subdevice *s) | |
498460eb | 368 | { |
f1e5aa75 HS |
369 | struct waveform_private *devpriv = dev->private; |
370 | ||
73e0e4df IA |
371 | /* mark command as no longer active */ |
372 | clear_bit(WAVEFORM_AI_RUNNING, &devpriv->state_bits); | |
373 | smp_mb__after_atomic(); | |
374 | /* cannot call del_timer_sync() as may be called from timer routine */ | |
375 | del_timer(&devpriv->timer); | |
498460eb JW |
376 | return 0; |
377 | } | |
378 | ||
0a85b6f0 MT |
379 | static int waveform_ai_insn_read(struct comedi_device *dev, |
380 | struct comedi_subdevice *s, | |
90035c08 | 381 | struct comedi_insn *insn, unsigned int *data) |
498460eb | 382 | { |
f1e5aa75 | 383 | struct waveform_private *devpriv = dev->private; |
498460eb JW |
384 | int i, chan = CR_CHAN(insn->chanspec); |
385 | ||
386 | for (i = 0; i < insn->n; i++) | |
387 | data[i] = devpriv->ao_loopbacks[chan]; | |
388 | ||
389 | return insn->n; | |
390 | } | |
391 | ||
0a85b6f0 MT |
392 | static int waveform_ao_insn_write(struct comedi_device *dev, |
393 | struct comedi_subdevice *s, | |
90035c08 | 394 | struct comedi_insn *insn, unsigned int *data) |
498460eb | 395 | { |
f1e5aa75 | 396 | struct waveform_private *devpriv = dev->private; |
498460eb JW |
397 | int i, chan = CR_CHAN(insn->chanspec); |
398 | ||
399 | for (i = 0; i < insn->n; i++) | |
400 | devpriv->ao_loopbacks[chan] = data[i]; | |
401 | ||
402 | return insn->n; | |
403 | } | |
90f703d3 | 404 | |
0eb0f278 HS |
405 | static int waveform_attach(struct comedi_device *dev, |
406 | struct comedi_devconfig *it) | |
407 | { | |
f1e5aa75 | 408 | struct waveform_private *devpriv; |
0eb0f278 HS |
409 | struct comedi_subdevice *s; |
410 | int amplitude = it->options[0]; | |
411 | int period = it->options[1]; | |
412 | int i; | |
8b6c5694 | 413 | int ret; |
0eb0f278 | 414 | |
0bdab509 | 415 | devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv)); |
c34fa261 HS |
416 | if (!devpriv) |
417 | return -ENOMEM; | |
0eb0f278 HS |
418 | |
419 | /* set default amplitude and period */ | |
420 | if (amplitude <= 0) | |
421 | amplitude = 1000000; /* 1 volt */ | |
422 | if (period <= 0) | |
423 | period = 100000; /* 0.1 sec */ | |
424 | ||
425 | devpriv->uvolt_amplitude = amplitude; | |
426 | devpriv->usec_period = period; | |
427 | ||
8b6c5694 HS |
428 | ret = comedi_alloc_subdevices(dev, 2); |
429 | if (ret) | |
430 | return ret; | |
0eb0f278 | 431 | |
713e5c35 | 432 | s = &dev->subdevices[0]; |
0eb0f278 HS |
433 | dev->read_subdev = s; |
434 | /* analog input subdevice */ | |
435 | s->type = COMEDI_SUBD_AI; | |
436 | s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ; | |
b1da4943 HS |
437 | s->n_chan = N_CHANS; |
438 | s->maxdata = 0xffff; | |
0eb0f278 HS |
439 | s->range_table = &waveform_ai_ranges; |
440 | s->len_chanlist = s->n_chan * 2; | |
441 | s->insn_read = waveform_ai_insn_read; | |
442 | s->do_cmd = waveform_ai_cmd; | |
443 | s->do_cmdtest = waveform_ai_cmdtest; | |
444 | s->cancel = waveform_ai_cancel; | |
445 | ||
713e5c35 | 446 | s = &dev->subdevices[1]; |
0eb0f278 HS |
447 | dev->write_subdev = s; |
448 | /* analog output subdevice (loopback) */ | |
449 | s->type = COMEDI_SUBD_AO; | |
ef49d832 | 450 | s->subdev_flags = SDF_WRITABLE | SDF_GROUND; |
b1da4943 HS |
451 | s->n_chan = N_CHANS; |
452 | s->maxdata = 0xffff; | |
0eb0f278 | 453 | s->range_table = &waveform_ai_ranges; |
0eb0f278 | 454 | s->insn_write = waveform_ao_insn_write; |
0eb0f278 HS |
455 | |
456 | /* Our default loopback value is just a 0V flatline */ | |
457 | for (i = 0; i < s->n_chan; i++) | |
458 | devpriv->ao_loopbacks[i] = s->maxdata / 2; | |
459 | ||
9a9bdd68 AM |
460 | setup_timer(&devpriv->timer, waveform_ai_interrupt, |
461 | (unsigned long)dev); | |
0eb0f278 | 462 | |
9ac6eb40 | 463 | dev_info(dev->class_dev, |
21ec1bf7 | 464 | "%s: %u microvolt, %u microsecond waveform attached\n", |
9254c841 NS |
465 | dev->board_name, |
466 | devpriv->uvolt_amplitude, devpriv->usec_period); | |
9ac6eb40 HS |
467 | |
468 | return 0; | |
0eb0f278 HS |
469 | } |
470 | ||
484ecc95 | 471 | static void waveform_detach(struct comedi_device *dev) |
0eb0f278 | 472 | { |
f1e5aa75 HS |
473 | struct waveform_private *devpriv = dev->private; |
474 | ||
475 | if (devpriv) | |
73e0e4df | 476 | del_timer_sync(&devpriv->timer); |
0eb0f278 HS |
477 | } |
478 | ||
0eb0f278 HS |
479 | static struct comedi_driver waveform_driver = { |
480 | .driver_name = "comedi_test", | |
481 | .module = THIS_MODULE, | |
482 | .attach = waveform_attach, | |
483 | .detach = waveform_detach, | |
0eb0f278 HS |
484 | }; |
485 | module_comedi_driver(waveform_driver); | |
486 | ||
90f703d3 AT |
487 | MODULE_AUTHOR("Comedi http://www.comedi.org"); |
488 | MODULE_DESCRIPTION("Comedi low-level driver"); | |
489 | MODULE_LICENSE("GPL"); |