[deliverable/linux.git] / drivers / media / dvb / dvb-usb / dvb-usb-remote.c

/* dvb-usb-remote.c is part of the DVB USB library.
 *
 * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
 * see dvb-usb-init.c for copyright information.
 *
 * This file contains functions for initializing the input-device and for handling remote-control-queries.
 */
#include "dvb-usb-common.h"
#include <linux/usb/input.h>

static int dvb_usb_getkeycode(struct input_dev *dev,
				unsigned int scancode, unsigned int *keycode)
{
	struct dvb_usb_device *d = input_get_drvdata(dev);

	struct ir_scancode *keymap = d->props.rc.legacy.rc_key_map;
	int i;

	/* See if we can match the raw key code. */
	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
		if (keymap[i].scancode == scancode) {
			*keycode = keymap[i].keycode;
			return 0;
		}

	/*
	 * If is there extra space, returns KEY_RESERVED,
	 * otherwise, input core won't let dvb_usb_setkeycode
	 * to work
	 */
	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
		if (keymap[i].keycode == KEY_RESERVED ||
		    keymap[i].keycode == KEY_UNKNOWN) {
			*keycode = KEY_RESERVED;
			return 0;
		}

	return -EINVAL;
}

static int dvb_usb_setkeycode(struct input_dev *dev,
				unsigned int scancode, unsigned int keycode)
{
	struct dvb_usb_device *d = input_get_drvdata(dev);

	struct ir_scancode *keymap = d->props.rc.legacy.rc_key_map;
	int i;

	/* Search if it is replacing an existing keycode */
	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
		if (keymap[i].scancode == scancode) {
			keymap[i].keycode = keycode;
			return 0;
		}

	/* Search if is there a clean entry. If so, use it */
	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
		if (keymap[i].keycode == KEY_RESERVED ||
		    keymap[i].keycode == KEY_UNKNOWN) {
			keymap[i].scancode = scancode;
			keymap[i].keycode = keycode;
			return 0;
		}

	/*
	 * FIXME: Currently, it is not possible to increase the size of
	 * scancode table. For it to happen, one possibility
	 * would be to allocate a table with key_map_size + 1,
	 * copying data, appending the new key on it, and freeing
	 * the old one - or maybe just allocating some spare space
	 */

	return -EINVAL;
}

/* Remote-control poll function - called every dib->rc_query_interval ms to see
 * whether the remote control has received anything.
 *
 * TODO: Fix the repeat rate of the input device.
 */
static void dvb_usb_read_remote_control(struct work_struct *work)
{
	struct dvb_usb_device *d =
		container_of(work, struct dvb_usb_device, rc_query_work.work);
	u32 event;
	int state;

	/* TODO: need a lock here.  We can simply skip checking for the remote control
	   if we're busy. */

	/* when the parameter has been set to 1 via sysfs while the driver was running */
	if (dvb_usb_disable_rc_polling)
		return;

	if (d->props.rc.legacy.rc_query(d,&event,&state)) {
		err("error while querying for an remote control event.");
		goto schedule;
	}


	switch (state) {
		case REMOTE_NO_KEY_PRESSED:
			break;
		case REMOTE_KEY_PRESSED:
			deb_rc("key pressed\n");
			d->last_event = event;
		case REMOTE_KEY_REPEAT:
			deb_rc("key repeated\n");
			input_event(d->rc_input_dev, EV_KEY, event, 1);
			input_sync(d->rc_input_dev);
			input_event(d->rc_input_dev, EV_KEY, d->last_event, 0);
			input_sync(d->rc_input_dev);
			break;
		default:
			break;
	}

/* improved repeat handling ???
	switch (state) {
		case REMOTE_NO_KEY_PRESSED:
			deb_rc("NO KEY PRESSED\n");
			if (d->last_state != REMOTE_NO_KEY_PRESSED) {
				deb_rc("releasing event %d\n",d->last_event);
				input_event(d->rc_input_dev, EV_KEY, d->last_event, 0);
				input_sync(d->rc_input_dev);
			}
			d->last_state = REMOTE_NO_KEY_PRESSED;
			d->last_event = 0;
			break;
		case REMOTE_KEY_PRESSED:
			deb_rc("KEY PRESSED\n");
			deb_rc("pressing event %d\n",event);

			input_event(d->rc_input_dev, EV_KEY, event, 1);
			input_sync(d->rc_input_dev);

			d->last_event = event;
			d->last_state = REMOTE_KEY_PRESSED;
			break;
		case REMOTE_KEY_REPEAT:
			deb_rc("KEY_REPEAT\n");
			if (d->last_state != REMOTE_NO_KEY_PRESSED) {
				deb_rc("repeating event %d\n",d->last_event);
				input_event(d->rc_input_dev, EV_KEY, d->last_event, 2);
				input_sync(d->rc_input_dev);
				d->last_state = REMOTE_KEY_REPEAT;
			}
		default:
			break;
	}
*/

schedule:
	schedule_delayed_work(&d->rc_query_work,msecs_to_jiffies(d->props.rc.legacy.rc_interval));
}

int dvb_usb_remote_init(struct dvb_usb_device *d)
{
	struct input_dev *input_dev;
	int i;
	int err;

	if (d->props.rc.legacy.rc_key_map == NULL ||
		d->props.rc.legacy.rc_query == NULL ||
		dvb_usb_disable_rc_polling)
		return 0;

	usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys));
	strlcat(d->rc_phys, "/ir0", sizeof(d->rc_phys));

	input_dev = input_allocate_device();
	if (!input_dev)
		return -ENOMEM;

	input_dev->evbit[0] = BIT_MASK(EV_KEY);
	input_dev->name = "IR-receiver inside an USB DVB receiver";
	input_dev->phys = d->rc_phys;
	usb_to_input_id(d->udev, &input_dev->id);
	input_dev->dev.parent = &d->udev->dev;
	input_dev->getkeycode = dvb_usb_getkeycode;
	input_dev->setkeycode = dvb_usb_setkeycode;

	/* set the bits for the keys */
	deb_rc("key map size: %d\n", d->props.rc.legacy.rc_key_map_size);
	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++) {
		deb_rc("setting bit for event %d item %d\n",
			d->props.rc.legacy.rc_key_map[i].keycode, i);
		set_bit(d->props.rc.legacy.rc_key_map[i].keycode, input_dev->keybit);
	}

	/* Start the remote-control polling. */
	if (d->props.rc.legacy.rc_interval < 40)
		d->props.rc.legacy.rc_interval = 100; /* default */

	/* setting these two values to non-zero, we have to manage key repeats */
	input_dev->rep[REP_PERIOD] = d->props.rc.legacy.rc_interval;
	input_dev->rep[REP_DELAY]  = d->props.rc.legacy.rc_interval + 150;

	input_set_drvdata(input_dev, d);

	err = input_register_device(input_dev);
	if (err) {
		input_free_device(input_dev);
		return err;
	}

	d->rc_input_dev = input_dev;

	INIT_DELAYED_WORK(&d->rc_query_work, dvb_usb_read_remote_control);

	info("schedule remote query interval to %d msecs.", d->props.rc.legacy.rc_interval);
	schedule_delayed_work(&d->rc_query_work,msecs_to_jiffies(d->props.rc.legacy.rc_interval));

	d->state |= DVB_USB_STATE_REMOTE;

	return 0;
}

int dvb_usb_remote_exit(struct dvb_usb_device *d)
{
	if (d->state & DVB_USB_STATE_REMOTE) {
		cancel_rearming_delayed_work(&d->rc_query_work);
		flush_scheduled_work();
		input_unregister_device(d->rc_input_dev);
	}
	d->state &= ~DVB_USB_STATE_REMOTE;
	return 0;
}

#define DVB_USB_RC_NEC_EMPTY           0x00
#define DVB_USB_RC_NEC_KEY_PRESSED     0x01
#define DVB_USB_RC_NEC_KEY_REPEATED    0x02
int dvb_usb_nec_rc_key_to_event(struct dvb_usb_device *d,
		u8 keybuf[5], u32 *event, int *state)
{
	int i;
	struct ir_scancode *keymap = d->props.rc.legacy.rc_key_map;
	*event = 0;
	*state = REMOTE_NO_KEY_PRESSED;
	switch (keybuf[0]) {
		case DVB_USB_RC_NEC_EMPTY:
			break;
		case DVB_USB_RC_NEC_KEY_PRESSED:
			if ((u8) ~keybuf[1] != keybuf[2] ||
				(u8) ~keybuf[3] != keybuf[4]) {
				deb_err("remote control checksum failed.\n");
				break;
			}
			/* See if we can match the raw key code. */
			for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
				if (rc5_custom(&keymap[i]) == keybuf[1] &&
					rc5_data(&keymap[i]) == keybuf[3]) {
					*event = keymap[i].keycode;
					*state = REMOTE_KEY_PRESSED;
					return 0;
				}
			deb_err("key mapping failed - no appropriate key found in keymapping\n");
			break;
		case DVB_USB_RC_NEC_KEY_REPEATED:
			*state = REMOTE_KEY_REPEAT;
			break;
		default:
			deb_err("unknown type of remote status: %d\n",keybuf[0]);
			break;
	}
	return 0;
}
EXPORT_SYMBOL(dvb_usb_nec_rc_key_to_event);
Commit	Line	Data
776338e1 JS	1	/* dvb-usb-remote.c is part of the DVB USB library.
776338e1 JS	2	*
4d43e13f	3	* Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
776338e1 JS	4	* see dvb-usb-init.c for copyright information.
776338e1 JS	5	*
59c51591	6	* This file contains functions for initializing the input-device and for handling remote-control-queries.
776338e1 JS	7	*/
776338e1 JS	8	#include "dvb-usb-common.h"
4fcd7d8f	9	#include <linux/usb/input.h>
776338e1	10
b77f0a76	11	static int dvb_usb_getkeycode(struct input_dev *dev,
58b93995	12	unsigned int scancode, unsigned int *keycode)
b77f0a76 MCC	13	{
	14	struct dvb_usb_device *d = input_get_drvdata(dev);
	15
f72a27b8	16	struct ir_scancode *keymap = d->props.rc.legacy.rc_key_map;
b77f0a76 MCC	17	int i;
	18
	19	/* See if we can match the raw key code. */
f72a27b8	20	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
34abf219 MCC	21	if (keymap[i].scancode == scancode) {
34abf219 MCC	22	*keycode = keymap[i].keycode;
b77f0a76 MCC	23	return 0;
b77f0a76 MCC	24	}
a4c1cbc7 MCC	25
	26	/*
	27	* If is there extra space, returns KEY_RESERVED,
	28	* otherwise, input core won't let dvb_usb_setkeycode
	29	* to work
	30	*/
f72a27b8	31	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
34abf219 MCC	32	if (keymap[i].keycode == KEY_RESERVED \|\|
34abf219 MCC	33	keymap[i].keycode == KEY_UNKNOWN) {
a4c1cbc7 MCC	34	*keycode = KEY_RESERVED;
	35	return 0;
	36	}
	37
b77f0a76 MCC	38	return -EINVAL;
	39	}
	40
	41	static int dvb_usb_setkeycode(struct input_dev *dev,
58b93995	42	unsigned int scancode, unsigned int keycode)
b77f0a76 MCC	43	{
	44	struct dvb_usb_device *d = input_get_drvdata(dev);
	45
f72a27b8	46	struct ir_scancode *keymap = d->props.rc.legacy.rc_key_map;
b77f0a76 MCC	47	int i;
	48
	49	/* Search if it is replacing an existing keycode */
f72a27b8	50	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
34abf219 MCC	51	if (keymap[i].scancode == scancode) {
34abf219 MCC	52	keymap[i].keycode = keycode;
b77f0a76 MCC	53	return 0;
	54	}
	55
	56	/* Search if is there a clean entry. If so, use it */
f72a27b8	57	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
34abf219 MCC	58	if (keymap[i].keycode == KEY_RESERVED \|\|
	59	keymap[i].keycode == KEY_UNKNOWN) {
	60	keymap[i].scancode = scancode;
	61	keymap[i].keycode = keycode;
b77f0a76 MCC	62	return 0;
	63	}
	64
	65	/*
	66	* FIXME: Currently, it is not possible to increase the size of
	67	* scancode table. For it to happen, one possibility
	68	* would be to allocate a table with key_map_size + 1,
	69	* copying data, appending the new key on it, and freeing
	70	* the old one - or maybe just allocating some spare space
	71	*/
	72
	73	return -EINVAL;
	74	}
	75
776338e1 JS	76	/* Remote-control poll function - called every dib->rc_query_interval ms to see
	77	* whether the remote control has received anything.
	78	*
	79	* TODO: Fix the repeat rate of the input device.
	80	*/
c4028958	81	static void dvb_usb_read_remote_control(struct work_struct *work)
776338e1	82	{
c4028958 DH	83	struct dvb_usb_device *d =
c4028958 DH	84	container_of(work, struct dvb_usb_device, rc_query_work.work);
776338e1 JS	85	u32 event;
	86	int state;
	87
	88	/* TODO: need a lock here. We can simply skip checking for the remote control
	89	if we're busy. */
	90
c9b06fa4 PB	91	/* when the parameter has been set to 1 via sysfs while the driver was running */
	92	if (dvb_usb_disable_rc_polling)
	93	return;
	94
f72a27b8	95	if (d->props.rc.legacy.rc_query(d,&event,&state)) {
776338e1 JS	96	err("error while querying for an remote control event.");
	97	goto schedule;
	98	}
	99
	100
	101	switch (state) {
	102	case REMOTE_NO_KEY_PRESSED:
	103	break;
	104	case REMOTE_KEY_PRESSED:
	105	deb_rc("key pressed\n");
	106	d->last_event = event;
	107	case REMOTE_KEY_REPEAT:
	108	deb_rc("key repeated\n");
b7df3910	109	input_event(d->rc_input_dev, EV_KEY, event, 1);
18718c96	110	input_sync(d->rc_input_dev);
b7df3910 DT	111	input_event(d->rc_input_dev, EV_KEY, d->last_event, 0);
b7df3910 DT	112	input_sync(d->rc_input_dev);
776338e1 JS	113	break;
	114	default:
	115	break;
	116	}
	117
	118	/* improved repeat handling ???
	119	switch (state) {
	120	case REMOTE_NO_KEY_PRESSED:
	121	deb_rc("NO KEY PRESSED\n");
	122	if (d->last_state != REMOTE_NO_KEY_PRESSED) {
	123	deb_rc("releasing event %d\n",d->last_event);
b7df3910 DT	124	input_event(d->rc_input_dev, EV_KEY, d->last_event, 0);
b7df3910 DT	125	input_sync(d->rc_input_dev);
776338e1 JS	126	}
	127	d->last_state = REMOTE_NO_KEY_PRESSED;
	128	d->last_event = 0;
	129	break;
	130	case REMOTE_KEY_PRESSED:
	131	deb_rc("KEY PRESSED\n");
	132	deb_rc("pressing event %d\n",event);
	133
b7df3910 DT	134	input_event(d->rc_input_dev, EV_KEY, event, 1);
b7df3910 DT	135	input_sync(d->rc_input_dev);
776338e1 JS	136
	137	d->last_event = event;
	138	d->last_state = REMOTE_KEY_PRESSED;
	139	break;
	140	case REMOTE_KEY_REPEAT:
	141	deb_rc("KEY_REPEAT\n");
	142	if (d->last_state != REMOTE_NO_KEY_PRESSED) {
	143	deb_rc("repeating event %d\n",d->last_event);
b7df3910 DT	144	input_event(d->rc_input_dev, EV_KEY, d->last_event, 2);
b7df3910 DT	145	input_sync(d->rc_input_dev);
776338e1 JS	146	d->last_state = REMOTE_KEY_REPEAT;
	147	}
	148	default:
	149	break;
	150	}
	151	*/
	152
	153	schedule:
f72a27b8	154	schedule_delayed_work(&d->rc_query_work,msecs_to_jiffies(d->props.rc.legacy.rc_interval));
776338e1 JS	155	}
	156
	157	int dvb_usb_remote_init(struct dvb_usb_device *d)
	158	{
b07b4783	159	struct input_dev *input_dev;
776338e1	160	int i;
b07b4783	161	int err;
b7df3910	162
f72a27b8 MCC	163	if (d->props.rc.legacy.rc_key_map == NULL \|\|
f72a27b8 MCC	164	d->props.rc.legacy.rc_query == NULL \|\|
c9b06fa4	165	dvb_usb_disable_rc_polling)
776338e1 JS	166	return 0;
776338e1 JS	167
b7df3910	168	usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys));
4fcd7d8f	169	strlcat(d->rc_phys, "/ir0", sizeof(d->rc_phys));
b7df3910	170
b07b4783 DT	171	input_dev = input_allocate_device();
b07b4783 DT	172	if (!input_dev)
b7df3910	173	return -ENOMEM;
776338e1	174
7b19ada2	175	input_dev->evbit[0] = BIT_MASK(EV_KEY);
b07b4783 DT	176	input_dev->name = "IR-receiver inside an USB DVB receiver";
	177	input_dev->phys = d->rc_phys;
	178	usb_to_input_id(d->udev, &input_dev->id);
2c8a3a33	179	input_dev->dev.parent = &d->udev->dev;
b77f0a76 MCC	180	input_dev->getkeycode = dvb_usb_getkeycode;
b77f0a76 MCC	181	input_dev->setkeycode = dvb_usb_setkeycode;
776338e1 JS	182
776338e1 JS	183	/* set the bits for the keys */
f72a27b8 MCC	184	deb_rc("key map size: %d\n", d->props.rc.legacy.rc_key_map_size);
f72a27b8 MCC	185	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++) {
b07b4783	186	deb_rc("setting bit for event %d item %d\n",
f72a27b8 MCC	187	d->props.rc.legacy.rc_key_map[i].keycode, i);
f72a27b8 MCC	188	set_bit(d->props.rc.legacy.rc_key_map[i].keycode, input_dev->keybit);
776338e1 JS	189	}
	190
	191	/* Start the remote-control polling. */
f72a27b8 MCC	192	if (d->props.rc.legacy.rc_interval < 40)
f72a27b8 MCC	193	d->props.rc.legacy.rc_interval = 100; /* default */
776338e1 JS	194
776338e1 JS	195	/* setting these two values to non-zero, we have to manage key repeats */
f72a27b8 MCC	196	input_dev->rep[REP_PERIOD] = d->props.rc.legacy.rc_interval;
f72a27b8 MCC	197	input_dev->rep[REP_DELAY] = d->props.rc.legacy.rc_interval + 150;
776338e1	198
b77f0a76 MCC	199	input_set_drvdata(input_dev, d);
b77f0a76 MCC	200
b07b4783 DT	201	err = input_register_device(input_dev);
	202	if (err) {
	203	input_free_device(input_dev);
	204	return err;
	205	}
	206
	207	d->rc_input_dev = input_dev;
776338e1	208
c4028958	209	INIT_DELAYED_WORK(&d->rc_query_work, dvb_usb_read_remote_control);
776338e1	210
f72a27b8 MCC	211	info("schedule remote query interval to %d msecs.", d->props.rc.legacy.rc_interval);
f72a27b8 MCC	212	schedule_delayed_work(&d->rc_query_work,msecs_to_jiffies(d->props.rc.legacy.rc_interval));
776338e1 JS	213
	214	d->state \|= DVB_USB_STATE_REMOTE;
	215
	216	return 0;
	217	}
	218
	219	int dvb_usb_remote_exit(struct dvb_usb_device *d)
	220	{
	221	if (d->state & DVB_USB_STATE_REMOTE) {
e1af4980	222	cancel_rearming_delayed_work(&d->rc_query_work);
776338e1	223	flush_scheduled_work();
b7df3910	224	input_unregister_device(d->rc_input_dev);
776338e1 JS	225	}
	226	d->state &= ~DVB_USB_STATE_REMOTE;
	227	return 0;
	228	}
	229
	230	#define DVB_USB_RC_NEC_EMPTY 0x00
	231	#define DVB_USB_RC_NEC_KEY_PRESSED 0x01
	232	#define DVB_USB_RC_NEC_KEY_REPEATED 0x02
	233	int dvb_usb_nec_rc_key_to_event(struct dvb_usb_device *d,
	234	u8 keybuf[5], u32 event, int state)
	235	{
	236	int i;
f72a27b8	237	struct ir_scancode *keymap = d->props.rc.legacy.rc_key_map;
776338e1 JS	238	*event = 0;
	239	*state = REMOTE_NO_KEY_PRESSED;
	240	switch (keybuf[0]) {
	241	case DVB_USB_RC_NEC_EMPTY:
	242	break;
	243	case DVB_USB_RC_NEC_KEY_PRESSED:
	244	if ((u8) ~keybuf[1] != keybuf[2] \|\|
	245	(u8) ~keybuf[3] != keybuf[4]) {
	246	deb_err("remote control checksum failed.\n");
	247	break;
	248	}
	249	/* See if we can match the raw key code. */
f72a27b8	250	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
2e365883 MCC	251	if (rc5_custom(&keymap[i]) == keybuf[1] &&
2e365883 MCC	252	rc5_data(&keymap[i]) == keybuf[3]) {
34abf219	253	*event = keymap[i].keycode;
776338e1	254	*state = REMOTE_KEY_PRESSED;
1df896aa	255	return 0;
776338e1 JS	256	}
	257	deb_err("key mapping failed - no appropriate key found in keymapping\n");
	258	break;
	259	case DVB_USB_RC_NEC_KEY_REPEATED:
	260	*state = REMOTE_KEY_REPEAT;
	261	break;
	262	default:
af901ca1	263	deb_err("unknown type of remote status: %d\n",keybuf[0]);
776338e1 JS	264	break;
	265	}
	266	return 0;
	267	}
	268	EXPORT_SYMBOL(dvb_usb_nec_rc_key_to_event);