]> git.ipfire.org Git - thirdparty/linux.git/blob - drivers/staging/comedi/comedi_fops.c
projects / thirdparty / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'riscv-for-linus-5.7-rc4' of git://git.kernel.org/pub/scm/linux/kernel...
[thirdparty/linux.git] / drivers / staging / comedi / comedi_fops.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * comedi/comedi_fops.c
4 * comedi kernel module
5 *
6 * COMEDI - Linux Control and Measurement Device Interface
7 * Copyright (C) 1997-2000 David A. Schleef <ds@schleef.org>
8 */
9
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12 #include "comedi_compat32.h"
13
14 #include <linux/module.h>
15 #include <linux/errno.h>
16 #include <linux/kernel.h>
17 #include <linux/sched/signal.h>
18 #include <linux/fcntl.h>
19 #include <linux/delay.h>
20 #include <linux/mm.h>
21 #include <linux/slab.h>
22 #include <linux/poll.h>
23 #include <linux/device.h>
24 #include <linux/fs.h>
25 #include "comedidev.h"
26 #include <linux/cdev.h>
27
28 #include <linux/io.h>
29 #include <linux/uaccess.h>
30
31 #include "comedi_internal.h"
32
33 /*
34 * comedi_subdevice "runflags"
35 * COMEDI_SRF_RT: DEPRECATED: command is running real-time
36 * COMEDI_SRF_ERROR: indicates an COMEDI_CB_ERROR event has occurred
37 * since the last command was started
38 * COMEDI_SRF_RUNNING: command is running
39 * COMEDI_SRF_FREE_SPRIV: free s->private on detach
40 *
41 * COMEDI_SRF_BUSY_MASK: runflags that indicate the subdevice is "busy"
42 */
43 #define COMEDI_SRF_RT BIT(1)
44 #define COMEDI_SRF_ERROR BIT(2)
45 #define COMEDI_SRF_RUNNING BIT(27)
46 #define COMEDI_SRF_FREE_SPRIV BIT(31)
47
48 #define COMEDI_SRF_BUSY_MASK (COMEDI_SRF_ERROR | COMEDI_SRF_RUNNING)
49
50 /**
51 * struct comedi_file - Per-file private data for COMEDI device
52 * @dev: COMEDI device.
53 * @read_subdev: Current "read" subdevice.
54 * @write_subdev: Current "write" subdevice.
55 * @last_detach_count: Last known detach count.
56 * @last_attached: Last known attached/detached state.
57 */
58 struct comedi_file {
59 struct comedi_device *dev;
60 struct comedi_subdevice *read_subdev;
61 struct comedi_subdevice *write_subdev;
62 unsigned int last_detach_count;
63 unsigned int last_attached:1;
64 };
65
66 #define COMEDI_NUM_MINORS 0x100
67 #define COMEDI_NUM_SUBDEVICE_MINORS \
68 (COMEDI_NUM_MINORS - COMEDI_NUM_BOARD_MINORS)
69
70 static unsigned short comedi_num_legacy_minors;
71 module_param(comedi_num_legacy_minors, ushort, 0444);
72 MODULE_PARM_DESC(comedi_num_legacy_minors,
73 "number of comedi minor devices to reserve for non-auto-configured devices (default 0)"
74 );
75
76 unsigned int comedi_default_buf_size_kb = CONFIG_COMEDI_DEFAULT_BUF_SIZE_KB;
77 module_param(comedi_default_buf_size_kb, uint, 0644);
78 MODULE_PARM_DESC(comedi_default_buf_size_kb,
79 "default asynchronous buffer size in KiB (default "
80 __MODULE_STRING(CONFIG_COMEDI_DEFAULT_BUF_SIZE_KB) ")");
81
82 unsigned int comedi_default_buf_maxsize_kb =
83 CONFIG_COMEDI_DEFAULT_BUF_MAXSIZE_KB;
84 module_param(comedi_default_buf_maxsize_kb, uint, 0644);
85 MODULE_PARM_DESC(comedi_default_buf_maxsize_kb,
86 "default maximum size of asynchronous buffer in KiB (default "
87 __MODULE_STRING(CONFIG_COMEDI_DEFAULT_BUF_MAXSIZE_KB) ")");
88
89 static DEFINE_MUTEX(comedi_board_minor_table_lock);
90 static struct comedi_device
91 *comedi_board_minor_table[COMEDI_NUM_BOARD_MINORS];
92
93 static DEFINE_MUTEX(comedi_subdevice_minor_table_lock);
94 /* Note: indexed by minor - COMEDI_NUM_BOARD_MINORS. */
95 static struct comedi_subdevice
96 *comedi_subdevice_minor_table[COMEDI_NUM_SUBDEVICE_MINORS];
97
98 static struct class *comedi_class;
99 static struct cdev comedi_cdev;
100
101 static void comedi_device_init(struct comedi_device *dev)
102 {
103 kref_init(&dev->refcount);
104 spin_lock_init(&dev->spinlock);
105 mutex_init(&dev->mutex);
106 init_rwsem(&dev->attach_lock);
107 dev->minor = -1;
108 }
109
110 static void comedi_dev_kref_release(struct kref *kref)
111 {
112 struct comedi_device *dev =
113 container_of(kref, struct comedi_device, refcount);
114
115 mutex_destroy(&dev->mutex);
116 put_device(dev->class_dev);
117 kfree(dev);
118 }
119
120 /**
121 * comedi_dev_put() - Release a use of a COMEDI device
122 * @dev: COMEDI device.
123 *
124 * Must be called when a user of a COMEDI device is finished with it.
125 * When the last user of the COMEDI device calls this function, the
126 * COMEDI device is destroyed.
127 *
128 * Return: 1 if the COMEDI device is destroyed by this call or @dev is
129 * NULL, otherwise return 0. Callers must not assume the COMEDI
130 * device is still valid if this function returns 0.
131 */
132 int comedi_dev_put(struct comedi_device *dev)
133 {
134 if (dev)
135 return kref_put(&dev->refcount, comedi_dev_kref_release);
136 return 1;
137 }
138 EXPORT_SYMBOL_GPL(comedi_dev_put);
139
140 static struct comedi_device *comedi_dev_get(struct comedi_device *dev)
141 {
142 if (dev)
143 kref_get(&dev->refcount);
144 return dev;
145 }
146
147 static void comedi_device_cleanup(struct comedi_device *dev)
148 {
149 struct module *driver_module = NULL;
150
151 if (!dev)
152 return;
153 mutex_lock(&dev->mutex);
154 if (dev->attached)
155 driver_module = dev->driver->module;
156 comedi_device_detach(dev);
157 if (driver_module && dev->use_count)
158 module_put(driver_module);
159 mutex_unlock(&dev->mutex);
160 }
161
162 static bool comedi_clear_board_dev(struct comedi_device *dev)
163 {
164 unsigned int i = dev->minor;
165 bool cleared = false;
166
167 lockdep_assert_held(&dev->mutex);
168 mutex_lock(&comedi_board_minor_table_lock);
169 if (dev == comedi_board_minor_table[i]) {
170 comedi_board_minor_table[i] = NULL;
171 cleared = true;
172 }
173 mutex_unlock(&comedi_board_minor_table_lock);
174 return cleared;
175 }
176
177 static struct comedi_device *comedi_clear_board_minor(unsigned int minor)
178 {
179 struct comedi_device *dev;
180
181 mutex_lock(&comedi_board_minor_table_lock);
182 dev = comedi_board_minor_table[minor];
183 comedi_board_minor_table[minor] = NULL;
184 mutex_unlock(&comedi_board_minor_table_lock);
185 return dev;
186 }
187
188 static void comedi_free_board_dev(struct comedi_device *dev)
189 {
190 if (dev) {
191 comedi_device_cleanup(dev);
192 if (dev->class_dev) {
193 device_destroy(comedi_class,
194 MKDEV(COMEDI_MAJOR, dev->minor));
195 }
196 comedi_dev_put(dev);
197 }
198 }
199
200 static struct comedi_subdevice *
201 comedi_subdevice_from_minor(const struct comedi_device *dev, unsigned int minor)
202 {
203 struct comedi_subdevice *s;
204 unsigned int i = minor - COMEDI_NUM_BOARD_MINORS;
205
206 mutex_lock(&comedi_subdevice_minor_table_lock);
207 s = comedi_subdevice_minor_table[i];
208 if (s && s->device != dev)
209 s = NULL;
210 mutex_unlock(&comedi_subdevice_minor_table_lock);
211 return s;
212 }
213
214 static struct comedi_device *comedi_dev_get_from_board_minor(unsigned int minor)
215 {
216 struct comedi_device *dev;
217
218 mutex_lock(&comedi_board_minor_table_lock);
219 dev = comedi_dev_get(comedi_board_minor_table[minor]);
220 mutex_unlock(&comedi_board_minor_table_lock);
221 return dev;
222 }
223
224 static struct comedi_device *
225 comedi_dev_get_from_subdevice_minor(unsigned int minor)
226 {
227 struct comedi_device *dev;
228 struct comedi_subdevice *s;
229 unsigned int i = minor - COMEDI_NUM_BOARD_MINORS;
230
231 mutex_lock(&comedi_subdevice_minor_table_lock);
232 s = comedi_subdevice_minor_table[i];
233 dev = comedi_dev_get(s ? s->device : NULL);
234 mutex_unlock(&comedi_subdevice_minor_table_lock);
235 return dev;
236 }
237
238 /**
239 * comedi_dev_get_from_minor() - Get COMEDI device by minor device number
240 * @minor: Minor device number.
241 *
242 * Finds the COMEDI device associated with the minor device number, if any,
243 * and increments its reference count. The COMEDI device is prevented from
244 * being freed until a matching call is made to comedi_dev_put().
245 *
246 * Return: A pointer to the COMEDI device if it exists, with its usage
247 * reference incremented. Return NULL if no COMEDI device exists with the
248 * specified minor device number.
249 */
250 struct comedi_device *comedi_dev_get_from_minor(unsigned int minor)
251 {
252 if (minor < COMEDI_NUM_BOARD_MINORS)
253 return comedi_dev_get_from_board_minor(minor);
254
255 return comedi_dev_get_from_subdevice_minor(minor);
256 }
257 EXPORT_SYMBOL_GPL(comedi_dev_get_from_minor);
258
259 static struct comedi_subdevice *
260 comedi_read_subdevice(const struct comedi_device *dev, unsigned int minor)
261 {
262 struct comedi_subdevice *s;
263
264 lockdep_assert_held(&dev->mutex);
265 if (minor >= COMEDI_NUM_BOARD_MINORS) {
266 s = comedi_subdevice_from_minor(dev, minor);
267 if (!s || (s->subdev_flags & SDF_CMD_READ))
268 return s;
269 }
270 return dev->read_subdev;
271 }
272
273 static struct comedi_subdevice *
274 comedi_write_subdevice(const struct comedi_device *dev, unsigned int minor)
275 {
276 struct comedi_subdevice *s;
277
278 lockdep_assert_held(&dev->mutex);
279 if (minor >= COMEDI_NUM_BOARD_MINORS) {
280 s = comedi_subdevice_from_minor(dev, minor);
281 if (!s || (s->subdev_flags & SDF_CMD_WRITE))
282 return s;
283 }
284 return dev->write_subdev;
285 }
286
287 static void comedi_file_reset(struct file *file)
288 {
289 struct comedi_file *cfp = file->private_data;
290 struct comedi_device *dev = cfp->dev;
291 struct comedi_subdevice *s, *read_s, *write_s;
292 unsigned int minor = iminor(file_inode(file));
293
294 read_s = dev->read_subdev;
295 write_s = dev->write_subdev;
296 if (minor >= COMEDI_NUM_BOARD_MINORS) {
297 s = comedi_subdevice_from_minor(dev, minor);
298 if (!s || s->subdev_flags & SDF_CMD_READ)
299 read_s = s;
300 if (!s || s->subdev_flags & SDF_CMD_WRITE)
301 write_s = s;
302 }
303 cfp->last_attached = dev->attached;
304 cfp->last_detach_count = dev->detach_count;
305 WRITE_ONCE(cfp->read_subdev, read_s);
306 WRITE_ONCE(cfp->write_subdev, write_s);
307 }
308
309 static void comedi_file_check(struct file *file)
310 {
311 struct comedi_file *cfp = file->private_data;
312 struct comedi_device *dev = cfp->dev;
313
314 if (cfp->last_attached != dev->attached ||
315 cfp->last_detach_count != dev->detach_count)
316 comedi_file_reset(file);
317 }
318
319 static struct comedi_subdevice *comedi_file_read_subdevice(struct file *file)
320 {
321 struct comedi_file *cfp = file->private_data;
322
323 comedi_file_check(file);
324 return READ_ONCE(cfp->read_subdev);
325 }
326
327 static struct comedi_subdevice *comedi_file_write_subdevice(struct file *file)
328 {
329 struct comedi_file *cfp = file->private_data;
330
331 comedi_file_check(file);
332 return READ_ONCE(cfp->write_subdev);
333 }
334
335 static int resize_async_buffer(struct comedi_device *dev,
336 struct comedi_subdevice *s,
337 unsigned int new_size)
338 {
339 struct comedi_async *async = s->async;
340 int retval;
341
342 lockdep_assert_held(&dev->mutex);
343
344 if (new_size > async->max_bufsize)
345 return -EPERM;
346
347 if (s->busy) {
348 dev_dbg(dev->class_dev,
349 "subdevice is busy, cannot resize buffer\n");
350 return -EBUSY;
351 }
352 if (comedi_buf_is_mmapped(s)) {
353 dev_dbg(dev->class_dev,
354 "subdevice is mmapped, cannot resize buffer\n");
355 return -EBUSY;
356 }
357
358 /* make sure buffer is an integral number of pages (we round up) */
359 new_size = (new_size + PAGE_SIZE - 1) & PAGE_MASK;
360
361 retval = comedi_buf_alloc(dev, s, new_size);
362 if (retval < 0)
363 return retval;
364
365 if (s->buf_change) {
366 retval = s->buf_change(dev, s);
367 if (retval < 0)
368 return retval;
369 }
370
371 dev_dbg(dev->class_dev, "subd %d buffer resized to %i bytes\n",
372 s->index, async->prealloc_bufsz);
373 return 0;
374 }
375
376 /* sysfs attribute files */
377
378 static ssize_t max_read_buffer_kb_show(struct device *csdev,
379 struct device_attribute *attr, char *buf)
380 {
381 unsigned int minor = MINOR(csdev->devt);
382 struct comedi_device *dev;
383 struct comedi_subdevice *s;
384 unsigned int size = 0;
385
386 dev = comedi_dev_get_from_minor(minor);
387 if (!dev)
388 return -ENODEV;
389
390 mutex_lock(&dev->mutex);
391 s = comedi_read_subdevice(dev, minor);
392 if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
393 size = s->async->max_bufsize / 1024;
394 mutex_unlock(&dev->mutex);
395
396 comedi_dev_put(dev);
397 return snprintf(buf, PAGE_SIZE, "%u\n", size);
398 }
399
400 static ssize_t max_read_buffer_kb_store(struct device *csdev,
401 struct device_attribute *attr,
402 const char *buf, size_t count)
403 {
404 unsigned int minor = MINOR(csdev->devt);
405 struct comedi_device *dev;
406 struct comedi_subdevice *s;
407 unsigned int size;
408 int err;
409
410 err = kstrtouint(buf, 10, &size);
411 if (err)
412 return err;
413 if (size > (UINT_MAX / 1024))
414 return -EINVAL;
415 size *= 1024;
416
417 dev = comedi_dev_get_from_minor(minor);
418 if (!dev)
419 return -ENODEV;
420
421 mutex_lock(&dev->mutex);
422 s = comedi_read_subdevice(dev, minor);
423 if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
424 s->async->max_bufsize = size;
425 else
426 err = -EINVAL;
427 mutex_unlock(&dev->mutex);
428
429 comedi_dev_put(dev);
430 return err ? err : count;
431 }
432 static DEVICE_ATTR_RW(max_read_buffer_kb);
433
434 static ssize_t read_buffer_kb_show(struct device *csdev,
435 struct device_attribute *attr, char *buf)
436 {
437 unsigned int minor = MINOR(csdev->devt);
438 struct comedi_device *dev;
439 struct comedi_subdevice *s;
440 unsigned int size = 0;
441
442 dev = comedi_dev_get_from_minor(minor);
443 if (!dev)
444 return -ENODEV;
445
446 mutex_lock(&dev->mutex);
447 s = comedi_read_subdevice(dev, minor);
448 if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
449 size = s->async->prealloc_bufsz / 1024;
450 mutex_unlock(&dev->mutex);
451
452 comedi_dev_put(dev);
453 return snprintf(buf, PAGE_SIZE, "%u\n", size);
454 }
455
456 static ssize_t read_buffer_kb_store(struct device *csdev,
457 struct device_attribute *attr,
458 const char *buf, size_t count)
459 {
460 unsigned int minor = MINOR(csdev->devt);
461 struct comedi_device *dev;
462 struct comedi_subdevice *s;
463 unsigned int size;
464 int err;
465
466 err = kstrtouint(buf, 10, &size);
467 if (err)
468 return err;
469 if (size > (UINT_MAX / 1024))
470 return -EINVAL;
471 size *= 1024;
472
473 dev = comedi_dev_get_from_minor(minor);
474 if (!dev)
475 return -ENODEV;
476
477 mutex_lock(&dev->mutex);
478 s = comedi_read_subdevice(dev, minor);
479 if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
480 err = resize_async_buffer(dev, s, size);
481 else
482 err = -EINVAL;
483 mutex_unlock(&dev->mutex);
484
485 comedi_dev_put(dev);
486 return err ? err : count;
487 }
488 static DEVICE_ATTR_RW(read_buffer_kb);
489
490 static ssize_t max_write_buffer_kb_show(struct device *csdev,
491 struct device_attribute *attr,
492 char *buf)
493 {
494 unsigned int minor = MINOR(csdev->devt);
495 struct comedi_device *dev;
496 struct comedi_subdevice *s;
497 unsigned int size = 0;
498
499 dev = comedi_dev_get_from_minor(minor);
500 if (!dev)
501 return -ENODEV;
502
503 mutex_lock(&dev->mutex);
504 s = comedi_write_subdevice(dev, minor);
505 if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
506 size = s->async->max_bufsize / 1024;
507 mutex_unlock(&dev->mutex);
508
509 comedi_dev_put(dev);
510 return snprintf(buf, PAGE_SIZE, "%u\n", size);
511 }
512
513 static ssize_t max_write_buffer_kb_store(struct device *csdev,
514 struct device_attribute *attr,
515 const char *buf, size_t count)
516 {
517 unsigned int minor = MINOR(csdev->devt);
518 struct comedi_device *dev;
519 struct comedi_subdevice *s;
520 unsigned int size;
521 int err;
522
523 err = kstrtouint(buf, 10, &size);
524 if (err)
525 return err;
526 if (size > (UINT_MAX / 1024))
527 return -EINVAL;
528 size *= 1024;
529
530 dev = comedi_dev_get_from_minor(minor);
531 if (!dev)
532 return -ENODEV;
533
534 mutex_lock(&dev->mutex);
535 s = comedi_write_subdevice(dev, minor);
536 if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
537 s->async->max_bufsize = size;
538 else
539 err = -EINVAL;
540 mutex_unlock(&dev->mutex);
541
542 comedi_dev_put(dev);
543 return err ? err : count;
544 }
545 static DEVICE_ATTR_RW(max_write_buffer_kb);
546
547 static ssize_t write_buffer_kb_show(struct device *csdev,
548 struct device_attribute *attr, char *buf)
549 {
550 unsigned int minor = MINOR(csdev->devt);
551 struct comedi_device *dev;
552 struct comedi_subdevice *s;
553 unsigned int size = 0;
554
555 dev = comedi_dev_get_from_minor(minor);
556 if (!dev)
557 return -ENODEV;
558
559 mutex_lock(&dev->mutex);
560 s = comedi_write_subdevice(dev, minor);
561 if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
562 size = s->async->prealloc_bufsz / 1024;
563 mutex_unlock(&dev->mutex);
564
565 comedi_dev_put(dev);
566 return snprintf(buf, PAGE_SIZE, "%u\n", size);
567 }
568
569 static ssize_t write_buffer_kb_store(struct device *csdev,
570 struct device_attribute *attr,
571 const char *buf, size_t count)
572 {
573 unsigned int minor = MINOR(csdev->devt);
574 struct comedi_device *dev;
575 struct comedi_subdevice *s;
576 unsigned int size;
577 int err;
578
579 err = kstrtouint(buf, 10, &size);
580 if (err)
581 return err;
582 if (size > (UINT_MAX / 1024))
583 return -EINVAL;
584 size *= 1024;
585
586 dev = comedi_dev_get_from_minor(minor);
587 if (!dev)
588 return -ENODEV;
589
590 mutex_lock(&dev->mutex);
591 s = comedi_write_subdevice(dev, minor);
592 if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
593 err = resize_async_buffer(dev, s, size);
594 else
595 err = -EINVAL;
596 mutex_unlock(&dev->mutex);
597
598 comedi_dev_put(dev);
599 return err ? err : count;
600 }
601 static DEVICE_ATTR_RW(write_buffer_kb);
602
603 static struct attribute *comedi_dev_attrs[] = {
604 &dev_attr_max_read_buffer_kb.attr,
605 &dev_attr_read_buffer_kb.attr,
606 &dev_attr_max_write_buffer_kb.attr,
607 &dev_attr_write_buffer_kb.attr,
608 NULL,
609 };
610 ATTRIBUTE_GROUPS(comedi_dev);
611
612 static void __comedi_clear_subdevice_runflags(struct comedi_subdevice *s,
613 unsigned int bits)
614 {
615 s->runflags &= ~bits;
616 }
617
618 static void __comedi_set_subdevice_runflags(struct comedi_subdevice *s,
619 unsigned int bits)
620 {
621 s->runflags |= bits;
622 }
623
624 static void comedi_update_subdevice_runflags(struct comedi_subdevice *s,
625 unsigned int mask,
626 unsigned int bits)
627 {
628 unsigned long flags;
629
630 spin_lock_irqsave(&s->spin_lock, flags);
631 __comedi_clear_subdevice_runflags(s, mask);
632 __comedi_set_subdevice_runflags(s, bits & mask);
633 spin_unlock_irqrestore(&s->spin_lock, flags);
634 }
635
636 static unsigned int __comedi_get_subdevice_runflags(struct comedi_subdevice *s)
637 {
638 return s->runflags;
639 }
640
641 static unsigned int comedi_get_subdevice_runflags(struct comedi_subdevice *s)
642 {
643 unsigned long flags;
644 unsigned int runflags;
645
646 spin_lock_irqsave(&s->spin_lock, flags);
647 runflags = __comedi_get_subdevice_runflags(s);
648 spin_unlock_irqrestore(&s->spin_lock, flags);
649 return runflags;
650 }
651
652 static bool comedi_is_runflags_running(unsigned int runflags)
653 {
654 return runflags & COMEDI_SRF_RUNNING;
655 }
656
657 static bool comedi_is_runflags_in_error(unsigned int runflags)
658 {
659 return runflags & COMEDI_SRF_ERROR;
660 }
661
662 /**
663 * comedi_is_subdevice_running() - Check if async command running on subdevice
664 * @s: COMEDI subdevice.
665 *
666 * Return: %true if an asynchronous COMEDI command is active on the
667 * subdevice, else %false.
668 */
669 bool comedi_is_subdevice_running(struct comedi_subdevice *s)
670 {
671 unsigned int runflags = comedi_get_subdevice_runflags(s);
672
673 return comedi_is_runflags_running(runflags);
674 }
675 EXPORT_SYMBOL_GPL(comedi_is_subdevice_running);
676
677 static bool __comedi_is_subdevice_running(struct comedi_subdevice *s)
678 {
679 unsigned int runflags = __comedi_get_subdevice_runflags(s);
680
681 return comedi_is_runflags_running(runflags);
682 }
683
684 bool comedi_can_auto_free_spriv(struct comedi_subdevice *s)
685 {
686 unsigned int runflags = __comedi_get_subdevice_runflags(s);
687
688 return runflags & COMEDI_SRF_FREE_SPRIV;
689 }
690
691 /**
692 * comedi_set_spriv_auto_free() - Mark subdevice private data as freeable
693 * @s: COMEDI subdevice.
694 *
695 * Mark the subdevice as having a pointer to private data that can be
696 * automatically freed when the COMEDI device is detached from the low-level
697 * driver.
698 */
699 void comedi_set_spriv_auto_free(struct comedi_subdevice *s)
700 {
701 __comedi_set_subdevice_runflags(s, COMEDI_SRF_FREE_SPRIV);
702 }
703 EXPORT_SYMBOL_GPL(comedi_set_spriv_auto_free);
704
705 /**
706 * comedi_alloc_spriv - Allocate memory for the subdevice private data
707 * @s: COMEDI subdevice.
708 * @size: Size of the memory to allocate.
709 *
710 * Allocate memory for the subdevice private data and point @s->private
711 * to it. The memory will be freed automatically when the COMEDI device
712 * is detached from the low-level driver.
713 *
714 * Return: A pointer to the allocated memory @s->private on success.
715 * Return NULL on failure.
716 */
717 void *comedi_alloc_spriv(struct comedi_subdevice *s, size_t size)
718 {
719 s->private = kzalloc(size, GFP_KERNEL);
720 if (s->private)
721 comedi_set_spriv_auto_free(s);
722 return s->private;
723 }
724 EXPORT_SYMBOL_GPL(comedi_alloc_spriv);
725
726 /*
727 * This function restores a subdevice to an idle state.
728 */
729 static void do_become_nonbusy(struct comedi_device *dev,
730 struct comedi_subdevice *s)
731 {
732 struct comedi_async *async = s->async;
733
734 lockdep_assert_held(&dev->mutex);
735 comedi_update_subdevice_runflags(s, COMEDI_SRF_RUNNING, 0);
736 if (async) {
737 comedi_buf_reset(s);
738 async->inttrig = NULL;
739 kfree(async->cmd.chanlist);
740 async->cmd.chanlist = NULL;
741 s->busy = NULL;
742 wake_up_interruptible_all(&async->wait_head);
743 } else {
744 dev_err(dev->class_dev,
745 "BUG: (?) %s called with async=NULL\n", __func__);
746 s->busy = NULL;
747 }
748 }
749
750 static int do_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
751 {
752 int ret = 0;
753
754 lockdep_assert_held(&dev->mutex);
755 if (comedi_is_subdevice_running(s) && s->cancel)
756 ret = s->cancel(dev, s);
757
758 do_become_nonbusy(dev, s);
759
760 return ret;
761 }
762
763 void comedi_device_cancel_all(struct comedi_device *dev)
764 {
765 struct comedi_subdevice *s;
766 int i;
767
768 lockdep_assert_held(&dev->mutex);
769 if (!dev->attached)
770 return;
771
772 for (i = 0; i < dev->n_subdevices; i++) {
773 s = &dev->subdevices[i];
774 if (s->async)
775 do_cancel(dev, s);
776 }
777 }
778
779 static int is_device_busy(struct comedi_device *dev)
780 {
781 struct comedi_subdevice *s;
782 int i;
783
784 lockdep_assert_held(&dev->mutex);
785 if (!dev->attached)
786 return 0;
787
788 for (i = 0; i < dev->n_subdevices; i++) {
789 s = &dev->subdevices[i];
790 if (s->busy)
791 return 1;
792 if (s->async && comedi_buf_is_mmapped(s))
793 return 1;
794 }
795
796 return 0;
797 }
798
799 /*
800 * COMEDI_DEVCONFIG ioctl
801 * attaches (and configures) or detaches a legacy device
802 *
803 * arg:
804 * pointer to comedi_devconfig structure (NULL if detaching)
805 *
806 * reads:
807 * comedi_devconfig structure (if attaching)
808 *
809 * writes:
810 * nothing
811 */
812 static int do_devconfig_ioctl(struct comedi_device *dev,
813 struct comedi_devconfig __user *arg)
814 {
815 struct comedi_devconfig it;
816
817 lockdep_assert_held(&dev->mutex);
818 if (!capable(CAP_SYS_ADMIN))
819 return -EPERM;
820
821 if (!arg) {
822 if (is_device_busy(dev))
823 return -EBUSY;
824 if (dev->attached) {
825 struct module *driver_module = dev->driver->module;
826
827 comedi_device_detach(dev);
828 module_put(driver_module);
829 }
830 return 0;
831 }
832
833 if (copy_from_user(&it, arg, sizeof(it)))
834 return -EFAULT;
835
836 it.board_name[COMEDI_NAMELEN - 1] = 0;
837
838 if (it.options[COMEDI_DEVCONF_AUX_DATA_LENGTH]) {
839 dev_warn(dev->class_dev,
840 "comedi_config --init_data is deprecated\n");
841 return -EINVAL;
842 }
843
844 if (dev->minor >= comedi_num_legacy_minors)
845 /* don't re-use dynamically allocated comedi devices */
846 return -EBUSY;
847
848 /* This increments the driver module count on success. */
849 return comedi_device_attach(dev, &it);
850 }
851
852 /*
853 * COMEDI_BUFCONFIG ioctl
854 * buffer configuration
855 *
856 * arg:
857 * pointer to comedi_bufconfig structure
858 *
859 * reads:
860 * comedi_bufconfig structure
861 *
862 * writes:
863 * modified comedi_bufconfig structure
864 */
865 static int do_bufconfig_ioctl(struct comedi_device *dev,
866 struct comedi_bufconfig __user *arg)
867 {
868 struct comedi_bufconfig bc;
869 struct comedi_async *async;
870 struct comedi_subdevice *s;
871 int retval = 0;
872
873 lockdep_assert_held(&dev->mutex);
874 if (copy_from_user(&bc, arg, sizeof(bc)))
875 return -EFAULT;
876
877 if (bc.subdevice >= dev->n_subdevices)
878 return -EINVAL;
879
880 s = &dev->subdevices[bc.subdevice];
881 async = s->async;
882
883 if (!async) {
884 dev_dbg(dev->class_dev,
885 "subdevice does not have async capability\n");
886 bc.size = 0;
887 bc.maximum_size = 0;
888 goto copyback;
889 }
890
891 if (bc.maximum_size) {
892 if (!capable(CAP_SYS_ADMIN))
893 return -EPERM;
894
895 async->max_bufsize = bc.maximum_size;
896 }
897
898 if (bc.size) {
899 retval = resize_async_buffer(dev, s, bc.size);
900 if (retval < 0)
901 return retval;
902 }
903
904 bc.size = async->prealloc_bufsz;
905 bc.maximum_size = async->max_bufsize;
906
907 copyback:
908 if (copy_to_user(arg, &bc, sizeof(bc)))
909 return -EFAULT;
910
911 return 0;
912 }
913
914 /*
915 * COMEDI_DEVINFO ioctl
916 * device info
917 *
918 * arg:
919 * pointer to comedi_devinfo structure
920 *
921 * reads:
922 * nothing
923 *
924 * writes:
925 * comedi_devinfo structure
926 */
927 static int do_devinfo_ioctl(struct comedi_device *dev,
928 struct comedi_devinfo __user *arg,
929 struct file *file)
930 {
931 struct comedi_subdevice *s;
932 struct comedi_devinfo devinfo;
933
934 lockdep_assert_held(&dev->mutex);
935 memset(&devinfo, 0, sizeof(devinfo));
936
937 /* fill devinfo structure */
938 devinfo.version_code = COMEDI_VERSION_CODE;
939 devinfo.n_subdevs = dev->n_subdevices;
940 strlcpy(devinfo.driver_name, dev->driver->driver_name, COMEDI_NAMELEN);
941 strlcpy(devinfo.board_name, dev->board_name, COMEDI_NAMELEN);
942
943 s = comedi_file_read_subdevice(file);
944 if (s)
945 devinfo.read_subdevice = s->index;
946 else
947 devinfo.read_subdevice = -1;
948
949 s = comedi_file_write_subdevice(file);
950 if (s)
951 devinfo.write_subdevice = s->index;
952 else
953 devinfo.write_subdevice = -1;
954
955 if (copy_to_user(arg, &devinfo, sizeof(devinfo)))
956 return -EFAULT;
957
958 return 0;
959 }
960
961 /*
962 * COMEDI_SUBDINFO ioctl
963 * subdevices info
964 *
965 * arg:
966 * pointer to array of comedi_subdinfo structures
967 *
968 * reads:
969 * nothing
970 *
971 * writes:
972 * array of comedi_subdinfo structures
973 */
974 static int do_subdinfo_ioctl(struct comedi_device *dev,
975 struct comedi_subdinfo __user *arg, void *file)
976 {
977 int ret, i;
978 struct comedi_subdinfo *tmp, *us;
979 struct comedi_subdevice *s;
980
981 lockdep_assert_held(&dev->mutex);
982 tmp = kcalloc(dev->n_subdevices, sizeof(*tmp), GFP_KERNEL);
983 if (!tmp)
984 return -ENOMEM;
985
986 /* fill subdinfo structs */
987 for (i = 0; i < dev->n_subdevices; i++) {
988 s = &dev->subdevices[i];
989 us = tmp + i;
990
991 us->type = s->type;
992 us->n_chan = s->n_chan;
993 us->subd_flags = s->subdev_flags;
994 if (comedi_is_subdevice_running(s))
995 us->subd_flags |= SDF_RUNNING;
996 #define TIMER_nanosec 5 /* backwards compatibility */
997 us->timer_type = TIMER_nanosec;
998 us->len_chanlist = s->len_chanlist;
999 us->maxdata = s->maxdata;
1000 if (s->range_table) {
1001 us->range_type =
1002 (i << 24) | (0 << 16) | (s->range_table->length);
1003 } else {
1004 us->range_type = 0; /* XXX */
1005 }
1006
1007 if (s->busy)
1008 us->subd_flags |= SDF_BUSY;
1009 if (s->busy == file)
1010 us->subd_flags |= SDF_BUSY_OWNER;
1011 if (s->lock)
1012 us->subd_flags |= SDF_LOCKED;
1013 if (s->lock == file)
1014 us->subd_flags |= SDF_LOCK_OWNER;
1015 if (!s->maxdata && s->maxdata_list)
1016 us->subd_flags |= SDF_MAXDATA;
1017 if (s->range_table_list)
1018 us->subd_flags |= SDF_RANGETYPE;
1019 if (s->do_cmd)
1020 us->subd_flags |= SDF_CMD;
1021
1022 if (s->insn_bits != &insn_inval)
1023 us->insn_bits_support = COMEDI_SUPPORTED;
1024 else
1025 us->insn_bits_support = COMEDI_UNSUPPORTED;
1026 }
1027
1028 ret = copy_to_user(arg, tmp, dev->n_subdevices * sizeof(*tmp));
1029
1030 kfree(tmp);
1031
1032 return ret ? -EFAULT : 0;
1033 }
1034
1035 /*
1036 * COMEDI_CHANINFO ioctl
1037 * subdevice channel info
1038 *
1039 * arg:
1040 * pointer to comedi_chaninfo structure
1041 *
1042 * reads:
1043 * comedi_chaninfo structure
1044 *
1045 * writes:
1046 * array of maxdata values to chaninfo->maxdata_list if requested
1047 * array of range table lengths to chaninfo->range_table_list if requested
1048 */
1049 static int do_chaninfo_ioctl(struct comedi_device *dev,
1050 struct comedi_chaninfo __user *arg)
1051 {
1052 struct comedi_subdevice *s;
1053 struct comedi_chaninfo it;
1054
1055 lockdep_assert_held(&dev->mutex);
1056 if (copy_from_user(&it, arg, sizeof(it)))
1057 return -EFAULT;
1058
1059 if (it.subdev >= dev->n_subdevices)
1060 return -EINVAL;
1061 s = &dev->subdevices[it.subdev];
1062
1063 if (it.maxdata_list) {
1064 if (s->maxdata || !s->maxdata_list)
1065 return -EINVAL;
1066 if (copy_to_user(it.maxdata_list, s->maxdata_list,
1067 s->n_chan * sizeof(unsigned int)))
1068 return -EFAULT;
1069 }
1070
1071 if (it.flaglist)
1072 return -EINVAL; /* flaglist not supported */
1073
1074 if (it.rangelist) {
1075 int i;
1076
1077 if (!s->range_table_list)
1078 return -EINVAL;
1079 for (i = 0; i < s->n_chan; i++) {
1080 int x;
1081
1082 x = (dev->minor << 28) | (it.subdev << 24) | (i << 16) |
1083 (s->range_table_list[i]->length);
1084 if (put_user(x, it.rangelist + i))
1085 return -EFAULT;
1086 }
1087 }
1088
1089 return 0;
1090 }
1091
1092 /*
1093 * COMEDI_BUFINFO ioctl
1094 * buffer information
1095 *
1096 * arg:
1097 * pointer to comedi_bufinfo structure
1098 *
1099 * reads:
1100 * comedi_bufinfo structure
1101 *
1102 * writes:
1103 * modified comedi_bufinfo structure
1104 */
1105 static int do_bufinfo_ioctl(struct comedi_device *dev,
1106 struct comedi_bufinfo __user *arg, void *file)
1107 {
1108 struct comedi_bufinfo bi;
1109 struct comedi_subdevice *s;
1110 struct comedi_async *async;
1111 unsigned int runflags;
1112 int retval = 0;
1113 bool become_nonbusy = false;
1114
1115 lockdep_assert_held(&dev->mutex);
1116 if (copy_from_user(&bi, arg, sizeof(bi)))
1117 return -EFAULT;
1118
1119 if (bi.subdevice >= dev->n_subdevices)
1120 return -EINVAL;
1121
1122 s = &dev->subdevices[bi.subdevice];
1123
1124 async = s->async;
1125
1126 if (!async || s->busy != file)
1127 return -EINVAL;
1128
1129 runflags = comedi_get_subdevice_runflags(s);
1130 if (!(async->cmd.flags & CMDF_WRITE)) {
1131 /* command was set up in "read" direction */
1132 if (bi.bytes_read) {
1133 comedi_buf_read_alloc(s, bi.bytes_read);
1134 bi.bytes_read = comedi_buf_read_free(s, bi.bytes_read);
1135 }
1136 /*
1137 * If nothing left to read, and command has stopped, and
1138 * {"read" position not updated or command stopped normally},
1139 * then become non-busy.
1140 */
1141 if (comedi_buf_read_n_available(s) == 0 &&
1142 !comedi_is_runflags_running(runflags) &&
1143 (bi.bytes_read == 0 ||
1144 !comedi_is_runflags_in_error(runflags))) {
1145 become_nonbusy = true;
1146 if (comedi_is_runflags_in_error(runflags))
1147 retval = -EPIPE;
1148 }
1149 bi.bytes_written = 0;
1150 } else {
1151 /* command was set up in "write" direction */
1152 if (!comedi_is_runflags_running(runflags)) {
1153 bi.bytes_written = 0;
1154 become_nonbusy = true;
1155 if (comedi_is_runflags_in_error(runflags))
1156 retval = -EPIPE;
1157 } else if (bi.bytes_written) {
1158 comedi_buf_write_alloc(s, bi.bytes_written);
1159 bi.bytes_written =
1160 comedi_buf_write_free(s, bi.bytes_written);
1161 }
1162 bi.bytes_read = 0;
1163 }
1164
1165 bi.buf_write_count = async->buf_write_count;
1166 bi.buf_write_ptr = async->buf_write_ptr;
1167 bi.buf_read_count = async->buf_read_count;
1168 bi.buf_read_ptr = async->buf_read_ptr;
1169
1170 if (become_nonbusy)
1171 do_become_nonbusy(dev, s);
1172
1173 if (retval)
1174 return retval;
1175
1176 if (copy_to_user(arg, &bi, sizeof(bi)))
1177 return -EFAULT;
1178
1179 return 0;
1180 }
1181
1182 static int check_insn_config_length(struct comedi_insn *insn,
1183 unsigned int *data)
1184 {
1185 if (insn->n < 1)
1186 return -EINVAL;
1187
1188 switch (data[0]) {
1189 case INSN_CONFIG_DIO_OUTPUT:
1190 case INSN_CONFIG_DIO_INPUT:
1191 case INSN_CONFIG_DISARM:
1192 case INSN_CONFIG_RESET:
1193 if (insn->n == 1)
1194 return 0;
1195 break;
1196 case INSN_CONFIG_ARM:
1197 case INSN_CONFIG_DIO_QUERY:
1198 case INSN_CONFIG_BLOCK_SIZE:
1199 case INSN_CONFIG_FILTER:
1200 case INSN_CONFIG_SERIAL_CLOCK:
1201 case INSN_CONFIG_BIDIRECTIONAL_DATA:
1202 case INSN_CONFIG_ALT_SOURCE:
1203 case INSN_CONFIG_SET_COUNTER_MODE:
1204 case INSN_CONFIG_8254_READ_STATUS:
1205 case INSN_CONFIG_SET_ROUTING:
1206 case INSN_CONFIG_GET_ROUTING:
1207 case INSN_CONFIG_GET_PWM_STATUS:
1208 case INSN_CONFIG_PWM_SET_PERIOD:
1209 case INSN_CONFIG_PWM_GET_PERIOD:
1210 if (insn->n == 2)
1211 return 0;
1212 break;
1213 case INSN_CONFIG_SET_GATE_SRC:
1214 case INSN_CONFIG_GET_GATE_SRC:
1215 case INSN_CONFIG_SET_CLOCK_SRC:
1216 case INSN_CONFIG_GET_CLOCK_SRC:
1217 case INSN_CONFIG_SET_OTHER_SRC:
1218 case INSN_CONFIG_GET_COUNTER_STATUS:
1219 case INSN_CONFIG_PWM_SET_H_BRIDGE:
1220 case INSN_CONFIG_PWM_GET_H_BRIDGE:
1221 case INSN_CONFIG_GET_HARDWARE_BUFFER_SIZE:
1222 if (insn->n == 3)
1223 return 0;
1224 break;
1225 case INSN_CONFIG_PWM_OUTPUT:
1226 case INSN_CONFIG_ANALOG_TRIG:
1227 case INSN_CONFIG_TIMER_1:
1228 if (insn->n == 5)
1229 return 0;
1230 break;
1231 case INSN_CONFIG_DIGITAL_TRIG:
1232 if (insn->n == 6)
1233 return 0;
1234 break;
1235 case INSN_CONFIG_GET_CMD_TIMING_CONSTRAINTS:
1236 if (insn->n >= 4)
1237 return 0;
1238 break;
1239 /*
1240 * by default we allow the insn since we don't have checks for
1241 * all possible cases yet
1242 */
1243 default:
1244 pr_warn("No check for data length of config insn id %i is implemented\n",
1245 data[0]);
1246 pr_warn("Add a check to %s in %s\n", __func__, __FILE__);
1247 pr_warn("Assuming n=%i is correct\n", insn->n);
1248 return 0;
1249 }
1250 return -EINVAL;
1251 }
1252
1253 static int check_insn_device_config_length(struct comedi_insn *insn,
1254 unsigned int *data)
1255 {
1256 if (insn->n < 1)
1257 return -EINVAL;
1258
1259 switch (data[0]) {
1260 case INSN_DEVICE_CONFIG_TEST_ROUTE:
1261 case INSN_DEVICE_CONFIG_CONNECT_ROUTE:
1262 case INSN_DEVICE_CONFIG_DISCONNECT_ROUTE:
1263 if (insn->n == 3)
1264 return 0;
1265 break;
1266 case INSN_DEVICE_CONFIG_GET_ROUTES:
1267 /*
1268 * Big enough for config_id and the length of the userland
1269 * memory buffer. Additional length should be in factors of 2
1270 * to communicate any returned route pairs (source,destination).
1271 */
1272 if (insn->n >= 2)
1273 return 0;
1274 break;
1275 }
1276 return -EINVAL;
1277 }
1278
1279 /**
1280 * get_valid_routes() - Calls low-level driver get_valid_routes function to
1281 * either return a count of valid routes to user, or copy
1282 * of list of all valid device routes to buffer in
1283 * userspace.
1284 * @dev: comedi device pointer
1285 * @data: data from user insn call. The length of the data must be >= 2.
1286 * data[0] must contain the INSN_DEVICE_CONFIG config_id.
1287 * data[1](input) contains the number of _pairs_ for which memory is
1288 * allotted from the user. If the user specifies '0', then only
1289 * the number of pairs available is returned.
1290 * data[1](output) returns either the number of pairs available (if none
1291 * where requested) or the number of _pairs_ that are copied back
1292 * to the user.
1293 * data[2::2] returns each (source, destination) pair.
1294 *
1295 * Return: -EINVAL if low-level driver does not allocate and return routes as
1296 * expected. Returns 0 otherwise.
1297 */
1298 static int get_valid_routes(struct comedi_device *dev, unsigned int *data)
1299 {
1300 lockdep_assert_held(&dev->mutex);
1301 data[1] = dev->get_valid_routes(dev, data[1], data + 2);
1302 return 0;
1303 }
1304
1305 static int parse_insn(struct comedi_device *dev, struct comedi_insn *insn,
1306 unsigned int *data, void *file)
1307 {
1308 struct comedi_subdevice *s;
1309 int ret = 0;
1310 int i;
1311
1312 lockdep_assert_held(&dev->mutex);
1313 if (insn->insn & INSN_MASK_SPECIAL) {
1314 /* a non-subdevice instruction */
1315
1316 switch (insn->insn) {
1317 case INSN_GTOD:
1318 {
1319 struct timespec64 tv;
1320
1321 if (insn->n != 2) {
1322 ret = -EINVAL;
1323 break;
1324 }
1325
1326 ktime_get_real_ts64(&tv);
1327 /* unsigned data safe until 2106 */
1328 data[0] = (unsigned int)tv.tv_sec;
1329 data[1] = tv.tv_nsec / NSEC_PER_USEC;
1330 ret = 2;
1331
1332 break;
1333 }
1334 case INSN_WAIT:
1335 if (insn->n != 1 || data[0] >= 100000) {
1336 ret = -EINVAL;
1337 break;
1338 }
1339 udelay(data[0] / 1000);
1340 ret = 1;
1341 break;
1342 case INSN_INTTRIG:
1343 if (insn->n != 1) {
1344 ret = -EINVAL;
1345 break;
1346 }
1347 if (insn->subdev >= dev->n_subdevices) {
1348 dev_dbg(dev->class_dev,
1349 "%d not usable subdevice\n",
1350 insn->subdev);
1351 ret = -EINVAL;
1352 break;
1353 }
1354 s = &dev->subdevices[insn->subdev];
1355 if (!s->async) {
1356 dev_dbg(dev->class_dev, "no async\n");
1357 ret = -EINVAL;
1358 break;
1359 }
1360 if (!s->async->inttrig) {
1361 dev_dbg(dev->class_dev, "no inttrig\n");
1362 ret = -EAGAIN;
1363 break;
1364 }
1365 ret = s->async->inttrig(dev, s, data[0]);
1366 if (ret >= 0)
1367 ret = 1;
1368 break;
1369 case INSN_DEVICE_CONFIG:
1370 ret = check_insn_device_config_length(insn, data);
1371 if (ret)
1372 break;
1373
1374 if (data[0] == INSN_DEVICE_CONFIG_GET_ROUTES) {
1375 /*
1376 * data[1] should be the number of _pairs_ that
1377 * the memory can hold.
1378 */
1379 data[1] = (insn->n - 2) / 2;
1380 ret = get_valid_routes(dev, data);
1381 break;
1382 }
1383
1384 /* other global device config instructions. */
1385 ret = dev->insn_device_config(dev, insn, data);
1386 break;
1387 default:
1388 dev_dbg(dev->class_dev, "invalid insn\n");
1389 ret = -EINVAL;
1390 break;
1391 }
1392 } else {
1393 /* a subdevice instruction */
1394 unsigned int maxdata;
1395
1396 if (insn->subdev >= dev->n_subdevices) {
1397 dev_dbg(dev->class_dev, "subdevice %d out of range\n",
1398 insn->subdev);
1399 ret = -EINVAL;
1400 goto out;
1401 }
1402 s = &dev->subdevices[insn->subdev];
1403
1404 if (s->type == COMEDI_SUBD_UNUSED) {
1405 dev_dbg(dev->class_dev, "%d not usable subdevice\n",
1406 insn->subdev);
1407 ret = -EIO;
1408 goto out;
1409 }
1410
1411 /* are we locked? (ioctl lock) */
1412 if (s->lock && s->lock != file) {
1413 dev_dbg(dev->class_dev, "device locked\n");
1414 ret = -EACCES;
1415 goto out;
1416 }
1417
1418 ret = comedi_check_chanlist(s, 1, &insn->chanspec);
1419 if (ret < 0) {
1420 ret = -EINVAL;
1421 dev_dbg(dev->class_dev, "bad chanspec\n");
1422 goto out;
1423 }
1424
1425 if (s->busy) {
1426 ret = -EBUSY;
1427 goto out;
1428 }
1429 /* This looks arbitrary. It is. */
1430 s->busy = parse_insn;
1431 switch (insn->insn) {
1432 case INSN_READ:
1433 ret = s->insn_read(dev, s, insn, data);
1434 if (ret == -ETIMEDOUT) {
1435 dev_dbg(dev->class_dev,
1436 "subdevice %d read instruction timed out\n",
1437 s->index);
1438 }
1439 break;
1440 case INSN_WRITE:
1441 maxdata = s->maxdata_list
1442 ? s->maxdata_list[CR_CHAN(insn->chanspec)]
1443 : s->maxdata;
1444 for (i = 0; i < insn->n; ++i) {
1445 if (data[i] > maxdata) {
1446 ret = -EINVAL;
1447 dev_dbg(dev->class_dev,
1448 "bad data value(s)\n");
1449 break;
1450 }
1451 }
1452 if (ret == 0) {
1453 ret = s->insn_write(dev, s, insn, data);
1454 if (ret == -ETIMEDOUT) {
1455 dev_dbg(dev->class_dev,
1456 "subdevice %d write instruction timed out\n",
1457 s->index);
1458 }
1459 }
1460 break;
1461 case INSN_BITS:
1462 if (insn->n != 2) {
1463 ret = -EINVAL;
1464 } else {
1465 /*
1466 * Most drivers ignore the base channel in
1467 * insn->chanspec. Fix this here if
1468 * the subdevice has <= 32 channels.
1469 */
1470 unsigned int orig_mask = data[0];
1471 unsigned int shift = 0;
1472
1473 if (s->n_chan <= 32) {
1474 shift = CR_CHAN(insn->chanspec);
1475 if (shift > 0) {
1476 insn->chanspec = 0;
1477 data[0] <<= shift;
1478 data[1] <<= shift;
1479 }
1480 }
1481 ret = s->insn_bits(dev, s, insn, data);
1482 data[0] = orig_mask;
1483 if (shift > 0)
1484 data[1] >>= shift;
1485 }
1486 break;
1487 case INSN_CONFIG:
1488 ret = check_insn_config_length(insn, data);
1489 if (ret)
1490 break;
1491 ret = s->insn_config(dev, s, insn, data);
1492 break;
1493 default:
1494 ret = -EINVAL;
1495 break;
1496 }
1497
1498 s->busy = NULL;
1499 }
1500
1501 out:
1502 return ret;
1503 }
1504
1505 /*
1506 * COMEDI_INSNLIST ioctl
1507 * synchronous instruction list
1508 *
1509 * arg:
1510 * pointer to comedi_insnlist structure
1511 *
1512 * reads:
1513 * comedi_insnlist structure
1514 * array of comedi_insn structures from insnlist->insns pointer
1515 * data (for writes) from insns[].data pointers
1516 *
1517 * writes:
1518 * data (for reads) to insns[].data pointers
1519 */
1520 /* arbitrary limits */
1521 #define MIN_SAMPLES 16
1522 #define MAX_SAMPLES 65536
1523 static int do_insnlist_ioctl(struct comedi_device *dev,
1524 struct comedi_insnlist __user *arg, void *file)
1525 {
1526 struct comedi_insnlist insnlist;
1527 struct comedi_insn *insns = NULL;
1528 unsigned int *data = NULL;
1529 unsigned int max_n_data_required = MIN_SAMPLES;
1530 int i = 0;
1531 int ret = 0;
1532
1533 lockdep_assert_held(&dev->mutex);
1534 if (copy_from_user(&insnlist, arg, sizeof(insnlist)))
1535 return -EFAULT;
1536
1537 insns = kcalloc(insnlist.n_insns, sizeof(*insns), GFP_KERNEL);
1538 if (!insns) {
1539 ret = -ENOMEM;
1540 goto error;
1541 }
1542
1543 if (copy_from_user(insns, insnlist.insns,
1544 sizeof(*insns) * insnlist.n_insns)) {
1545 dev_dbg(dev->class_dev, "copy_from_user failed\n");
1546 ret = -EFAULT;
1547 goto error;
1548 }
1549
1550 /* Determine maximum memory needed for all instructions. */
1551 for (i = 0; i < insnlist.n_insns; ++i) {
1552 if (insns[i].n > MAX_SAMPLES) {
1553 dev_dbg(dev->class_dev,
1554 "number of samples too large\n");
1555 ret = -EINVAL;
1556 goto error;
1557 }
1558 max_n_data_required = max(max_n_data_required, insns[i].n);
1559 }
1560
1561 /* Allocate scratch space for all instruction data. */
1562 data = kmalloc_array(max_n_data_required, sizeof(unsigned int),
1563 GFP_KERNEL);
1564 if (!data) {
1565 ret = -ENOMEM;
1566 goto error;
1567 }
1568
1569 for (i = 0; i < insnlist.n_insns; ++i) {
1570 if (insns[i].insn & INSN_MASK_WRITE) {
1571 if (copy_from_user(data, insns[i].data,
1572 insns[i].n * sizeof(unsigned int))) {
1573 dev_dbg(dev->class_dev,
1574 "copy_from_user failed\n");
1575 ret = -EFAULT;
1576 goto error;
1577 }
1578 }
1579 ret = parse_insn(dev, insns + i, data, file);
1580 if (ret < 0)
1581 goto error;
1582 if (insns[i].insn & INSN_MASK_READ) {
1583 if (copy_to_user(insns[i].data, data,
1584 insns[i].n * sizeof(unsigned int))) {
1585 dev_dbg(dev->class_dev,
1586 "copy_to_user failed\n");
1587 ret = -EFAULT;
1588 goto error;
1589 }
1590 }
1591 if (need_resched())
1592 schedule();
1593 }
1594
1595 error:
1596 kfree(insns);
1597 kfree(data);
1598
1599 if (ret < 0)
1600 return ret;
1601 return i;
1602 }
1603
1604 /*
1605 * COMEDI_INSN ioctl
1606 * synchronous instruction
1607 *
1608 * arg:
1609 * pointer to comedi_insn structure
1610 *
1611 * reads:
1612 * comedi_insn structure
1613 * data (for writes) from insn->data pointer
1614 *
1615 * writes:
1616 * data (for reads) to insn->data pointer
1617 */
1618 static int do_insn_ioctl(struct comedi_device *dev,
1619 struct comedi_insn __user *arg, void *file)
1620 {
1621 struct comedi_insn insn;
1622 unsigned int *data = NULL;
1623 unsigned int n_data = MIN_SAMPLES;
1624 int ret = 0;
1625
1626 lockdep_assert_held(&dev->mutex);
1627 if (copy_from_user(&insn, arg, sizeof(insn)))
1628 return -EFAULT;
1629
1630 n_data = max(n_data, insn.n);
1631
1632 /* This is where the behavior of insn and insnlist deviate. */
1633 if (insn.n > MAX_SAMPLES) {
1634 insn.n = MAX_SAMPLES;
1635 n_data = MAX_SAMPLES;
1636 }
1637
1638 data = kmalloc_array(n_data, sizeof(unsigned int), GFP_KERNEL);
1639 if (!data) {
1640 ret = -ENOMEM;
1641 goto error;
1642 }
1643
1644 if (insn.insn & INSN_MASK_WRITE) {
1645 if (copy_from_user(data,
1646 insn.data,
1647 insn.n * sizeof(unsigned int))) {
1648 ret = -EFAULT;
1649 goto error;
1650 }
1651 }
1652 ret = parse_insn(dev, &insn, data, file);
1653 if (ret < 0)
1654 goto error;
1655 if (insn.insn & INSN_MASK_READ) {
1656 if (copy_to_user(insn.data,
1657 data,
1658 insn.n * sizeof(unsigned int))) {
1659 ret = -EFAULT;
1660 goto error;
1661 }
1662 }
1663 ret = insn.n;
1664
1665 error:
1666 kfree(data);
1667
1668 return ret;
1669 }
1670
1671 static int __comedi_get_user_cmd(struct comedi_device *dev,
1672 struct comedi_cmd __user *arg,
1673 struct comedi_cmd *cmd)
1674 {
1675 struct comedi_subdevice *s;
1676
1677 lockdep_assert_held(&dev->mutex);
1678 if (copy_from_user(cmd, arg, sizeof(*cmd))) {
1679 dev_dbg(dev->class_dev, "bad cmd address\n");
1680 return -EFAULT;
1681 }
1682
1683 if (cmd->subdev >= dev->n_subdevices) {
1684 dev_dbg(dev->class_dev, "%d no such subdevice\n", cmd->subdev);
1685 return -ENODEV;
1686 }
1687
1688 s = &dev->subdevices[cmd->subdev];
1689
1690 if (s->type == COMEDI_SUBD_UNUSED) {
1691 dev_dbg(dev->class_dev, "%d not valid subdevice\n",
1692 cmd->subdev);
1693 return -EIO;
1694 }
1695
1696 if (!s->do_cmd || !s->do_cmdtest || !s->async) {
1697 dev_dbg(dev->class_dev,
1698 "subdevice %d does not support commands\n",
1699 cmd->subdev);
1700 return -EIO;
1701 }
1702
1703 /* make sure channel/gain list isn't too long */
1704 if (cmd->chanlist_len > s->len_chanlist) {
1705 dev_dbg(dev->class_dev, "channel/gain list too long %d > %d\n",
1706 cmd->chanlist_len, s->len_chanlist);
1707 return -EINVAL;
1708 }
1709
1710 /*
1711 * Set the CMDF_WRITE flag to the correct state if the subdevice
1712 * supports only "read" commands or only "write" commands.
1713 */
1714 switch (s->subdev_flags & (SDF_CMD_READ | SDF_CMD_WRITE)) {
1715 case SDF_CMD_READ:
1716 cmd->flags &= ~CMDF_WRITE;
1717 break;
1718 case SDF_CMD_WRITE:
1719 cmd->flags |= CMDF_WRITE;
1720 break;
1721 default:
1722 break;
1723 }
1724
1725 return 0;
1726 }
1727
1728 static int __comedi_get_user_chanlist(struct comedi_device *dev,
1729 struct comedi_subdevice *s,
1730 unsigned int __user *user_chanlist,
1731 struct comedi_cmd *cmd)
1732 {
1733 unsigned int *chanlist;
1734 int ret;
1735
1736 lockdep_assert_held(&dev->mutex);
1737 cmd->chanlist = NULL;
1738 chanlist = memdup_user(user_chanlist,
1739 cmd->chanlist_len * sizeof(unsigned int));
1740 if (IS_ERR(chanlist))
1741 return PTR_ERR(chanlist);
1742
1743 /* make sure each element in channel/gain list is valid */
1744 ret = comedi_check_chanlist(s, cmd->chanlist_len, chanlist);
1745 if (ret < 0) {
1746 kfree(chanlist);
1747 return ret;
1748 }
1749
1750 cmd->chanlist = chanlist;
1751
1752 return 0;
1753 }
1754
1755 /*
1756 * COMEDI_CMD ioctl
1757 * asynchronous acquisition command set-up
1758 *
1759 * arg:
1760 * pointer to comedi_cmd structure
1761 *
1762 * reads:
1763 * comedi_cmd structure
1764 * channel/range list from cmd->chanlist pointer
1765 *
1766 * writes:
1767 * possibly modified comedi_cmd structure (when -EAGAIN returned)
1768 */
1769 static int do_cmd_ioctl(struct comedi_device *dev,
1770 struct comedi_cmd __user *arg, void *file)
1771 {
1772 struct comedi_cmd cmd;
1773 struct comedi_subdevice *s;
1774 struct comedi_async *async;
1775 unsigned int __user *user_chanlist;
1776 int ret;
1777
1778 lockdep_assert_held(&dev->mutex);
1779
1780 /* get the user's cmd and do some simple validation */
1781 ret = __comedi_get_user_cmd(dev, arg, &cmd);
1782 if (ret)
1783 return ret;
1784
1785 /* save user's chanlist pointer so it can be restored later */
1786 user_chanlist = (unsigned int __user *)cmd.chanlist;
1787
1788 s = &dev->subdevices[cmd.subdev];
1789 async = s->async;
1790
1791 /* are we locked? (ioctl lock) */
1792 if (s->lock && s->lock != file) {
1793 dev_dbg(dev->class_dev, "subdevice locked\n");
1794 return -EACCES;
1795 }
1796
1797 /* are we busy? */
1798 if (s->busy) {
1799 dev_dbg(dev->class_dev, "subdevice busy\n");
1800 return -EBUSY;
1801 }
1802
1803 /* make sure channel/gain list isn't too short */
1804 if (cmd.chanlist_len < 1) {
1805 dev_dbg(dev->class_dev, "channel/gain list too short %u < 1\n",
1806 cmd.chanlist_len);
1807 return -EINVAL;
1808 }
1809
1810 async->cmd = cmd;
1811 async->cmd.data = NULL;
1812
1813 /* load channel/gain list */
1814 ret = __comedi_get_user_chanlist(dev, s, user_chanlist, &async->cmd);
1815 if (ret)
1816 goto cleanup;
1817
1818 ret = s->do_cmdtest(dev, s, &async->cmd);
1819
1820 if (async->cmd.flags & CMDF_BOGUS || ret) {
1821 dev_dbg(dev->class_dev, "test returned %d\n", ret);
1822 cmd = async->cmd;
1823 /* restore chanlist pointer before copying back */
1824 cmd.chanlist = (unsigned int __force *)user_chanlist;
1825 cmd.data = NULL;
1826 if (copy_to_user(arg, &cmd, sizeof(cmd))) {
1827 dev_dbg(dev->class_dev, "fault writing cmd\n");
1828 ret = -EFAULT;
1829 goto cleanup;
1830 }
1831 ret = -EAGAIN;
1832 goto cleanup;
1833 }
1834
1835 if (!async->prealloc_bufsz) {
1836 ret = -ENOMEM;
1837 dev_dbg(dev->class_dev, "no buffer (?)\n");
1838 goto cleanup;
1839 }
1840
1841 comedi_buf_reset(s);
1842
1843 async->cb_mask = COMEDI_CB_BLOCK | COMEDI_CB_CANCEL_MASK;
1844 if (async->cmd.flags & CMDF_WAKE_EOS)
1845 async->cb_mask |= COMEDI_CB_EOS;
1846
1847 comedi_update_subdevice_runflags(s, COMEDI_SRF_BUSY_MASK,
1848 COMEDI_SRF_RUNNING);
1849
1850 /*
1851 * Set s->busy _after_ setting COMEDI_SRF_RUNNING flag to avoid
1852 * race with comedi_read() or comedi_write().
1853 */
1854 s->busy = file;
1855 ret = s->do_cmd(dev, s);
1856 if (ret == 0)
1857 return 0;
1858
1859 cleanup:
1860 do_become_nonbusy(dev, s);
1861
1862 return ret;
1863 }
1864
1865 /*
1866 * COMEDI_CMDTEST ioctl
1867 * asynchronous acquisition command testing
1868 *
1869 * arg:
1870 * pointer to comedi_cmd structure
1871 *
1872 * reads:
1873 * comedi_cmd structure
1874 * channel/range list from cmd->chanlist pointer
1875 *
1876 * writes:
1877 * possibly modified comedi_cmd structure
1878 */
1879 static int do_cmdtest_ioctl(struct comedi_device *dev,
1880 struct comedi_cmd __user *arg, void *file)
1881 {
1882 struct comedi_cmd cmd;
1883 struct comedi_subdevice *s;
1884 unsigned int __user *user_chanlist;
1885 int ret;
1886
1887 lockdep_assert_held(&dev->mutex);
1888
1889 /* get the user's cmd and do some simple validation */
1890 ret = __comedi_get_user_cmd(dev, arg, &cmd);
1891 if (ret)
1892 return ret;
1893
1894 /* save user's chanlist pointer so it can be restored later */
1895 user_chanlist = (unsigned int __user *)cmd.chanlist;
1896
1897 s = &dev->subdevices[cmd.subdev];
1898
1899 /* user_chanlist can be NULL for COMEDI_CMDTEST ioctl */
1900 if (user_chanlist) {
1901 /* load channel/gain list */
1902 ret = __comedi_get_user_chanlist(dev, s, user_chanlist, &cmd);
1903 if (ret)
1904 return ret;
1905 }
1906
1907 ret = s->do_cmdtest(dev, s, &cmd);
1908
1909 kfree(cmd.chanlist); /* free kernel copy of user chanlist */
1910
1911 /* restore chanlist pointer before copying back */
1912 cmd.chanlist = (unsigned int __force *)user_chanlist;
1913
1914 if (copy_to_user(arg, &cmd, sizeof(cmd))) {
1915 dev_dbg(dev->class_dev, "bad cmd address\n");
1916 ret = -EFAULT;
1917 }
1918
1919 return ret;
1920 }
1921
1922 /*
1923 * COMEDI_LOCK ioctl
1924 * lock subdevice
1925 *
1926 * arg:
1927 * subdevice number
1928 *
1929 * reads:
1930 * nothing
1931 *
1932 * writes:
1933 * nothing
1934 */
1935 static int do_lock_ioctl(struct comedi_device *dev, unsigned long arg,
1936 void *file)
1937 {
1938 int ret = 0;
1939 unsigned long flags;
1940 struct comedi_subdevice *s;
1941
1942 lockdep_assert_held(&dev->mutex);
1943 if (arg >= dev->n_subdevices)
1944 return -EINVAL;
1945 s = &dev->subdevices[arg];
1946
1947 spin_lock_irqsave(&s->spin_lock, flags);
1948 if (s->busy || s->lock)
1949 ret = -EBUSY;
1950 else
1951 s->lock = file;
1952 spin_unlock_irqrestore(&s->spin_lock, flags);
1953
1954 return ret;
1955 }
1956
1957 /*
1958 * COMEDI_UNLOCK ioctl
1959 * unlock subdevice
1960 *
1961 * arg:
1962 * subdevice number
1963 *
1964 * reads:
1965 * nothing
1966 *
1967 * writes:
1968 * nothing
1969 */
1970 static int do_unlock_ioctl(struct comedi_device *dev, unsigned long arg,
1971 void *file)
1972 {
1973 struct comedi_subdevice *s;
1974
1975 lockdep_assert_held(&dev->mutex);
1976 if (arg >= dev->n_subdevices)
1977 return -EINVAL;
1978 s = &dev->subdevices[arg];
1979
1980 if (s->busy)
1981 return -EBUSY;
1982
1983 if (s->lock && s->lock != file)
1984 return -EACCES;
1985
1986 if (s->lock == file)
1987 s->lock = NULL;
1988
1989 return 0;
1990 }
1991
1992 /*
1993 * COMEDI_CANCEL ioctl
1994 * cancel asynchronous acquisition
1995 *
1996 * arg:
1997 * subdevice number
1998 *
1999 * reads:
2000 * nothing
2001 *
2002 * writes:
2003 * nothing
2004 */
2005 static int do_cancel_ioctl(struct comedi_device *dev, unsigned long arg,
2006 void *file)
2007 {
2008 struct comedi_subdevice *s;
2009
2010 lockdep_assert_held(&dev->mutex);
2011 if (arg >= dev->n_subdevices)
2012 return -EINVAL;
2013 s = &dev->subdevices[arg];
2014 if (!s->async)
2015 return -EINVAL;
2016
2017 if (!s->busy)
2018 return 0;
2019
2020 if (s->busy != file)
2021 return -EBUSY;
2022
2023 return do_cancel(dev, s);
2024 }
2025
2026 /*
2027 * COMEDI_POLL ioctl
2028 * instructs driver to synchronize buffers
2029 *
2030 * arg:
2031 * subdevice number
2032 *
2033 * reads:
2034 * nothing
2035 *
2036 * writes:
2037 * nothing
2038 */
2039 static int do_poll_ioctl(struct comedi_device *dev, unsigned long arg,
2040 void *file)
2041 {
2042 struct comedi_subdevice *s;
2043
2044 lockdep_assert_held(&dev->mutex);
2045 if (arg >= dev->n_subdevices)
2046 return -EINVAL;
2047 s = &dev->subdevices[arg];
2048
2049 if (!s->busy)
2050 return 0;
2051
2052 if (s->busy != file)
2053 return -EBUSY;
2054
2055 if (s->poll)
2056 return s->poll(dev, s);
2057
2058 return -EINVAL;
2059 }
2060
2061 /*
2062 * COMEDI_SETRSUBD ioctl
2063 * sets the current "read" subdevice on a per-file basis
2064 *
2065 * arg:
2066 * subdevice number
2067 *
2068 * reads:
2069 * nothing
2070 *
2071 * writes:
2072 * nothing
2073 */
2074 static int do_setrsubd_ioctl(struct comedi_device *dev, unsigned long arg,
2075 struct file *file)
2076 {
2077 struct comedi_file *cfp = file->private_data;
2078 struct comedi_subdevice *s_old, *s_new;
2079
2080 lockdep_assert_held(&dev->mutex);
2081 if (arg >= dev->n_subdevices)
2082 return -EINVAL;
2083
2084 s_new = &dev->subdevices[arg];
2085 s_old = comedi_file_read_subdevice(file);
2086 if (s_old == s_new)
2087 return 0; /* no change */
2088
2089 if (!(s_new->subdev_flags & SDF_CMD_READ))
2090 return -EINVAL;
2091
2092 /*
2093 * Check the file isn't still busy handling a "read" command on the
2094 * old subdevice (if any).
2095 */
2096 if (s_old && s_old->busy == file && s_old->async &&
2097 !(s_old->async->cmd.flags & CMDF_WRITE))
2098 return -EBUSY;
2099
2100 WRITE_ONCE(cfp->read_subdev, s_new);
2101 return 0;
2102 }
2103
2104 /*
2105 * COMEDI_SETWSUBD ioctl
2106 * sets the current "write" subdevice on a per-file basis
2107 *
2108 * arg:
2109 * subdevice number
2110 *
2111 * reads:
2112 * nothing
2113 *
2114 * writes:
2115 * nothing
2116 */
2117 static int do_setwsubd_ioctl(struct comedi_device *dev, unsigned long arg,
2118 struct file *file)
2119 {
2120 struct comedi_file *cfp = file->private_data;
2121 struct comedi_subdevice *s_old, *s_new;
2122
2123 lockdep_assert_held(&dev->mutex);
2124 if (arg >= dev->n_subdevices)
2125 return -EINVAL;
2126
2127 s_new = &dev->subdevices[arg];
2128 s_old = comedi_file_write_subdevice(file);
2129 if (s_old == s_new)
2130 return 0; /* no change */
2131
2132 if (!(s_new->subdev_flags & SDF_CMD_WRITE))
2133 return -EINVAL;
2134
2135 /*
2136 * Check the file isn't still busy handling a "write" command on the
2137 * old subdevice (if any).
2138 */
2139 if (s_old && s_old->busy == file && s_old->async &&
2140 (s_old->async->cmd.flags & CMDF_WRITE))
2141 return -EBUSY;
2142
2143 WRITE_ONCE(cfp->write_subdev, s_new);
2144 return 0;
2145 }
2146
2147 static long comedi_unlocked_ioctl(struct file *file, unsigned int cmd,
2148 unsigned long arg)
2149 {
2150 unsigned int minor = iminor(file_inode(file));
2151 struct comedi_file *cfp = file->private_data;
2152 struct comedi_device *dev = cfp->dev;
2153 int rc;
2154
2155 mutex_lock(&dev->mutex);
2156
2157 /*
2158 * Device config is special, because it must work on
2159 * an unconfigured device.
2160 */
2161 if (cmd == COMEDI_DEVCONFIG) {
2162 if (minor >= COMEDI_NUM_BOARD_MINORS) {
2163 /* Device config not appropriate on non-board minors. */
2164 rc = -ENOTTY;
2165 goto done;
2166 }
2167 rc = do_devconfig_ioctl(dev,
2168 (struct comedi_devconfig __user *)arg);
2169 if (rc == 0) {
2170 if (arg == 0 &&
2171 dev->minor >= comedi_num_legacy_minors) {
2172 /*
2173 * Successfully unconfigured a dynamically
2174 * allocated device. Try and remove it.
2175 */
2176 if (comedi_clear_board_dev(dev)) {
2177 mutex_unlock(&dev->mutex);
2178 comedi_free_board_dev(dev);
2179 return rc;
2180 }
2181 }
2182 }
2183 goto done;
2184 }
2185
2186 if (!dev->attached) {
2187 dev_dbg(dev->class_dev, "no driver attached\n");
2188 rc = -ENODEV;
2189 goto done;
2190 }
2191
2192 switch (cmd) {
2193 case COMEDI_BUFCONFIG:
2194 rc = do_bufconfig_ioctl(dev,
2195 (struct comedi_bufconfig __user *)arg);
2196 break;
2197 case COMEDI_DEVINFO:
2198 rc = do_devinfo_ioctl(dev, (struct comedi_devinfo __user *)arg,
2199 file);
2200 break;
2201 case COMEDI_SUBDINFO:
2202 rc = do_subdinfo_ioctl(dev,
2203 (struct comedi_subdinfo __user *)arg,
2204 file);
2205 break;
2206 case COMEDI_CHANINFO:
2207 rc = do_chaninfo_ioctl(dev, (void __user *)arg);
2208 break;
2209 case COMEDI_RANGEINFO:
2210 rc = do_rangeinfo_ioctl(dev, (void __user *)arg);
2211 break;
2212 case COMEDI_BUFINFO:
2213 rc = do_bufinfo_ioctl(dev,
2214 (struct comedi_bufinfo __user *)arg,
2215 file);
2216 break;
2217 case COMEDI_LOCK:
2218 rc = do_lock_ioctl(dev, arg, file);
2219 break;
2220 case COMEDI_UNLOCK:
2221 rc = do_unlock_ioctl(dev, arg, file);
2222 break;
2223 case COMEDI_CANCEL:
2224 rc = do_cancel_ioctl(dev, arg, file);
2225 break;
2226 case COMEDI_CMD:
2227 rc = do_cmd_ioctl(dev, (struct comedi_cmd __user *)arg, file);
2228 break;
2229 case COMEDI_CMDTEST:
2230 rc = do_cmdtest_ioctl(dev, (struct comedi_cmd __user *)arg,
2231 file);
2232 break;
2233 case COMEDI_INSNLIST:
2234 rc = do_insnlist_ioctl(dev,
2235 (struct comedi_insnlist __user *)arg,
2236 file);
2237 break;
2238 case COMEDI_INSN:
2239 rc = do_insn_ioctl(dev, (struct comedi_insn __user *)arg,
2240 file);
2241 break;
2242 case COMEDI_POLL:
2243 rc = do_poll_ioctl(dev, arg, file);
2244 break;
2245 case COMEDI_SETRSUBD:
2246 rc = do_setrsubd_ioctl(dev, arg, file);
2247 break;
2248 case COMEDI_SETWSUBD:
2249 rc = do_setwsubd_ioctl(dev, arg, file);
2250 break;
2251 default:
2252 rc = -ENOTTY;
2253 break;
2254 }
2255
2256 done:
2257 mutex_unlock(&dev->mutex);
2258 return rc;
2259 }
2260
2261 static void comedi_vm_open(struct vm_area_struct *area)
2262 {
2263 struct comedi_buf_map *bm;
2264
2265 bm = area->vm_private_data;
2266 comedi_buf_map_get(bm);
2267 }
2268
2269 static void comedi_vm_close(struct vm_area_struct *area)
2270 {
2271 struct comedi_buf_map *bm;
2272
2273 bm = area->vm_private_data;
2274 comedi_buf_map_put(bm);
2275 }
2276
2277 static int comedi_vm_access(struct vm_area_struct *vma, unsigned long addr,
2278 void *buf, int len, int write)
2279 {
2280 struct comedi_buf_map *bm = vma->vm_private_data;
2281 unsigned long offset =
2282 addr - vma->vm_start + (vma->vm_pgoff << PAGE_SHIFT);
2283
2284 if (len < 0)
2285 return -EINVAL;
2286 if (len > vma->vm_end - addr)
2287 len = vma->vm_end - addr;
2288 return comedi_buf_map_access(bm, offset, buf, len, write);
2289 }
2290
2291 static const struct vm_operations_struct comedi_vm_ops = {
2292 .open = comedi_vm_open,
2293 .close = comedi_vm_close,
2294 .access = comedi_vm_access,
2295 };
2296
2297 static int comedi_mmap(struct file *file, struct vm_area_struct *vma)
2298 {
2299 struct comedi_file *cfp = file->private_data;
2300 struct comedi_device *dev = cfp->dev;
2301 struct comedi_subdevice *s;
2302 struct comedi_async *async;
2303 struct comedi_buf_map *bm = NULL;
2304 struct comedi_buf_page *buf;
2305 unsigned long start = vma->vm_start;
2306 unsigned long size;
2307 int n_pages;
2308 int i;
2309 int retval = 0;
2310
2311 /*
2312 * 'trylock' avoids circular dependency with current->mm->mmap_sem
2313 * and down-reading &dev->attach_lock should normally succeed without
2314 * contention unless the device is in the process of being attached
2315 * or detached.
2316 */
2317 if (!down_read_trylock(&dev->attach_lock))
2318 return -EAGAIN;
2319
2320 if (!dev->attached) {
2321 dev_dbg(dev->class_dev, "no driver attached\n");
2322 retval = -ENODEV;
2323 goto done;
2324 }
2325
2326 if (vma->vm_flags & VM_WRITE)
2327 s = comedi_file_write_subdevice(file);
2328 else
2329 s = comedi_file_read_subdevice(file);
2330 if (!s) {
2331 retval = -EINVAL;
2332 goto done;
2333 }
2334
2335 async = s->async;
2336 if (!async) {
2337 retval = -EINVAL;
2338 goto done;
2339 }
2340
2341 if (vma->vm_pgoff != 0) {
2342 dev_dbg(dev->class_dev, "mmap() offset must be 0.\n");
2343 retval = -EINVAL;
2344 goto done;
2345 }
2346
2347 size = vma->vm_end - vma->vm_start;
2348 if (size > async->prealloc_bufsz) {
2349 retval = -EFAULT;
2350 goto done;
2351 }
2352 if (offset_in_page(size)) {
2353 retval = -EFAULT;
2354 goto done;
2355 }
2356
2357 n_pages = vma_pages(vma);
2358
2359 /* get reference to current buf map (if any) */
2360 bm = comedi_buf_map_from_subdev_get(s);
2361 if (!bm || n_pages > bm->n_pages) {
2362 retval = -EINVAL;
2363 goto done;
2364 }
2365 if (bm->dma_dir != DMA_NONE) {
2366 /*
2367 * DMA buffer was allocated as a single block.
2368 * Address is in page_list[0].
2369 */
2370 buf = &bm->page_list[0];
2371 retval = dma_mmap_coherent(bm->dma_hw_dev, vma, buf->virt_addr,
2372 buf->dma_addr, n_pages * PAGE_SIZE);
2373 } else {
2374 for (i = 0; i < n_pages; ++i) {
2375 unsigned long pfn;
2376
2377 buf = &bm->page_list[i];
2378 pfn = page_to_pfn(virt_to_page(buf->virt_addr));
2379 retval = remap_pfn_range(vma, start, pfn, PAGE_SIZE,
2380 PAGE_SHARED);
2381 if (retval)
2382 break;
2383
2384 start += PAGE_SIZE;
2385 }
2386 }
2387
2388 if (retval == 0) {
2389 vma->vm_ops = &comedi_vm_ops;
2390 vma->vm_private_data = bm;
2391
2392 vma->vm_ops->open(vma);
2393 }
2394
2395 done:
2396 up_read(&dev->attach_lock);
2397 comedi_buf_map_put(bm); /* put reference to buf map - okay if NULL */
2398 return retval;
2399 }
2400
2401 static __poll_t comedi_poll(struct file *file, poll_table *wait)
2402 {
2403 __poll_t mask = 0;
2404 struct comedi_file *cfp = file->private_data;
2405 struct comedi_device *dev = cfp->dev;
2406 struct comedi_subdevice *s, *s_read;
2407
2408 down_read(&dev->attach_lock);
2409
2410 if (!dev->attached) {
2411 dev_dbg(dev->class_dev, "no driver attached\n");
2412 goto done;
2413 }
2414
2415 s = comedi_file_read_subdevice(file);
2416 s_read = s;
2417 if (s && s->async) {
2418 poll_wait(file, &s->async->wait_head, wait);
2419 if (s->busy != file || !comedi_is_subdevice_running(s) ||
2420 (s->async->cmd.flags & CMDF_WRITE) ||
2421 comedi_buf_read_n_available(s) > 0)
2422 mask |= EPOLLIN | EPOLLRDNORM;
2423 }
2424
2425 s = comedi_file_write_subdevice(file);
2426 if (s && s->async) {
2427 unsigned int bps = comedi_bytes_per_sample(s);
2428
2429 if (s != s_read)
2430 poll_wait(file, &s->async->wait_head, wait);
2431 if (s->busy != file || !comedi_is_subdevice_running(s) ||
2432 !(s->async->cmd.flags & CMDF_WRITE) ||
2433 comedi_buf_write_n_available(s) >= bps)
2434 mask |= EPOLLOUT | EPOLLWRNORM;
2435 }
2436
2437 done:
2438 up_read(&dev->attach_lock);
2439 return mask;
2440 }
2441
2442 static ssize_t comedi_write(struct file *file, const char __user *buf,
2443 size_t nbytes, loff_t *offset)
2444 {
2445 struct comedi_subdevice *s;
2446 struct comedi_async *async;
2447 unsigned int n, m;
2448 ssize_t count = 0;
2449 int retval = 0;
2450 DECLARE_WAITQUEUE(wait, current);
2451 struct comedi_file *cfp = file->private_data;
2452 struct comedi_device *dev = cfp->dev;
2453 bool become_nonbusy = false;
2454 bool attach_locked;
2455 unsigned int old_detach_count;
2456
2457 /* Protect against device detachment during operation. */
2458 down_read(&dev->attach_lock);
2459 attach_locked = true;
2460 old_detach_count = dev->detach_count;
2461
2462 if (!dev->attached) {
2463 dev_dbg(dev->class_dev, "no driver attached\n");
2464 retval = -ENODEV;
2465 goto out;
2466 }
2467
2468 s = comedi_file_write_subdevice(file);
2469 if (!s || !s->async) {
2470 retval = -EIO;
2471 goto out;
2472 }
2473
2474 async = s->async;
2475 if (s->busy != file || !(async->cmd.flags & CMDF_WRITE)) {
2476 retval = -EINVAL;
2477 goto out;
2478 }
2479
2480 add_wait_queue(&async->wait_head, &wait);
2481 while (count == 0 && !retval) {
2482 unsigned int runflags;
2483 unsigned int wp, n1, n2;
2484
2485 set_current_state(TASK_INTERRUPTIBLE);
2486
2487 runflags = comedi_get_subdevice_runflags(s);
2488 if (!comedi_is_runflags_running(runflags)) {
2489 if (comedi_is_runflags_in_error(runflags))
2490 retval = -EPIPE;
2491 if (retval || nbytes)
2492 become_nonbusy = true;
2493 break;
2494 }
2495 if (nbytes == 0)
2496 break;
2497
2498 /* Allocate all free buffer space. */
2499 comedi_buf_write_alloc(s, async->prealloc_bufsz);
2500 m = comedi_buf_write_n_allocated(s);
2501 n = min_t(size_t, m, nbytes);
2502
2503 if (n == 0) {
2504 if (file->f_flags & O_NONBLOCK) {
2505 retval = -EAGAIN;
2506 break;
2507 }
2508 schedule();
2509 if (signal_pending(current)) {
2510 retval = -ERESTARTSYS;
2511 break;
2512 }
2513 if (s->busy != file ||
2514 !(async->cmd.flags & CMDF_WRITE)) {
2515 retval = -EINVAL;
2516 break;
2517 }
2518 continue;
2519 }
2520
2521 set_current_state(TASK_RUNNING);
2522 wp = async->buf_write_ptr;
2523 n1 = min(n, async->prealloc_bufsz - wp);
2524 n2 = n - n1;
2525 m = copy_from_user(async->prealloc_buf + wp, buf, n1);
2526 if (m)
2527 m += n2;
2528 else if (n2)
2529 m = copy_from_user(async->prealloc_buf, buf + n1, n2);
2530 if (m) {
2531 n -= m;
2532 retval = -EFAULT;
2533 }
2534 comedi_buf_write_free(s, n);
2535
2536 count += n;
2537 nbytes -= n;
2538
2539 buf += n;
2540 }
2541 remove_wait_queue(&async->wait_head, &wait);
2542 set_current_state(TASK_RUNNING);
2543 if (become_nonbusy && count == 0) {
2544 struct comedi_subdevice *new_s;
2545
2546 /*
2547 * To avoid deadlock, cannot acquire dev->mutex
2548 * while dev->attach_lock is held.
2549 */
2550 up_read(&dev->attach_lock);
2551 attach_locked = false;
2552 mutex_lock(&dev->mutex);
2553 /*
2554 * Check device hasn't become detached behind our back.
2555 * Checking dev->detach_count is unchanged ought to be
2556 * sufficient (unless there have been 2**32 detaches in the
2557 * meantime!), but check the subdevice pointer as well just in
2558 * case.
2559 *
2560 * Also check the subdevice is still in a suitable state to
2561 * become non-busy in case it changed behind our back.
2562 */
2563 new_s = comedi_file_write_subdevice(file);
2564 if (dev->attached && old_detach_count == dev->detach_count &&
2565 s == new_s && new_s->async == async && s->busy == file &&
2566 (async->cmd.flags & CMDF_WRITE) &&
2567 !comedi_is_subdevice_running(s))
2568 do_become_nonbusy(dev, s);
2569 mutex_unlock(&dev->mutex);
2570 }
2571 out:
2572 if (attach_locked)
2573 up_read(&dev->attach_lock);
2574
2575 return count ? count : retval;
2576 }
2577
2578 static ssize_t comedi_read(struct file *file, char __user *buf, size_t nbytes,
2579 loff_t *offset)
2580 {
2581 struct comedi_subdevice *s;
2582 struct comedi_async *async;
2583 unsigned int n, m;
2584 ssize_t count = 0;
2585 int retval = 0;
2586 DECLARE_WAITQUEUE(wait, current);
2587 struct comedi_file *cfp = file->private_data;
2588 struct comedi_device *dev = cfp->dev;
2589 unsigned int old_detach_count;
2590 bool become_nonbusy = false;
2591 bool attach_locked;
2592
2593 /* Protect against device detachment during operation. */
2594 down_read(&dev->attach_lock);
2595 attach_locked = true;
2596 old_detach_count = dev->detach_count;
2597
2598 if (!dev->attached) {
2599 dev_dbg(dev->class_dev, "no driver attached\n");
2600 retval = -ENODEV;
2601 goto out;
2602 }
2603
2604 s = comedi_file_read_subdevice(file);
2605 if (!s || !s->async) {
2606 retval = -EIO;
2607 goto out;
2608 }
2609
2610 async = s->async;
2611 if (s->busy != file || (async->cmd.flags & CMDF_WRITE)) {
2612 retval = -EINVAL;
2613 goto out;
2614 }
2615
2616 add_wait_queue(&async->wait_head, &wait);
2617 while (count == 0 && !retval) {
2618 unsigned int rp, n1, n2;
2619
2620 set_current_state(TASK_INTERRUPTIBLE);
2621
2622 m = comedi_buf_read_n_available(s);
2623 n = min_t(size_t, m, nbytes);
2624
2625 if (n == 0) {
2626 unsigned int runflags =
2627 comedi_get_subdevice_runflags(s);
2628
2629 if (!comedi_is_runflags_running(runflags)) {
2630 if (comedi_is_runflags_in_error(runflags))
2631 retval = -EPIPE;
2632 if (retval || nbytes)
2633 become_nonbusy = true;
2634 break;
2635 }
2636 if (nbytes == 0)
2637 break;
2638 if (file->f_flags & O_NONBLOCK) {
2639 retval = -EAGAIN;
2640 break;
2641 }
2642 schedule();
2643 if (signal_pending(current)) {
2644 retval = -ERESTARTSYS;
2645 break;
2646 }
2647 if (s->busy != file ||
2648 (async->cmd.flags & CMDF_WRITE)) {
2649 retval = -EINVAL;
2650 break;
2651 }
2652 continue;
2653 }
2654
2655 set_current_state(TASK_RUNNING);
2656 rp = async->buf_read_ptr;
2657 n1 = min(n, async->prealloc_bufsz - rp);
2658 n2 = n - n1;
2659 m = copy_to_user(buf, async->prealloc_buf + rp, n1);
2660 if (m)
2661 m += n2;
2662 else if (n2)
2663 m = copy_to_user(buf + n1, async->prealloc_buf, n2);
2664 if (m) {
2665 n -= m;
2666 retval = -EFAULT;
2667 }
2668
2669 comedi_buf_read_alloc(s, n);
2670 comedi_buf_read_free(s, n);
2671
2672 count += n;
2673 nbytes -= n;
2674
2675 buf += n;
2676 }
2677 remove_wait_queue(&async->wait_head, &wait);
2678 set_current_state(TASK_RUNNING);
2679 if (become_nonbusy && count == 0) {
2680 struct comedi_subdevice *new_s;
2681
2682 /*
2683 * To avoid deadlock, cannot acquire dev->mutex
2684 * while dev->attach_lock is held.
2685 */
2686 up_read(&dev->attach_lock);
2687 attach_locked = false;
2688 mutex_lock(&dev->mutex);
2689 /*
2690 * Check device hasn't become detached behind our back.
2691 * Checking dev->detach_count is unchanged ought to be
2692 * sufficient (unless there have been 2**32 detaches in the
2693 * meantime!), but check the subdevice pointer as well just in
2694 * case.
2695 *
2696 * Also check the subdevice is still in a suitable state to
2697 * become non-busy in case it changed behind our back.
2698 */
2699 new_s = comedi_file_read_subdevice(file);
2700 if (dev->attached && old_detach_count == dev->detach_count &&
2701 s == new_s && new_s->async == async && s->busy == file &&
2702 !(async->cmd.flags & CMDF_WRITE) &&
2703 !comedi_is_subdevice_running(s) &&
2704 comedi_buf_read_n_available(s) == 0)
2705 do_become_nonbusy(dev, s);
2706 mutex_unlock(&dev->mutex);
2707 }
2708 out:
2709 if (attach_locked)
2710 up_read(&dev->attach_lock);
2711
2712 return count ? count : retval;
2713 }
2714
2715 static int comedi_open(struct inode *inode, struct file *file)
2716 {
2717 const unsigned int minor = iminor(inode);
2718 struct comedi_file *cfp;
2719 struct comedi_device *dev = comedi_dev_get_from_minor(minor);
2720 int rc;
2721
2722 if (!dev) {
2723 pr_debug("invalid minor number\n");
2724 return -ENODEV;
2725 }
2726
2727 cfp = kzalloc(sizeof(*cfp), GFP_KERNEL);
2728 if (!cfp) {
2729 comedi_dev_put(dev);
2730 return -ENOMEM;
2731 }
2732
2733 cfp->dev = dev;
2734
2735 mutex_lock(&dev->mutex);
2736 if (!dev->attached && !capable(CAP_SYS_ADMIN)) {
2737 dev_dbg(dev->class_dev, "not attached and not CAP_SYS_ADMIN\n");
2738 rc = -ENODEV;
2739 goto out;
2740 }
2741 if (dev->attached && dev->use_count == 0) {
2742 if (!try_module_get(dev->driver->module)) {
2743 rc = -ENXIO;
2744 goto out;
2745 }
2746 if (dev->open) {
2747 rc = dev->open(dev);
2748 if (rc < 0) {
2749 module_put(dev->driver->module);
2750 goto out;
2751 }
2752 }
2753 }
2754
2755 dev->use_count++;
2756 file->private_data = cfp;
2757 comedi_file_reset(file);
2758 rc = 0;
2759
2760 out:
2761 mutex_unlock(&dev->mutex);
2762 if (rc) {
2763 comedi_dev_put(dev);
2764 kfree(cfp);
2765 }
2766 return rc;
2767 }
2768
2769 static int comedi_fasync(int fd, struct file *file, int on)
2770 {
2771 struct comedi_file *cfp = file->private_data;
2772 struct comedi_device *dev = cfp->dev;
2773
2774 return fasync_helper(fd, file, on, &dev->async_queue);
2775 }
2776
2777 static int comedi_close(struct inode *inode, struct file *file)
2778 {
2779 struct comedi_file *cfp = file->private_data;
2780 struct comedi_device *dev = cfp->dev;
2781 struct comedi_subdevice *s = NULL;
2782 int i;
2783
2784 mutex_lock(&dev->mutex);
2785
2786 if (dev->subdevices) {
2787 for (i = 0; i < dev->n_subdevices; i++) {
2788 s = &dev->subdevices[i];
2789
2790 if (s->busy == file)
2791 do_cancel(dev, s);
2792 if (s->lock == file)
2793 s->lock = NULL;
2794 }
2795 }
2796 if (dev->attached && dev->use_count == 1) {
2797 if (dev->close)
2798 dev->close(dev);
2799 module_put(dev->driver->module);
2800 }
2801
2802 dev->use_count--;
2803
2804 mutex_unlock(&dev->mutex);
2805 comedi_dev_put(dev);
2806 kfree(cfp);
2807
2808 return 0;
2809 }
2810
2811 static const struct file_operations comedi_fops = {
2812 .owner = THIS_MODULE,
2813 .unlocked_ioctl = comedi_unlocked_ioctl,
2814 .compat_ioctl = comedi_compat_ioctl,
2815 .open = comedi_open,
2816 .release = comedi_close,
2817 .read = comedi_read,
2818 .write = comedi_write,
2819 .mmap = comedi_mmap,
2820 .poll = comedi_poll,
2821 .fasync = comedi_fasync,
2822 .llseek = noop_llseek,
2823 };
2824
2825 /**
2826 * comedi_event() - Handle events for asynchronous COMEDI command
2827 * @dev: COMEDI device.
2828 * @s: COMEDI subdevice.
2829 * Context: in_interrupt() (usually), @s->spin_lock spin-lock not held.
2830 *
2831 * If an asynchronous COMEDI command is active on the subdevice, process
2832 * any %COMEDI_CB_... event flags that have been set, usually by an
2833 * interrupt handler. These may change the run state of the asynchronous
2834 * command, wake a task, and/or send a %SIGIO signal.
2835 */
2836 void comedi_event(struct comedi_device *dev, struct comedi_subdevice *s)
2837 {
2838 struct comedi_async *async = s->async;
2839 unsigned int events;
2840 int si_code = 0;
2841 unsigned long flags;
2842
2843 spin_lock_irqsave(&s->spin_lock, flags);
2844
2845 events = async->events;
2846 async->events = 0;
2847 if (!__comedi_is_subdevice_running(s)) {
2848 spin_unlock_irqrestore(&s->spin_lock, flags);
2849 return;
2850 }
2851
2852 if (events & COMEDI_CB_CANCEL_MASK)
2853 __comedi_clear_subdevice_runflags(s, COMEDI_SRF_RUNNING);
2854
2855 /*
2856 * Remember if an error event has occurred, so an error can be
2857 * returned the next time the user does a read() or write().
2858 */
2859 if (events & COMEDI_CB_ERROR_MASK)
2860 __comedi_set_subdevice_runflags(s, COMEDI_SRF_ERROR);
2861
2862 if (async->cb_mask & events) {
2863 wake_up_interruptible(&async->wait_head);
2864 si_code = async->cmd.flags & CMDF_WRITE ? POLL_OUT : POLL_IN;
2865 }
2866
2867 spin_unlock_irqrestore(&s->spin_lock, flags);
2868
2869 if (si_code)
2870 kill_fasync(&dev->async_queue, SIGIO, si_code);
2871 }
2872 EXPORT_SYMBOL_GPL(comedi_event);
2873
2874 /* Note: the ->mutex is pre-locked on successful return */
2875 struct comedi_device *comedi_alloc_board_minor(struct device *hardware_device)
2876 {
2877 struct comedi_device *dev;
2878 struct device *csdev;
2879 unsigned int i;
2880
2881 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
2882 if (!dev)
2883 return ERR_PTR(-ENOMEM);
2884 comedi_device_init(dev);
2885 comedi_set_hw_dev(dev, hardware_device);
2886 mutex_lock(&dev->mutex);
2887 mutex_lock(&comedi_board_minor_table_lock);
2888 for (i = hardware_device ? comedi_num_legacy_minors : 0;
2889 i < COMEDI_NUM_BOARD_MINORS; ++i) {
2890 if (!comedi_board_minor_table[i]) {
2891 comedi_board_minor_table[i] = dev;
2892 break;
2893 }
2894 }
2895 mutex_unlock(&comedi_board_minor_table_lock);
2896 if (i == COMEDI_NUM_BOARD_MINORS) {
2897 mutex_unlock(&dev->mutex);
2898 comedi_device_cleanup(dev);
2899 comedi_dev_put(dev);
2900 dev_err(hardware_device,
2901 "ran out of minor numbers for board device files\n");
2902 return ERR_PTR(-EBUSY);
2903 }
2904 dev->minor = i;
2905 csdev = device_create(comedi_class, hardware_device,
2906 MKDEV(COMEDI_MAJOR, i), NULL, "comedi%i", i);
2907 if (!IS_ERR(csdev))
2908 dev->class_dev = get_device(csdev);
2909
2910 /* Note: dev->mutex needs to be unlocked by the caller. */
2911 return dev;
2912 }
2913
2914 void comedi_release_hardware_device(struct device *hardware_device)
2915 {
2916 int minor;
2917 struct comedi_device *dev;
2918
2919 for (minor = comedi_num_legacy_minors; minor < COMEDI_NUM_BOARD_MINORS;
2920 minor++) {
2921 mutex_lock(&comedi_board_minor_table_lock);
2922 dev = comedi_board_minor_table[minor];
2923 if (dev && dev->hw_dev == hardware_device) {
2924 comedi_board_minor_table[minor] = NULL;
2925 mutex_unlock(&comedi_board_minor_table_lock);
2926 comedi_free_board_dev(dev);
2927 break;
2928 }
2929 mutex_unlock(&comedi_board_minor_table_lock);
2930 }
2931 }
2932
2933 int comedi_alloc_subdevice_minor(struct comedi_subdevice *s)
2934 {
2935 struct comedi_device *dev = s->device;
2936 struct device *csdev;
2937 unsigned int i;
2938
2939 mutex_lock(&comedi_subdevice_minor_table_lock);
2940 for (i = 0; i < COMEDI_NUM_SUBDEVICE_MINORS; ++i) {
2941 if (!comedi_subdevice_minor_table[i]) {
2942 comedi_subdevice_minor_table[i] = s;
2943 break;
2944 }
2945 }
2946 mutex_unlock(&comedi_subdevice_minor_table_lock);
2947 if (i == COMEDI_NUM_SUBDEVICE_MINORS) {
2948 dev_err(dev->class_dev,
2949 "ran out of minor numbers for subdevice files\n");
2950 return -EBUSY;
2951 }
2952 i += COMEDI_NUM_BOARD_MINORS;
2953 s->minor = i;
2954 csdev = device_create(comedi_class, dev->class_dev,
2955 MKDEV(COMEDI_MAJOR, i), NULL, "comedi%i_subd%i",
2956 dev->minor, s->index);
2957 if (!IS_ERR(csdev))
2958 s->class_dev = csdev;
2959
2960 return 0;
2961 }
2962
2963 void comedi_free_subdevice_minor(struct comedi_subdevice *s)
2964 {
2965 unsigned int i;
2966
2967 if (!s)
2968 return;
2969 if (s->minor < COMEDI_NUM_BOARD_MINORS ||
2970 s->minor >= COMEDI_NUM_MINORS)
2971 return;
2972
2973 i = s->minor - COMEDI_NUM_BOARD_MINORS;
2974 mutex_lock(&comedi_subdevice_minor_table_lock);
2975 if (s == comedi_subdevice_minor_table[i])
2976 comedi_subdevice_minor_table[i] = NULL;
2977 mutex_unlock(&comedi_subdevice_minor_table_lock);
2978 if (s->class_dev) {
2979 device_destroy(comedi_class, MKDEV(COMEDI_MAJOR, s->minor));
2980 s->class_dev = NULL;
2981 }
2982 }
2983
2984 static void comedi_cleanup_board_minors(void)
2985 {
2986 struct comedi_device *dev;
2987 unsigned int i;
2988
2989 for (i = 0; i < COMEDI_NUM_BOARD_MINORS; i++) {
2990 dev = comedi_clear_board_minor(i);
2991 comedi_free_board_dev(dev);
2992 }
2993 }
2994
2995 static int __init comedi_init(void)
2996 {
2997 int i;
2998 int retval;
2999
3000 pr_info("version " COMEDI_RELEASE " - http://www.comedi.org\n");
3001
3002 if (comedi_num_legacy_minors > COMEDI_NUM_BOARD_MINORS) {
3003 pr_err("invalid value for module parameter \"comedi_num_legacy_minors\". Valid values are 0 through %i.\n",
3004 COMEDI_NUM_BOARD_MINORS);
3005 return -EINVAL;
3006 }
3007
3008 retval = register_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
3009 COMEDI_NUM_MINORS, "comedi");
3010 if (retval)
3011 return retval;
3012
3013 cdev_init(&comedi_cdev, &comedi_fops);
3014 comedi_cdev.owner = THIS_MODULE;
3015
3016 retval = kobject_set_name(&comedi_cdev.kobj, "comedi");
3017 if (retval)
3018 goto out_unregister_chrdev_region;
3019
3020 retval = cdev_add(&comedi_cdev, MKDEV(COMEDI_MAJOR, 0),
3021 COMEDI_NUM_MINORS);
3022 if (retval)
3023 goto out_unregister_chrdev_region;
3024
3025 comedi_class = class_create(THIS_MODULE, "comedi");
3026 if (IS_ERR(comedi_class)) {
3027 retval = PTR_ERR(comedi_class);
3028 pr_err("failed to create class\n");
3029 goto out_cdev_del;
3030 }
3031
3032 comedi_class->dev_groups = comedi_dev_groups;
3033
3034 /* create devices files for legacy/manual use */
3035 for (i = 0; i < comedi_num_legacy_minors; i++) {
3036 struct comedi_device *dev;
3037
3038 dev = comedi_alloc_board_minor(NULL);
3039 if (IS_ERR(dev)) {
3040 retval = PTR_ERR(dev);
3041 goto out_cleanup_board_minors;
3042 }
3043 /* comedi_alloc_board_minor() locked the mutex */
3044 lockdep_assert_held(&dev->mutex);
3045 mutex_unlock(&dev->mutex);
3046 }
3047
3048 /* XXX requires /proc interface */
3049 comedi_proc_init();
3050
3051 return 0;
3052
3053 out_cleanup_board_minors:
3054 comedi_cleanup_board_minors();
3055 class_destroy(comedi_class);
3056 out_cdev_del:
3057 cdev_del(&comedi_cdev);
3058 out_unregister_chrdev_region:
3059 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0), COMEDI_NUM_MINORS);
3060 return retval;
3061 }
3062 module_init(comedi_init);
3063
3064 static void __exit comedi_cleanup(void)
3065 {
3066 comedi_cleanup_board_minors();
3067 class_destroy(comedi_class);
3068 cdev_del(&comedi_cdev);
3069 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0), COMEDI_NUM_MINORS);
3070
3071 comedi_proc_cleanup();
3072 }
3073 module_exit(comedi_cleanup);
3074
3075 MODULE_AUTHOR("http://www.comedi.org");
3076 MODULE_DESCRIPTION("Comedi core module");
3077 MODULE_LICENSE("GPL");
A mirror of Linus' kernel repository