aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/IR/ir-raw-event.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/IR/ir-raw-event.c')
-rw-r--r--drivers/media/IR/ir-raw-event.c379
1 files changed, 0 insertions, 379 deletions
diff --git a/drivers/media/IR/ir-raw-event.c b/drivers/media/IR/ir-raw-event.c
deleted file mode 100644
index 8e0e1b1f8c87..000000000000
--- a/drivers/media/IR/ir-raw-event.c
+++ /dev/null
@@ -1,379 +0,0 @@
1/* ir-raw-event.c - handle IR Pulse/Space event
2 *
3 * Copyright (C) 2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
4 *
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.
8 *
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.
13 */
14
15#include <linux/kthread.h>
16#include <linux/mutex.h>
17#include <linux/sched.h>
18#include <linux/freezer.h>
19#include "ir-core-priv.h"
20
21/* Define the max number of pulse/space transitions to buffer */
22#define MAX_IR_EVENT_SIZE 512
23
24/* Used to keep track of IR raw clients, protected by ir_raw_handler_lock */
25static LIST_HEAD(ir_raw_client_list);
26
27/* Used to handle IR raw handler extensions */
28static DEFINE_MUTEX(ir_raw_handler_lock);
29static LIST_HEAD(ir_raw_handler_list);
30static u64 available_protocols;
31
32#ifdef MODULE
33/* Used to load the decoders */
34static struct work_struct wq_load;
35#endif
36
37static int ir_raw_event_thread(void *data)
38{
39 struct ir_raw_event ev;
40 struct ir_raw_handler *handler;
41 struct ir_raw_event_ctrl *raw = (struct ir_raw_event_ctrl *)data;
42
43 while (!kthread_should_stop()) {
44 try_to_freeze();
45
46 mutex_lock(&ir_raw_handler_lock);
47
48 while (kfifo_out(&raw->kfifo, &ev, sizeof(ev)) == sizeof(ev)) {
49 list_for_each_entry(handler, &ir_raw_handler_list, list)
50 handler->decode(raw->input_dev, ev);
51 raw->prev_ev = ev;
52 }
53
54 mutex_unlock(&ir_raw_handler_lock);
55
56 set_current_state(TASK_INTERRUPTIBLE);
57 schedule();
58 }
59
60 return 0;
61}
62
63/**
64 * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders
65 * @input_dev: the struct input_dev device descriptor
66 * @ev: the struct ir_raw_event descriptor of the pulse/space
67 *
68 * This routine (which may be called from an interrupt context) stores a
69 * pulse/space duration for the raw ir decoding state machines. Pulses are
70 * signalled as positive values and spaces as negative values. A zero value
71 * will reset the decoding state machines.
72 */
73int ir_raw_event_store(struct input_dev *input_dev, struct ir_raw_event *ev)
74{
75 struct ir_input_dev *ir = input_get_drvdata(input_dev);
76
77 if (!ir->raw)
78 return -EINVAL;
79
80 IR_dprintk(2, "sample: (05%dus %s)\n",
81 TO_US(ev->duration), TO_STR(ev->pulse));
82
83 if (kfifo_in(&ir->raw->kfifo, ev, sizeof(*ev)) != sizeof(*ev))
84 return -ENOMEM;
85
86 return 0;
87}
88EXPORT_SYMBOL_GPL(ir_raw_event_store);
89
90/**
91 * ir_raw_event_store_edge() - notify raw ir decoders of the start of a pulse/space
92 * @input_dev: the struct input_dev device descriptor
93 * @type: the type of the event that has occurred
94 *
95 * This routine (which may be called from an interrupt context) is used to
96 * store the beginning of an ir pulse or space (or the start/end of ir
97 * reception) for the raw ir decoding state machines. This is used by
98 * hardware which does not provide durations directly but only interrupts
99 * (or similar events) on state change.
100 */
101int ir_raw_event_store_edge(struct input_dev *input_dev, enum raw_event_type type)
102{
103 struct ir_input_dev *ir = input_get_drvdata(input_dev);
104 ktime_t now;
105 s64 delta; /* ns */
106 struct ir_raw_event ev;
107 int rc = 0;
108
109 if (!ir->raw)
110 return -EINVAL;
111
112 now = ktime_get();
113 delta = ktime_to_ns(ktime_sub(now, ir->raw->last_event));
114
115 /* Check for a long duration since last event or if we're
116 * being called for the first time, note that delta can't
117 * possibly be negative.
118 */
119 ev.duration = 0;
120 if (delta > IR_MAX_DURATION || !ir->raw->last_type)
121 type |= IR_START_EVENT;
122 else
123 ev.duration = delta;
124
125 if (type & IR_START_EVENT)
126 ir_raw_event_reset(input_dev);
127 else if (ir->raw->last_type & IR_SPACE) {
128 ev.pulse = false;
129 rc = ir_raw_event_store(input_dev, &ev);
130 } else if (ir->raw->last_type & IR_PULSE) {
131 ev.pulse = true;
132 rc = ir_raw_event_store(input_dev, &ev);
133 } else
134 return 0;
135
136 ir->raw->last_event = now;
137 ir->raw->last_type = type;
138 return rc;
139}
140EXPORT_SYMBOL_GPL(ir_raw_event_store_edge);
141
142/**
143 * ir_raw_event_store_with_filter() - pass next pulse/space to decoders with some processing
144 * @input_dev: the struct input_dev device descriptor
145 * @type: the type of the event that has occurred
146 *
147 * This routine (which may be called from an interrupt context) works
148 * in similiar manner to ir_raw_event_store_edge.
149 * This routine is intended for devices with limited internal buffer
150 * It automerges samples of same type, and handles timeouts
151 */
152int ir_raw_event_store_with_filter(struct input_dev *input_dev,
153 struct ir_raw_event *ev)
154{
155 struct ir_input_dev *ir = input_get_drvdata(input_dev);
156 struct ir_raw_event_ctrl *raw = ir->raw;
157
158 if (!raw || !ir->props)
159 return -EINVAL;
160
161 /* Ignore spaces in idle mode */
162 if (ir->idle && !ev->pulse)
163 return 0;
164 else if (ir->idle)
165 ir_raw_event_set_idle(input_dev, 0);
166
167 if (!raw->this_ev.duration) {
168 raw->this_ev = *ev;
169 } else if (ev->pulse == raw->this_ev.pulse) {
170 raw->this_ev.duration += ev->duration;
171 } else {
172 ir_raw_event_store(input_dev, &raw->this_ev);
173 raw->this_ev = *ev;
174 }
175
176 /* Enter idle mode if nessesary */
177 if (!ev->pulse && ir->props->timeout &&
178 raw->this_ev.duration >= ir->props->timeout)
179 ir_raw_event_set_idle(input_dev, 1);
180 return 0;
181}
182EXPORT_SYMBOL_GPL(ir_raw_event_store_with_filter);
183
184void ir_raw_event_set_idle(struct input_dev *input_dev, int idle)
185{
186 struct ir_input_dev *ir = input_get_drvdata(input_dev);
187 struct ir_raw_event_ctrl *raw = ir->raw;
188 ktime_t now;
189 u64 delta;
190
191 if (!ir->props)
192 return;
193
194 if (!ir->raw)
195 goto out;
196
197 if (idle) {
198 IR_dprintk(2, "enter idle mode\n");
199 raw->last_event = ktime_get();
200 } else {
201 IR_dprintk(2, "exit idle mode\n");
202
203 now = ktime_get();
204 delta = ktime_to_ns(ktime_sub(now, ir->raw->last_event));
205
206 WARN_ON(raw->this_ev.pulse);
207
208 raw->this_ev.duration =
209 min(raw->this_ev.duration + delta,
210 (u64)IR_MAX_DURATION);
211
212 ir_raw_event_store(input_dev, &raw->this_ev);
213
214 if (raw->this_ev.duration == IR_MAX_DURATION)
215 ir_raw_event_reset(input_dev);
216
217 raw->this_ev.duration = 0;
218 }
219out:
220 if (ir->props->s_idle)
221 ir->props->s_idle(ir->props->priv, idle);
222 ir->idle = idle;
223}
224EXPORT_SYMBOL_GPL(ir_raw_event_set_idle);
225
226/**
227 * ir_raw_event_handle() - schedules the decoding of stored ir data
228 * @input_dev: the struct input_dev device descriptor
229 *
230 * This routine will signal the workqueue to start decoding stored ir data.
231 */
232void ir_raw_event_handle(struct input_dev *input_dev)
233{
234 struct ir_input_dev *ir = input_get_drvdata(input_dev);
235
236 if (!ir->raw)
237 return;
238
239 wake_up_process(ir->raw->thread);
240}
241EXPORT_SYMBOL_GPL(ir_raw_event_handle);
242
243/* used internally by the sysfs interface */
244u64
245ir_raw_get_allowed_protocols()
246{
247 u64 protocols;
248 mutex_lock(&ir_raw_handler_lock);
249 protocols = available_protocols;
250 mutex_unlock(&ir_raw_handler_lock);
251 return protocols;
252}
253
254/*
255 * Used to (un)register raw event clients
256 */
257int ir_raw_event_register(struct input_dev *input_dev)
258{
259 struct ir_input_dev *ir = input_get_drvdata(input_dev);
260 int rc;
261 struct ir_raw_handler *handler;
262
263 ir->raw = kzalloc(sizeof(*ir->raw), GFP_KERNEL);
264 if (!ir->raw)
265 return -ENOMEM;
266
267 ir->raw->input_dev = input_dev;
268
269 ir->raw->enabled_protocols = ~0;
270 rc = kfifo_alloc(&ir->raw->kfifo, sizeof(s64) * MAX_IR_EVENT_SIZE,
271 GFP_KERNEL);
272 if (rc < 0) {
273 kfree(ir->raw);
274 ir->raw = NULL;
275 return rc;
276 }
277
278 ir->raw->thread = kthread_run(ir_raw_event_thread, ir->raw,
279 "rc%u", (unsigned int)ir->devno);
280
281 if (IS_ERR(ir->raw->thread)) {
282 int ret = PTR_ERR(ir->raw->thread);
283
284 kfree(ir->raw);
285 ir->raw = NULL;
286 return ret;
287 }
288
289 mutex_lock(&ir_raw_handler_lock);
290 list_add_tail(&ir->raw->list, &ir_raw_client_list);
291 list_for_each_entry(handler, &ir_raw_handler_list, list)
292 if (handler->raw_register)
293 handler->raw_register(ir->raw->input_dev);
294 mutex_unlock(&ir_raw_handler_lock);
295
296 return 0;
297}
298
299void ir_raw_event_unregister(struct input_dev *input_dev)
300{
301 struct ir_input_dev *ir = input_get_drvdata(input_dev);
302 struct ir_raw_handler *handler;
303
304 if (!ir->raw)
305 return;
306
307 kthread_stop(ir->raw->thread);
308
309 mutex_lock(&ir_raw_handler_lock);
310 list_del(&ir->raw->list);
311 list_for_each_entry(handler, &ir_raw_handler_list, list)
312 if (handler->raw_unregister)
313 handler->raw_unregister(ir->raw->input_dev);
314 mutex_unlock(&ir_raw_handler_lock);
315
316 kfifo_free(&ir->raw->kfifo);
317 kfree(ir->raw);
318 ir->raw = NULL;
319}
320
321/*
322 * Extension interface - used to register the IR decoders
323 */
324
325int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler)
326{
327 struct ir_raw_event_ctrl *raw;
328
329 mutex_lock(&ir_raw_handler_lock);
330 list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list);
331 if (ir_raw_handler->raw_register)
332 list_for_each_entry(raw, &ir_raw_client_list, list)
333 ir_raw_handler->raw_register(raw->input_dev);
334 available_protocols |= ir_raw_handler->protocols;
335 mutex_unlock(&ir_raw_handler_lock);
336
337 return 0;
338}
339EXPORT_SYMBOL(ir_raw_handler_register);
340
341void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler)
342{
343 struct ir_raw_event_ctrl *raw;
344
345 mutex_lock(&ir_raw_handler_lock);
346 list_del(&ir_raw_handler->list);
347 if (ir_raw_handler->raw_unregister)
348 list_for_each_entry(raw, &ir_raw_client_list, list)
349 ir_raw_handler->raw_unregister(raw->input_dev);
350 available_protocols &= ~ir_raw_handler->protocols;
351 mutex_unlock(&ir_raw_handler_lock);
352}
353EXPORT_SYMBOL(ir_raw_handler_unregister);
354
355#ifdef MODULE
356static void init_decoders(struct work_struct *work)
357{
358 /* Load the decoder modules */
359
360 load_nec_decode();
361 load_rc5_decode();
362 load_rc6_decode();
363 load_jvc_decode();
364 load_sony_decode();
365 load_lirc_codec();
366
367 /* If needed, we may later add some init code. In this case,
368 it is needed to change the CONFIG_MODULE test at ir-core.h
369 */
370}
371#endif
372
373void ir_raw_init(void)
374{
375#ifdef MODULE
376 INIT_WORK(&wq_load, init_decoders);
377 schedule_work(&wq_load);
378#endif
379}
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-20 15:58:40 -0400