Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : // rc-ir-raw.c - handle IR pulse/space events
3 : : //
4 : : // Copyright (C) 2010 by Mauro Carvalho Chehab
5 : :
6 : : #include <linux/export.h>
7 : : #include <linux/kthread.h>
8 : : #include <linux/mutex.h>
9 : : #include <linux/kmod.h>
10 : : #include <linux/sched.h>
11 : : #include "rc-core-priv.h"
12 : :
13 : : /* Used to keep track of IR raw clients, protected by ir_raw_handler_lock */
14 : : static LIST_HEAD(ir_raw_client_list);
15 : :
16 : : /* Used to handle IR raw handler extensions */
17 : : DEFINE_MUTEX(ir_raw_handler_lock);
18 : : static LIST_HEAD(ir_raw_handler_list);
19 : : static atomic64_t available_protocols = ATOMIC64_INIT(0);
20 : :
21 : 0 : static int ir_raw_event_thread(void *data)
22 : : {
23 : : struct ir_raw_event ev;
24 : : struct ir_raw_handler *handler;
25 : : struct ir_raw_event_ctrl *raw = data;
26 : 0 : struct rc_dev *dev = raw->dev;
27 : :
28 : : while (1) {
29 : 0 : mutex_lock(&ir_raw_handler_lock);
30 : 0 : while (kfifo_out(&raw->kfifo, &ev, 1)) {
31 : 0 : if (is_timing_event(ev)) {
32 : 0 : if (ev.duration == 0)
33 : 0 : dev_warn_once(&dev->dev, "nonsensical timing event of duration 0");
34 : 0 : if (is_timing_event(raw->prev_ev) &&
35 : : !is_transition(&ev, &raw->prev_ev))
36 : 0 : dev_warn_once(&dev->dev, "two consecutive events of type %s",
37 : : TO_STR(ev.pulse));
38 : 0 : if (raw->prev_ev.reset && ev.pulse == 0)
39 : 0 : dev_warn_once(&dev->dev, "timing event after reset should be pulse");
40 : : }
41 : 0 : list_for_each_entry(handler, &ir_raw_handler_list, list)
42 : 0 : if (dev->enabled_protocols &
43 : 0 : handler->protocols || !handler->protocols)
44 : 0 : handler->decode(dev, ev);
45 : 0 : ir_lirc_raw_event(dev, ev);
46 : 0 : raw->prev_ev = ev;
47 : : }
48 : 0 : mutex_unlock(&ir_raw_handler_lock);
49 : :
50 : 0 : set_current_state(TASK_INTERRUPTIBLE);
51 : :
52 : 0 : if (kthread_should_stop()) {
53 : 0 : __set_current_state(TASK_RUNNING);
54 : : break;
55 : 0 : } else if (!kfifo_is_empty(&raw->kfifo))
56 : 0 : set_current_state(TASK_RUNNING);
57 : :
58 : 0 : schedule();
59 : 0 : }
60 : :
61 : 0 : return 0;
62 : : }
63 : :
64 : : /**
65 : : * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders
66 : : * @dev: the struct rc_dev device descriptor
67 : : * @ev: the struct ir_raw_event descriptor of the pulse/space
68 : : *
69 : : * This routine (which may be called from an interrupt context) stores a
70 : : * pulse/space duration for the raw ir decoding state machines. Pulses are
71 : : * signalled as positive values and spaces as negative values. A zero value
72 : : * will reset the decoding state machines.
73 : : */
74 : 0 : int ir_raw_event_store(struct rc_dev *dev, struct ir_raw_event *ev)
75 : : {
76 : 0 : if (!dev->raw)
77 : : return -EINVAL;
78 : :
79 : : dev_dbg(&dev->dev, "sample: (%05dus %s)\n",
80 : : TO_US(ev->duration), TO_STR(ev->pulse));
81 : :
82 : 0 : if (!kfifo_put(&dev->raw->kfifo, *ev)) {
83 : 0 : dev_err(&dev->dev, "IR event FIFO is full!\n");
84 : 0 : return -ENOSPC;
85 : : }
86 : :
87 : : return 0;
88 : : }
89 : : EXPORT_SYMBOL_GPL(ir_raw_event_store);
90 : :
91 : : /**
92 : : * ir_raw_event_store_edge() - notify raw ir decoders of the start of a pulse/space
93 : : * @dev: the struct rc_dev device descriptor
94 : : * @pulse: true for pulse, false for space
95 : : *
96 : : * This routine (which may be called from an interrupt context) is used to
97 : : * store the beginning of an ir pulse or space (or the start/end of ir
98 : : * reception) for the raw ir decoding state machines. This is used by
99 : : * hardware which does not provide durations directly but only interrupts
100 : : * (or similar events) on state change.
101 : : */
102 : 0 : int ir_raw_event_store_edge(struct rc_dev *dev, bool pulse)
103 : : {
104 : : ktime_t now;
105 : 0 : struct ir_raw_event ev = {};
106 : :
107 : 0 : if (!dev->raw)
108 : : return -EINVAL;
109 : :
110 : 0 : now = ktime_get();
111 : 0 : ev.duration = ktime_to_ns(ktime_sub(now, dev->raw->last_event));
112 : 0 : ev.pulse = !pulse;
113 : :
114 : 0 : return ir_raw_event_store_with_timeout(dev, &ev);
115 : : }
116 : : EXPORT_SYMBOL_GPL(ir_raw_event_store_edge);
117 : :
118 : : /*
119 : : * ir_raw_event_store_with_timeout() - pass a pulse/space duration to the raw
120 : : * ir decoders, schedule decoding and
121 : : * timeout
122 : : * @dev: the struct rc_dev device descriptor
123 : : * @ev: the struct ir_raw_event descriptor of the pulse/space
124 : : *
125 : : * This routine (which may be called from an interrupt context) stores a
126 : : * pulse/space duration for the raw ir decoding state machines, schedules
127 : : * decoding and generates a timeout.
128 : : */
129 : 0 : int ir_raw_event_store_with_timeout(struct rc_dev *dev, struct ir_raw_event *ev)
130 : : {
131 : : ktime_t now;
132 : : int rc = 0;
133 : :
134 : 0 : if (!dev->raw)
135 : : return -EINVAL;
136 : :
137 : 0 : now = ktime_get();
138 : :
139 : 0 : spin_lock(&dev->raw->edge_spinlock);
140 : 0 : rc = ir_raw_event_store(dev, ev);
141 : :
142 : 0 : dev->raw->last_event = now;
143 : :
144 : : /* timer could be set to timeout (125ms by default) */
145 : 0 : if (!timer_pending(&dev->raw->edge_handle) ||
146 : 0 : time_after(dev->raw->edge_handle.expires,
147 : : jiffies + msecs_to_jiffies(15))) {
148 : 0 : mod_timer(&dev->raw->edge_handle,
149 : : jiffies + msecs_to_jiffies(15));
150 : : }
151 : 0 : spin_unlock(&dev->raw->edge_spinlock);
152 : :
153 : 0 : return rc;
154 : : }
155 : : EXPORT_SYMBOL_GPL(ir_raw_event_store_with_timeout);
156 : :
157 : : /**
158 : : * ir_raw_event_store_with_filter() - pass next pulse/space to decoders with some processing
159 : : * @dev: the struct rc_dev device descriptor
160 : : * @ev: the event that has occurred
161 : : *
162 : : * This routine (which may be called from an interrupt context) works
163 : : * in similar manner to ir_raw_event_store_edge.
164 : : * This routine is intended for devices with limited internal buffer
165 : : * It automerges samples of same type, and handles timeouts. Returns non-zero
166 : : * if the event was added, and zero if the event was ignored due to idle
167 : : * processing.
168 : : */
169 : 0 : int ir_raw_event_store_with_filter(struct rc_dev *dev, struct ir_raw_event *ev)
170 : : {
171 : 0 : if (!dev->raw)
172 : : return -EINVAL;
173 : :
174 : : /* Ignore spaces in idle mode */
175 : 0 : if (dev->idle && !ev->pulse)
176 : : return 0;
177 : 0 : else if (dev->idle)
178 : 0 : ir_raw_event_set_idle(dev, false);
179 : :
180 : 0 : if (!dev->raw->this_ev.duration)
181 : 0 : dev->raw->this_ev = *ev;
182 : 0 : else if (ev->pulse == dev->raw->this_ev.pulse)
183 : 0 : dev->raw->this_ev.duration += ev->duration;
184 : : else {
185 : 0 : ir_raw_event_store(dev, &dev->raw->this_ev);
186 : 0 : dev->raw->this_ev = *ev;
187 : : }
188 : :
189 : : /* Enter idle mode if necessary */
190 : 0 : if (!ev->pulse && dev->timeout &&
191 : 0 : dev->raw->this_ev.duration >= dev->timeout)
192 : 0 : ir_raw_event_set_idle(dev, true);
193 : :
194 : : return 1;
195 : : }
196 : : EXPORT_SYMBOL_GPL(ir_raw_event_store_with_filter);
197 : :
198 : : /**
199 : : * ir_raw_event_set_idle() - provide hint to rc-core when the device is idle or not
200 : : * @dev: the struct rc_dev device descriptor
201 : : * @idle: whether the device is idle or not
202 : : */
203 : 0 : void ir_raw_event_set_idle(struct rc_dev *dev, bool idle)
204 : : {
205 : 0 : if (!dev->raw)
206 : 0 : return;
207 : :
208 : : dev_dbg(&dev->dev, "%s idle mode\n", idle ? "enter" : "leave");
209 : :
210 : 0 : if (idle) {
211 : 0 : dev->raw->this_ev.timeout = true;
212 : 0 : ir_raw_event_store(dev, &dev->raw->this_ev);
213 : 0 : dev->raw->this_ev = (struct ir_raw_event) {};
214 : : }
215 : :
216 : 0 : if (dev->s_idle)
217 : 0 : dev->s_idle(dev, idle);
218 : :
219 : 0 : dev->idle = idle;
220 : : }
221 : : EXPORT_SYMBOL_GPL(ir_raw_event_set_idle);
222 : :
223 : : /**
224 : : * ir_raw_event_handle() - schedules the decoding of stored ir data
225 : : * @dev: the struct rc_dev device descriptor
226 : : *
227 : : * This routine will tell rc-core to start decoding stored ir data.
228 : : */
229 : 0 : void ir_raw_event_handle(struct rc_dev *dev)
230 : : {
231 : 0 : if (!dev->raw || !dev->raw->thread)
232 : 0 : return;
233 : :
234 : 0 : wake_up_process(dev->raw->thread);
235 : : }
236 : : EXPORT_SYMBOL_GPL(ir_raw_event_handle);
237 : :
238 : : /* used internally by the sysfs interface */
239 : : u64
240 : 0 : ir_raw_get_allowed_protocols(void)
241 : : {
242 : 0 : return atomic64_read(&available_protocols);
243 : : }
244 : :
245 : 0 : static int change_protocol(struct rc_dev *dev, u64 *rc_proto)
246 : : {
247 : : struct ir_raw_handler *handler;
248 : : u32 timeout = 0;
249 : :
250 : 0 : mutex_lock(&ir_raw_handler_lock);
251 : 0 : list_for_each_entry(handler, &ir_raw_handler_list, list) {
252 : 0 : if (!(dev->enabled_protocols & handler->protocols) &&
253 : 0 : (*rc_proto & handler->protocols) && handler->raw_register)
254 : 0 : handler->raw_register(dev);
255 : :
256 : 0 : if ((dev->enabled_protocols & handler->protocols) &&
257 : 0 : !(*rc_proto & handler->protocols) &&
258 : 0 : handler->raw_unregister)
259 : 0 : handler->raw_unregister(dev);
260 : : }
261 : 0 : mutex_unlock(&ir_raw_handler_lock);
262 : :
263 : 0 : if (!dev->max_timeout)
264 : : return 0;
265 : :
266 : 0 : mutex_lock(&ir_raw_handler_lock);
267 : 0 : list_for_each_entry(handler, &ir_raw_handler_list, list) {
268 : 0 : if (handler->protocols & *rc_proto) {
269 : 0 : if (timeout < handler->min_timeout)
270 : : timeout = handler->min_timeout;
271 : : }
272 : : }
273 : 0 : mutex_unlock(&ir_raw_handler_lock);
274 : :
275 : 0 : if (timeout == 0)
276 : : timeout = IR_DEFAULT_TIMEOUT;
277 : : else
278 : 0 : timeout += MS_TO_NS(10);
279 : :
280 : 0 : if (timeout < dev->min_timeout)
281 : : timeout = dev->min_timeout;
282 : 0 : else if (timeout > dev->max_timeout)
283 : : timeout = dev->max_timeout;
284 : :
285 : 0 : if (dev->s_timeout)
286 : 0 : dev->s_timeout(dev, timeout);
287 : : else
288 : 0 : dev->timeout = timeout;
289 : :
290 : : return 0;
291 : : }
292 : :
293 : 0 : static void ir_raw_disable_protocols(struct rc_dev *dev, u64 protocols)
294 : : {
295 : 0 : mutex_lock(&dev->lock);
296 : 0 : dev->enabled_protocols &= ~protocols;
297 : 0 : mutex_unlock(&dev->lock);
298 : 0 : }
299 : :
300 : : /**
301 : : * ir_raw_gen_manchester() - Encode data with Manchester (bi-phase) modulation.
302 : : * @ev: Pointer to pointer to next free event. *@ev is incremented for
303 : : * each raw event filled.
304 : : * @max: Maximum number of raw events to fill.
305 : : * @timings: Manchester modulation timings.
306 : : * @n: Number of bits of data.
307 : : * @data: Data bits to encode.
308 : : *
309 : : * Encodes the @n least significant bits of @data using Manchester (bi-phase)
310 : : * modulation with the timing characteristics described by @timings, writing up
311 : : * to @max raw IR events using the *@ev pointer.
312 : : *
313 : : * Returns: 0 on success.
314 : : * -ENOBUFS if there isn't enough space in the array to fit the
315 : : * full encoded data. In this case all @max events will have been
316 : : * written.
317 : : */
318 : 0 : int ir_raw_gen_manchester(struct ir_raw_event **ev, unsigned int max,
319 : : const struct ir_raw_timings_manchester *timings,
320 : : unsigned int n, u64 data)
321 : : {
322 : : bool need_pulse;
323 : : u64 i;
324 : : int ret = -ENOBUFS;
325 : :
326 : 0 : i = BIT_ULL(n - 1);
327 : :
328 : 0 : if (timings->leader_pulse) {
329 : 0 : if (!max--)
330 : : return ret;
331 : 0 : init_ir_raw_event_duration((*ev), 1, timings->leader_pulse);
332 : 0 : if (timings->leader_space) {
333 : 0 : if (!max--)
334 : : return ret;
335 : 0 : init_ir_raw_event_duration(++(*ev), 0,
336 : : timings->leader_space);
337 : : }
338 : : } else {
339 : : /* continue existing signal */
340 : 0 : --(*ev);
341 : : }
342 : : /* from here on *ev will point to the last event rather than the next */
343 : :
344 : 0 : while (n && i > 0) {
345 : 0 : need_pulse = !(data & i);
346 : 0 : if (timings->invert)
347 : 0 : need_pulse = !need_pulse;
348 : 0 : if (need_pulse == !!(*ev)->pulse) {
349 : 0 : (*ev)->duration += timings->clock;
350 : : } else {
351 : 0 : if (!max--)
352 : : goto nobufs;
353 : 0 : init_ir_raw_event_duration(++(*ev), need_pulse,
354 : : timings->clock);
355 : : }
356 : :
357 : 0 : if (!max--)
358 : : goto nobufs;
359 : 0 : init_ir_raw_event_duration(++(*ev), !need_pulse,
360 : : timings->clock);
361 : 0 : i >>= 1;
362 : : }
363 : :
364 : 0 : if (timings->trailer_space) {
365 : 0 : if (!(*ev)->pulse)
366 : 0 : (*ev)->duration += timings->trailer_space;
367 : 0 : else if (!max--)
368 : : goto nobufs;
369 : : else
370 : 0 : init_ir_raw_event_duration(++(*ev), 0,
371 : : timings->trailer_space);
372 : : }
373 : :
374 : : ret = 0;
375 : : nobufs:
376 : : /* point to the next event rather than last event before returning */
377 : 0 : ++(*ev);
378 : 0 : return ret;
379 : : }
380 : : EXPORT_SYMBOL(ir_raw_gen_manchester);
381 : :
382 : : /**
383 : : * ir_raw_gen_pd() - Encode data to raw events with pulse-distance modulation.
384 : : * @ev: Pointer to pointer to next free event. *@ev is incremented for
385 : : * each raw event filled.
386 : : * @max: Maximum number of raw events to fill.
387 : : * @timings: Pulse distance modulation timings.
388 : : * @n: Number of bits of data.
389 : : * @data: Data bits to encode.
390 : : *
391 : : * Encodes the @n least significant bits of @data using pulse-distance
392 : : * modulation with the timing characteristics described by @timings, writing up
393 : : * to @max raw IR events using the *@ev pointer.
394 : : *
395 : : * Returns: 0 on success.
396 : : * -ENOBUFS if there isn't enough space in the array to fit the
397 : : * full encoded data. In this case all @max events will have been
398 : : * written.
399 : : */
400 : 0 : int ir_raw_gen_pd(struct ir_raw_event **ev, unsigned int max,
401 : : const struct ir_raw_timings_pd *timings,
402 : : unsigned int n, u64 data)
403 : : {
404 : : int i;
405 : : int ret;
406 : : unsigned int space;
407 : :
408 : 0 : if (timings->header_pulse) {
409 : 0 : ret = ir_raw_gen_pulse_space(ev, &max, timings->header_pulse,
410 : : timings->header_space);
411 : 0 : if (ret)
412 : : return ret;
413 : : }
414 : :
415 : 0 : if (timings->msb_first) {
416 : 0 : for (i = n - 1; i >= 0; --i) {
417 : 0 : space = timings->bit_space[(data >> i) & 1];
418 : 0 : ret = ir_raw_gen_pulse_space(ev, &max,
419 : : timings->bit_pulse,
420 : : space);
421 : 0 : if (ret)
422 : 0 : return ret;
423 : : }
424 : : } else {
425 : 0 : for (i = 0; i < n; ++i, data >>= 1) {
426 : 0 : space = timings->bit_space[data & 1];
427 : 0 : ret = ir_raw_gen_pulse_space(ev, &max,
428 : : timings->bit_pulse,
429 : : space);
430 : 0 : if (ret)
431 : 0 : return ret;
432 : : }
433 : : }
434 : :
435 : 0 : ret = ir_raw_gen_pulse_space(ev, &max, timings->trailer_pulse,
436 : : timings->trailer_space);
437 : 0 : return ret;
438 : : }
439 : : EXPORT_SYMBOL(ir_raw_gen_pd);
440 : :
441 : : /**
442 : : * ir_raw_gen_pl() - Encode data to raw events with pulse-length modulation.
443 : : * @ev: Pointer to pointer to next free event. *@ev is incremented for
444 : : * each raw event filled.
445 : : * @max: Maximum number of raw events to fill.
446 : : * @timings: Pulse distance modulation timings.
447 : : * @n: Number of bits of data.
448 : : * @data: Data bits to encode.
449 : : *
450 : : * Encodes the @n least significant bits of @data using space-distance
451 : : * modulation with the timing characteristics described by @timings, writing up
452 : : * to @max raw IR events using the *@ev pointer.
453 : : *
454 : : * Returns: 0 on success.
455 : : * -ENOBUFS if there isn't enough space in the array to fit the
456 : : * full encoded data. In this case all @max events will have been
457 : : * written.
458 : : */
459 : 0 : int ir_raw_gen_pl(struct ir_raw_event **ev, unsigned int max,
460 : : const struct ir_raw_timings_pl *timings,
461 : : unsigned int n, u64 data)
462 : : {
463 : : int i;
464 : : int ret = -ENOBUFS;
465 : : unsigned int pulse;
466 : :
467 : 0 : if (!max--)
468 : : return ret;
469 : :
470 : 0 : init_ir_raw_event_duration((*ev)++, 1, timings->header_pulse);
471 : :
472 : 0 : if (timings->msb_first) {
473 : 0 : for (i = n - 1; i >= 0; --i) {
474 : 0 : if (!max--)
475 : : return ret;
476 : 0 : init_ir_raw_event_duration((*ev)++, 0,
477 : : timings->bit_space);
478 : 0 : if (!max--)
479 : : return ret;
480 : 0 : pulse = timings->bit_pulse[(data >> i) & 1];
481 : 0 : init_ir_raw_event_duration((*ev)++, 1, pulse);
482 : : }
483 : : } else {
484 : 0 : for (i = 0; i < n; ++i, data >>= 1) {
485 : 0 : if (!max--)
486 : : return ret;
487 : 0 : init_ir_raw_event_duration((*ev)++, 0,
488 : : timings->bit_space);
489 : 0 : if (!max--)
490 : : return ret;
491 : 0 : pulse = timings->bit_pulse[data & 1];
492 : 0 : init_ir_raw_event_duration((*ev)++, 1, pulse);
493 : : }
494 : : }
495 : :
496 : 0 : if (!max--)
497 : : return ret;
498 : :
499 : 0 : init_ir_raw_event_duration((*ev)++, 0, timings->trailer_space);
500 : :
501 : 0 : return 0;
502 : : }
503 : : EXPORT_SYMBOL(ir_raw_gen_pl);
504 : :
505 : : /**
506 : : * ir_raw_encode_scancode() - Encode a scancode as raw events
507 : : *
508 : : * @protocol: protocol
509 : : * @scancode: scancode filter describing a single scancode
510 : : * @events: array of raw events to write into
511 : : * @max: max number of raw events
512 : : *
513 : : * Attempts to encode the scancode as raw events.
514 : : *
515 : : * Returns: The number of events written.
516 : : * -ENOBUFS if there isn't enough space in the array to fit the
517 : : * encoding. In this case all @max events will have been written.
518 : : * -EINVAL if the scancode is ambiguous or invalid, or if no
519 : : * compatible encoder was found.
520 : : */
521 : 0 : int ir_raw_encode_scancode(enum rc_proto protocol, u32 scancode,
522 : : struct ir_raw_event *events, unsigned int max)
523 : : {
524 : : struct ir_raw_handler *handler;
525 : : int ret = -EINVAL;
526 : 0 : u64 mask = 1ULL << protocol;
527 : :
528 : 0 : ir_raw_load_modules(&mask);
529 : :
530 : 0 : mutex_lock(&ir_raw_handler_lock);
531 : 0 : list_for_each_entry(handler, &ir_raw_handler_list, list) {
532 : 0 : if (handler->protocols & mask && handler->encode) {
533 : 0 : ret = handler->encode(protocol, scancode, events, max);
534 : 0 : if (ret >= 0 || ret == -ENOBUFS)
535 : : break;
536 : : }
537 : : }
538 : 0 : mutex_unlock(&ir_raw_handler_lock);
539 : :
540 : 0 : return ret;
541 : : }
542 : : EXPORT_SYMBOL(ir_raw_encode_scancode);
543 : :
544 : : /**
545 : : * ir_raw_edge_handle() - Handle ir_raw_event_store_edge() processing
546 : : *
547 : : * @t: timer_list
548 : : *
549 : : * This callback is armed by ir_raw_event_store_edge(). It does two things:
550 : : * first of all, rather than calling ir_raw_event_handle() for each
551 : : * edge and waking up the rc thread, 15 ms after the first edge
552 : : * ir_raw_event_handle() is called. Secondly, generate a timeout event
553 : : * no more IR is received after the rc_dev timeout.
554 : : */
555 : 0 : static void ir_raw_edge_handle(struct timer_list *t)
556 : : {
557 : : struct ir_raw_event_ctrl *raw = from_timer(raw, t, edge_handle);
558 : 0 : struct rc_dev *dev = raw->dev;
559 : : unsigned long flags;
560 : : ktime_t interval;
561 : :
562 : 0 : spin_lock_irqsave(&dev->raw->edge_spinlock, flags);
563 : 0 : interval = ktime_sub(ktime_get(), dev->raw->last_event);
564 : 0 : if (ktime_to_ns(interval) >= dev->timeout) {
565 : 0 : struct ir_raw_event ev = {
566 : : .timeout = true,
567 : : .duration = ktime_to_ns(interval)
568 : : };
569 : :
570 : 0 : ir_raw_event_store(dev, &ev);
571 : : } else {
572 : 0 : mod_timer(&dev->raw->edge_handle,
573 : 0 : jiffies + nsecs_to_jiffies(dev->timeout -
574 : : ktime_to_ns(interval)));
575 : : }
576 : 0 : spin_unlock_irqrestore(&dev->raw->edge_spinlock, flags);
577 : :
578 : 0 : ir_raw_event_handle(dev);
579 : 0 : }
580 : :
581 : : /**
582 : : * ir_raw_encode_carrier() - Get carrier used for protocol
583 : : *
584 : : * @protocol: protocol
585 : : *
586 : : * Attempts to find the carrier for the specified protocol
587 : : *
588 : : * Returns: The carrier in Hz
589 : : * -EINVAL if the protocol is invalid, or if no
590 : : * compatible encoder was found.
591 : : */
592 : 0 : int ir_raw_encode_carrier(enum rc_proto protocol)
593 : : {
594 : : struct ir_raw_handler *handler;
595 : : int ret = -EINVAL;
596 : 0 : u64 mask = BIT_ULL(protocol);
597 : :
598 : 0 : mutex_lock(&ir_raw_handler_lock);
599 : 0 : list_for_each_entry(handler, &ir_raw_handler_list, list) {
600 : 0 : if (handler->protocols & mask && handler->encode) {
601 : 0 : ret = handler->carrier;
602 : 0 : break;
603 : : }
604 : : }
605 : 0 : mutex_unlock(&ir_raw_handler_lock);
606 : :
607 : 0 : return ret;
608 : : }
609 : : EXPORT_SYMBOL(ir_raw_encode_carrier);
610 : :
611 : : /*
612 : : * Used to (un)register raw event clients
613 : : */
614 : 0 : int ir_raw_event_prepare(struct rc_dev *dev)
615 : : {
616 : 0 : if (!dev)
617 : : return -EINVAL;
618 : :
619 : 0 : dev->raw = kzalloc(sizeof(*dev->raw), GFP_KERNEL);
620 : 0 : if (!dev->raw)
621 : : return -ENOMEM;
622 : :
623 : 0 : dev->raw->dev = dev;
624 : 0 : dev->change_protocol = change_protocol;
625 : 0 : dev->idle = true;
626 : 0 : spin_lock_init(&dev->raw->edge_spinlock);
627 : 0 : timer_setup(&dev->raw->edge_handle, ir_raw_edge_handle, 0);
628 : 0 : INIT_KFIFO(dev->raw->kfifo);
629 : :
630 : 0 : return 0;
631 : : }
632 : :
633 : 0 : int ir_raw_event_register(struct rc_dev *dev)
634 : : {
635 : : struct task_struct *thread;
636 : :
637 : 0 : thread = kthread_run(ir_raw_event_thread, dev->raw, "rc%u", dev->minor);
638 : 0 : if (IS_ERR(thread))
639 : 0 : return PTR_ERR(thread);
640 : :
641 : 0 : dev->raw->thread = thread;
642 : :
643 : 0 : mutex_lock(&ir_raw_handler_lock);
644 : 0 : list_add_tail(&dev->raw->list, &ir_raw_client_list);
645 : 0 : mutex_unlock(&ir_raw_handler_lock);
646 : :
647 : 0 : return 0;
648 : : }
649 : :
650 : 0 : void ir_raw_event_free(struct rc_dev *dev)
651 : : {
652 : 0 : if (!dev)
653 : 0 : return;
654 : :
655 : 0 : kfree(dev->raw);
656 : 0 : dev->raw = NULL;
657 : : }
658 : :
659 : 0 : void ir_raw_event_unregister(struct rc_dev *dev)
660 : : {
661 : : struct ir_raw_handler *handler;
662 : :
663 : 0 : if (!dev || !dev->raw)
664 : 0 : return;
665 : :
666 : 0 : kthread_stop(dev->raw->thread);
667 : 0 : del_timer_sync(&dev->raw->edge_handle);
668 : :
669 : 0 : mutex_lock(&ir_raw_handler_lock);
670 : 0 : list_del(&dev->raw->list);
671 : 0 : list_for_each_entry(handler, &ir_raw_handler_list, list)
672 : 0 : if (handler->raw_unregister &&
673 : 0 : (handler->protocols & dev->enabled_protocols))
674 : 0 : handler->raw_unregister(dev);
675 : :
676 : 0 : lirc_bpf_free(dev);
677 : :
678 : : ir_raw_event_free(dev);
679 : :
680 : : /*
681 : : * A user can be calling bpf(BPF_PROG_{QUERY|ATTACH|DETACH}), so
682 : : * ensure that the raw member is null on unlock; this is how
683 : : * "device gone" is checked.
684 : : */
685 : 0 : mutex_unlock(&ir_raw_handler_lock);
686 : : }
687 : :
688 : : /*
689 : : * Extension interface - used to register the IR decoders
690 : : */
691 : :
692 : 0 : int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler)
693 : : {
694 : 0 : mutex_lock(&ir_raw_handler_lock);
695 : 0 : list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list);
696 : 0 : atomic64_or(ir_raw_handler->protocols, &available_protocols);
697 : 0 : mutex_unlock(&ir_raw_handler_lock);
698 : :
699 : 0 : return 0;
700 : : }
701 : : EXPORT_SYMBOL(ir_raw_handler_register);
702 : :
703 : 0 : void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler)
704 : : {
705 : : struct ir_raw_event_ctrl *raw;
706 : 0 : u64 protocols = ir_raw_handler->protocols;
707 : :
708 : 0 : mutex_lock(&ir_raw_handler_lock);
709 : : list_del(&ir_raw_handler->list);
710 : 0 : list_for_each_entry(raw, &ir_raw_client_list, list) {
711 : 0 : if (ir_raw_handler->raw_unregister &&
712 : 0 : (raw->dev->enabled_protocols & protocols))
713 : 0 : ir_raw_handler->raw_unregister(raw->dev);
714 : 0 : ir_raw_disable_protocols(raw->dev, protocols);
715 : : }
716 : 0 : atomic64_andnot(protocols, &available_protocols);
717 : 0 : mutex_unlock(&ir_raw_handler_lock);
718 : 0 : }
719 : : EXPORT_SYMBOL(ir_raw_handler_unregister);
|
