projects/linux·blob master · refs

840 lines · 17.7 KiB

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
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 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 */
40void 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 */
111void 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}
125EXPORT_SYMBOL_GPL(lirc_scancode_event);
126
127static 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_obj(*fh);
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;
181out_kfifo:
182 if (dev->driver_type != RC_DRIVER_IR_RAW_TX)
183 kfifo_free(&fh->scancodes);
184out_rawir:
185 if (dev->driver_type == RC_DRIVER_IR_RAW)
186 kfifo_free(&fh->rawir);
187out_fh:
188 kfree(fh);
189 put_device(&dev->dev);
190
191 return retval;
192}
193
194static 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
216static 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_objs(*raw, LIRCBUF_SIZE);
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;
353out_kfree:
354 kfree(txbuf);
355out_kfree_raw:
356 kfree(raw);
357out_unlock:
358 mutex_unlock(&dev->lock);
359 return ret;
360}
361
362static 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
577out:
578 mutex_unlock(&dev->lock);
579 return ret;
580}
581
582static __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
605static 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
643static 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
682static 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
700static 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
711static 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
718int 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 get_device(&dev->dev);
740
741 err = cdev_device_add(&dev->lirc_cdev, &dev->lirc_dev);
742 if (err)
743 goto out_put_device;
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
767out_put_device:
768 put_device(&dev->lirc_dev);
769 ida_free(&lirc_ida, minor);
770 return err;
771}
772
773void lirc_unregister(struct rc_dev *dev)
774{
775 unsigned long flags;
776 struct lirc_fh *fh;
777
778 dev_dbg(&dev->dev, "lirc_dev: driver %s unregistered from minor = %d\n",
779 dev->driver_name, MINOR(dev->lirc_dev.devt));
780
781 spin_lock_irqsave(&dev->lirc_fh_lock, flags);
782 list_for_each_entry(fh, &dev->lirc_fh, list)
783 wake_up_poll(&fh->wait_poll, EPOLLHUP | EPOLLERR);
784 spin_unlock_irqrestore(&dev->lirc_fh_lock, flags);
785
786 cdev_device_del(&dev->lirc_cdev, &dev->lirc_dev);
787 ida_free(&lirc_ida, MINOR(dev->lirc_dev.devt));
788}
789
790int __init lirc_dev_init(void)
791{
792 int retval;
793
794 retval = class_register(&lirc_class);
795 if (retval)
796 return retval;
797
798 retval = alloc_chrdev_region(&lirc_base_dev, 0, RC_DEV_MAX, "lirc");
799 if (retval) {
800 class_unregister(&lirc_class);
801 pr_err("alloc_chrdev_region failed\n");
802 return retval;
803 }
804
805 pr_debug("IR Remote Control driver registered, major %d\n",
806 MAJOR(lirc_base_dev));
807
808 return 0;
809}
810
811void __exit lirc_dev_exit(void)
812{
813 class_unregister(&lirc_class);
814 unregister_chrdev_region(lirc_base_dev, RC_DEV_MAX);
815}
816
817struct rc_dev *rc_dev_get_from_fd(int fd, bool write)
818{
819 CLASS(fd, f)(fd);
820 struct lirc_fh *fh;
821 struct rc_dev *dev;
822
823 if (fd_empty(f))
824 return ERR_PTR(-EBADF);
825
826 if (fd_file(f)->f_op != &lirc_fops)
827 return ERR_PTR(-EINVAL);
828
829 if (write && !(fd_file(f)->f_mode & FMODE_WRITE))
830 return ERR_PTR(-EPERM);
831
832 fh = fd_file(f)->private_data;
833 dev = fh->rc;
834
835 get_device(&dev->dev);
836
837 return dev;
838}
839
840MODULE_ALIAS("lirc_dev");