[linux-2.6-block.git] / drivers / media / usb / 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@posteo.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 unsigned int
legacy_dvb_usb_get_keymap_index(const struct input_keymap_entry *ke,
				struct rc_map_table *keymap,
				unsigned int keymap_size)
{
	unsigned int index;
	unsigned int scancode;

	if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
		index = ke->index;
	} else {
		if (input_scancode_to_scalar(ke, &scancode))
			return keymap_size;

		/* See if we can match the raw key code. */
		for (index = 0; index < keymap_size; index++)
			if (keymap[index].scancode == scancode)
				break;

		/* See if there is an unused hole in the map */
		if (index >= keymap_size) {
			for (index = 0; index < keymap_size; index++) {
				if (keymap[index].keycode == KEY_RESERVED ||
				    keymap[index].keycode == KEY_UNKNOWN) {
					break;
				}
			}
		}
	}

	return index;
}

static int legacy_dvb_usb_getkeycode(struct input_dev *dev,
				     struct input_keymap_entry *ke)
{
	struct dvb_usb_device *d = input_get_drvdata(dev);
	struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
	unsigned int keymap_size = d->props.rc.legacy.rc_map_size;
	unsigned int index;

	index = legacy_dvb_usb_get_keymap_index(ke, keymap, keymap_size);
	if (index >= keymap_size)
		return -EINVAL;

	ke->keycode = keymap[index].keycode;
	if (ke->keycode == KEY_UNKNOWN)
		ke->keycode = KEY_RESERVED;
	ke->len = sizeof(keymap[index].scancode);
	memcpy(&ke->scancode, &keymap[index].scancode, ke->len);
	ke->index = index;

	return 0;
}

static int legacy_dvb_usb_setkeycode(struct input_dev *dev,
				     const struct input_keymap_entry *ke,
				     unsigned int *old_keycode)
{
	struct dvb_usb_device *d = input_get_drvdata(dev);
	struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
	unsigned int keymap_size = d->props.rc.legacy.rc_map_size;
	unsigned int index;

	index = legacy_dvb_usb_get_keymap_index(ke, keymap, keymap_size);
	/*
	 * 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
	 */
	if (index >= keymap_size)
		return -EINVAL;

	*old_keycode = keymap[index].keycode;
	keymap->keycode = ke->keycode;
	__set_bit(ke->keycode, dev->keybit);

	if (*old_keycode != KEY_RESERVED) {
		__clear_bit(*old_keycode, dev->keybit);
		for (index = 0; index < keymap_size; index++) {
			if (keymap[index].keycode == *old_keycode) {
				__set_bit(*old_keycode, dev->keybit);
				break;
			}
		}
	}

	return 0;
}

/* 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 legacy_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;
			input_event(d->input_dev, EV_KEY, event, 1);
			input_sync(d->input_dev);
			input_event(d->input_dev, EV_KEY, d->last_event, 0);
			input_sync(d->input_dev);
			break;
		case REMOTE_KEY_REPEAT:
			deb_rc("key repeated\n");
			input_event(d->input_dev, EV_KEY, event, 1);
			input_sync(d->input_dev);
			input_event(d->input_dev, EV_KEY, d->last_event, 0);
			input_sync(d->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));
}

static int legacy_dvb_usb_remote_init(struct dvb_usb_device *d)
{
	int i, err, rc_interval;
	struct input_dev *input_dev;

	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;
	d->input_dev = input_dev;
	d->rc_dev = NULL;

	input_dev->getkeycode = legacy_dvb_usb_getkeycode;
	input_dev->setkeycode = legacy_dvb_usb_setkeycode;

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

	/* 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);

	rc_interval = d->props.rc.legacy.rc_interval;

	INIT_DELAYED_WORK(&d->rc_query_work, legacy_dvb_usb_read_remote_control);

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

	d->state |= DVB_USB_STATE_REMOTE;

	return err;
}

/* 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);
	int err;

	/* 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, or when bulk mode is enabled after IR init
	 */
	if (dvb_usb_disable_rc_polling || d->props.rc.core.bulk_mode)
		return;

	err = d->props.rc.core.rc_query(d);
	if (err)
		err("error %d while querying for an remote control event.", err);

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

static int rc_core_dvb_usb_remote_init(struct dvb_usb_device *d)
{
	int err, rc_interval;
	struct rc_dev *dev;

	dev = rc_allocate_device(d->props.rc.core.driver_type);
	if (!dev)
		return -ENOMEM;

	dev->driver_name = d->props.rc.core.module_name;
	dev->map_name = d->props.rc.core.rc_codes;
	dev->change_protocol = d->props.rc.core.change_protocol;
	dev->allowed_protocols = d->props.rc.core.allowed_protos;
	usb_to_input_id(d->udev, &dev->input_id);
	dev->device_name = "IR-receiver inside an USB DVB receiver";
	dev->input_phys = d->rc_phys;
	dev->dev.parent = &d->udev->dev;
	dev->priv = d;

	err = rc_register_device(dev);
	if (err < 0) {
		rc_free_device(dev);
		return err;
	}

	d->input_dev = NULL;
	d->rc_dev = dev;

	if (!d->props.rc.core.rc_query || d->props.rc.core.bulk_mode)
		return 0;

	/* Polling mode - initialize a work queue for handling it */
	INIT_DELAYED_WORK(&d->rc_query_work, dvb_usb_read_remote_control);

	rc_interval = d->props.rc.core.rc_interval;

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

	return 0;
}

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

	if (dvb_usb_disable_rc_polling)
		return 0;

	if (d->props.rc.legacy.rc_map_table && d->props.rc.legacy.rc_query)
		d->props.rc.mode = DVB_RC_LEGACY;
	else if (d->props.rc.core.rc_codes)
		d->props.rc.mode = DVB_RC_CORE;
	else
		return 0;

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

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

	if (d->props.rc.mode == DVB_RC_LEGACY)
		err = legacy_dvb_usb_remote_init(d);
	else
		err = rc_core_dvb_usb_remote_init(d);
	if (err)
		return err;

	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_delayed_work_sync(&d->rc_query_work);
		if (d->props.rc.mode == DVB_RC_LEGACY)
			input_unregister_device(d->input_dev);
		else
			rc_unregister_device(d->rc_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 rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
	*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_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	*
99e44da7	3	* Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@posteo.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
f06e6a52 DT	11	static unsigned int
	12	legacy_dvb_usb_get_keymap_index(const struct input_keymap_entry *ke,
	13	struct rc_map_table *keymap,
	14	unsigned int keymap_size)
	15	{
	16	unsigned int index;
	17	unsigned int scancode;
	18
	19	if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
	20	index = ke->index;
	21	} else {
	22	if (input_scancode_to_scalar(ke, &scancode))
	23	return keymap_size;
	24
	25	/* See if we can match the raw key code. */
	26	for (index = 0; index < keymap_size; index++)
	27	if (keymap[index].scancode == scancode)
	28	break;
	29
	30	/* See if there is an unused hole in the map */
	31	if (index >= keymap_size) {
	32	for (index = 0; index < keymap_size; index++) {
	33	if (keymap[index].keycode == KEY_RESERVED \|\|
	34	keymap[index].keycode == KEY_UNKNOWN) {
	35	break;
	36	}
	37	}
	38	}
	39	}
	40
	41	return index;
	42	}
	43
6520342b	44	static int legacy_dvb_usb_getkeycode(struct input_dev *dev,
f06e6a52	45	struct input_keymap_entry *ke)
b77f0a76 MCC	46	{
b77f0a76 MCC	47	struct dvb_usb_device *d = input_get_drvdata(dev);
2f4f58d6	48	struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
f06e6a52 DT	49	unsigned int keymap_size = d->props.rc.legacy.rc_map_size;
f06e6a52 DT	50	unsigned int index;
b77f0a76	51
f06e6a52 DT	52	index = legacy_dvb_usb_get_keymap_index(ke, keymap, keymap_size);
	53	if (index >= keymap_size)
	54	return -EINVAL;
a4c1cbc7	55
f06e6a52 DT	56	ke->keycode = keymap[index].keycode;
	57	if (ke->keycode == KEY_UNKNOWN)
	58	ke->keycode = KEY_RESERVED;
	59	ke->len = sizeof(keymap[index].scancode);
	60	memcpy(&ke->scancode, &keymap[index].scancode, ke->len);
	61	ke->index = index;
a4c1cbc7	62
f06e6a52	63	return 0;
b77f0a76 MCC	64	}
b77f0a76 MCC	65
6520342b	66	static int legacy_dvb_usb_setkeycode(struct input_dev *dev,
f06e6a52 DT	67	const struct input_keymap_entry *ke,
f06e6a52 DT	68	unsigned int *old_keycode)
b77f0a76 MCC	69	{
b77f0a76 MCC	70	struct dvb_usb_device *d = input_get_drvdata(dev);
2f4f58d6	71	struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
f06e6a52 DT	72	unsigned int keymap_size = d->props.rc.legacy.rc_map_size;
f06e6a52 DT	73	unsigned int index;
b77f0a76	74
f06e6a52	75	index = legacy_dvb_usb_get_keymap_index(ke, keymap, keymap_size);
b77f0a76 MCC	76	/*
	77	* FIXME: Currently, it is not possible to increase the size of
	78	* scancode table. For it to happen, one possibility
	79	* would be to allocate a table with key_map_size + 1,
	80	* copying data, appending the new key on it, and freeing
	81	* the old one - or maybe just allocating some spare space
	82	*/
f06e6a52 DT	83	if (index >= keymap_size)
	84	return -EINVAL;
	85
	86	*old_keycode = keymap[index].keycode;
	87	keymap->keycode = ke->keycode;
	88	__set_bit(ke->keycode, dev->keybit);
	89
	90	if (*old_keycode != KEY_RESERVED) {
	91	__clear_bit(*old_keycode, dev->keybit);
	92	for (index = 0; index < keymap_size; index++) {
	93	if (keymap[index].keycode == *old_keycode) {
	94	__set_bit(*old_keycode, dev->keybit);
	95	break;
	96	}
	97	}
	98	}
b77f0a76	99
f06e6a52	100	return 0;
b77f0a76 MCC	101	}
b77f0a76 MCC	102
776338e1 JS	103	/* Remote-control poll function - called every dib->rc_query_interval ms to see
	104	* whether the remote control has received anything.
	105	*
	106	* TODO: Fix the repeat rate of the input device.
	107	*/
6520342b	108	static void legacy_dvb_usb_read_remote_control(struct work_struct *work)
776338e1	109	{
c4028958 DH	110	struct dvb_usb_device *d =
c4028958 DH	111	container_of(work, struct dvb_usb_device, rc_query_work.work);
776338e1 JS	112	u32 event;
	113	int state;
	114
	115	/* TODO: need a lock here. We can simply skip checking for the remote control
	116	if we're busy. */
	117
c9b06fa4 PB	118	/* when the parameter has been set to 1 via sysfs while the driver was running */
	119	if (dvb_usb_disable_rc_polling)
	120	return;
	121
f72a27b8	122	if (d->props.rc.legacy.rc_query(d,&event,&state)) {
776338e1 JS	123	err("error while querying for an remote control event.");
	124	goto schedule;
	125	}
	126
	127
	128	switch (state) {
	129	case REMOTE_NO_KEY_PRESSED:
	130	break;
	131	case REMOTE_KEY_PRESSED:
	132	deb_rc("key pressed\n");
	133	d->last_event = event;
39c4806e MCC	134	input_event(d->input_dev, EV_KEY, event, 1);
	135	input_sync(d->input_dev);
	136	input_event(d->input_dev, EV_KEY, d->last_event, 0);
	137	input_sync(d->input_dev);
	138	break;
776338e1 JS	139	case REMOTE_KEY_REPEAT:
776338e1 JS	140	deb_rc("key repeated\n");
d8b4b582 DH	141	input_event(d->input_dev, EV_KEY, event, 1);
	142	input_sync(d->input_dev);
	143	input_event(d->input_dev, EV_KEY, d->last_event, 0);
	144	input_sync(d->input_dev);
776338e1 JS	145	break;
	146	default:
	147	break;
	148	}
	149
	150	/* improved repeat handling ???
	151	switch (state) {
	152	case REMOTE_NO_KEY_PRESSED:
	153	deb_rc("NO KEY PRESSED\n");
	154	if (d->last_state != REMOTE_NO_KEY_PRESSED) {
	155	deb_rc("releasing event %d\n",d->last_event);
b7df3910 DT	156	input_event(d->rc_input_dev, EV_KEY, d->last_event, 0);
b7df3910 DT	157	input_sync(d->rc_input_dev);
776338e1 JS	158	}
	159	d->last_state = REMOTE_NO_KEY_PRESSED;
	160	d->last_event = 0;
	161	break;
	162	case REMOTE_KEY_PRESSED:
	163	deb_rc("KEY PRESSED\n");
	164	deb_rc("pressing event %d\n",event);
	165
b7df3910 DT	166	input_event(d->rc_input_dev, EV_KEY, event, 1);
b7df3910 DT	167	input_sync(d->rc_input_dev);
776338e1 JS	168
	169	d->last_event = event;
	170	d->last_state = REMOTE_KEY_PRESSED;
	171	break;
	172	case REMOTE_KEY_REPEAT:
	173	deb_rc("KEY_REPEAT\n");
	174	if (d->last_state != REMOTE_NO_KEY_PRESSED) {
	175	deb_rc("repeating event %d\n",d->last_event);
b7df3910 DT	176	input_event(d->rc_input_dev, EV_KEY, d->last_event, 2);
b7df3910 DT	177	input_sync(d->rc_input_dev);
776338e1 JS	178	d->last_state = REMOTE_KEY_REPEAT;
	179	}
	180	default:
	181	break;
	182	}
	183	*/
	184
	185	schedule:
f72a27b8	186	schedule_delayed_work(&d->rc_query_work,msecs_to_jiffies(d->props.rc.legacy.rc_interval));
776338e1 JS	187	}
776338e1 JS	188
d8b4b582	189	static int legacy_dvb_usb_remote_init(struct dvb_usb_device *d)
6520342b MCC	190	{
6520342b MCC	191	int i, err, rc_interval;
d8b4b582 DH	192	struct input_dev *input_dev;
	193
	194	input_dev = input_allocate_device();
	195	if (!input_dev)
	196	return -ENOMEM;
	197
	198	input_dev->evbit[0] = BIT_MASK(EV_KEY);
	199	input_dev->name = "IR-receiver inside an USB DVB receiver";
	200	input_dev->phys = d->rc_phys;
	201	usb_to_input_id(d->udev, &input_dev->id);
	202	input_dev->dev.parent = &d->udev->dev;
	203	d->input_dev = input_dev;
	204	d->rc_dev = NULL;
6520342b	205
aebd636b DT	206	input_dev->getkeycode = legacy_dvb_usb_getkeycode;
aebd636b DT	207	input_dev->setkeycode = legacy_dvb_usb_setkeycode;
6520342b MCC	208
6520342b MCC	209	/* set the bits for the keys */
2f4f58d6 MCC	210	deb_rc("key map size: %d\n", d->props.rc.legacy.rc_map_size);
2f4f58d6 MCC	211	for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
6520342b	212	deb_rc("setting bit for event %d item %d\n",
2f4f58d6 MCC	213	d->props.rc.legacy.rc_map_table[i].keycode, i);
2f4f58d6 MCC	214	set_bit(d->props.rc.legacy.rc_map_table[i].keycode, input_dev->keybit);
6520342b MCC	215	}
	216
	217	/* setting these two values to non-zero, we have to manage key repeats */
	218	input_dev->rep[REP_PERIOD] = d->props.rc.legacy.rc_interval;
	219	input_dev->rep[REP_DELAY] = d->props.rc.legacy.rc_interval + 150;
	220
	221	input_set_drvdata(input_dev, d);
	222
	223	err = input_register_device(input_dev);
	224	if (err)
	225	input_free_device(input_dev);
	226
	227	rc_interval = d->props.rc.legacy.rc_interval;
	228
	229	INIT_DELAYED_WORK(&d->rc_query_work, legacy_dvb_usb_read_remote_control);
	230
	231	info("schedule remote query interval to %d msecs.", rc_interval);
	232	schedule_delayed_work(&d->rc_query_work,
	233	msecs_to_jiffies(rc_interval));
	234
	235	d->state \|= DVB_USB_STATE_REMOTE;
	236
	237	return err;
	238	}
	239
	240	/* Remote-control poll function - called every dib->rc_query_interval ms to see
	241	* whether the remote control has received anything.
	242	*
	243	* TODO: Fix the repeat rate of the input device.
	244	*/
	245	static void dvb_usb_read_remote_control(struct work_struct *work)
	246	{
	247	struct dvb_usb_device *d =
	248	container_of(work, struct dvb_usb_device, rc_query_work.work);
	249	int err;
	250
	251	/* TODO: need a lock here. We can simply skip checking for the remote control
	252	if we're busy. */
	253
	254	/* when the parameter has been set to 1 via sysfs while the
	255	* driver was running, or when bulk mode is enabled after IR init
	256	*/
	257	if (dvb_usb_disable_rc_polling \|\| d->props.rc.core.bulk_mode)
	258	return;
	259
	260	err = d->props.rc.core.rc_query(d);
	261	if (err)
	262	err("error %d while querying for an remote control event.", err);
	263
	264	schedule_delayed_work(&d->rc_query_work,
	265	msecs_to_jiffies(d->props.rc.core.rc_interval));
	266	}
	267
d8b4b582	268	static int rc_core_dvb_usb_remote_init(struct dvb_usb_device *d)
6520342b MCC	269	{
6520342b MCC	270	int err, rc_interval;
d8b4b582 DH	271	struct rc_dev *dev;
d8b4b582 DH	272
0f7499fd	273	dev = rc_allocate_device(d->props.rc.core.driver_type);
d8b4b582 DH	274	if (!dev)
d8b4b582 DH	275	return -ENOMEM;
6520342b	276
d8b4b582 DH	277	dev->driver_name = d->props.rc.core.module_name;
	278	dev->map_name = d->props.rc.core.rc_codes;
	279	dev->change_protocol = d->props.rc.core.change_protocol;
c5540fbb	280	dev->allowed_protocols = d->props.rc.core.allowed_protos;
d8b4b582	281	usb_to_input_id(d->udev, &dev->input_id);
518f4b26	282	dev->device_name = "IR-receiver inside an USB DVB receiver";
d8b4b582 DH	283	dev->input_phys = d->rc_phys;
	284	dev->dev.parent = &d->udev->dev;
	285	dev->priv = d;
	286
	287	err = rc_register_device(dev);
	288	if (err < 0) {
	289	rc_free_device(dev);
6520342b	290	return err;
d8b4b582 DH	291	}
	292
	293	d->input_dev = NULL;
	294	d->rc_dev = dev;
6520342b MCC	295
	296	if (!d->props.rc.core.rc_query \|\| d->props.rc.core.bulk_mode)
	297	return 0;
	298
	299	/* Polling mode - initialize a work queue for handling it */
	300	INIT_DELAYED_WORK(&d->rc_query_work, dvb_usb_read_remote_control);
	301
	302	rc_interval = d->props.rc.core.rc_interval;
	303
	304	info("schedule remote query interval to %d msecs.", rc_interval);
	305	schedule_delayed_work(&d->rc_query_work,
	306	msecs_to_jiffies(rc_interval));
	307
	308	return 0;
	309	}
	310
776338e1 JS	311	int dvb_usb_remote_init(struct dvb_usb_device *d)
776338e1 JS	312	{
b07b4783	313	int err;
b7df3910	314
6520342b MCC	315	if (dvb_usb_disable_rc_polling)
	316	return 0;
	317
2f4f58d6	318	if (d->props.rc.legacy.rc_map_table && d->props.rc.legacy.rc_query)
6520342b MCC	319	d->props.rc.mode = DVB_RC_LEGACY;
	320	else if (d->props.rc.core.rc_codes)
	321	d->props.rc.mode = DVB_RC_CORE;
	322	else
776338e1 JS	323	return 0;
776338e1 JS	324
b7df3910	325	usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys));
4fcd7d8f	326	strlcat(d->rc_phys, "/ir0", sizeof(d->rc_phys));
b7df3910	327
776338e1	328	/* Start the remote-control polling. */
f72a27b8 MCC	329	if (d->props.rc.legacy.rc_interval < 40)
f72a27b8 MCC	330	d->props.rc.legacy.rc_interval = 100; /* default */
776338e1	331
6520342b	332	if (d->props.rc.mode == DVB_RC_LEGACY)
d8b4b582	333	err = legacy_dvb_usb_remote_init(d);
6520342b	334	else
d8b4b582	335	err = rc_core_dvb_usb_remote_init(d);
6520342b MCC	336	if (err)
6520342b MCC	337	return err;
776338e1 JS	338
	339	d->state \|= DVB_USB_STATE_REMOTE;
	340
	341	return 0;
	342	}
	343
	344	int dvb_usb_remote_exit(struct dvb_usb_device *d)
	345	{
	346	if (d->state & DVB_USB_STATE_REMOTE) {
afe2c511	347	cancel_delayed_work_sync(&d->rc_query_work);
6520342b	348	if (d->props.rc.mode == DVB_RC_LEGACY)
d8b4b582	349	input_unregister_device(d->input_dev);
6520342b	350	else
d8b4b582	351	rc_unregister_device(d->rc_dev);
776338e1 JS	352	}
	353	d->state &= ~DVB_USB_STATE_REMOTE;
	354	return 0;
	355	}
	356
	357	#define DVB_USB_RC_NEC_EMPTY 0x00
	358	#define DVB_USB_RC_NEC_KEY_PRESSED 0x01
	359	#define DVB_USB_RC_NEC_KEY_REPEATED 0x02
	360	int dvb_usb_nec_rc_key_to_event(struct dvb_usb_device *d,
	361	u8 keybuf[5], u32 event, int state)
	362	{
	363	int i;
2f4f58d6	364	struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
776338e1 JS	365	*event = 0;
	366	*state = REMOTE_NO_KEY_PRESSED;
	367	switch (keybuf[0]) {
	368	case DVB_USB_RC_NEC_EMPTY:
	369	break;
	370	case DVB_USB_RC_NEC_KEY_PRESSED:
	371	if ((u8) ~keybuf[1] != keybuf[2] \|\|
	372	(u8) ~keybuf[3] != keybuf[4]) {
	373	deb_err("remote control checksum failed.\n");
	374	break;
	375	}
	376	/* See if we can match the raw key code. */
2f4f58d6	377	for (i = 0; i < d->props.rc.legacy.rc_map_size; i++)
2e365883 MCC	378	if (rc5_custom(&keymap[i]) == keybuf[1] &&
2e365883 MCC	379	rc5_data(&keymap[i]) == keybuf[3]) {
34abf219	380	*event = keymap[i].keycode;
776338e1	381	*state = REMOTE_KEY_PRESSED;
1df896aa	382	return 0;
776338e1 JS	383	}
	384	deb_err("key mapping failed - no appropriate key found in keymapping\n");
	385	break;
	386	case DVB_USB_RC_NEC_KEY_REPEATED:
	387	*state = REMOTE_KEY_REPEAT;
	388	break;
	389	default:
af901ca1	390	deb_err("unknown type of remote status: %d\n",keybuf[0]);
776338e1 JS	391	break;
	392	}
	393	return 0;
	394	}
	395	EXPORT_SYMBOL(dvb_usb_nec_rc_key_to_event);