1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * by Artur Lipowski <alipowski@interia.pl>
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
19 #include "rc-core-priv.h"
20 #include <uapi/linux/lirc.h>
22 #define LIRCBUF_SIZE 1024
24 static dev_t lirc_base_dev;
26 /* Used to keep track of allocated lirc devices */
27 static DEFINE_IDA(lirc_ida);
29 /* Only used for sysfs but defined to void otherwise */
30 static struct class *lirc_class;
33 * lirc_raw_event() - Send raw IR data to lirc to be relayed to userspace
35 * @dev: the struct rc_dev descriptor of the device
36 * @ev: the struct ir_raw_event descriptor of the pulse/space
38 void lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev)
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.
53 sample = LIRC_SPACE(LIRC_VALUE_MASK);
54 dev_dbg(&dev->dev, "delivering reset sync space to lirc_dev\n");
57 } else if (ev.carrier_report) {
58 sample = LIRC_FREQUENCY(ev.carrier);
59 dev_dbg(&dev->dev, "carrier report (freq: %d)\n", sample);
62 } else if (ev.timeout) {
66 dev->gap_start = ktime_get();
68 dev->gap_duration = ev.duration;
70 sample = LIRC_TIMEOUT(ev.duration);
71 dev_dbg(&dev->dev, "timeout report (duration: %d)\n", sample);
76 dev->gap_duration += ktime_to_us(ktime_sub(ktime_get(),
79 /* Cap by LIRC_VALUE_MASK */
80 dev->gap_duration = min_t(u64, dev->gap_duration,
83 spin_lock_irqsave(&dev->lirc_fh_lock, flags);
84 list_for_each_entry(fh, &dev->lirc_fh, list)
86 LIRC_SPACE(dev->gap_duration));
87 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
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));
98 * bpf does not care about the gap generated above; that exists
99 * for backwards compatibility
101 lirc_bpf_run(dev, sample);
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)
107 if (kfifo_put(&fh->rawir, sample))
108 wake_up_poll(&fh->wait_poll, EPOLLIN | EPOLLRDNORM);
110 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
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
119 void lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc)
124 lsc->timestamp = ktime_get_ns();
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);
131 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
133 EXPORT_SYMBOL_GPL(lirc_scancode_event);
135 static int lirc_open(struct inode *inode, struct file *file)
137 struct rc_dev *dev = container_of(inode->i_cdev, struct rc_dev,
139 struct lirc_fh *fh = kzalloc(sizeof(*fh), GFP_KERNEL);
146 get_device(&dev->dev);
148 if (!dev->registered) {
153 if (dev->driver_type == RC_DRIVER_IR_RAW) {
154 if (kfifo_alloc(&fh->rawir, MAX_IR_EVENT_SIZE, GFP_KERNEL)) {
160 if (dev->driver_type != RC_DRIVER_IR_RAW_TX) {
161 if (kfifo_alloc(&fh->scancodes, 32, GFP_KERNEL)) {
167 fh->send_mode = LIRC_MODE_PULSE;
169 fh->send_timeout_reports = true;
171 if (dev->driver_type == RC_DRIVER_SCANCODE)
172 fh->rec_mode = LIRC_MODE_SCANCODE;
174 fh->rec_mode = LIRC_MODE_MODE2;
176 retval = rc_open(dev);
180 init_waitqueue_head(&fh->wait_poll);
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);
187 stream_open(inode, file);
191 if (dev->driver_type != RC_DRIVER_IR_RAW_TX)
192 kfifo_free(&fh->scancodes);
194 if (dev->driver_type == RC_DRIVER_IR_RAW)
195 kfifo_free(&fh->rawir);
198 put_device(&dev->dev);
203 static int lirc_close(struct inode *inode, struct file *file)
205 struct lirc_fh *fh = file->private_data;
206 struct rc_dev *dev = fh->rc;
209 spin_lock_irqsave(&dev->lirc_fh_lock, flags);
211 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
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);
220 put_device(&dev->dev);
225 static ssize_t lirc_transmit(struct file *file, const char __user *buf,
226 size_t n, loff_t *ppos)
228 struct lirc_fh *fh = file->private_data;
229 struct rc_dev *dev = fh->rc;
231 struct ir_raw_event *raw = NULL;
236 unsigned int duration = 0; /* signal duration in us */
239 ret = mutex_lock_interruptible(&dev->lock);
243 if (!dev->registered) {
253 if (fh->send_mode == LIRC_MODE_SCANCODE) {
254 struct lirc_scancode scan;
256 if (n != sizeof(scan)) {
261 if (copy_from_user(&scan, buf, sizeof(scan))) {
266 if (scan.flags || scan.keycode || scan.timestamp ||
267 scan.rc_proto > RC_PROTO_MAX) {
272 /* We only have encoders for 32-bit protocols. */
273 if (scan.scancode > U32_MAX ||
274 !rc_validate_scancode(scan.rc_proto, scan.scancode)) {
279 raw = kmalloc_array(LIRCBUF_SIZE, sizeof(*raw), GFP_KERNEL);
285 ret = ir_raw_encode_scancode(scan.rc_proto, scan.scancode,
292 txbuf = kmalloc_array(count, sizeof(unsigned int), GFP_KERNEL);
298 for (i = 0; i < count; i++)
299 txbuf[i] = raw[i].duration;
301 if (dev->s_tx_carrier) {
302 int carrier = ir_raw_encode_carrier(scan.rc_proto);
305 dev->s_tx_carrier(dev, carrier);
308 if (n < sizeof(unsigned int) || n % sizeof(unsigned int)) {
313 count = n / sizeof(unsigned int);
314 if (count > LIRCBUF_SIZE || count % 2 == 0) {
319 txbuf = memdup_user(buf, n);
321 ret = PTR_ERR(txbuf);
326 for (i = 0; i < count; i++) {
327 if (txbuf[i] > IR_MAX_DURATION - duration || !txbuf[i]) {
332 duration += txbuf[i];
337 ret = dev->tx_ir(dev, txbuf, count);
343 mutex_unlock(&dev->lock);
346 * The lircd gap calculation expects the write function to
347 * wait for the actual IR signal to be transmitted before
350 towait = ktime_us_delta(ktime_add_us(start, duration),
353 set_current_state(TASK_INTERRUPTIBLE);
354 schedule_timeout(usecs_to_jiffies(towait));
363 mutex_unlock(&dev->lock);
367 static long lirc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
369 struct lirc_fh *fh = file->private_data;
370 struct rc_dev *dev = fh->rc;
371 u32 __user *argp = (u32 __user *)(arg);
375 if (_IOC_DIR(cmd) & _IOC_WRITE) {
376 ret = get_user(val, argp);
381 ret = mutex_lock_interruptible(&dev->lock);
385 if (!dev->registered) {
391 case LIRC_GET_FEATURES:
392 if (dev->driver_type == RC_DRIVER_SCANCODE)
393 val |= LIRC_CAN_REC_SCANCODE;
395 if (dev->driver_type == RC_DRIVER_IR_RAW) {
396 val |= LIRC_CAN_REC_MODE2;
397 if (dev->rx_resolution)
398 val |= LIRC_CAN_GET_REC_RESOLUTION;
402 val |= LIRC_CAN_SEND_PULSE;
404 val |= LIRC_CAN_SET_TRANSMITTER_MASK;
405 if (dev->s_tx_carrier)
406 val |= LIRC_CAN_SET_SEND_CARRIER;
407 if (dev->s_tx_duty_cycle)
408 val |= LIRC_CAN_SET_SEND_DUTY_CYCLE;
411 if (dev->s_rx_carrier_range)
412 val |= LIRC_CAN_SET_REC_CARRIER |
413 LIRC_CAN_SET_REC_CARRIER_RANGE;
415 if (dev->s_learning_mode)
416 val |= LIRC_CAN_USE_WIDEBAND_RECEIVER;
418 if (dev->s_carrier_report)
419 val |= LIRC_CAN_MEASURE_CARRIER;
421 if (dev->max_timeout)
422 val |= LIRC_CAN_SET_REC_TIMEOUT;
427 case LIRC_GET_REC_MODE:
428 if (dev->driver_type == RC_DRIVER_IR_RAW_TX)
434 case LIRC_SET_REC_MODE:
435 switch (dev->driver_type) {
436 case RC_DRIVER_IR_RAW_TX:
439 case RC_DRIVER_SCANCODE:
440 if (val != LIRC_MODE_SCANCODE)
443 case RC_DRIVER_IR_RAW:
444 if (!(val == LIRC_MODE_MODE2 ||
445 val == LIRC_MODE_SCANCODE))
454 case LIRC_GET_SEND_MODE:
461 case LIRC_SET_SEND_MODE:
464 else if (!(val == LIRC_MODE_PULSE || val == LIRC_MODE_SCANCODE))
471 case LIRC_SET_TRANSMITTER_MASK:
475 ret = dev->s_tx_mask(dev, val);
478 case LIRC_SET_SEND_CARRIER:
479 if (!dev->s_tx_carrier)
482 ret = dev->s_tx_carrier(dev, val);
485 case LIRC_SET_SEND_DUTY_CYCLE:
486 if (!dev->s_tx_duty_cycle)
488 else if (val <= 0 || val >= 100)
491 ret = dev->s_tx_duty_cycle(dev, val);
495 case LIRC_SET_REC_CARRIER:
496 if (!dev->s_rx_carrier_range)
501 ret = dev->s_rx_carrier_range(dev, fh->carrier_low,
505 case LIRC_SET_REC_CARRIER_RANGE:
506 if (!dev->s_rx_carrier_range)
511 fh->carrier_low = val;
514 case LIRC_GET_REC_RESOLUTION:
515 if (!dev->rx_resolution)
518 val = dev->rx_resolution;
521 case LIRC_SET_WIDEBAND_RECEIVER:
522 if (!dev->s_learning_mode)
525 ret = dev->s_learning_mode(dev, !!val);
528 case LIRC_SET_MEASURE_CARRIER_MODE:
529 if (!dev->s_carrier_report)
532 ret = dev->s_carrier_report(dev, !!val);
535 /* Generic timeout support */
536 case LIRC_GET_MIN_TIMEOUT:
537 if (!dev->max_timeout)
540 val = dev->min_timeout;
543 case LIRC_GET_MAX_TIMEOUT:
544 if (!dev->max_timeout)
547 val = dev->max_timeout;
550 case LIRC_SET_REC_TIMEOUT:
551 if (!dev->max_timeout) {
554 if (val < dev->min_timeout || val > dev->max_timeout)
556 else if (dev->s_timeout)
557 ret = dev->s_timeout(dev, val);
563 case LIRC_GET_REC_TIMEOUT:
570 case LIRC_SET_REC_TIMEOUT_REPORTS:
571 if (dev->driver_type != RC_DRIVER_IR_RAW)
574 fh->send_timeout_reports = !!val;
581 if (!ret && _IOC_DIR(cmd) & _IOC_READ)
582 ret = put_user(val, argp);
585 mutex_unlock(&dev->lock);
589 static __poll_t lirc_poll(struct file *file, struct poll_table_struct *wait)
591 struct lirc_fh *fh = file->private_data;
592 struct rc_dev *rcdev = fh->rc;
595 poll_wait(file, &fh->wait_poll, wait);
597 if (!rcdev->registered) {
598 events = EPOLLHUP | EPOLLERR;
599 } else if (rcdev->driver_type != RC_DRIVER_IR_RAW_TX) {
600 if (fh->rec_mode == LIRC_MODE_SCANCODE &&
601 !kfifo_is_empty(&fh->scancodes))
602 events = EPOLLIN | EPOLLRDNORM;
604 if (fh->rec_mode == LIRC_MODE_MODE2 &&
605 !kfifo_is_empty(&fh->rawir))
606 events = EPOLLIN | EPOLLRDNORM;
612 static ssize_t lirc_read_mode2(struct file *file, char __user *buffer,
615 struct lirc_fh *fh = file->private_data;
616 struct rc_dev *rcdev = fh->rc;
620 if (length < sizeof(unsigned int) || length % sizeof(unsigned int))
624 if (kfifo_is_empty(&fh->rawir)) {
625 if (file->f_flags & O_NONBLOCK)
628 ret = wait_event_interruptible(fh->wait_poll,
629 !kfifo_is_empty(&fh->rawir) ||
635 if (!rcdev->registered)
638 ret = mutex_lock_interruptible(&rcdev->lock);
641 ret = kfifo_to_user(&fh->rawir, buffer, length, &copied);
642 mutex_unlock(&rcdev->lock);
645 } while (copied == 0);
650 static ssize_t lirc_read_scancode(struct file *file, char __user *buffer,
653 struct lirc_fh *fh = file->private_data;
654 struct rc_dev *rcdev = fh->rc;
658 if (length < sizeof(struct lirc_scancode) ||
659 length % sizeof(struct lirc_scancode))
663 if (kfifo_is_empty(&fh->scancodes)) {
664 if (file->f_flags & O_NONBLOCK)
667 ret = wait_event_interruptible(fh->wait_poll,
668 !kfifo_is_empty(&fh->scancodes) ||
674 if (!rcdev->registered)
677 ret = mutex_lock_interruptible(&rcdev->lock);
680 ret = kfifo_to_user(&fh->scancodes, buffer, length, &copied);
681 mutex_unlock(&rcdev->lock);
684 } while (copied == 0);
689 static ssize_t lirc_read(struct file *file, char __user *buffer, size_t length,
692 struct lirc_fh *fh = file->private_data;
693 struct rc_dev *rcdev = fh->rc;
695 if (rcdev->driver_type == RC_DRIVER_IR_RAW_TX)
698 if (!rcdev->registered)
701 if (fh->rec_mode == LIRC_MODE_MODE2)
702 return lirc_read_mode2(file, buffer, length);
703 else /* LIRC_MODE_SCANCODE */
704 return lirc_read_scancode(file, buffer, length);
707 static const struct file_operations lirc_fops = {
708 .owner = THIS_MODULE,
709 .write = lirc_transmit,
710 .unlocked_ioctl = lirc_ioctl,
711 .compat_ioctl = compat_ptr_ioctl,
715 .release = lirc_close,
719 static void lirc_release_device(struct device *ld)
721 struct rc_dev *rcdev = container_of(ld, struct rc_dev, lirc_dev);
723 put_device(&rcdev->dev);
726 int lirc_register(struct rc_dev *dev)
728 const char *rx_type, *tx_type;
731 minor = ida_simple_get(&lirc_ida, 0, RC_DEV_MAX, GFP_KERNEL);
735 device_initialize(&dev->lirc_dev);
736 dev->lirc_dev.class = lirc_class;
737 dev->lirc_dev.parent = &dev->dev;
738 dev->lirc_dev.release = lirc_release_device;
739 dev->lirc_dev.devt = MKDEV(MAJOR(lirc_base_dev), minor);
740 dev_set_name(&dev->lirc_dev, "lirc%d", minor);
742 INIT_LIST_HEAD(&dev->lirc_fh);
743 spin_lock_init(&dev->lirc_fh_lock);
745 cdev_init(&dev->lirc_cdev, &lirc_fops);
747 err = cdev_device_add(&dev->lirc_cdev, &dev->lirc_dev);
751 get_device(&dev->dev);
753 switch (dev->driver_type) {
754 case RC_DRIVER_SCANCODE:
755 rx_type = "scancode";
757 case RC_DRIVER_IR_RAW:
770 dev_info(&dev->dev, "lirc_dev: driver %s registered at minor = %d, %s receiver, %s transmitter",
771 dev->driver_name, minor, rx_type, tx_type);
776 ida_simple_remove(&lirc_ida, minor);
780 void lirc_unregister(struct rc_dev *dev)
785 dev_dbg(&dev->dev, "lirc_dev: driver %s unregistered from minor = %d\n",
786 dev->driver_name, MINOR(dev->lirc_dev.devt));
788 spin_lock_irqsave(&dev->lirc_fh_lock, flags);
789 list_for_each_entry(fh, &dev->lirc_fh, list)
790 wake_up_poll(&fh->wait_poll, EPOLLHUP | EPOLLERR);
791 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
793 cdev_device_del(&dev->lirc_cdev, &dev->lirc_dev);
794 ida_simple_remove(&lirc_ida, MINOR(dev->lirc_dev.devt));
797 int __init lirc_dev_init(void)
801 lirc_class = class_create(THIS_MODULE, "lirc");
802 if (IS_ERR(lirc_class)) {
803 pr_err("class_create failed\n");
804 return PTR_ERR(lirc_class);
807 retval = alloc_chrdev_region(&lirc_base_dev, 0, RC_DEV_MAX, "lirc");
809 class_destroy(lirc_class);
810 pr_err("alloc_chrdev_region failed\n");
814 pr_debug("IR Remote Control driver registered, major %d\n",
815 MAJOR(lirc_base_dev));
820 void __exit lirc_dev_exit(void)
822 class_destroy(lirc_class);
823 unregister_chrdev_region(lirc_base_dev, RC_DEV_MAX);
826 struct rc_dev *rc_dev_get_from_fd(int fd)
828 struct fd f = fdget(fd);
833 return ERR_PTR(-EBADF);
835 if (f.file->f_op != &lirc_fops) {
837 return ERR_PTR(-EINVAL);
840 fh = f.file->private_data;
843 get_device(&dev->dev);
849 MODULE_ALIAS("lirc_dev");