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

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