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.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #define __NO_VERSION__
27 #include "comedi_fops.h"
28 #include "comedi_compat32.h"
30 #include <linux/module.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/sched.h>
34 #include <linux/fcntl.h>
35 #include <linux/delay.h>
36 #include <linux/ioport.h>
38 #include <linux/slab.h>
39 #include <linux/kmod.h>
40 #include <linux/poll.h>
41 #include <linux/init.h>
42 #include <linux/device.h>
43 #include <linux/vmalloc.h>
45 #include "comedidev.h"
46 #include <linux/cdev.h>
47 #include <linux/stat.h>
50 #include <linux/uaccess.h>
52 /* #include "kvmem.h" */
54 MODULE_AUTHOR("http://www.comedi.org");
55 MODULE_DESCRIPTION("Comedi core module");
56 MODULE_LICENSE("GPL");
58 #ifdef CONFIG_COMEDI_DEBUG
60 module_param(comedi_debug
, int, 0644);
63 int comedi_autoconfig
= 1;
64 module_param(comedi_autoconfig
, bool, 0444);
66 int comedi_num_legacy_minors
= 0;
67 module_param(comedi_num_legacy_minors
, int, 0444);
69 static DEFINE_SPINLOCK(comedi_file_info_table_lock
);
70 static struct comedi_device_file_info
71 *comedi_file_info_table
[COMEDI_NUM_MINORS
];
73 static int do_devconfig_ioctl(struct comedi_device
*dev
, struct comedi_devconfig
*arg
);
74 static int do_bufconfig_ioctl(struct comedi_device
*dev
, void *arg
);
75 static int do_devinfo_ioctl(struct comedi_device
*dev
, struct comedi_devinfo
*arg
,
77 static int do_subdinfo_ioctl(struct comedi_device
*dev
, struct comedi_subdinfo
*arg
,
79 static int do_chaninfo_ioctl(struct comedi_device
*dev
, struct comedi_chaninfo
*arg
);
80 static int do_bufinfo_ioctl(struct comedi_device
*dev
, void *arg
);
81 static int do_cmd_ioctl(struct comedi_device
*dev
, void *arg
, void *file
);
82 static int do_lock_ioctl(struct comedi_device
*dev
, unsigned int arg
, void *file
);
83 static int do_unlock_ioctl(struct comedi_device
*dev
, unsigned int arg
, void *file
);
84 static int do_cancel_ioctl(struct comedi_device
*dev
, unsigned int arg
, void *file
);
85 static int do_cmdtest_ioctl(struct comedi_device
*dev
, void *arg
, void *file
);
86 static int do_insnlist_ioctl(struct comedi_device
*dev
, void *arg
, void *file
);
87 static int do_insn_ioctl(struct comedi_device
*dev
, void *arg
, void *file
);
88 static int do_poll_ioctl(struct comedi_device
*dev
, unsigned int subd
, void *file
);
90 extern void do_become_nonbusy(struct comedi_device
*dev
, struct comedi_subdevice
*s
);
91 static int do_cancel(struct comedi_device
*dev
, struct comedi_subdevice
*s
);
93 static int comedi_fasync(int fd
, struct file
*file
, int on
);
95 static int is_device_busy(struct comedi_device
*dev
);
96 static int resize_async_buffer(struct comedi_device
*dev
,
97 struct comedi_subdevice
*s
,
98 struct comedi_async
*async
, unsigned new_size
);
100 /* declarations for sysfs attribute files */
101 static struct device_attribute dev_attr_max_read_buffer_kb
;
102 static struct device_attribute dev_attr_read_buffer_kb
;
103 static struct device_attribute dev_attr_max_write_buffer_kb
;
104 static struct device_attribute dev_attr_write_buffer_kb
;
106 #ifdef HAVE_UNLOCKED_IOCTL
107 static long comedi_unlocked_ioctl(struct file
*file
, unsigned int cmd
,
110 static int comedi_ioctl(struct inode
*inode
, struct file
*file
,
111 unsigned int cmd
, unsigned long arg
)
114 const unsigned minor
= iminor(file
->f_dentry
->d_inode
);
115 struct comedi_device_file_info
*dev_file_info
=
116 comedi_get_device_file_info(minor
);
117 struct comedi_device
*dev
;
120 if (dev_file_info
== NULL
|| dev_file_info
->device
== NULL
)
122 dev
= dev_file_info
->device
;
124 mutex_lock(&dev
->mutex
);
126 /* Device config is special, because it must work on
127 * an unconfigured device. */
128 if (cmd
== COMEDI_DEVCONFIG
) {
129 rc
= do_devconfig_ioctl(dev
, (void *)arg
);
133 if (!dev
->attached
) {
134 DPRINTK("no driver configured on /dev/comedi%i\n", dev
->minor
);
140 case COMEDI_BUFCONFIG
:
141 rc
= do_bufconfig_ioctl(dev
, (void *)arg
);
144 rc
= do_devinfo_ioctl(dev
, (void *)arg
, file
);
146 case COMEDI_SUBDINFO
:
147 rc
= do_subdinfo_ioctl(dev
, (void *)arg
, file
);
149 case COMEDI_CHANINFO
:
150 rc
= do_chaninfo_ioctl(dev
, (void *)arg
);
152 case COMEDI_RANGEINFO
:
153 rc
= do_rangeinfo_ioctl(dev
, (void *)arg
);
156 rc
= do_bufinfo_ioctl(dev
, (void *)arg
);
159 rc
= do_lock_ioctl(dev
, arg
, file
);
162 rc
= do_unlock_ioctl(dev
, arg
, file
);
165 rc
= do_cancel_ioctl(dev
, arg
, file
);
168 rc
= do_cmd_ioctl(dev
, (void *)arg
, file
);
171 rc
= do_cmdtest_ioctl(dev
, (void *)arg
, file
);
173 case COMEDI_INSNLIST
:
174 rc
= do_insnlist_ioctl(dev
, (void *)arg
, file
);
177 rc
= do_insn_ioctl(dev
, (void *)arg
, file
);
180 rc
= do_poll_ioctl(dev
, arg
, file
);
188 mutex_unlock(&dev
->mutex
);
197 pointer to devconfig structure
200 devconfig structure at arg
205 static int do_devconfig_ioctl(struct comedi_device
*dev
, struct comedi_devconfig
*arg
)
207 struct comedi_devconfig it
;
209 unsigned char *aux_data
= NULL
;
212 if (!capable(CAP_SYS_ADMIN
))
216 if (is_device_busy(dev
))
219 struct module
*driver_module
= dev
->driver
->module
;
220 comedi_device_detach(dev
);
221 module_put(driver_module
);
226 if (copy_from_user(&it
, arg
, sizeof(struct comedi_devconfig
)))
229 it
.board_name
[COMEDI_NAMELEN
- 1] = 0;
231 if (comedi_aux_data(it
.options
, 0) &&
232 it
.options
[COMEDI_DEVCONF_AUX_DATA_LENGTH
]) {
234 aux_len
= it
.options
[COMEDI_DEVCONF_AUX_DATA_LENGTH
];
238 aux_data
= vmalloc(aux_len
);
242 if (copy_from_user(aux_data
,
243 comedi_aux_data(it
.options
, 0), aux_len
)) {
247 it
.options
[COMEDI_DEVCONF_AUX_DATA_LO
] =
248 (unsigned long)aux_data
;
249 if (sizeof(void *) > sizeof(int)) {
250 bit_shift
= sizeof(int) * 8;
251 it
.options
[COMEDI_DEVCONF_AUX_DATA_HI
] =
252 ((unsigned long)aux_data
) >> bit_shift
;
254 it
.options
[COMEDI_DEVCONF_AUX_DATA_HI
] = 0;
257 ret
= comedi_device_attach(dev
, &it
);
259 if (!try_module_get(dev
->driver
->module
)) {
260 comedi_device_detach(dev
);
273 buffer configuration ioctl
276 pointer to bufconfig structure
282 modified bufconfig at arg
285 static int do_bufconfig_ioctl(struct comedi_device
*dev
, void *arg
)
287 struct comedi_bufconfig bc
;
288 struct comedi_async
*async
;
289 struct comedi_subdevice
*s
;
292 if (copy_from_user(&bc
, arg
, sizeof(struct comedi_bufconfig
)))
295 if (bc
.subdevice
>= dev
->n_subdevices
|| bc
.subdevice
< 0)
298 s
= dev
->subdevices
+ bc
.subdevice
;
302 DPRINTK("subdevice does not have async capability\n");
308 if (bc
.maximum_size
) {
309 if (!capable(CAP_SYS_ADMIN
))
312 async
->max_bufsize
= bc
.maximum_size
;
316 retval
= resize_async_buffer(dev
, s
, async
, bc
.size
);
321 bc
.size
= async
->prealloc_bufsz
;
322 bc
.maximum_size
= async
->max_bufsize
;
325 if (copy_to_user(arg
, &bc
, sizeof(struct comedi_bufconfig
)))
336 pointer to devinfo structure
345 static int do_devinfo_ioctl(struct comedi_device
*dev
, struct comedi_devinfo
*arg
,
348 struct comedi_devinfo devinfo
;
349 const unsigned minor
= iminor(file
->f_dentry
->d_inode
);
350 struct comedi_device_file_info
*dev_file_info
=
351 comedi_get_device_file_info(minor
);
352 struct comedi_subdevice
*read_subdev
=
353 comedi_get_read_subdevice(dev_file_info
);
354 struct comedi_subdevice
*write_subdev
=
355 comedi_get_write_subdevice(dev_file_info
);
357 memset(&devinfo
, 0, sizeof(devinfo
));
359 /* fill devinfo structure */
360 devinfo
.version_code
= COMEDI_VERSION_CODE
;
361 devinfo
.n_subdevs
= dev
->n_subdevices
;
362 memcpy(devinfo
.driver_name
, dev
->driver
->driver_name
, COMEDI_NAMELEN
);
363 memcpy(devinfo
.board_name
, dev
->board_name
, COMEDI_NAMELEN
);
366 devinfo
.read_subdevice
= read_subdev
- dev
->subdevices
;
368 devinfo
.read_subdevice
= -1;
371 devinfo
.write_subdevice
= write_subdev
- dev
->subdevices
;
373 devinfo
.write_subdevice
= -1;
375 if (copy_to_user(arg
, &devinfo
, sizeof(struct comedi_devinfo
)))
386 pointer to array of subdevice info structures
392 array of subdevice info structures at arg
395 static int do_subdinfo_ioctl(struct comedi_device
*dev
, struct comedi_subdinfo
*arg
,
399 struct comedi_subdinfo
*tmp
, *us
;
400 struct comedi_subdevice
*s
;
402 tmp
= kcalloc(dev
->n_subdevices
, sizeof(struct comedi_subdinfo
), GFP_KERNEL
);
406 /* fill subdinfo structs */
407 for (i
= 0; i
< dev
->n_subdevices
; i
++) {
408 s
= dev
->subdevices
+ i
;
412 us
->n_chan
= s
->n_chan
;
413 us
->subd_flags
= s
->subdev_flags
;
414 if (comedi_get_subdevice_runflags(s
) & SRF_RUNNING
)
415 us
->subd_flags
|= SDF_RUNNING
;
416 #define TIMER_nanosec 5 /* backwards compatibility */
417 us
->timer_type
= TIMER_nanosec
;
418 us
->len_chanlist
= s
->len_chanlist
;
419 us
->maxdata
= s
->maxdata
;
420 if (s
->range_table
) {
422 (i
<< 24) | (0 << 16) | (s
->range_table
->length
);
424 us
->range_type
= 0; /* XXX */
426 us
->flags
= s
->flags
;
429 us
->subd_flags
|= SDF_BUSY
;
431 us
->subd_flags
|= SDF_BUSY_OWNER
;
433 us
->subd_flags
|= SDF_LOCKED
;
435 us
->subd_flags
|= SDF_LOCK_OWNER
;
436 if (!s
->maxdata
&& s
->maxdata_list
)
437 us
->subd_flags
|= SDF_MAXDATA
;
439 us
->subd_flags
|= SDF_FLAGS
;
440 if (s
->range_table_list
)
441 us
->subd_flags
|= SDF_RANGETYPE
;
443 us
->subd_flags
|= SDF_CMD
;
445 if (s
->insn_bits
!= &insn_inval
)
446 us
->insn_bits_support
= COMEDI_SUPPORTED
;
448 us
->insn_bits_support
= COMEDI_UNSUPPORTED
;
450 us
->settling_time_0
= s
->settling_time_0
;
453 ret
= copy_to_user(arg
, tmp
,
454 dev
->n_subdevices
* sizeof(struct comedi_subdinfo
));
458 return ret
? -EFAULT
: 0;
466 pointer to chaninfo structure
469 chaninfo structure at arg
472 arrays at elements of chaninfo structure
475 static int do_chaninfo_ioctl(struct comedi_device
*dev
, struct comedi_chaninfo
*arg
)
477 struct comedi_subdevice
*s
;
478 struct comedi_chaninfo it
;
480 if (copy_from_user(&it
, arg
, sizeof(struct comedi_chaninfo
)))
483 if (it
.subdev
>= dev
->n_subdevices
)
485 s
= dev
->subdevices
+ it
.subdev
;
487 if (it
.maxdata_list
) {
488 if (s
->maxdata
|| !s
->maxdata_list
)
490 if (copy_to_user(it
.maxdata_list
, s
->maxdata_list
,
491 s
->n_chan
* sizeof(unsigned int)))
498 if (copy_to_user(it
.flaglist
, s
->flaglist
,
499 s
->n_chan
* sizeof(unsigned int)))
506 if (!s
->range_table_list
)
508 for (i
= 0; i
< s
->n_chan
; i
++) {
511 x
= (dev
->minor
<< 28) | (it
.subdev
<< 24) | (i
<< 16) |
512 (s
->range_table_list
[i
]->length
);
513 put_user(x
, it
.rangelist
+ i
);
516 if (copy_to_user(it
.rangelist
, s
->range_type_list
,
517 s
->n_chan
*sizeof(unsigned int)))
527 buffer information ioctl
530 pointer to bufinfo structure
536 modified bufinfo at arg
539 static int do_bufinfo_ioctl(struct comedi_device
*dev
, void *arg
)
541 struct comedi_bufinfo bi
;
542 struct comedi_subdevice
*s
;
543 struct comedi_async
*async
;
545 if (copy_from_user(&bi
, arg
, sizeof(struct comedi_bufinfo
)))
548 if (bi
.subdevice
>= dev
->n_subdevices
|| bi
.subdevice
< 0)
551 s
= dev
->subdevices
+ bi
.subdevice
;
555 DPRINTK("subdevice does not have async capability\n");
556 bi
.buf_write_ptr
= 0;
558 bi
.buf_write_count
= 0;
559 bi
.buf_read_count
= 0;
563 if (bi
.bytes_read
&& (s
->subdev_flags
& SDF_CMD_READ
)) {
564 bi
.bytes_read
= comedi_buf_read_alloc(async
, bi
.bytes_read
);
565 comedi_buf_read_free(async
, bi
.bytes_read
);
567 if (!(comedi_get_subdevice_runflags(s
) & (SRF_ERROR
|
569 && async
->buf_write_count
== async
->buf_read_count
) {
570 do_become_nonbusy(dev
, s
);
574 if (bi
.bytes_written
&& (s
->subdev_flags
& SDF_CMD_WRITE
)) {
576 comedi_buf_write_alloc(async
, bi
.bytes_written
);
577 comedi_buf_write_free(async
, bi
.bytes_written
);
580 bi
.buf_write_count
= async
->buf_write_count
;
581 bi
.buf_write_ptr
= async
->buf_write_ptr
;
582 bi
.buf_read_count
= async
->buf_read_count
;
583 bi
.buf_read_ptr
= async
->buf_read_ptr
;
586 if (copy_to_user(arg
, &bi
, sizeof(struct comedi_bufinfo
)))
592 static int parse_insn(struct comedi_device
*dev
, struct comedi_insn
*insn
, unsigned int *data
,
596 * synchronous instructions
599 * pointer to sync cmd structure
602 * sync cmd struct at arg
609 /* arbitrary limits */
610 #define MAX_SAMPLES 256
611 static int do_insnlist_ioctl(struct comedi_device
*dev
, void *arg
, void *file
)
613 struct comedi_insnlist insnlist
;
614 struct comedi_insn
*insns
= NULL
;
615 unsigned int *data
= NULL
;
619 if (copy_from_user(&insnlist
, arg
, sizeof(struct comedi_insnlist
)))
622 data
= kmalloc(sizeof(unsigned int) * MAX_SAMPLES
, GFP_KERNEL
);
624 DPRINTK("kmalloc failed\n");
629 insns
= kmalloc(sizeof(struct comedi_insn
) * insnlist
.n_insns
, GFP_KERNEL
);
631 DPRINTK("kmalloc failed\n");
636 if (copy_from_user(insns
, insnlist
.insns
,
637 sizeof(struct comedi_insn
) * insnlist
.n_insns
)) {
638 DPRINTK("copy_from_user failed\n");
643 for (i
= 0; i
< insnlist
.n_insns
; i
++) {
644 if (insns
[i
].n
> MAX_SAMPLES
) {
645 DPRINTK("number of samples too large\n");
649 if (insns
[i
].insn
& INSN_MASK_WRITE
) {
650 if (copy_from_user(data
, insns
[i
].data
,
651 insns
[i
].n
* sizeof(unsigned int))) {
652 DPRINTK("copy_from_user failed\n");
657 ret
= parse_insn(dev
, insns
+ i
, data
, file
);
660 if (insns
[i
].insn
& INSN_MASK_READ
) {
661 if (copy_to_user(insns
[i
].data
, data
,
662 insns
[i
].n
* sizeof(unsigned int))) {
663 DPRINTK("copy_to_user failed\n");
681 static int check_insn_config_length(struct comedi_insn
*insn
, unsigned int *data
)
687 case INSN_CONFIG_DIO_OUTPUT
:
688 case INSN_CONFIG_DIO_INPUT
:
689 case INSN_CONFIG_DISARM
:
690 case INSN_CONFIG_RESET
:
694 case INSN_CONFIG_ARM
:
695 case INSN_CONFIG_DIO_QUERY
:
696 case INSN_CONFIG_BLOCK_SIZE
:
697 case INSN_CONFIG_FILTER
:
698 case INSN_CONFIG_SERIAL_CLOCK
:
699 case INSN_CONFIG_BIDIRECTIONAL_DATA
:
700 case INSN_CONFIG_ALT_SOURCE
:
701 case INSN_CONFIG_SET_COUNTER_MODE
:
702 case INSN_CONFIG_8254_READ_STATUS
:
703 case INSN_CONFIG_SET_ROUTING
:
704 case INSN_CONFIG_GET_ROUTING
:
705 case INSN_CONFIG_GET_PWM_STATUS
:
706 case INSN_CONFIG_PWM_SET_PERIOD
:
707 case INSN_CONFIG_PWM_GET_PERIOD
:
711 case INSN_CONFIG_SET_GATE_SRC
:
712 case INSN_CONFIG_GET_GATE_SRC
:
713 case INSN_CONFIG_SET_CLOCK_SRC
:
714 case INSN_CONFIG_GET_CLOCK_SRC
:
715 case INSN_CONFIG_SET_OTHER_SRC
:
716 case INSN_CONFIG_GET_COUNTER_STATUS
:
717 case INSN_CONFIG_PWM_SET_H_BRIDGE
:
718 case INSN_CONFIG_PWM_GET_H_BRIDGE
:
719 case INSN_CONFIG_GET_HARDWARE_BUFFER_SIZE
:
723 case INSN_CONFIG_PWM_OUTPUT
:
724 case INSN_CONFIG_ANALOG_TRIG
:
728 /* by default we allow the insn since we don't have checks for
729 * all possible cases yet */
731 printk("comedi: no check for data length of config insn id "
732 "%i is implemented.\n"
733 " Add a check to %s in %s.\n"
734 " Assuming n=%i is correct.\n", data
[0], __func__
,
742 static int parse_insn(struct comedi_device
*dev
, struct comedi_insn
*insn
, unsigned int *data
,
745 struct comedi_subdevice
*s
;
749 if (insn
->insn
& INSN_MASK_SPECIAL
) {
750 /* a non-subdevice instruction */
752 switch (insn
->insn
) {
762 do_gettimeofday(&tv
);
764 data
[1] = tv
.tv_usec
;
770 if (insn
->n
!= 1 || data
[0] >= 100000) {
774 udelay(data
[0] / 1000);
782 if (insn
->subdev
>= dev
->n_subdevices
) {
783 DPRINTK("%d not usable subdevice\n",
788 s
= dev
->subdevices
+ insn
->subdev
;
790 DPRINTK("no async\n");
794 if (!s
->async
->inttrig
) {
795 DPRINTK("no inttrig\n");
799 ret
= s
->async
->inttrig(dev
, s
, insn
->data
[0]);
804 DPRINTK("invalid insn\n");
809 /* a subdevice instruction */
810 unsigned int maxdata
;
812 if (insn
->subdev
>= dev
->n_subdevices
) {
813 DPRINTK("subdevice %d out of range\n", insn
->subdev
);
817 s
= dev
->subdevices
+ insn
->subdev
;
819 if (s
->type
== COMEDI_SUBD_UNUSED
) {
820 DPRINTK("%d not usable subdevice\n", insn
->subdev
);
825 /* are we locked? (ioctl lock) */
826 if (s
->lock
&& s
->lock
!= file
) {
827 DPRINTK("device locked\n");
832 ret
= check_chanlist(s
, 1, &insn
->chanspec
);
835 DPRINTK("bad chanspec\n");
843 /* This looks arbitrary. It is. */
844 s
->busy
= &parse_insn
;
845 switch (insn
->insn
) {
847 ret
= s
->insn_read(dev
, s
, insn
, data
);
850 maxdata
= s
->maxdata_list
851 ? s
->maxdata_list
[CR_CHAN(insn
->chanspec
)]
853 for (i
= 0; i
< insn
->n
; ++i
) {
854 if (data
[i
] > maxdata
) {
856 DPRINTK("bad data value(s)\n");
861 ret
= s
->insn_write(dev
, s
, insn
, data
);
868 ret
= s
->insn_bits(dev
, s
, insn
, data
);
871 ret
= check_insn_config_length(insn
, data
);
874 ret
= s
->insn_config(dev
, s
, insn
, data
);
890 * synchronous instructions
896 * struct comedi_insn struct at arg
902 static int do_insn_ioctl(struct comedi_device
*dev
, void *arg
, void *file
)
904 struct comedi_insn insn
;
905 unsigned int *data
= NULL
;
908 data
= kmalloc(sizeof(unsigned int) * MAX_SAMPLES
, GFP_KERNEL
);
914 if (copy_from_user(&insn
, arg
, sizeof(struct comedi_insn
))) {
919 /* This is where the behavior of insn and insnlist deviate. */
920 if (insn
.n
> MAX_SAMPLES
)
921 insn
.n
= MAX_SAMPLES
;
922 if (insn
.insn
& INSN_MASK_WRITE
) {
923 if (copy_from_user(data
, insn
.data
, insn
.n
* sizeof(unsigned int))) {
928 ret
= parse_insn(dev
, &insn
, data
, file
);
931 if (insn
.insn
& INSN_MASK_READ
) {
932 if (copy_to_user(insn
.data
, data
, insn
.n
* sizeof(unsigned int))) {
950 pointer to cmd structure
957 modified cmd structure at arg
960 static int do_cmd_ioctl(struct comedi_device
*dev
, void *arg
, void *file
)
962 struct comedi_cmd user_cmd
;
963 struct comedi_subdevice
*s
;
964 struct comedi_async
*async
;
966 unsigned int *chanlist_saver
= NULL
;
968 if (copy_from_user(&user_cmd
, arg
, sizeof(struct comedi_cmd
))) {
969 DPRINTK("bad cmd address\n");
972 /* save user's chanlist pointer so it can be restored later */
973 chanlist_saver
= user_cmd
.chanlist
;
975 if (user_cmd
.subdev
>= dev
->n_subdevices
) {
976 DPRINTK("%d no such subdevice\n", user_cmd
.subdev
);
980 s
= dev
->subdevices
+ user_cmd
.subdev
;
983 if (s
->type
== COMEDI_SUBD_UNUSED
) {
984 DPRINTK("%d not valid subdevice\n", user_cmd
.subdev
);
988 if (!s
->do_cmd
|| !s
->do_cmdtest
|| !s
->async
) {
989 DPRINTK("subdevice %i does not support commands\n",
994 /* are we locked? (ioctl lock) */
995 if (s
->lock
&& s
->lock
!= file
) {
996 DPRINTK("subdevice locked\n");
1002 DPRINTK("subdevice busy\n");
1007 /* make sure channel/gain list isn't too long */
1008 if (user_cmd
.chanlist_len
> s
->len_chanlist
) {
1009 DPRINTK("channel/gain list too long %u > %d\n",
1010 user_cmd
.chanlist_len
, s
->len_chanlist
);
1015 /* make sure channel/gain list isn't too short */
1016 if (user_cmd
.chanlist_len
< 1) {
1017 DPRINTK("channel/gain list too short %u < 1\n",
1018 user_cmd
.chanlist_len
);
1023 kfree(async
->cmd
.chanlist
);
1024 async
->cmd
= user_cmd
;
1025 async
->cmd
.data
= NULL
;
1026 /* load channel/gain list */
1027 async
->cmd
.chanlist
=
1028 kmalloc(async
->cmd
.chanlist_len
* sizeof(int), GFP_KERNEL
);
1029 if (!async
->cmd
.chanlist
) {
1030 DPRINTK("allocation failed\n");
1035 if (copy_from_user(async
->cmd
.chanlist
, user_cmd
.chanlist
,
1036 async
->cmd
.chanlist_len
* sizeof(int))) {
1037 DPRINTK("fault reading chanlist\n");
1042 /* make sure each element in channel/gain list is valid */
1043 ret
= check_chanlist(s
, async
->cmd
.chanlist_len
, async
->cmd
.chanlist
);
1045 DPRINTK("bad chanlist\n");
1049 ret
= s
->do_cmdtest(dev
, s
, &async
->cmd
);
1051 if (async
->cmd
.flags
& TRIG_BOGUS
|| ret
) {
1052 DPRINTK("test returned %d\n", ret
);
1053 user_cmd
= async
->cmd
;
1054 /* restore chanlist pointer before copying back */
1055 user_cmd
.chanlist
= chanlist_saver
;
1056 user_cmd
.data
= NULL
;
1057 if (copy_to_user(arg
, &user_cmd
, sizeof(struct comedi_cmd
))) {
1058 DPRINTK("fault writing cmd\n");
1066 if (!async
->prealloc_bufsz
) {
1068 DPRINTK("no buffer (?)\n");
1072 comedi_reset_async_buf(async
);
1075 COMEDI_CB_EOA
| COMEDI_CB_BLOCK
| COMEDI_CB_ERROR
|
1077 if (async
->cmd
.flags
& TRIG_WAKE_EOS
)
1078 async
->cb_mask
|= COMEDI_CB_EOS
;
1080 comedi_set_subdevice_runflags(s
, ~0, SRF_USER
| SRF_RUNNING
);
1082 ret
= s
->do_cmd(dev
, s
);
1087 do_become_nonbusy(dev
, s
);
1094 command testing ioctl
1097 pointer to cmd structure
1100 cmd structure at arg
1104 modified cmd structure at arg
1107 static int do_cmdtest_ioctl(struct comedi_device
*dev
, void *arg
, void *file
)
1109 struct comedi_cmd user_cmd
;
1110 struct comedi_subdevice
*s
;
1112 unsigned int *chanlist
= NULL
;
1113 unsigned int *chanlist_saver
= NULL
;
1115 if (copy_from_user(&user_cmd
, arg
, sizeof(struct comedi_cmd
))) {
1116 DPRINTK("bad cmd address\n");
1119 /* save user's chanlist pointer so it can be restored later */
1120 chanlist_saver
= user_cmd
.chanlist
;
1122 if (user_cmd
.subdev
>= dev
->n_subdevices
) {
1123 DPRINTK("%d no such subdevice\n", user_cmd
.subdev
);
1127 s
= dev
->subdevices
+ user_cmd
.subdev
;
1128 if (s
->type
== COMEDI_SUBD_UNUSED
) {
1129 DPRINTK("%d not valid subdevice\n", user_cmd
.subdev
);
1133 if (!s
->do_cmd
|| !s
->do_cmdtest
) {
1134 DPRINTK("subdevice %i does not support commands\n",
1139 /* make sure channel/gain list isn't too long */
1140 if (user_cmd
.chanlist_len
> s
->len_chanlist
) {
1141 DPRINTK("channel/gain list too long %d > %d\n",
1142 user_cmd
.chanlist_len
, s
->len_chanlist
);
1147 /* load channel/gain list */
1148 if (user_cmd
.chanlist
) {
1150 kmalloc(user_cmd
.chanlist_len
* sizeof(int), GFP_KERNEL
);
1152 DPRINTK("allocation failed\n");
1157 if (copy_from_user(chanlist
, user_cmd
.chanlist
,
1158 user_cmd
.chanlist_len
* sizeof(int))) {
1159 DPRINTK("fault reading chanlist\n");
1164 /* make sure each element in channel/gain list is valid */
1165 ret
= check_chanlist(s
, user_cmd
.chanlist_len
, chanlist
);
1167 DPRINTK("bad chanlist\n");
1171 user_cmd
.chanlist
= chanlist
;
1174 ret
= s
->do_cmdtest(dev
, s
, &user_cmd
);
1176 /* restore chanlist pointer before copying back */
1177 user_cmd
.chanlist
= chanlist_saver
;
1179 if (copy_to_user(arg
, &user_cmd
, sizeof(struct comedi_cmd
))) {
1180 DPRINTK("bad cmd address\n");
1205 static int do_lock_ioctl(struct comedi_device
*dev
, unsigned int arg
, void *file
)
1208 unsigned long flags
;
1209 struct comedi_subdevice
*s
;
1211 if (arg
>= dev
->n_subdevices
)
1213 s
= dev
->subdevices
+ arg
;
1215 spin_lock_irqsave(&s
->spin_lock
, flags
);
1216 if (s
->busy
|| s
->lock
)
1220 spin_unlock_irqrestore(&s
->spin_lock
, flags
);
1227 ret
= s
->lock_f(dev
, s
);
1246 This function isn't protected by the semaphore, since
1247 we already own the lock.
1249 static int do_unlock_ioctl(struct comedi_device
*dev
, unsigned int arg
, void *file
)
1251 struct comedi_subdevice
*s
;
1253 if (arg
>= dev
->n_subdevices
)
1255 s
= dev
->subdevices
+ arg
;
1260 if (s
->lock
&& s
->lock
!= file
)
1263 if (s
->lock
== file
) {
1277 cancel acquisition ioctl
1289 static int do_cancel_ioctl(struct comedi_device
*dev
, unsigned int arg
, void *file
)
1291 struct comedi_subdevice
*s
;
1293 if (arg
>= dev
->n_subdevices
)
1295 s
= dev
->subdevices
+ arg
;
1296 if (s
->async
== NULL
)
1299 if (s
->lock
&& s
->lock
!= file
)
1305 if (s
->busy
!= file
)
1308 return do_cancel(dev
, s
);
1313 instructs driver to synchronize buffers
1325 static int do_poll_ioctl(struct comedi_device
*dev
, unsigned int arg
, void *file
)
1327 struct comedi_subdevice
*s
;
1329 if (arg
>= dev
->n_subdevices
)
1331 s
= dev
->subdevices
+ arg
;
1333 if (s
->lock
&& s
->lock
!= file
)
1339 if (s
->busy
!= file
)
1343 return s
->poll(dev
, s
);
1348 static int do_cancel(struct comedi_device
*dev
, struct comedi_subdevice
*s
)
1352 if ((comedi_get_subdevice_runflags(s
) & SRF_RUNNING
) && s
->cancel
)
1353 ret
= s
->cancel(dev
, s
);
1355 do_become_nonbusy(dev
, s
);
1360 void comedi_unmap(struct vm_area_struct
*area
)
1362 struct comedi_async
*async
;
1363 struct comedi_device
*dev
;
1365 async
= area
->vm_private_data
;
1366 dev
= async
->subdevice
->device
;
1368 mutex_lock(&dev
->mutex
);
1369 async
->mmap_count
--;
1370 mutex_unlock(&dev
->mutex
);
1373 static struct vm_operations_struct comedi_vm_ops
= {
1374 .close
= comedi_unmap
,
1377 static int comedi_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1379 const unsigned minor
= iminor(file
->f_dentry
->d_inode
);
1380 struct comedi_device_file_info
*dev_file_info
=
1381 comedi_get_device_file_info(minor
);
1382 struct comedi_device
*dev
= dev_file_info
->device
;
1383 struct comedi_async
*async
= NULL
;
1384 unsigned long start
= vma
->vm_start
;
1389 struct comedi_subdevice
*s
;
1391 mutex_lock(&dev
->mutex
);
1392 if (!dev
->attached
) {
1393 DPRINTK("no driver configured on comedi%i\n", dev
->minor
);
1397 if (vma
->vm_flags
& VM_WRITE
)
1398 s
= comedi_get_write_subdevice(dev_file_info
);
1400 s
= comedi_get_read_subdevice(dev_file_info
);
1407 if (async
== NULL
) {
1412 if (vma
->vm_pgoff
!= 0) {
1413 DPRINTK("comedi: mmap() offset must be 0.\n");
1418 size
= vma
->vm_end
- vma
->vm_start
;
1419 if (size
> async
->prealloc_bufsz
) {
1423 if (size
& (~PAGE_MASK
)) {
1428 n_pages
= size
>> PAGE_SHIFT
;
1429 for (i
= 0; i
< n_pages
; ++i
) {
1430 if (remap_pfn_range(vma
, start
,
1431 page_to_pfn(virt_to_page(async
->
1434 PAGE_SIZE
, PAGE_SHARED
)) {
1441 vma
->vm_ops
= &comedi_vm_ops
;
1442 vma
->vm_private_data
= async
;
1444 async
->mmap_count
++;
1448 mutex_unlock(&dev
->mutex
);
1452 static unsigned int comedi_poll(struct file
*file
, poll_table
*wait
)
1454 unsigned int mask
= 0;
1455 const unsigned minor
= iminor(file
->f_dentry
->d_inode
);
1456 struct comedi_device_file_info
*dev_file_info
=
1457 comedi_get_device_file_info(minor
);
1458 struct comedi_device
*dev
= dev_file_info
->device
;
1459 struct comedi_subdevice
*read_subdev
;
1460 struct comedi_subdevice
*write_subdev
;
1462 mutex_lock(&dev
->mutex
);
1463 if (!dev
->attached
) {
1464 DPRINTK("no driver configured on comedi%i\n", dev
->minor
);
1465 mutex_unlock(&dev
->mutex
);
1470 read_subdev
= comedi_get_read_subdevice(dev_file_info
);
1472 poll_wait(file
, &read_subdev
->async
->wait_head
, wait
);
1473 if (!read_subdev
->busy
1474 || comedi_buf_read_n_available(read_subdev
->async
) > 0
1475 || !(comedi_get_subdevice_runflags(read_subdev
) &
1477 mask
|= POLLIN
| POLLRDNORM
;
1480 write_subdev
= comedi_get_write_subdevice(dev_file_info
);
1482 poll_wait(file
, &write_subdev
->async
->wait_head
, wait
);
1483 comedi_buf_write_alloc(write_subdev
->async
,
1484 write_subdev
->async
->prealloc_bufsz
);
1485 if (!write_subdev
->busy
1486 || !(comedi_get_subdevice_runflags(write_subdev
) &
1488 || comedi_buf_write_n_allocated(write_subdev
->async
) >=
1489 bytes_per_sample(write_subdev
->async
->subdevice
)) {
1490 mask
|= POLLOUT
| POLLWRNORM
;
1494 mutex_unlock(&dev
->mutex
);
1498 static ssize_t
comedi_write(struct file
*file
, const char *buf
, size_t nbytes
,
1501 struct comedi_subdevice
*s
;
1502 struct comedi_async
*async
;
1503 int n
, m
, count
= 0, retval
= 0;
1504 DECLARE_WAITQUEUE(wait
, current
);
1505 const unsigned minor
= iminor(file
->f_dentry
->d_inode
);
1506 struct comedi_device_file_info
*dev_file_info
=
1507 comedi_get_device_file_info(minor
);
1508 struct comedi_device
*dev
= dev_file_info
->device
;
1510 if (!dev
->attached
) {
1511 DPRINTK("no driver configured on comedi%i\n", dev
->minor
);
1516 s
= comedi_get_write_subdevice(dev_file_info
);
1531 if (s
->busy
!= file
) {
1535 add_wait_queue(&async
->wait_head
, &wait
);
1536 while (nbytes
> 0 && !retval
) {
1537 set_current_state(TASK_INTERRUPTIBLE
);
1542 if (async
->buf_write_ptr
+ m
> async
->prealloc_bufsz
)
1543 m
= async
->prealloc_bufsz
- async
->buf_write_ptr
;
1544 comedi_buf_write_alloc(async
, async
->prealloc_bufsz
);
1545 if (m
> comedi_buf_write_n_allocated(async
))
1546 m
= comedi_buf_write_n_allocated(async
);
1551 if (!(comedi_get_subdevice_runflags(s
) & SRF_RUNNING
)) {
1552 if (comedi_get_subdevice_runflags(s
) &
1558 do_become_nonbusy(dev
, s
);
1561 if (file
->f_flags
& O_NONBLOCK
) {
1565 if (signal_pending(current
)) {
1566 retval
= -ERESTARTSYS
;
1572 if (s
->busy
!= file
) {
1579 m
= copy_from_user(async
->prealloc_buf
+ async
->buf_write_ptr
,
1585 comedi_buf_write_free(async
, n
);
1591 break; /* makes device work like a pipe */
1593 set_current_state(TASK_RUNNING
);
1594 remove_wait_queue(&async
->wait_head
, &wait
);
1597 return count
? count
: retval
;
1600 static ssize_t
comedi_read(struct file
*file
, char *buf
, size_t nbytes
,
1603 struct comedi_subdevice
*s
;
1604 struct comedi_async
*async
;
1605 int n
, m
, count
= 0, retval
= 0;
1606 DECLARE_WAITQUEUE(wait
, current
);
1607 const unsigned minor
= iminor(file
->f_dentry
->d_inode
);
1608 struct comedi_device_file_info
*dev_file_info
=
1609 comedi_get_device_file_info(minor
);
1610 struct comedi_device
*dev
= dev_file_info
->device
;
1612 if (!dev
->attached
) {
1613 DPRINTK("no driver configured on comedi%i\n", dev
->minor
);
1618 s
= comedi_get_read_subdevice(dev_file_info
);
1632 if (s
->busy
!= file
) {
1637 add_wait_queue(&async
->wait_head
, &wait
);
1638 while (nbytes
> 0 && !retval
) {
1639 set_current_state(TASK_INTERRUPTIBLE
);
1643 m
= comedi_buf_read_n_available(async
);
1644 /* printk("%d available\n",m); */
1645 if (async
->buf_read_ptr
+ m
> async
->prealloc_bufsz
)
1646 m
= async
->prealloc_bufsz
- async
->buf_read_ptr
;
1647 /* printk("%d contiguous\n",m); */
1652 if (!(comedi_get_subdevice_runflags(s
) & SRF_RUNNING
)) {
1653 do_become_nonbusy(dev
, s
);
1654 if (comedi_get_subdevice_runflags(s
) &
1662 if (file
->f_flags
& O_NONBLOCK
) {
1666 if (signal_pending(current
)) {
1667 retval
= -ERESTARTSYS
;
1675 if (s
->busy
!= file
) {
1681 m
= copy_to_user(buf
, async
->prealloc_buf
+
1682 async
->buf_read_ptr
, n
);
1688 comedi_buf_read_alloc(async
, n
);
1689 comedi_buf_read_free(async
, n
);
1695 break; /* makes device work like a pipe */
1697 if (!(comedi_get_subdevice_runflags(s
) & (SRF_ERROR
| SRF_RUNNING
)) &&
1698 async
->buf_read_count
- async
->buf_write_count
== 0) {
1699 do_become_nonbusy(dev
, s
);
1701 set_current_state(TASK_RUNNING
);
1702 remove_wait_queue(&async
->wait_head
, &wait
);
1705 return count
? count
: retval
;
1709 This function restores a subdevice to an idle state.
1711 void do_become_nonbusy(struct comedi_device
*dev
, struct comedi_subdevice
*s
)
1713 struct comedi_async
*async
= s
->async
;
1715 comedi_set_subdevice_runflags(s
, SRF_RUNNING
, 0);
1717 comedi_reset_async_buf(async
);
1718 async
->inttrig
= NULL
;
1721 "BUG: (?) do_become_nonbusy called with async=0\n");
1727 static int comedi_open(struct inode
*inode
, struct file
*file
)
1729 const unsigned minor
= iminor(inode
);
1730 struct comedi_device_file_info
*dev_file_info
=
1731 comedi_get_device_file_info(minor
);
1732 struct comedi_device
*dev
= dev_file_info
? dev_file_info
->device
: NULL
;
1735 DPRINTK("invalid minor number\n");
1739 /* This is slightly hacky, but we want module autoloading
1741 * case: user opens device, attached -> ok
1742 * case: user opens device, unattached, in_request_module=0 -> autoload
1743 * case: user opens device, unattached, in_request_module=1 -> fail
1744 * case: root opens device, attached -> ok
1745 * case: root opens device, unattached, in_request_module=1 -> ok
1746 * (typically called from modprobe)
1747 * case: root opens device, unattached, in_request_module=0 -> autoload
1749 * The last could be changed to "-> ok", which would deny root
1752 mutex_lock(&dev
->mutex
);
1755 if (!capable(CAP_SYS_MODULE
) && dev
->in_request_module
) {
1756 DPRINTK("in request module\n");
1757 mutex_unlock(&dev
->mutex
);
1760 if (capable(CAP_SYS_MODULE
) && dev
->in_request_module
)
1763 dev
->in_request_module
= 1;
1766 mutex_unlock(&dev
->mutex
);
1767 request_module("char-major-%i-%i", COMEDI_MAJOR
, dev
->minor
);
1768 mutex_lock(&dev
->mutex
);
1771 dev
->in_request_module
= 0;
1773 if (!dev
->attached
&& !capable(CAP_SYS_MODULE
)) {
1774 DPRINTK("not attached and not CAP_SYS_MODULE\n");
1775 mutex_unlock(&dev
->mutex
);
1779 __module_get(THIS_MODULE
);
1781 if (dev
->attached
) {
1782 if (!try_module_get(dev
->driver
->module
)) {
1783 module_put(THIS_MODULE
);
1784 mutex_unlock(&dev
->mutex
);
1789 if (dev
->attached
&& dev
->use_count
== 0 && dev
->open
)
1794 mutex_unlock(&dev
->mutex
);
1799 static int comedi_close(struct inode
*inode
, struct file
*file
)
1801 const unsigned minor
= iminor(inode
);
1802 struct comedi_device_file_info
*dev_file_info
=
1803 comedi_get_device_file_info(minor
);
1804 struct comedi_device
*dev
= dev_file_info
->device
;
1805 struct comedi_subdevice
*s
= NULL
;
1808 mutex_lock(&dev
->mutex
);
1810 if (dev
->subdevices
) {
1811 for (i
= 0; i
< dev
->n_subdevices
; i
++) {
1812 s
= dev
->subdevices
+ i
;
1814 if (s
->busy
== file
)
1816 if (s
->lock
== file
)
1820 if (dev
->attached
&& dev
->use_count
== 1 && dev
->close
)
1823 module_put(THIS_MODULE
);
1825 module_put(dev
->driver
->module
);
1829 mutex_unlock(&dev
->mutex
);
1831 if (file
->f_flags
& FASYNC
)
1832 comedi_fasync(-1, file
, 0);
1837 static int comedi_fasync(int fd
, struct file
*file
, int on
)
1839 const unsigned minor
= iminor(file
->f_dentry
->d_inode
);
1840 struct comedi_device_file_info
*dev_file_info
=
1841 comedi_get_device_file_info(minor
);
1843 struct comedi_device
*dev
= dev_file_info
->device
;
1845 return fasync_helper(fd
, file
, on
, &dev
->async_queue
);
1848 const struct file_operations comedi_fops
= {
1849 .owner
= THIS_MODULE
,
1850 #ifdef HAVE_UNLOCKED_IOCTL
1851 .unlocked_ioctl
= comedi_unlocked_ioctl
,
1853 .ioctl
= comedi_ioctl
,
1855 #ifdef HAVE_COMPAT_IOCTL
1856 .compat_ioctl
= comedi_compat_ioctl
,
1858 .open
= comedi_open
,
1859 .release
= comedi_close
,
1860 .read
= comedi_read
,
1861 .write
= comedi_write
,
1862 .mmap
= comedi_mmap
,
1863 .poll
= comedi_poll
,
1864 .fasync
= comedi_fasync
,
1867 struct class *comedi_class
;
1868 static struct cdev comedi_cdev
;
1870 static void comedi_cleanup_legacy_minors(void)
1874 for (i
= 0; i
< comedi_num_legacy_minors
; i
++)
1875 comedi_free_board_minor(i
);
1878 static int __init
comedi_init(void)
1883 printk(KERN_INFO
"comedi: version " COMEDI_RELEASE
1884 " - http://www.comedi.org\n");
1886 if (comedi_num_legacy_minors
< 0 ||
1887 comedi_num_legacy_minors
> COMEDI_NUM_BOARD_MINORS
) {
1888 printk(KERN_ERR
"comedi: error: invalid value for module "
1889 "parameter \"comedi_num_legacy_minors\". Valid values "
1890 "are 0 through %i.\n", COMEDI_NUM_BOARD_MINORS
);
1895 * comedi is unusable if both comedi_autoconfig and
1896 * comedi_num_legacy_minors are zero, so we might as well adjust the
1897 * defaults in that case
1899 if (comedi_autoconfig
== 0 && comedi_num_legacy_minors
== 0)
1900 comedi_num_legacy_minors
= 16;
1902 memset(comedi_file_info_table
, 0,
1903 sizeof(struct comedi_device_file_info
*) * COMEDI_NUM_MINORS
);
1905 retval
= register_chrdev_region(MKDEV(COMEDI_MAJOR
, 0),
1906 COMEDI_NUM_MINORS
, "comedi");
1909 cdev_init(&comedi_cdev
, &comedi_fops
);
1910 comedi_cdev
.owner
= THIS_MODULE
;
1911 kobject_set_name(&comedi_cdev
.kobj
, "comedi");
1912 if (cdev_add(&comedi_cdev
, MKDEV(COMEDI_MAJOR
, 0), COMEDI_NUM_MINORS
)) {
1913 unregister_chrdev_region(MKDEV(COMEDI_MAJOR
, 0),
1917 comedi_class
= class_create(THIS_MODULE
, "comedi");
1918 if (IS_ERR(comedi_class
)) {
1919 printk("comedi: failed to create class");
1920 cdev_del(&comedi_cdev
);
1921 unregister_chrdev_region(MKDEV(COMEDI_MAJOR
, 0),
1923 return PTR_ERR(comedi_class
);
1926 /* XXX requires /proc interface */
1929 /* create devices files for legacy/manual use */
1930 for (i
= 0; i
< comedi_num_legacy_minors
; i
++) {
1932 minor
= comedi_alloc_board_minor(NULL
);
1934 comedi_cleanup_legacy_minors();
1935 cdev_del(&comedi_cdev
);
1936 unregister_chrdev_region(MKDEV(COMEDI_MAJOR
, 0),
1942 comedi_register_ioctl32();
1947 static void __exit
comedi_cleanup(void)
1951 comedi_cleanup_legacy_minors();
1952 for (i
= 0; i
< COMEDI_NUM_MINORS
; ++i
)
1953 BUG_ON(comedi_file_info_table
[i
]);
1956 class_destroy(comedi_class
);
1957 cdev_del(&comedi_cdev
);
1958 unregister_chrdev_region(MKDEV(COMEDI_MAJOR
, 0), COMEDI_NUM_MINORS
);
1960 comedi_proc_cleanup();
1962 comedi_unregister_ioctl32();
1965 module_init(comedi_init
);
1966 module_exit(comedi_cleanup
);
1968 void comedi_error(const struct comedi_device
*dev
, const char *s
)
1970 printk("comedi%d: %s: %s\n", dev
->minor
, dev
->driver
->driver_name
, s
);
1973 void comedi_event(struct comedi_device
*dev
, struct comedi_subdevice
*s
)
1975 struct comedi_async
*async
= s
->async
;
1976 unsigned runflags
= 0;
1977 unsigned runflags_mask
= 0;
1979 /* DPRINTK("comedi_event 0x%x\n",mask); */
1981 if ((comedi_get_subdevice_runflags(s
) & SRF_RUNNING
) == 0)
1985 events
& (COMEDI_CB_EOA
| COMEDI_CB_ERROR
| COMEDI_CB_OVERFLOW
)) {
1986 runflags_mask
|= SRF_RUNNING
;
1988 /* remember if an error event has occured, so an error
1989 * can be returned the next time the user does a read() */
1990 if (s
->async
->events
& (COMEDI_CB_ERROR
| COMEDI_CB_OVERFLOW
)) {
1991 runflags_mask
|= SRF_ERROR
;
1992 runflags
|= SRF_ERROR
;
1994 if (runflags_mask
) {
1995 /*sets SRF_ERROR and SRF_RUNNING together atomically */
1996 comedi_set_subdevice_runflags(s
, runflags_mask
, runflags
);
1999 if (async
->cb_mask
& s
->async
->events
) {
2000 if (comedi_get_subdevice_runflags(s
) & SRF_USER
) {
2001 wake_up_interruptible(&async
->wait_head
);
2002 if (s
->subdev_flags
& SDF_CMD_READ
) {
2003 kill_fasync(&dev
->async_queue
, SIGIO
,
2006 if (s
->subdev_flags
& SDF_CMD_WRITE
) {
2007 kill_fasync(&dev
->async_queue
, SIGIO
,
2012 async
->cb_func(s
->async
->events
, async
->cb_arg
);
2015 s
->async
->events
= 0;
2018 void comedi_set_subdevice_runflags(struct comedi_subdevice
*s
, unsigned mask
,
2021 unsigned long flags
;
2023 spin_lock_irqsave(&s
->spin_lock
, flags
);
2024 s
->runflags
&= ~mask
;
2025 s
->runflags
|= (bits
& mask
);
2026 spin_unlock_irqrestore(&s
->spin_lock
, flags
);
2029 unsigned comedi_get_subdevice_runflags(struct comedi_subdevice
*s
)
2031 unsigned long flags
;
2034 spin_lock_irqsave(&s
->spin_lock
, flags
);
2035 runflags
= s
->runflags
;
2036 spin_unlock_irqrestore(&s
->spin_lock
, flags
);
2040 static int is_device_busy(struct comedi_device
*dev
)
2042 struct comedi_subdevice
*s
;
2048 for (i
= 0; i
< dev
->n_subdevices
; i
++) {
2049 s
= dev
->subdevices
+ i
;
2052 if (s
->async
&& s
->async
->mmap_count
)
2059 void comedi_device_init(struct comedi_device
*dev
)
2061 memset(dev
, 0, sizeof(struct comedi_device
));
2062 spin_lock_init(&dev
->spinlock
);
2063 mutex_init(&dev
->mutex
);
2067 void comedi_device_cleanup(struct comedi_device
*dev
)
2071 mutex_lock(&dev
->mutex
);
2072 comedi_device_detach(dev
);
2073 mutex_unlock(&dev
->mutex
);
2074 mutex_destroy(&dev
->mutex
);
2077 int comedi_alloc_board_minor(struct device
*hardware_device
)
2079 unsigned long flags
;
2080 struct comedi_device_file_info
*info
;
2081 struct device
*csdev
;
2085 info
= kzalloc(sizeof(struct comedi_device_file_info
), GFP_KERNEL
);
2088 info
->device
= kzalloc(sizeof(struct comedi_device
), GFP_KERNEL
);
2089 if (info
->device
== NULL
) {
2093 comedi_device_init(info
->device
);
2094 spin_lock_irqsave(&comedi_file_info_table_lock
, flags
);
2095 for (i
= 0; i
< COMEDI_NUM_BOARD_MINORS
; ++i
) {
2096 if (comedi_file_info_table
[i
] == NULL
) {
2097 comedi_file_info_table
[i
] = info
;
2101 spin_unlock_irqrestore(&comedi_file_info_table_lock
, flags
);
2102 if (i
== COMEDI_NUM_BOARD_MINORS
) {
2103 comedi_device_cleanup(info
->device
);
2104 kfree(info
->device
);
2106 printk(KERN_ERR
"comedi: error: ran out of minor numbers for board device files.\n");
2109 info
->device
->minor
= i
;
2110 csdev
= COMEDI_DEVICE_CREATE(comedi_class
, NULL
,
2111 MKDEV(COMEDI_MAJOR
, i
), NULL
,
2112 hardware_device
, "comedi%i", i
);
2114 info
->device
->class_dev
= csdev
;
2115 dev_set_drvdata(csdev
, info
);
2116 retval
= device_create_file(csdev
, &dev_attr_max_read_buffer_kb
);
2118 printk(KERN_ERR
"comedi: failed to create sysfs attribute file \"%s\".\n",
2119 dev_attr_max_read_buffer_kb
.attr
.name
);
2120 comedi_free_board_minor(i
);
2123 retval
= device_create_file(csdev
, &dev_attr_read_buffer_kb
);
2125 printk(KERN_ERR
"comedi: failed to create sysfs attribute file \"%s\".\n",
2126 dev_attr_read_buffer_kb
.attr
.name
);
2127 comedi_free_board_minor(i
);
2130 retval
= device_create_file(csdev
, &dev_attr_max_write_buffer_kb
);
2132 printk(KERN_ERR
"comedi: failed to create sysfs attribute file \"%s\".\n",
2133 dev_attr_max_write_buffer_kb
.attr
.name
);
2134 comedi_free_board_minor(i
);
2137 retval
= device_create_file(csdev
, &dev_attr_write_buffer_kb
);
2139 printk(KERN_ERR
"comedi: failed to create sysfs attribute file \"%s\".\n",
2140 dev_attr_write_buffer_kb
.attr
.name
);
2141 comedi_free_board_minor(i
);
2147 void comedi_free_board_minor(unsigned minor
)
2149 unsigned long flags
;
2150 struct comedi_device_file_info
*info
;
2152 BUG_ON(minor
>= COMEDI_NUM_BOARD_MINORS
);
2153 spin_lock_irqsave(&comedi_file_info_table_lock
, flags
);
2154 info
= comedi_file_info_table
[minor
];
2155 comedi_file_info_table
[minor
] = NULL
;
2156 spin_unlock_irqrestore(&comedi_file_info_table_lock
, flags
);
2159 struct comedi_device
*dev
= info
->device
;
2161 if (dev
->class_dev
) {
2162 device_destroy(comedi_class
,
2163 MKDEV(COMEDI_MAJOR
, dev
->minor
));
2165 comedi_device_cleanup(dev
);
2172 int comedi_alloc_subdevice_minor(struct comedi_device
*dev
,
2173 struct comedi_subdevice
*s
)
2175 unsigned long flags
;
2176 struct comedi_device_file_info
*info
;
2177 struct device
*csdev
;
2181 info
= kmalloc(sizeof(struct comedi_device_file_info
), GFP_KERNEL
);
2185 info
->read_subdevice
= s
;
2186 info
->write_subdevice
= s
;
2187 spin_lock_irqsave(&comedi_file_info_table_lock
, flags
);
2188 for (i
= COMEDI_FIRST_SUBDEVICE_MINOR
; i
< COMEDI_NUM_MINORS
; ++i
) {
2189 if (comedi_file_info_table
[i
] == NULL
) {
2190 comedi_file_info_table
[i
] = info
;
2194 spin_unlock_irqrestore(&comedi_file_info_table_lock
, flags
);
2195 if (i
== COMEDI_NUM_MINORS
) {
2197 printk(KERN_ERR
"comedi: error: ran out of minor numbers for board device files.\n");
2201 csdev
= COMEDI_DEVICE_CREATE(comedi_class
, dev
->class_dev
,
2202 MKDEV(COMEDI_MAJOR
, i
), NULL
, NULL
,
2203 "comedi%i_subd%i", dev
->minor
,
2204 (int)(s
- dev
->subdevices
));
2206 s
->class_dev
= csdev
;
2207 dev_set_drvdata(csdev
, info
);
2208 retval
= device_create_file(csdev
, &dev_attr_max_read_buffer_kb
);
2210 printk(KERN_ERR
"comedi: failed to create sysfs attribute file \"%s\".\n",
2211 dev_attr_max_read_buffer_kb
.attr
.name
);
2212 comedi_free_subdevice_minor(s
);
2215 retval
= device_create_file(csdev
, &dev_attr_read_buffer_kb
);
2217 printk(KERN_ERR
"comedi: failed to create sysfs attribute file \"%s\".\n",
2218 dev_attr_read_buffer_kb
.attr
.name
);
2219 comedi_free_subdevice_minor(s
);
2222 retval
= device_create_file(csdev
, &dev_attr_max_write_buffer_kb
);
2224 printk(KERN_ERR
"comedi: failed to create sysfs attribute file \"%s\".\n",
2225 dev_attr_max_write_buffer_kb
.attr
.name
);
2226 comedi_free_subdevice_minor(s
);
2229 retval
= device_create_file(csdev
, &dev_attr_write_buffer_kb
);
2231 printk(KERN_ERR
"comedi: failed to create sysfs attribute file \"%s\".\n",
2232 dev_attr_write_buffer_kb
.attr
.name
);
2233 comedi_free_subdevice_minor(s
);
2239 void comedi_free_subdevice_minor(struct comedi_subdevice
*s
)
2241 unsigned long flags
;
2242 struct comedi_device_file_info
*info
;
2249 BUG_ON(s
->minor
>= COMEDI_NUM_MINORS
);
2250 BUG_ON(s
->minor
< COMEDI_FIRST_SUBDEVICE_MINOR
);
2252 spin_lock_irqsave(&comedi_file_info_table_lock
, flags
);
2253 info
= comedi_file_info_table
[s
->minor
];
2254 comedi_file_info_table
[s
->minor
] = NULL
;
2255 spin_unlock_irqrestore(&comedi_file_info_table_lock
, flags
);
2258 device_destroy(comedi_class
, MKDEV(COMEDI_MAJOR
, s
->minor
));
2259 s
->class_dev
= NULL
;
2264 struct comedi_device_file_info
*comedi_get_device_file_info(unsigned minor
)
2266 unsigned long flags
;
2267 struct comedi_device_file_info
*info
;
2269 BUG_ON(minor
>= COMEDI_NUM_MINORS
);
2270 spin_lock_irqsave(&comedi_file_info_table_lock
, flags
);
2271 info
= comedi_file_info_table
[minor
];
2272 spin_unlock_irqrestore(&comedi_file_info_table_lock
, flags
);
2276 static int resize_async_buffer(struct comedi_device
*dev
,
2277 struct comedi_subdevice
*s
,
2278 struct comedi_async
*async
, unsigned new_size
)
2282 if (new_size
> async
->max_bufsize
)
2286 DPRINTK("subdevice is busy, cannot resize buffer\n");
2289 if (async
->mmap_count
) {
2290 DPRINTK("subdevice is mmapped, cannot resize buffer\n");
2294 if (!async
->prealloc_buf
)
2297 /* make sure buffer is an integral number of pages
2299 new_size
= (new_size
+ PAGE_SIZE
- 1) & PAGE_MASK
;
2301 retval
= comedi_buf_alloc(dev
, s
, new_size
);
2305 if (s
->buf_change
) {
2306 retval
= s
->buf_change(dev
, s
, new_size
);
2311 DPRINTK("comedi%i subd %d buffer resized to %i bytes\n",
2312 dev
->minor
, s
- dev
->subdevices
, async
->prealloc_bufsz
);
2316 /* sysfs attribute files */
2318 static const unsigned bytes_per_kibi
= 1024;
2320 static ssize_t
show_max_read_buffer_kb(struct device
*dev
,
2321 struct device_attribute
*attr
, char *buf
)
2324 struct comedi_device_file_info
*info
= dev_get_drvdata(dev
);
2325 unsigned max_buffer_size_kb
= 0;
2326 struct comedi_subdevice
*const read_subdevice
=
2327 comedi_get_read_subdevice(info
);
2329 mutex_lock(&info
->device
->mutex
);
2330 if (read_subdevice
&&
2331 (read_subdevice
->subdev_flags
& SDF_CMD_READ
) &&
2332 read_subdevice
->async
) {
2333 max_buffer_size_kb
= read_subdevice
->async
->max_bufsize
/
2336 retval
= snprintf(buf
, PAGE_SIZE
, "%i\n", max_buffer_size_kb
);
2337 mutex_unlock(&info
->device
->mutex
);
2342 static ssize_t
store_max_read_buffer_kb(struct device
*dev
,
2343 struct device_attribute
*attr
,
2344 const char *buf
, size_t count
)
2346 struct comedi_device_file_info
*info
= dev_get_drvdata(dev
);
2347 unsigned long new_max_size_kb
;
2348 uint64_t new_max_size
;
2349 struct comedi_subdevice
*const read_subdevice
=
2350 comedi_get_read_subdevice(info
);
2352 if (strict_strtoul(buf
, 10, &new_max_size_kb
))
2354 if (new_max_size_kb
!= (uint32_t)new_max_size_kb
)
2356 new_max_size
= ((uint64_t)new_max_size_kb
) * bytes_per_kibi
;
2357 if (new_max_size
!= (uint32_t)new_max_size
)
2360 mutex_lock(&info
->device
->mutex
);
2361 if (read_subdevice
== NULL
||
2362 (read_subdevice
->subdev_flags
& SDF_CMD_READ
) == 0 ||
2363 read_subdevice
->async
== NULL
) {
2364 mutex_unlock(&info
->device
->mutex
);
2367 read_subdevice
->async
->max_bufsize
= new_max_size
;
2368 mutex_unlock(&info
->device
->mutex
);
2373 static struct device_attribute dev_attr_max_read_buffer_kb
= {
2375 .name
= "max_read_buffer_kb",
2376 .mode
= S_IRUGO
| S_IWUSR
2378 .show
= &show_max_read_buffer_kb
,
2379 .store
= &store_max_read_buffer_kb
2382 static ssize_t
show_read_buffer_kb(struct device
*dev
,
2383 struct device_attribute
*attr
, char *buf
)
2386 struct comedi_device_file_info
*info
= dev_get_drvdata(dev
);
2387 unsigned buffer_size_kb
= 0;
2388 struct comedi_subdevice
*const read_subdevice
=
2389 comedi_get_read_subdevice(info
);
2391 mutex_lock(&info
->device
->mutex
);
2392 if (read_subdevice
&&
2393 (read_subdevice
->subdev_flags
& SDF_CMD_READ
) &&
2394 read_subdevice
->async
) {
2395 buffer_size_kb
= read_subdevice
->async
->prealloc_bufsz
/
2398 retval
= snprintf(buf
, PAGE_SIZE
, "%i\n", buffer_size_kb
);
2399 mutex_unlock(&info
->device
->mutex
);
2404 static ssize_t
store_read_buffer_kb(struct device
*dev
,
2405 struct device_attribute
*attr
,
2406 const char *buf
, size_t count
)
2408 struct comedi_device_file_info
*info
= dev_get_drvdata(dev
);
2409 unsigned long new_size_kb
;
2412 struct comedi_subdevice
*const read_subdevice
=
2413 comedi_get_read_subdevice(info
);
2415 if (strict_strtoul(buf
, 10, &new_size_kb
))
2417 if (new_size_kb
!= (uint32_t)new_size_kb
)
2419 new_size
= ((uint64_t)new_size_kb
) * bytes_per_kibi
;
2420 if (new_size
!= (uint32_t)new_size
)
2423 mutex_lock(&info
->device
->mutex
);
2424 if (read_subdevice
== NULL
||
2425 (read_subdevice
->subdev_flags
& SDF_CMD_READ
) == 0 ||
2426 read_subdevice
->async
== NULL
) {
2427 mutex_unlock(&info
->device
->mutex
);
2430 retval
= resize_async_buffer(info
->device
, read_subdevice
,
2431 read_subdevice
->async
, new_size
);
2432 mutex_unlock(&info
->device
->mutex
);
2439 static struct device_attribute dev_attr_read_buffer_kb
= {
2441 .name
= "read_buffer_kb",
2442 .mode
= S_IRUGO
| S_IWUSR
| S_IWGRP
2444 .show
= &show_read_buffer_kb
,
2445 .store
= &store_read_buffer_kb
2448 static ssize_t
show_max_write_buffer_kb(struct device
*dev
,
2449 struct device_attribute
*attr
,
2453 struct comedi_device_file_info
*info
= dev_get_drvdata(dev
);
2454 unsigned max_buffer_size_kb
= 0;
2455 struct comedi_subdevice
*const write_subdevice
=
2456 comedi_get_write_subdevice(info
);
2458 mutex_lock(&info
->device
->mutex
);
2459 if (write_subdevice
&&
2460 (write_subdevice
->subdev_flags
& SDF_CMD_WRITE
) &&
2461 write_subdevice
->async
) {
2462 max_buffer_size_kb
= write_subdevice
->async
->max_bufsize
/
2465 retval
= snprintf(buf
, PAGE_SIZE
, "%i\n", max_buffer_size_kb
);
2466 mutex_unlock(&info
->device
->mutex
);
2471 static ssize_t
store_max_write_buffer_kb(struct device
*dev
,
2472 struct device_attribute
*attr
,
2473 const char *buf
, size_t count
)
2475 struct comedi_device_file_info
*info
= dev_get_drvdata(dev
);
2476 unsigned long new_max_size_kb
;
2477 uint64_t new_max_size
;
2478 struct comedi_subdevice
*const write_subdevice
=
2479 comedi_get_write_subdevice(info
);
2481 if (strict_strtoul(buf
, 10, &new_max_size_kb
))
2483 if (new_max_size_kb
!= (uint32_t)new_max_size_kb
)
2485 new_max_size
= ((uint64_t)new_max_size_kb
) * bytes_per_kibi
;
2486 if (new_max_size
!= (uint32_t)new_max_size
)
2489 mutex_lock(&info
->device
->mutex
);
2490 if (write_subdevice
== NULL
||
2491 (write_subdevice
->subdev_flags
& SDF_CMD_WRITE
) == 0 ||
2492 write_subdevice
->async
== NULL
) {
2493 mutex_unlock(&info
->device
->mutex
);
2496 write_subdevice
->async
->max_bufsize
= new_max_size
;
2497 mutex_unlock(&info
->device
->mutex
);
2502 static struct device_attribute dev_attr_max_write_buffer_kb
= {
2504 .name
= "max_write_buffer_kb",
2505 .mode
= S_IRUGO
| S_IWUSR
2507 .show
= &show_max_write_buffer_kb
,
2508 .store
= &store_max_write_buffer_kb
2511 static ssize_t
show_write_buffer_kb(struct device
*dev
,
2512 struct device_attribute
*attr
, char *buf
)
2515 struct comedi_device_file_info
*info
= dev_get_drvdata(dev
);
2516 unsigned buffer_size_kb
= 0;
2517 struct comedi_subdevice
*const write_subdevice
=
2518 comedi_get_write_subdevice(info
);
2520 mutex_lock(&info
->device
->mutex
);
2521 if (write_subdevice
&&
2522 (write_subdevice
->subdev_flags
& SDF_CMD_WRITE
) &&
2523 write_subdevice
->async
) {
2524 buffer_size_kb
= write_subdevice
->async
->prealloc_bufsz
/
2527 retval
= snprintf(buf
, PAGE_SIZE
, "%i\n", buffer_size_kb
);
2528 mutex_unlock(&info
->device
->mutex
);
2533 static ssize_t
store_write_buffer_kb(struct device
*dev
,
2534 struct device_attribute
*attr
,
2535 const char *buf
, size_t count
)
2537 struct comedi_device_file_info
*info
= dev_get_drvdata(dev
);
2538 unsigned long new_size_kb
;
2541 struct comedi_subdevice
*const write_subdevice
=
2542 comedi_get_write_subdevice(info
);
2544 if (strict_strtoul(buf
, 10, &new_size_kb
))
2546 if (new_size_kb
!= (uint32_t)new_size_kb
)
2548 new_size
= ((uint64_t)new_size_kb
) * bytes_per_kibi
;
2549 if (new_size
!= (uint32_t)new_size
)
2552 mutex_lock(&info
->device
->mutex
);
2553 if (write_subdevice
== NULL
||
2554 (write_subdevice
->subdev_flags
& SDF_CMD_WRITE
) == 0 ||
2555 write_subdevice
->async
== NULL
) {
2556 mutex_unlock(&info
->device
->mutex
);
2559 retval
= resize_async_buffer(info
->device
, write_subdevice
,
2560 write_subdevice
->async
, new_size
);
2561 mutex_unlock(&info
->device
->mutex
);
2568 static struct device_attribute dev_attr_write_buffer_kb
= {
2570 .name
= "write_buffer_kb",
2571 .mode
= S_IRUGO
| S_IWUSR
| S_IWGRP
2573 .show
= &show_write_buffer_kb
,
2574 .store
= &store_write_buffer_kb