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