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 */
lirc_raw_event(struct rc_dev * dev,struct ir_raw_event ev)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 */
lirc_scancode_event(struct rc_dev * dev,struct lirc_scancode * lsc)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
lirc_open(struct inode * inode,struct file * file)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
lirc_close(struct inode * inode,struct file * file)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
lirc_transmit(struct file * file,const char __user * buf,size_t n,loff_t * ppos)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
lirc_ioctl(struct file * file,unsigned int cmd,unsigned long arg)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
lirc_poll(struct file * file,struct poll_table_struct * wait)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
lirc_read_mode2(struct file * file,char __user * buffer,size_t length)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
lirc_read_scancode(struct file * file,char __user * buffer,size_t length)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
lirc_read(struct file * file,char __user * buffer,size_t length,loff_t * ppos)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
lirc_release_device(struct device * ld)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
lirc_register(struct rc_dev * dev)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
lirc_unregister(struct rc_dev * dev)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
lirc_dev_init(void)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
lirc_dev_exit(void)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
rc_dev_get_from_fd(int fd,bool write)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");
856