projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Staging: comedi: fix mmap_count
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / comedi / comedi_fops.c
CommitLineData
ed9eccbe
DS		 1/*
2 comedi/comedi_fops.c
3 comedi kernel module
4
5 COMEDI - Linux Control and Measurement Device Interface
6 Copyright (C) 1997-2000 David A. Schleef <ds@schleef.org>
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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>
883db3d9 47#include <linux/stat.h>
ed9eccbe 48
476b8477
GKH		 49#include <linux/io.h>
50#include <linux/uaccess.h>
ed9eccbe 51
242e7ad9 52#include "internal.h"
ed9eccbe
DS		 53
54MODULE_AUTHOR("http://www.comedi.org");
55MODULE_DESCRIPTION("Comedi core module");
56MODULE_LICENSE("GPL");
57
58#ifdef CONFIG_COMEDI_DEBUG
59int comedi_debug;
18736438 60EXPORT_SYMBOL(comedi_debug);
ed9eccbe
DS		 61module_param(comedi_debug, int, 0644);
62#endif
63
6a9d7a21
IA		 64int comedi_autoconfig = 1;
65module_param(comedi_autoconfig, bool, 0444);
66
92d0127c 67static int comedi_num_legacy_minors;
1dd33ab8
BP		 68module_param(comedi_num_legacy_minors, int, 0444);
69
ed9eccbe 70static DEFINE_SPINLOCK(comedi_file_info_table_lock);
476b8477 71static struct comedi_device_file_info
0a85b6f0 72*comedi_file_info_table[COMEDI_NUM_MINORS];
476b8477 73
0a85b6f0 74static int do_devconfig_ioctl(struct comedi_device *dev,
92d0127c
GKH		 75 struct comedi_devconfig __user *arg);
76static int do_bufconfig_ioctl(struct comedi_device *dev,
77 struct comedi_bufconfig __user *arg);
0a85b6f0 78static int do_devinfo_ioctl(struct comedi_device *dev,
92d0127c
GKH		 79 struct comedi_devinfo __user *arg,
80 struct file *file);
0a85b6f0 81static int do_subdinfo_ioctl(struct comedi_device *dev,
92d0127c 82 struct comedi_subdinfo __user *arg, void *file);
0a85b6f0 83static int do_chaninfo_ioctl(struct comedi_device *dev,
92d0127c
GKH		 84 struct comedi_chaninfo __user *arg);
85static int do_bufinfo_ioctl(struct comedi_device *dev,
53fa827e 86 struct comedi_bufinfo __user *arg, void *file);
92d0127c
GKH		 87static int do_cmd_ioctl(struct comedi_device *dev,
88 struct comedi_cmd __user *arg, void *file);
0a85b6f0
MT		 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);
92d0127c
GKH		 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);
0a85b6f0
MT		 101static int do_poll_ioctl(struct comedi_device *dev, unsigned int subd,
102 void *file);
71b5f4f1 103
f5283a4b 104static void do_become_nonbusy(struct comedi_device *dev,
0a85b6f0 105 struct comedi_subdevice *s);
34c43922 106static int do_cancel(struct comedi_device *dev, struct comedi_subdevice *s);
ed9eccbe
DS		 107
108static int comedi_fasync(int fd, struct file *file, int on);
109
71b5f4f1 110static int is_device_busy(struct comedi_device *dev);
883db3d9
FMH		 111static int resize_async_buffer(struct comedi_device *dev,
112 struct comedi_subdevice *s,
113 struct comedi_async *async, unsigned new_size);
114
115/* declarations for sysfs attribute files */
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;
ed9eccbe 120
ed9eccbe 121static long comedi_unlocked_ioctl(struct file *file, unsigned int cmd,
476b8477 122 unsigned long arg)
ed9eccbe
DS		 123{
124 const unsigned minor = iminor(file->f_dentry->d_inode);
476b8477
GKH		 125 struct comedi_device_file_info *dev_file_info =
126 comedi_get_device_file_info(minor);
71b5f4f1 127 struct comedi_device *dev;
ed9eccbe
DS		 128 int rc;
129
53b670a7
FMH		 130 if (dev_file_info == NULL || dev_file_info->device == NULL)
131 return -ENODEV;
132 dev = dev_file_info->device;
133
ed9eccbe
DS		 134 mutex_lock(&dev->mutex);
135
136 /* Device config is special, because it must work on
137 * an unconfigured device. */
138 if (cmd == COMEDI_DEVCONFIG) {
92d0127c
GKH		 139 rc = do_devconfig_ioctl(dev,
140 (struct comedi_devconfig __user *)arg);
ed9eccbe
DS		 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:
92d0127c
GKH		 152 rc = do_bufconfig_ioctl(dev,
153 (struct comedi_bufconfig __user *)arg);
ed9eccbe
DS		 154 break;
155 case COMEDI_DEVINFO:
92d0127c
GKH		 156 rc = do_devinfo_ioctl(dev, (struct comedi_devinfo __user *)arg,
157 file);
ed9eccbe
DS		 158 break;
159 case COMEDI_SUBDINFO:
92d0127c
GKH		 160 rc = do_subdinfo_ioctl(dev,
161 (struct comedi_subdinfo __user *)arg,
162 file);
ed9eccbe
DS		 163 break;
164 case COMEDI_CHANINFO:
92d0127c 165 rc = do_chaninfo_ioctl(dev, (void __user *)arg);
ed9eccbe
DS		 166 break;
167 case COMEDI_RANGEINFO:
92d0127c 168 rc = do_rangeinfo_ioctl(dev, (void __user *)arg);
ed9eccbe
DS		 169 break;
170 case COMEDI_BUFINFO:
92d0127c 171 rc = do_bufinfo_ioctl(dev,
53fa827e
IA		 172 (struct comedi_bufinfo __user *)arg,
173 file);
ed9eccbe
DS		 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:
92d0127c 185 rc = do_cmd_ioctl(dev, (struct comedi_cmd __user *)arg, file);
ed9eccbe
DS		 186 break;
187 case COMEDI_CMDTEST:
92d0127c
GKH		 188 rc = do_cmdtest_ioctl(dev, (struct comedi_cmd __user *)arg,
189 file);
ed9eccbe
DS		 190 break;
191 case COMEDI_INSNLIST:
92d0127c
GKH		 192 rc = do_insnlist_ioctl(dev,
193 (struct comedi_insnlist __user *)arg,
194 file);
ed9eccbe
DS		 195 break;
196 case COMEDI_INSN:
92d0127c
GKH		 197 rc = do_insn_ioctl(dev, (struct comedi_insn __user *)arg,
198 file);
ed9eccbe
DS		 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
476b8477 208done:
ed9eccbe
DS		 209 mutex_unlock(&dev->mutex);
210 return rc;
211}
212
213/*
214 COMEDI_DEVCONFIG
215 device config ioctl
216
217 arg:
218 pointer to devconfig structure
219
220 reads:
221 devconfig structure at arg
222
223 writes:
224 none
225*/
0a85b6f0 226static int do_devconfig_ioctl(struct comedi_device *dev,
92d0127c 227 struct comedi_devconfig __user *arg)
ed9eccbe 228{
0707bb04 229 struct comedi_devconfig it;
ed9eccbe
DS		 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;
476b8477 240 if (dev->attached) {
ed9eccbe
DS		 241 struct module *driver_module = dev->driver->module;
242 comedi_device_detach(dev);
243 module_put(driver_module);
244 }
245 return 0;
246 }
247
0707bb04 248 if (copy_from_user(&it, arg, sizeof(struct comedi_devconfig)))
ed9eccbe
DS		 249 return -EFAULT;
250
251 it.board_name[COMEDI_NAMELEN - 1] = 0;
252
253 if (comedi_aux_data(it.options, 0) &&
476b8477 254 it.options[COMEDI_DEVCONF_AUX_DATA_LENGTH]) {
ed9eccbe
DS		 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,
476b8477 265 comedi_aux_data(it.options, 0), aux_len)) {
ed9eccbe
DS		 266 vfree(aux_data);
267 return -EFAULT;
268 }
269 it.options[COMEDI_DEVCONF_AUX_DATA_LO] =
476b8477 270 (unsigned long)aux_data;
ed9eccbe
DS		 271 if (sizeof(void *) > sizeof(int)) {
272 bit_shift = sizeof(int) * 8;
273 it.options[COMEDI_DEVCONF_AUX_DATA_HI] =
476b8477 274 ((unsigned long)aux_data) >> bit_shift;
ed9eccbe
DS		 275 } else
276 it.options[COMEDI_DEVCONF_AUX_DATA_HI] = 0;
277 }
278
279 ret = comedi_device_attach(dev, &it);
476b8477
GKH		 280 if (ret == 0) {
281 if (!try_module_get(dev->driver->module)) {
ed9eccbe
DS		 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 COMEDI_BUFCONFIG
295 buffer configuration ioctl
296
297 arg:
298 pointer to bufconfig structure
299
300 reads:
301 bufconfig at arg
302
303 writes:
304 modified bufconfig at arg
305
306*/
92d0127c
GKH		 307static int do_bufconfig_ioctl(struct comedi_device *dev,
308 struct comedi_bufconfig __user *arg)
ed9eccbe 309{
be6aba4a 310 struct comedi_bufconfig bc;
d163679c 311 struct comedi_async *async;
34c43922 312 struct comedi_subdevice *s;
883db3d9 313 int retval = 0;
ed9eccbe 314
be6aba4a 315 if (copy_from_user(&bc, arg, sizeof(struct comedi_bufconfig)))
ed9eccbe
DS		 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) {
883db3d9
FMH		 339 retval = resize_async_buffer(dev, s, async, bc.size);
340 if (retval < 0)
341 return retval;
ed9eccbe
DS		 342 }
343
344 bc.size = async->prealloc_bufsz;
345 bc.maximum_size = async->max_bufsize;
346
476b8477 347copyback:
be6aba4a 348 if (copy_to_user(arg, &bc, sizeof(struct comedi_bufconfig)))
ed9eccbe
DS		 349 return -EFAULT;
350
351 return 0;
352}
353
354/*
355 COMEDI_DEVINFO
356 device info ioctl
357
358 arg:
359 pointer to devinfo structure
360
361 reads:
362 none
363
364 writes:
365 devinfo structure
366
367*/
0a85b6f0 368static int do_devinfo_ioctl(struct comedi_device *dev,
92d0127c
GKH		 369 struct comedi_devinfo __user *arg,
370 struct file *file)
ed9eccbe 371{
063db04b 372 struct comedi_devinfo devinfo;
ed9eccbe 373 const unsigned minor = iminor(file->f_dentry->d_inode);
476b8477
GKH		 374 struct comedi_device_file_info *dev_file_info =
375 comedi_get_device_file_info(minor);
34c43922 376 struct comedi_subdevice *read_subdev =
476b8477 377 comedi_get_read_subdevice(dev_file_info);
34c43922 378 struct comedi_subdevice *write_subdev =
476b8477 379 comedi_get_write_subdevice(dev_file_info);
ed9eccbe
DS		 380
381 memset(&devinfo, 0, sizeof(devinfo));
382
383 /* fill devinfo structure */
384 devinfo.version_code = COMEDI_VERSION_CODE;
385 devinfo.n_subdevs = dev->n_subdevices;
819cbb12
VK		 386 strlcpy(devinfo.driver_name, dev->driver->driver_name, COMEDI_NAMELEN);
387 strlcpy(devinfo.board_name, dev->board_name, COMEDI_NAMELEN);
ed9eccbe 388
476b8477 389 if (read_subdev)
ed9eccbe 390 devinfo.read_subdevice = read_subdev - dev->subdevices;
476b8477 391 else
ed9eccbe 392 devinfo.read_subdevice = -1;
476b8477
GKH		 393
394 if (write_subdev)
ed9eccbe 395 devinfo.write_subdevice = write_subdev - dev->subdevices;
476b8477 396 else
ed9eccbe 397 devinfo.write_subdevice = -1;
ed9eccbe 398
063db04b 399 if (copy_to_user(arg, &devinfo, sizeof(struct comedi_devinfo)))
ed9eccbe
DS		 400 return -EFAULT;
401
402 return 0;
403}
404
405/*
406 COMEDI_SUBDINFO
407 subdevice info ioctl
408
409 arg:
410 pointer to array of subdevice info structures
411
412 reads:
413 none
414
415 writes:
416 array of subdevice info structures at arg
417
418*/
0a85b6f0 419static int do_subdinfo_ioctl(struct comedi_device *dev,
92d0127c 420 struct comedi_subdinfo __user *arg, void *file)
ed9eccbe
DS		 421{
422 int ret, i;
bd52efbb 423 struct comedi_subdinfo *tmp, *us;
34c43922 424 struct comedi_subdevice *s;
ed9eccbe 425
0a85b6f0
MT		 426 tmp =
427 kcalloc(dev->n_subdevices, sizeof(struct comedi_subdinfo),
428 GFP_KERNEL);
ed9eccbe
DS		 429 if (!tmp)
430 return -ENOMEM;
431
432 /* fill subdinfo structs */
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 /* backwards compatibility */
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 =
476b8477 448 (i << 24) | (0 << 16) | (s->range_table->length);
ed9eccbe
DS		 449 } else {
450 us->range_type = 0; /* XXX */
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,
bd52efbb 480 dev->n_subdevices * sizeof(struct comedi_subdinfo));
ed9eccbe
DS		 481
482 kfree(tmp);
483
484 return ret ? -EFAULT : 0;
485}
486
487/*
488 COMEDI_CHANINFO
489 subdevice info ioctl
490
491 arg:
492 pointer to chaninfo structure
493
494 reads:
495 chaninfo structure at arg
496
497 writes:
498 arrays at elements of chaninfo structure
499
500*/
0a85b6f0 501static int do_chaninfo_ioctl(struct comedi_device *dev,
92d0127c 502 struct comedi_chaninfo __user *arg)
ed9eccbe 503{
34c43922 504 struct comedi_subdevice *s;
a18b416d 505 struct comedi_chaninfo it;
ed9eccbe 506
a18b416d 507 if (copy_from_user(&it, arg, sizeof(struct comedi_chaninfo)))
ed9eccbe
DS		 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,
790c5541 518 s->n_chan * sizeof(unsigned int)))
ed9eccbe
DS		 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,
476b8477 526 s->n_chan * sizeof(unsigned int)))
ed9eccbe
DS		 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) |
476b8477 539 (s->range_table_list[i]->length);
81604d43
VK		 540 if (put_user(x, it.rangelist + i))
541 return -EFAULT;
ed9eccbe 542 }
476b8477
GKH		 543#if 0
544 if (copy_to_user(it.rangelist, s->range_type_list,
0a85b6f0 545 s->n_chan * sizeof(unsigned int)))
476b8477
GKH		 546 return -EFAULT;
547#endif
ed9eccbe
DS		 548 }
549
550 return 0;
551}
552
553 /*
554 COMEDI_BUFINFO
555 buffer information ioctl
556
557 arg:
558 pointer to bufinfo structure
559
560 reads:
561 bufinfo at arg
562
563 writes:
564 modified bufinfo at arg
565
566 */
92d0127c 567static int do_bufinfo_ioctl(struct comedi_device *dev,
53fa827e 568 struct comedi_bufinfo __user *arg, void *file)
ed9eccbe 569{
9aa5339a 570 struct comedi_bufinfo bi;
34c43922 571 struct comedi_subdevice *s;
d163679c 572 struct comedi_async *async;
ed9eccbe 573
9aa5339a 574 if (copy_from_user(&bi, arg, sizeof(struct comedi_bufinfo)))
ed9eccbe
DS		 575 return -EFAULT;
576
577 if (bi.subdevice >= dev->n_subdevices || bi.subdevice < 0)
578 return -EINVAL;
579
580 s = dev->subdevices + bi.subdevice;
53fa827e
IA		 581
582 if (s->lock && s->lock != file)
583 return -EACCES;
584
ed9eccbe
DS		 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;
4772c018
IA		 593 bi.bytes_read = 0;
594 bi.bytes_written = 0;
ed9eccbe
DS		 595 goto copyback;
596 }
53fa827e
IA		 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;
ed9eccbe
DS		 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 |
476b8477
GKH		 610 SRF_RUNNING))
611 && async->buf_write_count == async->buf_read_count) {
ed9eccbe
DS		 612 do_become_nonbusy(dev, s);
613 }
614 }
615
616 if (bi.bytes_written && (s->subdev_flags & SDF_CMD_WRITE)) {
617 bi.bytes_written =
476b8477 618 comedi_buf_write_alloc(async, bi.bytes_written);
ed9eccbe
DS		 619 comedi_buf_write_free(async, bi.bytes_written);
620 }
621
53fa827e 622copyback_position:
ed9eccbe
DS		 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
476b8477 628copyback:
9aa5339a 629 if (copy_to_user(arg, &bi, sizeof(struct comedi_bufinfo)))
ed9eccbe
DS		 630 return -EFAULT;
631
632 return 0;
633}
634
0a85b6f0
MT		 635static int parse_insn(struct comedi_device *dev, struct comedi_insn *insn,
636 unsigned int *data, void *file);
ed9eccbe 637/*
20617f22
PDP		 638 * COMEDI_INSNLIST
639 * synchronous instructions
ed9eccbe 640 *
20617f22
PDP		 641 * arg:
642 * pointer to sync cmd structure
ed9eccbe 643 *
20617f22
PDP		 644 * reads:
645 * sync cmd struct at arg
646 * instruction list
647 * data (for writes)
ed9eccbe 648 *
20617f22
PDP		 649 * writes:
650 * data (for reads)
ed9eccbe
DS		 651 */
652/* arbitrary limits */
653#define MAX_SAMPLES 256
92d0127c
GKH		 654static int do_insnlist_ioctl(struct comedi_device *dev,
655 struct comedi_insnlist __user *arg, void *file)
ed9eccbe 656{
da613f4f 657 struct comedi_insnlist insnlist;
90035c08 658 struct comedi_insn *insns = NULL;
790c5541 659 unsigned int *data = NULL;
ed9eccbe
DS		 660 int i = 0;
661 int ret = 0;
662
da613f4f 663 if (copy_from_user(&insnlist, arg, sizeof(struct comedi_insnlist)))
ed9eccbe
DS		 664 return -EFAULT;
665
790c5541 666 data = kmalloc(sizeof(unsigned int) * MAX_SAMPLES, GFP_KERNEL);
ed9eccbe
DS		 667 if (!data) {
668 DPRINTK("kmalloc failed\n");
669 ret = -ENOMEM;
670 goto error;
671 }
672
0a85b6f0
MT		 673 insns =
674 kmalloc(sizeof(struct comedi_insn) * insnlist.n_insns, GFP_KERNEL);
ed9eccbe
DS		 675 if (!insns) {
676 DPRINTK("kmalloc failed\n");
677 ret = -ENOMEM;
678 goto error;
679 }
680
681 if (copy_from_user(insns, insnlist.insns,
90035c08 682 sizeof(struct comedi_insn) * insnlist.n_insns)) {
ed9eccbe
DS		 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,
790c5541 696 insns[i].n * sizeof(unsigned int))) {
ed9eccbe
DS		 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,
790c5541 707 insns[i].n * sizeof(unsigned int))) {
ed9eccbe
DS		 708 DPRINTK("copy_to_user failed\n");
709 ret = -EFAULT;
710 goto error;
711 }
712 }
713 if (need_resched())
714 schedule();
715 }
716
476b8477
GKH		 717error:
718 kfree(insns);
719 kfree(data);
ed9eccbe
DS		 720
721 if (ret < 0)
722 return ret;
723 return i;
724}
725
0a85b6f0
MT		 726static int check_insn_config_length(struct comedi_insn *insn,
727 unsigned int *data)
ed9eccbe 728{
476b8477
GKH		 729 if (insn->n < 1)
730 return -EINVAL;
ed9eccbe
DS		 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;
0a85b6f0
MT		 774 /* by default we allow the insn since we don't have checks for
775 * all possible cases yet */
ed9eccbe 776 default:
3fffdf20
MR		 777 printk(KERN_WARNING
778 "comedi: no check for data length of config insn id "
0a85b6f0
MT		 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);
ed9eccbe
DS		 783 return 0;
784 break;
785 }
786 return -EINVAL;
787}
788
0a85b6f0
MT		 789static int parse_insn(struct comedi_device *dev, struct comedi_insn *insn,
790 unsigned int *data, void *file)
ed9eccbe 791{
34c43922 792 struct comedi_subdevice *s;
ed9eccbe
DS		 793 int ret = 0;
794 int i;
795
796 if (insn->insn & INSN_MASK_SPECIAL) {
797 /* a non-subdevice instruction */
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 /* a subdevice instruction */
790c5541 857 unsigned int maxdata;
ed9eccbe
DS		 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 /* are we locked? (ioctl lock) */
873 if (s->lock && s->lock != file) {
874 DPRINTK("device locked\n");
875 ret = -EACCES;
876 goto out;
877 }
878
0fd0ca75 879 ret = comedi_check_chanlist(s, 1, &insn->chanspec);
476b8477 880 if (ret < 0) {
ed9eccbe
DS		 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 /* This looks arbitrary. It is. */
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
476b8477
GKH		 898 ? s->maxdata_list[CR_CHAN(insn->chanspec)]
899 : s->maxdata;
ed9eccbe
DS		 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;
2f644ccf
IA		 913 } else {
914 /* Most drivers ignore the base channel in
915 * insn->chanspec. Fix this here if
916 * the subdevice has <= 32 channels. */
917 unsigned int shift;
918 unsigned int orig_mask;
919
920 orig_mask = data[0];
921 if (s->n_chan <= 32) {
922 shift = CR_CHAN(insn->chanspec);
923 if (shift > 0) {
924 insn->chanspec = 0;
925 data[0] <<= shift;
926 data[1] <<= shift;
927 }
928 } else
929 shift = 0;
930 ret = s->insn_bits(dev, s, insn, data);
931 data[0] = orig_mask;
932 if (shift > 0)
933 data[1] >>= shift;
ed9eccbe 934 }
ed9eccbe
DS		 935 break;
936 case INSN_CONFIG:
937 ret = check_insn_config_length(insn, data);
938 if (ret)
939 break;
940 ret = s->insn_config(dev, s, insn, data);
941 break;
942 default:
943 ret = -EINVAL;
944 break;
945 }
946
947 s->busy = NULL;
948 }
949
476b8477 950out:
ed9eccbe
DS		 951 return ret;
952}
953
954/*
20617f22
PDP		 955 * COMEDI_INSN
956 * synchronous instructions
ed9eccbe 957 *
20617f22
PDP		 958 * arg:
959 * pointer to insn
ed9eccbe 960 *
20617f22
PDP		 961 * reads:
962 * struct comedi_insn struct at arg
963 * data (for writes)
ed9eccbe 964 *
20617f22
PDP		 965 * writes:
966 * data (for reads)
ed9eccbe 967 */
92d0127c
GKH		 968static int do_insn_ioctl(struct comedi_device *dev,
969 struct comedi_insn __user *arg, void *file)
ed9eccbe 970{
90035c08 971 struct comedi_insn insn;
790c5541 972 unsigned int *data = NULL;
ed9eccbe
DS		 973 int ret = 0;
974
790c5541 975 data = kmalloc(sizeof(unsigned int) * MAX_SAMPLES, GFP_KERNEL);
ed9eccbe
DS		 976 if (!data) {
977 ret = -ENOMEM;
978 goto error;
979 }
980
90035c08 981 if (copy_from_user(&insn, arg, sizeof(struct comedi_insn))) {
ed9eccbe
DS		 982 ret = -EFAULT;
983 goto error;
984 }
985
986 /* This is where the behavior of insn and insnlist deviate. */
987 if (insn.n > MAX_SAMPLES)
988 insn.n = MAX_SAMPLES;
989 if (insn.insn & INSN_MASK_WRITE) {
21fe2eea
M		 990 if (copy_from_user(data,
991 insn.data,
992 insn.n * sizeof(unsigned int))) {
ed9eccbe
DS		 993 ret = -EFAULT;
994 goto error;
995 }
996 }
997 ret = parse_insn(dev, &insn, data, file);
998 if (ret < 0)
999 goto error;
1000 if (insn.insn & INSN_MASK_READ) {
21fe2eea
M		 1001 if (copy_to_user(insn.data,
1002 data,
1003 insn.n * sizeof(unsigned int))) {
ed9eccbe
DS		 1004 ret = -EFAULT;
1005 goto error;
1006 }
1007 }
1008 ret = insn.n;
1009
476b8477
GKH		 1010error:
1011 kfree(data);
ed9eccbe
DS		 1012
1013 return ret;
1014}
1015
181bd67b
GKH		 1016static void comedi_set_subdevice_runflags(struct comedi_subdevice *s,
1017 unsigned mask, unsigned bits)
1018{
1019 unsigned long flags;
1020
1021 spin_lock_irqsave(&s->spin_lock, flags);
1022 s->runflags &= ~mask;
1023 s->runflags |= (bits & mask);
1024 spin_unlock_irqrestore(&s->spin_lock, flags);
1025}
1026
92d0127c
GKH		 1027static int do_cmd_ioctl(struct comedi_device *dev,
1028 struct comedi_cmd __user *cmd, void *file)
ed9eccbe 1029{
ea6d0d4c 1030 struct comedi_cmd user_cmd;
34c43922 1031 struct comedi_subdevice *s;
d163679c 1032 struct comedi_async *async;
ed9eccbe 1033 int ret = 0;
92d0127c 1034 unsigned int __user *chanlist_saver = NULL;
ed9eccbe 1035
92d0127c 1036 if (copy_from_user(&user_cmd, cmd, sizeof(struct comedi_cmd))) {
ed9eccbe
DS		 1037 DPRINTK("bad cmd address\n");
1038 return -EFAULT;
1039 }
476b8477 1040 /* save user's chanlist pointer so it can be restored later */
ed9eccbe
DS		 1041 chanlist_saver = user_cmd.chanlist;
1042
1043 if (user_cmd.subdev >= dev->n_subdevices) {
1044 DPRINTK("%d no such subdevice\n", user_cmd.subdev);
1045 return -ENODEV;
1046 }
1047
1048 s = dev->subdevices + user_cmd.subdev;
1049 async = s->async;
1050
1051 if (s->type == COMEDI_SUBD_UNUSED) {
1052 DPRINTK("%d not valid subdevice\n", user_cmd.subdev);
1053 return -EIO;
1054 }
1055
1056 if (!s->do_cmd || !s->do_cmdtest || !s->async) {
1057 DPRINTK("subdevice %i does not support commands\n",
1058 user_cmd.subdev);
1059 return -EIO;
1060 }
1061
1062 /* are we locked? (ioctl lock) */
1063 if (s->lock && s->lock != file) {
1064 DPRINTK("subdevice locked\n");
1065 return -EACCES;
1066 }
1067
1068 /* are we busy? */
1069 if (s->busy) {
1070 DPRINTK("subdevice busy\n");
1071 return -EBUSY;
1072 }
1073 s->busy = file;
1074
1075 /* make sure channel/gain list isn't too long */
1076 if (user_cmd.chanlist_len > s->len_chanlist) {
1077 DPRINTK("channel/gain list too long %u > %d\n",
1078 user_cmd.chanlist_len, s->len_chanlist);
1079 ret = -EINVAL;
1080 goto cleanup;
1081 }
1082
1083 /* make sure channel/gain list isn't too short */
1084 if (user_cmd.chanlist_len < 1) {
1085 DPRINTK("channel/gain list too short %u < 1\n",
1086 user_cmd.chanlist_len);
1087 ret = -EINVAL;
1088 goto cleanup;
1089 }
1090
476b8477 1091 kfree(async->cmd.chanlist);
ed9eccbe
DS		 1092 async->cmd = user_cmd;
1093 async->cmd.data = NULL;
1094 /* load channel/gain list */
1095 async->cmd.chanlist =
476b8477 1096 kmalloc(async->cmd.chanlist_len * sizeof(int), GFP_KERNEL);
ed9eccbe
DS		 1097 if (!async->cmd.chanlist) {
1098 DPRINTK("allocation failed\n");
1099 ret = -ENOMEM;
1100 goto cleanup;
1101 }
1102
1103 if (copy_from_user(async->cmd.chanlist, user_cmd.chanlist,
476b8477 1104 async->cmd.chanlist_len * sizeof(int))) {
ed9eccbe
DS		 1105 DPRINTK("fault reading chanlist\n");
1106 ret = -EFAULT;
1107 goto cleanup;
1108 }
1109
1110 /* make sure each element in channel/gain list is valid */
21fe2eea
M		 1111 ret = comedi_check_chanlist(s,
1112 async->cmd.chanlist_len,
1113 async->cmd.chanlist);
476b8477 1114 if (ret < 0) {
ed9eccbe
DS		 1115 DPRINTK("bad chanlist\n");
1116 goto cleanup;
1117 }
1118
1119 ret = s->do_cmdtest(dev, s, &async->cmd);
1120
1121 if (async->cmd.flags & TRIG_BOGUS || ret) {
1122 DPRINTK("test returned %d\n", ret);
1123 user_cmd = async->cmd;
476b8477 1124 /* restore chanlist pointer before copying back */
ed9eccbe
DS		 1125 user_cmd.chanlist = chanlist_saver;
1126 user_cmd.data = NULL;
92d0127c 1127 if (copy_to_user(cmd, &user_cmd, sizeof(struct comedi_cmd))) {
ed9eccbe
DS		 1128 DPRINTK("fault writing cmd\n");
1129 ret = -EFAULT;
1130 goto cleanup;
1131 }
1132 ret = -EAGAIN;
1133 goto cleanup;
1134 }
1135
1136 if (!async->prealloc_bufsz) {
1137 ret = -ENOMEM;
1138 DPRINTK("no buffer (?)\n");
1139 goto cleanup;
1140 }
1141
1142 comedi_reset_async_buf(async);
1143
1144 async->cb_mask =
476b8477
GKH		 1145 COMEDI_CB_EOA | COMEDI_CB_BLOCK | COMEDI_CB_ERROR |
1146 COMEDI_CB_OVERFLOW;
1147 if (async->cmd.flags & TRIG_WAKE_EOS)
ed9eccbe 1148 async->cb_mask |= COMEDI_CB_EOS;
ed9eccbe
DS		 1149
1150 comedi_set_subdevice_runflags(s, ~0, SRF_USER | SRF_RUNNING);
1151
ed9eccbe
DS		 1152 ret = s->do_cmd(dev, s);
1153 if (ret == 0)
1154 return 0;
1155
476b8477 1156cleanup:
ed9eccbe
DS		 1157 do_become_nonbusy(dev, s);
1158
1159 return ret;
1160}
1161
1162/*
1163 COMEDI_CMDTEST
1164 command testing ioctl
1165
1166 arg:
1167 pointer to cmd structure
1168
1169 reads:
1170 cmd structure at arg
1171 channel/range list
1172
1173 writes:
1174 modified cmd structure at arg
1175
1176*/
92d0127c
GKH		 1177static int do_cmdtest_ioctl(struct comedi_device *dev,
1178 struct comedi_cmd __user *arg, void *file)
ed9eccbe 1179{
ea6d0d4c 1180 struct comedi_cmd user_cmd;
34c43922 1181 struct comedi_subdevice *s;
ed9eccbe
DS		 1182 int ret = 0;
1183 unsigned int *chanlist = NULL;
92d0127c 1184 unsigned int __user *chanlist_saver = NULL;
ed9eccbe 1185
ea6d0d4c 1186 if (copy_from_user(&user_cmd, arg, sizeof(struct comedi_cmd))) {
ed9eccbe
DS		 1187 DPRINTK("bad cmd address\n");
1188 return -EFAULT;
1189 }
476b8477 1190 /* save user's chanlist pointer so it can be restored later */
ed9eccbe
DS		 1191 chanlist_saver = user_cmd.chanlist;
1192
1193 if (user_cmd.subdev >= dev->n_subdevices) {
1194 DPRINTK("%d no such subdevice\n", user_cmd.subdev);
1195 return -ENODEV;
1196 }
1197
1198 s = dev->subdevices + user_cmd.subdev;
1199 if (s->type == COMEDI_SUBD_UNUSED) {
1200 DPRINTK("%d not valid subdevice\n", user_cmd.subdev);
1201 return -EIO;
1202 }
1203
1204 if (!s->do_cmd || !s->do_cmdtest) {
1205 DPRINTK("subdevice %i does not support commands\n",
1206 user_cmd.subdev);
1207 return -EIO;
1208 }
1209
1210 /* make sure channel/gain list isn't too long */
1211 if (user_cmd.chanlist_len > s->len_chanlist) {
1212 DPRINTK("channel/gain list too long %d > %d\n",
1213 user_cmd.chanlist_len, s->len_chanlist);
1214 ret = -EINVAL;
1215 goto cleanup;
1216 }
1217
1218 /* load channel/gain list */
1219 if (user_cmd.chanlist) {
1220 chanlist =
476b8477 1221 kmalloc(user_cmd.chanlist_len * sizeof(int), GFP_KERNEL);
ed9eccbe
DS		 1222 if (!chanlist) {
1223 DPRINTK("allocation failed\n");
1224 ret = -ENOMEM;
1225 goto cleanup;
1226 }
1227
1228 if (copy_from_user(chanlist, user_cmd.chanlist,
476b8477 1229 user_cmd.chanlist_len * sizeof(int))) {
ed9eccbe
DS		 1230 DPRINTK("fault reading chanlist\n");
1231 ret = -EFAULT;
1232 goto cleanup;
1233 }
1234
1235 /* make sure each element in channel/gain list is valid */
0fd0ca75 1236 ret = comedi_check_chanlist(s, user_cmd.chanlist_len, chanlist);
476b8477 1237 if (ret < 0) {
ed9eccbe
DS		 1238 DPRINTK("bad chanlist\n");
1239 goto cleanup;
1240 }
1241
1242 user_cmd.chanlist = chanlist;
1243 }
1244
1245 ret = s->do_cmdtest(dev, s, &user_cmd);
1246
476b8477 1247 /* restore chanlist pointer before copying back */
ed9eccbe
DS		 1248 user_cmd.chanlist = chanlist_saver;
1249
ea6d0d4c 1250 if (copy_to_user(arg, &user_cmd, sizeof(struct comedi_cmd))) {
ed9eccbe
DS		 1251 DPRINTK("bad cmd address\n");
1252 ret = -EFAULT;
1253 goto cleanup;
1254 }
476b8477
GKH		 1255cleanup:
1256 kfree(chanlist);
ed9eccbe
DS		 1257
1258 return ret;
1259}
1260
1261/*
1262 COMEDI_LOCK
1263 lock subdevice
1264
1265 arg:
1266 subdevice number
1267
1268 reads:
1269 none
1270
1271 writes:
1272 none
1273
1274*/
1275
0a85b6f0
MT		 1276static int do_lock_ioctl(struct comedi_device *dev, unsigned int arg,
1277 void *file)
ed9eccbe
DS		 1278{
1279 int ret = 0;
1280 unsigned long flags;
34c43922 1281 struct comedi_subdevice *s;
ed9eccbe
DS		 1282
1283 if (arg >= dev->n_subdevices)
1284 return -EINVAL;
1285 s = dev->subdevices + arg;
1286
5f74ea14 1287 spin_lock_irqsave(&s->spin_lock, flags);
476b8477 1288 if (s->busy || s->lock)
ed9eccbe 1289 ret = -EBUSY;
476b8477 1290 else
ed9eccbe 1291 s->lock = file;
5f74ea14 1292 spin_unlock_irqrestore(&s->spin_lock, flags);
ed9eccbe 1293
c5274ab0 1294#if 0
ed9eccbe
DS		 1295 if (ret < 0)
1296 return ret;
1297
ed9eccbe
DS		 1298 if (s->lock_f)
1299 ret = s->lock_f(dev, s);
1300#endif
1301
1302 return ret;
1303}
1304
1305/*
1306 COMEDI_UNLOCK
1307 unlock subdevice
1308
1309 arg:
1310 subdevice number
1311
1312 reads:
1313 none
1314
1315 writes:
1316 none
1317
1318 This function isn't protected by the semaphore, since
1319 we already own the lock.
1320*/
0a85b6f0
MT		 1321static int do_unlock_ioctl(struct comedi_device *dev, unsigned int arg,
1322 void *file)
ed9eccbe 1323{
34c43922 1324 struct comedi_subdevice *s;
ed9eccbe
DS		 1325
1326 if (arg >= dev->n_subdevices)
1327 return -EINVAL;
1328 s = dev->subdevices + arg;
1329
1330 if (s->busy)
1331 return -EBUSY;
1332
1333 if (s->lock && s->lock != file)
1334 return -EACCES;
1335
1336 if (s->lock == file) {
1337#if 0
1338 if (s->unlock)
1339 s->unlock(dev, s);
1340#endif
1341
1342 s->lock = NULL;
1343 }
1344
1345 return 0;
1346}
1347
1348/*
1349 COMEDI_CANCEL
1350 cancel acquisition ioctl
1351
1352 arg:
1353 subdevice number
1354
1355 reads:
1356 nothing
1357
1358 writes:
1359 nothing
1360
1361*/
0a85b6f0
MT		 1362static int do_cancel_ioctl(struct comedi_device *dev, unsigned int arg,
1363 void *file)
ed9eccbe 1364{
34c43922 1365 struct comedi_subdevice *s;
ed9eccbe
DS		 1366
1367 if (arg >= dev->n_subdevices)
1368 return -EINVAL;
1369 s = dev->subdevices + arg;
1370 if (s->async == NULL)
1371 return -EINVAL;
1372
1373 if (s->lock && s->lock != file)
1374 return -EACCES;
1375
1376 if (!s->busy)
1377 return 0;
1378
1379 if (s->busy != file)
1380 return -EBUSY;
1381
1382 return do_cancel(dev, s);
1383}
1384
1385/*
1386 COMEDI_POLL ioctl
1387 instructs driver to synchronize buffers
1388
1389 arg:
1390 subdevice number
1391
1392 reads:
1393 nothing
1394
1395 writes:
1396 nothing
1397
1398*/
0a85b6f0
MT		 1399static int do_poll_ioctl(struct comedi_device *dev, unsigned int arg,
1400 void *file)
ed9eccbe 1401{
34c43922 1402 struct comedi_subdevice *s;
ed9eccbe
DS		 1403
1404 if (arg >= dev->n_subdevices)
1405 return -EINVAL;
1406 s = dev->subdevices + arg;
1407
1408 if (s->lock && s->lock != file)
1409 return -EACCES;
1410
1411 if (!s->busy)
1412 return 0;
1413
1414 if (s->busy != file)
1415 return -EBUSY;
1416
1417 if (s->poll)
1418 return s->poll(dev, s);
1419
1420 return -EINVAL;
1421}
1422
34c43922 1423static int do_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
ed9eccbe
DS		 1424{
1425 int ret = 0;
1426
1427 if ((comedi_get_subdevice_runflags(s) & SRF_RUNNING) && s->cancel)
1428 ret = s->cancel(dev, s);
1429
1430 do_become_nonbusy(dev, s);
1431
1432 return ret;
1433}
1434
df30b21c
FV		 1435
1436static void comedi_vm_open(struct vm_area_struct *area)
1437{
1438 struct comedi_async *async;
1439 struct comedi_device *dev;
1440
1441 async = area->vm_private_data;
1442 dev = async->subdevice->device;
1443
1444 mutex_lock(&dev->mutex);
1445 async->mmap_count++;
1446 mutex_unlock(&dev->mutex);
1447}
1448
1449static void comedi_vm_close(struct vm_area_struct *area)
ed9eccbe 1450{
d163679c 1451 struct comedi_async *async;
71b5f4f1 1452 struct comedi_device *dev;
ed9eccbe
DS		 1453
1454 async = area->vm_private_data;
1455 dev = async->subdevice->device;
1456
1457 mutex_lock(&dev->mutex);
1458 async->mmap_count--;
1459 mutex_unlock(&dev->mutex);
1460}
1461
1462static struct vm_operations_struct comedi_vm_ops = {
df30b21c
FV		 1463 .open = comedi_vm_open,
1464 .close = comedi_vm_close,
ed9eccbe
DS		 1465};
1466
1467static int comedi_mmap(struct file *file, struct vm_area_struct *vma)
1468{
1469 const unsigned minor = iminor(file->f_dentry->d_inode);
d163679c 1470 struct comedi_async *async = NULL;
ed9eccbe
DS		 1471 unsigned long start = vma->vm_start;
1472 unsigned long size;
1473 int n_pages;
1474 int i;
1475 int retval;
34c43922 1476 struct comedi_subdevice *s;
3ffab428
BP		 1477 struct comedi_device_file_info *dev_file_info;
1478 struct comedi_device *dev;
1479
1480 dev_file_info = comedi_get_device_file_info(minor);
1481 if (dev_file_info == NULL)
1482 return -ENODEV;
1483 dev = dev_file_info->device;
1484 if (dev == NULL)
1485 return -ENODEV;
ed9eccbe
DS		 1486
1487 mutex_lock(&dev->mutex);
1488 if (!dev->attached) {
1489 DPRINTK("no driver configured on comedi%i\n", dev->minor);
1490 retval = -ENODEV;
1491 goto done;
1492 }
476b8477 1493 if (vma->vm_flags & VM_WRITE)
ed9eccbe 1494 s = comedi_get_write_subdevice(dev_file_info);
476b8477 1495 else
ed9eccbe 1496 s = comedi_get_read_subdevice(dev_file_info);
476b8477 1497
ed9eccbe
DS		 1498 if (s == NULL) {
1499 retval = -EINVAL;
1500 goto done;
1501 }
1502 async = s->async;
1503 if (async == NULL) {
1504 retval = -EINVAL;
1505 goto done;
1506 }
1507
1508 if (vma->vm_pgoff != 0) {
1509 DPRINTK("comedi: mmap() offset must be 0.\n");
1510 retval = -EINVAL;
1511 goto done;
1512 }
1513
1514 size = vma->vm_end - vma->vm_start;
1515 if (size > async->prealloc_bufsz) {
1516 retval = -EFAULT;
1517 goto done;
1518 }
1519 if (size & (~PAGE_MASK)) {
1520 retval = -EFAULT;
1521 goto done;
1522 }
1523
1524 n_pages = size >> PAGE_SHIFT;
1525 for (i = 0; i < n_pages; ++i) {
1526 if (remap_pfn_range(vma, start,
0a85b6f0
MT		 1527 page_to_pfn(virt_to_page
1528 (async->buf_page_list
1529 [i].virt_addr)), PAGE_SIZE,
1530 PAGE_SHARED)) {
ed9eccbe
DS		 1531 retval = -EAGAIN;
1532 goto done;
1533 }
1534 start += PAGE_SIZE;
1535 }
1536
1537 vma->vm_ops = &comedi_vm_ops;
1538 vma->vm_private_data = async;
1539
1540 async->mmap_count++;
1541
1542 retval = 0;
476b8477 1543done:
ed9eccbe
DS		 1544 mutex_unlock(&dev->mutex);
1545 return retval;
1546}
1547
0a85b6f0 1548static unsigned int comedi_poll(struct file *file, poll_table * wait)
ed9eccbe
DS		 1549{
1550 unsigned int mask = 0;
1551 const unsigned minor = iminor(file->f_dentry->d_inode);
34c43922
BP		 1552 struct comedi_subdevice *read_subdev;
1553 struct comedi_subdevice *write_subdev;
3ffab428
BP		 1554 struct comedi_device_file_info *dev_file_info;
1555 struct comedi_device *dev;
1556 dev_file_info = comedi_get_device_file_info(minor);
1557
1558 if (dev_file_info == NULL)
1559 return -ENODEV;
1560 dev = dev_file_info->device;
1561 if (dev == NULL)
1562 return -ENODEV;
ed9eccbe
DS		 1563
1564 mutex_lock(&dev->mutex);
1565 if (!dev->attached) {
1566 DPRINTK("no driver configured on comedi%i\n", dev->minor);
1567 mutex_unlock(&dev->mutex);
1568 return 0;
1569 }
1570
1571 mask = 0;
1572 read_subdev = comedi_get_read_subdevice(dev_file_info);
1573 if (read_subdev) {
1574 poll_wait(file, &read_subdev->async->wait_head, wait);
1575 if (!read_subdev->busy
476b8477
GKH		 1576 || comedi_buf_read_n_available(read_subdev->async) > 0
1577 || !(comedi_get_subdevice_runflags(read_subdev) &
1578 SRF_RUNNING)) {
ed9eccbe
DS		 1579 mask |= POLLIN | POLLRDNORM;
1580 }
1581 }
1582 write_subdev = comedi_get_write_subdevice(dev_file_info);
1583 if (write_subdev) {
1584 poll_wait(file, &write_subdev->async->wait_head, wait);
476b8477
GKH		 1585 comedi_buf_write_alloc(write_subdev->async,
1586 write_subdev->async->prealloc_bufsz);
ed9eccbe 1587 if (!write_subdev->busy
476b8477
GKH		 1588 || !(comedi_get_subdevice_runflags(write_subdev) &
1589 SRF_RUNNING)
1590 || comedi_buf_write_n_allocated(write_subdev->async) >=
1591 bytes_per_sample(write_subdev->async->subdevice)) {
ed9eccbe
DS		 1592 mask |= POLLOUT | POLLWRNORM;
1593 }
1594 }
1595
1596 mutex_unlock(&dev->mutex);
1597 return mask;
1598}
1599
92d0127c
GKH		 1600static ssize_t comedi_write(struct file *file, const char __user *buf,
1601 size_t nbytes, loff_t *offset)
ed9eccbe 1602{
34c43922 1603 struct comedi_subdevice *s;
d163679c 1604 struct comedi_async *async;
ed9eccbe
DS		 1605 int n, m, count = 0, retval = 0;
1606 DECLARE_WAITQUEUE(wait, current);
1607 const unsigned minor = iminor(file->f_dentry->d_inode);
3ffab428
BP		 1608 struct comedi_device_file_info *dev_file_info;
1609 struct comedi_device *dev;
1610 dev_file_info = comedi_get_device_file_info(minor);
1611
1612 if (dev_file_info == NULL)
1613 return -ENODEV;
1614 dev = dev_file_info->device;
1615 if (dev == NULL)
1616 return -ENODEV;
ed9eccbe
DS		 1617
1618 if (!dev->attached) {
1619 DPRINTK("no driver configured on comedi%i\n", dev->minor);
1620 retval = -ENODEV;
1621 goto done;
1622 }
1623
1624 s = comedi_get_write_subdevice(dev_file_info);
1625 if (s == NULL) {
1626 retval = -EIO;
1627 goto done;
1628 }
1629 async = s->async;
1630
1631 if (!nbytes) {
1632 retval = 0;
1633 goto done;
1634 }
1635 if (!s->busy) {
1636 retval = 0;
1637 goto done;
1638 }
1639 if (s->busy != file) {
1640 retval = -EACCES;
1641 goto done;
1642 }
1643 add_wait_queue(&async->wait_head, &wait);
1644 while (nbytes > 0 && !retval) {
1645 set_current_state(TASK_INTERRUPTIBLE);
1646
d2611540
IA		 1647 if (!(comedi_get_subdevice_runflags(s) & SRF_RUNNING)) {
1648 if (count == 0) {
1649 if (comedi_get_subdevice_runflags(s) &
1650 SRF_ERROR) {
1651 retval = -EPIPE;
1652 } else {
1653 retval = 0;
1654 }
1655 do_become_nonbusy(dev, s);
1656 }
1657 break;
1658 }
1659
ed9eccbe
DS		 1660 n = nbytes;
1661
1662 m = n;
476b8477 1663 if (async->buf_write_ptr + m > async->prealloc_bufsz)
ed9eccbe 1664 m = async->prealloc_bufsz - async->buf_write_ptr;
ed9eccbe 1665 comedi_buf_write_alloc(async, async->prealloc_bufsz);
476b8477 1666 if (m > comedi_buf_write_n_allocated(async))
ed9eccbe 1667 m = comedi_buf_write_n_allocated(async);
ed9eccbe
DS		 1668 if (m < n)
1669 n = m;
1670
1671 if (n == 0) {
ed9eccbe
DS		 1672 if (file->f_flags & O_NONBLOCK) {
1673 retval = -EAGAIN;
1674 break;
1675 }
1676 if (signal_pending(current)) {
1677 retval = -ERESTARTSYS;
1678 break;
1679 }
1680 schedule();
476b8477 1681 if (!s->busy)
ed9eccbe 1682 break;
ed9eccbe
DS		 1683 if (s->busy != file) {
1684 retval = -EACCES;
1685 break;
1686 }
1687 continue;
1688 }
1689
1690 m = copy_from_user(async->prealloc_buf + async->buf_write_ptr,
476b8477 1691 buf, n);
ed9eccbe
DS		 1692 if (m) {
1693 n -= m;
1694 retval = -EFAULT;
1695 }
1696 comedi_buf_write_free(async, n);
1697
1698 count += n;
1699 nbytes -= n;
1700
1701 buf += n;
1702 break; /* makes device work like a pipe */
1703 }
1704 set_current_state(TASK_RUNNING);
1705 remove_wait_queue(&async->wait_head, &wait);
1706
1707done:
476b8477 1708 return count ? count : retval;
ed9eccbe
DS		 1709}
1710
92d0127c 1711static ssize_t comedi_read(struct file *file, char __user *buf, size_t nbytes,
6705b68d 1712 loff_t *offset)
ed9eccbe 1713{
34c43922 1714 struct comedi_subdevice *s;
d163679c 1715 struct comedi_async *async;
ed9eccbe
DS		 1716 int n, m, count = 0, retval = 0;
1717 DECLARE_WAITQUEUE(wait, current);
1718 const unsigned minor = iminor(file->f_dentry->d_inode);
3ffab428
BP		 1719 struct comedi_device_file_info *dev_file_info;
1720 struct comedi_device *dev;
1721 dev_file_info = comedi_get_device_file_info(minor);
1722
1723 if (dev_file_info == NULL)
1724 return -ENODEV;
1725 dev = dev_file_info->device;
1726 if (dev == NULL)
1727 return -ENODEV;
ed9eccbe
DS		 1728
1729 if (!dev->attached) {
1730 DPRINTK("no driver configured on comedi%i\n", dev->minor);
1731 retval = -ENODEV;
1732 goto done;
1733 }
1734
1735 s = comedi_get_read_subdevice(dev_file_info);
1736 if (s == NULL) {
1737 retval = -EIO;
1738 goto done;
1739 }
1740 async = s->async;
1741 if (!nbytes) {
1742 retval = 0;
1743 goto done;
1744 }
1745 if (!s->busy) {
1746 retval = 0;
1747 goto done;
1748 }
1749 if (s->busy != file) {
1750 retval = -EACCES;
1751 goto done;
1752 }
1753
1754 add_wait_queue(&async->wait_head, &wait);
1755 while (nbytes > 0 && !retval) {
1756 set_current_state(TASK_INTERRUPTIBLE);
1757
1758 n = nbytes;
1759
1760 m = comedi_buf_read_n_available(async);
476b8477
GKH		 1761 /* printk("%d available\n",m); */
1762 if (async->buf_read_ptr + m > async->prealloc_bufsz)
ed9eccbe 1763 m = async->prealloc_bufsz - async->buf_read_ptr;
476b8477 1764 /* printk("%d contiguous\n",m); */
ed9eccbe
DS		 1765 if (m < n)
1766 n = m;
1767
1768 if (n == 0) {
1769 if (!(comedi_get_subdevice_runflags(s) & SRF_RUNNING)) {
1770 do_become_nonbusy(dev, s);
1771 if (comedi_get_subdevice_runflags(s) &
476b8477 1772 SRF_ERROR) {
ed9eccbe
DS		 1773 retval = -EPIPE;
1774 } else {
1775 retval = 0;
1776 }
1777 break;
1778 }
1779 if (file->f_flags & O_NONBLOCK) {
1780 retval = -EAGAIN;
1781 break;
1782 }
1783 if (signal_pending(current)) {
1784 retval = -ERESTARTSYS;
1785 break;
1786 }
1787 schedule();
1788 if (!s->busy) {
1789 retval = 0;
1790 break;
1791 }
1792 if (s->busy != file) {
1793 retval = -EACCES;
1794 break;
1795 }
1796 continue;
1797 }
1798 m = copy_to_user(buf, async->prealloc_buf +
476b8477 1799 async->buf_read_ptr, n);
ed9eccbe
DS		 1800 if (m) {
1801 n -= m;
1802 retval = -EFAULT;
1803 }
1804
1805 comedi_buf_read_alloc(async, n);
1806 comedi_buf_read_free(async, n);
1807
1808 count += n;
1809 nbytes -= n;
1810
1811 buf += n;
1812 break; /* makes device work like a pipe */
1813 }
1814 if (!(comedi_get_subdevice_runflags(s) & (SRF_ERROR | SRF_RUNNING)) &&
476b8477 1815 async->buf_read_count - async->buf_write_count == 0) {
ed9eccbe
DS		 1816 do_become_nonbusy(dev, s);
1817 }
1818 set_current_state(TASK_RUNNING);
1819 remove_wait_queue(&async->wait_head, &wait);
1820
1821done:
476b8477 1822 return count ? count : retval;
ed9eccbe
DS		 1823}
1824
1825/*
1826 This function restores a subdevice to an idle state.
1827 */
34c43922 1828void do_become_nonbusy(struct comedi_device *dev, struct comedi_subdevice *s)
ed9eccbe 1829{
d163679c 1830 struct comedi_async *async = s->async;
ed9eccbe
DS		 1831
1832 comedi_set_subdevice_runflags(s, SRF_RUNNING, 0);
ed9eccbe
DS		 1833 if (async) {
1834 comedi_reset_async_buf(async);
1835 async->inttrig = NULL;
1836 } else {
476b8477
GKH		 1837 printk(KERN_ERR
1838 "BUG: (?) do_become_nonbusy called with async=0\n");
ed9eccbe
DS		 1839 }
1840
1841 s->busy = NULL;
1842}
1843
1844static int comedi_open(struct inode *inode, struct file *file)
1845{
ed9eccbe 1846 const unsigned minor = iminor(inode);
476b8477
GKH		 1847 struct comedi_device_file_info *dev_file_info =
1848 comedi_get_device_file_info(minor);
0a85b6f0
MT		 1849 struct comedi_device *dev =
1850 dev_file_info ? dev_file_info->device : NULL;
97920071 1851
ed9eccbe
DS		 1852 if (dev == NULL) {
1853 DPRINTK("invalid minor number\n");
1854 return -ENODEV;
1855 }
1856
1857 /* This is slightly hacky, but we want module autoloading
1858 * to work for root.
1859 * case: user opens device, attached -> ok
1860 * case: user opens device, unattached, in_request_module=0 -> autoload
1861 * case: user opens device, unattached, in_request_module=1 -> fail
1862 * case: root opens device, attached -> ok
1863 * case: root opens device, unattached, in_request_module=1 -> ok
1864 * (typically called from modprobe)
1865 * case: root opens device, unattached, in_request_module=0 -> autoload
1866 *
1867 * The last could be changed to "-> ok", which would deny root
1868 * autoloading.
1869 */
1870 mutex_lock(&dev->mutex);
1871 if (dev->attached)
1872 goto ok;
a8f80e8f 1873 if (!capable(CAP_NET_ADMIN) && dev->in_request_module) {
ed9eccbe
DS		 1874 DPRINTK("in request module\n");
1875 mutex_unlock(&dev->mutex);
1876 return -ENODEV;
1877 }
a8f80e8f 1878 if (capable(CAP_NET_ADMIN) && dev->in_request_module)
ed9eccbe
DS		 1879 goto ok;
1880
1881 dev->in_request_module = 1;
1882
ed9eccbe
DS		 1883#ifdef CONFIG_KMOD
1884 mutex_unlock(&dev->mutex);
56d92c60 1885 request_module("char-major-%i-%i", COMEDI_MAJOR, dev->minor);
ed9eccbe
DS		 1886 mutex_lock(&dev->mutex);
1887#endif
1888
1889 dev->in_request_module = 0;
1890
a8f80e8f
EP		 1891 if (!dev->attached && !capable(CAP_NET_ADMIN)) {
1892 DPRINTK("not attached and not CAP_NET_ADMIN\n");
ed9eccbe
DS		 1893 mutex_unlock(&dev->mutex);
1894 return -ENODEV;
1895 }
1896ok:
1897 __module_get(THIS_MODULE);
1898
1899 if (dev->attached) {
1900 if (!try_module_get(dev->driver->module)) {
1901 module_put(THIS_MODULE);
1902 mutex_unlock(&dev->mutex);
1903 return -ENOSYS;
1904 }
1905 }
1906
3c17ba07
IA		 1907 if (dev->attached && dev->use_count == 0 && dev->open) {
1908 int rc = dev->open(dev);
1909 if (rc < 0) {
1910 module_put(dev->driver->module);
1911 module_put(THIS_MODULE);
1912 mutex_unlock(&dev->mutex);
1913 return rc;
1914 }
1915 }
ed9eccbe
DS		 1916
1917 dev->use_count++;
1918
1919 mutex_unlock(&dev->mutex);
1920
1921 return 0;
1922}
1923
1924static int comedi_close(struct inode *inode, struct file *file)
1925{
1926 const unsigned minor = iminor(inode);
34c43922 1927 struct comedi_subdevice *s = NULL;
ed9eccbe 1928 int i;
3ffab428
BP		 1929 struct comedi_device_file_info *dev_file_info;
1930 struct comedi_device *dev;
1931 dev_file_info = comedi_get_device_file_info(minor);
1932
1933 if (dev_file_info == NULL)
1934 return -ENODEV;
1935 dev = dev_file_info->device;
1936 if (dev == NULL)
1937 return -ENODEV;
ed9eccbe
DS		 1938
1939 mutex_lock(&dev->mutex);
1940
1941 if (dev->subdevices) {
1942 for (i = 0; i < dev->n_subdevices; i++) {
1943 s = dev->subdevices + i;
1944
476b8477 1945 if (s->busy == file)
ed9eccbe 1946 do_cancel(dev, s);
476b8477 1947 if (s->lock == file)
ed9eccbe 1948 s->lock = NULL;
ed9eccbe
DS		 1949 }
1950 }
476b8477 1951 if (dev->attached && dev->use_count == 1 && dev->close)
ed9eccbe 1952 dev->close(dev);
ed9eccbe
DS		 1953
1954 module_put(THIS_MODULE);
476b8477 1955 if (dev->attached)
ed9eccbe 1956 module_put(dev->driver->module);
ed9eccbe
DS		 1957
1958 dev->use_count--;
1959
1960 mutex_unlock(&dev->mutex);
1961
476b8477 1962 if (file->f_flags & FASYNC)
ed9eccbe 1963 comedi_fasync(-1, file, 0);
ed9eccbe
DS		 1964
1965 return 0;
1966}
1967
1968static int comedi_fasync(int fd, struct file *file, int on)
1969{
1970 const unsigned minor = iminor(file->f_dentry->d_inode);
3ffab428
BP		 1971 struct comedi_device_file_info *dev_file_info;
1972 struct comedi_device *dev;
1973 dev_file_info = comedi_get_device_file_info(minor);
476b8477 1974
3ffab428
BP		 1975 if (dev_file_info == NULL)
1976 return -ENODEV;
1977 dev = dev_file_info->device;
1978 if (dev == NULL)
1979 return -ENODEV;
ed9eccbe
DS		 1980
1981 return fasync_helper(fd, file, on, &dev->async_queue);
1982}
1983
1984const struct file_operations comedi_fops = {
0a85b6f0 1985 .owner = THIS_MODULE,
0a85b6f0 1986 .unlocked_ioctl = comedi_unlocked_ioctl,
0a85b6f0 1987 .compat_ioctl = comedi_compat_ioctl,
0a85b6f0
MT		 1988 .open = comedi_open,
1989 .release = comedi_close,
1990 .read = comedi_read,
1991 .write = comedi_write,
1992 .mmap = comedi_mmap,
1993 .poll = comedi_poll,
1994 .fasync = comedi_fasync,
6038f373 1995 .llseek = noop_llseek,
ed9eccbe
DS		 1996};
1997
476b8477 1998struct class *comedi_class;
ed9eccbe
DS		 1999static struct cdev comedi_cdev;
2000
2001static void comedi_cleanup_legacy_minors(void)
2002{
2003 unsigned i;
476b8477 2004
1dd33ab8 2005 for (i = 0; i < comedi_num_legacy_minors; i++)
ed9eccbe 2006 comedi_free_board_minor(i);
ed9eccbe
DS		 2007}
2008
2009static int __init comedi_init(void)
2010{
2011 int i;
2012 int retval;
2013
476b8477
GKH		 2014 printk(KERN_INFO "comedi: version " COMEDI_RELEASE
2015 " - http://www.comedi.org\n");
ed9eccbe 2016
a3cb729e
FMH		 2017 if (comedi_num_legacy_minors < 0 ||
2018 comedi_num_legacy_minors > COMEDI_NUM_BOARD_MINORS) {
2019 printk(KERN_ERR "comedi: error: invalid value for module "
2020 "parameter \"comedi_num_legacy_minors\". Valid values "
2021 "are 0 through %i.\n", COMEDI_NUM_BOARD_MINORS);
2022 return -EINVAL;
2023 }
2024
2025 /*
2026 * comedi is unusable if both comedi_autoconfig and
2027 * comedi_num_legacy_minors are zero, so we might as well adjust the
2028 * defaults in that case
2029 */
2030 if (comedi_autoconfig == 0 && comedi_num_legacy_minors == 0)
2031 comedi_num_legacy_minors = 16;
2032
476b8477
GKH		 2033 memset(comedi_file_info_table, 0,
2034 sizeof(struct comedi_device_file_info *) * COMEDI_NUM_MINORS);
ed9eccbe
DS		 2035
2036 retval = register_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
476b8477 2037 COMEDI_NUM_MINORS, "comedi");
ed9eccbe
DS		 2038 if (retval)
2039 return -EIO;
2040 cdev_init(&comedi_cdev, &comedi_fops);
2041 comedi_cdev.owner = THIS_MODULE;
2042 kobject_set_name(&comedi_cdev.kobj, "comedi");
2043 if (cdev_add(&comedi_cdev, MKDEV(COMEDI_MAJOR, 0), COMEDI_NUM_MINORS)) {
2044 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
476b8477 2045 COMEDI_NUM_MINORS);
ed9eccbe
DS		 2046 return -EIO;
2047 }
2048 comedi_class = class_create(THIS_MODULE, "comedi");
2049 if (IS_ERR(comedi_class)) {
3fffdf20 2050 printk(KERN_ERR "comedi: failed to create class");
ed9eccbe
DS		 2051 cdev_del(&comedi_cdev);
2052 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
476b8477 2053 COMEDI_NUM_MINORS);
ed9eccbe
DS		 2054 return PTR_ERR(comedi_class);
2055 }
2056
2057 /* XXX requires /proc interface */
2058 comedi_proc_init();
2059
476b8477 2060 /* create devices files for legacy/manual use */
1dd33ab8 2061 for (i = 0; i < comedi_num_legacy_minors; i++) {
ed9eccbe
DS		 2062 int minor;
2063 minor = comedi_alloc_board_minor(NULL);
476b8477 2064 if (minor < 0) {
ed9eccbe
DS		 2065 comedi_cleanup_legacy_minors();
2066 cdev_del(&comedi_cdev);
2067 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0),
476b8477 2068 COMEDI_NUM_MINORS);
ed9eccbe
DS		 2069 return minor;
2070 }
2071 }
2072
ed9eccbe
DS		 2073 return 0;
2074}
2075
2076static void __exit comedi_cleanup(void)
2077{
2078 int i;
2079
2080 comedi_cleanup_legacy_minors();
476b8477 2081 for (i = 0; i < COMEDI_NUM_MINORS; ++i)
ed9eccbe 2082 BUG_ON(comedi_file_info_table[i]);
476b8477 2083
ed9eccbe
DS		 2084 class_destroy(comedi_class);
2085 cdev_del(&comedi_cdev);
2086 unregister_chrdev_region(MKDEV(COMEDI_MAJOR, 0), COMEDI_NUM_MINORS);
2087
2088 comedi_proc_cleanup();
ed9eccbe
DS		 2089}
2090
2091module_init(comedi_init);
2092module_exit(comedi_cleanup);
2093
71b5f4f1 2094void comedi_error(const struct comedi_device *dev, const char *s)
ed9eccbe 2095{
3fffdf20
MR		 2096 printk(KERN_ERR "comedi%d: %s: %s\n", dev->minor,
2097 dev->driver->driver_name, s);
ed9eccbe 2098}
18736438 2099EXPORT_SYMBOL(comedi_error);
ed9eccbe 2100
34c43922 2101void comedi_event(struct comedi_device *dev, struct comedi_subdevice *s)
ed9eccbe 2102{
d163679c 2103 struct comedi_async *async = s->async;
ed9eccbe
DS		 2104 unsigned runflags = 0;
2105 unsigned runflags_mask = 0;
2106
476b8477 2107 /* DPRINTK("comedi_event 0x%x\n",mask); */
ed9eccbe
DS		 2108
2109 if ((comedi_get_subdevice_runflags(s) & SRF_RUNNING) == 0)
2110 return;
2111
0a85b6f0
MT		 2112 if (s->
2113 async->events & (COMEDI_CB_EOA | COMEDI_CB_ERROR |
2114 COMEDI_CB_OVERFLOW)) {
ed9eccbe
DS		 2115 runflags_mask |= SRF_RUNNING;
2116 }
25985edc 2117 /* remember if an error event has occurred, so an error
ed9eccbe
DS		 2118 * can be returned the next time the user does a read() */
2119 if (s->async->events & (COMEDI_CB_ERROR | COMEDI_CB_OVERFLOW)) {
2120 runflags_mask |= SRF_ERROR;
2121 runflags |= SRF_ERROR;
2122 }
2123 if (runflags_mask) {
2124 /*sets SRF_ERROR and SRF_RUNNING together atomically */
2125 comedi_set_subdevice_runflags(s, runflags_mask, runflags);
2126 }
2127
2128 if (async->cb_mask & s->async->events) {
2129 if (comedi_get_subdevice_runflags(s) & SRF_USER) {
fcea1154 2130 wake_up_interruptible(&async->wait_head);
6705b68d 2131 if (s->subdev_flags & SDF_CMD_READ)
0a85b6f0 2132 kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
6705b68d 2133 if (s->subdev_flags & SDF_CMD_WRITE)
0a85b6f0 2134 kill_fasync(&dev->async_queue, SIGIO, POLL_OUT);
ed9eccbe
DS		 2135 } else {
2136 if (async->cb_func)
2137 async->cb_func(s->async->events, async->cb_arg);
ed9eccbe
DS		 2138 }
2139 }
2140 s->async->events = 0;
2141}
18736438 2142EXPORT_SYMBOL(comedi_event);
ed9eccbe 2143
34c43922 2144unsigned comedi_get_subdevice_runflags(struct comedi_subdevice *s)
ed9eccbe
DS		 2145{
2146 unsigned long flags;
2147 unsigned runflags;
2148
5f74ea14 2149 spin_lock_irqsave(&s->spin_lock, flags);
ed9eccbe 2150 runflags = s->runflags;
5f74ea14 2151 spin_unlock_irqrestore(&s->spin_lock, flags);
ed9eccbe
DS		 2152 return runflags;
2153}
18736438 2154EXPORT_SYMBOL(comedi_get_subdevice_runflags);
ed9eccbe 2155
71b5f4f1 2156static int is_device_busy(struct comedi_device *dev)
ed9eccbe 2157{
34c43922 2158 struct comedi_subdevice *s;
ed9eccbe
DS		 2159 int i;
2160
2161 if (!dev->attached)
2162 return 0;
2163
2164 for (i = 0; i < dev->n_subdevices; i++) {
2165 s = dev->subdevices + i;
2166 if (s->busy)
2167 return 1;
2168 if (s->async && s->async->mmap_count)
2169 return 1;
2170 }
2171
2172 return 0;
2173}
2174
92d0127c 2175static void comedi_device_init(struct comedi_device *dev)
ed9eccbe 2176{
71b5f4f1 2177 memset(dev, 0, sizeof(struct comedi_device));
ed9eccbe
DS		 2178 spin_lock_init(&dev->spinlock);
2179 mutex_init(&dev->mutex);
2180 dev->minor = -1;
2181}
2182
92d0127c 2183static void comedi_device_cleanup(struct comedi_device *dev)
ed9eccbe 2184{
476b8477
GKH		 2185 if (dev == NULL)
2186 return;
ed9eccbe
DS		 2187 mutex_lock(&dev->mutex);
2188 comedi_device_detach(dev);
2189 mutex_unlock(&dev->mutex);
2190 mutex_destroy(&dev->mutex);
2191}
2192
2193int comedi_alloc_board_minor(struct device *hardware_device)
2194{
2195 unsigned long flags;
2196 struct comedi_device_file_info *info;
0bfbbe8f 2197 struct device *csdev;
ed9eccbe 2198 unsigned i;
883db3d9 2199 int retval;
ed9eccbe
DS		 2200
2201 info = kzalloc(sizeof(struct comedi_device_file_info), GFP_KERNEL);
476b8477
GKH		 2202 if (info == NULL)
2203 return -ENOMEM;
71b5f4f1 2204 info->device = kzalloc(sizeof(struct comedi_device), GFP_KERNEL);
476b8477 2205 if (info->device == NULL) {
ed9eccbe
DS		 2206 kfree(info);
2207 return -ENOMEM;
2208 }
2209 comedi_device_init(info->device);
5f74ea14 2210 spin_lock_irqsave(&comedi_file_info_table_lock, flags);
476b8477
GKH		 2211 for (i = 0; i < COMEDI_NUM_BOARD_MINORS; ++i) {
2212 if (comedi_file_info_table[i] == NULL) {
ed9eccbe
DS		 2213 comedi_file_info_table[i] = info;
2214 break;
2215 }
2216 }
5f74ea14 2217 spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);
476b8477 2218 if (i == COMEDI_NUM_BOARD_MINORS) {
ed9eccbe
DS		 2219 comedi_device_cleanup(info->device);
2220 kfree(info->device);
2221 kfree(info);
0a85b6f0 2222 printk(KERN_ERR
21fe2eea
M		 2223 "comedi: error: "
2224 "ran out of minor numbers for board device files.\n");
ed9eccbe
DS		 2225 return -EBUSY;
2226 }
2227 info->device->minor = i;
0435f933
PR		 2228 csdev = device_create(comedi_class, hardware_device,
2229 MKDEV(COMEDI_MAJOR, i), NULL, "comedi%i", i);
476b8477 2230 if (!IS_ERR(csdev))
ed9eccbe 2231 info->device->class_dev = csdev;
883db3d9
FMH		 2232 dev_set_drvdata(csdev, info);
2233 retval = device_create_file(csdev, &dev_attr_max_read_buffer_kb);
2234 if (retval) {
0a85b6f0 2235 printk(KERN_ERR
21fe2eea
M		 2236 "comedi: "
2237 "failed to create sysfs attribute file \"%s\".\n",
0a85b6f0 2238 dev_attr_max_read_buffer_kb.attr.name);
883db3d9
FMH		 2239 comedi_free_board_minor(i);
2240 return retval;
2241 }
2242 retval = device_create_file(csdev, &dev_attr_read_buffer_kb);
2243 if (retval) {
0a85b6f0 2244 printk(KERN_ERR
21fe2eea
M		 2245 "comedi: "
2246 "failed to create sysfs attribute file \"%s\".\n",
0a85b6f0 2247 dev_attr_read_buffer_kb.attr.name);
883db3d9
FMH		 2248 comedi_free_board_minor(i);
2249 return retval;
2250 }
2251 retval = device_create_file(csdev, &dev_attr_max_write_buffer_kb);
2252 if (retval) {
0a85b6f0 2253 printk(KERN_ERR
21fe2eea
M		 2254 "comedi: "
2255 "failed to create sysfs attribute file \"%s\".\n",
0a85b6f0 2256 dev_attr_max_write_buffer_kb.attr.name);
883db3d9
FMH		 2257 comedi_free_board_minor(i);
2258 return retval;
2259 }
2260 retval = device_create_file(csdev, &dev_attr_write_buffer_kb);
2261 if (retval) {
0a85b6f0 2262 printk(KERN_ERR
21fe2eea
M		 2263 "comedi: "
2264 "failed to create sysfs attribute file \"%s\".\n",
0a85b6f0 2265 dev_attr_write_buffer_kb.attr.name);
883db3d9
FMH		 2266 comedi_free_board_minor(i);
2267 return retval;
2268 }
ed9eccbe
DS		 2269 return i;
2270}
2271
2272void comedi_free_board_minor(unsigned minor)
2273{
2274 unsigned long flags;
2275 struct comedi_device_file_info *info;
2276
2277 BUG_ON(minor >= COMEDI_NUM_BOARD_MINORS);
5f74ea14 2278 spin_lock_irqsave(&comedi_file_info_table_lock, flags);
ed9eccbe
DS		 2279 info = comedi_file_info_table[minor];
2280 comedi_file_info_table[minor] = NULL;
5f74ea14 2281 spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);
ed9eccbe 2282
476b8477 2283 if (info) {
71b5f4f1 2284 struct comedi_device *dev = info->device;
476b8477
GKH		 2285 if (dev) {
2286 if (dev->class_dev) {
2287 device_destroy(comedi_class,
2288 MKDEV(COMEDI_MAJOR, dev->minor));
ed9eccbe
DS		 2289 }
2290 comedi_device_cleanup(dev);
2291 kfree(dev);
2292 }
2293 kfree(info);
2294 }
2295}
2296
883db3d9
FMH		 2297int comedi_alloc_subdevice_minor(struct comedi_device *dev,
2298 struct comedi_subdevice *s)
ed9eccbe
DS		 2299{
2300 unsigned long flags;
2301 struct comedi_device_file_info *info;
0bfbbe8f 2302 struct device *csdev;
ed9eccbe 2303 unsigned i;
883db3d9 2304 int retval;
ed9eccbe
DS		 2305
2306 info = kmalloc(sizeof(struct comedi_device_file_info), GFP_KERNEL);
476b8477
GKH		 2307 if (info == NULL)
2308 return -ENOMEM;
ed9eccbe
DS		 2309 info->device = dev;
2310 info->read_subdevice = s;
2311 info->write_subdevice = s;
5f74ea14 2312 spin_lock_irqsave(&comedi_file_info_table_lock, flags);
4c41f3ae 2313 for (i = COMEDI_FIRST_SUBDEVICE_MINOR; i < COMEDI_NUM_MINORS; ++i) {
476b8477 2314 if (comedi_file_info_table[i] == NULL) {
ed9eccbe
DS		 2315 comedi_file_info_table[i] = info;
2316 break;
2317 }
2318 }
5f74ea14 2319 spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);
476b8477 2320 if (i == COMEDI_NUM_MINORS) {
ed9eccbe 2321 kfree(info);
0a85b6f0 2322 printk(KERN_ERR
21fe2eea
M		 2323 "comedi: error: "
2324 "ran out of minor numbers for board device files.\n");
ed9eccbe
DS		 2325 return -EBUSY;
2326 }
2327 s->minor = i;
0435f933
PR		 2328 csdev = device_create(comedi_class, dev->class_dev,
2329 MKDEV(COMEDI_MAJOR, i), NULL, "comedi%i_subd%i",
2330 dev->minor, (int)(s - dev->subdevices));
476b8477 2331 if (!IS_ERR(csdev))
ed9eccbe 2332 s->class_dev = csdev;
883db3d9
FMH		 2333 dev_set_drvdata(csdev, info);
2334 retval = device_create_file(csdev, &dev_attr_max_read_buffer_kb);
2335 if (retval) {
0a85b6f0 2336 printk(KERN_ERR
21fe2eea
M		 2337 "comedi: "
2338 "failed to create sysfs attribute file \"%s\".\n",
0a85b6f0 2339 dev_attr_max_read_buffer_kb.attr.name);
883db3d9
FMH		 2340 comedi_free_subdevice_minor(s);
2341 return retval;
2342 }
2343 retval = device_create_file(csdev, &dev_attr_read_buffer_kb);
2344 if (retval) {
0a85b6f0 2345 printk(KERN_ERR
21fe2eea
M		 2346 "comedi: "
2347 "failed to create sysfs attribute file \"%s\".\n",
0a85b6f0 2348 dev_attr_read_buffer_kb.attr.name);
883db3d9
FMH		 2349 comedi_free_subdevice_minor(s);
2350 return retval;
2351 }
2352 retval = device_create_file(csdev, &dev_attr_max_write_buffer_kb);
2353 if (retval) {
0a85b6f0 2354 printk(KERN_ERR
21fe2eea
M		 2355 "comedi: "
2356 "failed to create sysfs attribute file \"%s\".\n",
0a85b6f0 2357 dev_attr_max_write_buffer_kb.attr.name);
883db3d9
FMH		 2358 comedi_free_subdevice_minor(s);
2359 return retval;
2360 }
2361 retval = device_create_file(csdev, &dev_attr_write_buffer_kb);
2362 if (retval) {
0a85b6f0 2363 printk(KERN_ERR
21fe2eea
M		 2364 "comedi: "
2365 "failed to create sysfs attribute file \"%s\".\n",
0a85b6f0 2366 dev_attr_write_buffer_kb.attr.name);
883db3d9
FMH		 2367 comedi_free_subdevice_minor(s);
2368 return retval;
2369 }
ed9eccbe
DS		 2370 return i;
2371}
2372
34c43922 2373void comedi_free_subdevice_minor(struct comedi_subdevice *s)
ed9eccbe
DS		 2374{
2375 unsigned long flags;
2376 struct comedi_device_file_info *info;
2377
476b8477
GKH		 2378 if (s == NULL)
2379 return;
2380 if (s->minor < 0)
2381 return;
ed9eccbe
DS		 2382
2383 BUG_ON(s->minor >= COMEDI_NUM_MINORS);
2384 BUG_ON(s->minor < COMEDI_FIRST_SUBDEVICE_MINOR);
2385
5f74ea14 2386 spin_lock_irqsave(&comedi_file_info_table_lock, flags);
ed9eccbe
DS		 2387 info = comedi_file_info_table[s->minor];
2388 comedi_file_info_table[s->minor] = NULL;
5f74ea14 2389 spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);
ed9eccbe 2390
476b8477 2391 if (s->class_dev) {
ed9eccbe
DS		 2392 device_destroy(comedi_class, MKDEV(COMEDI_MAJOR, s->minor));
2393 s->class_dev = NULL;
2394 }
2395 kfree(info);
2396}
2397
2398struct comedi_device_file_info *comedi_get_device_file_info(unsigned minor)
2399{
2400 unsigned long flags;
2401 struct comedi_device_file_info *info;
2402
2403 BUG_ON(minor >= COMEDI_NUM_MINORS);
5f74ea14 2404 spin_lock_irqsave(&comedi_file_info_table_lock, flags);
ed9eccbe 2405 info = comedi_file_info_table[minor];
5f74ea14 2406 spin_unlock_irqrestore(&comedi_file_info_table_lock, flags);
ed9eccbe
DS		 2407 return info;
2408}
18736438 2409EXPORT_SYMBOL_GPL(comedi_get_device_file_info);
883db3d9
FMH		 2410
2411static int resize_async_buffer(struct comedi_device *dev,
2412 struct comedi_subdevice *s,
2413 struct comedi_async *async, unsigned new_size)
2414{
2415 int retval;
2416
2417 if (new_size > async->max_bufsize)
2418 return -EPERM;
2419
2420 if (s->busy) {
2421 DPRINTK("subdevice is busy, cannot resize buffer\n");
2422 return -EBUSY;
2423 }
2424 if (async->mmap_count) {
2425 DPRINTK("subdevice is mmapped, cannot resize buffer\n");
2426 return -EBUSY;
2427 }
2428
2429 if (!async->prealloc_buf)
2430 return -EINVAL;
2431
2432 /* make sure buffer is an integral number of pages
0a85b6f0 2433 * (we round up) */
883db3d9
FMH		 2434 new_size = (new_size + PAGE_SIZE - 1) & PAGE_MASK;
2435
2436 retval = comedi_buf_alloc(dev, s, new_size);
2437 if (retval < 0)
2438 return retval;
2439
2440 if (s->buf_change) {
2441 retval = s->buf_change(dev, s, new_size);
2442 if (retval < 0)
2443 return retval;
2444 }
2445
2446 DPRINTK("comedi%i subd %d buffer resized to %i bytes\n",
b8b5cd9f 2447 dev->minor, (int)(s - dev->subdevices), async->prealloc_bufsz);
883db3d9
FMH		 2448 return 0;
2449}
2450
2451/* sysfs attribute files */
2452
2453static const unsigned bytes_per_kibi = 1024;
2454
2455static ssize_t show_max_read_buffer_kb(struct device *dev,
2456 struct device_attribute *attr, char *buf)
2457{
2458 ssize_t retval;
2459 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2460 unsigned max_buffer_size_kb = 0;
2461 struct comedi_subdevice *const read_subdevice =
0a85b6f0 2462 comedi_get_read_subdevice(info);
883db3d9
FMH		 2463
2464 mutex_lock(&info->device->mutex);
2465 if (read_subdevice &&
2466 (read_subdevice->subdev_flags & SDF_CMD_READ) &&
2467 read_subdevice->async) {
2468 max_buffer_size_kb = read_subdevice->async->max_bufsize /
0a85b6f0 2469 bytes_per_kibi;
883db3d9 2470 }
0a85b6f0 2471 retval = snprintf(buf, PAGE_SIZE, "%i\n", max_buffer_size_kb);
883db3d9
FMH		 2472 mutex_unlock(&info->device->mutex);
2473
2474 return retval;
2475}
2476
2477static ssize_t store_max_read_buffer_kb(struct device *dev,
2478 struct device_attribute *attr,
2479 const char *buf, size_t count)
2480{
2481 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2482 unsigned long new_max_size_kb;
2483 uint64_t new_max_size;
2484 struct comedi_subdevice *const read_subdevice =
0a85b6f0 2485 comedi_get_read_subdevice(info);
883db3d9
FMH		 2486
2487 if (strict_strtoul(buf, 10, &new_max_size_kb))
2488 return -EINVAL;
0a85b6f0 2489 if (new_max_size_kb != (uint32_t) new_max_size_kb)
883db3d9 2490 return -EINVAL;
0a85b6f0
MT		 2491 new_max_size = ((uint64_t) new_max_size_kb) * bytes_per_kibi;
2492 if (new_max_size != (uint32_t) new_max_size)
883db3d9
FMH		 2493 return -EINVAL;
2494
2495 mutex_lock(&info->device->mutex);
2496 if (read_subdevice == NULL ||
2497 (read_subdevice->subdev_flags & SDF_CMD_READ) == 0 ||
2498 read_subdevice->async == NULL) {
2499 mutex_unlock(&info->device->mutex);
2500 return -EINVAL;
2501 }
2502 read_subdevice->async->max_bufsize = new_max_size;
2503 mutex_unlock(&info->device->mutex);
2504
2505 return count;
2506}
2507
2508static struct device_attribute dev_attr_max_read_buffer_kb = {
2509 .attr = {
0a85b6f0
MT		 2510 .name = "max_read_buffer_kb",
2511 .mode = S_IRUGO | S_IWUSR},
883db3d9
FMH		 2512 .show = &show_max_read_buffer_kb,
2513 .store = &store_max_read_buffer_kb
2514};
2515
2516static ssize_t show_read_buffer_kb(struct device *dev,
2517 struct device_attribute *attr, char *buf)
2518{
2519 ssize_t retval;
2520 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2521 unsigned buffer_size_kb = 0;
2522 struct comedi_subdevice *const read_subdevice =
0a85b6f0 2523 comedi_get_read_subdevice(info);
883db3d9
FMH		 2524
2525 mutex_lock(&info->device->mutex);
2526 if (read_subdevice &&
0a85b6f0
MT		 2527 (read_subdevice->subdev_flags & SDF_CMD_READ) &&
2528 read_subdevice->async) {
883db3d9 2529 buffer_size_kb = read_subdevice->async->prealloc_bufsz /
0a85b6f0 2530 bytes_per_kibi;
883db3d9 2531 }
0a85b6f0 2532 retval = snprintf(buf, PAGE_SIZE, "%i\n", buffer_size_kb);
883db3d9
FMH		 2533 mutex_unlock(&info->device->mutex);
2534
2535 return retval;
2536}
2537
2538static ssize_t store_read_buffer_kb(struct device *dev,
2539 struct device_attribute *attr,
2540 const char *buf, size_t count)
2541{
2542 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2543 unsigned long new_size_kb;
2544 uint64_t new_size;
2545 int retval;
2546 struct comedi_subdevice *const read_subdevice =
0a85b6f0 2547 comedi_get_read_subdevice(info);
883db3d9
FMH		 2548
2549 if (strict_strtoul(buf, 10, &new_size_kb))
2550 return -EINVAL;
0a85b6f0 2551 if (new_size_kb != (uint32_t) new_size_kb)
883db3d9 2552 return -EINVAL;
0a85b6f0
MT		 2553 new_size = ((uint64_t) new_size_kb) * bytes_per_kibi;
2554 if (new_size != (uint32_t) new_size)
883db3d9
FMH		 2555 return -EINVAL;
2556
2557 mutex_lock(&info->device->mutex);
2558 if (read_subdevice == NULL ||
2559 (read_subdevice->subdev_flags & SDF_CMD_READ) == 0 ||
2560 read_subdevice->async == NULL) {
2561 mutex_unlock(&info->device->mutex);
2562 return -EINVAL;
2563 }
2564 retval = resize_async_buffer(info->device, read_subdevice,
2565 read_subdevice->async, new_size);
2566 mutex_unlock(&info->device->mutex);
2567
2568 if (retval < 0)
2569 return retval;
2570 return count;
2571}
2572
2573static struct device_attribute dev_attr_read_buffer_kb = {
2574 .attr = {
0a85b6f0
MT		 2575 .name = "read_buffer_kb",
2576 .mode = S_IRUGO | S_IWUSR | S_IWGRP},
883db3d9
FMH		 2577 .show = &show_read_buffer_kb,
2578 .store = &store_read_buffer_kb
2579};
2580
2581static ssize_t show_max_write_buffer_kb(struct device *dev,
2582 struct device_attribute *attr,
2583 char *buf)
2584{
2585 ssize_t retval;
2586 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2587 unsigned max_buffer_size_kb = 0;
2588 struct comedi_subdevice *const write_subdevice =
0a85b6f0 2589 comedi_get_write_subdevice(info);
883db3d9
FMH		 2590
2591 mutex_lock(&info->device->mutex);
2592 if (write_subdevice &&
2593 (write_subdevice->subdev_flags & SDF_CMD_WRITE) &&
2594 write_subdevice->async) {
2595 max_buffer_size_kb = write_subdevice->async->max_bufsize /
0a85b6f0 2596 bytes_per_kibi;
883db3d9 2597 }
0a85b6f0 2598 retval = snprintf(buf, PAGE_SIZE, "%i\n", max_buffer_size_kb);
883db3d9
FMH		 2599 mutex_unlock(&info->device->mutex);
2600
2601 return retval;
2602}
2603
2604static ssize_t store_max_write_buffer_kb(struct device *dev,
2605 struct device_attribute *attr,
2606 const char *buf, size_t count)
2607{
2608 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2609 unsigned long new_max_size_kb;
2610 uint64_t new_max_size;
2611 struct comedi_subdevice *const write_subdevice =
0a85b6f0 2612 comedi_get_write_subdevice(info);
883db3d9
FMH		 2613
2614 if (strict_strtoul(buf, 10, &new_max_size_kb))
2615 return -EINVAL;
0a85b6f0 2616 if (new_max_size_kb != (uint32_t) new_max_size_kb)
883db3d9 2617 return -EINVAL;
0a85b6f0
MT		 2618 new_max_size = ((uint64_t) new_max_size_kb) * bytes_per_kibi;
2619 if (new_max_size != (uint32_t) new_max_size)
883db3d9
FMH		 2620 return -EINVAL;
2621
2622 mutex_lock(&info->device->mutex);
2623 if (write_subdevice == NULL ||
2624 (write_subdevice->subdev_flags & SDF_CMD_WRITE) == 0 ||
2625 write_subdevice->async == NULL) {
2626 mutex_unlock(&info->device->mutex);
2627 return -EINVAL;
2628 }
2629 write_subdevice->async->max_bufsize = new_max_size;
2630 mutex_unlock(&info->device->mutex);
2631
2632 return count;
2633}
2634
2635static struct device_attribute dev_attr_max_write_buffer_kb = {
2636 .attr = {
0a85b6f0
MT		 2637 .name = "max_write_buffer_kb",
2638 .mode = S_IRUGO | S_IWUSR},
883db3d9
FMH		 2639 .show = &show_max_write_buffer_kb,
2640 .store = &store_max_write_buffer_kb
2641};
2642
2643static ssize_t show_write_buffer_kb(struct device *dev,
2644 struct device_attribute *attr, char *buf)
2645{
2646 ssize_t retval;
2647 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2648 unsigned buffer_size_kb = 0;
2649 struct comedi_subdevice *const write_subdevice =
0a85b6f0 2650 comedi_get_write_subdevice(info);
883db3d9
FMH		 2651
2652 mutex_lock(&info->device->mutex);
2653 if (write_subdevice &&
2654 (write_subdevice->subdev_flags & SDF_CMD_WRITE) &&
2655 write_subdevice->async) {
2656 buffer_size_kb = write_subdevice->async->prealloc_bufsz /
0a85b6f0 2657 bytes_per_kibi;
883db3d9 2658 }
0a85b6f0 2659 retval = snprintf(buf, PAGE_SIZE, "%i\n", buffer_size_kb);
883db3d9
FMH		 2660 mutex_unlock(&info->device->mutex);
2661
2662 return retval;
2663}
2664
2665static ssize_t store_write_buffer_kb(struct device *dev,
2666 struct device_attribute *attr,
2667 const char *buf, size_t count)
2668{
2669 struct comedi_device_file_info *info = dev_get_drvdata(dev);
2670 unsigned long new_size_kb;
2671 uint64_t new_size;
2672 int retval;
2673 struct comedi_subdevice *const write_subdevice =
0a85b6f0 2674 comedi_get_write_subdevice(info);
883db3d9
FMH		 2675
2676 if (strict_strtoul(buf, 10, &new_size_kb))
2677 return -EINVAL;
0a85b6f0 2678 if (new_size_kb != (uint32_t) new_size_kb)
883db3d9 2679 return -EINVAL;
0a85b6f0
MT		 2680 new_size = ((uint64_t) new_size_kb) * bytes_per_kibi;
2681 if (new_size != (uint32_t) new_size)
883db3d9
FMH		 2682 return -EINVAL;
2683
2684 mutex_lock(&info->device->mutex);
2685 if (write_subdevice == NULL ||
2686 (write_subdevice->subdev_flags & SDF_CMD_WRITE) == 0 ||
2687 write_subdevice->async == NULL) {
2688 mutex_unlock(&info->device->mutex);
2689 return -EINVAL;
2690 }
2691 retval = resize_async_buffer(info->device, write_subdevice,
0a85b6f0 2692 write_subdevice->async, new_size);
883db3d9
FMH		 2693 mutex_unlock(&info->device->mutex);
2694
2695 if (retval < 0)
2696 return retval;
2697 return count;
2698}
2699
2700static struct device_attribute dev_attr_write_buffer_kb = {
2701 .attr = {
0a85b6f0
MT		 2702 .name = "write_buffer_kb",
2703 .mode = S_IRUGO | S_IWUSR | S_IWGRP},
883db3d9
FMH		 2704 .show = &show_write_buffer_kb,
2705 .store = &store_write_buffer_kb
2706};
kernel source for telekom puls (alcatel/mediatek)