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