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