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