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