2 include/linux/comedidev.h
3 header file for kernel-only structures, variables, and constants
5 COMEDI - Linux Control and Measurement Device Interface
6 Copyright (C) 1997-2000 David A. Schleef <ds@schleef.org>
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
22 #include <linux/dma-mapping.h>
23 #include <linux/mutex.h>
24 #include <linux/spinlock_types.h>
25 #include <linux/rwsem.h>
26 #include <linux/kref.h>
30 #define COMEDI_VERSION(a, b, c) (((a) << 16) + ((b) << 8) + (c))
31 #define COMEDI_VERSION_CODE COMEDI_VERSION(COMEDI_MAJORVERSION, \
32 COMEDI_MINORVERSION, COMEDI_MICROVERSION)
33 #define COMEDI_RELEASE VERSION
35 #define COMEDI_NUM_BOARD_MINORS 0x30
37 struct comedi_subdevice {
38 struct comedi_device *device;
43 int len_chanlist; /* maximum length of channel/gain list */
47 struct comedi_async *async;
56 unsigned int maxdata; /* if maxdata==0, use list */
57 const unsigned int *maxdata_list; /* list is channel specific */
59 const struct comedi_lrange *range_table;
60 const struct comedi_lrange *const *range_table_list;
62 unsigned int *chanlist; /* driver-owned chanlist (not used) */
64 int (*insn_read)(struct comedi_device *, struct comedi_subdevice *,
65 struct comedi_insn *, unsigned int *);
66 int (*insn_write)(struct comedi_device *, struct comedi_subdevice *,
67 struct comedi_insn *, unsigned int *);
68 int (*insn_bits)(struct comedi_device *, struct comedi_subdevice *,
69 struct comedi_insn *, unsigned int *);
70 int (*insn_config)(struct comedi_device *, struct comedi_subdevice *,
71 struct comedi_insn *, unsigned int *);
73 int (*do_cmd)(struct comedi_device *, struct comedi_subdevice *);
74 int (*do_cmdtest)(struct comedi_device *, struct comedi_subdevice *,
76 int (*poll)(struct comedi_device *, struct comedi_subdevice *);
77 int (*cancel)(struct comedi_device *, struct comedi_subdevice *);
79 /* called when the buffer changes */
80 int (*buf_change)(struct comedi_device *, struct comedi_subdevice *);
82 void (*munge)(struct comedi_device *dev, struct comedi_subdevice *s,
83 void *data, unsigned int num_bytes,
84 unsigned int start_chan_index);
85 enum dma_data_direction async_dma_dir;
89 struct device *class_dev;
92 unsigned int *readback;
95 struct comedi_buf_page {
100 struct comedi_buf_map {
101 struct device *dma_hw_dev;
102 struct comedi_buf_page *page_list;
103 unsigned int n_pages;
104 enum dma_data_direction dma_dir;
105 struct kref refcount;
109 * struct comedi_async - control data for asynchronous comedi commands
110 * @prealloc_buf: preallocated buffer
111 * @prealloc_bufsz: buffer size (in bytes)
112 * @buf_map: map of buffer pages
113 * @max_bufsize: maximum buffer size (in bytes)
114 * @buf_write_count: "write completed" count (in bytes, modulo 2**32)
115 * @buf_write_alloc_count: "allocated for writing" count (in bytes,
117 * @buf_read_count: "read completed" count (in bytes, modulo 2**32)
118 * @buf_read_alloc_count: "allocated for reading" count (in bytes,
120 * @buf_write_ptr: buffer position for writer
121 * @buf_read_ptr: buffer position for reader
122 * @cur_chan: current position in chanlist for scan (for those
123 * drivers that use it)
124 * @scans_done: the number of scans completed (COMEDI_CB_EOS)
125 * @scan_progress: amount received or sent for current scan (in bytes)
126 * @munge_chan: current position in chanlist for "munging"
127 * @munge_count: "munge" count (in bytes, modulo 2**32)
128 * @munge_ptr: buffer position for "munging"
129 * @events: bit-vector of events that have occurred
130 * @cmd: details of comedi command in progress
131 * @wait_head: task wait queue for file reader or writer
132 * @cb_mask: bit-vector of events that should wake waiting tasks
133 * @inttrig: software trigger function for command, or NULL
135 * Note about the ..._count and ..._ptr members:
137 * Think of the _Count values being integers of unlimited size, indexing
138 * into a buffer of infinite length (though only an advancing portion
139 * of the buffer of fixed length prealloc_bufsz is accessible at any time).
142 * Buf_Read_Count <= Buf_Read_Alloc_Count <= Munge_Count <=
143 * Buf_Write_Count <= Buf_Write_Alloc_Count <=
144 * (Buf_Read_Count + prealloc_bufsz)
146 * (Those aren't the actual members, apart from prealloc_bufsz.) When
147 * the buffer is reset, those _Count values start at 0 and only increase
148 * in value, maintaining the above inequalities until the next time the
149 * buffer is reset. The buffer is divided into the following regions by
152 * [0, Buf_Read_Count):
153 * old region no longer accessible
154 * [Buf_Read_Count, Buf_Read_Alloc_Count):
155 * filled and munged region allocated for reading but not yet read
156 * [Buf_Read_Alloc_Count, Munge_Count):
157 * filled and munged region not yet allocated for reading
158 * [Munge_Count, Buf_Write_Count):
159 * filled region not yet munged
160 * [Buf_Write_Count, Buf_Write_Alloc_Count):
161 * unfilled region allocated for writing but not yet written
162 * [Buf_Write_Alloc_Count, Buf_Read_Count + prealloc_bufsz):
163 * unfilled region not yet allocated for writing
164 * [Buf_Read_Count + prealloc_bufsz, infinity):
165 * unfilled region not yet accessible
167 * Data needs to be written into the buffer before it can be read out,
168 * and may need to be converted (or "munged") between the two
169 * operations. Extra unfilled buffer space may need to allocated for
170 * writing (advancing Buf_Write_Alloc_Count) before new data is written.
171 * After writing new data, the newly filled space needs to be released
172 * (advancing Buf_Write_Count). This also results in the new data being
173 * "munged" (advancing Munge_Count). Before data is read out of the
174 * buffer, extra space may need to be allocated for reading (advancing
175 * Buf_Read_Alloc_Count). After the data has been read out, the space
176 * needs to be released (advancing Buf_Read_Count).
178 * The actual members, buf_read_count, buf_read_alloc_count,
179 * munge_count, buf_write_count, and buf_write_alloc_count take the
180 * value of the corresponding capitalized _Count values modulo 2^32
181 * (UINT_MAX+1). Subtracting a "higher" _count value from a "lower"
182 * _count value gives the same answer as subtracting a "higher" _Count
183 * value from a lower _Count value because prealloc_bufsz < UINT_MAX+1.
184 * The modulo operation is done implicitly.
186 * The buf_read_ptr, munge_ptr, and buf_write_ptr members take the value
187 * of the corresponding capitalized _Count values modulo prealloc_bufsz.
188 * These correspond to byte indices in the physical buffer. The modulo
189 * operation is done by subtracting prealloc_bufsz when the value
190 * exceeds prealloc_bufsz (assuming prealloc_bufsz plus the increment is
191 * less than or equal to UINT_MAX).
193 struct comedi_async {
195 unsigned int prealloc_bufsz;
196 struct comedi_buf_map *buf_map;
197 unsigned int max_bufsize;
198 unsigned int buf_write_count;
199 unsigned int buf_write_alloc_count;
200 unsigned int buf_read_count;
201 unsigned int buf_read_alloc_count;
202 unsigned int buf_write_ptr;
203 unsigned int buf_read_ptr;
204 unsigned int cur_chan;
205 unsigned int scans_done;
206 unsigned int scan_progress;
207 unsigned int munge_chan;
208 unsigned int munge_count;
209 unsigned int munge_ptr;
211 struct comedi_cmd cmd;
212 wait_queue_head_t wait_head;
213 unsigned int cb_mask;
214 int (*inttrig)(struct comedi_device *dev, struct comedi_subdevice *s,
219 * comedi_async callback "events"
220 * @COMEDI_CB_EOS: end-of-scan
221 * @COMEDI_CB_EOA: end-of-acquisition/output
222 * @COMEDI_CB_BLOCK: data has arrived, wakes up read() / write()
223 * @COMEDI_CB_EOBUF: DEPRECATED: end of buffer
224 * @COMEDI_CB_ERROR: card error during acquisition
225 * @COMEDI_CB_OVERFLOW: buffer overflow/underflow
227 * @COMEDI_CB_ERROR_MASK: events that indicate an error has occurred
228 * @COMEDI_CB_CANCEL_MASK: events that will cancel an async command
230 #define COMEDI_CB_EOS (1 << 0)
231 #define COMEDI_CB_EOA (1 << 1)
232 #define COMEDI_CB_BLOCK (1 << 2)
233 #define COMEDI_CB_EOBUF (1 << 3)
234 #define COMEDI_CB_ERROR (1 << 4)
235 #define COMEDI_CB_OVERFLOW (1 << 5)
237 #define COMEDI_CB_ERROR_MASK (COMEDI_CB_ERROR | COMEDI_CB_OVERFLOW)
238 #define COMEDI_CB_CANCEL_MASK (COMEDI_CB_EOA | COMEDI_CB_ERROR_MASK)
240 struct comedi_driver {
241 struct comedi_driver *next;
243 const char *driver_name;
244 struct module *module;
245 int (*attach)(struct comedi_device *, struct comedi_devconfig *);
246 void (*detach)(struct comedi_device *);
247 int (*auto_attach)(struct comedi_device *, unsigned long);
249 /* number of elements in board_name and board_id arrays */
250 unsigned int num_names;
251 const char *const *board_name;
252 /* offset in bytes from one board name pointer to the next */
256 struct comedi_device {
258 struct comedi_driver *driver;
259 struct comedi_8254 *pacer;
262 struct device *class_dev;
264 unsigned int detach_count;
265 /* hw_dev is passed to dma_alloc_coherent when allocating async buffers
266 * for subdevices that have async_dma_dir set to something other than
268 struct device *hw_dev;
270 const char *board_name;
271 const void *board_ptr;
276 struct rw_semaphore attach_lock;
277 struct kref refcount;
280 struct comedi_subdevice *subdevices;
284 unsigned long iobase;
288 struct comedi_subdevice *read_subdev;
289 struct comedi_subdevice *write_subdev;
291 struct fasync_struct *async_queue;
293 int (*open)(struct comedi_device *dev);
294 void (*close)(struct comedi_device *dev);
298 * function prototypes
301 void comedi_event(struct comedi_device *dev, struct comedi_subdevice *s);
303 struct comedi_device *comedi_dev_get_from_minor(unsigned minor);
304 int comedi_dev_put(struct comedi_device *dev);
307 * comedi_subdevice "runflags"
308 * @COMEDI_SRF_RT: DEPRECATED: command is running real-time
309 * @COMEDI_SRF_ERROR: indicates an COMEDI_CB_ERROR event has occurred
310 * since the last command was started
311 * @COMEDI_SRF_RUNNING: command is running
312 * @COMEDI_SRF_FREE_SPRIV: free s->private on detach
314 * @COMEDI_SRF_BUSY_MASK: runflags that indicate the subdevice is "busy"
316 #define COMEDI_SRF_RT BIT(1)
317 #define COMEDI_SRF_ERROR BIT(2)
318 #define COMEDI_SRF_RUNNING BIT(27)
319 #define COMEDI_SRF_FREE_SPRIV BIT(31)
321 #define COMEDI_SRF_BUSY_MASK (COMEDI_SRF_ERROR | COMEDI_SRF_RUNNING)
323 bool comedi_is_subdevice_running(struct comedi_subdevice *s);
325 void *comedi_alloc_spriv(struct comedi_subdevice *s, size_t size);
327 int comedi_check_chanlist(struct comedi_subdevice *s,
329 unsigned int *chanlist);
333 #define RANGE(a, b) {(a)*1e6, (b)*1e6, 0}
334 #define RANGE_ext(a, b) {(a)*1e6, (b)*1e6, RF_EXTERNAL}
335 #define RANGE_mA(a, b) {(a)*1e6, (b)*1e6, UNIT_mA}
336 #define RANGE_unitless(a, b) {(a)*1e6, (b)*1e6, 0}
337 #define BIP_RANGE(a) {-(a)*1e6, (a)*1e6, 0}
338 #define UNI_RANGE(a) {0, (a)*1e6, 0}
340 extern const struct comedi_lrange range_bipolar10;
341 extern const struct comedi_lrange range_bipolar5;
342 extern const struct comedi_lrange range_bipolar2_5;
343 extern const struct comedi_lrange range_unipolar10;
344 extern const struct comedi_lrange range_unipolar5;
345 extern const struct comedi_lrange range_unipolar2_5;
346 extern const struct comedi_lrange range_0_20mA;
347 extern const struct comedi_lrange range_4_20mA;
348 extern const struct comedi_lrange range_0_32mA;
349 extern const struct comedi_lrange range_unknown;
351 #define range_digital range_unipolar5
354 #define GCC_ZERO_LENGTH_ARRAY
356 #define GCC_ZERO_LENGTH_ARRAY 0
359 struct comedi_lrange {
361 struct comedi_krange range[GCC_ZERO_LENGTH_ARRAY];
364 static inline bool comedi_range_is_bipolar(struct comedi_subdevice *s,
367 return s->range_table->range[range].min < 0;
370 static inline bool comedi_range_is_unipolar(struct comedi_subdevice *s,
373 return s->range_table->range[range].min >= 0;
376 static inline bool comedi_range_is_external(struct comedi_subdevice *s,
379 return !!(s->range_table->range[range].flags & RF_EXTERNAL);
382 static inline bool comedi_chan_range_is_bipolar(struct comedi_subdevice *s,
386 return s->range_table_list[chan]->range[range].min < 0;
389 static inline bool comedi_chan_range_is_unipolar(struct comedi_subdevice *s,
393 return s->range_table_list[chan]->range[range].min >= 0;
396 static inline bool comedi_chan_range_is_external(struct comedi_subdevice *s,
400 return !!(s->range_table_list[chan]->range[range].flags & RF_EXTERNAL);
403 /* munge between offset binary and two's complement values */
404 static inline unsigned int comedi_offset_munge(struct comedi_subdevice *s,
407 return val ^ s->maxdata ^ (s->maxdata >> 1);
411 * comedi_bytes_per_sample - determine subdevice sample size
412 * @s: comedi_subdevice struct
414 * The sample size will be 4 (sizeof int) or 2 (sizeof short) depending on
415 * whether the SDF_LSAMPL subdevice flag is set or not.
417 * Returns the subdevice sample size.
419 static inline unsigned int comedi_bytes_per_sample(struct comedi_subdevice *s)
421 return s->subdev_flags & SDF_LSAMPL ? sizeof(int) : sizeof(short);
425 * comedi_sample_shift - determine log2 of subdevice sample size
426 * @s: comedi_subdevice struct
428 * The sample size will be 4 (sizeof int) or 2 (sizeof short) depending on
429 * whether the SDF_LSAMPL subdevice flag is set or not. The log2 of the
430 * sample size will be 2 or 1 and can be used as the right operand of a
431 * bit-shift operator to multiply or divide something by the sample size.
433 * Returns log2 of the subdevice sample size.
435 static inline unsigned int comedi_sample_shift(struct comedi_subdevice *s)
437 return s->subdev_flags & SDF_LSAMPL ? 2 : 1;
441 * comedi_bytes_to_samples - converts a number of bytes to a number of samples
442 * @s: comedi_subdevice struct
443 * @nbytes: number of bytes
445 * Returns the number of bytes divided by the subdevice sample size.
447 static inline unsigned int comedi_bytes_to_samples(struct comedi_subdevice *s,
450 return nbytes >> comedi_sample_shift(s);
454 * comedi_samples_to_bytes - converts a number of samples to a number of bytes
455 * @s: comedi_subdevice struct
456 * @nsamples: number of samples
458 * Returns the number of samples multiplied by the subdevice sample size.
459 * Does not check for arithmetic overflow.
461 static inline unsigned int comedi_samples_to_bytes(struct comedi_subdevice *s,
462 unsigned int nsamples)
464 return nsamples << comedi_sample_shift(s);
468 * comedi_check_trigger_src() - trivially validate a comedi_cmd trigger source
469 * @src: pointer to the trigger source to validate
470 * @flags: bitmask of valid TRIG_* for the trigger
472 * This is used in "step 1" of the do_cmdtest functions of comedi drivers
473 * to vaildate the comedi_cmd triggers. The mask of the @src against the
474 * @flags allows the userspace comedilib to pass all the comedi_cmd
475 * triggers as TRIG_ANY and get back a bitmask of the valid trigger sources.
477 static inline int comedi_check_trigger_src(unsigned int *src,
480 unsigned int orig_src = *src;
482 *src = orig_src & flags;
483 if (*src == TRIG_INVALID || *src != orig_src)
489 * comedi_check_trigger_is_unique() - make sure a trigger source is unique
490 * @src: the trigger source to check
492 static inline int comedi_check_trigger_is_unique(unsigned int src)
494 /* this test is true if more than one _src bit is set */
495 if ((src & (src - 1)) != 0)
501 * comedi_check_trigger_arg_is() - trivially validate a trigger argument
502 * @arg: pointer to the trigger arg to validate
503 * @val: the value the argument should be
505 static inline int comedi_check_trigger_arg_is(unsigned int *arg,
516 * comedi_check_trigger_arg_min() - trivially validate a trigger argument
517 * @arg: pointer to the trigger arg to validate
518 * @val: the minimum value the argument should be
520 static inline int comedi_check_trigger_arg_min(unsigned int *arg,
531 * comedi_check_trigger_arg_max() - trivially validate a trigger argument
532 * @arg: pointer to the trigger arg to validate
533 * @val: the maximum value the argument should be
535 static inline int comedi_check_trigger_arg_max(unsigned int *arg,
546 * Must set dev->hw_dev if you wish to dma directly into comedi's buffer.
547 * Also useful for retrieving a previously configured hardware device of
548 * known bus type. Set automatically for auto-configured devices.
549 * Automatically set to NULL when detaching hardware device.
551 int comedi_set_hw_dev(struct comedi_device *dev, struct device *hw_dev);
553 static inline unsigned int comedi_buf_n_bytes_ready(struct comedi_subdevice *s)
555 return s->async->buf_write_count - s->async->buf_read_count;
558 unsigned int comedi_buf_write_alloc(struct comedi_subdevice *s, unsigned int n);
559 unsigned int comedi_buf_write_free(struct comedi_subdevice *s, unsigned int n);
561 unsigned int comedi_buf_read_n_available(struct comedi_subdevice *s);
562 unsigned int comedi_buf_read_alloc(struct comedi_subdevice *s, unsigned int n);
563 unsigned int comedi_buf_read_free(struct comedi_subdevice *s, unsigned int n);
565 unsigned int comedi_buf_write_samples(struct comedi_subdevice *s,
566 const void *data, unsigned int nsamples);
567 unsigned int comedi_buf_read_samples(struct comedi_subdevice *s,
568 void *data, unsigned int nsamples);
570 /* drivers.c - general comedi driver functions */
572 #define COMEDI_TIMEOUT_MS 1000
574 int comedi_timeout(struct comedi_device *, struct comedi_subdevice *,
575 struct comedi_insn *,
576 int (*cb)(struct comedi_device *, struct comedi_subdevice *,
577 struct comedi_insn *, unsigned long context),
578 unsigned long context);
580 unsigned int comedi_handle_events(struct comedi_device *dev,
581 struct comedi_subdevice *s);
583 int comedi_dio_insn_config(struct comedi_device *, struct comedi_subdevice *,
584 struct comedi_insn *, unsigned int *data,
586 unsigned int comedi_dio_update_state(struct comedi_subdevice *,
588 unsigned int comedi_bytes_per_scan(struct comedi_subdevice *s);
589 unsigned int comedi_nscans_left(struct comedi_subdevice *s,
590 unsigned int nscans);
591 unsigned int comedi_nsamples_left(struct comedi_subdevice *s,
592 unsigned int nsamples);
593 void comedi_inc_scan_progress(struct comedi_subdevice *s,
594 unsigned int num_bytes);
596 void *comedi_alloc_devpriv(struct comedi_device *, size_t);
597 int comedi_alloc_subdevices(struct comedi_device *, int);
598 int comedi_alloc_subdev_readback(struct comedi_subdevice *);
600 int comedi_readback_insn_read(struct comedi_device *, struct comedi_subdevice *,
601 struct comedi_insn *, unsigned int *data);
603 int comedi_load_firmware(struct comedi_device *, struct device *,
605 int (*cb)(struct comedi_device *,
606 const u8 *data, size_t size,
607 unsigned long context),
608 unsigned long context);
610 int __comedi_request_region(struct comedi_device *,
611 unsigned long start, unsigned long len);
612 int comedi_request_region(struct comedi_device *,
613 unsigned long start, unsigned long len);
614 void comedi_legacy_detach(struct comedi_device *);
616 int comedi_auto_config(struct device *, struct comedi_driver *,
617 unsigned long context);
618 void comedi_auto_unconfig(struct device *);
620 int comedi_driver_register(struct comedi_driver *);
621 void comedi_driver_unregister(struct comedi_driver *);
624 * module_comedi_driver() - Helper macro for registering a comedi driver
625 * @__comedi_driver: comedi_driver struct
627 * Helper macro for comedi drivers which do not do anything special in module
628 * init/exit. This eliminates a lot of boilerplate. Each module may only use
629 * this macro once, and calling it replaces module_init() and module_exit().
631 #define module_comedi_driver(__comedi_driver) \
632 module_driver(__comedi_driver, comedi_driver_register, \
633 comedi_driver_unregister)
635 #endif /* _COMEDIDEV_H */