[GitHub/mt8127/android_kernel_alcatel_ttab.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 legacy_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 legacy_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 legacy_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 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;
		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_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);
	}

	/* 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();
	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_protos = d->props.rc.core.allowed_protos;
	dev->driver_type = RC_DRIVER_SCANCODE;
	usb_to_input_id(d->udev, &dev->input_id);
	dev->input_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_key_map && 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_rearming_delayed_work(&d->rc_query_work);
		flush_scheduled_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 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
6520342b	11	static int legacy_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,
6520342b	28	* otherwise, input core won't let legacy_dvb_usb_setkeycode
a4c1cbc7 MCC	29	* to work
a4c1cbc7 MCC	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
6520342b	41	static int legacy_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	*/
6520342b	81	static void legacy_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");
d8b4b582 DH	109	input_event(d->input_dev, EV_KEY, event, 1);
	110	input_sync(d->input_dev);
	111	input_event(d->input_dev, EV_KEY, d->last_event, 0);
	112	input_sync(d->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	}
776338e1 JS	156
d8b4b582	157	static int legacy_dvb_usb_remote_init(struct dvb_usb_device *d)
6520342b MCC	158	{
6520342b MCC	159	int i, err, rc_interval;
d8b4b582 DH	160	struct input_dev *input_dev;
	161
	162	input_dev = input_allocate_device();
	163	if (!input_dev)
	164	return -ENOMEM;
	165
	166	input_dev->evbit[0] = BIT_MASK(EV_KEY);
	167	input_dev->name = "IR-receiver inside an USB DVB receiver";
	168	input_dev->phys = d->rc_phys;
	169	usb_to_input_id(d->udev, &input_dev->id);
	170	input_dev->dev.parent = &d->udev->dev;
	171	d->input_dev = input_dev;
	172	d->rc_dev = NULL;
6520342b MCC	173
	174	input_dev->getkeycode = legacy_dvb_usb_getkeycode;
	175	input_dev->setkeycode = legacy_dvb_usb_setkeycode;
	176
	177	/* set the bits for the keys */
	178	deb_rc("key map size: %d\n", d->props.rc.legacy.rc_key_map_size);
	179	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++) {
	180	deb_rc("setting bit for event %d item %d\n",
	181	d->props.rc.legacy.rc_key_map[i].keycode, i);
	182	set_bit(d->props.rc.legacy.rc_key_map[i].keycode, input_dev->keybit);
	183	}
	184
	185	/* setting these two values to non-zero, we have to manage key repeats */
	186	input_dev->rep[REP_PERIOD] = d->props.rc.legacy.rc_interval;
	187	input_dev->rep[REP_DELAY] = d->props.rc.legacy.rc_interval + 150;
	188
	189	input_set_drvdata(input_dev, d);
	190
	191	err = input_register_device(input_dev);
	192	if (err)
	193	input_free_device(input_dev);
	194
	195	rc_interval = d->props.rc.legacy.rc_interval;
	196
	197	INIT_DELAYED_WORK(&d->rc_query_work, legacy_dvb_usb_read_remote_control);
	198
	199	info("schedule remote query interval to %d msecs.", rc_interval);
	200	schedule_delayed_work(&d->rc_query_work,
	201	msecs_to_jiffies(rc_interval));
	202
	203	d->state \|= DVB_USB_STATE_REMOTE;
	204
	205	return err;
	206	}
	207
	208	/* Remote-control poll function - called every dib->rc_query_interval ms to see
	209	* whether the remote control has received anything.
	210	*
	211	* TODO: Fix the repeat rate of the input device.
	212	*/
	213	static void dvb_usb_read_remote_control(struct work_struct *work)
	214	{
	215	struct dvb_usb_device *d =
	216	container_of(work, struct dvb_usb_device, rc_query_work.work);
	217	int err;
	218
	219	/* TODO: need a lock here. We can simply skip checking for the remote control
	220	if we're busy. */
	221
	222	/* when the parameter has been set to 1 via sysfs while the
	223	* driver was running, or when bulk mode is enabled after IR init
	224	*/
	225	if (dvb_usb_disable_rc_polling \|\| d->props.rc.core.bulk_mode)
	226	return;
	227
	228	err = d->props.rc.core.rc_query(d);
	229	if (err)
	230	err("error %d while querying for an remote control event.", err);
	231
	232	schedule_delayed_work(&d->rc_query_work,
	233	msecs_to_jiffies(d->props.rc.core.rc_interval));
	234	}
	235
d8b4b582	236	static int rc_core_dvb_usb_remote_init(struct dvb_usb_device *d)
6520342b MCC	237	{
6520342b MCC	238	int err, rc_interval;
d8b4b582 DH	239	struct rc_dev *dev;
	240
	241	dev = rc_allocate_device();
	242	if (!dev)
	243	return -ENOMEM;
6520342b	244
d8b4b582 DH	245	dev->driver_name = d->props.rc.core.module_name;
	246	dev->map_name = d->props.rc.core.rc_codes;
	247	dev->change_protocol = d->props.rc.core.change_protocol;
	248	dev->allowed_protos = d->props.rc.core.allowed_protos;
	249	dev->driver_type = RC_DRIVER_SCANCODE;
	250	usb_to_input_id(d->udev, &dev->input_id);
	251	dev->input_name = "IR-receiver inside an USB DVB receiver";
	252	dev->input_phys = d->rc_phys;
	253	dev->dev.parent = &d->udev->dev;
	254	dev->priv = d;
	255
	256	err = rc_register_device(dev);
	257	if (err < 0) {
	258	rc_free_device(dev);
6520342b	259	return err;
d8b4b582 DH	260	}
	261
	262	d->input_dev = NULL;
	263	d->rc_dev = dev;
6520342b MCC	264
	265	if (!d->props.rc.core.rc_query \|\| d->props.rc.core.bulk_mode)
	266	return 0;
	267
	268	/* Polling mode - initialize a work queue for handling it */
	269	INIT_DELAYED_WORK(&d->rc_query_work, dvb_usb_read_remote_control);
	270
	271	rc_interval = d->props.rc.core.rc_interval;
	272
	273	info("schedule remote query interval to %d msecs.", rc_interval);
	274	schedule_delayed_work(&d->rc_query_work,
	275	msecs_to_jiffies(rc_interval));
	276
	277	return 0;
	278	}
	279
776338e1 JS	280	int dvb_usb_remote_init(struct dvb_usb_device *d)
776338e1 JS	281	{
b07b4783	282	int err;
b7df3910	283
6520342b MCC	284	if (dvb_usb_disable_rc_polling)
	285	return 0;
	286
	287	if (d->props.rc.legacy.rc_key_map && d->props.rc.legacy.rc_query)
	288	d->props.rc.mode = DVB_RC_LEGACY;
	289	else if (d->props.rc.core.rc_codes)
	290	d->props.rc.mode = DVB_RC_CORE;
	291	else
776338e1 JS	292	return 0;
776338e1 JS	293
b7df3910	294	usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys));
4fcd7d8f	295	strlcat(d->rc_phys, "/ir0", sizeof(d->rc_phys));
b7df3910	296
776338e1	297	/* Start the remote-control polling. */
f72a27b8 MCC	298	if (d->props.rc.legacy.rc_interval < 40)
f72a27b8 MCC	299	d->props.rc.legacy.rc_interval = 100; /* default */
776338e1	300
6520342b	301	if (d->props.rc.mode == DVB_RC_LEGACY)
d8b4b582	302	err = legacy_dvb_usb_remote_init(d);
6520342b	303	else
d8b4b582	304	err = rc_core_dvb_usb_remote_init(d);
6520342b MCC	305	if (err)
6520342b MCC	306	return err;
776338e1 JS	307
	308	d->state \|= DVB_USB_STATE_REMOTE;
	309
	310	return 0;
	311	}
	312
	313	int dvb_usb_remote_exit(struct dvb_usb_device *d)
	314	{
	315	if (d->state & DVB_USB_STATE_REMOTE) {
e1af4980	316	cancel_rearming_delayed_work(&d->rc_query_work);
776338e1	317	flush_scheduled_work();
6520342b	318	if (d->props.rc.mode == DVB_RC_LEGACY)
d8b4b582	319	input_unregister_device(d->input_dev);
6520342b	320	else
d8b4b582	321	rc_unregister_device(d->rc_dev);
776338e1 JS	322	}
	323	d->state &= ~DVB_USB_STATE_REMOTE;
	324	return 0;
	325	}
	326
	327	#define DVB_USB_RC_NEC_EMPTY 0x00
	328	#define DVB_USB_RC_NEC_KEY_PRESSED 0x01
	329	#define DVB_USB_RC_NEC_KEY_REPEATED 0x02
	330	int dvb_usb_nec_rc_key_to_event(struct dvb_usb_device *d,
	331	u8 keybuf[5], u32 event, int state)
	332	{
	333	int i;
f72a27b8	334	struct ir_scancode *keymap = d->props.rc.legacy.rc_key_map;
776338e1 JS	335	*event = 0;
	336	*state = REMOTE_NO_KEY_PRESSED;
	337	switch (keybuf[0]) {
	338	case DVB_USB_RC_NEC_EMPTY:
	339	break;
	340	case DVB_USB_RC_NEC_KEY_PRESSED:
	341	if ((u8) ~keybuf[1] != keybuf[2] \|\|
	342	(u8) ~keybuf[3] != keybuf[4]) {
	343	deb_err("remote control checksum failed.\n");
	344	break;
	345	}
	346	/* See if we can match the raw key code. */
f72a27b8	347	for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
2e365883 MCC	348	if (rc5_custom(&keymap[i]) == keybuf[1] &&
2e365883 MCC	349	rc5_data(&keymap[i]) == keybuf[3]) {
34abf219	350	*event = keymap[i].keycode;
776338e1	351	*state = REMOTE_KEY_PRESSED;
1df896aa	352	return 0;
776338e1 JS	353	}
	354	deb_err("key mapping failed - no appropriate key found in keymapping\n");
	355	break;
	356	case DVB_USB_RC_NEC_KEY_REPEATED:
	357	*state = REMOTE_KEY_REPEAT;
	358	break;
	359	default:
af901ca1	360	deb_err("unknown type of remote status: %d\n",keybuf[0]);
776338e1 JS	361	break;
	362	}
	363	return 0;
	364	}
	365	EXPORT_SYMBOL(dvb_usb_nec_rc_key_to_event);