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
	int			delay;
118

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

122
	now = ktime_get();
123
	delta = ktime_to_ns(ktime_sub(now, dev->raw->last_event));
124
	delay = MS_TO_NS(dev->input_dev->rep[REP_DELAY]);
125

126 127 128 129
	/* 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.
	 */
130
	if (delta > delay || !dev->raw->last_type)
131
		type |= IR_START_EVENT;
132 133
	else
		ev.duration = delta;
134 135

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

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

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

	/* Ignore spaces in idle mode */
168
	if (dev->idle && !ev->pulse)
169
		return 0;
170 171 172 173 174 175 176 177 178 179
	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;
180 181 182
	}

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

187 188 189 190
	return 0;
}
EXPORT_SYMBOL_GPL(ir_raw_event_store_with_filter);

191
/**
192 193 194
 * 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
195
 */
196
void ir_raw_event_set_idle(struct rc_dev *dev, bool idle)
197
{
198
	if (!dev->raw)
199 200
		return;

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

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

209 210 211 212
	if (dev->s_idle)
		dev->s_idle(dev, idle);

	dev->idle = idle;
213 214 215
}
EXPORT_SYMBOL_GPL(ir_raw_event_set_idle);

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

226
	if (!dev->raw)
227
		return;
228

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

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

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

254 255
	if (!dev)
		return -EINVAL;
256

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

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

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

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

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

285
	return 0;
286 287 288 289 290

out:
	kfree(dev->raw);
	dev->raw = NULL;
	return rc;
291 292
}

293
void ir_raw_event_unregister(struct rc_dev *dev)
294
{
295
	struct ir_raw_handler *handler;
296

297
	if (!dev || !dev->raw)
298 299
		return;

300
	kthread_stop(dev->raw->thread);
301

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

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

314 315 316 317 318 319
/*
 * Extension interface - used to register the IR decoders
 */

int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler)
{
320 321
	struct ir_raw_event_ctrl *raw;

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

330 331 332 333 334 335
	return 0;
}
EXPORT_SYMBOL(ir_raw_handler_register);

void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler)
{
336 337
	struct ir_raw_event_ctrl *raw;

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

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

	load_nec_decode();
354
	load_rc5_decode();
355
	load_rc6_decode();
356
	load_jvc_decode();
357
	load_sony_decode();
358
	load_mce_kbd_decode();
359
	load_lirc_codec();
360 361

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

void ir_raw_init(void)
{
369
#ifdef MODULE
370 371
	INIT_WORK(&wq_load, init_decoders);
	schedule_work(&wq_load);
372 373
#endif
}