[net-next-2.6.git] / drivers / media / IR / ir-raw-event.c

/* ir-raw-event.c - handle IR Pulse/Space event
 *
 * 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.
 */

#include <linux/kthread.h>
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/freezer.h>
#include "ir-core-priv.h"

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

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

/* Used to handle IR raw handler extensions */
static DEFINE_MUTEX(ir_raw_handler_lock);
static LIST_HEAD(ir_raw_handler_list);
static u64 available_protocols;

#ifdef MODULE
/* Used to load the decoders */
static struct work_struct wq_load;
#endif

static int ir_raw_event_thread(void *data)
{
	struct ir_raw_event ev;
	struct ir_raw_handler *handler;
	struct ir_raw_event_ctrl *raw = (struct ir_raw_event_ctrl *)data;

	while (!kthread_should_stop()) {
		try_to_freeze();

		mutex_lock(&ir_raw_handler_lock);

		while (kfifo_out(&raw->kfifo, &ev, sizeof(ev)) == sizeof(ev)) {
			list_for_each_entry(handler, &ir_raw_handler_list, list)
				handler->decode(raw->input_dev, ev);
			raw->prev_ev = ev;
		}

		mutex_unlock(&ir_raw_handler_lock);

		set_current_state(TASK_INTERRUPTIBLE);
		schedule();
	}

	return 0;
}

/**
 * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders
 * @input_dev:	the struct input_dev device descriptor
 * @ev:		the struct ir_raw_event descriptor of the pulse/space
 *
 * 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.
 */
int ir_raw_event_store(struct input_dev *input_dev, struct ir_raw_event *ev)
{
	struct ir_input_dev *ir = input_get_drvdata(input_dev);

	if (!ir->raw)
		return -EINVAL;

	IR_dprintk(2, "sample: (05%dus %s)\n",
		TO_US(ev->duration), TO_STR(ev->pulse));

	if (kfifo_in(&ir->raw->kfifo, ev, sizeof(*ev)) != sizeof(*ev))
		return -ENOMEM;

	return 0;
}
EXPORT_SYMBOL_GPL(ir_raw_event_store);

/**
 * ir_raw_event_store_edge() - notify raw ir decoders of the start of a pulse/space
 * @input_dev:	the struct input_dev device descriptor
 * @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.
 */
int ir_raw_event_store_edge(struct input_dev *input_dev, enum raw_event_type type)
{
	struct ir_input_dev	*ir = input_get_drvdata(input_dev);
	ktime_t			now;
	s64			delta; /* ns */
	struct ir_raw_event	ev;
	int			rc = 0;

	if (!ir->raw)
		return -EINVAL;

	now = ktime_get();
	delta = ktime_to_ns(ktime_sub(now, ir->raw->last_event));

	/* 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.
	 */
	ev.duration = 0;
	if (delta > IR_MAX_DURATION || !ir->raw->last_type)
		type |= IR_START_EVENT;
	else
		ev.duration = delta;

	if (type & IR_START_EVENT)
		ir_raw_event_reset(input_dev);
	else if (ir->raw->last_type & IR_SPACE) {
		ev.pulse = false;
		rc = ir_raw_event_store(input_dev, &ev);
	} else if (ir->raw->last_type & IR_PULSE) {
		ev.pulse = true;
		rc = ir_raw_event_store(input_dev, &ev);
	} else
		return 0;

	ir->raw->last_event = now;
	ir->raw->last_type = type;
	return rc;
}
EXPORT_SYMBOL_GPL(ir_raw_event_store_edge);

/**
 * ir_raw_event_store_with_filter() - pass next pulse/space to decoders with some processing
 * @input_dev:	the struct input_dev device descriptor
 * @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
 */
int ir_raw_event_store_with_filter(struct input_dev *input_dev,
						struct ir_raw_event *ev)
{
	struct ir_input_dev *ir = input_get_drvdata(input_dev);
	struct ir_raw_event_ctrl *raw = ir->raw;

	if (!raw || !ir->props)
		return -EINVAL;

	/* Ignore spaces in idle mode */
	if (ir->idle && !ev->pulse)
		return 0;
	else if (ir->idle)
		ir_raw_event_set_idle(input_dev, 0);

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

	/* Enter idle mode if nessesary */
	if (!ev->pulse && ir->props->timeout &&
		raw->this_ev.duration >= ir->props->timeout)
		ir_raw_event_set_idle(input_dev, 1);
	return 0;
}
EXPORT_SYMBOL_GPL(ir_raw_event_store_with_filter);

void ir_raw_event_set_idle(struct input_dev *input_dev, int idle)
{
	struct ir_input_dev *ir = input_get_drvdata(input_dev);
	struct ir_raw_event_ctrl *raw = ir->raw;
	ktime_t now;
	u64 delta;

	if (!ir->props)
		return;

	if (!ir->raw)
		goto out;

	if (idle) {
		IR_dprintk(2, "enter idle mode\n");
		raw->last_event = ktime_get();
	} else {
		IR_dprintk(2, "exit idle mode\n");

		now = ktime_get();
		delta = ktime_to_ns(ktime_sub(now, ir->raw->last_event));

		WARN_ON(raw->this_ev.pulse);

		raw->this_ev.duration =
			min(raw->this_ev.duration + delta,
						(u64)IR_MAX_DURATION);

		ir_raw_event_store(input_dev, &raw->this_ev);

		if (raw->this_ev.duration == IR_MAX_DURATION)
			ir_raw_event_reset(input_dev);

		raw->this_ev.duration = 0;
	}
out:
	if (ir->props->s_idle)
		ir->props->s_idle(ir->props->priv, idle);
	ir->idle = idle;
}
EXPORT_SYMBOL_GPL(ir_raw_event_set_idle);

/**
 * ir_raw_event_handle() - schedules the decoding of stored ir data
 * @input_dev:	the struct input_dev device descriptor
 *
 * This routine will signal the workqueue to start decoding stored ir data.
 */
void ir_raw_event_handle(struct input_dev *input_dev)
{
	struct ir_input_dev *ir = input_get_drvdata(input_dev);

	if (!ir->raw)
		return;

	wake_up_process(ir->raw->thread);
}
EXPORT_SYMBOL_GPL(ir_raw_event_handle);

/* used internally by the sysfs interface */
u64
ir_raw_get_allowed_protocols()
{
	u64 protocols;
	mutex_lock(&ir_raw_handler_lock);
	protocols = available_protocols;
	mutex_unlock(&ir_raw_handler_lock);
	return protocols;
}

/*
 * Used to (un)register raw event clients
 */
int ir_raw_event_register(struct input_dev *input_dev)
{
	struct ir_input_dev *ir = input_get_drvdata(input_dev);
	int rc;
	struct ir_raw_handler *handler;

	ir->raw = kzalloc(sizeof(*ir->raw), GFP_KERNEL);
	if (!ir->raw)
		return -ENOMEM;

	ir->raw->input_dev = input_dev;

	ir->raw->enabled_protocols = ~0;
	rc = kfifo_alloc(&ir->raw->kfifo, sizeof(s64) * MAX_IR_EVENT_SIZE,
			 GFP_KERNEL);
	if (rc < 0) {
		kfree(ir->raw);
		ir->raw = NULL;
		return rc;
	}

	ir->raw->thread = kthread_run(ir_raw_event_thread, ir->raw,
			"rc%u",  (unsigned int)ir->devno);

	if (IS_ERR(ir->raw->thread)) {
		int ret = PTR_ERR(ir->raw->thread);

		kfree(ir->raw);
		ir->raw = NULL;
		return ret;
	}

	mutex_lock(&ir_raw_handler_lock);
	list_add_tail(&ir->raw->list, &ir_raw_client_list);
	list_for_each_entry(handler, &ir_raw_handler_list, list)
		if (handler->raw_register)
			handler->raw_register(ir->raw->input_dev);
	mutex_unlock(&ir_raw_handler_lock);

	return 0;
}

void ir_raw_event_unregister(struct input_dev *input_dev)
{
	struct ir_input_dev *ir = input_get_drvdata(input_dev);
	struct ir_raw_handler *handler;

	if (!ir->raw)
		return;

	kthread_stop(ir->raw->thread);

	mutex_lock(&ir_raw_handler_lock);
	list_del(&ir->raw->list);
	list_for_each_entry(handler, &ir_raw_handler_list, list)
		if (handler->raw_unregister)
			handler->raw_unregister(ir->raw->input_dev);
	mutex_unlock(&ir_raw_handler_lock);

	kfifo_free(&ir->raw->kfifo);
	kfree(ir->raw);
	ir->raw = NULL;
}

/*
 * Extension interface - used to register the IR decoders
 */

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

	mutex_lock(&ir_raw_handler_lock);
	list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list);
	if (ir_raw_handler->raw_register)
		list_for_each_entry(raw, &ir_raw_client_list, list)
			ir_raw_handler->raw_register(raw->input_dev);
	available_protocols |= ir_raw_handler->protocols;
	mutex_unlock(&ir_raw_handler_lock);

	return 0;
}
EXPORT_SYMBOL(ir_raw_handler_register);

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

	mutex_lock(&ir_raw_handler_lock);
	list_del(&ir_raw_handler->list);
	if (ir_raw_handler->raw_unregister)
		list_for_each_entry(raw, &ir_raw_client_list, list)
			ir_raw_handler->raw_unregister(raw->input_dev);
	available_protocols &= ~ir_raw_handler->protocols;
	mutex_unlock(&ir_raw_handler_lock);
}
EXPORT_SYMBOL(ir_raw_handler_unregister);

#ifdef MODULE
static void init_decoders(struct work_struct *work)
{
	/* Load the decoder modules */

	load_nec_decode();
	load_rc5_decode();
	load_rc6_decode();
	load_jvc_decode();
	load_sony_decode();
	load_lirc_codec();

	/* If needed, we may later add some init code. In this case,
	   it is needed to change the CONFIG_MODULE test at ir-core.h
	 */
}
#endif

void ir_raw_init(void)
{
#ifdef MODULE
	INIT_WORK(&wq_load, init_decoders);
	schedule_work(&wq_load);
#endif
}
Commit	Line	Data
a3572c34 MCC	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
0d2cb1de	15	#include <linux/kthread.h>
45a568fa	16	#include <linux/mutex.h>
724e2495	17	#include <linux/sched.h>
0d2cb1de	18	#include <linux/freezer.h>
3f113e36	19	#include "ir-core-priv.h"
a3572c34	20
724e2495 DH	21	/* Define the max number of pulse/space transitions to buffer */
724e2495 DH	22	#define MAX_IR_EVENT_SIZE 512
a3572c34	23
c216369e DH	24	/* Used to keep track of IR raw clients, protected by ir_raw_handler_lock */
	25	static LIST_HEAD(ir_raw_client_list);
	26
995187be	27	/* Used to handle IR raw handler extensions */
45a568fa	28	static DEFINE_MUTEX(ir_raw_handler_lock);
667c9ebe DH	29	static LIST_HEAD(ir_raw_handler_list);
667c9ebe DH	30	static u64 available_protocols;
93c312ff	31
5fa2989f	32	#ifdef MODULE
995187be MCC	33	/* Used to load the decoders */
995187be MCC	34	static struct work_struct wq_load;
5fa2989f	35	#endif
995187be	36
0d2cb1de	37	static int ir_raw_event_thread(void *data)
724e2495	38	{
e40b1127	39	struct ir_raw_event ev;
c216369e	40	struct ir_raw_handler *handler;
0d2cb1de ML	41	struct ir_raw_event_ctrl raw = (struct ir_raw_event_ctrl )data;
	42
	43	while (!kthread_should_stop()) {
	44	try_to_freeze();
724e2495	45
45a568fa	46	mutex_lock(&ir_raw_handler_lock);
0d2cb1de ML	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
45a568fa	54	mutex_unlock(&ir_raw_handler_lock);
0d2cb1de ML	55
	56	set_current_state(TASK_INTERRUPTIBLE);
	57	schedule();
c216369e	58	}
0d2cb1de ML	59
0d2cb1de ML	60	return 0;
724e2495 DH	61	}
724e2495 DH	62
724e2495 DH	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
e40b1127	66	* @ev: the struct ir_raw_event descriptor of the pulse/space
724e2495 DH	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	*/
e40b1127	73	int ir_raw_event_store(struct input_dev input_dev, struct ir_raw_event ev)
a3572c34	74	{
724e2495	75	struct ir_input_dev *ir = input_get_drvdata(input_dev);
a3572c34 MCC	76
	77	if (!ir->raw)
	78	return -EINVAL;
	79
510fcb70 ML	80	IR_dprintk(2, "sample: (05%dus %s)\n",
	81	TO_US(ev->duration), TO_STR(ev->pulse));
	82
e40b1127	83	if (kfifo_in(&ir->raw->kfifo, ev, sizeof(ev)) != sizeof(ev))
724e2495	84	return -ENOMEM;
a3572c34	85
724e2495 DH	86	return 0;
	87	}
	88	EXPORT_SYMBOL_GPL(ir_raw_event_store);
a3572c34	89
724e2495 DH	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	*/
	101	int 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 */
e40b1127	106	struct ir_raw_event ev;
724e2495	107	int rc = 0;
a3572c34	108
724e2495 DH	109	if (!ir->raw)
724e2495 DH	110	return -EINVAL;
a3572c34	111
724e2495 DH	112	now = ktime_get();
724e2495 DH	113	delta = ktime_to_ns(ktime_sub(now, ir->raw->last_event));
a3572c34	114
724e2495 DH	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	*/
e40b1127 DH	119	ev.duration = 0;
e40b1127 DH	120	if (delta > IR_MAX_DURATION \|\| !ir->raw->last_type)
724e2495	121	type \|= IR_START_EVENT;
e40b1127 DH	122	else
e40b1127 DH	123	ev.duration = delta;
724e2495 DH	124
	125	if (type & IR_START_EVENT)
	126	ir_raw_event_reset(input_dev);
e40b1127 DH	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
724e2495	134	return 0;
a3572c34	135
724e2495 DH	136	ir->raw->last_event = now;
724e2495 DH	137	ir->raw->last_type = type;
a3572c34 MCC	138	return rc;
a3572c34 MCC	139	}
724e2495	140	EXPORT_SYMBOL_GPL(ir_raw_event_store_edge);
a3572c34	141
4a702ebf ML	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	*/
	152	int 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	}
	182	EXPORT_SYMBOL_GPL(ir_raw_event_store_with_filter);
	183
	184	void 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	}
219	out:
220	if (ir->props->s_idle)
221	ir->props->s_idle(ir->props->priv, idle);
222	ir->idle = idle;
223	}
224	EXPORT_SYMBOL_GPL(ir_raw_event_set_idle);
225
724e2495 DH	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	*/
	232	void ir_raw_event_handle(struct input_dev *input_dev)
a3572c34	233	{
724e2495	234	struct ir_input_dev *ir = input_get_drvdata(input_dev);
a3572c34	235
724e2495 DH	236	if (!ir->raw)
724e2495 DH	237	return;
a3572c34	238
0d2cb1de	239	wake_up_process(ir->raw->thread);
a3572c34 MCC	240	}
a3572c34 MCC	241	EXPORT_SYMBOL_GPL(ir_raw_event_handle);
995187be	242
667c9ebe DH	243	/* used internally by the sysfs interface */
	244	u64
	245	ir_raw_get_allowed_protocols()
	246	{
	247	u64 protocols;
45a568fa	248	mutex_lock(&ir_raw_handler_lock);
667c9ebe	249	protocols = available_protocols;
45a568fa	250	mutex_unlock(&ir_raw_handler_lock);
667c9ebe DH	251	return protocols;
	252	}
	253
	254	/*
	255	* Used to (un)register raw event clients
	256	*/
	257	int ir_raw_event_register(struct input_dev *input_dev)
	258	{
	259	struct ir_input_dev *ir = input_get_drvdata(input_dev);
	260	int rc;
c216369e	261	struct ir_raw_handler *handler;
667c9ebe DH	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;
0d2cb1de	268
667c9ebe DH	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
0d2cb1de ML	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)) {
028816bc DC	282	int ret = PTR_ERR(ir->raw->thread);
028816bc DC	283
0d2cb1de ML	284	kfree(ir->raw);
0d2cb1de ML	285	ir->raw = NULL;
028816bc	286	return ret;
0d2cb1de ML	287	}
0d2cb1de ML	288
45a568fa	289	mutex_lock(&ir_raw_handler_lock);
c216369e DH	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);
45a568fa	294	mutex_unlock(&ir_raw_handler_lock);
667c9ebe	295
c216369e	296	return 0;
667c9ebe DH	297	}
	298
	299	void ir_raw_event_unregister(struct input_dev *input_dev)
	300	{
	301	struct ir_input_dev *ir = input_get_drvdata(input_dev);
c216369e	302	struct ir_raw_handler *handler;
667c9ebe DH	303
	304	if (!ir->raw)
	305	return;
	306
0d2cb1de	307	kthread_stop(ir->raw->thread);
c216369e	308
45a568fa	309	mutex_lock(&ir_raw_handler_lock);
c216369e DH	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);
45a568fa	314	mutex_unlock(&ir_raw_handler_lock);
667c9ebe DH	315
	316	kfifo_free(&ir->raw->kfifo);
	317	kfree(ir->raw);
	318	ir->raw = NULL;
	319	}
	320
995187be MCC	321	/*
	322	* Extension interface - used to register the IR decoders
	323	*/
	324
	325	int ir_raw_handler_register(struct ir_raw_handler *ir_raw_handler)
	326	{
c216369e DH	327	struct ir_raw_event_ctrl *raw;
c216369e DH	328
45a568fa	329	mutex_lock(&ir_raw_handler_lock);
995187be	330	list_add_tail(&ir_raw_handler->list, &ir_raw_handler_list);
c216369e DH	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);
667c9ebe	334	available_protocols \|= ir_raw_handler->protocols;
45a568fa	335	mutex_unlock(&ir_raw_handler_lock);
667c9ebe	336
995187be MCC	337	return 0;
	338	}
	339	EXPORT_SYMBOL(ir_raw_handler_register);
	340
	341	void ir_raw_handler_unregister(struct ir_raw_handler *ir_raw_handler)
	342	{
c216369e DH	343	struct ir_raw_event_ctrl *raw;
c216369e DH	344
45a568fa	345	mutex_lock(&ir_raw_handler_lock);
995187be	346	list_del(&ir_raw_handler->list);
c216369e DH	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);
667c9ebe	350	available_protocols &= ~ir_raw_handler->protocols;
45a568fa	351	mutex_unlock(&ir_raw_handler_lock);
995187be MCC	352	}
	353	EXPORT_SYMBOL(ir_raw_handler_unregister);
	354
5fa2989f	355	#ifdef MODULE
995187be MCC	356	static void init_decoders(struct work_struct *work)
	357	{
	358	/* Load the decoder modules */
	359
	360	load_nec_decode();
db1423a6	361	load_rc5_decode();
784a4931	362	load_rc6_decode();
bf670f64	363	load_jvc_decode();
3fe29c89	364	load_sony_decode();
ca414698	365	load_lirc_codec();
995187be MCC	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	}
5fa2989f	371	#endif
995187be MCC	372
	373	void ir_raw_init(void)
	374	{
93c312ff	375	#ifdef MODULE
995187be MCC	376	INIT_WORK(&wq_load, init_decoders);
995187be MCC	377	schedule_work(&wq_load);
93c312ff MCC	378	#endif
93c312ff MCC	379	}