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