1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#undef DEBUG
25
26#define __NO_VERSION__
27#include "comedi_fops.h"
28#include "comedi_compat32.h"
29
30#include <linux/module.h>
31#include <linux/errno.h>
32#include <linux/kernel.h>
33#include <linux/sched.h>
34#include <linux/fcntl.h>
35#include <linux/delay.h>
36#include <linux/ioport.h>
37#include <linux/mm.h>
38#include <linux/slab.h>
39#include <linux/kmod.h>
40#include <linux/poll.h>
41#include <linux/init.h>
42#include <linux/device.h>
43#include <linux/vmalloc.h>
44#include <linux/fs.h>
45#include "comedidev.h"
46#include <linux/cdev.h>
47#include <linux/stat.h>
48
49#include <linux/io.h>
50#include <linux/uaccess.h>
51
52#include "internal.h"
53
54MODULE_AUTHOR("http://www.comedi.org");
55MODULE_DESCRIPTION("Comedi core module");
56MODULE_LICENSE("GPL");
57
58#ifdef CONFIG_COMEDI_DEBUG
59int comedi_debug;
60EXPORT_SYMBOL(comedi_debug);
61module_param(comedi_debug, int, 0644);
62#endif
63
64int comedi_autoconfig = 1;
65module_param(comedi_autoconfig, bool, 0444);
66
67static int comedi_num_legacy_minors;
68module_param(comedi_num_legacy_minors, int, 0444);
69
70static DEFINE_SPINLOCK(comedi_file_info_table_lock);
71static struct comedi_device_file_info
72*comedi_file_info_table[COMEDI_NUM_MINORS];
73
74static int do_devconfig_ioctl(struct comedi_device *dev,
75 struct comedi_devconfig __user *arg);
76static int do_bufconfig_ioctl(struct comedi_device *dev,
77 struct comedi_bufconfig __user *arg);
78static int do_devinfo_ioctl(struct comedi_device *dev,
79 struct comedi_devinfo __user *arg,
80 struct file *file);
81static int do_subdinfo_ioctl(struct comedi_device *dev,
82 struct comedi_subdinfo __user *arg, void *file);
83static int do_chaninfo_ioctl(struct comedi_device *dev,
84 struct comedi_chaninfo __user *arg);
85static int do_bufinfo_ioctl(struct comedi_device *dev,
86 struct comedi_bufinfo __user *arg, void *file);
87static int do_cmd_ioctl(struct comedi_device *dev,
88 struct comedi_cmd __user *arg, void *file);
89static int do_lock_ioctl(struct comedi_device *dev, unsigned int arg,
90 void *file);
91static int do_unlock_ioctl(struct comedi_device *dev, unsigned int arg,
92 void *file);
93static int do_cancel_ioctl(struct comedi_device *dev, unsigned int arg,
94 void *file);
95static int do_cmdtest_ioctl(struct comedi_device *dev,
96 struct comedi_cmd __user *arg, void *file);
97static int do_insnlist_ioctl(struct comedi_device *dev,
98 struct comedi_insnlist __user *arg, void *file);
99static int do_insn_ioctl(struct comedi_device *dev,
100 struct comedi_insn __user *arg, void *file);
101static int do_poll_ioctl(struct comedi_device *dev, unsigned int subd,
102 void *file);
103
104extern void do_become_nonbusy(struct comedi_device *dev,
105 struct comedi_subdevice *s);
106static int do_cancel(struct comedi_device *dev, struct comedi_subdevice *s);
107
108static int comedi_fasync(int fd, struct file *file, int on);
109
110static int is_device_busy(struct comedi_device *dev);
111static int resize_async_buffer(struct comedi_device *dev,
112 struct comedi_subdevice *s,
113 struct comedi_async *async, unsigned new_size);
114
115
116static struct device_attribute dev_attr_max_read_buffer_kb;
117static struct device_attribute dev_attr_read_buffer_kb;
118static struct device_attribute dev_attr_max_write_buffer_kb;
119static struct device_attribute dev_attr_write_buffer_kb;
120
121static long comedi_unlocked_ioctl(struct file *file, unsigned int cmd,
122 unsigned long arg)
123{
124 const unsigned minor = iminor(file->f_dentry->d_inode);
125 struct comedi_device_file_info *dev_file_info =
126 comedi_get_device_file_info(minor);
127 struct comedi_device *dev;
128 int rc;
129
130 if (dev_file_info == NULL || dev_file_info->device == NULL)
131 return -ENODEV;
132 dev = dev_file_info->device;
133
134 mutex_lock(&dev->mutex);
135
136
137
138 if (cmd == COMEDI_DEVCONFIG) {
139 rc = do_devconfig_ioctl(dev,
140 (struct comedi_devconfig __user *)arg);
141 goto done;
142 }
143
144 if (!dev->attached) {
145 DPRINTK("no driver configured on /dev/comedi%i\n", dev->minor);
146 rc = -ENODEV;
147 goto done;
148 }
149
150 switch (cmd) {
151 case COMEDI_BUFCONFIG:
152 rc = do_bufconfig_ioctl(dev,
153 (struct comedi_bufconfig __user *)arg);
154 break;
155 case COMEDI_DEVINFO:
156 rc = do_devinfo_ioctl(dev, (struct comedi_devinfo __user *)arg,
157 file);
158 break;
159 case COMEDI_SUBDINFO:
160 rc = do_subdinfo_ioctl(dev,
161 (struct comedi_subdinfo __user *)arg,
162 file);
163 break;
164 case COMEDI_CHANINFO:
165 rc = do_chaninfo_ioctl(dev, (void __user *)arg);
166 break;
167 case COMEDI_RANGEINFO:
168 rc = do_rangeinfo_ioctl(dev, (void __user *)arg);
169 break;
170 case COMEDI_BUFINFO:
171 rc = do_bufinfo_ioctl(dev,
172 (struct comedi_bufinfo __user *)arg,
173 file);
174 break;
175 case COMEDI_LOCK:
176 rc = do_lock_ioctl(dev, arg, file);
177 break;
178 case COMEDI_UNLOCK:
179 rc = do_unlock_ioctl(dev, arg, file);
180 break;
181 case COMEDI_CANCEL:
182 rc = do_cancel_ioctl(dev, arg, file);
183 break;
184 case COMEDI_CMD:
185 rc = do_cmd_ioctl(dev, (struct comedi_cmd __user *)arg, file);
186 break;
187 case COMEDI_CMDTEST:
188 rc = do_cmdtest_ioctl(dev, (struct comedi_cmd __user *)arg,
189 file);
190 break;
191 case COMEDI_INSNLIST:
192 rc = do_insnlist_ioctl(dev,
193 (struct comedi_insnlist __user *)arg,
194 file);
195 break;
196 case COMEDI_INSN:
197 rc = do_insn_ioctl(dev, (struct comedi_insn __user *)arg,
198 file);
199 break;
200 case COMEDI_POLL:
201 rc = do_poll_ioctl(dev, arg, file);
202 break;
203 default:
204 rc = -ENOTTY;
205 break;
206 }
207
208done:
209 mutex_unlock(&dev->mutex);
210 return rc;
211}
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226static int do_devconfig_ioctl(struct comedi_device *dev,
227 struct comedi_devconfig __user *arg)
228{
229 struct comedi_devconfig it;
230 int ret;
231 unsigned char *aux_data = NULL;
232 int aux_len;
233
234 if (!capable(CAP_SYS_ADMIN))
235 return -EPERM;
236
237 if (arg == NULL) {
238 if (is_device_busy(dev))
239 return -EBUSY;
240 if (dev->attached) {
241 struct module *driver_module = dev->driver->module;
242 comedi_device_detach(dev);
243 module_put(driver_module);
244 }
245 return 0;
246 }
247
248 if (copy_from_user(&it, arg, sizeof(struct comedi_devconfig)))
249 return -EFAULT;
250
251 it.board_name[COMEDI_NAMELEN - 1] = 0;
252
253 if (comedi_aux_data(it.options, 0) &&
254 it.options[COMEDI_DEVCONF_AUX_DATA_LENGTH]) {
255 int bit_shift;
256 aux_len = it.options[COMEDI_DEVCONF_AUX_DATA_LENGTH];
257 if (aux_len < 0)
258 return -EFAULT;
259
260 aux_data = vmalloc(aux_len);
261 if (!aux_data)
262 return -ENOMEM;
263
264 if (copy_from_user(aux_data,
265 comedi_aux_data(it.options, 0), aux_len)) {
266 vfree(aux_data);
267 return -EFAULT;
268 }
269 it.options[COMEDI_DEVCONF_AUX_DATA_LO] =
270 (unsigned long)aux_data;
271 if (sizeof(void *) > sizeof(int)) {
272 bit_shift = sizeof(int) * 8;
273 it.options[COMEDI_DEVCONF_AUX_DATA_HI] =
274 ((unsigned long)aux_data) >> bit_shift;
275 } else
276 it.options[COMEDI_DEVCONF_AUX_DATA_HI] = 0;
277 }
278
279 ret = comedi_device_attach(dev, &it);
280 if (ret == 0) {
281 if (!try_module_get(dev->driver->module)) {
282 comedi_device_detach(dev);
283 return -ENOSYS;
284 }
285 }
286
287 if (aux_data)
288 vfree(aux_data);
289
290 return ret;
291}
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307static int do_bufconfig_ioctl(struct comedi_device *dev,
308 struct comedi_bufconfig __user *arg)
309{
310 struct comedi_bufconfig bc;
311 struct comedi_async *async;
312 struct comedi_subdevice *s;
313 int retval = 0;
314
315 if (copy_from_user(&bc, arg, sizeof(struct comedi_bufconfig)))
316 return -EFAULT;
317
318 if (bc.subdevice >= dev->n_subdevices || bc.subdevice < 0)
319 return -EINVAL;
320
321 s = dev->subdevices + bc.subdevice;
322 async = s->async;
323
324 if (!async) {
325 DPRINTK("subdevice does not have async capability\n");
326 bc.size = 0;
327 bc.maximum_size = 0;
328 goto copyback;
329 }
330
331 if (bc.maximum_size) {
332 if (!capable(CAP_SYS_ADMIN))
333 return -EPERM;
334
335 async->max_bufsize = bc.maximum_size;
336 }
337
338 if (bc.size) {
339 retval = resize_async_buffer(dev, s, async, bc.size);
340 if (retval < 0)
341 return retval;
342 }
343
344 bc.size = async->prealloc_bufsz;
345 bc.maximum_size = async->max_bufsize;
346
347copyback:
348 if (copy_to_user(arg, &bc, sizeof(struct comedi_bufconfig)))
349 return -EFAULT;
350
351 return 0;
352}
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368static int do_devinfo_ioctl(struct comedi_device *dev,
369 struct comedi_devinfo __user *arg,
370 struct file *file)
371{
372 struct comedi_devinfo devinfo;
373 const unsigned minor = iminor(file->f_dentry->d_inode);
374 struct comedi_device_file_info *dev_file_info =
375 comedi_get_device_file_info(minor);
376 struct comedi_subdevice *read_subdev =
377 comedi_get_read_subdevice(dev_file_info);
378 struct comedi_subdevice *write_subdev =
379 comedi_get_write_subdevice(dev_file_info);
380
381 memset(&devinfo, 0, sizeof(devinfo));
382
383
384 devinfo.version_code = COMEDI_VERSION_CODE;
385 devinfo.n_subdevs = dev->n_subdevices;
386 memcpy(devinfo.driver_name, dev->driver->driver_name, COMEDI_NAMELEN);
387 memcpy(devinfo.board_name, dev->board_name, COMEDI_NAMELEN);
388
389 if (read_subdev)
390 devinfo.read_subdevice = read_subdev - dev->subdevices;
391 else
392 devinfo.read_subdevice = -1;
393
394 if (write_subdev)
395 devinfo.write_subdevice = write_subdev - dev->subdevices;
396 else
397 devinfo.write_subdevice = -1;
398
399 if (copy_to_user(arg, &devinfo, sizeof(struct comedi_devinfo)))
400 return -EFAULT;
401
402 return 0;
403}
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419static int do_subdinfo_ioctl(struct comedi_device *dev,
420 struct comedi_subdinfo __user *arg, void *file)
421{
422 int ret, i;
423 struct comedi_subdinfo *tmp, *us;
424 struct comedi_subdevice *s;
425
426 tmp =
427 kcalloc(dev->n_subdevices, sizeof(struct comedi_subdinfo),
428 GFP_KERNEL);
429 if (!tmp)
430 return -ENOMEM;
431
432
433 for (i = 0; i < dev->n_subdevices; i++) {
434 s = dev->subdevices + i;
435 us = tmp + i;
436
437 us->type = s->type;
438 us->n_chan = s->n_chan;
439 us->subd_flags = s->subdev_flags;
440 if (comedi_get_subdevice_runflags(s) & SRF_RUNNING)
441 us->subd_flags |= SDF_RUNNING;
442#define TIMER_nanosec 5
443 us->timer_type = TIMER_nanosec;
444 us->len_chanlist = s->len_chanlist;
445 us->maxdata = s->maxdata;
446 if (s->range_table) {
447 us->range_type =
448 (i << 24) | (0 << 16) | (s->range_table->length);
449 } else {
450 us->range_type = 0;
451 }
452 us->flags = s->flags;
453
454 if (s->busy)
455 us->subd_flags |= SDF_BUSY;
456 if (s->busy == file)
457 us->subd_flags |= SDF_BUSY_OWNER;
458 if (s->lock)
459 us->subd_flags |= SDF_LOCKED;
460 if (s->lock == file)
461 us->subd_flags |= SDF_LOCK_OWNER;
462 if (!s->maxdata && s->maxdata_list)
463 us->subd_flags |= SDF_MAXDATA;
464 if (s->flaglist)
465 us->subd_flags |= SDF_FLAGS;
466 if (s->range_table_list)
467 us->subd_flags |= SDF_RANGETYPE;
468 if (s->do_cmd)
469 us->subd_flags |= SDF_CMD;
470
471 if (s->insn_bits != &insn_inval)
472 us->insn_bits_support = COMEDI_SUPPORTED;
473 else
474 us->insn_bits_support = COMEDI_UNSUPPORTED;
475
476 us->settling_time_0 = s->settling_time_0;
477 }
478
479 ret = copy_to_user(arg, tmp,
480 dev->n_subdevices * sizeof(struct comedi_subdinfo));
481
482 kfree(tmp);
483
484 return ret ? -EFAULT : 0;
485}
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501static int do_chaninfo_ioctl(struct comedi_device *dev,
502 struct comedi_chaninfo __user *arg)
503{
504 struct comedi_subdevice *s;
505 struct comedi_chaninfo it;
506
507 if (copy_from_user(&it, arg, sizeof(struct comedi_chaninfo)))
508 return -EFAULT;
509
510 if (it.subdev >= dev->n_subdevices)
511 return -EINVAL;
512 s = dev->subdevices + it.subdev;
513
514 if (it.maxdata_list) {
515 if (s->maxdata || !s->maxdata_list)
516 return -EINVAL;
517 if (copy_to_user(it.maxdata_list, s->maxdata_list,
518 s->n_chan * sizeof(unsigned int)))
519 return -EFAULT;
520 }
521
522 if (it.flaglist) {
523 if (!s->flaglist)
524 return -EINVAL;
525 if (copy_to_user(it.flaglist, s->flaglist,
526 s->n_chan * sizeof(unsigned int)))
527 return -EFAULT;
528 }
529
530 if (it.rangelist) {
531 int i;
532
533 if (!s->range_table_list)
534 return -EINVAL;
535 for (i = 0; i < s->n_chan; i++) {
536 int x;
537
538 x = (dev->minor << 28) | (it.subdev << 24) | (i << 16) |
539 (s->range_table_list[i]->length);
540 if (put_user(x, it.rangelist + i))
541 return -EFAULT;
542 }
543#if 0
544 if (copy_to_user(it.rangelist, s->range_type_list,
545 s->n_chan * sizeof(unsigned int)))
546 return -EFAULT;
547#endif
548 }
549
550 return 0;
551}
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567static int do_bufinfo_ioctl(struct comedi_device *dev,
568 struct comedi_bufinfo __user *arg, void *file)
569{
570 struct comedi_bufinfo bi;
571 struct comedi_subdevice *s;
572 struct comedi_async *async;
573
574 if (copy_from_user(&bi, arg, sizeof(struct comedi_bufinfo)))
575 return -EFAULT;
576
577 if (bi.subdevice >= dev->n_subdevices || bi.subdevice < 0)
578 return -EINVAL;
579
580 s = dev->subdevices + bi.subdevice;
581
582 if (s->lock && s->lock != file)
583 return -EACCES;
584
585 async = s->async;
586
587 if (!async) {
588 DPRINTK("subdevice does not have async capability\n");
589 bi.buf_write_ptr = 0;
590 bi.buf_read_ptr = 0;
591 bi.buf_write_count = 0;
592 bi.buf_read_count = 0;
593 bi.bytes_read = 0;
594 bi.bytes_written = 0;
595 goto copyback;
596 }
597 if (!s->busy) {
598 bi.bytes_read = 0;
599 bi.bytes_written = 0;
600 goto copyback_position;
601 }
602 if (s->busy != file)
603 return -EACCES;
604
605 if (bi.bytes_read && (s->subdev_flags & SDF_CMD_READ)) {
606 bi.bytes_read = comedi_buf_read_alloc(async, bi.bytes_read);
607 comedi_buf_read_free(async, bi.bytes_read);
608
609 if (!(comedi_get_subdevice_runflags(s) & (SRF_ERROR |
610 SRF_RUNNING))
611 && async->buf_write_count == async->buf_read_count) {
612 do_become_nonbusy(dev, s);
613 }
614 }
615
616 if (bi.bytes_written && (s->subdev_flags & SDF_CMD_WRITE)) {
617 bi.bytes_written =
618 comedi_buf_write_alloc(async, bi.bytes_written);
619 comedi_buf_write_free(async, bi.bytes_written);
620 }
621
622copyback_position:
623 bi.buf_write_count = async->buf_write_count;
624 bi.buf_write_ptr = async->buf_write_ptr;
625 bi.buf_read_count = async->buf_read_count;
626 bi.buf_read_ptr = async->buf_read_ptr;
627
628copyback:
629 if (copy_to_user(arg, &bi, sizeof(struct comedi_bufinfo)))
630 return -EFAULT;
631
632 return 0;
633}
634
635static int parse_insn(struct comedi_device *dev, struct comedi_insn *insn,
636 unsigned int *data, void *file);
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653#define MAX_SAMPLES 256
654static int do_insnlist_ioctl(struct comedi_device *dev,
655 struct comedi_insnlist __user *arg, void *file)
656{
657 struct comedi_insnlist insnlist;
658 struct comedi_insn *insns = NULL;
659 unsigned int *data = NULL;
660 int i = 0;
661 int ret = 0;
662
663 if (copy_from_user(&insnlist, arg, sizeof(struct comedi_insnlist)))
664 return -EFAULT;
665
666 data = kmalloc(sizeof(unsigned int) * MAX_SAMPLES, GFP_KERNEL);
667 if (!data) {
668 DPRINTK("kmalloc failed\n");
669 ret = -ENOMEM;
670 goto error;
671 }
672
673 insns =
674 kmalloc(sizeof(struct comedi_insn) * insnlist.n_insns, GFP_KERNEL);
675 if (!insns) {
676 DPRINTK("kmalloc failed\n");
677 ret = -ENOMEM;
678 goto error;
679 }
680
681 if (copy_from_user(insns, insnlist.insns,
682 sizeof(struct comedi_insn) * insnlist.n_insns)) {
683 DPRINTK("copy_from_user failed\n");
684 ret = -EFAULT;
685 goto error;
686 }
687
688 for (i = 0; i < insnlist.n_insns; i++) {
689 if (insns[i].n > MAX_SAMPLES) {
690 DPRINTK("number of samples too large\n");
691 ret = -EINVAL;
692 goto error;
693 }
694 if (insns[i].insn & INSN_MASK_WRITE) {
695 if (copy_from_user(data, insns[i].data,
696 insns[i].n * sizeof(unsigned int))) {
697 DPRINTK("copy_from_user failed\n");
698 ret = -EFAULT;
699 goto error;
700 }
701 }
702 ret = parse_insn(dev, insns + i, data, file);
703 if (ret < 0)
704 goto error;
705 if (insns[i].insn & INSN_MASK_READ) {
706 if (copy_to_user(insns[i].data, data,
707 insns[i].n * sizeof(unsigned int))) {
708 DPRINTK("copy_to_user failed\n");
709 ret = -EFAULT;
710 goto error;
711 }
712 }
713 if (need_resched())
714 schedule();
715 }
716
717error:
718 kfree(insns);
719 kfree(data);
720
721 if (ret < 0)
722 return ret;
723 return i;
724}
725
726static int check_insn_config_length(struct comedi_insn *insn,
727 unsigned int *data)
728{
729 if (insn->n < 1)
730 return -EINVAL;
731
732 switch (data[0]) {
733 case INSN_CONFIG_DIO_OUTPUT:
734 case INSN_CONFIG_DIO_INPUT:
735 case INSN_CONFIG_DISARM:
736 case INSN_CONFIG_RESET:
737 if (insn->n == 1)
738 return 0;
739 break;
740 case INSN_CONFIG_ARM:
741 case INSN_CONFIG_DIO_QUERY:
742 case INSN_CONFIG_BLOCK_SIZE:
743 case INSN_CONFIG_FILTER:
744 case INSN_CONFIG_SERIAL_CLOCK:
745 case INSN_CONFIG_BIDIRECTIONAL_DATA:
746 case INSN_CONFIG_ALT_SOURCE:
747 case INSN_CONFIG_SET_COUNTER_MODE:
748 case INSN_CONFIG_8254_READ_STATUS:
749 case INSN_CONFIG_SET_ROUTING:
750 case INSN_CONFIG_GET_ROUTING:
751 case INSN_CONFIG_GET_PWM_STATUS:
752 case INSN_CONFIG_PWM_SET_PERIOD:
753 case INSN_CONFIG_PWM_GET_PERIOD:
754 if (insn->n == 2)
755 return 0;
756 break;
757 case INSN_CONFIG_SET_GATE_SRC:
758 case INSN_CONFIG_GET_GATE_SRC:
759 case INSN_CONFIG_SET_CLOCK_SRC:
760 case INSN_CONFIG_GET_CLOCK_SRC:
761 case INSN_CONFIG_SET_OTHER_SRC:
762 case INSN_CONFIG_GET_COUNTER_STATUS:
763 case INSN_CONFIG_PWM_SET_H_BRIDGE:
764 case INSN_CONFIG_PWM_GET_H_BRIDGE:
765 case INSN_CONFIG_GET_HARDWARE_BUFFER_SIZE:
766 if (insn->n == 3)
767 return 0;
768 break;
769 case INSN_CONFIG_PWM_OUTPUT:
770 case INSN_CONFIG_ANALOG_TRIG:
771 if (insn->n == 5)
772 return 0;
773 break;
774
775
776 default:
777 printk(KERN_WARNING
778 "comedi: no check for data length of config insn id "
779 "%i is implemented.\n"
780 " Add a check to %s in %s.\n"
781 " Assuming n=%i is correct.\n", data[0], __func__,
782 __FILE__, insn->n);
783 return 0;
784 break;
785 }
786 return -EINVAL;
787}
788
789static int parse_insn(struct comedi_device *dev, struct comedi_insn *insn,
790 unsigned int *data, void *file)
791{
792 struct comedi_subdevice *s;
793 int ret = 0;
794 int i;
795
796 if (insn->insn & INSN_MASK_SPECIAL) {
797
798
799 switch (insn->insn) {
800 case INSN_GTOD:
801 {
802 struct timeval tv;
803
804 if (insn->n != 2) {
805 ret = -EINVAL;
806 break;
807 }
808
809 do_gettimeofday(&tv);
810 data[0] = tv.tv_sec;
811 data[1] = tv.tv_usec;
812 ret = 2;
813
814 break;
815 }
816 case INSN_WAIT:
817 if (insn->n != 1 || data[0] >= 100000) {
818 ret = -EINVAL;
819 break;
820 }
821 udelay(data[0] / 1000);
822 ret = 1;
823 break;
824 case INSN_INTTRIG:
825 if (insn->n != 1) {
826 ret = -EINVAL;
827 break;
828 }
829 if (insn->subdev >= dev->n_subdevices) {
830 DPRINTK("%d not usable subdevice\n",
831 insn->subdev);
832 ret = -EINVAL;
833 break;
834 }
835 s = dev->subdevices + insn->subdev;
836 if (!s->async) {
837 DPRINTK("no async\n");
838 ret = -EINVAL;
839 break;
840 }
841 if (!s->async->inttrig) {
842 DPRINTK("no inttrig\n");
843 ret = -EAGAIN;
844 break;
845 }
846 ret = s->async->inttrig(dev, s, insn->data[0]);
847 if (ret >= 0)
848 ret = 1;
849 break;
850 default:
851 DPRINTK("invalid insn\n");
852 ret = -EINVAL;
853 break;
854 }
855 } else {
856
857 unsigned int maxdata;
858
859 if (insn->subdev >= dev->n_subdevices) {
860 DPRINTK("subdevice %d out of range\n", insn->subdev);
861 ret = -EINVAL;
862 goto out;
863 }
864 s = dev->subdevices + insn->subdev;
865
866 if (s->type == COMEDI_SUBD_UNUSED) {
867 DPRINTK("%d not usable subdevice\n", insn->subdev);
868 ret = -EIO;
869 goto out;
870 }
871
872
873 if (s->lock && s->lock != file) {
874 DPRINTK("device locked\n");
875 ret = -EACCES;
876 goto out;
877 }
878
879 ret = comedi_check_chanlist(s, 1, &insn->chanspec);
880 if (ret < 0) {
881 ret = -EINVAL;
882 DPRINTK("bad chanspec\n");
883 goto out;
884 }
885
886 if (s->busy) {
887 ret = -EBUSY;
888 goto out;
889 }
890
891 s->busy = &parse_insn;
892 switch (insn->insn) {
893 case INSN_READ:
894 ret = s->insn_read(dev, s, insn, data);
895 break;
896 case INSN_WRITE:
897 maxdata = s->maxdata_list
898 ? s->maxdata_list[CR_CHAN(insn->chanspec)]
899 : s->maxdata;
900 for (i = 0; i < insn->n; ++i) {
901 if (data[i] > maxdata) {
902 ret = -EINVAL;
903 DPRINTK("bad data value(s)\n");
904 break;
905 }
906 }
907 if (ret == 0)
908 ret = s->insn_write(dev, s, insn, data);
909 break;
910 case INSN_BITS:
911 if (insn->n != 2) {
912 ret = -EINVAL;
913 break;
914 }
915 ret = s->insn_bits(dev, s, insn, data);
916 break;
917 case INSN_CONFIG:
918 ret = check_insn_config_length(insn, data);
919 if (ret)
920 break;
921 ret = s->insn_config(dev, s, insn, data);
922 break;
923 default:
924 ret = -EINVAL;
925 break;
926 }
927
928 s->busy = NULL;
929 }
930
931out:
932 return ret;
933}
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949static int do_insn_ioctl(struct comedi_device *dev,
950 struct comedi_insn __user *arg, void *file)
951{
952 struct comedi_insn insn;
953 unsigned int *data = NULL;
954 int ret = 0;
955
956 data = kmalloc(sizeof(unsigned int) * MAX_SAMPLES, GFP_KERNEL);
957 if (!data) {
958 ret = -ENOMEM;
959 goto error;
960 }
961
962 if (copy_from_user(&insn, arg, sizeof(struct comedi_insn))) {
963 ret = -EFAULT;
964 goto error;
965 }
966
967
968 if (insn.n > MAX_SAMPLES)
969 insn.n = MAX_SAMPLES;
970 if (insn.insn & INSN_MASK_WRITE) {
971 if (copy_from_user(data,
972 insn.data,
973 insn.n * sizeof(unsigned int))) {
974 ret = -EFAULT;
975 goto error;
976 }
977 }
978 ret = parse_insn(dev, &insn, data, file);
979 if (ret < 0)
980 goto error;
981 if (insn.insn & INSN_MASK_READ) {
982 if (copy_to_user(insn.data,
983 data,
984 insn.n * sizeof(unsigned int))) {
985 ret = -EFAULT;
986 goto error;
987 }
988 }
989 ret = insn.n;
990
991error:
992 kfree(data);
993
994 return ret;
995}
996
997static void comedi_set_subdevice_runflags(struct comedi_subdevice *s,
998 unsigned mask, unsigned bits)
999{
1000 unsigned long flags;
1001
1002 spin_lock_irqsave(&s->spin_lock, flags);
1003 s->runflags &= ~mask;
1004 s->runflags |= (bits & mask);
1005 spin_unlock_irqrestore(&s->spin_lock, flags);
1006}
1007
1008static int do_cmd_ioctl(struct comedi_device *dev,
1009 struct comedi_cmd __user *cmd, void *file)
1010{
1011 struct comedi_cmd user_cmd;
1012 struct comedi_subdevice *s;
1013 struct comedi_async *async;
1014 int ret = 0;
1015 unsigned int __user *chanlist_saver = NULL;
1016
1017 if (copy_from_user(&user_cmd, cmd, sizeof(struct comedi_cmd))) {
1018 DPRINTK("bad cmd address\n");
1019 return -EFAULT;
1020 }
1021
1022 chanlist_saver = user_cmd.chanlist;
1023
1024 if (user_cmd.subdev >= dev->n_subdevices) {
1025 DPRINTK("%d no such subdevice\n", user_cmd.subdev);
1026 return -ENODEV;
1027 }
1028
1029 s = dev->subdevices + user_cmd.subdev;
1030 async = s->async;
1031
1032 if (s->type == COMEDI_SUBD_UNUSED) {
1033 DPRINTK("%d not valid subdevice\n", user_cmd.subdev);
1034 return -EIO;
1035 }
1036
1037 if (!s->do_cmd || !s->do_cmdtest || !s->async) {
1038 DPRINTK("subdevice %i does not support commands\n",
1039 user_cmd.subdev);
1040 return -EIO;
1041 }
1042
1043
1044 if (s->lock && s->lock != file) {
1045 DPRINTK("subdevice locked\n");
1046 return -EACCES;
1047 }
1048
1049
1050 if (s->busy) {
1051 DPRINTK("subdevice busy\n");
1052 return -EBUSY;
1053 }
1054 s->busy = file;
1055
1056
1057 if (user_cmd.chanlist_len > s->len_chanlist) {
1058 DPRINTK("channel/gain list too long %u > %d\n",
1059 user_cmd.chanlist_len, s->len_chanlist);
1060 ret = -EINVAL;
1061 goto cleanup;
1062 }
1063
1064
1065 if (user_cmd.chanlist_len < 1) {
1066 DPRINTK("channel/gain list too short %u < 1\n",
1067 user_cmd.chanlist_len);
1068 ret = -EINVAL;
1069 goto cleanup;
1070 }
1071
1072 kfree(async->cmd.chanlist);
1073 async->cmd = user_cmd;
1074 async->cmd.data = NULL;
1075
1076 async->cmd.chanlist =
1077 kmalloc(async->cmd.chanlist_len * sizeof(int), GFP_KERNEL);
1078 if (!async->cmd.chanlist) {
1079 DPRINTK("allocation failed\n");
1080 ret = -ENOMEM;
1081 goto cleanup;
1082 }
1083
1084 if (copy_from_user(async->cmd.chanlist, user_cmd.chanlist,
1085 async->cmd.chanlist_len * sizeof(int))) {
1086 DPRINTK("fault reading chanlist\n");
1087 ret = -EFAULT;
1088 goto cleanup;
1089 }
1090
1091
1092 ret = comedi_check_chanlist(s,
1093 async->cmd.chanlist_len,
1094 async->cmd.chanlist);
1095 if (ret < 0) {
1096 DPRINTK("bad chanlist\n");
1097 goto cleanup;
1098 }
1099
1100 ret = s->do_cmdtest(dev, s, &async->cmd);
1101
1102 if (async->cmd.flags & TRIG_BOGUS || ret) {
1103 DPRINTK("test returned %d\n", ret);
1104 user_cmd = async->cmd;
1105
1106 user_cmd.chanlist = chanlist_saver;
1107 user_cmd.data = NULL;
1108 if (copy_to_user(cmd, &user_cmd, sizeof(struct comedi_cmd))) {
1109 DPRINTK("fault writing cmd\n");
1110 ret = -EFAULT;
1111 goto cleanup;
1112 }
1113 ret = -EAGAIN;
1114 goto cleanup;
1115 }
1116
1117 if (!async->prealloc_bufsz) {
1118 ret = -ENOMEM;
1119 DPRINTK("no buffer (?)\n");
1120 goto cleanup;
1121 }
1122
1123 comedi_reset_async_buf(async);
1124
1125 async->cb_mask =
1126 COMEDI_CB_EOA | COMEDI_CB_BLOCK | COMEDI_CB_ERROR |
1127 COMEDI_CB_OVERFLOW;
1128 if (async->cmd.flags & TRIG_WAKE_EOS)
1129 async->cb_mask |= COMEDI_CB_EOS;
1130
1131 comedi_set_subdevice_runflags(s, ~0, SRF_USER | SRF_RUNNING);
1132
1133 ret = s->do_cmd(dev, s);
1134 if (ret == 0)
1135 return 0;
1136
1137cleanup:
1138 do_become_nonbusy(dev, s);
1139
1140 return ret;
1141}
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158static int do_cmdtest_ioctl(struct comedi_device *dev,
1159 struct comedi_cmd __user *arg, void *file)
1160{
1161 struct comedi_cmd user_cmd;
1162 struct comedi_subdevice *s;
1163 int ret = 0;
1164 unsigned int *chanlist = NULL;
1165 unsigned int __user *chanlist_saver = NULL;
1166
1167 if (copy_from_user(&user_cmd, arg, sizeof(struct comedi_cmd))) {
1168 DPRINTK("bad cmd address\n");
1169 return -EFAULT;
1170 }
1171
1172 chanlist_saver = user_cmd.chanlist;
1173
1174 if (user_cmd.subdev >= dev->n_subdevices) {
1175 DPRINTK("%d no such subdevice\n", user_cmd.subdev);
1176 return -ENODEV;
1177 }
1178
1179 s = dev->subdevices + user_cmd.subdev;
1180 if (s->type == COMEDI_SUBD_UNUSED) {
1181 DPRINTK("%d not valid subdevice\n", user_cmd.subdev);
1182 return -EIO;
1183 }
1184
1185 if (!s->do_cmd || !s->do_cmdtest) {
1186 DPRINTK("subdevice %i does not support commands\n",
1187 user_cmd.subdev);
1188 return -EIO;
1189 }
1190
1191
1192 if (user_cmd.chanlist_len > s->len_chanlist) {
1193 DPRINTK("channel/gain list too long %d > %d\n",
1194 user_cmd.chanlist_len, s->len_chanlist);
1195 ret = -EINVAL;
1196 goto cleanup;
1197 }
1198
1199
1200 if (user_cmd.chanlist) {
1201 chanlist =
1202 kmalloc(user_cmd.chanlist_len * sizeof(int), GFP_KERNEL);
1203 if (!chanlist) {
1204 DPRINTK("allocation failed\n");
1205 ret = -ENOMEM;
1206 goto cleanup;
1207 }
1208
1209 if (copy_from_user(chanlist, user_cmd.chanlist,
1210 user_cmd.chanlist_len * sizeof(int))) {
1211 DPRINTK("fault reading chanlist\n");
1212 ret = -EFAULT;
1213 goto cleanup;
1214 }
1215
1216
1217 ret = comedi_check_chanlist(s, user_cmd.chanlist_len, chanlist);
1218 if (ret < 0) {
1219 DPRINTK("bad chanlist\n");
1220 goto cleanup;
1221 }
1222
1223 user_cmd.chanlist = chanlist;
1224 }
1225
1226 ret = s->do_cmdtest(dev, s, &user_cmd);
1227
1228
1229 user_cmd.chanlist = chanlist_saver;
1230
1231 if (copy_to_user(arg, &user_cmd, sizeof(struct comedi_cmd))) {
1232 DPRINTK("bad cmd address\n");
1233 ret = -EFAULT;
1234 goto cleanup;
1235 }
1236cleanup:
1237 kfree(chanlist);
1238
1239 return ret;
1240}
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257static int do_lock_ioctl(struct comedi_device *dev, unsigned int arg,
1258 void *file)
1259{
1260 int ret = 0;
1261 unsigned long flags;
1262 struct comedi_subdevice *s;
1263
1264 if (arg >= dev->n_subdevices)
1265 return -EINVAL;
1266 s = dev->subdevices + arg;
1267
1268 spin_lock_irqsave(&s->spin_lock, flags);
1269 if (s->busy || s->lock)
1270 ret = -EBUSY;
1271 else
1272 s->lock = file;
1273 spin_unlock_irqrestore(&s->spin_lock, flags);
1274
1275 if (ret < 0)
1276 return ret;
1277
1278#if 0
1279 if (s->lock_f)
1280 ret = s->lock_f(dev, s);
1281#endif
1282
1283 return ret;
1284}
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302static int do_unlock_ioctl(struct comedi_device *dev, unsigned int arg,
1303 void *file)
1304{
1305 struct comedi_subdevice *s;
1306
1307 if (arg >= dev->n_subdevices)
1308 return -EINVAL;
1309 s = dev->subdevices + arg;
1310
1311 if (s->busy)
1312 return -EBUSY;
1313
1314 if (s->lock && s->lock != file)
1315 return -EACCES;
1316
1317 if (s->lock == file) {
1318#if 0
1319 if (s->unlock)
1320 s->unlock(dev, s);
1321#endif
1322
1323 s->lock = NULL;
1324 }
1325
1326 return 0;
1327}
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343static int do_cancel_ioctl(struct comedi_device *dev, unsigned int arg,
1344 void *file)
1345{
1346 struct comedi_subdevice *s;
1347
1348 if (arg >= dev->n_subdevices)
1349 return -EINVAL;
1350 s = dev->subdevices + arg;
1351 if (s->async == NULL)
1352 return -EINVAL;
1353
1354 if (s->lock && s->lock != file)
1355 return -EACCES;
1356
1357 if (!s->busy)
1358 return 0;
1359
1360 if (s->busy != file)
1361 return -EBUSY;
1362
1363 return do_cancel(dev, s);
1364}
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380static int do_poll_ioctl(struct comedi_device *dev, unsigned int arg,
1381 void *file)
1382{
1383 struct comedi_subdevice *s;
1384
1385 if (arg >= dev->n_subdevices)
1386 return -EINVAL;
1387 s = dev->subdevices + arg;
1388
1389 if (s->lock && s->lock != file)
1390 return -EACCES;
1391
1392 if (!s->busy)
1393 return 0;
1394
1395 if (s->busy != file)
1396 return -EBUSY;
1397
1398 if (s->poll)
1399 return s->poll(dev, s);
1400
1401 return -EINVAL;
1402}
1403
1404static int do_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
1405{
1406 int ret = 0;
1407
1408 if ((comedi_get_subdevice_runflags(s) & SRF_RUNNING) && s->cancel)
1409 ret = s->cancel(dev, s);
1410
1411 do_become_nonbusy(dev, s);
1412
1413 return ret;
1414}
1415
1416static void comedi_unmap(struct vm_area_struct *area)
1417{
1418 struct comedi_async *async;
1419 struct comedi_device *dev;
1420
1421 async = area->vm_private_data;
1422 dev = async->subdevice->device;
1423
1424 mutex_lock(&dev->mutex);
1425 async->mmap_count--;
1426 mutex_unlock(&dev->mutex);
1427}
1428
1429static struct vm_operations_struct comedi_vm_ops = {
1430 .close = comedi_unmap,
1431};
1432
1433static int comedi_mmap(struct file *file, struct vm_area_struct *vma)
1434{
1435 const unsigned minor = iminor(file->f_dentry->d_inode);
1436 struct comedi_device_file_info *dev_file_info =
1437 comedi_get_device_file_info(minor);
1438 struct comedi_device *dev = dev_file_info->device;
1439 struct comedi_async *async = NULL;
1440 unsigned long start = vma->vm_start;
1441 unsigned long size;
1442 int n_pages;
1443 int i;
1444 int retval;
1445 struct comedi_subdevice *s;
1446
1447 mutex_lock(&dev->mutex);
1448 if (!dev->attached) {
1449 DPRINTK("no driver configured on comedi%i\n", dev->minor);
1450 retval = -ENODEV;
1451 goto done;
1452 }
1453 if (vma->vm_flags & VM_WRITE)
1454 s = comedi_get_write_subdevice(dev_file_info);
1455 else
1456 s = comedi_get_read_subdevice(dev_file_info);
1457
1458 if (s == NULL) {
1459 retval = -EINVAL;
1460 goto done;
1461 }
1462 async = s->async;
1463 if (async == NULL) {
1464 retval = -EINVAL;
1465 goto done;
1466 }
1467
1468 if (vma->vm_pgoff != 0) {
1469 DPRINTK("comedi: mmap() offset must be 0.\n");
1470 retval = -EINVAL;
1471 goto done;
1472 }
1473
1474 size = vma->vm_end - vma->vm_start;
1475 if (size > async->prealloc_bufsz) {
1476 retval = -EFAULT;
1477 goto done;
1478 }
1479 if (size & (~PAGE_MASK)) {
1480 retval = -EFAULT;
1481 goto done;
1482 }
1483
1484 n_pages = size >> PAGE_SHIFT;
1485 for (i = 0; i < n_pages; ++i) {
1486 if (remap_pfn_range(vma, start,
1487 page_to_pfn(virt_to_page
1488 (async->buf_page_list
1489 [i].virt_addr)), PAGE_SIZE,
1490 PAGE_SHARED)) {
1491 retval = -EAGAIN;
1492 goto done;
1493 }
1494 start += PAGE_SIZE;
1495 }
1496
1497 vma->vm_ops = &comedi_vm_ops;
1498 vma->vm_private_data = async;
1499
1500 async->mmap_count++;
1501
1502 retval = 0;
1503done:
1504 mutex_unlock(&dev->mutex);
1505 return retval;
1506}
1507
1508static unsigned int comedi_poll(struct file *file, poll_table * wait)
1509{
1510 unsigned int mask = 0;
1511 const unsigned minor = iminor(file->f_dentry->d_inode);
1512 struct comedi_device_file_info *dev_file_info =
1513 comedi_get_device_file_info(minor);
1514 struct comedi_device *dev = dev_file_info->device;
1515 struct comedi_subdevice *read_subdev;
1516 struct comedi_subdevice *write_subdev;
1517
1518 mutex_lock(&dev->mutex);
1519 if (!dev->attached) {
1520 DPRINTK("no driver configured on comedi%i\n", dev->minor);
1521 mutex_unlock(&dev->mutex);
1522 return 0;
1523 }
1524
1525 mask = 0;
1526 read_subdev = comedi_get_read_subdevice(dev_file_info);
1527 if (read_subdev) {
1528 poll_wait(file, &read_subdev->async->wait_head, wait);
1529 if (!read_subdev->busy
1530 || comedi_buf_read_n_available(read_subdev->async) > 0
1531 || !(comedi_get_subdevice_runflags(read_subdev) &
1532 SRF_RUNNING)) {
1533 mask |= POLLIN | POLLRDNORM;
1534 }
1535 }
1536 write_subdev = comedi_get_write_subdevice(dev_file_info);
1537 if (write_subdev) {
1538 poll_wait(file, &write_subdev->async->wait_head, wait);
1539 comedi_buf_write_alloc(write_subdev->async,
1540 write_subdev->async->prealloc_bufsz);
1541 if (!write_subdev->busy
1542 || !(comedi_get_subdevice_runflags(write_subdev) &
1543 SRF_RUNNING)
1544 || comedi_buf_write_n_allocated(write_subdev->async) >=
1545 bytes_per_sample(write_subdev->async->subdevice)) {
1546 mask |= POLLOUT | POLLWRNORM;
1547 }
1548 }
1549
1550 mutex_unlock(&dev->mutex);
1551 return mask;
1552}
1553
1554static ssize_t comedi_write(struct file *file, const char __user *buf,
1555 size_t nbytes, loff_t *offset)
1556{
1557 struct comedi_subdevice *s;
1558 struct comedi_async *async;
1559 int n, m, count = 0, retval = 0;
1560 DECLARE_WAITQUEUE(wait, current);
1561 const unsigned minor = iminor(file->f_dentry->d_inode);
1562 struct comedi_device_file_info *dev_file_info =
1563 comedi_get_device_file_info(minor);
1564 struct comedi_device *dev = dev_file_info->device;
1565
1566 if (!dev->attached) {
1567 DPRINTK("no driver configured on comedi%i\n", dev->minor);
1568 retval = -ENODEV;
1569 goto done;
1570 }
1571
1572 s = comedi_get_write_subdevice(dev_file_info);
1573 if (s == NULL) {
1574 retval = -EIO;
1575 goto done;
1576 }
1577 async = s->async;
1578
1579 if (!nbytes) {
1580 retval = 0;
1581 goto done;
1582 }
1583 if (!s->busy) {
1584 retval = 0;
1585 goto done;
1586 }
1587 if (s->busy != file) {
1588 retval = -EACCES;
1589 goto done;
1590 }
1591 add_wait_queue(&async->wait_head, &wait);
1592 while (nbytes > 0 && !retval) {
1593 set_current_state(TASK_INTERRUPTIBLE);
1594
1595 if (!(comedi_get_subdevice_runflags(s) & SRF_RUNNING)) {
1596 if (count == 0) {
1597 if (comedi_get_subdevice_runflags(s) &
1598 SRF_ERROR) {
1599 retval = -EPIPE;
1600 } else {
1601 retval = 0;
1602 }
1603 do_become_nonbusy(dev, s);
1604 }
1605 break;
1606 }
1607
1608 n = nbytes;
1609
1610 m = n;
1611 if (async->buf_write_ptr + m > async->prealloc_bufsz)
1612 m = async->prealloc_bufsz - async->buf_write_ptr;
1613 comedi_buf_write_alloc(async, async->prealloc_bufsz);
1614 if (m > comedi_buf_write_n_allocated(async))
1615 m = comedi_buf_write_n_allocated(async);
1616 if (m < n)
1617 n = m;
1618
1619 if (n == 0) {
1620 if (file->f_flags & O_NONBLOCK) {
1621 retval = -EAGAIN;
1622 break;
1623 }
1624 if (signal_pending(current)) {
1625 retval = -ERESTARTSYS;
1626 break;
1627 }
1628 schedule();
1629 if (!s->busy)
1630 break;
1631 if (s->busy != file) {
1632 retval = -EACCES;
1633 break;
1634 }
1635 continue;
1636 }
1637
1638 m = copy_from_user(async->prealloc_buf + async->buf_write_ptr,
1639 buf, n);
1640 if (m) {
1641 n -= m;
1642 retval = -EFAULT;
1643 }
1644 comedi_buf_write_free(async, n);
1645
1646 count += n;
1647 nbytes -= n;
1648
1649 buf += n;
1650 break;
1651 }
1652 set_current_state(TASK_RUNNING);
1653 remove_wait_queue(&async->wait_head, &wait);
1654
1655done:
1656 return count ? count : retval;
1657}
1658
1659static ssize_t comedi_read(struct file *file, char __user *buf, size_t nbytes,
1660 loff_t *offset)
1661{
1662 struct comedi_subdevice *s;
1663 struct comedi_async *async;
1664 int n, m, count = 0, retval = 0;
1665 DECLARE_WAITQUEUE(wait, current);
1666 const unsigned minor = iminor(file->f_dentry->d_inode);
1667 struct comedi_device_file_info *dev_file_info =
1668 comedi_get_device_file_info(minor);
1669 struct comedi_device *dev = dev_file_info->device;
1670
1671 if (!dev->attached) {
1672 DPRINTK("no driver configured on comedi%i\n", dev->minor);
1673 retval = -ENODEV;
1674 goto done;
1675 }
1676
1677 s = comedi_get_read_subdevice(dev_file_info);
1678 if (s == NULL) {
1679 retval = -EIO;
1680 goto done;
1681 }
1682 async = s->async;
1683 if (!nbytes) {
1684 retval = 0;
1685 goto done;
1686 }
1687 if (!s->busy) {
1688 retval = 0;
1689 goto done;
1690 }
1691 if (s->busy != file) {
1692 retval = -EACCES;
1693 goto done;
1694 }
1695
1696 add_wait_queue(&async->wait_head, &wait);
1697 while (nbytes > 0 && !retval) {
1698 set_current_state(TASK_INTERRUPTIBLE);
1699
1700 n = nbytes;
1701
1702 m = comedi_buf_read_n_available(async);
1703
1704 if (async->buf_read_ptr + m > async->prealloc_bufsz)
1705 m = async->prealloc_bufsz - async->buf_read_ptr;
1706
1707 if (m < n)
1708 n = m;
1709
1710 if (n == 0) {
1711 if (!(comedi_get_subdevice_runflags(s) & SRF_RUNNING)) {
1712 do_become_nonbusy(dev, s);
1713 if (comedi_get_subdevice_runflags(s) &
1714 SRF_ERROR) {
1715 retval = -EPIPE;
1716 } else {
1717 retval = 0;
1718 }
1719 break;
1720 }
1721 if (file->f_flags & O_NONBLOCK) {
1722 retval = -EAGAIN;
1723 break;
1724 }
1725 if (signal_pending(current)) {
1726 retval = -ERESTARTSYS;
1727 break;
1728 }
1729 schedule();
1730 if (!s->busy) {
1731 retval = 0;
1732 break;
1733 }
1734 if (s->busy != file) {
1735 retval = -EACCES;
1736 break;
1737 }
1738 continue;
1739 }
1740 m = copy_to_user(buf, async->prealloc_buf +
1741 async->buf_read_ptr, n);
1742 if (m) {
1743 n -= m;
1744 retval = -EFAULT;
1745 }
1746
1747 comedi_buf_read_alloc(async, n);
1748 comedi_buf_read_free(async, n);
1749
1750 count += n;
1751 nbytes -= n;
1752
1753 buf += n;
1754 break;
1755 }
1756 if (!(comedi_get_subdevice_runflags(s) & (SRF_ERROR | SRF_RUNNING)) &&
1757 async->buf_read_count - async->buf_write_count == 0) {
1758 do_become_nonbusy(dev, s);
1759 }
1760 set_current_state(TASK_RUNNING);
1761 remove_wait_queue(&async->wait_head, &wait);
1762
1763done:
1764 return count ? count : retval;
1765}
1766
1767
1768
1769
1770void do_become_nonbusy(struct comedi_device *dev, struct comedi_subdevice *s)
1771{
1772 struct comedi_async *async = s->async;
1773
1774 comedi_set_subdevice_runflags(s, SRF_RUNNING, 0);
1775 if (async) {
1776 comedi_reset_async_buf(async);
1777 async->inttrig = NULL;
1778 } else {
1779 printk(KERN_ERR
1780 "BUG: (?) do_become_nonbusy called with async=0\n");
1781 }
1782
1783 s->busy = NULL;
1784}
1785
1786static int comedi_open(struct inode *inode, struct file *file)
1787{
1788 const unsigned minor = iminor(inode);
1789 struct comedi_device_file_info *dev_file_info =
1790 comedi_get_device_file_info(minor);
1791 struct comedi_device *dev =
1792 dev_file_info ? dev_file_info->device : NULL;
1793
1794 if (dev == NULL) {
1795 DPRINTK("invalid minor number\n");
1796 return -ENODEV;
1797 }
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812 mutex_lock(&dev->mutex);
1813 if (dev->attached)
1814 goto ok;
1815 if (!capable(CAP_NET_ADMIN) && dev->in_request_module) {
1816 DPRINTK("in request module\n");
1817 mutex_unlock(&dev->mutex);
1818 return -ENODEV;
1819 }
1820 if (capable(CAP_NET_ADMIN) && dev->in_request_module)
1821 goto ok;
1822
1823 dev->in_request_module = 1;
1824
1825#ifdef CONFIG_KMOD
1826 mutex_unlock(&dev->mutex);
1827 request_module("char-major-%i-%i", COMEDI_MAJOR, dev->minor);
1828 mutex_lock(&dev->mutex);
1829#endif
1830
1831 dev->in_request_module = 0;
1832
1833 if (!dev->attached && !capable(CAP_NET_ADMIN)) {
1834 DPRINTK("not attached and not CAP_NET_ADMIN\n");
1835 mutex_unlock(&dev->mutex);
1836 return -ENODEV;
1837 }
1838ok:
1839 __module_get(THIS_MODULE);
1840
1841 if (dev->attached) {
1842 if (!try_module_get(dev->driver->module)) {
1843 module_put(THIS_MODULE);
1844 mutex_unlock(&dev->mutex);
1845 return -ENOSYS;
1846 }
1847 }
1848
1849 if (dev->attached && dev->use_count == 0 && dev->open) {
1850 int rc = dev->open(dev);
1851 if (rc < 0) {
1852 module_put(dev->driver->module);
1853 module_put(THIS_MODULE);
1854 mutex_unlock(&dev->mutex);
1855 return rc;
1856 }
1857 }
1858
1859 dev->use_count++;
1860
1861 mutex_unlock(&dev->mutex);
1862
1863 return 0;
1864}
1865
1866static int comedi_close(struct inode *inode, struct file *file)
1867{
1868 const unsigned minor = iminor(inode);
1869 struct comedi_device_file_info *dev_file_info =
1870 comedi_get_device_file_info(minor);
1871 struct comedi_device *dev = dev_file_info->device;
1872 struct comedi_subdevice *s = NULL;
1873 int i;
1874
1875 mutex_lock(&dev->mutex);
1876
1877 if (dev->subdevices) {
1878 for (i = 0; i < dev->n_subdevices; i++) {
1879 s = dev->subdevices + i;
1880
1881 if (s->busy == file)
1882 do_cancel(dev, s);
1883 if (s->lock == file)
1884 s->lock = NULL;
1885 }
1886 }
1887 if (dev->attached && dev->use_count == 1 && dev->close)
1888 dev->close(dev);
1889
1890 module_put(THIS_MODULE);
1891 if (dev->attached)
1892 module_put(dev->driver->module);
1893
1894 dev->use_count--;
1895
1896 mutex_unlock(&dev->mutex);
1897
1898 if (file->f_flags & FASYNC)
1899 comedi_fasync(-1, file, 0);
1900
1901 return 0;
1902}
1903
1904static int comedi_fasync(int fd, struct file *file, int on)
1905{
1906 const unsigned minor = iminor(file->f_dentry->d_inode);
1907 struct comedi_device_file_info *dev_file_info =
1908 comedi_get_device_file_info(minor);
1909
1910 struct comedi_device *dev = dev_file_info->device;
1911
1912 return fasync_helper(fd, file, on, &dev->async_queue);
1913}
1914
1915const struct file_operations comedi_fops = {
1916 .owner = THIS_MODULE,
1917 .unlocked_ioctl = comedi_unlocked_ioctl,
1918 .compat_ioctl = comedi_compat_ioctl,
1919 .open = comedi_open,
1920 .release = comedi_close,
1921 .read = comedi_read,
1922 .write = comedi_write,
1923 .mmap = comedi_mmap,
1924 .poll = comedi_poll,
1925 .fasync = comedi_fasync,
1926 .llseek = noop_llseek,
1927};
1928
1929struct class *comedi_class;
1930static struct cdev comedi_cdev;
1931
1932static void comedi_cleanup_legacy_minors(void)
1933{
1934 unsigned i;
1935
1936 for (i = 0; i < comedi_num_legacy_minors; i++)
1937 comedi_free_board_minor(i);
1938}
1939
1940static int __init comedi_init(void)
1941{
1942 int i;
1943 int retval;
1944
1945 printk(KERN_INFO "comedi: version " COMEDI_RELEASE
1946 " - http://www.comedi.org\n");
1947
1948 if (comedi_num_legacy_minors < 0 ||
1949 comedi_num_legacy_minors > COMEDI_NUM_BOARD_MINORS) {
1950 printk(KERN_ERR "comedi: error: invalid value for module "
1951 "parameter \"comedi_num_legacy_minors\". Valid values "
1952 "are 0 through %i.\n", COMEDI_NUM_BOARD_MINORS);
1953 return -EINVAL;
1954 }
1955
1956
1957
1958
1959
1960
1961 if (comedi_autoconfig == 0 && comedi_num_legacy_minors == 0)
1962 comedi_num_legacy_minors = 16;
1963
1964 memset(comedi_file_info_table, 0,
1965 sizeof(struct comedi_device_file_info *) * COMEDI_NUM_MINORS);
1966
1967 retval = register_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
1968 COMEDI_NUM_MINORS, "comedi");
1969 if (retval)
1970 return -EIO;
1971 cdev_init(&comedi_cdev, &comedi_fops);
1972 comedi_cdev.owner = THIS_MODULE;
1973 kobject_set_name(&comedi_cdev.kobj, "comedi");
1974 if (cdev_add(&comedi_cdev, MKDEV(COMEDI_MAJOR, 0), COMEDI_NUM_MINORS)) {
1975 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
1976 COMEDI_NUM_MINORS);
1977 return -EIO;
1978 }
1979 comedi_class = class_create(THIS_MODULE, "comedi");
1980 if (IS_ERR(comedi_class)) {
1981 printk(KERN_ERR "comedi: failed to create class");
1982 cdev_del(&comedi_cdev);
1983 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
1984 COMEDI_NUM_MINORS);
1985 return PTR_ERR(comedi_class);
1986 }
1987
1988
1989 comedi_proc_init();
1990
1991
1992 for (i = 0; i < comedi_num_legacy_minors; i++) {
1993 int minor;
1994 minor = comedi_alloc_board_minor(NULL);
1995 if (minor < 0) {
1996 comedi_cleanup_legacy_minors();
1997 cdev_del(&comedi_cdev);
1998 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
1999 COMEDI_NUM_MINORS);
2000 return minor;
2001 }
2002 }
2003
2004 return 0;
2005}
2006
2007static void __exit comedi_cleanup(void)
2008{
2009 int i;
2010
2011 comedi_cleanup_legacy_minors();
2012 for (i = 0; i < COMEDI_NUM_MINORS; ++i)
2013 BUG_ON(comedi_file_info_table[i]);
2014
2015 class_destroy(comedi_class);
2016 cdev_del(&comedi_cdev);
2017 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0), COMEDI_NUM_MINORS);
2018
2019 comedi_proc_cleanup();
2020}
2021
2022module_init(comedi_init);
2023module_exit(comedi_cleanup);
2024
2025void comedi_error(const struct comedi_device *dev, const char *s)
2026{
2027 printk(KERN_ERR "comedi%d: %s: %s\n", dev->minor,
2028 dev->driver->driver_name, s);
2029}
2030EXPORT_SYMBOL(comedi_error);
2031
2032void comedi_event(struct comedi_device *dev, struct comedi_subdevice *s)
2033{
2034 struct comedi_async *async = s->async;
2035 unsigned runflags = 0;
2036 unsigned runflags_mask = 0;
2037
2038
2039
2040 if ((comedi_get_subdevice_runflags(s) & SRF_RUNNING) == 0)
2041 return;
2042
2043 if (s->
2044 async->events & (COMEDI_CB_EOA | COMEDI_CB_ERROR |
2045 COMEDI_CB_OVERFLOW)) {
2046 runflags_mask |= SRF_RUNNING;
2047 }
2048
2049
2050 if (s->async->events & (COMEDI_CB_ERROR | COMEDI_CB_OVERFLOW)) {
2051 runflags_mask |= SRF_ERROR;
2052 runflags |= SRF_ERROR;
2053 }
2054 if (runflags_mask) {
2055
2056 comedi_set_subdevice_runflags(s, runflags_mask, runflags);
2057 }
2058
2059 if (async->cb_mask & s->async->events) {
2060 if (comedi_get_subdevice_runflags(s) & SRF_USER) {
2061 wake_up_interruptible(&async->wait_head);
2062 if (s->subdev_flags & SDF_CMD_READ)
2063 kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
2064 if (s->subdev_flags & SDF_CMD_WRITE)
2065 kill_fasync(&dev->async_queue, SIGIO, POLL_OUT);
2066 } else {
2067 if (async->cb_func)
2068 async->cb_func(s->async->events, async->cb_arg);
2069 }
2070 }
2071 s->async->events = 0;
2072}
2073EXPORT_SYMBOL(comedi_event);
2074
2075unsigned comedi_get_subdevice_runflags(struct comedi_subdevice *s)
2076{
2077 unsigned long flags;
2078 unsigned runflags;
2079
2080 spin_lock_irqsave(&s->spin_lock, flags);
2081 runflags = s->runflags;
2082 spin_unlock_irqrestore(&s->spin_lock, flags);
2083 return runflags;
2084}
2085EXPORT_SYMBOL(comedi_get_subdevice_runflags);
2086
2087static int is_device_busy(struct comedi_device *dev)
2088{
2089 struct comedi_subdevice *s;
2090 int i;
2091
2092 if (!dev->attached)
2093 return 0;
2094
2095 for (i = 0; i < dev->n_subdevices; i++) {
2096 s = dev->subdevices + i;
2097 if (s->busy)
2098 return 1;
2099 if (s->async && s->async->mmap_count)
2100 return 1;
2101 }
2102
2103 return 0;
2104}
2105
2106static void comedi_device_init(struct comedi_device *dev)
2107{
2108 memset(dev, 0, sizeof(struct comedi_device));
2109 spin_lock_init(&dev->spinlock);
2110 mutex_init(&dev->mutex);
2111 dev->minor = -1;
2112}
2113
2114static void comedi_device_cleanup(struct comedi_device *dev)
2115{
2116 if (dev == NULL)
2117 return;
2118 mutex_lock(&dev->mutex);
2119 comedi_device_detach(dev);
2120 mutex_unlock(&dev->mutex);
2121 mutex_destroy(&dev->mutex);
2122}
2123
2124int comedi_alloc_board_minor(struct device *hardware_device)
2125{
2126 unsigned long flags;
2127 struct comedi_device_file_info *info;
2128 struct device *csdev;
2129 unsigned i;
2130 int retval;
2131
2132 info = kzalloc(sizeof(struct comedi_device_file_info), GFP_KERNEL);
2133 if (info == NULL)
2134 return -ENOMEM;
2135 info->device = kzalloc(sizeof(struct comedi_device), GFP_KERNEL);
2136 if (info->device == NULL) {
2137 kfree(info);
2138 return -ENOMEM;
2139 }
2140 comedi_device_init(info->device);
2141 spin_lock_irqsave(&comedi_file_info_table_lock, flags);
2142 for (i = 0; i < COMEDI_NUM_BOARD_MINORS; ++i) {
2143 if (comedi_file_info_table[i] == NULL) {
2144 comedi_file_info_table[i] = info;
2145 break;
2146 }
2147 }
2148 spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);
2149 if (i == COMEDI_NUM_BOARD_MINORS) {
2150 comedi_device_cleanup(info->device);
2151 kfree(info->device);
2152 kfree(info);
2153 printk(KERN_ERR
2154 "comedi: error: "
2155 "ran out of minor numbers for board device files.\n");
2156 return -EBUSY;
2157 }
2158 info->device->minor = i;
2159 csdev = COMEDI_DEVICE_CREATE(comedi_class, NULL,
2160 MKDEV(COMEDI_MAJOR, i), NULL,
2161 hardware_device, "comedi%i", i);
2162 if (!IS_ERR(csdev))
2163 info->device->class_dev = csdev;
2164 dev_set_drvdata(csdev, info);
2165 retval = device_create_file(csdev, &dev_attr_max_read_buffer_kb);
2166 if (retval) {
2167 printk(KERN_ERR
2168 "comedi: "
2169 "failed to create sysfs attribute file \"%s\".\n",
2170 dev_attr_max_read_buffer_kb.attr.name);
2171 comedi_free_board_minor(i);
2172 return retval;
2173 }
2174 retval = device_create_file(csdev, &dev_attr_read_buffer_kb);
2175 if (retval) {
2176 printk(KERN_ERR
2177 "comedi: "
2178 "failed to create sysfs attribute file \"%s\".\n",
2179 dev_attr_read_buffer_kb.attr.name);
2180 comedi_free_board_minor(i);
2181 return retval;
2182 }
2183 retval = device_create_file(csdev, &dev_attr_max_write_buffer_kb);
2184 if (retval) {
2185 printk(KERN_ERR
2186 "comedi: "
2187 "failed to create sysfs attribute file \"%s\".\n",
2188 dev_attr_max_write_buffer_kb.attr.name);
2189 comedi_free_board_minor(i);
2190 return retval;
2191 }
2192 retval = device_create_file(csdev, &dev_attr_write_buffer_kb);
2193 if (retval) {
2194 printk(KERN_ERR
2195 "comedi: "
2196 "failed to create sysfs attribute file \"%s\".\n",
2197 dev_attr_write_buffer_kb.attr.name);
2198 comedi_free_board_minor(i);
2199 return retval;
2200 }
2201 return i;
2202}
2203
2204void comedi_free_board_minor(unsigned minor)
2205{
2206 unsigned long flags;
2207 struct comedi_device_file_info *info;
2208
2209 BUG_ON(minor >= COMEDI_NUM_BOARD_MINORS);
2210 spin_lock_irqsave(&comedi_file_info_table_lock, flags);
2211 info = comedi_file_info_table[minor];
2212 comedi_file_info_table[minor] = NULL;
2213 spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);
2214
2215 if (info) {
2216 struct comedi_device *dev = info->device;
2217 if (dev) {
2218 if (dev->class_dev) {
2219 device_destroy(comedi_class,
2220 MKDEV(COMEDI_MAJOR, dev->minor));
2221 }
2222 comedi_device_cleanup(dev);
2223 kfree(dev);
2224 }
2225 kfree(info);
2226 }
2227}
2228
2229int comedi_alloc_subdevice_minor(struct comedi_device *dev,
2230 struct comedi_subdevice *s)
2231{
2232 unsigned long flags;
2233 struct comedi_device_file_info *info;
2234 struct device *csdev;
2235 unsigned i;
2236 int retval;
2237
2238 info = kmalloc(sizeof(struct comedi_device_file_info), GFP_KERNEL);
2239 if (info == NULL)
2240 return -ENOMEM;
2241 info->device = dev;
2242 info->read_subdevice = s;
2243 info->write_subdevice = s;
2244 spin_lock_irqsave(&comedi_file_info_table_lock, flags);
2245 for (i = COMEDI_FIRST_SUBDEVICE_MINOR; i < COMEDI_NUM_MINORS; ++i) {
2246 if (comedi_file_info_table[i] == NULL) {
2247 comedi_file_info_table[i] = info;
2248 break;
2249 }
2250 }
2251 spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);
2252 if (i == COMEDI_NUM_MINORS) {
2253 kfree(info);
2254 printk(KERN_ERR
2255 "comedi: error: "
2256 "ran out of minor numbers for board device files.\n");
2257 return -EBUSY;
2258 }
2259 s->minor = i;
2260 csdev = COMEDI_DEVICE_CREATE(comedi_class, dev->class_dev,
2261 MKDEV(COMEDI_MAJOR, i), NULL, NULL,
2262 "comedi%i_subd%i", dev->minor,
2263 (int)(s - dev->subdevices));
2264 if (!IS_ERR(csdev))
2265 s->class_dev = csdev;
2266 dev_set_drvdata(csdev, info);
2267 retval = device_create_file(csdev, &dev_attr_max_read_buffer_kb);
2268 if (retval) {
2269 printk(KERN_ERR
2270 "comedi: "
2271 "failed to create sysfs attribute file \"%s\".\n",
2272 dev_attr_max_read_buffer_kb.attr.name);
2273 comedi_free_subdevice_minor(s);
2274 return retval;
2275 }
2276 retval = device_create_file(csdev, &dev_attr_read_buffer_kb);
2277 if (retval) {
2278 printk(KERN_ERR
2279 "comedi: "
2280 "failed to create sysfs attribute file \"%s\".\n",
2281 dev_attr_read_buffer_kb.attr.name);
2282 comedi_free_subdevice_minor(s);
2283 return retval;
2284 }
2285 retval = device_create_file(csdev, &dev_attr_max_write_buffer_kb);
2286 if (retval) {
2287 printk(KERN_ERR
2288 "comedi: "
2289 "failed to create sysfs attribute file \"%s\".\n",
2290 dev_attr_max_write_buffer_kb.attr.name);
2291 comedi_free_subdevice_minor(s);
2292 return retval;
2293 }
2294 retval = device_create_file(csdev, &dev_attr_write_buffer_kb);
2295 if (retval) {
2296 printk(KERN_ERR
2297 "comedi: "
2298 "failed to create sysfs attribute file \"%s\".\n",
2299 dev_attr_write_buffer_kb.attr.name);
2300 comedi_free_subdevice_minor(s);
2301 return retval;
2302 }
2303 return i;
2304}
2305
2306void comedi_free_subdevice_minor(struct comedi_subdevice *s)
2307{
2308 unsigned long flags;
2309 struct comedi_device_file_info *info;
2310
2311 if (s == NULL)
2312 return;
2313 if (s->minor < 0)
2314 return;
2315
2316 BUG_ON(s->minor >= COMEDI_NUM_MINORS);
2317 BUG_ON(s->minor < COMEDI_FIRST_SUBDEVICE_MINOR);
2318
2319 spin_lock_irqsave(&comedi_file_info_table_lock, flags);
2320 info = comedi_file_info_table[s->minor];
2321 comedi_file_info_table[s->minor] = NULL;
2322 spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);
2323
2324 if (s->class_dev) {
2325 device_destroy(comedi_class, MKDEV(COMEDI_MAJOR, s->minor));
2326 s->class_dev = NULL;
2327 }
2328 kfree(info);
2329}
2330
2331struct comedi_device_file_info *comedi_get_device_file_info(unsigned minor)
2332{
2333 unsigned long flags;
2334 struct comedi_device_file_info *info;
2335
2336 BUG_ON(minor >= COMEDI_NUM_MINORS);
2337 spin_lock_irqsave(&comedi_file_info_table_lock, flags);
2338 info = comedi_file_info_table[minor];
2339 spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);
2340 return info;
2341}
2342EXPORT_SYMBOL_GPL(comedi_get_device_file_info);
2343
2344static int resize_async_buffer(struct comedi_device *dev,
2345 struct comedi_subdevice *s,
2346 struct comedi_async *async, unsigned new_size)
2347{
2348 int retval;
2349
2350 if (new_size > async->max_bufsize)
2351 return -EPERM;
2352
2353 if (s->busy) {
2354 DPRINTK("subdevice is busy, cannot resize buffer\n");
2355 return -EBUSY;
2356 }
2357 if (async->mmap_count) {
2358 DPRINTK("subdevice is mmapped, cannot resize buffer\n");
2359 return -EBUSY;
2360 }
2361
2362 if (!async->prealloc_buf)
2363 return -EINVAL;
2364
2365
2366
2367 new_size = (new_size + PAGE_SIZE - 1) & PAGE_MASK;
2368
2369 retval = comedi_buf_alloc(dev, s, new_size);
2370 if (retval < 0)
2371 return retval;
2372
2373 if (s->buf_change) {
2374 retval = s->buf_change(dev, s, new_size);
2375 if (retval < 0)
2376 return retval;
2377 }
2378
2379 DPRINTK("comedi%i subd %d buffer resized to %i bytes\n",
2380 dev->minor, (int)(s - dev->subdevices), async->prealloc_bufsz);
2381 return 0;
2382}
2383
2384
2385
2386static const unsigned bytes_per_kibi = 1024;
2387
2388static ssize_t show_max_read_buffer_kb(struct device *dev,
2389 struct device_attribute *attr, char *buf)
2390{
2391 ssize_t retval;
2392 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2393 unsigned max_buffer_size_kb = 0;
2394 struct comedi_subdevice *const read_subdevice =
2395 comedi_get_read_subdevice(info);
2396
2397 mutex_lock(&info->device->mutex);
2398 if (read_subdevice &&
2399 (read_subdevice->subdev_flags & SDF_CMD_READ) &&
2400 read_subdevice->async) {
2401 max_buffer_size_kb = read_subdevice->async->max_bufsize /
2402 bytes_per_kibi;
2403 }
2404 retval = snprintf(buf, PAGE_SIZE, "%i\n", max_buffer_size_kb);
2405 mutex_unlock(&info->device->mutex);
2406
2407 return retval;
2408}
2409
2410static ssize_t store_max_read_buffer_kb(struct device *dev,
2411 struct device_attribute *attr,
2412 const char *buf, size_t count)
2413{
2414 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2415 unsigned long new_max_size_kb;
2416 uint64_t new_max_size;
2417 struct comedi_subdevice *const read_subdevice =
2418 comedi_get_read_subdevice(info);
2419
2420 if (strict_strtoul(buf, 10, &new_max_size_kb))
2421 return -EINVAL;
2422 if (new_max_size_kb != (uint32_t) new_max_size_kb)
2423 return -EINVAL;
2424 new_max_size = ((uint64_t) new_max_size_kb) * bytes_per_kibi;
2425 if (new_max_size != (uint32_t) new_max_size)
2426 return -EINVAL;
2427
2428 mutex_lock(&info->device->mutex);
2429 if (read_subdevice == NULL ||
2430 (read_subdevice->subdev_flags & SDF_CMD_READ) == 0 ||
2431 read_subdevice->async == NULL) {
2432 mutex_unlock(&info->device->mutex);
2433 return -EINVAL;
2434 }
2435 read_subdevice->async->max_bufsize = new_max_size;
2436 mutex_unlock(&info->device->mutex);
2437
2438 return count;
2439}
2440
2441static struct device_attribute dev_attr_max_read_buffer_kb = {
2442 .attr = {
2443 .name = "max_read_buffer_kb",
2444 .mode = S_IRUGO | S_IWUSR},
2445 .show = &show_max_read_buffer_kb,
2446 .store = &store_max_read_buffer_kb
2447};
2448
2449static ssize_t show_read_buffer_kb(struct device *dev,
2450 struct device_attribute *attr, char *buf)
2451{
2452 ssize_t retval;
2453 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2454 unsigned buffer_size_kb = 0;
2455 struct comedi_subdevice *const read_subdevice =
2456 comedi_get_read_subdevice(info);
2457
2458 mutex_lock(&info->device->mutex);
2459 if (read_subdevice &&
2460 (read_subdevice->subdev_flags & SDF_CMD_READ) &&
2461 read_subdevice->async) {
2462 buffer_size_kb = read_subdevice->async->prealloc_bufsz /
2463 bytes_per_kibi;
2464 }
2465 retval = snprintf(buf, PAGE_SIZE, "%i\n", buffer_size_kb);
2466 mutex_unlock(&info->device->mutex);
2467
2468 return retval;
2469}
2470
2471static ssize_t store_read_buffer_kb(struct device *dev,
2472 struct device_attribute *attr,
2473 const char *buf, size_t count)
2474{
2475 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2476 unsigned long new_size_kb;
2477 uint64_t new_size;
2478 int retval;
2479 struct comedi_subdevice *const read_subdevice =
2480 comedi_get_read_subdevice(info);
2481
2482 if (strict_strtoul(buf, 10, &new_size_kb))
2483 return -EINVAL;
2484 if (new_size_kb != (uint32_t) new_size_kb)
2485 return -EINVAL;
2486 new_size = ((uint64_t) new_size_kb) * bytes_per_kibi;
2487 if (new_size != (uint32_t) new_size)
2488 return -EINVAL;
2489
2490 mutex_lock(&info->device->mutex);
2491 if (read_subdevice == NULL ||
2492 (read_subdevice->subdev_flags & SDF_CMD_READ) == 0 ||
2493 read_subdevice->async == NULL) {
2494 mutex_unlock(&info->device->mutex);
2495 return -EINVAL;
2496 }
2497 retval = resize_async_buffer(info->device, read_subdevice,
2498 read_subdevice->async, new_size);
2499 mutex_unlock(&info->device->mutex);
2500
2501 if (retval < 0)
2502 return retval;
2503 return count;
2504}
2505
2506static struct device_attribute dev_attr_read_buffer_kb = {
2507 .attr = {
2508 .name = "read_buffer_kb",
2509 .mode = S_IRUGO | S_IWUSR | S_IWGRP},
2510 .show = &show_read_buffer_kb,
2511 .store = &store_read_buffer_kb
2512};
2513
2514static ssize_t show_max_write_buffer_kb(struct device *dev,
2515 struct device_attribute *attr,
2516 char *buf)
2517{
2518 ssize_t retval;
2519 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2520 unsigned max_buffer_size_kb = 0;
2521 struct comedi_subdevice *const write_subdevice =
2522 comedi_get_write_subdevice(info);
2523
2524 mutex_lock(&info->device->mutex);
2525 if (write_subdevice &&
2526 (write_subdevice->subdev_flags & SDF_CMD_WRITE) &&
2527 write_subdevice->async) {
2528 max_buffer_size_kb = write_subdevice->async->max_bufsize /
2529 bytes_per_kibi;
2530 }
2531 retval = snprintf(buf, PAGE_SIZE, "%i\n", max_buffer_size_kb);
2532 mutex_unlock(&info->device->mutex);
2533
2534 return retval;
2535}
2536
2537static ssize_t store_max_write_buffer_kb(struct device *dev,
2538 struct device_attribute *attr,
2539 const char *buf, size_t count)
2540{
2541 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2542 unsigned long new_max_size_kb;
2543 uint64_t new_max_size;
2544 struct comedi_subdevice *const write_subdevice =
2545 comedi_get_write_subdevice(info);
2546
2547 if (strict_strtoul(buf, 10, &new_max_size_kb))
2548 return -EINVAL;
2549 if (new_max_size_kb != (uint32_t) new_max_size_kb)
2550 return -EINVAL;
2551 new_max_size = ((uint64_t) new_max_size_kb) * bytes_per_kibi;
2552 if (new_max_size != (uint32_t) new_max_size)
2553 return -EINVAL;
2554
2555 mutex_lock(&info->device->mutex);
2556 if (write_subdevice == NULL ||
2557 (write_subdevice->subdev_flags & SDF_CMD_WRITE) == 0 ||
2558 write_subdevice->async == NULL) {
2559 mutex_unlock(&info->device->mutex);
2560 return -EINVAL;
2561 }
2562 write_subdevice->async->max_bufsize = new_max_size;
2563 mutex_unlock(&info->device->mutex);
2564
2565 return count;
2566}
2567
2568static struct device_attribute dev_attr_max_write_buffer_kb = {
2569 .attr = {
2570 .name = "max_write_buffer_kb",
2571 .mode = S_IRUGO | S_IWUSR},
2572 .show = &show_max_write_buffer_kb,
2573 .store = &store_max_write_buffer_kb
2574};
2575
2576static ssize_t show_write_buffer_kb(struct device *dev,
2577 struct device_attribute *attr, char *buf)
2578{
2579 ssize_t retval;
2580 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2581 unsigned buffer_size_kb = 0;
2582 struct comedi_subdevice *const write_subdevice =
2583 comedi_get_write_subdevice(info);
2584
2585 mutex_lock(&info->device->mutex);
2586 if (write_subdevice &&
2587 (write_subdevice->subdev_flags & SDF_CMD_WRITE) &&
2588 write_subdevice->async) {
2589 buffer_size_kb = write_subdevice->async->prealloc_bufsz /
2590 bytes_per_kibi;
2591 }
2592 retval = snprintf(buf, PAGE_SIZE, "%i\n", buffer_size_kb);
2593 mutex_unlock(&info->device->mutex);
2594
2595 return retval;
2596}
2597
2598static ssize_t store_write_buffer_kb(struct device *dev,
2599 struct device_attribute *attr,
2600 const char *buf, size_t count)
2601{
2602 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2603 unsigned long new_size_kb;
2604 uint64_t new_size;
2605 int retval;
2606 struct comedi_subdevice *const write_subdevice =
2607 comedi_get_write_subdevice(info);
2608
2609 if (strict_strtoul(buf, 10, &new_size_kb))
2610 return -EINVAL;
2611 if (new_size_kb != (uint32_t) new_size_kb)
2612 return -EINVAL;
2613 new_size = ((uint64_t) new_size_kb) * bytes_per_kibi;
2614 if (new_size != (uint32_t) new_size)
2615 return -EINVAL;
2616
2617 mutex_lock(&info->device->mutex);
2618 if (write_subdevice == NULL ||
2619 (write_subdevice->subdev_flags & SDF_CMD_WRITE) == 0 ||
2620 write_subdevice->async == NULL) {
2621 mutex_unlock(&info->device->mutex);
2622 return -EINVAL;
2623 }
2624 retval = resize_async_buffer(info->device, write_subdevice,
2625 write_subdevice->async, new_size);
2626 mutex_unlock(&info->device->mutex);
2627
2628 if (retval < 0)
2629 return retval;
2630 return count;
2631}
2632
2633static struct device_attribute dev_attr_write_buffer_kb = {
2634 .attr = {
2635 .name = "write_buffer_kb",
2636 .mode = S_IRUGO | S_IWUSR | S_IWGRP},
2637 .show = &show_write_buffer_kb,
2638 .store = &store_write_buffer_kb
2639};
2640
