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  */
  17
  18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20 #include <linux/module.h>
  21 #include <linux/mutex.h>
  22 #include <linux/device.h>
  23 #include <linux/file.h>
  24 #include <linux/idr.h>
  25 #include <linux/poll.h>
  26 #include <linux/sched.h>
  27 #include <linux/wait.h>
  28
  29 #include "rc-core-priv.h"
  30 #include <uapi/linux/lirc.h>
  31
  32 #define LIRCBUF_SIZE    256
  33
  34 static dev_t lirc_base_dev;
  35
  36 /* Used to keep track of allocated lirc devices */
  37 static DEFINE_IDA(lirc_ida);
  38
  39 /* Only used for sysfs but defined to void otherwise */
  40 static struct class *lirc_class;
  41
  42 /**
  43  * ir_lirc_raw_event() - Send raw IR data to lirc to be relayed to userspace
  44  *
  45  * @dev:        the struct rc_dev descriptor of the device
  46  * @ev:         the struct ir_raw_event descriptor of the pulse/space
  47  */
  48 void ir_lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev)
  49 {
  50         unsigned long flags;
  51         struct lirc_fh *fh;
  52         int sample;
  53
  54         /* Packet start */
  55         if (ev.reset) {
  56                 /*
  57                  * Userspace expects a long space event before the start of
  58                  * the signal to use as a sync.  This may be done with repeat
  59                  * packets and normal samples.  But if a reset has been sent
  60                  * then we assume that a long time has passed, so we send a
  61                  * space with the maximum time value.
  62                  */
  63                 sample = LIRC_SPACE(LIRC_VALUE_MASK);
  64                 dev_dbg(&dev->dev, "delivering reset sync space to lirc_dev\n");
  65
  66         /* Carrier reports */
  67         } else if (ev.carrier_report) {
  68                 sample = LIRC_FREQUENCY(ev.carrier);
  69                 dev_dbg(&dev->dev, "carrier report (freq: %d)\n", sample);
  70
  71         /* Packet end */
  72         } else if (ev.timeout) {
  73                 if (dev->gap)
  74                         return;
  75
  76                 dev->gap_start = ktime_get();
  77                 dev->gap = true;
  78                 dev->gap_duration = ev.duration;
  79
  80                 sample = LIRC_TIMEOUT(ev.duration / 1000);
  81                 dev_dbg(&dev->dev, "timeout report (duration: %d)\n", sample);
  82
  83         /* Normal sample */
  84         } else {
  85                 if (dev->gap) {
  86                         dev->gap_duration += ktime_to_ns(ktime_sub(ktime_get(),
  87                                                          dev->gap_start));
  88
  89                         /* Convert to ms and cap by LIRC_VALUE_MASK */
  90                         do_div(dev->gap_duration, 1000);
  91                         dev->gap_duration = min_t(u64, dev->gap_duration,
  92                                                   LIRC_VALUE_MASK);
  93
  94                         spin_lock_irqsave(&dev->lirc_fh_lock, flags);
  95                         list_for_each_entry(fh, &dev->lirc_fh, list)
  96                                 kfifo_put(&fh->rawir,
  97                                           LIRC_SPACE(dev->gap_duration));
  98                         spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
  99                         dev->gap = false;
 100                 }
 101
 102                 sample = ev.pulse ? LIRC_PULSE(ev.duration / 1000) :
 103                                         LIRC_SPACE(ev.duration / 1000);
 104                 dev_dbg(&dev->dev, "delivering %uus %s to lirc_dev\n",
 105                         TO_US(ev.duration), TO_STR(ev.pulse));
 106         }
 107
 108         /*
 109          * bpf does not care about the gap generated above; that exists
 110          * for backwards compatibility
 111          */
 112         lirc_bpf_run(dev, sample);
 113
 114         spin_lock_irqsave(&dev->lirc_fh_lock, flags);
 115         list_for_each_entry(fh, &dev->lirc_fh, list) {
 116                 if (LIRC_IS_TIMEOUT(sample) && !fh->send_timeout_reports)
 117                         continue;
 118                 if (kfifo_put(&fh->rawir, sample))
 119                         wake_up_poll(&fh->wait_poll, EPOLLIN | EPOLLRDNORM);
 120         }
 121         spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
 122 }
 123
 124 /**
 125  * ir_lirc_scancode_event() - Send scancode data to lirc to be relayed to
 126  *              userspace. This can be called in atomic context.
 127  * @dev:        the struct rc_dev descriptor of the device
 128  * @lsc:        the struct lirc_scancode describing the decoded scancode
 129  */
 130 void ir_lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc)
 131 {
 132         unsigned long flags;
 133         struct lirc_fh *fh;
 134
 135         lsc->timestamp = ktime_get_ns();
 136
 137         spin_lock_irqsave(&dev->lirc_fh_lock, flags);
 138         list_for_each_entry(fh, &dev->lirc_fh, list) {
 139                 if (kfifo_put(&fh->scancodes, *lsc))
 140                         wake_up_poll(&fh->wait_poll, EPOLLIN | EPOLLRDNORM);
 141         }
 142         spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
 143 }
 144 EXPORT_SYMBOL_GPL(ir_lirc_scancode_event);
 145
 146 static int ir_lirc_open(struct inode *inode, struct file *file)
 147 {
 148         struct rc_dev *dev = container_of(inode->i_cdev, struct rc_dev,
 149                                           lirc_cdev);
 150         struct lirc_fh *fh = kzalloc(sizeof(*fh), GFP_KERNEL);
 151         unsigned long flags;
 152         int retval;
 153
 154         if (!fh)
 155                 return -ENOMEM;
 156
 157         get_device(&dev->dev);
 158
 159         if (!dev->registered) {
 160                 retval = -ENODEV;
 161                 goto out_fh;
 162         }
 163
 164         if (dev->driver_type == RC_DRIVER_IR_RAW) {
 165                 if (kfifo_alloc(&fh->rawir, MAX_IR_EVENT_SIZE, GFP_KERNEL)) {
 166                         retval = -ENOMEM;
 167                         goto out_fh;
 168                 }
 169         }
 170
 171         if (dev->driver_type != RC_DRIVER_IR_RAW_TX) {
 172                 if (kfifo_alloc(&fh->scancodes, 32, GFP_KERNEL)) {
 173                         retval = -ENOMEM;
 174                         goto out_rawir;
 175                 }
 176         }
 177
 178         fh->send_mode = LIRC_MODE_PULSE;
 179         fh->rc = dev;
 180         fh->send_timeout_reports = true;
 181
 182         if (dev->driver_type == RC_DRIVER_SCANCODE)
 183                 fh->rec_mode = LIRC_MODE_SCANCODE;
 184         else
 185                 fh->rec_mode = LIRC_MODE_MODE2;
 186
 187         retval = rc_open(dev);
 188         if (retval)
 189                 goto out_kfifo;
 190
 191         init_waitqueue_head(&fh->wait_poll);
 192
 193         file->private_data = fh;
 194         spin_lock_irqsave(&dev->lirc_fh_lock, flags);
 195         list_add(&fh->list, &dev->lirc_fh);
 196         spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
 197
 198         nonseekable_open(inode, file);
 199
 200         return 0;
 201 out_kfifo:
 202         if (dev->driver_type != RC_DRIVER_IR_RAW_TX)
 203                 kfifo_free(&fh->scancodes);
 204 out_rawir:
 205         if (dev->driver_type == RC_DRIVER_IR_RAW)
 206                 kfifo_free(&fh->rawir);
 207 out_fh:
 208         kfree(fh);
 209         put_device(&dev->dev);
 210
 211         return retval;
 212 }
 213
 214 static int ir_lirc_close(struct inode *inode, struct file *file)
 215 {
 216         struct lirc_fh *fh = file->private_data;
 217         struct rc_dev *dev = fh->rc;
 218         unsigned long flags;
 219
 220         spin_lock_irqsave(&dev->lirc_fh_lock, flags);
 221         list_del(&fh->list);
 222         spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
 223
 224         if (dev->driver_type == RC_DRIVER_IR_RAW)
 225                 kfifo_free(&fh->rawir);
 226         if (dev->driver_type != RC_DRIVER_IR_RAW_TX)
 227                 kfifo_free(&fh->scancodes);
 228         kfree(fh);
 229
 230         rc_close(dev);
 231         put_device(&dev->dev);
 232
 233         return 0;
 234 }
 235
 236 static ssize_t ir_lirc_transmit_ir(struct file *file, const char __user *buf,
 237                                    size_t n, loff_t *ppos)
 238 {
 239         struct lirc_fh *fh = file->private_data;
 240         struct rc_dev *dev = fh->rc;
 241         unsigned int *txbuf;
 242         struct ir_raw_event *raw = NULL;
 243         ssize_t ret;
 244         size_t count;
 245         ktime_t start;
 246         s64 towait;
 247         unsigned int duration = 0; /* signal duration in us */
 248         int i;
 249
 250         ret = mutex_lock_interruptible(&dev->lock);
 251         if (ret)
 252                 return ret;
 253
 254         if (!dev->registered) {
 255                 ret = -ENODEV;
 256                 goto out_unlock;
 257         }
 258
 259         if (!dev->tx_ir) {
 260                 ret = -EINVAL;
 261                 goto out_unlock;
 262         }
 263
 264         if (fh->send_mode == LIRC_MODE_SCANCODE) {
 265                 struct lirc_scancode scan;
 266
 267                 if (n != sizeof(scan)) {
 268                         ret = -EINVAL;
 269                         goto out_unlock;
 270                 }
 271
 272                 if (copy_from_user(&scan, buf, sizeof(scan))) {
 273                         ret = -EFAULT;
 274                         goto out_unlock;
 275                 }
 276
 277                 if (scan.flags || scan.keycode || scan.timestamp) {
 278                         ret = -EINVAL;
 279                         goto out_unlock;
 280                 }
 281
 282                 /*
 283                  * The scancode field in lirc_scancode is 64-bit simply
 284                  * to future-proof it, since there are IR protocols encode
 285                  * use more than 32 bits. For now only 32-bit protocols
 286                  * are supported.
 287                  */
 288                 if (scan.scancode > U32_MAX ||
 289                     !rc_validate_scancode(scan.rc_proto, scan.scancode)) {
 290                         ret = -EINVAL;
 291                         goto out_unlock;
 292                 }
 293
 294                 raw = kmalloc_array(LIRCBUF_SIZE, sizeof(*raw), GFP_KERNEL);
 295                 if (!raw) {
 296                         ret = -ENOMEM;
 297                         goto out_unlock;
 298                 }
 299
 300                 ret = ir_raw_encode_scancode(scan.rc_proto, scan.scancode,
 301                                              raw, LIRCBUF_SIZE);
 302                 if (ret < 0)
 303                         goto out_kfree_raw;
 304
 305                 count = ret;
 306
 307                 txbuf = kmalloc_array(count, sizeof(unsigned int), GFP_KERNEL);
 308                 if (!txbuf) {
 309                         ret = -ENOMEM;
 310                         goto out_kfree_raw;
 311                 }
 312
 313                 for (i = 0; i < count; i++)
 314                         /* Convert from NS to US */
 315                         txbuf[i] = DIV_ROUND_UP(raw[i].duration, 1000);
 316
 317                 if (dev->s_tx_carrier) {
 318                         int carrier = ir_raw_encode_carrier(scan.rc_proto);
 319
 320                         if (carrier > 0)
 321                                 dev->s_tx_carrier(dev, carrier);
 322                 }
 323         } else {
 324                 if (n < sizeof(unsigned int) || n % sizeof(unsigned int)) {
 325                         ret = -EINVAL;
 326                         goto out_unlock;
 327                 }
 328
 329                 count = n / sizeof(unsigned int);
 330                 if (count > LIRCBUF_SIZE || count % 2 == 0) {
 331                         ret = -EINVAL;
 332                         goto out_unlock;
 333                 }
 334
 335                 txbuf = memdup_user(buf, n);
 336                 if (IS_ERR(txbuf)) {
 337                         ret = PTR_ERR(txbuf);
 338                         goto out_unlock;
 339                 }
 340         }
 341
 342         for (i = 0; i < count; i++) {
 343                 if (txbuf[i] > IR_MAX_DURATION / 1000 - duration || !txbuf[i]) {
 344                         ret = -EINVAL;
 345                         goto out_kfree;
 346                 }
 347
 348                 duration += txbuf[i];
 349         }
 350
 351         start = ktime_get();
 352
 353         ret = dev->tx_ir(dev, txbuf, count);
 354         if (ret < 0)
 355                 goto out_kfree;
 356
 357         kfree(txbuf);
 358         kfree(raw);
 359         mutex_unlock(&dev->lock);
 360
 361         /*
 362          * The lircd gap calculation expects the write function to
 363          * wait for the actual IR signal to be transmitted before
 364          * returning.
 365          */
 366         towait = ktime_us_delta(ktime_add_us(start, duration),
 367                                 ktime_get());
 368         if (towait > 0) {
 369                 set_current_state(TASK_INTERRUPTIBLE);
 370                 schedule_timeout(usecs_to_jiffies(towait));
 371         }
 372
 373         return n;
 374 out_kfree:
 375         kfree(txbuf);
 376 out_kfree_raw:
 377         kfree(raw);
 378 out_unlock:
 379         mutex_unlock(&dev->lock);
 380         return ret;
 381 }
 382
 383 static long ir_lirc_ioctl(struct file *file, unsigned int cmd,
 384                           unsigned long arg)
 385 {
 386         struct lirc_fh *fh = file->private_data;
 387         struct rc_dev *dev = fh->rc;
 388         u32 __user *argp = (u32 __user *)(arg);
 389         u32 val = 0;
 390         int ret;
 391
 392         if (_IOC_DIR(cmd) & _IOC_WRITE) {
 393                 ret = get_user(val, argp);
 394                 if (ret)
 395                         return ret;
 396         }
 397
 398         ret = mutex_lock_interruptible(&dev->lock);
 399         if (ret)
 400                 return ret;
 401
 402         if (!dev->registered) {
 403                 ret = -ENODEV;
 404                 goto out;
 405         }
 406
 407         switch (cmd) {
 408         case LIRC_GET_FEATURES:
 409                 if (dev->driver_type == RC_DRIVER_SCANCODE)
 410                         val |= LIRC_CAN_REC_SCANCODE;
 411
 412                 if (dev->driver_type == RC_DRIVER_IR_RAW) {
 413                         val |= LIRC_CAN_REC_MODE2;
 414                         if (dev->rx_resolution)
 415                                 val |= LIRC_CAN_GET_REC_RESOLUTION;
 416                 }
 417
 418                 if (dev->tx_ir) {
 419                         val |= LIRC_CAN_SEND_PULSE;
 420                         if (dev->s_tx_mask)
 421                                 val |= LIRC_CAN_SET_TRANSMITTER_MASK;
 422                         if (dev->s_tx_carrier)
 423                                 val |= LIRC_CAN_SET_SEND_CARRIER;
 424                         if (dev->s_tx_duty_cycle)
 425                                 val |= LIRC_CAN_SET_SEND_DUTY_CYCLE;
 426                 }
 427
 428                 if (dev->s_rx_carrier_range)
 429                         val |= LIRC_CAN_SET_REC_CARRIER |
 430                                 LIRC_CAN_SET_REC_CARRIER_RANGE;
 431
 432                 if (dev->s_learning_mode)
 433                         val |= LIRC_CAN_USE_WIDEBAND_RECEIVER;
 434
 435                 if (dev->s_carrier_report)
 436                         val |= LIRC_CAN_MEASURE_CARRIER;
 437
 438                 if (dev->max_timeout)
 439                         val |= LIRC_CAN_SET_REC_TIMEOUT;
 440
 441                 break;
 442
 443         /* mode support */
 444         case LIRC_GET_REC_MODE:
 445                 if (dev->driver_type == RC_DRIVER_IR_RAW_TX)
 446                         ret = -ENOTTY;
 447                 else
 448                         val = fh->rec_mode;
 449                 break;
 450
 451         case LIRC_SET_REC_MODE:
 452                 switch (dev->driver_type) {
 453                 case RC_DRIVER_IR_RAW_TX:
 454                         ret = -ENOTTY;
 455                         break;
 456                 case RC_DRIVER_SCANCODE:
 457                         if (val != LIRC_MODE_SCANCODE)
 458                                 ret = -EINVAL;
 459                         break;
 460                 case RC_DRIVER_IR_RAW:
 461                         if (!(val == LIRC_MODE_MODE2 ||
 462                               val == LIRC_MODE_SCANCODE))
 463                                 ret = -EINVAL;
 464                         break;
 465                 }
 466
 467                 if (!ret)
 468                         fh->rec_mode = val;
 469                 break;
 470
 471         case LIRC_GET_SEND_MODE:
 472                 if (!dev->tx_ir)
 473                         ret = -ENOTTY;
 474                 else
 475                         val = fh->send_mode;
 476                 break;
 477
 478         case LIRC_SET_SEND_MODE:
 479                 if (!dev->tx_ir)
 480                         ret = -ENOTTY;
 481                 else if (!(val == LIRC_MODE_PULSE || val == LIRC_MODE_SCANCODE))
 482                         ret = -EINVAL;
 483                 else
 484                         fh->send_mode = val;
 485                 break;
 486
 487         /* TX settings */
 488         case LIRC_SET_TRANSMITTER_MASK:
 489                 if (!dev->s_tx_mask)
 490                         ret = -ENOTTY;
 491                 else
 492                         ret = dev->s_tx_mask(dev, val);
 493                 break;
 494
 495         case LIRC_SET_SEND_CARRIER:
 496                 if (!dev->s_tx_carrier)
 497                         ret = -ENOTTY;
 498                 else
 499                         ret = dev->s_tx_carrier(dev, val);
 500                 break;
 501
 502         case LIRC_SET_SEND_DUTY_CYCLE:
 503                 if (!dev->s_tx_duty_cycle)
 504                         ret = -ENOTTY;
 505                 else if (val <= 0 || val >= 100)
 506                         ret = -EINVAL;
 507                 else
 508                         ret = dev->s_tx_duty_cycle(dev, val);
 509                 break;
 510
 511         /* RX settings */
 512         case LIRC_SET_REC_CARRIER:
 513                 if (!dev->s_rx_carrier_range)
 514                         ret = -ENOTTY;
 515                 else if (val <= 0)
 516                         ret = -EINVAL;
 517                 else
 518                         ret = dev->s_rx_carrier_range(dev, fh->carrier_low,
 519                                                       val);
 520                 break;
 521
 522         case LIRC_SET_REC_CARRIER_RANGE:
 523                 if (!dev->s_rx_carrier_range)
 524                         ret = -ENOTTY;
 525                 else if (val <= 0)
 526                         ret = -EINVAL;
 527                 else
 528                         fh->carrier_low = val;
 529                 break;
 530
 531         case LIRC_GET_REC_RESOLUTION:
 532                 if (!dev->rx_resolution)
 533                         ret = -ENOTTY;
 534                 else
 535                         val = dev->rx_resolution / 1000;
 536                 break;
 537
 538         case LIRC_SET_WIDEBAND_RECEIVER:
 539                 if (!dev->s_learning_mode)
 540                         ret = -ENOTTY;
 541                 else
 542                         ret = dev->s_learning_mode(dev, !!val);
 543                 break;
 544
 545         case LIRC_SET_MEASURE_CARRIER_MODE:
 546                 if (!dev->s_carrier_report)
 547                         ret = -ENOTTY;
 548                 else
 549                         ret = dev->s_carrier_report(dev, !!val);
 550                 break;
 551
 552         /* Generic timeout support */
 553         case LIRC_GET_MIN_TIMEOUT:
 554                 if (!dev->max_timeout)
 555                         ret = -ENOTTY;
 556                 else
 557                         val = DIV_ROUND_UP(dev->min_timeout, 1000);
 558                 break;
 559
 560         case LIRC_GET_MAX_TIMEOUT:
 561                 if (!dev->max_timeout)
 562                         ret = -ENOTTY;
 563                 else
 564                         val = dev->max_timeout / 1000;
 565                 break;
 566
 567         case LIRC_SET_REC_TIMEOUT:
 568                 if (!dev->max_timeout) {
 569                         ret = -ENOTTY;
 570                 } else if (val > U32_MAX / 1000) {
 571                         /* Check for multiply overflow */
 572                         ret = -EINVAL;
 573                 } else {
 574                         u32 tmp = val * 1000;
 575
 576                         if (tmp < dev->min_timeout || tmp > dev->max_timeout)
 577                                 ret = -EINVAL;
 578                         else if (dev->s_timeout)
 579                                 ret = dev->s_timeout(dev, tmp);
 580                         else
 581                                 dev->timeout = tmp;
 582                 }
 583                 break;
 584
 585         case LIRC_GET_REC_TIMEOUT:
 586                 if (!dev->timeout)
 587                         ret = -ENOTTY;
 588                 else
 589                         val = DIV_ROUND_UP(dev->timeout, 1000);
 590                 break;
 591
 592         case LIRC_SET_REC_TIMEOUT_REPORTS:
 593                 if (dev->driver_type != RC_DRIVER_IR_RAW)
 594                         ret = -ENOTTY;
 595                 else
 596                         fh->send_timeout_reports = !!val;
 597                 break;
 598
 599         default:
 600                 ret = -ENOTTY;
 601         }
 602
 603         if (!ret && _IOC_DIR(cmd) & _IOC_READ)
 604                 ret = put_user(val, argp);
 605
 606 out:
 607         mutex_unlock(&dev->lock);
 608         return ret;
 609 }
 610
 611 static __poll_t ir_lirc_poll(struct file *file, struct poll_table_struct *wait)
 612 {
 613         struct lirc_fh *fh = file->private_data;
 614         struct rc_dev *rcdev = fh->rc;
 615         __poll_t events = 0;
 616
 617         poll_wait(file, &fh->wait_poll, wait);
 618
 619         if (!rcdev->registered) {
 620                 events = EPOLLHUP | EPOLLERR;
 621         } else if (rcdev->driver_type != RC_DRIVER_IR_RAW_TX) {
 622                 if (fh->rec_mode == LIRC_MODE_SCANCODE &&
 623                     !kfifo_is_empty(&fh->scancodes))
 624                         events = EPOLLIN | EPOLLRDNORM;
 625
 626                 if (fh->rec_mode == LIRC_MODE_MODE2 &&
 627                     !kfifo_is_empty(&fh->rawir))
 628                         events = EPOLLIN | EPOLLRDNORM;
 629         }
 630
 631         return events;
 632 }
 633
 634 static ssize_t ir_lirc_read_mode2(struct file *file, char __user *buffer,
 635                                   size_t length)
 636 {
 637         struct lirc_fh *fh = file->private_data;
 638         struct rc_dev *rcdev = fh->rc;
 639         unsigned int copied;
 640         int ret;
 641
 642         if (length < sizeof(unsigned int) || length % sizeof(unsigned int))
 643                 return -EINVAL;
 644
 645         do {
 646                 if (kfifo_is_empty(&fh->rawir)) {
 647                         if (file->f_flags & O_NONBLOCK)
 648                                 return -EAGAIN;
 649
 650                         ret = wait_event_interruptible(fh->wait_poll,
 651                                         !kfifo_is_empty(&fh->rawir) ||
 652                                         !rcdev->registered);
 653                         if (ret)
 654                                 return ret;
 655                 }
 656
 657                 if (!rcdev->registered)
 658                         return -ENODEV;
 659
 660                 ret = mutex_lock_interruptible(&rcdev->lock);
 661                 if (ret)
 662                         return ret;
 663                 ret = kfifo_to_user(&fh->rawir, buffer, length, &copied);
 664                 mutex_unlock(&rcdev->lock);
 665                 if (ret)
 666                         return ret;
 667         } while (copied == 0);
 668
 669         return copied;
 670 }
 671
 672 static ssize_t ir_lirc_read_scancode(struct file *file, char __user *buffer,
 673                                      size_t length)
 674 {
 675         struct lirc_fh *fh = file->private_data;
 676         struct rc_dev *rcdev = fh->rc;
 677         unsigned int copied;
 678         int ret;
 679
 680         if (length < sizeof(struct lirc_scancode) ||
 681             length % sizeof(struct lirc_scancode))
 682                 return -EINVAL;
 683
 684         do {
 685                 if (kfifo_is_empty(&fh->scancodes)) {
 686                         if (file->f_flags & O_NONBLOCK)
 687                                 return -EAGAIN;
 688
 689                         ret = wait_event_interruptible(fh->wait_poll,
 690                                         !kfifo_is_empty(&fh->scancodes) ||
 691                                         !rcdev->registered);
 692                         if (ret)
 693                                 return ret;
 694                 }
 695
 696                 if (!rcdev->registered)
 697                         return -ENODEV;
 698
 699                 ret = mutex_lock_interruptible(&rcdev->lock);
 700                 if (ret)
 701                         return ret;
 702                 ret = kfifo_to_user(&fh->scancodes, buffer, length, &copied);
 703                 mutex_unlock(&rcdev->lock);
 704                 if (ret)
 705                         return ret;
 706         } while (copied == 0);
 707
 708         return copied;
 709 }
 710
 711 static ssize_t ir_lirc_read(struct file *file, char __user *buffer,
 712                             size_t length, loff_t *ppos)
 713 {
 714         struct lirc_fh *fh = file->private_data;
 715         struct rc_dev *rcdev = fh->rc;
 716
 717         if (rcdev->driver_type == RC_DRIVER_IR_RAW_TX)
 718                 return -EINVAL;
 719
 720         if (!rcdev->registered)
 721                 return -ENODEV;
 722
 723         if (fh->rec_mode == LIRC_MODE_MODE2)
 724                 return ir_lirc_read_mode2(file, buffer, length);
 725         else /* LIRC_MODE_SCANCODE */
 726                 return ir_lirc_read_scancode(file, buffer, length);
 727 }
 728
 729 static const struct file_operations lirc_fops = {
 730         .owner          = THIS_MODULE,
 731         .write          = ir_lirc_transmit_ir,
 732         .unlocked_ioctl = ir_lirc_ioctl,
 733 #ifdef CONFIG_COMPAT
 734         .compat_ioctl   = ir_lirc_ioctl,
 735 #endif
 736         .read           = ir_lirc_read,
 737         .poll           = ir_lirc_poll,
 738         .open           = ir_lirc_open,
 739         .release        = ir_lirc_close,
 740         .llseek         = no_llseek,
 741 };
 742
 743 static void lirc_release_device(struct device *ld)
 744 {
 745         struct rc_dev *rcdev = container_of(ld, struct rc_dev, lirc_dev);
 746
 747         put_device(&rcdev->dev);
 748 }
 749
 750 int ir_lirc_register(struct rc_dev *dev)
 751 {
 752         const char *rx_type, *tx_type;
 753         int err, minor;
 754
 755         minor = ida_simple_get(&lirc_ida, 0, RC_DEV_MAX, GFP_KERNEL);
 756         if (minor < 0)
 757                 return minor;
 758
 759         device_initialize(&dev->lirc_dev);
 760         dev->lirc_dev.class = lirc_class;
 761         dev->lirc_dev.parent = &dev->dev;
 762         dev->lirc_dev.release = lirc_release_device;
 763         dev->lirc_dev.devt = MKDEV(MAJOR(lirc_base_dev), minor);
 764         dev_set_name(&dev->lirc_dev, "lirc%d", minor);
 765
 766         INIT_LIST_HEAD(&dev->lirc_fh);
 767         spin_lock_init(&dev->lirc_fh_lock);
 768
 769         cdev_init(&dev->lirc_cdev, &lirc_fops);
 770
 771         err = cdev_device_add(&dev->lirc_cdev, &dev->lirc_dev);
 772         if (err)
 773                 goto out_ida;
 774
 775         get_device(&dev->dev);
 776
 777         switch (dev->driver_type) {
 778         case RC_DRIVER_SCANCODE:
 779                 rx_type = "scancode";
 780                 break;
 781         case RC_DRIVER_IR_RAW:
 782                 rx_type = "raw IR";
 783                 break;
 784         default:
 785                 rx_type = "no";
 786                 break;
 787         }
 788
 789         if (dev->tx_ir)
 790                 tx_type = "raw IR";
 791         else
 792                 tx_type = "no";
 793
 794         dev_info(&dev->dev, "lirc_dev: driver %s registered at minor = %d, %s receiver, %s transmitter",
 795                  dev->driver_name, minor, rx_type, tx_type);
 796
 797         return 0;
 798
 799 out_ida:
 800         ida_simple_remove(&lirc_ida, minor);
 801         return err;
 802 }
 803
 804 void ir_lirc_unregister(struct rc_dev *dev)
 805 {
 806         unsigned long flags;
 807         struct lirc_fh *fh;
 808
 809         dev_dbg(&dev->dev, "lirc_dev: driver %s unregistered from minor = %d\n",
 810                 dev->driver_name, MINOR(dev->lirc_dev.devt));
 811
 812         spin_lock_irqsave(&dev->lirc_fh_lock, flags);
 813         list_for_each_entry(fh, &dev->lirc_fh, list)
 814                 wake_up_poll(&fh->wait_poll, EPOLLHUP | EPOLLERR);
 815         spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
 816
 817         cdev_device_del(&dev->lirc_cdev, &dev->lirc_dev);
 818         ida_simple_remove(&lirc_ida, MINOR(dev->lirc_dev.devt));
 819 }
 820
 821 int __init lirc_dev_init(void)
 822 {
 823         int retval;
 824
 825         lirc_class = class_create(THIS_MODULE, "lirc");
 826         if (IS_ERR(lirc_class)) {
 827                 pr_err("class_create failed\n");
 828                 return PTR_ERR(lirc_class);
 829         }
 830
 831         retval = alloc_chrdev_region(&lirc_base_dev, 0, RC_DEV_MAX,
 832                                      "BaseRemoteCtl");
 833         if (retval) {
 834                 class_destroy(lirc_class);
 835                 pr_err("alloc_chrdev_region failed\n");
 836                 return retval;
 837         }
 838
 839         pr_debug("IR Remote Control driver registered, major %d\n",
 840                  MAJOR(lirc_base_dev));
 841
 842         return 0;
 843 }
 844
 845 void __exit lirc_dev_exit(void)
 846 {
 847         class_destroy(lirc_class);
 848         unregister_chrdev_region(lirc_base_dev, RC_DEV_MAX);
 849 }
 850
 851 struct rc_dev *rc_dev_get_from_fd(int fd)
 852 {
 853         struct fd f = fdget(fd);
 854         struct lirc_fh *fh;
 855         struct rc_dev *dev;
 856
 857         if (!f.file)
 858                 return ERR_PTR(-EBADF);
 859
 860         if (f.file->f_op != &lirc_fops) {
 861                 fdput(f);
 862                 return ERR_PTR(-EINVAL);
 863         }
 864
 865         fh = f.file->private_data;
 866         dev = fh->rc;
 867
 868         get_device(&dev->dev);
 869         fdput(f);
 870
 871         return dev;
 872 }
 873
 874 MODULE_ALIAS("lirc_dev");