1 /* dvb-usb-remote.c is part of the DVB USB library.
3 * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
4 * see dvb-usb-init.c for copyright information.
6 * This file contains functions for initializing the input-device and for handling remote-control-queries.
8 #include "dvb-usb-common.h"
9 #include <linux/usb/input.h>
11 static int legacy_dvb_usb_getkeycode(struct input_dev *dev,
12 unsigned int scancode, unsigned int *keycode)
14 struct dvb_usb_device *d = input_get_drvdata(dev);
16 struct ir_scancode *keymap = d->props.rc.legacy.rc_key_map;
19 /* See if we can match the raw key code. */
20 for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
21 if (keymap[i].scancode == scancode) {
22 *keycode = keymap[i].keycode;
27 * If is there extra space, returns KEY_RESERVED,
28 * otherwise, input core won't let legacy_dvb_usb_setkeycode
31 for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
32 if (keymap[i].keycode == KEY_RESERVED ||
33 keymap[i].keycode == KEY_UNKNOWN) {
34 *keycode = KEY_RESERVED;
41 static int legacy_dvb_usb_setkeycode(struct input_dev *dev,
42 unsigned int scancode, unsigned int keycode)
44 struct dvb_usb_device *d = input_get_drvdata(dev);
46 struct ir_scancode *keymap = d->props.rc.legacy.rc_key_map;
49 /* Search if it is replacing an existing keycode */
50 for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
51 if (keymap[i].scancode == scancode) {
52 keymap[i].keycode = keycode;
56 /* Search if is there a clean entry. If so, use it */
57 for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
58 if (keymap[i].keycode == KEY_RESERVED ||
59 keymap[i].keycode == KEY_UNKNOWN) {
60 keymap[i].scancode = scancode;
61 keymap[i].keycode = keycode;
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
76 /* Remote-control poll function - called every dib->rc_query_interval ms to see
77 * whether the remote control has received anything.
79 * TODO: Fix the repeat rate of the input device.
81 static void legacy_dvb_usb_read_remote_control(struct work_struct *work)
83 struct dvb_usb_device *d =
84 container_of(work, struct dvb_usb_device, rc_query_work.work);
88 /* TODO: need a lock here. We can simply skip checking for the remote control
91 /* when the parameter has been set to 1 via sysfs while the driver was running */
92 if (dvb_usb_disable_rc_polling)
95 if (d->props.rc.legacy.rc_query(d,&event,&state)) {
96 err("error while querying for an remote control event.");
102 case REMOTE_NO_KEY_PRESSED:
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");
109 input_event(d->rc_input_dev, EV_KEY, event, 1);
110 input_sync(d->rc_input_dev);
111 input_event(d->rc_input_dev, EV_KEY, d->last_event, 0);
112 input_sync(d->rc_input_dev);
118 /* improved repeat handling ???
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);
124 input_event(d->rc_input_dev, EV_KEY, d->last_event, 0);
125 input_sync(d->rc_input_dev);
127 d->last_state = REMOTE_NO_KEY_PRESSED;
130 case REMOTE_KEY_PRESSED:
131 deb_rc("KEY PRESSED\n");
132 deb_rc("pressing event %d\n",event);
134 input_event(d->rc_input_dev, EV_KEY, event, 1);
135 input_sync(d->rc_input_dev);
137 d->last_event = event;
138 d->last_state = REMOTE_KEY_PRESSED;
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);
144 input_event(d->rc_input_dev, EV_KEY, d->last_event, 2);
145 input_sync(d->rc_input_dev);
146 d->last_state = REMOTE_KEY_REPEAT;
154 schedule_delayed_work(&d->rc_query_work,msecs_to_jiffies(d->props.rc.legacy.rc_interval));
157 static int legacy_dvb_usb_remote_init(struct dvb_usb_device *d,
158 struct input_dev *input_dev)
160 int i, err, rc_interval;
162 input_dev->getkeycode = legacy_dvb_usb_getkeycode;
163 input_dev->setkeycode = legacy_dvb_usb_setkeycode;
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);
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;
177 input_set_drvdata(input_dev, d);
179 err = input_register_device(input_dev);
181 input_free_device(input_dev);
183 rc_interval = d->props.rc.legacy.rc_interval;
185 INIT_DELAYED_WORK(&d->rc_query_work, legacy_dvb_usb_read_remote_control);
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));
191 d->state |= DVB_USB_STATE_REMOTE;
196 /* Remote-control poll function - called every dib->rc_query_interval ms to see
197 * whether the remote control has received anything.
199 * TODO: Fix the repeat rate of the input device.
201 static void dvb_usb_read_remote_control(struct work_struct *work)
203 struct dvb_usb_device *d =
204 container_of(work, struct dvb_usb_device, rc_query_work.work);
207 /* TODO: need a lock here. We can simply skip checking for the remote control
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
213 if (dvb_usb_disable_rc_polling || d->props.rc.core.bulk_mode)
216 err = d->props.rc.core.rc_query(d);
218 err("error %d while querying for an remote control event.", err);
220 schedule_delayed_work(&d->rc_query_work,
221 msecs_to_jiffies(d->props.rc.core.rc_interval));
224 static int rc_core_dvb_usb_remote_init(struct dvb_usb_device *d,
225 struct input_dev *input_dev)
227 int err, rc_interval;
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);
237 if (!d->props.rc.core.rc_query || d->props.rc.core.bulk_mode)
240 /* Polling mode - initialize a work queue for handling it */
241 INIT_DELAYED_WORK(&d->rc_query_work, dvb_usb_read_remote_control);
243 rc_interval = d->props.rc.core.rc_interval;
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));
252 int dvb_usb_remote_init(struct dvb_usb_device *d)
254 struct input_dev *input_dev;
257 if (dvb_usb_disable_rc_polling)
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;
267 usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys));
268 strlcat(d->rc_phys, "/ir0", sizeof(d->rc_phys));
270 input_dev = input_allocate_device();
274 input_dev->evbit[0] = BIT_MASK(EV_KEY);
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);
278 input_dev->dev.parent = &d->udev->dev;
280 /* Start the remote-control polling. */
281 if (d->props.rc.legacy.rc_interval < 40)
282 d->props.rc.legacy.rc_interval = 100; /* default */
284 d->rc_input_dev = input_dev;
286 if (d->props.rc.mode == DVB_RC_LEGACY)
287 err = legacy_dvb_usb_remote_init(d, input_dev);
289 err = rc_core_dvb_usb_remote_init(d, input_dev);
293 d->state |= DVB_USB_STATE_REMOTE;
298 int dvb_usb_remote_exit(struct dvb_usb_device *d)
300 if (d->state & DVB_USB_STATE_REMOTE) {
301 cancel_rearming_delayed_work(&d->rc_query_work);
302 flush_scheduled_work();
303 if (d->props.rc.mode == DVB_RC_LEGACY)
304 input_unregister_device(d->rc_input_dev);
306 ir_input_unregister(d->rc_input_dev);
308 d->state &= ~DVB_USB_STATE_REMOTE;
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)
319 struct ir_scancode *keymap = d->props.rc.legacy.rc_key_map;
321 *state = REMOTE_NO_KEY_PRESSED;
323 case DVB_USB_RC_NEC_EMPTY:
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");
331 /* See if we can match the raw key code. */
332 for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++)
333 if (rc5_custom(&keymap[i]) == keybuf[1] &&
334 rc5_data(&keymap[i]) == keybuf[3]) {
335 *event = keymap[i].keycode;
336 *state = REMOTE_KEY_PRESSED;
339 deb_err("key mapping failed - no appropriate key found in keymapping\n");
341 case DVB_USB_RC_NEC_KEY_REPEATED:
342 *state = REMOTE_KEY_REPEAT;
345 deb_err("unknown type of remote status: %d\n",keybuf[0]);
350 EXPORT_SYMBOL(dvb_usb_nec_rc_key_to_event);