[media] dvb_usb_v2: remote controller

* remove old legacy code totally
* move default RC keymap definition the the (struct dvb_usb_driver_info)

Signed-off-by: Antti Palosaari <crope@iki.fi>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

1 files changed, 17 insertions, 261 deletions

diff --git a/drivers/media/dvb/dvb-usb/dvb_usb_remote.c b/drivers/media/dvb/dvb-usb/dvb_usb_remote.c
index b445990644a..b8d2cb193bb 100644
--- a/drivers/media/dvb/dvb-usb/dvb_usb_remote.c
+++ b/drivers/media/dvb/dvb-usb/dvb_usb_remote.c
@@ -9,200 +9,6 @@
 #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;
-        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;
-        }
-
-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.
  *
@@ -220,16 +26,16 @@ static void dvb_usb_read_remote_control(struct work_struct *work)
         /* 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)
+        if (dvb_usb_disable_rc_polling || d->props.rc.bulk_mode)
                 return;
 
-        err = d->props.rc.core.rc_query(d);
+        err = d->props.rc.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));
+                              msecs_to_jiffies(d->props.rc.rc_interval));
 }
 
 static int rc_core_dvb_usb_remote_init(struct dvb_usb_device *d)
@@ -241,17 +47,21 @@ static int rc_core_dvb_usb_remote_init(struct dvb_usb_device *d)
         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 = d->props.rc.core.driver_type;
+        dev->driver_name = d->props.rc.module_name;
+        dev->map_name = d->rc_map;
+        dev->change_protocol = d->props.rc.change_protocol;
+        dev->allowed_protos = d->props.rc.allowed_protos;
+        dev->driver_type = d->props.rc.driver_type;
         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;
 
+        /* leave remote controller enabled even there is no default map */
+        if (dev->map_name == NULL)
+                dev->map_name = RC_MAP_EMPTY;
+
         err = rc_register_device(dev);
         if (err < 0) {
                 rc_free_device(dev);
@@ -261,13 +71,13 @@ static int rc_core_dvb_usb_remote_init(struct dvb_usb_device *d)
         d->input_dev = NULL;
         d->rc_dev = dev;
 
-        if (!d->props.rc.core.rc_query || d->props.rc.core.bulk_mode)
+        if (!d->props.rc.rc_query || d->props.rc.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;
+        rc_interval = d->props.rc.rc_interval;
 
         info("schedule remote query interval to %d msecs.", rc_interval);
         schedule_delayed_work(&d->rc_query_work,
@@ -283,24 +93,14 @@ int dvb_usb_remote_init(struct dvb_usb_device *d)
         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
+        if (d->props.rc.module_name == NULL)
                 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);
+        err = rc_core_dvb_usb_remote_init(d);
         if (err)
                 return err;
 
@@ -313,52 +113,8 @@ 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);
+                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_usbv2_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_usbv2_nec_rc_key_to_event);