drivers/media/rc/lirc_dev.c

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