git.oblomov.eu Git - linux-2.6/blob - drivers/staging/comedi/comedi_fops.c

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