← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/media/dvb/dvb-usb/dvb-usb-remote.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/dvb/dvb-usb/dvb-usb-remote.c
8
8
#include "dvb-usb-common.h"
9
9
#include <linux/usb/input.h>
10
10
 
 
11
static unsigned int
 
12
legacy_dvb_usb_get_keymap_index(const struct input_keymap_entry *ke,
 
13
                                struct rc_map_table *keymap,
 
14
                                unsigned int keymap_size)
 
15
{
 
16
        unsigned int index;
 
17
        unsigned int scancode;
 
18
 
 
19
        if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
 
20
                index = ke->index;
 
21
        } else {
 
22
                if (input_scancode_to_scalar(ke, &scancode))
 
23
                        return keymap_size;
 
24
 
 
25
                /* See if we can match the raw key code. */
 
26
                for (index = 0; index < keymap_size; index++)
 
27
                        if (keymap[index].scancode == scancode)
 
28
                                break;
 
29
 
 
30
                /* See if there is an unused hole in the map */
 
31
                if (index >= keymap_size) {
 
32
                        for (index = 0; index < keymap_size; index++) {
 
33
                                if (keymap[index].keycode == KEY_RESERVED ||
 
34
                                    keymap[index].keycode == KEY_UNKNOWN) {
 
35
                                        break;
 
36
                                }
 
37
                        }
 
38
                }
 
39
        }
 
40
 
 
41
        return index;
 
42
}
 
43
 
11
44
static int legacy_dvb_usb_getkeycode(struct input_dev *dev,
12
 
                                unsigned int scancode, unsigned int *keycode)
 
45
                                     struct input_keymap_entry *ke)
13
46
{
14
47
        struct dvb_usb_device *d = input_get_drvdata(dev);
15
 
 
16
48
        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
17
 
        int i;
18
 
 
19
 
        /* See if we can match the raw key code. */
20
 
        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++)
21
 
                if (keymap[i].scancode == scancode) {
22
 
                        *keycode = keymap[i].keycode;
23
 
                        return 0;
24
 
                }
25
 
 
26
 
        /*
27
 
         * If is there extra space, returns KEY_RESERVED,
28
 
         * otherwise, input core won't let legacy_dvb_usb_setkeycode
29
 
         * to work
30
 
         */
31
 
        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++)
32
 
                if (keymap[i].keycode == KEY_RESERVED ||
33
 
                    keymap[i].keycode == KEY_UNKNOWN) {
34
 
                        *keycode = KEY_RESERVED;
35
 
                        return 0;
36
 
                }
37
 
 
38
 
        return -EINVAL;
 
49
        unsigned int keymap_size = d->props.rc.legacy.rc_map_size;
 
50
        unsigned int index;
 
51
 
 
52
        index = legacy_dvb_usb_get_keymap_index(ke, keymap, keymap_size);
 
53
        if (index >= keymap_size)
 
54
                return -EINVAL;
 
55
 
 
56
        ke->keycode = keymap[index].keycode;
 
57
        if (ke->keycode == KEY_UNKNOWN)
 
58
                ke->keycode = KEY_RESERVED;
 
59
        ke->len = sizeof(keymap[index].scancode);
 
60
        memcpy(&ke->scancode, &keymap[index].scancode, ke->len);
 
61
        ke->index = index;
 
62
 
 
63
        return 0;
39
64
}
40
65
 
41
66
static int legacy_dvb_usb_setkeycode(struct input_dev *dev,
42
 
                                unsigned int scancode, unsigned int keycode)
 
67
                                     const struct input_keymap_entry *ke,
 
68
                                     unsigned int *old_keycode)
43
69
{
44
70
        struct dvb_usb_device *d = input_get_drvdata(dev);
45
 
 
46
71
        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
47
 
        int i;
48
 
 
49
 
        /* Search if it is replacing an existing keycode */
50
 
        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++)
51
 
                if (keymap[i].scancode == scancode) {
52
 
                        keymap[i].keycode = keycode;
53
 
                        return 0;
54
 
                }
55
 
 
56
 
        /* Search if is there a clean entry. If so, use it */
57
 
        for (i = 0; i < d->props.rc.legacy.rc_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;
62
 
                        return 0;
63
 
                }
64
 
 
 
72
        unsigned int keymap_size = d->props.rc.legacy.rc_map_size;
 
73
        unsigned int index;
 
74
 
 
75
        index = legacy_dvb_usb_get_keymap_index(ke, keymap, keymap_size);
65
76
        /*
66
77
         * FIXME: Currently, it is not possible to increase the size of
67
78
         * scancode table. For it to happen, one possibility
69
80
         * copying data, appending the new key on it, and freeing
70
81
         * the old one - or maybe just allocating some spare space
71
82
         */
72
 
 
73
 
        return -EINVAL;
 
83
        if (index >= keymap_size)
 
84
                return -EINVAL;
 
85
 
 
86
        *old_keycode = keymap[index].keycode;
 
87
        keymap->keycode = ke->keycode;
 
88
        __set_bit(ke->keycode, dev->keybit);
 
89
 
 
90
        if (*old_keycode != KEY_RESERVED) {
 
91
                __clear_bit(*old_keycode, dev->keybit);
 
92
                for (index = 0; index < keymap_size; index++) {
 
93
                        if (keymap[index].keycode == *old_keycode) {
 
94
                                __set_bit(*old_keycode, dev->keybit);
 
95
                                break;
 
96
                        }
 
97
                }
 
98
        }
 
99
 
 
100
        return 0;
74
101
}
75
102
 
76
103
/* Remote-control poll function - called every dib->rc_query_interval ms to see
246
273
        dev->map_name = d->props.rc.core.rc_codes;
247
274
        dev->change_protocol = d->props.rc.core.change_protocol;
248
275
        dev->allowed_protos = d->props.rc.core.allowed_protos;
249
 
        dev->driver_type = RC_DRIVER_SCANCODE;
 
276
        dev->driver_type = d->props.rc.core.driver_type;
250
277
        usb_to_input_id(d->udev, &dev->input_id);
251
278
        dev->input_name = "IR-receiver inside an USB DVB receiver";
252
279
        dev->input_phys = d->rc_phys;