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 | */ |
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(later: ktime_get(), |
71 | earlier: 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(lock: &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(lock: &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 | */ |
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(lock: &dev->lirc_fh_lock, flags); |
122 | } |
123 | EXPORT_SYMBOL_GPL(lirc_scancode_event); |
124 | |
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(size: sizeof(*fh), GFP_KERNEL); |
130 | unsigned long flags; |
131 | int retval; |
132 | |
133 | if (!fh) |
134 | return -ENOMEM; |
135 | |
136 | get_device(dev: &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(rdev: 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(new: &fh->list, head: &dev->lirc_fh); |
174 | spin_unlock_irqrestore(lock: &dev->lirc_fh_lock, flags); |
175 | |
176 | stream_open(inode, filp: 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(objp: fh); |
187 | put_device(dev: &dev->dev); |
188 | |
189 | return retval; |
190 | } |
191 | |
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(entry: &fh->list); |
200 | spin_unlock_irqrestore(lock: &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(objp: fh); |
207 | |
208 | rc_close(rdev: dev); |
209 | put_device(dev: &dev->dev); |
210 | |
211 | return 0; |
212 | } |
213 | |
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(to: &scan, from: buf, n: 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(proto: scan.rc_proto, scancode: scan.scancode)) { |
264 | ret = -EINVAL; |
265 | goto out_unlock; |
266 | } |
267 | |
268 | raw = kmalloc_array(LIRCBUF_SIZE, size: sizeof(*raw), GFP_KERNEL); |
269 | if (!raw) { |
270 | ret = -ENOMEM; |
271 | goto out_unlock; |
272 | } |
273 | |
274 | ret = ir_raw_encode_scancode(protocol: scan.rc_proto, scancode: scan.scancode, |
275 | events: raw, LIRCBUF_SIZE); |
276 | if (ret < 0) |
277 | goto out_kfree_raw; |
278 | |
279 | /* drop trailing space */ |
280 | if (!(ret % 2)) |
281 | count = ret - 1; |
282 | else |
283 | count = ret; |
284 | |
285 | txbuf = kmalloc_array(n: count, size: sizeof(unsigned int), GFP_KERNEL); |
286 | if (!txbuf) { |
287 | ret = -ENOMEM; |
288 | goto out_kfree_raw; |
289 | } |
290 | |
291 | for (i = 0; i < count; i++) |
292 | txbuf[i] = raw[i].duration; |
293 | |
294 | if (dev->s_tx_carrier) { |
295 | int carrier = ir_raw_encode_carrier(protocol: scan.rc_proto); |
296 | |
297 | if (carrier > 0) |
298 | dev->s_tx_carrier(dev, carrier); |
299 | } |
300 | } else { |
301 | if (n < sizeof(unsigned int) || n % sizeof(unsigned int)) { |
302 | ret = -EINVAL; |
303 | goto out_unlock; |
304 | } |
305 | |
306 | count = n / sizeof(unsigned int); |
307 | if (count > LIRCBUF_SIZE || count % 2 == 0) { |
308 | ret = -EINVAL; |
309 | goto out_unlock; |
310 | } |
311 | |
312 | txbuf = memdup_user(buf, n); |
313 | if (IS_ERR(ptr: txbuf)) { |
314 | ret = PTR_ERR(ptr: txbuf); |
315 | goto out_unlock; |
316 | } |
317 | } |
318 | |
319 | for (i = 0; i < count; i++) { |
320 | if (txbuf[i] > IR_MAX_DURATION - duration || !txbuf[i]) { |
321 | ret = -EINVAL; |
322 | goto out_kfree; |
323 | } |
324 | |
325 | duration += txbuf[i]; |
326 | } |
327 | |
328 | start = ktime_get(); |
329 | |
330 | ret = dev->tx_ir(dev, txbuf, count); |
331 | if (ret < 0) |
332 | goto out_kfree; |
333 | |
334 | kfree(objp: txbuf); |
335 | kfree(objp: raw); |
336 | mutex_unlock(lock: &dev->lock); |
337 | |
338 | /* |
339 | * The lircd gap calculation expects the write function to |
340 | * wait for the actual IR signal to be transmitted before |
341 | * returning. |
342 | */ |
343 | towait = ktime_us_delta(later: ktime_add_us(kt: start, usec: duration), |
344 | earlier: ktime_get()); |
345 | if (towait > 0) { |
346 | set_current_state(TASK_INTERRUPTIBLE); |
347 | schedule_timeout(timeout: usecs_to_jiffies(u: towait)); |
348 | } |
349 | |
350 | return n; |
351 | out_kfree: |
352 | kfree(objp: txbuf); |
353 | out_kfree_raw: |
354 | kfree(objp: raw); |
355 | out_unlock: |
356 | mutex_unlock(lock: &dev->lock); |
357 | return ret; |
358 | } |
359 | |
360 | static long lirc_ioctl(struct file *file, unsigned int cmd, unsigned long arg) |
361 | { |
362 | struct lirc_fh *fh = file->private_data; |
363 | struct rc_dev *dev = fh->rc; |
364 | u32 __user *argp = (u32 __user *)(arg); |
365 | u32 val = 0; |
366 | int ret; |
367 | |
368 | if (_IOC_DIR(cmd) & _IOC_WRITE) { |
369 | ret = get_user(val, argp); |
370 | if (ret) |
371 | return ret; |
372 | } |
373 | |
374 | ret = mutex_lock_interruptible(&dev->lock); |
375 | if (ret) |
376 | return ret; |
377 | |
378 | if (!dev->registered) { |
379 | ret = -ENODEV; |
380 | goto out; |
381 | } |
382 | |
383 | switch (cmd) { |
384 | case LIRC_GET_FEATURES: |
385 | if (dev->driver_type == RC_DRIVER_SCANCODE) |
386 | val |= LIRC_CAN_REC_SCANCODE; |
387 | |
388 | if (dev->driver_type == RC_DRIVER_IR_RAW) { |
389 | val |= LIRC_CAN_REC_MODE2; |
390 | if (dev->rx_resolution) |
391 | val |= LIRC_CAN_GET_REC_RESOLUTION; |
392 | } |
393 | |
394 | if (dev->tx_ir) { |
395 | val |= LIRC_CAN_SEND_PULSE; |
396 | if (dev->s_tx_mask) |
397 | val |= LIRC_CAN_SET_TRANSMITTER_MASK; |
398 | if (dev->s_tx_carrier) |
399 | val |= LIRC_CAN_SET_SEND_CARRIER; |
400 | if (dev->s_tx_duty_cycle) |
401 | val |= LIRC_CAN_SET_SEND_DUTY_CYCLE; |
402 | } |
403 | |
404 | if (dev->s_rx_carrier_range) |
405 | val |= LIRC_CAN_SET_REC_CARRIER | |
406 | LIRC_CAN_SET_REC_CARRIER_RANGE; |
407 | |
408 | if (dev->s_wideband_receiver) |
409 | val |= LIRC_CAN_USE_WIDEBAND_RECEIVER; |
410 | |
411 | if (dev->s_carrier_report) |
412 | val |= LIRC_CAN_MEASURE_CARRIER; |
413 | |
414 | if (dev->max_timeout) |
415 | val |= LIRC_CAN_SET_REC_TIMEOUT; |
416 | |
417 | break; |
418 | |
419 | /* mode support */ |
420 | case LIRC_GET_REC_MODE: |
421 | if (dev->driver_type == RC_DRIVER_IR_RAW_TX) |
422 | ret = -ENOTTY; |
423 | else |
424 | val = fh->rec_mode; |
425 | break; |
426 | |
427 | case LIRC_SET_REC_MODE: |
428 | switch (dev->driver_type) { |
429 | case RC_DRIVER_IR_RAW_TX: |
430 | ret = -ENOTTY; |
431 | break; |
432 | case RC_DRIVER_SCANCODE: |
433 | if (val != LIRC_MODE_SCANCODE) |
434 | ret = -EINVAL; |
435 | break; |
436 | case RC_DRIVER_IR_RAW: |
437 | if (!(val == LIRC_MODE_MODE2 || |
438 | val == LIRC_MODE_SCANCODE)) |
439 | ret = -EINVAL; |
440 | break; |
441 | } |
442 | |
443 | if (!ret) |
444 | fh->rec_mode = val; |
445 | break; |
446 | |
447 | case LIRC_GET_SEND_MODE: |
448 | if (!dev->tx_ir) |
449 | ret = -ENOTTY; |
450 | else |
451 | val = fh->send_mode; |
452 | break; |
453 | |
454 | case LIRC_SET_SEND_MODE: |
455 | if (!dev->tx_ir) |
456 | ret = -ENOTTY; |
457 | else if (!(val == LIRC_MODE_PULSE || val == LIRC_MODE_SCANCODE)) |
458 | ret = -EINVAL; |
459 | else |
460 | fh->send_mode = val; |
461 | break; |
462 | |
463 | /* TX settings */ |
464 | case LIRC_SET_TRANSMITTER_MASK: |
465 | if (!dev->s_tx_mask) |
466 | ret = -ENOTTY; |
467 | else |
468 | ret = dev->s_tx_mask(dev, val); |
469 | break; |
470 | |
471 | case LIRC_SET_SEND_CARRIER: |
472 | if (!dev->s_tx_carrier) |
473 | ret = -ENOTTY; |
474 | else |
475 | ret = dev->s_tx_carrier(dev, val); |
476 | break; |
477 | |
478 | case LIRC_SET_SEND_DUTY_CYCLE: |
479 | if (!dev->s_tx_duty_cycle) |
480 | ret = -ENOTTY; |
481 | else if (val <= 0 || val >= 100) |
482 | ret = -EINVAL; |
483 | else |
484 | ret = dev->s_tx_duty_cycle(dev, val); |
485 | break; |
486 | |
487 | /* RX settings */ |
488 | case LIRC_SET_REC_CARRIER: |
489 | if (!dev->s_rx_carrier_range) |
490 | ret = -ENOTTY; |
491 | else if (val <= 0) |
492 | ret = -EINVAL; |
493 | else |
494 | ret = dev->s_rx_carrier_range(dev, fh->carrier_low, |
495 | val); |
496 | break; |
497 | |
498 | case LIRC_SET_REC_CARRIER_RANGE: |
499 | if (!dev->s_rx_carrier_range) |
500 | ret = -ENOTTY; |
501 | else if (val <= 0) |
502 | ret = -EINVAL; |
503 | else |
504 | fh->carrier_low = val; |
505 | break; |
506 | |
507 | case LIRC_GET_REC_RESOLUTION: |
508 | if (!dev->rx_resolution) |
509 | ret = -ENOTTY; |
510 | else |
511 | val = dev->rx_resolution; |
512 | break; |
513 | |
514 | case LIRC_SET_WIDEBAND_RECEIVER: |
515 | if (!dev->s_wideband_receiver) |
516 | ret = -ENOTTY; |
517 | else |
518 | ret = dev->s_wideband_receiver(dev, !!val); |
519 | break; |
520 | |
521 | case LIRC_SET_MEASURE_CARRIER_MODE: |
522 | if (!dev->s_carrier_report) |
523 | ret = -ENOTTY; |
524 | else |
525 | ret = dev->s_carrier_report(dev, !!val); |
526 | break; |
527 | |
528 | /* Generic timeout support */ |
529 | case LIRC_GET_MIN_TIMEOUT: |
530 | if (!dev->max_timeout) |
531 | ret = -ENOTTY; |
532 | else |
533 | val = dev->min_timeout; |
534 | break; |
535 | |
536 | case LIRC_GET_MAX_TIMEOUT: |
537 | if (!dev->max_timeout) |
538 | ret = -ENOTTY; |
539 | else |
540 | val = dev->max_timeout; |
541 | break; |
542 | |
543 | case LIRC_SET_REC_TIMEOUT: |
544 | if (!dev->max_timeout) { |
545 | ret = -ENOTTY; |
546 | } else { |
547 | if (val < dev->min_timeout || val > dev->max_timeout) |
548 | ret = -EINVAL; |
549 | else if (dev->s_timeout) |
550 | ret = dev->s_timeout(dev, val); |
551 | else |
552 | dev->timeout = val; |
553 | } |
554 | break; |
555 | |
556 | case LIRC_GET_REC_TIMEOUT: |
557 | if (!dev->timeout) |
558 | ret = -ENOTTY; |
559 | else |
560 | val = dev->timeout; |
561 | break; |
562 | |
563 | case LIRC_SET_REC_TIMEOUT_REPORTS: |
564 | if (dev->driver_type != RC_DRIVER_IR_RAW) |
565 | ret = -ENOTTY; |
566 | break; |
567 | |
568 | default: |
569 | ret = -ENOTTY; |
570 | } |
571 | |
572 | if (!ret && _IOC_DIR(cmd) & _IOC_READ) |
573 | ret = put_user(val, argp); |
574 | |
575 | out: |
576 | mutex_unlock(lock: &dev->lock); |
577 | return ret; |
578 | } |
579 | |
580 | static __poll_t lirc_poll(struct file *file, struct poll_table_struct *wait) |
581 | { |
582 | struct lirc_fh *fh = file->private_data; |
583 | struct rc_dev *rcdev = fh->rc; |
584 | __poll_t events = 0; |
585 | |
586 | poll_wait(filp: file, wait_address: &fh->wait_poll, p: wait); |
587 | |
588 | if (!rcdev->registered) { |
589 | events = EPOLLHUP | EPOLLERR; |
590 | } else if (rcdev->driver_type != RC_DRIVER_IR_RAW_TX) { |
591 | if (fh->rec_mode == LIRC_MODE_SCANCODE && |
592 | !kfifo_is_empty(&fh->scancodes)) |
593 | events = EPOLLIN | EPOLLRDNORM; |
594 | |
595 | if (fh->rec_mode == LIRC_MODE_MODE2 && |
596 | !kfifo_is_empty(&fh->rawir)) |
597 | events = EPOLLIN | EPOLLRDNORM; |
598 | } |
599 | |
600 | return events; |
601 | } |
602 | |
603 | static ssize_t lirc_read_mode2(struct file *file, char __user *buffer, |
604 | size_t length) |
605 | { |
606 | struct lirc_fh *fh = file->private_data; |
607 | struct rc_dev *rcdev = fh->rc; |
608 | unsigned int copied; |
609 | int ret; |
610 | |
611 | if (length < sizeof(unsigned int) || length % sizeof(unsigned int)) |
612 | return -EINVAL; |
613 | |
614 | do { |
615 | if (kfifo_is_empty(&fh->rawir)) { |
616 | if (file->f_flags & O_NONBLOCK) |
617 | return -EAGAIN; |
618 | |
619 | ret = wait_event_interruptible(fh->wait_poll, |
620 | !kfifo_is_empty(&fh->rawir) || |
621 | !rcdev->registered); |
622 | if (ret) |
623 | return ret; |
624 | } |
625 | |
626 | if (!rcdev->registered) |
627 | return -ENODEV; |
628 | |
629 | ret = mutex_lock_interruptible(&rcdev->lock); |
630 | if (ret) |
631 | return ret; |
632 | ret = kfifo_to_user(&fh->rawir, buffer, length, &copied); |
633 | mutex_unlock(lock: &rcdev->lock); |
634 | if (ret) |
635 | return ret; |
636 | } while (copied == 0); |
637 | |
638 | return copied; |
639 | } |
640 | |
641 | static ssize_t lirc_read_scancode(struct file *file, char __user *buffer, |
642 | size_t length) |
643 | { |
644 | struct lirc_fh *fh = file->private_data; |
645 | struct rc_dev *rcdev = fh->rc; |
646 | unsigned int copied; |
647 | int ret; |
648 | |
649 | if (length < sizeof(struct lirc_scancode) || |
650 | length % sizeof(struct lirc_scancode)) |
651 | return -EINVAL; |
652 | |
653 | do { |
654 | if (kfifo_is_empty(&fh->scancodes)) { |
655 | if (file->f_flags & O_NONBLOCK) |
656 | return -EAGAIN; |
657 | |
658 | ret = wait_event_interruptible(fh->wait_poll, |
659 | !kfifo_is_empty(&fh->scancodes) || |
660 | !rcdev->registered); |
661 | if (ret) |
662 | return ret; |
663 | } |
664 | |
665 | if (!rcdev->registered) |
666 | return -ENODEV; |
667 | |
668 | ret = mutex_lock_interruptible(&rcdev->lock); |
669 | if (ret) |
670 | return ret; |
671 | ret = kfifo_to_user(&fh->scancodes, buffer, length, &copied); |
672 | mutex_unlock(lock: &rcdev->lock); |
673 | if (ret) |
674 | return ret; |
675 | } while (copied == 0); |
676 | |
677 | return copied; |
678 | } |
679 | |
680 | static ssize_t lirc_read(struct file *file, char __user *buffer, size_t length, |
681 | loff_t *ppos) |
682 | { |
683 | struct lirc_fh *fh = file->private_data; |
684 | struct rc_dev *rcdev = fh->rc; |
685 | |
686 | if (rcdev->driver_type == RC_DRIVER_IR_RAW_TX) |
687 | return -EINVAL; |
688 | |
689 | if (!rcdev->registered) |
690 | return -ENODEV; |
691 | |
692 | if (fh->rec_mode == LIRC_MODE_MODE2) |
693 | return lirc_read_mode2(file, buffer, length); |
694 | else /* LIRC_MODE_SCANCODE */ |
695 | return lirc_read_scancode(file, buffer, length); |
696 | } |
697 | |
698 | static const struct file_operations lirc_fops = { |
699 | .owner = THIS_MODULE, |
700 | .write = lirc_transmit, |
701 | .unlocked_ioctl = lirc_ioctl, |
702 | .compat_ioctl = compat_ptr_ioctl, |
703 | .read = lirc_read, |
704 | .poll = lirc_poll, |
705 | .open = lirc_open, |
706 | .release = lirc_close, |
707 | .llseek = no_llseek, |
708 | }; |
709 | |
710 | static void lirc_release_device(struct device *ld) |
711 | { |
712 | struct rc_dev *rcdev = container_of(ld, struct rc_dev, lirc_dev); |
713 | |
714 | put_device(dev: &rcdev->dev); |
715 | } |
716 | |
717 | int lirc_register(struct rc_dev *dev) |
718 | { |
719 | const char *rx_type, *tx_type; |
720 | int err, minor; |
721 | |
722 | minor = ida_alloc_max(ida: &lirc_ida, RC_DEV_MAX - 1, GFP_KERNEL); |
723 | if (minor < 0) |
724 | return minor; |
725 | |
726 | device_initialize(dev: &dev->lirc_dev); |
727 | dev->lirc_dev.class = lirc_class; |
728 | dev->lirc_dev.parent = &dev->dev; |
729 | dev->lirc_dev.release = lirc_release_device; |
730 | dev->lirc_dev.devt = MKDEV(MAJOR(lirc_base_dev), minor); |
731 | dev_set_name(dev: &dev->lirc_dev, name: "lirc%d" , minor); |
732 | |
733 | INIT_LIST_HEAD(list: &dev->lirc_fh); |
734 | spin_lock_init(&dev->lirc_fh_lock); |
735 | |
736 | cdev_init(&dev->lirc_cdev, &lirc_fops); |
737 | |
738 | err = cdev_device_add(cdev: &dev->lirc_cdev, dev: &dev->lirc_dev); |
739 | if (err) |
740 | goto out_ida; |
741 | |
742 | get_device(dev: &dev->dev); |
743 | |
744 | switch (dev->driver_type) { |
745 | case RC_DRIVER_SCANCODE: |
746 | rx_type = "scancode" ; |
747 | break; |
748 | case RC_DRIVER_IR_RAW: |
749 | rx_type = "raw IR" ; |
750 | break; |
751 | default: |
752 | rx_type = "no" ; |
753 | break; |
754 | } |
755 | |
756 | if (dev->tx_ir) |
757 | tx_type = "raw IR" ; |
758 | else |
759 | tx_type = "no" ; |
760 | |
761 | dev_info(&dev->dev, "lirc_dev: driver %s registered at minor = %d, %s receiver, %s transmitter" , |
762 | dev->driver_name, minor, rx_type, tx_type); |
763 | |
764 | return 0; |
765 | |
766 | out_ida: |
767 | ida_free(&lirc_ida, id: minor); |
768 | return err; |
769 | } |
770 | |
771 | void lirc_unregister(struct rc_dev *dev) |
772 | { |
773 | unsigned long flags; |
774 | struct lirc_fh *fh; |
775 | |
776 | dev_dbg(&dev->dev, "lirc_dev: driver %s unregistered from minor = %d\n" , |
777 | dev->driver_name, MINOR(dev->lirc_dev.devt)); |
778 | |
779 | spin_lock_irqsave(&dev->lirc_fh_lock, flags); |
780 | list_for_each_entry(fh, &dev->lirc_fh, list) |
781 | wake_up_poll(&fh->wait_poll, EPOLLHUP | EPOLLERR); |
782 | spin_unlock_irqrestore(lock: &dev->lirc_fh_lock, flags); |
783 | |
784 | cdev_device_del(cdev: &dev->lirc_cdev, dev: &dev->lirc_dev); |
785 | ida_free(&lirc_ida, MINOR(dev->lirc_dev.devt)); |
786 | } |
787 | |
788 | int __init lirc_dev_init(void) |
789 | { |
790 | int retval; |
791 | |
792 | lirc_class = class_create(name: "lirc" ); |
793 | if (IS_ERR(ptr: lirc_class)) { |
794 | pr_err("class_create failed\n" ); |
795 | return PTR_ERR(ptr: lirc_class); |
796 | } |
797 | |
798 | retval = alloc_chrdev_region(&lirc_base_dev, 0, RC_DEV_MAX, "lirc" ); |
799 | if (retval) { |
800 | class_destroy(cls: 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 | |
811 | void __exit lirc_dev_exit(void) |
812 | { |
813 | class_destroy(cls: lirc_class); |
814 | unregister_chrdev_region(lirc_base_dev, RC_DEV_MAX); |
815 | } |
816 | |
817 | struct rc_dev *rc_dev_get_from_fd(int fd) |
818 | { |
819 | struct fd f = fdget(fd); |
820 | struct lirc_fh *fh; |
821 | struct rc_dev *dev; |
822 | |
823 | if (!f.file) |
824 | return ERR_PTR(error: -EBADF); |
825 | |
826 | if (f.file->f_op != &lirc_fops) { |
827 | fdput(fd: f); |
828 | return ERR_PTR(error: -EINVAL); |
829 | } |
830 | |
831 | fh = f.file->private_data; |
832 | dev = fh->rc; |
833 | |
834 | get_device(dev: &dev->dev); |
835 | fdput(fd: f); |
836 | |
837 | return dev; |
838 | } |
839 | |
840 | MODULE_ALIAS("lirc_dev" ); |
841 | |