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