drivers/media/rc/lirc_dev.c

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