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.
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21 #include "comedi_compat32.h"
23 #include <linux/module.h>
24 #include <linux/errno.h>
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
27 #include <linux/fcntl.h>
28 #include <linux/delay.h>
30 #include <linux/slab.h>
31 #include <linux/kmod.h>
32 #include <linux/poll.h>
33 #include <linux/init.h>
34 #include <linux/device.h>
35 #include <linux/vmalloc.h>
37 #include "comedidev.h"
38 #include <linux/cdev.h>
39 #include <linux/stat.h>
42 #include <linux/uaccess.h>
44 #include "comedi_internal.h"
47 * comedi_subdevice "runflags"
48 * COMEDI_SRF_RT: DEPRECATED: command is running real-time
49 * COMEDI_SRF_ERROR: indicates an COMEDI_CB_ERROR event has occurred
50 * since the last command was started
51 * COMEDI_SRF_RUNNING: command is running
52 * COMEDI_SRF_FREE_SPRIV: free s->private on detach
54 * COMEDI_SRF_BUSY_MASK: runflags that indicate the subdevice is "busy"
56 #define COMEDI_SRF_RT BIT(1)
57 #define COMEDI_SRF_ERROR BIT(2)
58 #define COMEDI_SRF_RUNNING BIT(27)
59 #define COMEDI_SRF_FREE_SPRIV BIT(31)
61 #define COMEDI_SRF_BUSY_MASK (COMEDI_SRF_ERROR | COMEDI_SRF_RUNNING)
64 * struct comedi_file - Per-file private data for COMEDI device
65 * @dev: COMEDI device.
66 * @read_subdev: Current "read" subdevice.
67 * @write_subdev: Current "write" subdevice.
68 * @last_detach_count: Last known detach count.
69 * @last_attached: Last known attached/detached state.
72 struct comedi_device *dev;
73 struct comedi_subdevice *read_subdev;
74 struct comedi_subdevice *write_subdev;
75 unsigned int last_detach_count;
79 #define COMEDI_NUM_MINORS 0x100
80 #define COMEDI_NUM_SUBDEVICE_MINORS \
81 (COMEDI_NUM_MINORS - COMEDI_NUM_BOARD_MINORS)
83 static int comedi_num_legacy_minors;
84 module_param(comedi_num_legacy_minors, int, S_IRUGO);
85 MODULE_PARM_DESC(comedi_num_legacy_minors,
86 "number of comedi minor devices to reserve for non-auto-configured devices (default 0)"
89 unsigned int comedi_default_buf_size_kb = CONFIG_COMEDI_DEFAULT_BUF_SIZE_KB;
90 module_param(comedi_default_buf_size_kb, uint, S_IRUGO | S_IWUSR);
91 MODULE_PARM_DESC(comedi_default_buf_size_kb,
92 "default asynchronous buffer size in KiB (default "
93 __MODULE_STRING(CONFIG_COMEDI_DEFAULT_BUF_SIZE_KB) ")");
95 unsigned int comedi_default_buf_maxsize_kb
96 = CONFIG_COMEDI_DEFAULT_BUF_MAXSIZE_KB;
97 module_param(comedi_default_buf_maxsize_kb, uint, S_IRUGO | S_IWUSR);
98 MODULE_PARM_DESC(comedi_default_buf_maxsize_kb,
99 "default maximum size of asynchronous buffer in KiB (default "
100 __MODULE_STRING(CONFIG_COMEDI_DEFAULT_BUF_MAXSIZE_KB) ")");
102 static DEFINE_MUTEX(comedi_board_minor_table_lock);
103 static struct comedi_device
104 *comedi_board_minor_table[COMEDI_NUM_BOARD_MINORS];
106 static DEFINE_MUTEX(comedi_subdevice_minor_table_lock);
107 /* Note: indexed by minor - COMEDI_NUM_BOARD_MINORS. */
108 static struct comedi_subdevice
109 *comedi_subdevice_minor_table[COMEDI_NUM_SUBDEVICE_MINORS];
111 static struct class *comedi_class;
112 static struct cdev comedi_cdev;
114 static void comedi_device_init(struct comedi_device *dev)
116 kref_init(&dev->refcount);
117 spin_lock_init(&dev->spinlock);
118 mutex_init(&dev->mutex);
119 init_rwsem(&dev->attach_lock);
123 static void comedi_dev_kref_release(struct kref *kref)
125 struct comedi_device *dev =
126 container_of(kref, struct comedi_device, refcount);
128 mutex_destroy(&dev->mutex);
129 put_device(dev->class_dev);
134 * comedi_dev_put() - Release a use of a COMEDI device
135 * @dev: COMEDI device.
137 * Must be called when a user of a COMEDI device is finished with it.
138 * When the last user of the COMEDI device calls this function, the
139 * COMEDI device is destroyed.
141 * Return: 1 if the COMEDI device is destroyed by this call or @dev is
142 * NULL, otherwise return 0. Callers must not assume the COMEDI
143 * device is still valid if this function returns 0.
145 int comedi_dev_put(struct comedi_device *dev)
148 return kref_put(&dev->refcount, comedi_dev_kref_release);
151 EXPORT_SYMBOL_GPL(comedi_dev_put);
153 static struct comedi_device *comedi_dev_get(struct comedi_device *dev)
156 kref_get(&dev->refcount);
160 static void comedi_device_cleanup(struct comedi_device *dev)
162 struct module *driver_module = NULL;
166 mutex_lock(&dev->mutex);
168 driver_module = dev->driver->module;
169 comedi_device_detach(dev);
170 if (driver_module && dev->use_count)
171 module_put(driver_module);
172 mutex_unlock(&dev->mutex);
175 static bool comedi_clear_board_dev(struct comedi_device *dev)
177 unsigned int i = dev->minor;
178 bool cleared = false;
180 mutex_lock(&comedi_board_minor_table_lock);
181 if (dev == comedi_board_minor_table[i]) {
182 comedi_board_minor_table[i] = NULL;
185 mutex_unlock(&comedi_board_minor_table_lock);
189 static struct comedi_device *comedi_clear_board_minor(unsigned minor)
191 struct comedi_device *dev;
193 mutex_lock(&comedi_board_minor_table_lock);
194 dev = comedi_board_minor_table[minor];
195 comedi_board_minor_table[minor] = NULL;
196 mutex_unlock(&comedi_board_minor_table_lock);
200 static void comedi_free_board_dev(struct comedi_device *dev)
203 comedi_device_cleanup(dev);
204 if (dev->class_dev) {
205 device_destroy(comedi_class,
206 MKDEV(COMEDI_MAJOR, dev->minor));
212 static struct comedi_subdevice
213 *comedi_subdevice_from_minor(const struct comedi_device *dev, unsigned minor)
215 struct comedi_subdevice *s;
216 unsigned int i = minor - COMEDI_NUM_BOARD_MINORS;
218 mutex_lock(&comedi_subdevice_minor_table_lock);
219 s = comedi_subdevice_minor_table[i];
220 if (s && s->device != dev)
222 mutex_unlock(&comedi_subdevice_minor_table_lock);
226 static struct comedi_device *comedi_dev_get_from_board_minor(unsigned minor)
228 struct comedi_device *dev;
230 mutex_lock(&comedi_board_minor_table_lock);
231 dev = comedi_dev_get(comedi_board_minor_table[minor]);
232 mutex_unlock(&comedi_board_minor_table_lock);
236 static struct comedi_device *comedi_dev_get_from_subdevice_minor(unsigned minor)
238 struct comedi_device *dev;
239 struct comedi_subdevice *s;
240 unsigned int i = minor - COMEDI_NUM_BOARD_MINORS;
242 mutex_lock(&comedi_subdevice_minor_table_lock);
243 s = comedi_subdevice_minor_table[i];
244 dev = comedi_dev_get(s ? s->device : NULL);
245 mutex_unlock(&comedi_subdevice_minor_table_lock);
250 * comedi_dev_get_from_minor() - Get COMEDI device by minor device number
251 * @minor: Minor device number.
253 * Finds the COMEDI device associated with the minor device number, if any,
254 * and increments its reference count. The COMEDI device is prevented from
255 * being freed until a matching call is made to comedi_dev_put().
257 * Return: A pointer to the COMEDI device if it exists, with its usage
258 * reference incremented. Return NULL if no COMEDI device exists with the
259 * specified minor device number.
261 struct comedi_device *comedi_dev_get_from_minor(unsigned minor)
263 if (minor < COMEDI_NUM_BOARD_MINORS)
264 return comedi_dev_get_from_board_minor(minor);
266 return comedi_dev_get_from_subdevice_minor(minor);
268 EXPORT_SYMBOL_GPL(comedi_dev_get_from_minor);
270 static struct comedi_subdevice *
271 comedi_read_subdevice(const struct comedi_device *dev, unsigned int minor)
273 struct comedi_subdevice *s;
275 if (minor >= COMEDI_NUM_BOARD_MINORS) {
276 s = comedi_subdevice_from_minor(dev, minor);
277 if (!s || (s->subdev_flags & SDF_CMD_READ))
280 return dev->read_subdev;
283 static struct comedi_subdevice *
284 comedi_write_subdevice(const struct comedi_device *dev, unsigned int minor)
286 struct comedi_subdevice *s;
288 if (minor >= COMEDI_NUM_BOARD_MINORS) {
289 s = comedi_subdevice_from_minor(dev, minor);
290 if (!s || (s->subdev_flags & SDF_CMD_WRITE))
293 return dev->write_subdev;
296 static void comedi_file_reset(struct file *file)
298 struct comedi_file *cfp = file->private_data;
299 struct comedi_device *dev = cfp->dev;
300 struct comedi_subdevice *s, *read_s, *write_s;
301 unsigned int minor = iminor(file_inode(file));
303 read_s = dev->read_subdev;
304 write_s = dev->write_subdev;
305 if (minor >= COMEDI_NUM_BOARD_MINORS) {
306 s = comedi_subdevice_from_minor(dev, minor);
307 if (!s || s->subdev_flags & SDF_CMD_READ)
309 if (!s || s->subdev_flags & SDF_CMD_WRITE)
312 cfp->last_attached = dev->attached;
313 cfp->last_detach_count = dev->detach_count;
314 ACCESS_ONCE(cfp->read_subdev) = read_s;
315 ACCESS_ONCE(cfp->write_subdev) = write_s;
318 static void comedi_file_check(struct file *file)
320 struct comedi_file *cfp = file->private_data;
321 struct comedi_device *dev = cfp->dev;
323 if (cfp->last_attached != dev->attached ||
324 cfp->last_detach_count != dev->detach_count)
325 comedi_file_reset(file);
328 static struct comedi_subdevice *comedi_file_read_subdevice(struct file *file)
330 struct comedi_file *cfp = file->private_data;
332 comedi_file_check(file);
333 return ACCESS_ONCE(cfp->read_subdev);
336 static struct comedi_subdevice *comedi_file_write_subdevice(struct file *file)
338 struct comedi_file *cfp = file->private_data;
340 comedi_file_check(file);
341 return ACCESS_ONCE(cfp->write_subdev);
344 static int resize_async_buffer(struct comedi_device *dev,
345 struct comedi_subdevice *s, unsigned new_size)
347 struct comedi_async *async = s->async;
350 if (new_size > async->max_bufsize)
354 dev_dbg(dev->class_dev,
355 "subdevice is busy, cannot resize buffer\n");
358 if (comedi_buf_is_mmapped(s)) {
359 dev_dbg(dev->class_dev,
360 "subdevice is mmapped, cannot resize buffer\n");
364 /* make sure buffer is an integral number of pages (we round up) */
365 new_size = (new_size + PAGE_SIZE - 1) & PAGE_MASK;
367 retval = comedi_buf_alloc(dev, s, new_size);
372 retval = s->buf_change(dev, s);
377 dev_dbg(dev->class_dev, "subd %d buffer resized to %i bytes\n",
378 s->index, async->prealloc_bufsz);
382 /* sysfs attribute files */
384 static ssize_t max_read_buffer_kb_show(struct device *csdev,
385 struct device_attribute *attr, char *buf)
387 unsigned int minor = MINOR(csdev->devt);
388 struct comedi_device *dev;
389 struct comedi_subdevice *s;
390 unsigned int size = 0;
392 dev = comedi_dev_get_from_minor(minor);
396 mutex_lock(&dev->mutex);
397 s = comedi_read_subdevice(dev, minor);
398 if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
399 size = s->async->max_bufsize / 1024;
400 mutex_unlock(&dev->mutex);
403 return snprintf(buf, PAGE_SIZE, "%u\n", size);
406 static ssize_t max_read_buffer_kb_store(struct device *csdev,
407 struct device_attribute *attr,
408 const char *buf, size_t count)
410 unsigned int minor = MINOR(csdev->devt);
411 struct comedi_device *dev;
412 struct comedi_subdevice *s;
416 err = kstrtouint(buf, 10, &size);
419 if (size > (UINT_MAX / 1024))
423 dev = comedi_dev_get_from_minor(minor);
427 mutex_lock(&dev->mutex);
428 s = comedi_read_subdevice(dev, minor);
429 if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
430 s->async->max_bufsize = size;
433 mutex_unlock(&dev->mutex);
436 return err ? err : count;
438 static DEVICE_ATTR_RW(max_read_buffer_kb);
440 static ssize_t read_buffer_kb_show(struct device *csdev,
441 struct device_attribute *attr, char *buf)
443 unsigned int minor = MINOR(csdev->devt);
444 struct comedi_device *dev;
445 struct comedi_subdevice *s;
446 unsigned int size = 0;
448 dev = comedi_dev_get_from_minor(minor);
452 mutex_lock(&dev->mutex);
453 s = comedi_read_subdevice(dev, minor);
454 if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
455 size = s->async->prealloc_bufsz / 1024;
456 mutex_unlock(&dev->mutex);
459 return snprintf(buf, PAGE_SIZE, "%u\n", size);
462 static ssize_t read_buffer_kb_store(struct device *csdev,
463 struct device_attribute *attr,
464 const char *buf, size_t count)
466 unsigned int minor = MINOR(csdev->devt);
467 struct comedi_device *dev;
468 struct comedi_subdevice *s;
472 err = kstrtouint(buf, 10, &size);
475 if (size > (UINT_MAX / 1024))
479 dev = comedi_dev_get_from_minor(minor);
483 mutex_lock(&dev->mutex);
484 s = comedi_read_subdevice(dev, minor);
485 if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
486 err = resize_async_buffer(dev, s, size);
489 mutex_unlock(&dev->mutex);
492 return err ? err : count;
494 static DEVICE_ATTR_RW(read_buffer_kb);
496 static ssize_t max_write_buffer_kb_show(struct device *csdev,
497 struct device_attribute *attr,
500 unsigned int minor = MINOR(csdev->devt);
501 struct comedi_device *dev;
502 struct comedi_subdevice *s;
503 unsigned int size = 0;
505 dev = comedi_dev_get_from_minor(minor);
509 mutex_lock(&dev->mutex);
510 s = comedi_write_subdevice(dev, minor);
511 if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
512 size = s->async->max_bufsize / 1024;
513 mutex_unlock(&dev->mutex);
516 return snprintf(buf, PAGE_SIZE, "%u\n", size);
519 static ssize_t max_write_buffer_kb_store(struct device *csdev,
520 struct device_attribute *attr,
521 const char *buf, size_t count)
523 unsigned int minor = MINOR(csdev->devt);
524 struct comedi_device *dev;
525 struct comedi_subdevice *s;
529 err = kstrtouint(buf, 10, &size);
532 if (size > (UINT_MAX / 1024))
536 dev = comedi_dev_get_from_minor(minor);
540 mutex_lock(&dev->mutex);
541 s = comedi_write_subdevice(dev, minor);
542 if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
543 s->async->max_bufsize = size;
546 mutex_unlock(&dev->mutex);
549 return err ? err : count;
551 static DEVICE_ATTR_RW(max_write_buffer_kb);
553 static ssize_t write_buffer_kb_show(struct device *csdev,
554 struct device_attribute *attr, char *buf)
556 unsigned int minor = MINOR(csdev->devt);
557 struct comedi_device *dev;
558 struct comedi_subdevice *s;
559 unsigned int size = 0;
561 dev = comedi_dev_get_from_minor(minor);
565 mutex_lock(&dev->mutex);
566 s = comedi_write_subdevice(dev, minor);
567 if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
568 size = s->async->prealloc_bufsz / 1024;
569 mutex_unlock(&dev->mutex);
572 return snprintf(buf, PAGE_SIZE, "%u\n", size);
575 static ssize_t write_buffer_kb_store(struct device *csdev,
576 struct device_attribute *attr,
577 const char *buf, size_t count)
579 unsigned int minor = MINOR(csdev->devt);
580 struct comedi_device *dev;
581 struct comedi_subdevice *s;
585 err = kstrtouint(buf, 10, &size);
588 if (size > (UINT_MAX / 1024))
592 dev = comedi_dev_get_from_minor(minor);
596 mutex_lock(&dev->mutex);
597 s = comedi_write_subdevice(dev, minor);
598 if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
599 err = resize_async_buffer(dev, s, size);
602 mutex_unlock(&dev->mutex);
605 return err ? err : count;
607 static DEVICE_ATTR_RW(write_buffer_kb);
609 static struct attribute *comedi_dev_attrs[] = {
610 &dev_attr_max_read_buffer_kb.attr,
611 &dev_attr_read_buffer_kb.attr,
612 &dev_attr_max_write_buffer_kb.attr,
613 &dev_attr_write_buffer_kb.attr,
616 ATTRIBUTE_GROUPS(comedi_dev);
618 static void __comedi_clear_subdevice_runflags(struct comedi_subdevice *s,
621 s->runflags &= ~bits;
624 static void __comedi_set_subdevice_runflags(struct comedi_subdevice *s,
630 static void comedi_update_subdevice_runflags(struct comedi_subdevice *s,
631 unsigned mask, unsigned bits)
635 spin_lock_irqsave(&s->spin_lock, flags);
636 __comedi_clear_subdevice_runflags(s, mask);
637 __comedi_set_subdevice_runflags(s, bits & mask);
638 spin_unlock_irqrestore(&s->spin_lock, flags);
641 static unsigned __comedi_get_subdevice_runflags(struct comedi_subdevice *s)
646 static unsigned comedi_get_subdevice_runflags(struct comedi_subdevice *s)
651 spin_lock_irqsave(&s->spin_lock, flags);
652 runflags = __comedi_get_subdevice_runflags(s);
653 spin_unlock_irqrestore(&s->spin_lock, flags);
657 static bool comedi_is_runflags_running(unsigned runflags)
659 return runflags & COMEDI_SRF_RUNNING;
662 static bool comedi_is_runflags_in_error(unsigned runflags)
664 return runflags & COMEDI_SRF_ERROR;
668 * comedi_is_subdevice_running() - Check if async command running on subdevice
669 * @s: COMEDI subdevice.
671 * Return: %true if an asynchronous COMEDI command is active on the
672 * subdevice, else %false.
674 bool comedi_is_subdevice_running(struct comedi_subdevice *s)
676 unsigned runflags = comedi_get_subdevice_runflags(s);
678 return comedi_is_runflags_running(runflags);
680 EXPORT_SYMBOL_GPL(comedi_is_subdevice_running);
682 static bool __comedi_is_subdevice_running(struct comedi_subdevice *s)
684 unsigned runflags = __comedi_get_subdevice_runflags(s);
686 return comedi_is_runflags_running(runflags);
689 static bool comedi_is_subdevice_idle(struct comedi_subdevice *s)
691 unsigned runflags = comedi_get_subdevice_runflags(s);
693 return !(runflags & COMEDI_SRF_BUSY_MASK);
696 bool comedi_can_auto_free_spriv(struct comedi_subdevice *s)
698 unsigned runflags = __comedi_get_subdevice_runflags(s);
700 return runflags & COMEDI_SRF_FREE_SPRIV;
704 * comedi_set_spriv_auto_free() - Mark subdevice private data as freeable
705 * @s: COMEDI subdevice.
707 * Mark the subdevice as having a pointer to private data that can be
708 * automatically freed when the COMEDI device is detached from the low-level
711 void comedi_set_spriv_auto_free(struct comedi_subdevice *s)
713 __comedi_set_subdevice_runflags(s, COMEDI_SRF_FREE_SPRIV);
715 EXPORT_SYMBOL_GPL(comedi_set_spriv_auto_free);
718 * comedi_alloc_spriv - Allocate memory for the subdevice private data
719 * @s: COMEDI subdevice.
720 * @size: Size of the memory to allocate.
722 * Allocate memory for the subdevice private data and point @s->private
723 * to it. The memory will be freed automatically when the COMEDI device
724 * is detached from the low-level driver.
726 * Return: A pointer to the allocated memory @s->private on success.
727 * Return NULL on failure.
729 void *comedi_alloc_spriv(struct comedi_subdevice *s, size_t size)
731 s->private = kzalloc(size, GFP_KERNEL);
733 comedi_set_spriv_auto_free(s);
736 EXPORT_SYMBOL_GPL(comedi_alloc_spriv);
739 * This function restores a subdevice to an idle state.
741 static void do_become_nonbusy(struct comedi_device *dev,
742 struct comedi_subdevice *s)
744 struct comedi_async *async = s->async;
746 comedi_update_subdevice_runflags(s, COMEDI_SRF_RUNNING, 0);
749 async->inttrig = NULL;
750 kfree(async->cmd.chanlist);
751 async->cmd.chanlist = NULL;
753 wake_up_interruptible_all(&async->wait_head);
755 dev_err(dev->class_dev,
756 "BUG: (?) do_become_nonbusy called with async=NULL\n");
761 static int do_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
765 if (comedi_is_subdevice_running(s) && s->cancel)
766 ret = s->cancel(dev, s);
768 do_become_nonbusy(dev, s);
773 void comedi_device_cancel_all(struct comedi_device *dev)
775 struct comedi_subdevice *s;
781 for (i = 0; i < dev->n_subdevices; i++) {
782 s = &dev->subdevices[i];
788 static int is_device_busy(struct comedi_device *dev)
790 struct comedi_subdevice *s;
796 for (i = 0; i < dev->n_subdevices; i++) {
797 s = &dev->subdevices[i];
800 if (s->async && comedi_buf_is_mmapped(s))
808 * COMEDI_DEVCONFIG ioctl
809 * attaches (and configures) or detaches a legacy device
812 * pointer to comedi_devconfig structure (NULL if detaching)
815 * comedi_devconfig structure (if attaching)
820 static int do_devconfig_ioctl(struct comedi_device *dev,
821 struct comedi_devconfig __user *arg)
823 struct comedi_devconfig it;
825 if (!capable(CAP_SYS_ADMIN))
829 if (is_device_busy(dev))
832 struct module *driver_module = dev->driver->module;
834 comedi_device_detach(dev);
835 module_put(driver_module);
840 if (copy_from_user(&it, arg, sizeof(it)))
843 it.board_name[COMEDI_NAMELEN - 1] = 0;
845 if (it.options[COMEDI_DEVCONF_AUX_DATA_LENGTH]) {
846 dev_warn(dev->class_dev,
847 "comedi_config --init_data is deprecated\n");
851 if (dev->minor >= comedi_num_legacy_minors)
852 /* don't re-use dynamically allocated comedi devices */
855 /* This increments the driver module count on success. */
856 return comedi_device_attach(dev, &it);
860 * COMEDI_BUFCONFIG ioctl
861 * buffer configuration
864 * pointer to comedi_bufconfig structure
867 * comedi_bufconfig structure
870 * modified comedi_bufconfig structure
872 static int do_bufconfig_ioctl(struct comedi_device *dev,
873 struct comedi_bufconfig __user *arg)
875 struct comedi_bufconfig bc;
876 struct comedi_async *async;
877 struct comedi_subdevice *s;
880 if (copy_from_user(&bc, arg, sizeof(bc)))
883 if (bc.subdevice >= dev->n_subdevices)
886 s = &dev->subdevices[bc.subdevice];
890 dev_dbg(dev->class_dev,
891 "subdevice does not have async capability\n");
897 if (bc.maximum_size) {
898 if (!capable(CAP_SYS_ADMIN))
901 async->max_bufsize = bc.maximum_size;
905 retval = resize_async_buffer(dev, s, bc.size);
910 bc.size = async->prealloc_bufsz;
911 bc.maximum_size = async->max_bufsize;
914 if (copy_to_user(arg, &bc, sizeof(bc)))
921 * COMEDI_DEVINFO ioctl
925 * pointer to comedi_devinfo structure
931 * comedi_devinfo structure
933 static int do_devinfo_ioctl(struct comedi_device *dev,
934 struct comedi_devinfo __user *arg,
937 struct comedi_subdevice *s;
938 struct comedi_devinfo devinfo;
940 memset(&devinfo, 0, sizeof(devinfo));
942 /* fill devinfo structure */
943 devinfo.version_code = COMEDI_VERSION_CODE;
944 devinfo.n_subdevs = dev->n_subdevices;
945 strlcpy(devinfo.driver_name, dev->driver->driver_name, COMEDI_NAMELEN);
946 strlcpy(devinfo.board_name, dev->board_name, COMEDI_NAMELEN);
948 s = comedi_file_read_subdevice(file);
950 devinfo.read_subdevice = s->index;
952 devinfo.read_subdevice = -1;
954 s = comedi_file_write_subdevice(file);
956 devinfo.write_subdevice = s->index;
958 devinfo.write_subdevice = -1;
960 if (copy_to_user(arg, &devinfo, sizeof(devinfo)))
967 * COMEDI_SUBDINFO ioctl
971 * pointer to array of comedi_subdinfo structures
977 * array of comedi_subdinfo structures
979 static int do_subdinfo_ioctl(struct comedi_device *dev,
980 struct comedi_subdinfo __user *arg, void *file)
983 struct comedi_subdinfo *tmp, *us;
984 struct comedi_subdevice *s;
986 tmp = kcalloc(dev->n_subdevices, sizeof(*tmp), GFP_KERNEL);
990 /* fill subdinfo structs */
991 for (i = 0; i < dev->n_subdevices; i++) {
992 s = &dev->subdevices[i];
996 us->n_chan = s->n_chan;
997 us->subd_flags = s->subdev_flags;
998 if (comedi_is_subdevice_running(s))
999 us->subd_flags |= SDF_RUNNING;
1000 #define TIMER_nanosec 5 /* backwards compatibility */
1001 us->timer_type = TIMER_nanosec;
1002 us->len_chanlist = s->len_chanlist;
1003 us->maxdata = s->maxdata;
1004 if (s->range_table) {
1006 (i << 24) | (0 << 16) | (s->range_table->length);
1008 us->range_type = 0; /* XXX */
1012 us->subd_flags |= SDF_BUSY;
1013 if (s->busy == file)
1014 us->subd_flags |= SDF_BUSY_OWNER;
1016 us->subd_flags |= SDF_LOCKED;
1017 if (s->lock == file)
1018 us->subd_flags |= SDF_LOCK_OWNER;
1019 if (!s->maxdata && s->maxdata_list)
1020 us->subd_flags |= SDF_MAXDATA;
1021 if (s->range_table_list)
1022 us->subd_flags |= SDF_RANGETYPE;
1024 us->subd_flags |= SDF_CMD;
1026 if (s->insn_bits != &insn_inval)
1027 us->insn_bits_support = COMEDI_SUPPORTED;
1029 us->insn_bits_support = COMEDI_UNSUPPORTED;
1032 ret = copy_to_user(arg, tmp, dev->n_subdevices * sizeof(*tmp));
1036 return ret ? -EFAULT : 0;
1040 * COMEDI_CHANINFO ioctl
1041 * subdevice channel info
1044 * pointer to comedi_chaninfo structure
1047 * comedi_chaninfo structure
1050 * array of maxdata values to chaninfo->maxdata_list if requested
1051 * array of range table lengths to chaninfo->range_table_list if requested
1053 static int do_chaninfo_ioctl(struct comedi_device *dev,
1054 struct comedi_chaninfo __user *arg)
1056 struct comedi_subdevice *s;
1057 struct comedi_chaninfo it;
1059 if (copy_from_user(&it, arg, sizeof(it)))
1062 if (it.subdev >= dev->n_subdevices)
1064 s = &dev->subdevices[it.subdev];
1066 if (it.maxdata_list) {
1067 if (s->maxdata || !s->maxdata_list)
1069 if (copy_to_user(it.maxdata_list, s->maxdata_list,
1070 s->n_chan * sizeof(unsigned int)))
1075 return -EINVAL; /* flaglist not supported */
1080 if (!s->range_table_list)
1082 for (i = 0; i < s->n_chan; i++) {
1085 x = (dev->minor << 28) | (it.subdev << 24) | (i << 16) |
1086 (s->range_table_list[i]->length);
1087 if (put_user(x, it.rangelist + i))
1096 * COMEDI_BUFINFO ioctl
1097 * buffer information
1100 * pointer to comedi_bufinfo structure
1103 * comedi_bufinfo structure
1106 * modified comedi_bufinfo structure
1108 static int do_bufinfo_ioctl(struct comedi_device *dev,
1109 struct comedi_bufinfo __user *arg, void *file)
1111 struct comedi_bufinfo bi;
1112 struct comedi_subdevice *s;
1113 struct comedi_async *async;
1115 if (copy_from_user(&bi, arg, sizeof(bi)))
1118 if (bi.subdevice >= dev->n_subdevices)
1121 s = &dev->subdevices[bi.subdevice];
1126 dev_dbg(dev->class_dev,
1127 "subdevice does not have async capability\n");
1128 bi.buf_write_ptr = 0;
1129 bi.buf_read_ptr = 0;
1130 bi.buf_write_count = 0;
1131 bi.buf_read_count = 0;
1133 bi.bytes_written = 0;
1138 bi.bytes_written = 0;
1139 goto copyback_position;
1141 if (s->busy != file)
1144 if (bi.bytes_read && !(async->cmd.flags & CMDF_WRITE)) {
1145 bi.bytes_read = comedi_buf_read_alloc(s, bi.bytes_read);
1146 comedi_buf_read_free(s, bi.bytes_read);
1148 if (comedi_is_subdevice_idle(s) &&
1149 comedi_buf_n_bytes_ready(s) == 0) {
1150 do_become_nonbusy(dev, s);
1154 if (bi.bytes_written && (async->cmd.flags & CMDF_WRITE)) {
1156 comedi_buf_write_alloc(s, bi.bytes_written);
1157 comedi_buf_write_free(s, bi.bytes_written);
1161 bi.buf_write_count = async->buf_write_count;
1162 bi.buf_write_ptr = async->buf_write_ptr;
1163 bi.buf_read_count = async->buf_read_count;
1164 bi.buf_read_ptr = async->buf_read_ptr;
1167 if (copy_to_user(arg, &bi, sizeof(bi)))
1173 static int check_insn_config_length(struct comedi_insn *insn,
1180 case INSN_CONFIG_DIO_OUTPUT:
1181 case INSN_CONFIG_DIO_INPUT:
1182 case INSN_CONFIG_DISARM:
1183 case INSN_CONFIG_RESET:
1187 case INSN_CONFIG_ARM:
1188 case INSN_CONFIG_DIO_QUERY:
1189 case INSN_CONFIG_BLOCK_SIZE:
1190 case INSN_CONFIG_FILTER:
1191 case INSN_CONFIG_SERIAL_CLOCK:
1192 case INSN_CONFIG_BIDIRECTIONAL_DATA:
1193 case INSN_CONFIG_ALT_SOURCE:
1194 case INSN_CONFIG_SET_COUNTER_MODE:
1195 case INSN_CONFIG_8254_READ_STATUS:
1196 case INSN_CONFIG_SET_ROUTING:
1197 case INSN_CONFIG_GET_ROUTING:
1198 case INSN_CONFIG_GET_PWM_STATUS:
1199 case INSN_CONFIG_PWM_SET_PERIOD:
1200 case INSN_CONFIG_PWM_GET_PERIOD:
1204 case INSN_CONFIG_SET_GATE_SRC:
1205 case INSN_CONFIG_GET_GATE_SRC:
1206 case INSN_CONFIG_SET_CLOCK_SRC:
1207 case INSN_CONFIG_GET_CLOCK_SRC:
1208 case INSN_CONFIG_SET_OTHER_SRC:
1209 case INSN_CONFIG_GET_COUNTER_STATUS:
1210 case INSN_CONFIG_PWM_SET_H_BRIDGE:
1211 case INSN_CONFIG_PWM_GET_H_BRIDGE:
1212 case INSN_CONFIG_GET_HARDWARE_BUFFER_SIZE:
1216 case INSN_CONFIG_PWM_OUTPUT:
1217 case INSN_CONFIG_ANALOG_TRIG:
1221 case INSN_CONFIG_DIGITAL_TRIG:
1226 * by default we allow the insn since we don't have checks for
1227 * all possible cases yet
1230 pr_warn("No check for data length of config insn id %i is implemented\n",
1232 pr_warn("Add a check to %s in %s\n", __func__, __FILE__);
1233 pr_warn("Assuming n=%i is correct\n", insn->n);
1239 static int parse_insn(struct comedi_device *dev, struct comedi_insn *insn,
1240 unsigned int *data, void *file)
1242 struct comedi_subdevice *s;
1246 if (insn->insn & INSN_MASK_SPECIAL) {
1247 /* a non-subdevice instruction */
1249 switch (insn->insn) {
1259 do_gettimeofday(&tv);
1260 data[0] = tv.tv_sec;
1261 data[1] = tv.tv_usec;
1267 if (insn->n != 1 || data[0] >= 100000) {
1271 udelay(data[0] / 1000);
1279 if (insn->subdev >= dev->n_subdevices) {
1280 dev_dbg(dev->class_dev,
1281 "%d not usable subdevice\n",
1286 s = &dev->subdevices[insn->subdev];
1288 dev_dbg(dev->class_dev, "no async\n");
1292 if (!s->async->inttrig) {
1293 dev_dbg(dev->class_dev, "no inttrig\n");
1297 ret = s->async->inttrig(dev, s, data[0]);
1302 dev_dbg(dev->class_dev, "invalid insn\n");
1307 /* a subdevice instruction */
1308 unsigned int maxdata;
1310 if (insn->subdev >= dev->n_subdevices) {
1311 dev_dbg(dev->class_dev, "subdevice %d out of range\n",
1316 s = &dev->subdevices[insn->subdev];
1318 if (s->type == COMEDI_SUBD_UNUSED) {
1319 dev_dbg(dev->class_dev, "%d not usable subdevice\n",
1325 /* are we locked? (ioctl lock) */
1326 if (s->lock && s->lock != file) {
1327 dev_dbg(dev->class_dev, "device locked\n");
1332 ret = comedi_check_chanlist(s, 1, &insn->chanspec);
1335 dev_dbg(dev->class_dev, "bad chanspec\n");
1343 /* This looks arbitrary. It is. */
1344 s->busy = &parse_insn;
1345 switch (insn->insn) {
1347 ret = s->insn_read(dev, s, insn, data);
1348 if (ret == -ETIMEDOUT) {
1349 dev_dbg(dev->class_dev,
1350 "subdevice %d read instruction timed out\n",
1355 maxdata = s->maxdata_list
1356 ? s->maxdata_list[CR_CHAN(insn->chanspec)]
1358 for (i = 0; i < insn->n; ++i) {
1359 if (data[i] > maxdata) {
1361 dev_dbg(dev->class_dev,
1362 "bad data value(s)\n");
1367 ret = s->insn_write(dev, s, insn, data);
1368 if (ret == -ETIMEDOUT) {
1369 dev_dbg(dev->class_dev,
1370 "subdevice %d write instruction timed out\n",
1380 * Most drivers ignore the base channel in
1381 * insn->chanspec. Fix this here if
1382 * the subdevice has <= 32 channels.
1384 unsigned int orig_mask = data[0];
1385 unsigned int shift = 0;
1387 if (s->n_chan <= 32) {
1388 shift = CR_CHAN(insn->chanspec);
1395 ret = s->insn_bits(dev, s, insn, data);
1396 data[0] = orig_mask;
1402 ret = check_insn_config_length(insn, data);
1405 ret = s->insn_config(dev, s, insn, data);
1420 * COMEDI_INSNLIST ioctl
1421 * synchronous instruction list
1424 * pointer to comedi_insnlist structure
1427 * comedi_insnlist structure
1428 * array of comedi_insn structures from insnlist->insns pointer
1429 * data (for writes) from insns[].data pointers
1432 * data (for reads) to insns[].data pointers
1434 /* arbitrary limits */
1435 #define MAX_SAMPLES 256
1436 static int do_insnlist_ioctl(struct comedi_device *dev,
1437 struct comedi_insnlist __user *arg, void *file)
1439 struct comedi_insnlist insnlist;
1440 struct comedi_insn *insns = NULL;
1441 unsigned int *data = NULL;
1445 if (copy_from_user(&insnlist, arg, sizeof(insnlist)))
1448 data = kmalloc_array(MAX_SAMPLES, sizeof(unsigned int), GFP_KERNEL);
1454 insns = kcalloc(insnlist.n_insns, sizeof(*insns), GFP_KERNEL);
1460 if (copy_from_user(insns, insnlist.insns,
1461 sizeof(*insns) * insnlist.n_insns)) {
1462 dev_dbg(dev->class_dev, "copy_from_user failed\n");
1467 for (i = 0; i < insnlist.n_insns; i++) {
1468 if (insns[i].n > MAX_SAMPLES) {
1469 dev_dbg(dev->class_dev,
1470 "number of samples too large\n");
1474 if (insns[i].insn & INSN_MASK_WRITE) {
1475 if (copy_from_user(data, insns[i].data,
1476 insns[i].n * sizeof(unsigned int))) {
1477 dev_dbg(dev->class_dev,
1478 "copy_from_user failed\n");
1483 ret = parse_insn(dev, insns + i, data, file);
1486 if (insns[i].insn & INSN_MASK_READ) {
1487 if (copy_to_user(insns[i].data, data,
1488 insns[i].n * sizeof(unsigned int))) {
1489 dev_dbg(dev->class_dev,
1490 "copy_to_user failed\n");
1510 * synchronous instruction
1513 * pointer to comedi_insn structure
1516 * comedi_insn structure
1517 * data (for writes) from insn->data pointer
1520 * data (for reads) to insn->data pointer
1522 static int do_insn_ioctl(struct comedi_device *dev,
1523 struct comedi_insn __user *arg, void *file)
1525 struct comedi_insn insn;
1526 unsigned int *data = NULL;
1529 data = kmalloc_array(MAX_SAMPLES, sizeof(unsigned int), GFP_KERNEL);
1535 if (copy_from_user(&insn, arg, sizeof(insn))) {
1540 /* This is where the behavior of insn and insnlist deviate. */
1541 if (insn.n > MAX_SAMPLES)
1542 insn.n = MAX_SAMPLES;
1543 if (insn.insn & INSN_MASK_WRITE) {
1544 if (copy_from_user(data,
1546 insn.n * sizeof(unsigned int))) {
1551 ret = parse_insn(dev, &insn, data, file);
1554 if (insn.insn & INSN_MASK_READ) {
1555 if (copy_to_user(insn.data,
1557 insn.n * sizeof(unsigned int))) {
1570 static int __comedi_get_user_cmd(struct comedi_device *dev,
1571 struct comedi_cmd __user *arg,
1572 struct comedi_cmd *cmd)
1574 struct comedi_subdevice *s;
1576 if (copy_from_user(cmd, arg, sizeof(*cmd))) {
1577 dev_dbg(dev->class_dev, "bad cmd address\n");
1581 if (cmd->subdev >= dev->n_subdevices) {
1582 dev_dbg(dev->class_dev, "%d no such subdevice\n", cmd->subdev);
1586 s = &dev->subdevices[cmd->subdev];
1588 if (s->type == COMEDI_SUBD_UNUSED) {
1589 dev_dbg(dev->class_dev, "%d not valid subdevice\n",
1594 if (!s->do_cmd || !s->do_cmdtest || !s->async) {
1595 dev_dbg(dev->class_dev,
1596 "subdevice %d does not support commands\n",
1601 /* make sure channel/gain list isn't too long */
1602 if (cmd->chanlist_len > s->len_chanlist) {
1603 dev_dbg(dev->class_dev, "channel/gain list too long %d > %d\n",
1604 cmd->chanlist_len, s->len_chanlist);
1609 * Set the CMDF_WRITE flag to the correct state if the subdevice
1610 * supports only "read" commands or only "write" commands.
1612 switch (s->subdev_flags & (SDF_CMD_READ | SDF_CMD_WRITE)) {
1614 cmd->flags &= ~CMDF_WRITE;
1617 cmd->flags |= CMDF_WRITE;
1626 static int __comedi_get_user_chanlist(struct comedi_device *dev,
1627 struct comedi_subdevice *s,
1628 unsigned int __user *user_chanlist,
1629 struct comedi_cmd *cmd)
1631 unsigned int *chanlist;
1634 cmd->chanlist = NULL;
1635 chanlist = memdup_user(user_chanlist,
1636 cmd->chanlist_len * sizeof(unsigned int));
1637 if (IS_ERR(chanlist))
1638 return PTR_ERR(chanlist);
1640 /* make sure each element in channel/gain list is valid */
1641 ret = comedi_check_chanlist(s, cmd->chanlist_len, chanlist);
1647 cmd->chanlist = chanlist;
1654 * asynchronous acquisition command set-up
1657 * pointer to comedi_cmd structure
1660 * comedi_cmd structure
1661 * channel/range list from cmd->chanlist pointer
1664 * possibly modified comedi_cmd structure (when -EAGAIN returned)
1666 static int do_cmd_ioctl(struct comedi_device *dev,
1667 struct comedi_cmd __user *arg, void *file)
1669 struct comedi_cmd cmd;
1670 struct comedi_subdevice *s;
1671 struct comedi_async *async;
1672 unsigned int __user *user_chanlist;
1675 /* get the user's cmd and do some simple validation */
1676 ret = __comedi_get_user_cmd(dev, arg, &cmd);
1680 /* save user's chanlist pointer so it can be restored later */
1681 user_chanlist = (unsigned int __user *)cmd.chanlist;
1683 s = &dev->subdevices[cmd.subdev];
1686 /* are we locked? (ioctl lock) */
1687 if (s->lock && s->lock != file) {
1688 dev_dbg(dev->class_dev, "subdevice locked\n");
1694 dev_dbg(dev->class_dev, "subdevice busy\n");
1698 /* make sure channel/gain list isn't too short */
1699 if (cmd.chanlist_len < 1) {
1700 dev_dbg(dev->class_dev, "channel/gain list too short %u < 1\n",
1706 async->cmd.data = NULL;
1708 /* load channel/gain list */
1709 ret = __comedi_get_user_chanlist(dev, s, user_chanlist, &async->cmd);
1713 ret = s->do_cmdtest(dev, s, &async->cmd);
1715 if (async->cmd.flags & CMDF_BOGUS || ret) {
1716 dev_dbg(dev->class_dev, "test returned %d\n", ret);
1718 /* restore chanlist pointer before copying back */
1719 cmd.chanlist = (unsigned int __force *)user_chanlist;
1721 if (copy_to_user(arg, &cmd, sizeof(cmd))) {
1722 dev_dbg(dev->class_dev, "fault writing cmd\n");
1730 if (!async->prealloc_bufsz) {
1732 dev_dbg(dev->class_dev, "no buffer (?)\n");
1736 comedi_buf_reset(s);
1738 async->cb_mask = COMEDI_CB_BLOCK | COMEDI_CB_CANCEL_MASK;
1739 if (async->cmd.flags & CMDF_WAKE_EOS)
1740 async->cb_mask |= COMEDI_CB_EOS;
1742 comedi_update_subdevice_runflags(s, COMEDI_SRF_BUSY_MASK,
1743 COMEDI_SRF_RUNNING);
1746 * Set s->busy _after_ setting COMEDI_SRF_RUNNING flag to avoid
1747 * race with comedi_read() or comedi_write().
1750 ret = s->do_cmd(dev, s);
1755 do_become_nonbusy(dev, s);
1761 * COMEDI_CMDTEST ioctl
1762 * asynchronous acquisition command testing
1765 * pointer to comedi_cmd structure
1768 * comedi_cmd structure
1769 * channel/range list from cmd->chanlist pointer
1772 * possibly modified comedi_cmd structure
1774 static int do_cmdtest_ioctl(struct comedi_device *dev,
1775 struct comedi_cmd __user *arg, void *file)
1777 struct comedi_cmd cmd;
1778 struct comedi_subdevice *s;
1779 unsigned int __user *user_chanlist;
1782 /* get the user's cmd and do some simple validation */
1783 ret = __comedi_get_user_cmd(dev, arg, &cmd);
1787 /* save user's chanlist pointer so it can be restored later */
1788 user_chanlist = (unsigned int __user *)cmd.chanlist;
1790 s = &dev->subdevices[cmd.subdev];
1792 /* user_chanlist can be NULL for COMEDI_CMDTEST ioctl */
1793 if (user_chanlist) {
1794 /* load channel/gain list */
1795 ret = __comedi_get_user_chanlist(dev, s, user_chanlist, &cmd);
1800 ret = s->do_cmdtest(dev, s, &cmd);
1802 kfree(cmd.chanlist); /* free kernel copy of user chanlist */
1804 /* restore chanlist pointer before copying back */
1805 cmd.chanlist = (unsigned int __force *)user_chanlist;
1807 if (copy_to_user(arg, &cmd, sizeof(cmd))) {
1808 dev_dbg(dev->class_dev, "bad cmd address\n");
1828 static int do_lock_ioctl(struct comedi_device *dev, unsigned long arg,
1832 unsigned long flags;
1833 struct comedi_subdevice *s;
1835 if (arg >= dev->n_subdevices)
1837 s = &dev->subdevices[arg];
1839 spin_lock_irqsave(&s->spin_lock, flags);
1840 if (s->busy || s->lock)
1844 spin_unlock_irqrestore(&s->spin_lock, flags);
1850 * COMEDI_UNLOCK ioctl
1862 static int do_unlock_ioctl(struct comedi_device *dev, unsigned long arg,
1865 struct comedi_subdevice *s;
1867 if (arg >= dev->n_subdevices)
1869 s = &dev->subdevices[arg];
1874 if (s->lock && s->lock != file)
1877 if (s->lock == file)
1884 * COMEDI_CANCEL ioctl
1885 * cancel asynchronous acquisition
1896 static int do_cancel_ioctl(struct comedi_device *dev, unsigned long arg,
1899 struct comedi_subdevice *s;
1901 if (arg >= dev->n_subdevices)
1903 s = &dev->subdevices[arg];
1910 if (s->busy != file)
1913 return do_cancel(dev, s);
1918 * instructs driver to synchronize buffers
1929 static int do_poll_ioctl(struct comedi_device *dev, unsigned long arg,
1932 struct comedi_subdevice *s;
1934 if (arg >= dev->n_subdevices)
1936 s = &dev->subdevices[arg];
1941 if (s->busy != file)
1945 return s->poll(dev, s);
1951 * COMEDI_SETRSUBD ioctl
1952 * sets the current "read" subdevice on a per-file basis
1963 static int do_setrsubd_ioctl(struct comedi_device *dev, unsigned long arg,
1966 struct comedi_file *cfp = file->private_data;
1967 struct comedi_subdevice *s_old, *s_new;
1969 if (arg >= dev->n_subdevices)
1972 s_new = &dev->subdevices[arg];
1973 s_old = comedi_file_read_subdevice(file);
1975 return 0; /* no change */
1977 if (!(s_new->subdev_flags & SDF_CMD_READ))
1981 * Check the file isn't still busy handling a "read" command on the
1982 * old subdevice (if any).
1984 if (s_old && s_old->busy == file && s_old->async &&
1985 !(s_old->async->cmd.flags & CMDF_WRITE))
1988 ACCESS_ONCE(cfp->read_subdev) = s_new;
1993 * COMEDI_SETWSUBD ioctl
1994 * sets the current "write" subdevice on a per-file basis
2005 static int do_setwsubd_ioctl(struct comedi_device *dev, unsigned long arg,
2008 struct comedi_file *cfp = file->private_data;
2009 struct comedi_subdevice *s_old, *s_new;
2011 if (arg >= dev->n_subdevices)
2014 s_new = &dev->subdevices[arg];
2015 s_old = comedi_file_write_subdevice(file);
2017 return 0; /* no change */
2019 if (!(s_new->subdev_flags & SDF_CMD_WRITE))
2023 * Check the file isn't still busy handling a "write" command on the
2024 * old subdevice (if any).
2026 if (s_old && s_old->busy == file && s_old->async &&
2027 (s_old->async->cmd.flags & CMDF_WRITE))
2030 ACCESS_ONCE(cfp->write_subdev) = s_new;
2034 static long comedi_unlocked_ioctl(struct file *file, unsigned int cmd,
2037 unsigned minor = iminor(file_inode(file));
2038 struct comedi_file *cfp = file->private_data;
2039 struct comedi_device *dev = cfp->dev;
2042 mutex_lock(&dev->mutex);
2045 * Device config is special, because it must work on
2046 * an unconfigured device.
2048 if (cmd == COMEDI_DEVCONFIG) {
2049 if (minor >= COMEDI_NUM_BOARD_MINORS) {
2050 /* Device config not appropriate on non-board minors. */
2054 rc = do_devconfig_ioctl(dev,
2055 (struct comedi_devconfig __user *)arg);
2058 dev->minor >= comedi_num_legacy_minors) {
2060 * Successfully unconfigured a dynamically
2061 * allocated device. Try and remove it.
2063 if (comedi_clear_board_dev(dev)) {
2064 mutex_unlock(&dev->mutex);
2065 comedi_free_board_dev(dev);
2073 if (!dev->attached) {
2074 dev_dbg(dev->class_dev, "no driver attached\n");
2080 case COMEDI_BUFCONFIG:
2081 rc = do_bufconfig_ioctl(dev,
2082 (struct comedi_bufconfig __user *)arg);
2084 case COMEDI_DEVINFO:
2085 rc = do_devinfo_ioctl(dev, (struct comedi_devinfo __user *)arg,
2088 case COMEDI_SUBDINFO:
2089 rc = do_subdinfo_ioctl(dev,
2090 (struct comedi_subdinfo __user *)arg,
2093 case COMEDI_CHANINFO:
2094 rc = do_chaninfo_ioctl(dev, (void __user *)arg);
2096 case COMEDI_RANGEINFO:
2097 rc = do_rangeinfo_ioctl(dev, (void __user *)arg);
2099 case COMEDI_BUFINFO:
2100 rc = do_bufinfo_ioctl(dev,
2101 (struct comedi_bufinfo __user *)arg,
2105 rc = do_lock_ioctl(dev, arg, file);
2108 rc = do_unlock_ioctl(dev, arg, file);
2111 rc = do_cancel_ioctl(dev, arg, file);
2114 rc = do_cmd_ioctl(dev, (struct comedi_cmd __user *)arg, file);
2116 case COMEDI_CMDTEST:
2117 rc = do_cmdtest_ioctl(dev, (struct comedi_cmd __user *)arg,
2120 case COMEDI_INSNLIST:
2121 rc = do_insnlist_ioctl(dev,
2122 (struct comedi_insnlist __user *)arg,
2126 rc = do_insn_ioctl(dev, (struct comedi_insn __user *)arg,
2130 rc = do_poll_ioctl(dev, arg, file);
2132 case COMEDI_SETRSUBD:
2133 rc = do_setrsubd_ioctl(dev, arg, file);
2135 case COMEDI_SETWSUBD:
2136 rc = do_setwsubd_ioctl(dev, arg, file);
2144 mutex_unlock(&dev->mutex);
2148 static void comedi_vm_open(struct vm_area_struct *area)
2150 struct comedi_buf_map *bm;
2152 bm = area->vm_private_data;
2153 comedi_buf_map_get(bm);
2156 static void comedi_vm_close(struct vm_area_struct *area)
2158 struct comedi_buf_map *bm;
2160 bm = area->vm_private_data;
2161 comedi_buf_map_put(bm);
2164 static const struct vm_operations_struct comedi_vm_ops = {
2165 .open = comedi_vm_open,
2166 .close = comedi_vm_close,
2169 static int comedi_mmap(struct file *file, struct vm_area_struct *vma)
2171 struct comedi_file *cfp = file->private_data;
2172 struct comedi_device *dev = cfp->dev;
2173 struct comedi_subdevice *s;
2174 struct comedi_async *async;
2175 struct comedi_buf_map *bm = NULL;
2176 unsigned long start = vma->vm_start;
2183 * 'trylock' avoids circular dependency with current->mm->mmap_sem
2184 * and down-reading &dev->attach_lock should normally succeed without
2185 * contention unless the device is in the process of being attached
2188 if (!down_read_trylock(&dev->attach_lock))
2191 if (!dev->attached) {
2192 dev_dbg(dev->class_dev, "no driver attached\n");
2197 if (vma->vm_flags & VM_WRITE)
2198 s = comedi_file_write_subdevice(file);
2200 s = comedi_file_read_subdevice(file);
2212 if (vma->vm_pgoff != 0) {
2213 dev_dbg(dev->class_dev, "mmap() offset must be 0.\n");
2218 size = vma->vm_end - vma->vm_start;
2219 if (size > async->prealloc_bufsz) {
2223 if (size & (~PAGE_MASK)) {
2228 n_pages = size >> PAGE_SHIFT;
2230 /* get reference to current buf map (if any) */
2231 bm = comedi_buf_map_from_subdev_get(s);
2232 if (!bm || n_pages > bm->n_pages) {
2236 for (i = 0; i < n_pages; ++i) {
2237 struct comedi_buf_page *buf = &bm->page_list[i];
2239 if (remap_pfn_range(vma, start,
2240 page_to_pfn(virt_to_page(buf->virt_addr)),
2241 PAGE_SIZE, PAGE_SHARED)) {
2248 vma->vm_ops = &comedi_vm_ops;
2249 vma->vm_private_data = bm;
2251 vma->vm_ops->open(vma);
2255 up_read(&dev->attach_lock);
2256 comedi_buf_map_put(bm); /* put reference to buf map - okay if NULL */
2260 static unsigned int comedi_poll(struct file *file, poll_table *wait)
2262 unsigned int mask = 0;
2263 struct comedi_file *cfp = file->private_data;
2264 struct comedi_device *dev = cfp->dev;
2265 struct comedi_subdevice *s;
2267 mutex_lock(&dev->mutex);
2269 if (!dev->attached) {
2270 dev_dbg(dev->class_dev, "no driver attached\n");
2274 s = comedi_file_read_subdevice(file);
2275 if (s && s->async) {
2276 poll_wait(file, &s->async->wait_head, wait);
2277 if (!s->busy || !comedi_is_subdevice_running(s) ||
2278 (s->async->cmd.flags & CMDF_WRITE) ||
2279 comedi_buf_read_n_available(s) > 0)
2280 mask |= POLLIN | POLLRDNORM;
2283 s = comedi_file_write_subdevice(file);
2284 if (s && s->async) {
2285 unsigned int bps = comedi_bytes_per_sample(s);
2287 poll_wait(file, &s->async->wait_head, wait);
2288 comedi_buf_write_alloc(s, s->async->prealloc_bufsz);
2289 if (!s->busy || !comedi_is_subdevice_running(s) ||
2290 !(s->async->cmd.flags & CMDF_WRITE) ||
2291 comedi_buf_write_n_allocated(s) >= bps)
2292 mask |= POLLOUT | POLLWRNORM;
2296 mutex_unlock(&dev->mutex);
2300 static ssize_t comedi_write(struct file *file, const char __user *buf,
2301 size_t nbytes, loff_t *offset)
2303 struct comedi_subdevice *s;
2304 struct comedi_async *async;
2305 int n, m, count = 0, retval = 0;
2306 DECLARE_WAITQUEUE(wait, current);
2307 struct comedi_file *cfp = file->private_data;
2308 struct comedi_device *dev = cfp->dev;
2309 bool on_wait_queue = false;
2311 unsigned int old_detach_count;
2313 /* Protect against device detachment during operation. */
2314 down_read(&dev->attach_lock);
2315 attach_locked = true;
2316 old_detach_count = dev->detach_count;
2318 if (!dev->attached) {
2319 dev_dbg(dev->class_dev, "no driver attached\n");
2324 s = comedi_file_write_subdevice(file);
2325 if (!s || !s->async) {
2332 if (!s->busy || !nbytes)
2334 if (s->busy != file) {
2338 if (!(async->cmd.flags & CMDF_WRITE)) {
2343 add_wait_queue(&async->wait_head, &wait);
2344 on_wait_queue = true;
2345 while (nbytes > 0 && !retval) {
2348 set_current_state(TASK_INTERRUPTIBLE);
2350 runflags = comedi_get_subdevice_runflags(s);
2351 if (!comedi_is_runflags_running(runflags)) {
2353 struct comedi_subdevice *new_s;
2355 if (comedi_is_runflags_in_error(runflags))
2360 * To avoid deadlock, cannot acquire dev->mutex
2361 * while dev->attach_lock is held. Need to
2362 * remove task from the async wait queue before
2363 * releasing dev->attach_lock, as it might not
2364 * be valid afterwards.
2366 remove_wait_queue(&async->wait_head, &wait);
2367 on_wait_queue = false;
2368 up_read(&dev->attach_lock);
2369 attach_locked = false;
2370 mutex_lock(&dev->mutex);
2372 * Become non-busy unless things have changed
2373 * behind our back. Checking dev->detach_count
2374 * is unchanged ought to be sufficient (unless
2375 * there have been 2**32 detaches in the
2376 * meantime!), but check the subdevice pointer
2377 * as well just in case.
2379 new_s = comedi_file_write_subdevice(file);
2380 if (dev->attached &&
2381 old_detach_count == dev->detach_count &&
2382 s == new_s && new_s->async == async)
2383 do_become_nonbusy(dev, s);
2384 mutex_unlock(&dev->mutex);
2392 if (async->buf_write_ptr + m > async->prealloc_bufsz)
2393 m = async->prealloc_bufsz - async->buf_write_ptr;
2394 comedi_buf_write_alloc(s, async->prealloc_bufsz);
2395 if (m > comedi_buf_write_n_allocated(s))
2396 m = comedi_buf_write_n_allocated(s);
2401 if (file->f_flags & O_NONBLOCK) {
2406 if (signal_pending(current)) {
2407 retval = -ERESTARTSYS;
2412 if (s->busy != file) {
2416 if (!(async->cmd.flags & CMDF_WRITE)) {
2423 m = copy_from_user(async->prealloc_buf + async->buf_write_ptr,
2429 comedi_buf_write_free(s, n);
2435 break; /* makes device work like a pipe */
2439 remove_wait_queue(&async->wait_head, &wait);
2440 set_current_state(TASK_RUNNING);
2442 up_read(&dev->attach_lock);
2444 return count ? count : retval;
2447 static ssize_t comedi_read(struct file *file, char __user *buf, size_t nbytes,
2450 struct comedi_subdevice *s;
2451 struct comedi_async *async;
2452 int n, m, count = 0, retval = 0;
2453 DECLARE_WAITQUEUE(wait, current);
2454 struct comedi_file *cfp = file->private_data;
2455 struct comedi_device *dev = cfp->dev;
2456 unsigned int old_detach_count;
2457 bool become_nonbusy = false;
2460 /* Protect against device detachment during operation. */
2461 down_read(&dev->attach_lock);
2462 attach_locked = true;
2463 old_detach_count = dev->detach_count;
2465 if (!dev->attached) {
2466 dev_dbg(dev->class_dev, "no driver attached\n");
2471 s = comedi_file_read_subdevice(file);
2472 if (!s || !s->async) {
2478 if (!s->busy || !nbytes)
2480 if (s->busy != file) {
2484 if (async->cmd.flags & CMDF_WRITE) {
2489 add_wait_queue(&async->wait_head, &wait);
2490 while (nbytes > 0 && !retval) {
2491 set_current_state(TASK_INTERRUPTIBLE);
2495 m = comedi_buf_read_n_available(s);
2496 if (async->buf_read_ptr + m > async->prealloc_bufsz)
2497 m = async->prealloc_bufsz - async->buf_read_ptr;
2502 unsigned runflags = comedi_get_subdevice_runflags(s);
2504 if (!comedi_is_runflags_running(runflags)) {
2505 if (comedi_is_runflags_in_error(runflags))
2509 become_nonbusy = true;
2512 if (file->f_flags & O_NONBLOCK) {
2517 if (signal_pending(current)) {
2518 retval = -ERESTARTSYS;
2525 if (s->busy != file) {
2529 if (async->cmd.flags & CMDF_WRITE) {
2535 m = copy_to_user(buf, async->prealloc_buf +
2536 async->buf_read_ptr, n);
2542 comedi_buf_read_alloc(s, n);
2543 comedi_buf_read_free(s, n);
2549 break; /* makes device work like a pipe */
2551 remove_wait_queue(&async->wait_head, &wait);
2552 set_current_state(TASK_RUNNING);
2553 if (become_nonbusy || comedi_is_subdevice_idle(s)) {
2554 struct comedi_subdevice *new_s;
2557 * To avoid deadlock, cannot acquire dev->mutex
2558 * while dev->attach_lock is held.
2560 up_read(&dev->attach_lock);
2561 attach_locked = false;
2562 mutex_lock(&dev->mutex);
2564 * Check device hasn't become detached behind our back.
2565 * Checking dev->detach_count is unchanged ought to be
2566 * sufficient (unless there have been 2**32 detaches in the
2567 * meantime!), but check the subdevice pointer as well just in
2570 new_s = comedi_file_read_subdevice(file);
2571 if (dev->attached && old_detach_count == dev->detach_count &&
2572 s == new_s && new_s->async == async) {
2573 if (become_nonbusy || comedi_buf_n_bytes_ready(s) == 0)
2574 do_become_nonbusy(dev, s);
2576 mutex_unlock(&dev->mutex);
2580 up_read(&dev->attach_lock);
2582 return count ? count : retval;
2585 static int comedi_open(struct inode *inode, struct file *file)
2587 const unsigned minor = iminor(inode);
2588 struct comedi_file *cfp;
2589 struct comedi_device *dev = comedi_dev_get_from_minor(minor);
2593 pr_debug("invalid minor number\n");
2597 cfp = kzalloc(sizeof(*cfp), GFP_KERNEL);
2603 mutex_lock(&dev->mutex);
2604 if (!dev->attached && !capable(CAP_SYS_ADMIN)) {
2605 dev_dbg(dev->class_dev, "not attached and not CAP_SYS_ADMIN\n");
2609 if (dev->attached && dev->use_count == 0) {
2610 if (!try_module_get(dev->driver->module)) {
2615 rc = dev->open(dev);
2617 module_put(dev->driver->module);
2624 file->private_data = cfp;
2625 comedi_file_reset(file);
2629 mutex_unlock(&dev->mutex);
2631 comedi_dev_put(dev);
2637 static int comedi_fasync(int fd, struct file *file, int on)
2639 struct comedi_file *cfp = file->private_data;
2640 struct comedi_device *dev = cfp->dev;
2642 return fasync_helper(fd, file, on, &dev->async_queue);
2645 static int comedi_close(struct inode *inode, struct file *file)
2647 struct comedi_file *cfp = file->private_data;
2648 struct comedi_device *dev = cfp->dev;
2649 struct comedi_subdevice *s = NULL;
2652 mutex_lock(&dev->mutex);
2654 if (dev->subdevices) {
2655 for (i = 0; i < dev->n_subdevices; i++) {
2656 s = &dev->subdevices[i];
2658 if (s->busy == file)
2660 if (s->lock == file)
2664 if (dev->attached && dev->use_count == 1) {
2667 module_put(dev->driver->module);
2672 mutex_unlock(&dev->mutex);
2673 comedi_dev_put(dev);
2679 static const struct file_operations comedi_fops = {
2680 .owner = THIS_MODULE,
2681 .unlocked_ioctl = comedi_unlocked_ioctl,
2682 .compat_ioctl = comedi_compat_ioctl,
2683 .open = comedi_open,
2684 .release = comedi_close,
2685 .read = comedi_read,
2686 .write = comedi_write,
2687 .mmap = comedi_mmap,
2688 .poll = comedi_poll,
2689 .fasync = comedi_fasync,
2690 .llseek = noop_llseek,
2694 * comedi_event() - Handle events for asynchronous COMEDI command
2695 * @dev: COMEDI device.
2696 * @s: COMEDI subdevice.
2697 * Context: in_interrupt() (usually), @s->spin_lock spin-lock not held.
2699 * If an asynchronous COMEDI command is active on the subdevice, process
2700 * any %COMEDI_CB_... event flags that have been set, usually by an
2701 * interrupt handler. These may change the run state of the asynchronous
2702 * command, wake a task, and/or send a %SIGIO signal.
2704 void comedi_event(struct comedi_device *dev, struct comedi_subdevice *s)
2706 struct comedi_async *async = s->async;
2707 unsigned int events;
2709 unsigned long flags;
2711 spin_lock_irqsave(&s->spin_lock, flags);
2713 events = async->events;
2715 if (!__comedi_is_subdevice_running(s)) {
2716 spin_unlock_irqrestore(&s->spin_lock, flags);
2720 if (events & COMEDI_CB_CANCEL_MASK)
2721 __comedi_clear_subdevice_runflags(s, COMEDI_SRF_RUNNING);
2724 * Remember if an error event has occurred, so an error can be
2725 * returned the next time the user does a read() or write().
2727 if (events & COMEDI_CB_ERROR_MASK)
2728 __comedi_set_subdevice_runflags(s, COMEDI_SRF_ERROR);
2730 if (async->cb_mask & events) {
2731 wake_up_interruptible(&async->wait_head);
2732 si_code = async->cmd.flags & CMDF_WRITE ? POLL_OUT : POLL_IN;
2735 spin_unlock_irqrestore(&s->spin_lock, flags);
2738 kill_fasync(&dev->async_queue, SIGIO, si_code);
2740 EXPORT_SYMBOL_GPL(comedi_event);
2742 /* Note: the ->mutex is pre-locked on successful return */
2743 struct comedi_device *comedi_alloc_board_minor(struct device *hardware_device)
2745 struct comedi_device *dev;
2746 struct device *csdev;
2749 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
2751 return ERR_PTR(-ENOMEM);
2752 comedi_device_init(dev);
2753 comedi_set_hw_dev(dev, hardware_device);
2754 mutex_lock(&dev->mutex);
2755 mutex_lock(&comedi_board_minor_table_lock);
2756 for (i = hardware_device ? comedi_num_legacy_minors : 0;
2757 i < COMEDI_NUM_BOARD_MINORS; ++i) {
2758 if (!comedi_board_minor_table[i]) {
2759 comedi_board_minor_table[i] = dev;
2763 mutex_unlock(&comedi_board_minor_table_lock);
2764 if (i == COMEDI_NUM_BOARD_MINORS) {
2765 mutex_unlock(&dev->mutex);
2766 comedi_device_cleanup(dev);
2767 comedi_dev_put(dev);
2768 dev_err(hardware_device,
2769 "ran out of minor numbers for board device files\n");
2770 return ERR_PTR(-EBUSY);
2773 csdev = device_create(comedi_class, hardware_device,
2774 MKDEV(COMEDI_MAJOR, i), NULL, "comedi%i", i);
2776 dev->class_dev = get_device(csdev);
2778 /* Note: dev->mutex needs to be unlocked by the caller. */
2782 void comedi_release_hardware_device(struct device *hardware_device)
2785 struct comedi_device *dev;
2787 for (minor = comedi_num_legacy_minors; minor < COMEDI_NUM_BOARD_MINORS;
2789 mutex_lock(&comedi_board_minor_table_lock);
2790 dev = comedi_board_minor_table[minor];
2791 if (dev && dev->hw_dev == hardware_device) {
2792 comedi_board_minor_table[minor] = NULL;
2793 mutex_unlock(&comedi_board_minor_table_lock);
2794 comedi_free_board_dev(dev);
2797 mutex_unlock(&comedi_board_minor_table_lock);
2801 int comedi_alloc_subdevice_minor(struct comedi_subdevice *s)
2803 struct comedi_device *dev = s->device;
2804 struct device *csdev;
2807 mutex_lock(&comedi_subdevice_minor_table_lock);
2808 for (i = 0; i < COMEDI_NUM_SUBDEVICE_MINORS; ++i) {
2809 if (!comedi_subdevice_minor_table[i]) {
2810 comedi_subdevice_minor_table[i] = s;
2814 mutex_unlock(&comedi_subdevice_minor_table_lock);
2815 if (i == COMEDI_NUM_SUBDEVICE_MINORS) {
2816 dev_err(dev->class_dev,
2817 "ran out of minor numbers for subdevice files\n");
2820 i += COMEDI_NUM_BOARD_MINORS;
2822 csdev = device_create(comedi_class, dev->class_dev,
2823 MKDEV(COMEDI_MAJOR, i), NULL, "comedi%i_subd%i",
2824 dev->minor, s->index);
2826 s->class_dev = csdev;
2831 void comedi_free_subdevice_minor(struct comedi_subdevice *s)
2837 if (s->minor < COMEDI_NUM_BOARD_MINORS ||
2838 s->minor >= COMEDI_NUM_MINORS)
2841 i = s->minor - COMEDI_NUM_BOARD_MINORS;
2842 mutex_lock(&comedi_subdevice_minor_table_lock);
2843 if (s == comedi_subdevice_minor_table[i])
2844 comedi_subdevice_minor_table[i] = NULL;
2845 mutex_unlock(&comedi_subdevice_minor_table_lock);
2847 device_destroy(comedi_class, MKDEV(COMEDI_MAJOR, s->minor));
2848 s->class_dev = NULL;
2852 static void comedi_cleanup_board_minors(void)
2854 struct comedi_device *dev;
2857 for (i = 0; i < COMEDI_NUM_BOARD_MINORS; i++) {
2858 dev = comedi_clear_board_minor(i);
2859 comedi_free_board_dev(dev);
2863 static int __init comedi_init(void)
2868 pr_info("version " COMEDI_RELEASE " - http://www.comedi.org\n");
2870 if (comedi_num_legacy_minors < 0 ||
2871 comedi_num_legacy_minors > COMEDI_NUM_BOARD_MINORS) {
2872 pr_err("invalid value for module parameter \"comedi_num_legacy_minors\". Valid values are 0 through %i.\n",
2873 COMEDI_NUM_BOARD_MINORS);
2877 retval = register_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
2878 COMEDI_NUM_MINORS, "comedi");
2881 cdev_init(&comedi_cdev, &comedi_fops);
2882 comedi_cdev.owner = THIS_MODULE;
2884 retval = kobject_set_name(&comedi_cdev.kobj, "comedi");
2886 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
2891 if (cdev_add(&comedi_cdev, MKDEV(COMEDI_MAJOR, 0), COMEDI_NUM_MINORS)) {
2892 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
2896 comedi_class = class_create(THIS_MODULE, "comedi");
2897 if (IS_ERR(comedi_class)) {
2898 pr_err("failed to create class\n");
2899 cdev_del(&comedi_cdev);
2900 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
2902 return PTR_ERR(comedi_class);
2905 comedi_class->dev_groups = comedi_dev_groups;
2907 /* XXX requires /proc interface */
2910 /* create devices files for legacy/manual use */
2911 for (i = 0; i < comedi_num_legacy_minors; i++) {
2912 struct comedi_device *dev;
2914 dev = comedi_alloc_board_minor(NULL);
2916 comedi_cleanup_board_minors();
2917 cdev_del(&comedi_cdev);
2918 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
2920 return PTR_ERR(dev);
2922 /* comedi_alloc_board_minor() locked the mutex */
2923 mutex_unlock(&dev->mutex);
2928 module_init(comedi_init);
2930 static void __exit comedi_cleanup(void)
2932 comedi_cleanup_board_minors();
2933 class_destroy(comedi_class);
2934 cdev_del(&comedi_cdev);
2935 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0), COMEDI_NUM_MINORS);
2937 comedi_proc_cleanup();
2939 module_exit(comedi_cleanup);
2941 MODULE_AUTHOR("http://www.comedi.org");
2942 MODULE_DESCRIPTION("Comedi core module");
2943 MODULE_LICENSE("GPL");