[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 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->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));
}

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

	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,
				       struct input_dev *input_dev)
{
	int err, rc_interval;

	d->props.rc.core.rc_props.priv = d;
	err = ir_input_register(input_dev,
				 d->props.rc.core.rc_codes,
				 &d->props.rc.core.rc_props,
				 d->props.rc.core.module_name);
	if (err < 0)
		return err;

	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)
{
	struct input_dev *input_dev;
	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));

	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;

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

	d->rc_input_dev = input_dev;

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