drivers/media/rc/lirc_dev.c

   1 /*
   2  * LIRC base driver
   3  *
   4  * by Artur Lipowski <alipowski@interia.pl>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  24 #include <linux/module.h>
  25 #include <linux/kernel.h>
  26 #include <linux/sched.h>
  27 #include <linux/errno.h>
  28 #include <linux/ioctl.h>
  29 #include <linux/fs.h>
  30 #include <linux/poll.h>
  31 #include <linux/completion.h>
  32 #include <linux/mutex.h>
  33 #include <linux/wait.h>
  34 #include <linux/unistd.h>
  35 #include <linux/kthread.h>
  36 #include <linux/bitops.h>
  37 #include <linux/device.h>
  38 #include <linux/cdev.h>
  39
  40 #include <media/rc-core.h>
  41 #include <media/lirc.h>
  42 #include <media/lirc_dev.h>
  43
  44 static bool debug;
  45
  46 #define IRCTL_DEV_NAME  "BaseRemoteCtl"
  47 #define NOPLUG          -1
  48 #define LOGHEAD         "lirc_dev (%s[%d]): "
  49
  50 static dev_t lirc_base_dev;
  51
  52 struct irctl {
  53         struct lirc_driver d;
  54         int attached;
  55         int open;
  56
  57         struct mutex irctl_lock;
  58         struct lirc_buffer *buf;
  59         unsigned int chunk_size;
  60
  61         struct cdev *cdev;
  62
  63         struct task_struct *task;
  64         long jiffies_to_wait;
  65 };
  66
  67 static DEFINE_MUTEX(lirc_dev_lock);
  68
  69 static struct irctl *irctls[MAX_IRCTL_DEVICES];
  70
  71 /* Only used for sysfs but defined to void otherwise */
  72 static struct class *lirc_class;
  73
  74 /*  helper function
  75  *  initializes the irctl structure
  76  */
  77 static void lirc_irctl_init(struct irctl *ir)
  78 {
  79         mutex_init(&ir->irctl_lock);
  80         ir->d.minor = NOPLUG;
  81 }
  82
  83 static void lirc_irctl_cleanup(struct irctl *ir)
  84 {
  85         device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor));
  86
  87         if (ir->buf != ir->d.rbuf) {
  88                 lirc_buffer_free(ir->buf);
  89                 kfree(ir->buf);
  90         }
  91         ir->buf = NULL;
  92 }
  93
  94 /*  helper function
  95  *  reads key codes from driver and puts them into buffer
  96  *  returns 0 on success
  97  */
  98 static int lirc_add_to_buf(struct irctl *ir)
  99 {
 100         if (ir->d.add_to_buf) {
 101                 int res = -ENODATA;
 102                 int got_data = 0;
 103
 104                 /*
 105                  * service the device as long as it is returning
 106                  * data and we have space
 107                  */
 108 get_data:
 109                 res = ir->d.add_to_buf(ir->d.data, ir->buf);
 110                 if (res == 0) {
 111                         got_data++;
 112                         goto get_data;
 113                 }
 114
 115                 if (res == -ENODEV)
 116                         kthread_stop(ir->task);
 117
 118                 return got_data ? 0 : res;
 119         }
 120
 121         return 0;
 122 }
 123
 124 /* main function of the polling thread
 125  */
 126 static int lirc_thread(void *irctl)
 127 {
 128         struct irctl *ir = irctl;
 129
 130         do {
 131                 if (ir->open) {
 132                         if (ir->jiffies_to_wait) {
 133                                 set_current_state(TASK_INTERRUPTIBLE);
 134                                 schedule_timeout(ir->jiffies_to_wait);
 135                         }
 136                         if (kthread_should_stop())
 137                                 break;
 138                         if (!lirc_add_to_buf(ir))
 139                                 wake_up_interruptible(&ir->buf->wait_poll);
 140                 } else {
 141                         set_current_state(TASK_INTERRUPTIBLE);
 142                         schedule();
 143                 }
 144         } while (!kthread_should_stop());
 145
 146         return 0;
 147 }
 148
 149
 150 static const struct file_operations lirc_dev_fops = {
 151         .owner          = THIS_MODULE,
 152         .read           = lirc_dev_fop_read,
 153         .write          = lirc_dev_fop_write,
 154         .poll           = lirc_dev_fop_poll,
 155         .unlocked_ioctl = lirc_dev_fop_ioctl,
 156 #ifdef CONFIG_COMPAT
 157         .compat_ioctl   = lirc_dev_fop_ioctl,
 158 #endif
 159         .open           = lirc_dev_fop_open,
 160         .release        = lirc_dev_fop_close,
 161         .llseek         = noop_llseek,
 162 };
 163
 164 static int lirc_cdev_add(struct irctl *ir)
 165 {
 166         int retval = -ENOMEM;
 167         struct lirc_driver *d = &ir->d;
 168         struct cdev *cdev;
 169
 170         cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
 171         if (!cdev)
 172                 goto err_out;
 173
 174         if (d->fops) {
 175                 cdev_init(cdev, d->fops);
 176                 cdev->owner = d->owner;
 177         } else {
 178                 cdev_init(cdev, &lirc_dev_fops);
 179                 cdev->owner = THIS_MODULE;
 180         }
 181         retval = kobject_set_name(&cdev->kobj, "lirc%d", d->minor);
 182         if (retval)
 183                 goto err_out;
 184
 185         retval = cdev_add(cdev, MKDEV(MAJOR(lirc_base_dev), d->minor), 1);
 186         if (retval) {
 187                 kobject_put(&cdev->kobj);
 188                 goto err_out;
 189         }
 190
 191         ir->cdev = cdev;
 192
 193         return 0;
 194
 195 err_out:
 196         kfree(cdev);
 197         return retval;
 198 }
 199
 200 static int lirc_allocate_buffer(struct irctl *ir)
 201 {
 202         int err = 0;
 203         int bytes_in_key;
 204         unsigned int chunk_size;
 205         unsigned int buffer_size;
 206         struct lirc_driver *d = &ir->d;
 207
 208         mutex_lock(&lirc_dev_lock);
 209
 210         bytes_in_key = BITS_TO_LONGS(d->code_length) +
 211                                                 (d->code_length % 8 ? 1 : 0);
 212         buffer_size = d->buffer_size ? d->buffer_size : BUFLEN / bytes_in_key;
 213         chunk_size  = d->chunk_size  ? d->chunk_size  : bytes_in_key;
 214
 215         if (d->rbuf) {
 216                 ir->buf = d->rbuf;
 217         } else {
 218                 ir->buf = kmalloc(sizeof(struct lirc_buffer), GFP_KERNEL);
 219                 if (!ir->buf) {
 220                         err = -ENOMEM;
 221                         goto out;
 222                 }
 223
 224                 err = lirc_buffer_init(ir->buf, chunk_size, buffer_size);
 225                 if (err) {
 226                         kfree(ir->buf);
 227                         goto out;
 228                 }
 229         }
 230         ir->chunk_size = ir->buf->chunk_size;
 231
 232 out:
 233         mutex_unlock(&lirc_dev_lock);
 234
 235         return err;
 236 }
 237
 238 static int lirc_allocate_driver(struct lirc_driver *d)
 239 {
 240         struct irctl *ir;
 241         int minor;
 242         int err;
 243
 244         if (!d) {
 245                 pr_err("driver pointer must be not NULL!\n");
 246                 return -EBADRQC;
 247         }
 248
 249         if (!d->dev) {
 250                 pr_err("dev pointer not filled in!\n");
 251                 return -EINVAL;
 252         }
 253
 254         if (MAX_IRCTL_DEVICES <= d->minor) {
 255                 dev_err(d->dev, "minor must be between 0 and %d!\n",
 256                                                 MAX_IRCTL_DEVICES - 1);
 257                 return -EBADRQC;
 258         }
 259
 260         if (1 > d->code_length || (BUFLEN * 8) < d->code_length) {
 261                 dev_err(d->dev, "code length must be less than %d bits\n",
 262                                                                 BUFLEN * 8);
 263                 return -EBADRQC;
 264         }
 265
 266         if (d->sample_rate) {
 267                 if (2 > d->sample_rate || HZ < d->sample_rate) {
 268                         dev_err(d->dev, "invalid %d sample rate\n",
 269                                                         d->sample_rate);
 270                         return -EBADRQC;
 271                 }
 272                 if (!d->add_to_buf) {
 273                         dev_err(d->dev, "add_to_buf not set\n");
 274                         return -EBADRQC;
 275                 }
 276         } else if (!(d->fops && d->fops->read) && !d->rbuf) {
 277                 dev_err(d->dev, "fops->read and rbuf are NULL!\n");
 278                 return -EBADRQC;
 279         } else if (!d->rbuf) {
 280                 if (!(d->fops && d->fops->read && d->fops->poll &&
 281                       d->fops->unlocked_ioctl)) {
 282                         dev_err(d->dev, "undefined read, poll, ioctl\n");
 283                         return -EBADRQC;
 284                 }
 285         }
 286
 287         mutex_lock(&lirc_dev_lock);
 288
 289         minor = d->minor;
 290
 291         if (minor < 0) {
 292                 /* find first free slot for driver */
 293                 for (minor = 0; minor < MAX_IRCTL_DEVICES; minor++)
 294                         if (!irctls[minor])
 295                                 break;
 296                 if (MAX_IRCTL_DEVICES == minor) {
 297                         dev_err(d->dev, "no free slots for drivers!\n");
 298                         err = -ENOMEM;
 299                         goto out_lock;
 300                 }
 301         } else if (irctls[minor]) {
 302                 dev_err(d->dev, "minor (%d) just registered!\n", minor);
 303                 err = -EBUSY;
 304                 goto out_lock;
 305         }
 306
 307         ir = kzalloc(sizeof(struct irctl), GFP_KERNEL);
 308         if (!ir) {
 309                 err = -ENOMEM;
 310                 goto out_lock;
 311         }
 312         lirc_irctl_init(ir);
 313         irctls[minor] = ir;
 314         d->minor = minor;
 315
 316         if (d->sample_rate) {
 317                 ir->jiffies_to_wait = HZ / d->sample_rate;
 318         } else {
 319                 /* it means - wait for external event in task queue */
 320                 ir->jiffies_to_wait = 0;
 321         }
 322
 323         /* some safety check 8-) */
 324         d->name[sizeof(d->name)-1] = '\0';
 325
 326         if (d->features == 0)
 327                 d->features = LIRC_CAN_REC_LIRCCODE;
 328
 329         ir->d = *d;
 330
 331         device_create(lirc_class, ir->d.dev,
 332                       MKDEV(MAJOR(lirc_base_dev), ir->d.minor), NULL,
 333                       "lirc%u", ir->d.minor);
 334
 335         if (d->sample_rate) {
 336                 /* try to fire up polling thread */
 337                 ir->task = kthread_run(lirc_thread, (void *)ir, "lirc_dev");
 338                 if (IS_ERR(ir->task)) {
 339                         dev_err(d->dev, "cannot run thread for minor = %d\n",
 340                                                                 d->minor);
 341                         err = -ECHILD;
 342                         goto out_sysfs;
 343                 }
 344         }
 345
 346         err = lirc_cdev_add(ir);
 347         if (err)
 348                 goto out_sysfs;
 349
 350         ir->attached = 1;
 351         mutex_unlock(&lirc_dev_lock);
 352
 353         dev_info(ir->d.dev, "lirc_dev: driver %s registered at minor = %d\n",
 354                  ir->d.name, ir->d.minor);
 355         return minor;
 356
 357 out_sysfs:
 358         device_destroy(lirc_class, MKDEV(MAJOR(lirc_base_dev), ir->d.minor));
 359 out_lock:
 360         mutex_unlock(&lirc_dev_lock);
 361
 362         return err;
 363 }
 364
 365 int lirc_register_driver(struct lirc_driver *d)
 366 {
 367         int minor, err = 0;
 368
 369         minor = lirc_allocate_driver(d);
 370         if (minor < 0)
 371                 return minor;
 372
 373         if (LIRC_CAN_REC(d->features)) {
 374                 err = lirc_allocate_buffer(irctls[minor]);
 375                 if (err)
 376                         lirc_unregister_driver(minor);
 377         }
 378
 379         return err ? err : minor;
 380 }
 381 EXPORT_SYMBOL(lirc_register_driver);
 382
 383 int lirc_unregister_driver(int minor)
 384 {
 385         struct irctl *ir;
 386         struct cdev *cdev;
 387
 388         if (minor < 0 || minor >= MAX_IRCTL_DEVICES) {
 389                 pr_err("minor (%d) must be between 0 and %d!\n",
 390                                         minor, MAX_IRCTL_DEVICES - 1);
 391                 return -EBADRQC;
 392         }
 393
 394         ir = irctls[minor];
 395         if (!ir) {
 396                 pr_err("failed to get irctl\n");
 397                 return -ENOENT;
 398         }
 399
 400         cdev = ir->cdev;
 401
 402         mutex_lock(&lirc_dev_lock);
 403
 404         if (ir->d.minor != minor) {
 405                 dev_err(ir->d.dev, "lirc_dev: minor %d device not registered\n",
 406                                                                         minor);
 407                 mutex_unlock(&lirc_dev_lock);
 408                 return -ENOENT;
 409         }
 410
 411         /* end up polling thread */
 412         if (ir->task)
 413                 kthread_stop(ir->task);
 414
 415         dev_dbg(ir->d.dev, "lirc_dev: driver %s unregistered from minor = %d\n",
 416                 ir->d.name, ir->d.minor);
 417
 418         ir->attached = 0;
 419         if (ir->open) {
 420                 dev_dbg(ir->d.dev, LOGHEAD "releasing opened driver\n",
 421                         ir->d.name, ir->d.minor);
 422                 wake_up_interruptible(&ir->buf->wait_poll);
 423                 mutex_lock(&ir->irctl_lock);
 424                 ir->d.set_use_dec(ir->d.data);
 425                 module_put(cdev->owner);
 426                 mutex_unlock(&ir->irctl_lock);
 427         } else {
 428                 lirc_irctl_cleanup(ir);
 429                 cdev_del(cdev);
 430                 kfree(cdev);
 431                 kfree(ir);
 432                 irctls[minor] = NULL;
 433         }
 434
 435         mutex_unlock(&lirc_dev_lock);
 436
 437         return 0;
 438 }
 439 EXPORT_SYMBOL(lirc_unregister_driver);
 440
 441 int lirc_dev_fop_open(struct inode *inode, struct file *file)
 442 {
 443         struct irctl *ir;
 444         struct cdev *cdev;
 445         int retval = 0;
 446
 447         if (iminor(inode) >= MAX_IRCTL_DEVICES) {
 448                 pr_err("open result for %d is -ENODEV\n", iminor(inode));
 449                 return -ENODEV;
 450         }
 451
 452         if (mutex_lock_interruptible(&lirc_dev_lock))
 453                 return -ERESTARTSYS;
 454
 455         ir = irctls[iminor(inode)];
 456         if (!ir) {
 457                 retval = -ENODEV;
 458                 goto error;
 459         }
 460
 461         dev_dbg(ir->d.dev, LOGHEAD "open called\n", ir->d.name, ir->d.minor);
 462
 463         if (ir->d.minor == NOPLUG) {
 464                 retval = -ENODEV;
 465                 goto error;
 466         }
 467
 468         if (ir->open) {
 469                 retval = -EBUSY;
 470                 goto error;
 471         }
 472
 473         if (ir->d.rdev) {
 474                 retval = rc_open(ir->d.rdev);
 475                 if (retval)
 476                         goto error;
 477         }
 478
 479         cdev = ir->cdev;
 480         if (try_module_get(cdev->owner)) {
 481                 ir->open++;
 482                 retval = ir->d.set_use_inc(ir->d.data);
 483
 484                 if (retval) {
 485                         module_put(cdev->owner);
 486                         ir->open--;
 487                 } else {
 488                         lirc_buffer_clear(ir->buf);
 489                 }
 490                 if (ir->task)
 491                         wake_up_process(ir->task);
 492         }
 493
 494 error:
 495         mutex_unlock(&lirc_dev_lock);
 496
 497         nonseekable_open(inode, file);
 498
 499         return retval;
 500 }
 501 EXPORT_SYMBOL(lirc_dev_fop_open);
 502
 503 int lirc_dev_fop_close(struct inode *inode, struct file *file)
 504 {
 505         struct irctl *ir = irctls[iminor(inode)];
 506         struct cdev *cdev;
 507         int ret;
 508
 509         if (!ir) {
 510                 pr_err("called with invalid irctl\n");
 511                 return -EINVAL;
 512         }
 513
 514         cdev = ir->cdev;
 515
 516         ret = mutex_lock_killable(&lirc_dev_lock);
 517         WARN_ON(ret);
 518
 519         rc_close(ir->d.rdev);
 520
 521         ir->open--;
 522         if (ir->attached) {
 523                 ir->d.set_use_dec(ir->d.data);
 524                 module_put(cdev->owner);
 525         } else {
 526                 lirc_irctl_cleanup(ir);
 527                 cdev_del(cdev);
 528                 irctls[ir->d.minor] = NULL;
 529                 kfree(cdev);
 530                 kfree(ir);
 531         }
 532
 533         if (!ret)
 534                 mutex_unlock(&lirc_dev_lock);
 535
 536         return 0;
 537 }
 538 EXPORT_SYMBOL(lirc_dev_fop_close);
 539
 540 unsigned int lirc_dev_fop_poll(struct file *file, poll_table *wait)
 541 {
 542         struct irctl *ir = irctls[iminor(file_inode(file))];
 543         unsigned int ret;
 544
 545         if (!ir) {
 546                 pr_err("called with invalid irctl\n");
 547                 return POLLERR;
 548         }
 549
 550         if (!ir->attached)
 551                 return POLLERR;
 552
 553         if (ir->buf) {
 554                 poll_wait(file, &ir->buf->wait_poll, wait);
 555
 556                 if (lirc_buffer_empty(ir->buf))
 557                         ret = 0;
 558                 else
 559                         ret = POLLIN | POLLRDNORM;
 560         } else
 561                 ret = POLLERR;
 562
 563         dev_dbg(ir->d.dev, LOGHEAD "poll result = %d\n",
 564                 ir->d.name, ir->d.minor, ret);
 565
 566         return ret;
 567 }
 568 EXPORT_SYMBOL(lirc_dev_fop_poll);
 569
 570 long lirc_dev_fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 571 {
 572         __u32 mode;
 573         int result = 0;
 574         struct irctl *ir = irctls[iminor(file_inode(file))];
 575
 576         if (!ir) {
 577                 pr_err("no irctl found!\n");
 578                 return -ENODEV;
 579         }
 580
 581         dev_dbg(ir->d.dev, LOGHEAD "ioctl called (0x%x)\n",
 582                 ir->d.name, ir->d.minor, cmd);
 583
 584         if (ir->d.minor == NOPLUG || !ir->attached) {
 585                 dev_err(ir->d.dev, LOGHEAD "ioctl result = -ENODEV\n",
 586                         ir->d.name, ir->d.minor);
 587                 return -ENODEV;
 588         }
 589
 590         mutex_lock(&ir->irctl_lock);
 591
 592         switch (cmd) {
 593         case LIRC_GET_FEATURES:
 594                 result = put_user(ir->d.features, (__u32 __user *)arg);
 595                 break;
 596         case LIRC_GET_REC_MODE:
 597                 if (!(ir->d.features & LIRC_CAN_REC_MASK)) {
 598                         result = -ENOSYS;
 599                         break;
 600                 }
 601
 602                 result = put_user(LIRC_REC2MODE
 603                                   (ir->d.features & LIRC_CAN_REC_MASK),
 604                                   (__u32 __user *)arg);
 605                 break;
 606         case LIRC_SET_REC_MODE:
 607                 if (!(ir->d.features & LIRC_CAN_REC_MASK)) {
 608                         result = -ENOSYS;
 609                         break;
 610                 }
 611
 612                 result = get_user(mode, (__u32 __user *)arg);
 613                 if (!result && !(LIRC_MODE2REC(mode) & ir->d.features))
 614                         result = -EINVAL;
 615                 /*
 616                  * FIXME: We should actually set the mode somehow but
 617                  * for now, lirc_serial doesn't support mode changing either
 618                  */
 619                 break;
 620         case LIRC_GET_LENGTH:
 621                 result = put_user(ir->d.code_length, (__u32 __user *)arg);
 622                 break;
 623         case LIRC_GET_MIN_TIMEOUT:
 624                 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) ||
 625                     ir->d.min_timeout == 0) {
 626                         result = -ENOSYS;
 627                         break;
 628                 }
 629
 630                 result = put_user(ir->d.min_timeout, (__u32 __user *)arg);
 631                 break;
 632         case LIRC_GET_MAX_TIMEOUT:
 633                 if (!(ir->d.features & LIRC_CAN_SET_REC_TIMEOUT) ||
 634                     ir->d.max_timeout == 0) {
 635                         result = -ENOSYS;
 636                         break;
 637                 }
 638
 639                 result = put_user(ir->d.max_timeout, (__u32 __user *)arg);
 640                 break;
 641         default:
 642                 result = -EINVAL;
 643         }
 644
 645         mutex_unlock(&ir->irctl_lock);
 646
 647         return result;
 648 }
 649 EXPORT_SYMBOL(lirc_dev_fop_ioctl);
 650
 651 ssize_t lirc_dev_fop_read(struct file *file,
 652                           char __user *buffer,
 653                           size_t length,
 654                           loff_t *ppos)
 655 {
 656         struct irctl *ir = irctls[iminor(file_inode(file))];
 657         unsigned char *buf;
 658         int ret = 0, written = 0;
 659         DECLARE_WAITQUEUE(wait, current);
 660
 661         if (!ir) {
 662                 pr_err("called with invalid irctl\n");
 663                 return -ENODEV;
 664         }
 665
 666         dev_dbg(ir->d.dev, LOGHEAD "read called\n", ir->d.name, ir->d.minor);
 667
 668         buf = kzalloc(ir->chunk_size, GFP_KERNEL);
 669         if (!buf)
 670                 return -ENOMEM;
 671
 672         if (mutex_lock_interruptible(&ir->irctl_lock)) {
 673                 ret = -ERESTARTSYS;
 674                 goto out_unlocked;
 675         }
 676         if (!ir->attached) {
 677                 ret = -ENODEV;
 678                 goto out_locked;
 679         }
 680
 681         if (length % ir->chunk_size) {
 682                 ret = -EINVAL;
 683                 goto out_locked;
 684         }
 685
 686         /*
 687          * we add ourselves to the task queue before buffer check
 688          * to avoid losing scan code (in case when queue is awaken somewhere
 689          * between while condition checking and scheduling)
 690          */
 691         add_wait_queue(&ir->buf->wait_poll, &wait);
 692         set_current_state(TASK_INTERRUPTIBLE);
 693
 694         /*
 695          * while we didn't provide 'length' bytes, device is opened in blocking
 696          * mode and 'copy_to_user' is happy, wait for data.
 697          */
 698         while (written < length && ret == 0) {
 699                 if (lirc_buffer_empty(ir->buf)) {
 700                         /* According to the read(2) man page, 'written' can be
 701                          * returned as less than 'length', instead of blocking
 702                          * again, returning -EWOULDBLOCK, or returning
 703                          * -ERESTARTSYS */
 704                         if (written)
 705                                 break;
 706                         if (file->f_flags & O_NONBLOCK) {
 707                                 ret = -EWOULDBLOCK;
 708                                 break;
 709                         }
 710                         if (signal_pending(current)) {
 711                                 ret = -ERESTARTSYS;
 712                                 break;
 713                         }
 714
 715                         mutex_unlock(&ir->irctl_lock);
 716                         schedule();
 717                         set_current_state(TASK_INTERRUPTIBLE);
 718
 719                         if (mutex_lock_interruptible(&ir->irctl_lock)) {
 720                                 ret = -ERESTARTSYS;
 721                                 remove_wait_queue(&ir->buf->wait_poll, &wait);
 722                                 set_current_state(TASK_RUNNING);
 723                                 goto out_unlocked;
 724                         }
 725
 726                         if (!ir->attached) {
 727                                 ret = -ENODEV;
 728                                 break;
 729                         }
 730                 } else {
 731                         lirc_buffer_read(ir->buf, buf);
 732                         ret = copy_to_user((void __user *)buffer+written, buf,
 733                                            ir->buf->chunk_size);
 734                         if (!ret)
 735                                 written += ir->buf->chunk_size;
 736                         else
 737                                 ret = -EFAULT;
 738                 }
 739         }
 740
 741         remove_wait_queue(&ir->buf->wait_poll, &wait);
 742         set_current_state(TASK_RUNNING);
 743
 744 out_locked:
 745         mutex_unlock(&ir->irctl_lock);
 746
 747 out_unlocked:
 748         kfree(buf);
 749
 750         return ret ? ret : written;
 751 }
 752 EXPORT_SYMBOL(lirc_dev_fop_read);
 753
 754 void *lirc_get_pdata(struct file *file)
 755 {
 756         return irctls[iminor(file_inode(file))]->d.data;
 757 }
 758 EXPORT_SYMBOL(lirc_get_pdata);
 759
 760
 761 ssize_t lirc_dev_fop_write(struct file *file, const char __user *buffer,
 762                            size_t length, loff_t *ppos)
 763 {
 764         struct irctl *ir = irctls[iminor(file_inode(file))];
 765
 766         if (!ir) {
 767                 pr_err("called with invalid irctl\n");
 768                 return -ENODEV;
 769         }
 770
 771         if (!ir->attached)
 772                 return -ENODEV;
 773
 774         return -EINVAL;
 775 }
 776 EXPORT_SYMBOL(lirc_dev_fop_write);
 777
 778
 779 static int __init lirc_dev_init(void)
 780 {
 781         int retval;
 782
 783         lirc_class = class_create(THIS_MODULE, "lirc");
 784         if (IS_ERR(lirc_class)) {
 785                 pr_err("class_create failed\n");
 786                 return PTR_ERR(lirc_class);
 787         }
 788
 789         retval = alloc_chrdev_region(&lirc_base_dev, 0, MAX_IRCTL_DEVICES,
 790                                      IRCTL_DEV_NAME);
 791         if (retval) {
 792                 class_destroy(lirc_class);
 793                 pr_err("alloc_chrdev_region failed\n");
 794                 return retval;
 795         }
 796
 797
 798         pr_info("IR Remote Control driver registered, major %d\n",
 799                                                 MAJOR(lirc_base_dev));
 800
 801         return 0;
 802 }
 803
 804
 805
 806 static void __exit lirc_dev_exit(void)
 807 {
 808         class_destroy(lirc_class);
 809         unregister_chrdev_region(lirc_base_dev, MAX_IRCTL_DEVICES);
 810         pr_info("module unloaded\n");
 811 }
 812
 813 module_init(lirc_dev_init);
 814 module_exit(lirc_dev_exit);
 815
 816 MODULE_DESCRIPTION("LIRC base driver module");
 817 MODULE_AUTHOR("Artur Lipowski");
 818 MODULE_LICENSE("GPL");
 819
 820 module_param(debug, bool, S_IRUGO | S_IWUSR);
 821 MODULE_PARM_DESC(debug, "Enable debugging messages");