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 /* 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 */
lirc_scancode_event(struct rc_dev * dev,struct lirc_scancode * lsc)109 void 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 }
123 EXPORT_SYMBOL_GPL(lirc_scancode_event);
124
lirc_open(struct inode * inode,struct file * file)125 static 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;
179 out_kfifo:
180 if (dev->driver_type != RC_DRIVER_IR_RAW_TX)
181 kfifo_free(&fh->scancodes);
182 out_rawir:
183 if (dev->driver_type == RC_DRIVER_IR_RAW)
184 kfifo_free(&fh->rawir);
185 out_fh:
186 kfree(fh);
187 put_device(&dev->dev);
188
189 return retval;
190 }
191
lirc_close(struct inode * inode,struct file * file)192 static 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
lirc_transmit(struct file * file,const char __user * buf,size_t n,loff_t * ppos)214 static 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;
347 out_kfree:
348 kfree(txbuf);
349 out_kfree_raw:
350 kfree(raw);
351 out_unlock:
352 mutex_unlock(&dev->lock);
353 return ret;
354 }
355
lirc_ioctl(struct file * file,unsigned int cmd,unsigned long arg)356 static 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
571 out:
572 mutex_unlock(&dev->lock);
573 return ret;
574 }
575
lirc_poll(struct file * file,struct poll_table_struct * wait)576 static __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
lirc_read_mode2(struct file * file,char __user * buffer,size_t length)599 static 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
lirc_read_scancode(struct file * file,char __user * buffer,size_t length)637 static 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
lirc_read(struct file * file,char __user * buffer,size_t length,loff_t * ppos)676 static 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
694 static 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
lirc_release_device(struct device * ld)706 static 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
lirc_register(struct rc_dev * dev)713 int 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
762 out_ida:
763 ida_free(&lirc_ida, minor);
764 return err;
765 }
766
lirc_unregister(struct rc_dev * dev)767 void 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
lirc_dev_init(void)784 int __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
lirc_dev_exit(void)807 void __exit lirc_dev_exit(void)
808 {
809 class_destroy(lirc_class);
810 unregister_chrdev_region(lirc_base_dev, RC_DEV_MAX);
811 }
812
rc_dev_get_from_fd(int fd)813 struct 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
836 MODULE_ALIAS("lirc_dev");
837
