drivers/staging/comedi/comedi_fops.c

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