[net-next-2.6.git] / drivers / media / IR / rc-map.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 <media/ir-core.h>
#include <linux/spinlock.h>
#include <linux/delay.h>

/* Used to handle IR raw handler extensions */
static LIST_HEAD(rc_map_list);
static DEFINE_SPINLOCK(rc_map_lock);

static struct rc_keymap *seek_rc_map(const char *name)
{
	struct rc_keymap *map = NULL;

	spin_lock(&rc_map_lock);
	list_for_each_entry(map, &rc_map_list, list) {
		if (!strcmp(name, map->map.name)) {
			spin_unlock(&rc_map_lock);
			return map;
		}
	}
	spin_unlock(&rc_map_lock);

	return NULL;
}

struct ir_scancode_table *get_rc_map(const char *name)
{

	struct rc_keymap *map;

	map = seek_rc_map(name);
#ifdef MODULE
	if (!map) {
		int rc = request_module(name);
		if (rc < 0) {
			printk(KERN_ERR "Couldn't load IR keymap %s\n", name);
			return NULL;
		}
		msleep(20);	/* Give some time for IR to register */

		map = seek_rc_map(name);
	}
#endif
	if (!map) {
		printk(KERN_ERR "IR keymap %s not found\n", name);
		return NULL;
	}

	printk(KERN_INFO "Registered IR keymap %s\n", map->map.name);

	return &map->map;
}
EXPORT_SYMBOL_GPL(get_rc_map);

int ir_register_map(struct rc_keymap *map)
{
	spin_lock(&rc_map_lock);
	list_add_tail(&map->list, &rc_map_list);
	spin_unlock(&rc_map_lock);
	return 0;
}
EXPORT_SYMBOL_GPL(ir_register_map);

void ir_unregister_map(struct rc_keymap *map)
{
	spin_lock(&rc_map_lock);
	list_del(&map->list);
	spin_unlock(&rc_map_lock);
}
EXPORT_SYMBOL_GPL(ir_unregister_map);


static struct ir_scancode empty[] = {
	{ 0x2a, KEY_COFFEE },
};

static struct rc_keymap empty_map = {
	.map = {
		.scan    = empty,
		.size    = ARRAY_SIZE(empty),
		.ir_type = IR_TYPE_UNKNOWN,	/* Legacy IR type */
		.name    = RC_MAP_EMPTY,
	}
};

int ir_rcmap_init(void)
{
	return ir_register_map(&empty_map);
}

void ir_rcmap_cleanup(void)
{
	ir_unregister_map(&empty_map);
}
Commit	Line	Data
9ce50c1a 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
	15	#include <media/ir-core.h>
	16	#include <linux/spinlock.h>
a7b39036	17	#include <linux/delay.h>
9ce50c1a MCC	18
	19	/* Used to handle IR raw handler extensions */
	20	static LIST_HEAD(rc_map_list);
6eb9435b	21	static DEFINE_SPINLOCK(rc_map_lock);
9ce50c1a MCC	22
	23	static struct rc_keymap seek_rc_map(const char name)
	24	{
	25	struct rc_keymap *map = NULL;
	26
	27	spin_lock(&rc_map_lock);
	28	list_for_each_entry(map, &rc_map_list, list) {
02858eed MCC	29	if (!strcmp(name, map->map.name)) {
	30	spin_unlock(&rc_map_lock);
	31	return map;
	32	}
9ce50c1a MCC	33	}
	34	spin_unlock(&rc_map_lock);
	35
02858eed	36	return NULL;
9ce50c1a MCC	37	}
	38
	39	struct ir_scancode_table get_rc_map(const char name)
	40	{
9ce50c1a MCC	41
	42	struct rc_keymap *map;
	43
	44	map = seek_rc_map(name);
	45	#ifdef MODULE
	46	if (!map) {
5fa2989f	47	int rc = request_module(name);
02858eed MCC	48	if (rc < 0) {
02858eed MCC	49	printk(KERN_ERR "Couldn't load IR keymap %s\n", name);
9ce50c1a	50	return NULL;
02858eed MCC	51	}
02858eed MCC	52	msleep(20); /* Give some time for IR to register */
9ce50c1a MCC	53
	54	map = seek_rc_map(name);
	55	}
	56	#endif
02858eed MCC	57	if (!map) {
02858eed MCC	58	printk(KERN_ERR "IR keymap %s not found\n", name);
9ce50c1a	59	return NULL;
02858eed MCC	60	}
	61
	62	printk(KERN_INFO "Registered IR keymap %s\n", map->map.name);
9ce50c1a MCC	63
	64	return &map->map;
	65	}
	66	EXPORT_SYMBOL_GPL(get_rc_map);
	67
	68	int ir_register_map(struct rc_keymap *map)
	69	{
	70	spin_lock(&rc_map_lock);
	71	list_add_tail(&map->list, &rc_map_list);
	72	spin_unlock(&rc_map_lock);
	73	return 0;
	74	}
6686fa69	75	EXPORT_SYMBOL_GPL(ir_register_map);
9ce50c1a MCC	76
	77	void ir_unregister_map(struct rc_keymap *map)
	78	{
	79	spin_lock(&rc_map_lock);
	80	list_del(&map->list);
	81	spin_unlock(&rc_map_lock);
	82	}
6686fa69	83	EXPORT_SYMBOL_GPL(ir_unregister_map);
02858eed	84
b378f43f ML	85
	86	static struct ir_scancode empty[] = {
	87	{ 0x2a, KEY_COFFEE },
	88	};
	89
	90	static struct rc_keymap empty_map = {
	91	.map = {
	92	.scan = empty,
	93	.size = ARRAY_SIZE(empty),
	94	.ir_type = IR_TYPE_UNKNOWN, /* Legacy IR type */
	95	.name = RC_MAP_EMPTY,
	96	}
	97	};
	98
	99	int ir_rcmap_init(void)
	100	{
	101	return ir_register_map(&empty_map);
	102	}
	103
	104	void ir_rcmap_cleanup(void)
	105	{
	106	ir_unregister_map(&empty_map);
	107	}