1 /* rc-ir-raw.c - handle IR pulse/space events
3 * Copyright (C) 2010 by Mauro Carvalho Chehab
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation version 2 of the License.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
15 #include <linux/export.h>
16 #include <linux/kthread.h>
17 #include <linux/mutex.h>
18 #include <linux/kmod.h>
19 #include <linux/sched.h>
20 #include <linux/freezer.h>
21 #include "rc-core-priv.h"
23 /* Define the max number of pulse/space transitions to buffer */
24 #define MAX_IR_EVENT_SIZE 512
26 /* Used to keep track of IR raw clients, protected by ir_raw_handler_lock */
27 static LIST_HEAD(ir_raw_client_list
);
29 /* Used to handle IR raw handler extensions */
30 static DEFINE_MUTEX(ir_raw_handler_lock
);
31 static LIST_HEAD(ir_raw_handler_list
);
32 static u64 available_protocols
;
34 static int ir_raw_event_thread(void *data
)
36 struct ir_raw_event ev
;
37 struct ir_raw_handler
*handler
;
38 struct ir_raw_event_ctrl
*raw
= (struct ir_raw_event_ctrl
*)data
;
41 while (!kthread_should_stop()) {
43 spin_lock_irq(&raw
->lock
);
44 retval
= kfifo_len(&raw
->kfifo
);
46 if (retval
< sizeof(ev
)) {
47 set_current_state(TASK_INTERRUPTIBLE
);
49 if (kthread_should_stop())
50 set_current_state(TASK_RUNNING
);
52 spin_unlock_irq(&raw
->lock
);
57 retval
= kfifo_out(&raw
->kfifo
, &ev
, sizeof(ev
));
58 spin_unlock_irq(&raw
->lock
);
60 mutex_lock(&ir_raw_handler_lock
);
61 list_for_each_entry(handler
, &ir_raw_handler_list
, list
)
62 if (raw
->dev
->enabled_protocols
& handler
->protocols
||
64 handler
->decode(raw
->dev
, ev
);
66 mutex_unlock(&ir_raw_handler_lock
);
73 * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders
74 * @dev: the struct rc_dev device descriptor
75 * @ev: the struct ir_raw_event descriptor of the pulse/space
77 * This routine (which may be called from an interrupt context) stores a
78 * pulse/space duration for the raw ir decoding state machines. Pulses are
79 * signalled as positive values and spaces as negative values. A zero value
80 * will reset the decoding state machines.
82 int ir_raw_event_store(struct rc_dev
*dev
, struct ir_raw_event
*ev
)
87 IR_dprintk(2, "sample: (%05dus %s)\n",
88 TO_US(ev
->duration
), TO_STR(ev
->pulse
));
90 if (kfifo_in(&dev
->raw
->kfifo
, ev
, sizeof(*ev
)) != sizeof(*ev
))
95 EXPORT_SYMBOL_GPL(ir_raw_event_store
);
98 * ir_raw_event_store_edge() - notify raw ir decoders of the start of a pulse/space
99 * @dev: the struct rc_dev device descriptor
100 * @type: the type of the event that has occurred
102 * This routine (which may be called from an interrupt context) is used to
103 * store the beginning of an ir pulse or space (or the start/end of ir
104 * reception) for the raw ir decoding state machines. This is used by
105 * hardware which does not provide durations directly but only interrupts
106 * (or similar events) on state change.
108 int ir_raw_event_store_edge(struct rc_dev
*dev
, enum raw_event_type type
)
112 DEFINE_IR_RAW_EVENT(ev
);
120 delta
= ktime_to_ns(ktime_sub(now
, dev
->raw
->last_event
));
121 delay
= MS_TO_NS(dev
->input_dev
->rep
[REP_DELAY
]);
123 /* Check for a long duration since last event or if we're
124 * being called for the first time, note that delta can't
125 * possibly be negative.
127 if (delta
> delay
|| !dev
->raw
->last_type
)
128 type
|= IR_START_EVENT
;
132 if (type
& IR_START_EVENT
)
133 ir_raw_event_reset(dev
);
134 else if (dev
->raw
->last_type
& IR_SPACE
) {
136 rc
= ir_raw_event_store(dev
, &ev
);
137 } else if (dev
->raw
->last_type
& IR_PULSE
) {
139 rc
= ir_raw_event_store(dev
, &ev
);
143 dev
->raw
->last_event
= now
;
144 dev
->raw
->last_type
= type
;
147 EXPORT_SYMBOL_GPL(ir_raw_event_store_edge
);
150 * ir_raw_event_store_with_filter() - pass next pulse/space to decoders with some processing
151 * @dev: the struct rc_dev device descriptor
152 * @type: the type of the event that has occurred
154 * This routine (which may be called from an interrupt context) works
155 * in similar manner to ir_raw_event_store_edge.
156 * This routine is intended for devices with limited internal buffer
157 * It automerges samples of same type, and handles timeouts. Returns non-zero
158 * if the event was added, and zero if the event was ignored due to idle
161 int ir_raw_event_store_with_filter(struct rc_dev
*dev
, struct ir_raw_event
*ev
)
166 /* Ignore spaces in idle mode */
167 if (dev
->idle
&& !ev
->pulse
)
170 ir_raw_event_set_idle(dev
, false);
172 if (!dev
->raw
->this_ev
.duration
)
173 dev
->raw
->this_ev
= *ev
;
174 else if (ev
->pulse
== dev
->raw
->this_ev
.pulse
)
175 dev
->raw
->this_ev
.duration
+= ev
->duration
;
177 ir_raw_event_store(dev
, &dev
->raw
->this_ev
);
178 dev
->raw
->this_ev
= *ev
;
181 /* Enter idle mode if nessesary */
182 if (!ev
->pulse
&& dev
->timeout
&&
183 dev
->raw
->this_ev
.duration
>= dev
->timeout
)
184 ir_raw_event_set_idle(dev
, true);
188 EXPORT_SYMBOL_GPL(ir_raw_event_store_with_filter
);
191 * ir_raw_event_set_idle() - provide hint to rc-core when the device is idle or not
192 * @dev: the struct rc_dev device descriptor
193 * @idle: whether the device is idle or not
195 void ir_raw_event_set_idle(struct rc_dev
*dev
, bool idle
)
200 IR_dprintk(2, "%s idle mode\n", idle
? "enter" : "leave");
203 dev
->raw
->this_ev
.timeout
= true;
204 ir_raw_event_store(dev
, &dev
->raw
->this_ev
);
205 init_ir_raw_event(&dev
->raw
->this_ev
);
209 dev
->s_idle(dev
, idle
);
213 EXPORT_SYMBOL_GPL(ir_raw_event_set_idle
);
216 * ir_raw_event_handle() - schedules the decoding of stored ir data
217 * @dev: the struct rc_dev device descriptor
219 * This routine will tell rc-core to start decoding stored ir data.
221 void ir_raw_event_handle(struct rc_dev
*dev
)
228 spin_lock_irqsave(&dev
->raw
->lock
, flags
);
229 wake_up_process(dev
->raw
->thread
);
230 spin_unlock_irqrestore(&dev
->raw
->lock
, flags
);
232 EXPORT_SYMBOL_GPL(ir_raw_event_handle
);
234 /* used internally by the sysfs interface */
236 ir_raw_get_allowed_protocols(void)
239 mutex_lock(&ir_raw_handler_lock
);
240 protocols
= available_protocols
;
241 mutex_unlock(&ir_raw_handler_lock
);
245 static int change_protocol(struct rc_dev
*dev
, u64
*rc_type
)
247 /* the caller will update dev->enabled_protocols */
251 static void ir_raw_disable_protocols(struct rc_dev
*dev
, u64 protocols
)
253 mutex_lock(&dev
->lock
);
254 dev
->enabled_protocols
&= ~protocols
;
255 dev
->enabled_wakeup_protocols
&= ~protocols
;
256 mutex_unlock(&dev
->lock
);
260 * Used to (un)register raw event clients
262 int ir_raw_event_register(struct rc_dev
*dev
)
265 struct ir_raw_handler
*handler
;
270 dev
->raw
= kzalloc(sizeof(*dev
->raw
), GFP_KERNEL
);
275 dev
->change_protocol
= change_protocol
;
276 rc
= kfifo_alloc(&dev
->raw
->kfifo
,
277 sizeof(struct ir_raw_event
) * MAX_IR_EVENT_SIZE
,
282 spin_lock_init(&dev
->raw
->lock
);
283 dev
->raw
->thread
= kthread_run(ir_raw_event_thread
, dev
->raw
,
286 if (IS_ERR(dev
->raw
->thread
)) {
287 rc
= PTR_ERR(dev
->raw
->thread
);
291 mutex_lock(&ir_raw_handler_lock
);
292 list_add_tail(&dev
->raw
->list
, &ir_raw_client_list
);
293 list_for_each_entry(handler
, &ir_raw_handler_list
, list
)
294 if (handler
->raw_register
)
295 handler
->raw_register(dev
);
296 mutex_unlock(&ir_raw_handler_lock
);
306 void ir_raw_event_unregister(struct rc_dev
*dev
)
308 struct ir_raw_handler
*handler
;
310 if (!dev
|| !dev
->raw
)
313 kthread_stop(dev
->raw
->thread
);
315 mutex_lock(&ir_raw_handler_lock
);
316 list_del(&dev
->raw
->list
);
317 list_for_each_entry(handler
, &ir_raw_handler_list
, list
)
318 if (handler
->raw_unregister
)
319 handler
->raw_unregister(dev
);
320 mutex_unlock(&ir_raw_handler_lock
);
322 kfifo_free(&dev
->raw
->kfifo
);
328 * Extension interface - used to register the IR decoders
331 int ir_raw_handler_register(struct ir_raw_handler
*ir_raw_handler
)
333 struct ir_raw_event_ctrl
*raw
;
335 mutex_lock(&ir_raw_handler_lock
);
336 list_add_tail(&ir_raw_handler
->list
, &ir_raw_handler_list
);
337 if (ir_raw_handler
->raw_register
)
338 list_for_each_entry(raw
, &ir_raw_client_list
, list
)
339 ir_raw_handler
->raw_register(raw
->dev
);
340 available_protocols
|= ir_raw_handler
->protocols
;
341 mutex_unlock(&ir_raw_handler_lock
);
345 EXPORT_SYMBOL(ir_raw_handler_register
);
347 void ir_raw_handler_unregister(struct ir_raw_handler
*ir_raw_handler
)
349 struct ir_raw_event_ctrl
*raw
;
350 u64 protocols
= ir_raw_handler
->protocols
;
352 mutex_lock(&ir_raw_handler_lock
);
353 list_del(&ir_raw_handler
->list
);
354 list_for_each_entry(raw
, &ir_raw_client_list
, list
) {
355 ir_raw_disable_protocols(raw
->dev
, protocols
);
356 if (ir_raw_handler
->raw_unregister
)
357 ir_raw_handler
->raw_unregister(raw
->dev
);
359 available_protocols
&= ~protocols
;
360 mutex_unlock(&ir_raw_handler_lock
);
362 EXPORT_SYMBOL(ir_raw_handler_unregister
);