ir-raw.c 9.3 KB
Newer Older
1
/* ir-raw.c - handle IR pulse/space events
2 3 4 5 6 7 8 9 10 11 12 13 14
 *
 * Copyright (C) 2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 */

15
#include <linux/kthread.h>
16
#include <linux/mutex.h>
17
#include <linux/sched.h>
18
#include <linux/freezer.h>
19
#include "rc-core-priv.h"
20

21 22
/* Define the max number of pulse/space transitions to buffer */
#define MAX_IR_EVENT_SIZE      512
23

24 25 26
/* Used to keep track of IR raw clients, protected by ir_raw_handler_lock */
static LIST_HEAD(ir_raw_client_list);

27
/* Used to handle IR raw handler extensions */
28
static DEFINE_MUTEX(ir_raw_handler_lock);
29 30
static LIST_HEAD(ir_raw_handler_list);
static u64 available_protocols;
31

32
#ifdef MODULE
33 34
/* Used to load the decoders */
static struct work_struct wq_load;
35
#endif
36

37
static 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
	int retval;
43 44

	while (!kthread_should_stop()) {
45

46 47 48 49 50
		spin_lock_irq(&raw->lock);
		retval = kfifo_out(&raw->kfifo, &ev, sizeof(ev));

		if (!retval) {
			set_current_state(TASK_INTERRUPTIBLE);
51

52 53 54 55 56 57
			if (kthread_should_stop())
				set_current_state(TASK_RUNNING);

			spin_unlock_irq(&raw->lock);
			schedule();
			continue;
58 59
		}

60
		spin_unlock_irq(&raw->lock);
61

62 63 64 65 66

		BUG_ON(retval != sizeof(ev));

		mutex_lock(&ir_raw_handler_lock);
		list_for_each_entry(handler, &ir_raw_handler_list, list)
67
			handler->decode(raw->dev, ev);
68 69
		raw->prev_ev = ev;
		mutex_unlock(&ir_raw_handler_lock);
70
	}
71 72

	return 0;
73 74 75 76
}

/**
 * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders
77
 * @dev:	the struct rc_dev device descriptor
78
 * @ev:		the struct ir_raw_event descriptor of the pulse/space
79 80 81 82 83 84
 *
 * This routine (which may be called from an interrupt context) stores a
 * pulse/space duration for the raw ir decoding state machines. Pulses are
 * signalled as positive values and spaces as negative values. A zero value
 * will reset the decoding state machines.
 */
85
int ir_raw_event_store(struct rc_dev *dev, struct ir_raw_event *ev)
86
{
87
	if (!dev->raw)
88 89
		return -EINVAL;

90
	IR_dprintk(2, "sample: (%05dus %s)\n",
91
		   TO_US(ev->duration), TO_STR(ev->pulse));
M
Maxim Levitsky 已提交
92

93
	if (kfifo_in(&dev->raw->kfifo, ev, sizeof(*ev)) != sizeof(*ev))
94
		return -ENOMEM;
95

96 97 98
	return 0;
}
EXPORT_SYMBOL_GPL(ir_raw_event_store);
99

100 101
/**
 * ir_raw_event_store_edge() - notify raw ir decoders of the start of a pulse/space
102
 * @dev:	the struct rc_dev device descriptor
103 104 105 106 107 108 109 110
 * @type:	the type of the event that has occurred
 *
 * This routine (which may be called from an interrupt context) is used to
 * store the beginning of an ir pulse or space (or the start/end of ir
 * reception) for the raw ir decoding state machines. This is used by
 * hardware which does not provide durations directly but only interrupts
 * (or similar events) on state change.
 */
111
int ir_raw_event_store_edge(struct rc_dev *dev, enum raw_event_type type)
112 113 114
{
	ktime_t			now;
	s64			delta; /* ns */
115
	DEFINE_IR_RAW_EVENT(ev);
116
	int			rc = 0;
117

118
	if (!dev->raw)
119
		return -EINVAL;
120

121
	now = ktime_get();
122
	delta = ktime_to_ns(ktime_sub(now, dev->raw->last_event));
123

124 125 126 127
	/* Check for a long duration since last event or if we're
	 * being called for the first time, note that delta can't
	 * possibly be negative.
	 */
128
	if (delta > IR_MAX_DURATION || !dev->raw->last_type)
129
		type |= IR_START_EVENT;
130 131
	else
		ev.duration = delta;
132 133

	if (type & IR_START_EVENT)
134 135
		ir_raw_event_reset(dev);
	else if (dev->raw->last_type & IR_SPACE) {
136
		ev.pulse = false;
137 138
		rc = ir_raw_event_store(dev, &ev);
	} else if (dev->raw->last_type & IR_PULSE) {
139
		ev.pulse = true;
140
		rc = ir_raw_event_store(dev, &ev);
141
	} else
142
		return 0;
143

144 145
	dev->raw->last_event = now;
	dev->raw->last_type = type;
146 147
	return rc;
}
148
EXPORT_SYMBOL_GPL(ir_raw_event_store_edge);
149

150 151
/**
 * ir_raw_event_store_with_filter() - pass next pulse/space to decoders with some processing
152
 * @dev:	the struct rc_dev device descriptor
153 154 155 156 157 158 159
 * @type:	the type of the event that has occurred
 *
 * This routine (which may be called from an interrupt context) works
 * in similiar manner to ir_raw_event_store_edge.
 * This routine is intended for devices with limited internal buffer
 * It automerges samples of same type, and handles timeouts
 */
160
int ir_raw_event_store_with_filter(struct rc_dev *dev, struct ir_raw_event *ev)
161
{
162
	if (!dev->raw)
163 164 165
		return -EINVAL;

	/* Ignore spaces in idle mode */
166
	if (dev->idle && !ev->pulse)
167
		return 0;
168 169 170 171 172 173 174 175 176 177
	else if (dev->idle)
		ir_raw_event_set_idle(dev, false);

	if (!dev->raw->this_ev.duration)
		dev->raw->this_ev = *ev;
	else if (ev->pulse == dev->raw->this_ev.pulse)
		dev->raw->this_ev.duration += ev->duration;
	else {
		ir_raw_event_store(dev, &dev->raw->this_ev);
		dev->raw->this_ev = *ev;
178 179 180
	}

	/* Enter idle mode if nessesary */
181 182 183 184
	if (!ev->pulse && dev->timeout &&
	    dev->raw->this_ev.duration >= dev->timeout)
		ir_raw_event_set_idle(dev, true);

185 186 187 188
	return 0;
}
EXPORT_SYMBOL_GPL(ir_raw_event_store_with_filter);

189
/**
190 191 192
 * ir_raw_event_set_idle() - provide hint to rc-core when the device is idle or not
 * @dev:	the struct rc_dev device descriptor
 * @idle:	whether the device is idle or not
193
 */
194
void ir_raw_event_set_idle(struct rc_dev *dev, bool idle)
195
{
196
	if (!dev->raw)
197 198
		return;

199
	IR_dprintk(2, "%s idle mode\n", idle ? "enter" : "leave");
200 201

	if (idle) {
202 203 204
		dev->raw->this_ev.timeout = true;
		ir_raw_event_store(dev, &dev->raw->this_ev);
		init_ir_raw_event(&dev->raw->this_ev);
205
	}
206

207 208 209 210
	if (dev->s_idle)
		dev->s_idle(dev, idle);

	dev->idle = idle;
211 212 213
}
EXPORT_SYMBOL_GPL(ir_raw_event_set_idle);

214 215
/**
 * ir_raw_event_handle() - schedules the decoding of stored ir data
216
 * @dev:	the struct rc_dev device descriptor
217
 *
218
 * This routine will tell rc-core to start decoding stored ir data.
219
 */
220
void ir_raw_event_handle(struct rc_dev *dev)
221
{
222
	unsigned long flags;
223

224
	if (!dev->raw)
225
		return;
226

227 228 229
	spin_lock_irqsave(&dev->raw->lock, flags);
	wake_up_process(dev->raw->thread);
	spin_unlock_irqrestore(&dev->raw->lock, flags);
230 231
}
EXPORT_SYMBOL_GPL(ir_raw_event_handle);
232

233 234
/* used internally by the sysfs interface */
u64
235
ir_raw_get_allowed_protocols(void)
236 237
{
	u64 protocols;
238
	mutex_lock(&ir_raw_handler_lock);
239
	protocols = available_protocols;
240
	mutex_unlock(&ir_raw_handler_lock);
241 242 243 244 245 246
	return protocols;
}

/*
 * Used to (un)register raw event clients
 */
247
int ir_raw_event_register(struct rc_dev *dev)
248 249
{
	int rc;
250
	struct ir_raw_handler *handler;
251

252 253
	if (!dev)
		return -EINVAL;
254

255 256 257
	dev->raw = kzalloc(sizeof(*dev->raw), GFP_KERNEL);
	if (!dev->raw)
		return -ENOMEM;
258

259 260 261 262
	dev->raw->dev = dev;
	dev->raw->enabled_protocols = ~0;
	rc = kfifo_alloc(&dev->raw->kfifo,
			 sizeof(struct ir_raw_event) * MAX_IR_EVENT_SIZE,
263
			 GFP_KERNEL);
264 265
	if (rc < 0)
		goto out;
266

267 268 269
	spin_lock_init(&dev->raw->lock);
	dev->raw->thread = kthread_run(ir_raw_event_thread, dev->raw,
				       "rc%ld", dev->devno);
270

271 272 273
	if (IS_ERR(dev->raw->thread)) {
		rc = PTR_ERR(dev->raw->thread);
		goto out;
274 275
	}

276
	mutex_lock(&ir_raw_handler_lock);
277
	list_add_tail(&dev->raw->list, &ir_raw_client_list);
278 279
	list_for_each_entry(handler, &ir_raw_handler_list, list)
		if (handler->raw_register)
280
			handler->raw_register(dev);
281
	mutex_unlock(&ir_raw_handler_lock);
282

283
	return 0;
284 285 286 287 288

out:
	kfree(dev->raw);
	dev->raw = NULL;
	return rc;
289 290
}

291
void ir_raw_event_unregister(struct rc_dev *dev)
292
{
293
	struct ir_raw_handler *handler;
294

295
	if (!dev || !dev->raw)
296 297
		return;

298
	kthread_stop(dev->raw->thread);
299

300
	mutex_lock(&ir_raw_handler_lock);
301
	list_del(&dev->raw->list);
302 303
	list_for_each_entry(handler, &ir_raw_handler_list, list)
		if (handler->raw_unregister)
304
			handler->raw_unregister(dev);
305
	mutex_unlock(&ir_raw_handler_lock);
306

307 308 309
	kfifo_free(&dev->raw->kfifo);
	kfree(dev->raw);
	dev->raw = NULL;
310 311
}

312 313 314 315 316 317
/*
 * Extension interface - used to register the IR decoders
 */

int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler)
{
318 319
	struct ir_raw_event_ctrl *raw;

320
	mutex_lock(&ir_raw_handler_lock);
321
	list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list);
322 323
	if (ir_raw_handler->raw_register)
		list_for_each_entry(raw, &ir_raw_client_list, list)
324
			ir_raw_handler->raw_register(raw->dev);
325
	available_protocols |= ir_raw_handler->protocols;
326
	mutex_unlock(&ir_raw_handler_lock);
327

328 329 330 331 332 333
	return 0;
}
EXPORT_SYMBOL(ir_raw_handler_register);

void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler)
{
334 335
	struct ir_raw_event_ctrl *raw;

336
	mutex_lock(&ir_raw_handler_lock);
337
	list_del(&ir_raw_handler->list);
338 339
	if (ir_raw_handler->raw_unregister)
		list_for_each_entry(raw, &ir_raw_client_list, list)
340
			ir_raw_handler->raw_unregister(raw->dev);
341
	available_protocols &= ~ir_raw_handler->protocols;
342
	mutex_unlock(&ir_raw_handler_lock);
343 344 345
}
EXPORT_SYMBOL(ir_raw_handler_unregister);

346
#ifdef MODULE
347 348 349 350 351
static void init_decoders(struct work_struct *work)
{
	/* Load the decoder modules */

	load_nec_decode();
352
	load_rc5_decode();
353
	load_rc6_decode();
354
	load_jvc_decode();
355
	load_sony_decode();
356
	load_lirc_codec();
357 358

	/* If needed, we may later add some init code. In this case,
359
	   it is needed to change the CONFIG_MODULE test at rc-core.h
360 361
	 */
}
362
#endif
363 364 365

void ir_raw_init(void)
{
366
#ifdef MODULE
367 368
	INIT_WORK(&wq_load, init_decoders);
	schedule_work(&wq_load);
369 370
#endif
}