blob: f57cd5677ac27c4bee3ebbbbfda25997585d6f1b [file] [log] [blame]
David Härdeman829ba9f2010-11-19 20:43:27 -03001/* rc-main.c - Remote Controller core module
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -03002 *
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03003 * Copyright (C) 2009-2010 by Mauro Carvalho Chehab <mchehab@redhat.com>
Mauro Carvalho Chehab446e4a62009-12-11 08:34:07 -03004 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation version 2 of the License.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -030013 */
14
Mauro Carvalho Chehab6bda9642010-11-17 13:28:38 -030015#include <media/rc-core.h>
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030016#include <linux/spinlock.h>
17#include <linux/delay.h>
Mauro Carvalho Chehab882ead32009-12-29 10:37:38 -030018#include <linux/input.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090019#include <linux/slab.h>
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -030020#include <linux/device.h>
Mauro Carvalho Chehabf62de672010-11-09 23:09:57 -030021#include "rc-core-priv.h"
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -030022
David Härdemanb3074c02010-04-02 15:58:28 -030023/* Sizes are in bytes, 256 bytes allows for 32 entries on x64 */
24#define IR_TAB_MIN_SIZE 256
25#define IR_TAB_MAX_SIZE 8192
Mauro Carvalho Chehabf6fc5042009-11-29 11:08:02 -030026
David Härdemana374fef2010-04-02 15:58:29 -030027/* FIXME: IR_KEYPRESS_TIMEOUT should be protocol specific */
28#define IR_KEYPRESS_TIMEOUT 250
29
David Härdeman4c7b3552010-11-10 11:04:19 -030030/* Used to keep track of known keymaps */
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030031static LIST_HEAD(rc_map_list);
32static DEFINE_SPINLOCK(rc_map_lock);
33
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -030034static struct rc_map_list *seek_rc_map(const char *name)
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030035{
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -030036 struct rc_map_list *map = NULL;
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030037
38 spin_lock(&rc_map_lock);
39 list_for_each_entry(map, &rc_map_list, list) {
40 if (!strcmp(name, map->map.name)) {
41 spin_unlock(&rc_map_lock);
42 return map;
43 }
44 }
45 spin_unlock(&rc_map_lock);
46
47 return NULL;
48}
49
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -030050struct rc_map *rc_map_get(const char *name)
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030051{
52
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -030053 struct rc_map_list *map;
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030054
55 map = seek_rc_map(name);
56#ifdef MODULE
57 if (!map) {
58 int rc = request_module(name);
59 if (rc < 0) {
60 printk(KERN_ERR "Couldn't load IR keymap %s\n", name);
61 return NULL;
62 }
63 msleep(20); /* Give some time for IR to register */
64
65 map = seek_rc_map(name);
66 }
67#endif
68 if (!map) {
69 printk(KERN_ERR "IR keymap %s not found\n", name);
70 return NULL;
71 }
72
73 printk(KERN_INFO "Registered IR keymap %s\n", map->map.name);
74
75 return &map->map;
76}
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -030077EXPORT_SYMBOL_GPL(rc_map_get);
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030078
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -030079int rc_map_register(struct rc_map_list *map)
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030080{
81 spin_lock(&rc_map_lock);
82 list_add_tail(&map->list, &rc_map_list);
83 spin_unlock(&rc_map_lock);
84 return 0;
85}
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -030086EXPORT_SYMBOL_GPL(rc_map_register);
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030087
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -030088void rc_map_unregister(struct rc_map_list *map)
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030089{
90 spin_lock(&rc_map_lock);
91 list_del(&map->list);
92 spin_unlock(&rc_map_lock);
93}
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -030094EXPORT_SYMBOL_GPL(rc_map_unregister);
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030095
96
Mauro Carvalho Chehab2f4f58d2010-11-17 15:46:09 -030097static struct rc_map_table empty[] = {
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -030098 { 0x2a, KEY_COFFEE },
99};
100
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -0300101static struct rc_map_list empty_map = {
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -0300102 .map = {
103 .scan = empty,
104 .size = ARRAY_SIZE(empty),
Mauro Carvalho Chehab52b66142010-11-17 14:20:52 -0300105 .rc_type = RC_TYPE_UNKNOWN, /* Legacy IR type */
Mauro Carvalho Chehab631493e2010-11-09 23:44:27 -0300106 .name = RC_MAP_EMPTY,
107 }
108};
109
Mauro Carvalho Chehabf6fc5042009-11-29 11:08:02 -0300110/**
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700111 * ir_create_table() - initializes a scancode table
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300112 * @rc_map: the rc_map to initialize
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700113 * @name: name to assign to the table
Mauro Carvalho Chehab52b66142010-11-17 14:20:52 -0300114 * @rc_type: ir type to assign to the new table
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700115 * @size: initial size of the table
116 * @return: zero on success or a negative error code
117 *
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300118 * This routine will initialize the rc_map and will allocate
David Härdemand8b4b582010-10-29 16:08:23 -0300119 * memory to hold at least the specified number of elements.
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700120 */
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300121static int ir_create_table(struct rc_map *rc_map,
Mauro Carvalho Chehab52b66142010-11-17 14:20:52 -0300122 const char *name, u64 rc_type, size_t size)
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700123{
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300124 rc_map->name = name;
125 rc_map->rc_type = rc_type;
Mauro Carvalho Chehab2f4f58d2010-11-17 15:46:09 -0300126 rc_map->alloc = roundup_pow_of_two(size * sizeof(struct rc_map_table));
127 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300128 rc_map->scan = kmalloc(rc_map->alloc, GFP_KERNEL);
129 if (!rc_map->scan)
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700130 return -ENOMEM;
131
132 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300133 rc_map->size, rc_map->alloc);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700134 return 0;
135}
136
137/**
138 * ir_free_table() - frees memory allocated by a scancode table
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300139 * @rc_map: the table whose mappings need to be freed
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700140 *
141 * This routine will free memory alloctaed for key mappings used by given
142 * scancode table.
143 */
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300144static void ir_free_table(struct rc_map *rc_map)
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700145{
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300146 rc_map->size = 0;
147 kfree(rc_map->scan);
148 rc_map->scan = NULL;
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700149}
150
151/**
David Härdemanb3074c02010-04-02 15:58:28 -0300152 * ir_resize_table() - resizes a scancode table if necessary
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300153 * @rc_map: the rc_map to resize
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700154 * @gfp_flags: gfp flags to use when allocating memory
David Härdemanb3074c02010-04-02 15:58:28 -0300155 * @return: zero on success or a negative error code
Mauro Carvalho Chehab7fee03e2009-12-02 15:56:47 -0300156 *
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300157 * This routine will shrink the rc_map if it has lots of
David Härdemanb3074c02010-04-02 15:58:28 -0300158 * unused entries and grow it if it is full.
Mauro Carvalho Chehab7fee03e2009-12-02 15:56:47 -0300159 */
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300160static int ir_resize_table(struct rc_map *rc_map, gfp_t gfp_flags)
David Härdemanb3074c02010-04-02 15:58:28 -0300161{
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300162 unsigned int oldalloc = rc_map->alloc;
David Härdemanb3074c02010-04-02 15:58:28 -0300163 unsigned int newalloc = oldalloc;
Mauro Carvalho Chehab2f4f58d2010-11-17 15:46:09 -0300164 struct rc_map_table *oldscan = rc_map->scan;
165 struct rc_map_table *newscan;
David Härdemanb3074c02010-04-02 15:58:28 -0300166
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300167 if (rc_map->size == rc_map->len) {
David Härdemanb3074c02010-04-02 15:58:28 -0300168 /* All entries in use -> grow keytable */
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300169 if (rc_map->alloc >= IR_TAB_MAX_SIZE)
David Härdemanb3074c02010-04-02 15:58:28 -0300170 return -ENOMEM;
171
172 newalloc *= 2;
173 IR_dprintk(1, "Growing table to %u bytes\n", newalloc);
174 }
175
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300176 if ((rc_map->len * 3 < rc_map->size) && (oldalloc > IR_TAB_MIN_SIZE)) {
David Härdemanb3074c02010-04-02 15:58:28 -0300177 /* Less than 1/3 of entries in use -> shrink keytable */
178 newalloc /= 2;
179 IR_dprintk(1, "Shrinking table to %u bytes\n", newalloc);
180 }
181
182 if (newalloc == oldalloc)
183 return 0;
184
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700185 newscan = kmalloc(newalloc, gfp_flags);
David Härdemanb3074c02010-04-02 15:58:28 -0300186 if (!newscan) {
187 IR_dprintk(1, "Failed to kmalloc %u bytes\n", newalloc);
188 return -ENOMEM;
189 }
190
Mauro Carvalho Chehab2f4f58d2010-11-17 15:46:09 -0300191 memcpy(newscan, rc_map->scan, rc_map->len * sizeof(struct rc_map_table));
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300192 rc_map->scan = newscan;
193 rc_map->alloc = newalloc;
Mauro Carvalho Chehab2f4f58d2010-11-17 15:46:09 -0300194 rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
David Härdemanb3074c02010-04-02 15:58:28 -0300195 kfree(oldscan);
196 return 0;
197}
198
199/**
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700200 * ir_update_mapping() - set a keycode in the scancode->keycode table
David Härdemand8b4b582010-10-29 16:08:23 -0300201 * @dev: the struct rc_dev device descriptor
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300202 * @rc_map: scancode table to be adjusted
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700203 * @index: index of the mapping that needs to be updated
204 * @keycode: the desired keycode
205 * @return: previous keycode assigned to the mapping
David Härdemanb3074c02010-04-02 15:58:28 -0300206 *
David Härdemand8b4b582010-10-29 16:08:23 -0300207 * This routine is used to update scancode->keycode mapping at given
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700208 * position.
David Härdemanb3074c02010-04-02 15:58:28 -0300209 */
David Härdemand8b4b582010-10-29 16:08:23 -0300210static unsigned int ir_update_mapping(struct rc_dev *dev,
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300211 struct rc_map *rc_map,
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700212 unsigned int index,
213 unsigned int new_keycode)
214{
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300215 int old_keycode = rc_map->scan[index].keycode;
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700216 int i;
217
218 /* Did the user wish to remove the mapping? */
219 if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) {
220 IR_dprintk(1, "#%d: Deleting scan 0x%04x\n",
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300221 index, rc_map->scan[index].scancode);
222 rc_map->len--;
223 memmove(&rc_map->scan[index], &rc_map->scan[index+ 1],
Mauro Carvalho Chehab2f4f58d2010-11-17 15:46:09 -0300224 (rc_map->len - index) * sizeof(struct rc_map_table));
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700225 } else {
226 IR_dprintk(1, "#%d: %s scan 0x%04x with key 0x%04x\n",
227 index,
228 old_keycode == KEY_RESERVED ? "New" : "Replacing",
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300229 rc_map->scan[index].scancode, new_keycode);
230 rc_map->scan[index].keycode = new_keycode;
David Härdemand8b4b582010-10-29 16:08:23 -0300231 __set_bit(new_keycode, dev->input_dev->keybit);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700232 }
233
234 if (old_keycode != KEY_RESERVED) {
235 /* A previous mapping was updated... */
David Härdemand8b4b582010-10-29 16:08:23 -0300236 __clear_bit(old_keycode, dev->input_dev->keybit);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700237 /* ... but another scancode might use the same keycode */
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300238 for (i = 0; i < rc_map->len; i++) {
239 if (rc_map->scan[i].keycode == old_keycode) {
David Härdemand8b4b582010-10-29 16:08:23 -0300240 __set_bit(old_keycode, dev->input_dev->keybit);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700241 break;
242 }
243 }
244
245 /* Possibly shrink the keytable, failure is not a problem */
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300246 ir_resize_table(rc_map, GFP_ATOMIC);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700247 }
248
249 return old_keycode;
250}
251
252/**
David Härdeman4c7b3552010-11-10 11:04:19 -0300253 * ir_establish_scancode() - set a keycode in the scancode->keycode table
David Härdemand8b4b582010-10-29 16:08:23 -0300254 * @dev: the struct rc_dev device descriptor
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300255 * @rc_map: scancode table to be searched
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700256 * @scancode: the desired scancode
257 * @resize: controls whether we allowed to resize the table to
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300258 * accommodate not yet present scancodes
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700259 * @return: index of the mapping containing scancode in question
260 * or -1U in case of failure.
261 *
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300262 * This routine is used to locate given scancode in rc_map.
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700263 * If scancode is not yet present the routine will allocate a new slot
264 * for it.
265 */
David Härdemand8b4b582010-10-29 16:08:23 -0300266static unsigned int ir_establish_scancode(struct rc_dev *dev,
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300267 struct rc_map *rc_map,
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700268 unsigned int scancode,
269 bool resize)
David Härdemanb3074c02010-04-02 15:58:28 -0300270{
271 unsigned int i;
Mauro Carvalho Chehab9dfe4e82010-04-04 14:06:55 -0300272
273 /*
274 * Unfortunately, some hardware-based IR decoders don't provide
275 * all bits for the complete IR code. In general, they provide only
276 * the command part of the IR code. Yet, as it is possible to replace
277 * the provided IR with another one, it is needed to allow loading
David Härdemand8b4b582010-10-29 16:08:23 -0300278 * IR tables from other remotes. So, we support specifying a mask to
279 * indicate the valid bits of the scancodes.
Mauro Carvalho Chehab9dfe4e82010-04-04 14:06:55 -0300280 */
David Härdemand8b4b582010-10-29 16:08:23 -0300281 if (dev->scanmask)
282 scancode &= dev->scanmask;
David Härdemanb3074c02010-04-02 15:58:28 -0300283
284 /* First check if we already have a mapping for this ir command */
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300285 for (i = 0; i < rc_map->len; i++) {
286 if (rc_map->scan[i].scancode == scancode)
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700287 return i;
288
David Härdemanb3074c02010-04-02 15:58:28 -0300289 /* Keytable is sorted from lowest to highest scancode */
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300290 if (rc_map->scan[i].scancode >= scancode)
David Härdemanb3074c02010-04-02 15:58:28 -0300291 break;
David Härdemanb3074c02010-04-02 15:58:28 -0300292 }
293
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700294 /* No previous mapping found, we might need to grow the table */
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300295 if (rc_map->size == rc_map->len) {
296 if (!resize || ir_resize_table(rc_map, GFP_ATOMIC))
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700297 return -1U;
298 }
David Härdemanb3074c02010-04-02 15:58:28 -0300299
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700300 /* i is the proper index to insert our new keycode */
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300301 if (i < rc_map->len)
302 memmove(&rc_map->scan[i + 1], &rc_map->scan[i],
Mauro Carvalho Chehab2f4f58d2010-11-17 15:46:09 -0300303 (rc_map->len - i) * sizeof(struct rc_map_table));
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300304 rc_map->scan[i].scancode = scancode;
305 rc_map->scan[i].keycode = KEY_RESERVED;
306 rc_map->len++;
David Härdemanb3074c02010-04-02 15:58:28 -0300307
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700308 return i;
David Härdemanb3074c02010-04-02 15:58:28 -0300309}
310
311/**
312 * ir_setkeycode() - set a keycode in the scancode->keycode table
David Härdemand8b4b582010-10-29 16:08:23 -0300313 * @idev: the struct input_dev device descriptor
David Härdemanb3074c02010-04-02 15:58:28 -0300314 * @scancode: the desired scancode
315 * @keycode: result
316 * @return: -EINVAL if the keycode could not be inserted, otherwise zero.
317 *
318 * This routine is used to handle evdev EVIOCSKEY ioctl.
319 */
David Härdemand8b4b582010-10-29 16:08:23 -0300320static int ir_setkeycode(struct input_dev *idev,
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700321 const struct input_keymap_entry *ke,
322 unsigned int *old_keycode)
Mauro Carvalho Chehab7fee03e2009-12-02 15:56:47 -0300323{
David Härdemand8b4b582010-10-29 16:08:23 -0300324 struct rc_dev *rdev = input_get_drvdata(idev);
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300325 struct rc_map *rc_map = &rdev->rc_map;
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700326 unsigned int index;
327 unsigned int scancode;
Mauro Carvalho Chehabdea8a392010-11-29 07:46:13 -0300328 int retval = 0;
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700329 unsigned long flags;
Mauro Carvalho Chehab7fee03e2009-12-02 15:56:47 -0300330
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300331 spin_lock_irqsave(&rc_map->lock, flags);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700332
333 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
334 index = ke->index;
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300335 if (index >= rc_map->len) {
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700336 retval = -EINVAL;
337 goto out;
338 }
339 } else {
340 retval = input_scancode_to_scalar(ke, &scancode);
341 if (retval)
342 goto out;
343
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300344 index = ir_establish_scancode(rdev, rc_map, scancode, true);
345 if (index >= rc_map->len) {
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700346 retval = -ENOMEM;
347 goto out;
348 }
349 }
350
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300351 *old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700352
353out:
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300354 spin_unlock_irqrestore(&rc_map->lock, flags);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700355 return retval;
Mauro Carvalho Chehab7fee03e2009-12-02 15:56:47 -0300356}
357
358/**
David Härdemanb3074c02010-04-02 15:58:28 -0300359 * ir_setkeytable() - sets several entries in the scancode->keycode table
David Härdemand8b4b582010-10-29 16:08:23 -0300360 * @dev: the struct rc_dev device descriptor
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300361 * @to: the struct rc_map to copy entries to
362 * @from: the struct rc_map to copy entries from
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700363 * @return: -ENOMEM if all keycodes could not be inserted, otherwise zero.
Mauro Carvalho Chehabf6fc5042009-11-29 11:08:02 -0300364 *
David Härdemanb3074c02010-04-02 15:58:28 -0300365 * This routine is used to handle table initialization.
Mauro Carvalho Chehabf6fc5042009-11-29 11:08:02 -0300366 */
David Härdemand8b4b582010-10-29 16:08:23 -0300367static int ir_setkeytable(struct rc_dev *dev,
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300368 const struct rc_map *from)
Mauro Carvalho Chehabf6fc5042009-11-29 11:08:02 -0300369{
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300370 struct rc_map *rc_map = &dev->rc_map;
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700371 unsigned int i, index;
372 int rc;
Mauro Carvalho Chehabf6fc5042009-11-29 11:08:02 -0300373
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300374 rc = ir_create_table(rc_map, from->name,
Mauro Carvalho Chehab52b66142010-11-17 14:20:52 -0300375 from->rc_type, from->size);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700376 if (rc)
377 return rc;
378
379 IR_dprintk(1, "Allocated space for %u keycode entries (%u bytes)\n",
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300380 rc_map->size, rc_map->alloc);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700381
David Härdemanb3074c02010-04-02 15:58:28 -0300382 for (i = 0; i < from->size; i++) {
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300383 index = ir_establish_scancode(dev, rc_map,
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700384 from->scan[i].scancode, false);
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300385 if (index >= rc_map->len) {
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700386 rc = -ENOMEM;
David Härdemanb3074c02010-04-02 15:58:28 -0300387 break;
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700388 }
389
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300390 ir_update_mapping(dev, rc_map, index,
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700391 from->scan[i].keycode);
Mauro Carvalho Chehabf6fc5042009-11-29 11:08:02 -0300392 }
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700393
394 if (rc)
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300395 ir_free_table(rc_map);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700396
David Härdemanb3074c02010-04-02 15:58:28 -0300397 return rc;
Mauro Carvalho Chehabf6fc5042009-11-29 11:08:02 -0300398}
399
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300400/**
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700401 * ir_lookup_by_scancode() - locate mapping by scancode
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300402 * @rc_map: the struct rc_map to search
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700403 * @scancode: scancode to look for in the table
404 * @return: index in the table, -1U if not found
405 *
406 * This routine performs binary search in RC keykeymap table for
407 * given scancode.
408 */
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300409static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map,
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700410 unsigned int scancode)
411{
David Härdeman0d070252010-10-30 22:17:44 +0200412 int start = 0;
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300413 int end = rc_map->len - 1;
David Härdeman0d070252010-10-30 22:17:44 +0200414 int mid;
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700415
416 while (start <= end) {
417 mid = (start + end) / 2;
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300418 if (rc_map->scan[mid].scancode < scancode)
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700419 start = mid + 1;
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300420 else if (rc_map->scan[mid].scancode > scancode)
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700421 end = mid - 1;
422 else
423 return mid;
424 }
425
426 return -1U;
427}
428
429/**
David Härdemanb3074c02010-04-02 15:58:28 -0300430 * ir_getkeycode() - get a keycode from the scancode->keycode table
David Härdemand8b4b582010-10-29 16:08:23 -0300431 * @idev: the struct input_dev device descriptor
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300432 * @scancode: the desired scancode
David Härdemanb3074c02010-04-02 15:58:28 -0300433 * @keycode: used to return the keycode, if found, or KEY_RESERVED
434 * @return: always returns zero.
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300435 *
436 * This routine is used to handle evdev EVIOCGKEY ioctl.
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300437 */
David Härdemand8b4b582010-10-29 16:08:23 -0300438static int ir_getkeycode(struct input_dev *idev,
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700439 struct input_keymap_entry *ke)
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300440{
David Härdemand8b4b582010-10-29 16:08:23 -0300441 struct rc_dev *rdev = input_get_drvdata(idev);
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300442 struct rc_map *rc_map = &rdev->rc_map;
Mauro Carvalho Chehab2f4f58d2010-11-17 15:46:09 -0300443 struct rc_map_table *entry;
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700444 unsigned long flags;
445 unsigned int index;
446 unsigned int scancode;
447 int retval;
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300448
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300449 spin_lock_irqsave(&rc_map->lock, flags);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700450
451 if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
452 index = ke->index;
453 } else {
454 retval = input_scancode_to_scalar(ke, &scancode);
455 if (retval)
456 goto out;
457
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300458 index = ir_lookup_by_scancode(rc_map, scancode);
Mauro Carvalho Chehabe97f4672009-12-04 17:17:47 -0300459 }
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700460
Dmitry Torokhov54e74b82011-01-28 23:33:29 -0800461 if (index < rc_map->len) {
462 entry = &rc_map->scan[index];
463
464 ke->index = index;
465 ke->keycode = entry->keycode;
466 ke->len = sizeof(entry->scancode);
467 memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode));
468
469 } else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) {
470 /*
471 * We do not really know the valid range of scancodes
472 * so let's respond with KEY_RESERVED to anything we
473 * do not have mapping for [yet].
474 */
475 ke->index = index;
476 ke->keycode = KEY_RESERVED;
477 } else {
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700478 retval = -EINVAL;
479 goto out;
480 }
481
Dmitry Torokhov47c5ba52010-10-31 15:18:42 -0700482 retval = 0;
483
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700484out:
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300485 spin_unlock_irqrestore(&rc_map->lock, flags);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700486 return retval;
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300487}
488
489/**
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300490 * rc_g_keycode_from_table() - gets the keycode that corresponds to a scancode
David Härdemand8b4b582010-10-29 16:08:23 -0300491 * @dev: the struct rc_dev descriptor of the device
492 * @scancode: the scancode to look for
493 * @return: the corresponding keycode, or KEY_RESERVED
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300494 *
David Härdemand8b4b582010-10-29 16:08:23 -0300495 * This routine is used by drivers which need to convert a scancode to a
496 * keycode. Normally it should not be used since drivers should have no
497 * interest in keycodes.
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300498 */
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300499u32 rc_g_keycode_from_table(struct rc_dev *dev, u32 scancode)
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300500{
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300501 struct rc_map *rc_map = &dev->rc_map;
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700502 unsigned int keycode;
503 unsigned int index;
504 unsigned long flags;
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300505
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300506 spin_lock_irqsave(&rc_map->lock, flags);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700507
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300508 index = ir_lookup_by_scancode(rc_map, scancode);
509 keycode = index < rc_map->len ?
510 rc_map->scan[index].keycode : KEY_RESERVED;
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700511
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300512 spin_unlock_irqrestore(&rc_map->lock, flags);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700513
Mauro Carvalho Chehab35438942010-04-03 16:53:16 -0300514 if (keycode != KEY_RESERVED)
515 IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n",
David Härdemand8b4b582010-10-29 16:08:23 -0300516 dev->input_name, scancode, keycode);
Dmitry Torokhov9f470092010-09-09 21:59:11 -0700517
David Härdemanb3074c02010-04-02 15:58:28 -0300518 return keycode;
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300519}
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300520EXPORT_SYMBOL_GPL(rc_g_keycode_from_table);
Mauro Carvalho Chehabef53a112009-11-27 22:01:23 -0300521
522/**
David Härdeman62c65032010-10-29 16:08:07 -0300523 * ir_do_keyup() - internal function to signal the release of a keypress
David Härdemand8b4b582010-10-29 16:08:23 -0300524 * @dev: the struct rc_dev descriptor of the device
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300525 *
David Härdeman62c65032010-10-29 16:08:07 -0300526 * This function is used internally to release a keypress, it must be
527 * called with keylock held.
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300528 */
David Härdemand8b4b582010-10-29 16:08:23 -0300529static void ir_do_keyup(struct rc_dev *dev)
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300530{
David Härdemand8b4b582010-10-29 16:08:23 -0300531 if (!dev->keypressed)
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300532 return;
533
David Härdemand8b4b582010-10-29 16:08:23 -0300534 IR_dprintk(1, "keyup key 0x%04x\n", dev->last_keycode);
535 input_report_key(dev->input_dev, dev->last_keycode, 0);
536 input_sync(dev->input_dev);
537 dev->keypressed = false;
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300538}
David Härdeman62c65032010-10-29 16:08:07 -0300539
540/**
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300541 * rc_keyup() - signals the release of a keypress
David Härdemand8b4b582010-10-29 16:08:23 -0300542 * @dev: the struct rc_dev descriptor of the device
David Härdeman62c65032010-10-29 16:08:07 -0300543 *
544 * This routine is used to signal that a key has been released on the
545 * remote control.
546 */
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300547void rc_keyup(struct rc_dev *dev)
David Härdeman62c65032010-10-29 16:08:07 -0300548{
549 unsigned long flags;
David Härdeman62c65032010-10-29 16:08:07 -0300550
David Härdemand8b4b582010-10-29 16:08:23 -0300551 spin_lock_irqsave(&dev->keylock, flags);
552 ir_do_keyup(dev);
553 spin_unlock_irqrestore(&dev->keylock, flags);
David Härdeman62c65032010-10-29 16:08:07 -0300554}
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300555EXPORT_SYMBOL_GPL(rc_keyup);
David Härdemana374fef2010-04-02 15:58:29 -0300556
557/**
558 * ir_timer_keyup() - generates a keyup event after a timeout
David Härdemand8b4b582010-10-29 16:08:23 -0300559 * @cookie: a pointer to the struct rc_dev for the device
David Härdemana374fef2010-04-02 15:58:29 -0300560 *
561 * This routine will generate a keyup event some time after a keydown event
562 * is generated when no further activity has been detected.
563 */
564static void ir_timer_keyup(unsigned long cookie)
565{
David Härdemand8b4b582010-10-29 16:08:23 -0300566 struct rc_dev *dev = (struct rc_dev *)cookie;
David Härdemana374fef2010-04-02 15:58:29 -0300567 unsigned long flags;
568
569 /*
570 * ir->keyup_jiffies is used to prevent a race condition if a
571 * hardware interrupt occurs at this point and the keyup timer
572 * event is moved further into the future as a result.
573 *
574 * The timer will then be reactivated and this function called
575 * again in the future. We need to exit gracefully in that case
576 * to allow the input subsystem to do its auto-repeat magic or
577 * a keyup event might follow immediately after the keydown.
578 */
David Härdemand8b4b582010-10-29 16:08:23 -0300579 spin_lock_irqsave(&dev->keylock, flags);
580 if (time_is_before_eq_jiffies(dev->keyup_jiffies))
581 ir_do_keyup(dev);
582 spin_unlock_irqrestore(&dev->keylock, flags);
David Härdemana374fef2010-04-02 15:58:29 -0300583}
584
585/**
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300586 * rc_repeat() - signals that a key is still pressed
David Härdemand8b4b582010-10-29 16:08:23 -0300587 * @dev: the struct rc_dev descriptor of the device
David Härdemana374fef2010-04-02 15:58:29 -0300588 *
589 * This routine is used by IR decoders when a repeat message which does
590 * not include the necessary bits to reproduce the scancode has been
591 * received.
592 */
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300593void rc_repeat(struct rc_dev *dev)
David Härdemana374fef2010-04-02 15:58:29 -0300594{
595 unsigned long flags;
David Härdemana374fef2010-04-02 15:58:29 -0300596
David Härdemand8b4b582010-10-29 16:08:23 -0300597 spin_lock_irqsave(&dev->keylock, flags);
David Härdemana374fef2010-04-02 15:58:29 -0300598
David Härdemand8b4b582010-10-29 16:08:23 -0300599 input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode);
Maxim Levitskyed4d3872010-07-31 11:59:24 -0300600
David Härdemand8b4b582010-10-29 16:08:23 -0300601 if (!dev->keypressed)
David Härdemana374fef2010-04-02 15:58:29 -0300602 goto out;
603
David Härdemand8b4b582010-10-29 16:08:23 -0300604 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
605 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
David Härdemana374fef2010-04-02 15:58:29 -0300606
607out:
David Härdemand8b4b582010-10-29 16:08:23 -0300608 spin_unlock_irqrestore(&dev->keylock, flags);
David Härdemana374fef2010-04-02 15:58:29 -0300609}
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300610EXPORT_SYMBOL_GPL(rc_repeat);
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300611
612/**
David Härdeman62c65032010-10-29 16:08:07 -0300613 * ir_do_keydown() - internal function to process a keypress
David Härdemand8b4b582010-10-29 16:08:23 -0300614 * @dev: the struct rc_dev descriptor of the device
David Härdeman62c65032010-10-29 16:08:07 -0300615 * @scancode: the scancode of the keypress
616 * @keycode: the keycode of the keypress
617 * @toggle: the toggle value of the keypress
618 *
619 * This function is used internally to register a keypress, it must be
620 * called with keylock held.
621 */
David Härdemand8b4b582010-10-29 16:08:23 -0300622static void ir_do_keydown(struct rc_dev *dev, int scancode,
David Härdeman62c65032010-10-29 16:08:07 -0300623 u32 keycode, u8 toggle)
624{
David Härdemand8b4b582010-10-29 16:08:23 -0300625 input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
David Härdeman62c65032010-10-29 16:08:07 -0300626
627 /* Repeat event? */
David Härdemand8b4b582010-10-29 16:08:23 -0300628 if (dev->keypressed &&
629 dev->last_scancode == scancode &&
630 dev->last_toggle == toggle)
David Härdeman62c65032010-10-29 16:08:07 -0300631 return;
632
633 /* Release old keypress */
David Härdemand8b4b582010-10-29 16:08:23 -0300634 ir_do_keyup(dev);
David Härdeman62c65032010-10-29 16:08:07 -0300635
David Härdemand8b4b582010-10-29 16:08:23 -0300636 dev->last_scancode = scancode;
637 dev->last_toggle = toggle;
638 dev->last_keycode = keycode;
David Härdeman62c65032010-10-29 16:08:07 -0300639
640 if (keycode == KEY_RESERVED)
641 return;
642
643 /* Register a keypress */
David Härdemand8b4b582010-10-29 16:08:23 -0300644 dev->keypressed = true;
David Härdeman62c65032010-10-29 16:08:07 -0300645 IR_dprintk(1, "%s: key down event, key 0x%04x, scancode 0x%04x\n",
David Härdemand8b4b582010-10-29 16:08:23 -0300646 dev->input_name, keycode, scancode);
647 input_report_key(dev->input_dev, dev->last_keycode, 1);
648 input_sync(dev->input_dev);
David Härdeman62c65032010-10-29 16:08:07 -0300649}
650
651/**
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300652 * rc_keydown() - generates input event for a key press
David Härdemand8b4b582010-10-29 16:08:23 -0300653 * @dev: the struct rc_dev descriptor of the device
David Härdemana374fef2010-04-02 15:58:29 -0300654 * @scancode: the scancode that we're seeking
655 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
656 * support toggle values, this should be set to zero)
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300657 *
David Härdemand8b4b582010-10-29 16:08:23 -0300658 * This routine is used to signal that a key has been pressed on the
659 * remote control.
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300660 */
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300661void rc_keydown(struct rc_dev *dev, int scancode, u8 toggle)
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300662{
David Härdemana374fef2010-04-02 15:58:29 -0300663 unsigned long flags;
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300664 u32 keycode = rc_g_keycode_from_table(dev, scancode);
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300665
David Härdemand8b4b582010-10-29 16:08:23 -0300666 spin_lock_irqsave(&dev->keylock, flags);
David Härdeman62c65032010-10-29 16:08:07 -0300667 ir_do_keydown(dev, scancode, keycode, toggle);
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300668
David Härdemand8b4b582010-10-29 16:08:23 -0300669 if (dev->keypressed) {
670 dev->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
671 mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
David Härdeman62c65032010-10-29 16:08:07 -0300672 }
David Härdemand8b4b582010-10-29 16:08:23 -0300673 spin_unlock_irqrestore(&dev->keylock, flags);
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300674}
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300675EXPORT_SYMBOL_GPL(rc_keydown);
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300676
David Härdeman62c65032010-10-29 16:08:07 -0300677/**
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300678 * rc_keydown_notimeout() - generates input event for a key press without
David Härdeman62c65032010-10-29 16:08:07 -0300679 * an automatic keyup event at a later time
David Härdemand8b4b582010-10-29 16:08:23 -0300680 * @dev: the struct rc_dev descriptor of the device
David Härdeman62c65032010-10-29 16:08:07 -0300681 * @scancode: the scancode that we're seeking
682 * @toggle: the toggle value (protocol dependent, if the protocol doesn't
683 * support toggle values, this should be set to zero)
684 *
David Härdemand8b4b582010-10-29 16:08:23 -0300685 * This routine is used to signal that a key has been pressed on the
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300686 * remote control. The driver must manually call rc_keyup() at a later stage.
David Härdeman62c65032010-10-29 16:08:07 -0300687 */
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300688void rc_keydown_notimeout(struct rc_dev *dev, int scancode, u8 toggle)
David Härdeman62c65032010-10-29 16:08:07 -0300689{
690 unsigned long flags;
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300691 u32 keycode = rc_g_keycode_from_table(dev, scancode);
David Härdeman62c65032010-10-29 16:08:07 -0300692
David Härdemand8b4b582010-10-29 16:08:23 -0300693 spin_lock_irqsave(&dev->keylock, flags);
David Härdeman62c65032010-10-29 16:08:07 -0300694 ir_do_keydown(dev, scancode, keycode, toggle);
David Härdemand8b4b582010-10-29 16:08:23 -0300695 spin_unlock_irqrestore(&dev->keylock, flags);
David Härdeman62c65032010-10-29 16:08:07 -0300696}
Mauro Carvalho Chehabca866742010-11-17 13:53:11 -0300697EXPORT_SYMBOL_GPL(rc_keydown_notimeout);
David Härdeman62c65032010-10-29 16:08:07 -0300698
David Härdemand8b4b582010-10-29 16:08:23 -0300699static int ir_open(struct input_dev *idev)
Mauro Carvalho Chehab716aab42010-03-31 14:40:35 -0300700{
David Härdemand8b4b582010-10-29 16:08:23 -0300701 struct rc_dev *rdev = input_get_drvdata(idev);
Mauro Carvalho Chehab716aab42010-03-31 14:40:35 -0300702
David Härdemand8b4b582010-10-29 16:08:23 -0300703 return rdev->open(rdev);
Mauro Carvalho Chehab716aab42010-03-31 14:40:35 -0300704}
705
David Härdemand8b4b582010-10-29 16:08:23 -0300706static void ir_close(struct input_dev *idev)
Mauro Carvalho Chehab716aab42010-03-31 14:40:35 -0300707{
David Härdemand8b4b582010-10-29 16:08:23 -0300708 struct rc_dev *rdev = input_get_drvdata(idev);
Mauro Carvalho Chehab716aab42010-03-31 14:40:35 -0300709
Hussam Al-Tayeb88fda562011-02-21 15:20:26 -0300710 if (rdev)
711 rdev->close(rdev);
Mauro Carvalho Chehab716aab42010-03-31 14:40:35 -0300712}
Mauro Carvalho Chehab6660de52010-03-21 12:15:16 -0300713
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300714/* class for /sys/class/rc */
715static char *ir_devnode(struct device *dev, mode_t *mode)
716{
717 return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
718}
719
720static struct class ir_input_class = {
721 .name = "rc",
722 .devnode = ir_devnode,
723};
724
725static struct {
726 u64 type;
727 char *name;
728} proto_names[] = {
Mauro Carvalho Chehab52b66142010-11-17 14:20:52 -0300729 { RC_TYPE_UNKNOWN, "unknown" },
730 { RC_TYPE_RC5, "rc-5" },
731 { RC_TYPE_NEC, "nec" },
732 { RC_TYPE_RC6, "rc-6" },
733 { RC_TYPE_JVC, "jvc" },
734 { RC_TYPE_SONY, "sony" },
735 { RC_TYPE_RC5_SZ, "rc-5-sz" },
736 { RC_TYPE_LIRC, "lirc" },
Jarod Wilsonb3003932011-04-26 12:25:02 -0300737 { RC_TYPE_OTHER, "other" },
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300738};
739
740#define PROTO_NONE "none"
741
742/**
743 * show_protocols() - shows the current IR protocol(s)
David Härdemand8b4b582010-10-29 16:08:23 -0300744 * @device: the device descriptor
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300745 * @mattr: the device attribute struct (unused)
746 * @buf: a pointer to the output buffer
747 *
748 * This routine is a callback routine for input read the IR protocol type(s).
749 * it is trigged by reading /sys/class/rc/rc?/protocols.
750 * It returns the protocol names of supported protocols.
751 * Enabled protocols are printed in brackets.
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300752 *
753 * dev->lock is taken to guard against races between device
754 * registration, store_protocols and show_protocols.
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300755 */
David Härdemand8b4b582010-10-29 16:08:23 -0300756static ssize_t show_protocols(struct device *device,
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300757 struct device_attribute *mattr, char *buf)
758{
David Härdemand8b4b582010-10-29 16:08:23 -0300759 struct rc_dev *dev = to_rc_dev(device);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300760 u64 allowed, enabled;
761 char *tmp = buf;
762 int i;
763
764 /* Device is being removed */
David Härdemand8b4b582010-10-29 16:08:23 -0300765 if (!dev)
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300766 return -EINVAL;
767
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300768 mutex_lock(&dev->lock);
769
David Härdemand8b4b582010-10-29 16:08:23 -0300770 if (dev->driver_type == RC_DRIVER_SCANCODE) {
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300771 enabled = dev->rc_map.rc_type;
David Härdemand8b4b582010-10-29 16:08:23 -0300772 allowed = dev->allowed_protos;
773 } else {
774 enabled = dev->raw->enabled_protocols;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300775 allowed = ir_raw_get_allowed_protocols();
David Härdemand8b4b582010-10-29 16:08:23 -0300776 }
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300777
778 IR_dprintk(1, "allowed - 0x%llx, enabled - 0x%llx\n",
779 (long long)allowed,
780 (long long)enabled);
781
782 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
783 if (allowed & enabled & proto_names[i].type)
784 tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
785 else if (allowed & proto_names[i].type)
786 tmp += sprintf(tmp, "%s ", proto_names[i].name);
787 }
788
789 if (tmp != buf)
790 tmp--;
791 *tmp = '\n';
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300792
793 mutex_unlock(&dev->lock);
794
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300795 return tmp + 1 - buf;
796}
797
798/**
799 * store_protocols() - changes the current IR protocol(s)
David Härdemand8b4b582010-10-29 16:08:23 -0300800 * @device: the device descriptor
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300801 * @mattr: the device attribute struct (unused)
802 * @buf: a pointer to the input buffer
803 * @len: length of the input buffer
804 *
David Härdemand8b4b582010-10-29 16:08:23 -0300805 * This routine is for changing the IR protocol type.
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300806 * It is trigged by writing to /sys/class/rc/rc?/protocols.
807 * Writing "+proto" will add a protocol to the list of enabled protocols.
808 * Writing "-proto" will remove a protocol from the list of enabled protocols.
809 * Writing "proto" will enable only "proto".
810 * Writing "none" will disable all protocols.
811 * Returns -EINVAL if an invalid protocol combination or unknown protocol name
812 * is used, otherwise @len.
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300813 *
814 * dev->lock is taken to guard against races between device
815 * registration, store_protocols and show_protocols.
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300816 */
David Härdemand8b4b582010-10-29 16:08:23 -0300817static ssize_t store_protocols(struct device *device,
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300818 struct device_attribute *mattr,
819 const char *data,
820 size_t len)
821{
David Härdemand8b4b582010-10-29 16:08:23 -0300822 struct rc_dev *dev = to_rc_dev(device);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300823 bool enable, disable;
824 const char *tmp;
825 u64 type;
826 u64 mask;
827 int rc, i, count = 0;
828 unsigned long flags;
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300829 ssize_t ret;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300830
831 /* Device is being removed */
David Härdemand8b4b582010-10-29 16:08:23 -0300832 if (!dev)
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300833 return -EINVAL;
834
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300835 mutex_lock(&dev->lock);
836
David Härdemand8b4b582010-10-29 16:08:23 -0300837 if (dev->driver_type == RC_DRIVER_SCANCODE)
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300838 type = dev->rc_map.rc_type;
David Härdemand8b4b582010-10-29 16:08:23 -0300839 else if (dev->raw)
840 type = dev->raw->enabled_protocols;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300841 else {
842 IR_dprintk(1, "Protocol switching not supported\n");
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300843 ret = -EINVAL;
844 goto out;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300845 }
846
847 while ((tmp = strsep((char **) &data, " \n")) != NULL) {
848 if (!*tmp)
849 break;
850
851 if (*tmp == '+') {
852 enable = true;
853 disable = false;
854 tmp++;
855 } else if (*tmp == '-') {
856 enable = false;
857 disable = true;
858 tmp++;
859 } else {
860 enable = false;
861 disable = false;
862 }
863
864 if (!enable && !disable && !strncasecmp(tmp, PROTO_NONE, sizeof(PROTO_NONE))) {
865 tmp += sizeof(PROTO_NONE);
866 mask = 0;
867 count++;
868 } else {
869 for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
Antti Seppälä0a91be42011-02-13 07:29:15 -0300870 if (!strcasecmp(tmp, proto_names[i].name)) {
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300871 tmp += strlen(proto_names[i].name);
872 mask = proto_names[i].type;
873 break;
874 }
875 }
876 if (i == ARRAY_SIZE(proto_names)) {
877 IR_dprintk(1, "Unknown protocol: '%s'\n", tmp);
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300878 ret = -EINVAL;
879 goto out;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300880 }
881 count++;
882 }
883
884 if (enable)
885 type |= mask;
886 else if (disable)
887 type &= ~mask;
888 else
889 type = mask;
890 }
891
892 if (!count) {
893 IR_dprintk(1, "Protocol not specified\n");
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300894 ret = -EINVAL;
895 goto out;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300896 }
897
David Härdemand8b4b582010-10-29 16:08:23 -0300898 if (dev->change_protocol) {
899 rc = dev->change_protocol(dev, type);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300900 if (rc < 0) {
901 IR_dprintk(1, "Error setting protocols to 0x%llx\n",
902 (long long)type);
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300903 ret = -EINVAL;
904 goto out;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300905 }
906 }
907
David Härdemand8b4b582010-10-29 16:08:23 -0300908 if (dev->driver_type == RC_DRIVER_SCANCODE) {
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300909 spin_lock_irqsave(&dev->rc_map.lock, flags);
910 dev->rc_map.rc_type = type;
911 spin_unlock_irqrestore(&dev->rc_map.lock, flags);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300912 } else {
David Härdemand8b4b582010-10-29 16:08:23 -0300913 dev->raw->enabled_protocols = type;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300914 }
915
916 IR_dprintk(1, "Current protocol(s): 0x%llx\n",
917 (long long)type);
918
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300919 ret = len;
920
921out:
922 mutex_unlock(&dev->lock);
923 return ret;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300924}
925
David Härdemand8b4b582010-10-29 16:08:23 -0300926static void rc_dev_release(struct device *device)
927{
928 struct rc_dev *dev = to_rc_dev(device);
929
930 kfree(dev);
931 module_put(THIS_MODULE);
932}
933
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300934#define ADD_HOTPLUG_VAR(fmt, val...) \
935 do { \
936 int err = add_uevent_var(env, fmt, val); \
937 if (err) \
938 return err; \
939 } while (0)
940
941static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
942{
David Härdemand8b4b582010-10-29 16:08:23 -0300943 struct rc_dev *dev = to_rc_dev(device);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300944
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300945 if (dev->rc_map.name)
946 ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
David Härdemand8b4b582010-10-29 16:08:23 -0300947 if (dev->driver_name)
948 ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300949
950 return 0;
951}
952
953/*
954 * Static device attribute struct with the sysfs attributes for IR's
955 */
956static DEVICE_ATTR(protocols, S_IRUGO | S_IWUSR,
957 show_protocols, store_protocols);
958
959static struct attribute *rc_dev_attrs[] = {
960 &dev_attr_protocols.attr,
961 NULL,
962};
963
964static struct attribute_group rc_dev_attr_grp = {
965 .attrs = rc_dev_attrs,
966};
967
968static const struct attribute_group *rc_dev_attr_groups[] = {
969 &rc_dev_attr_grp,
970 NULL
971};
972
973static struct device_type rc_dev_type = {
974 .groups = rc_dev_attr_groups,
David Härdemand8b4b582010-10-29 16:08:23 -0300975 .release = rc_dev_release,
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300976 .uevent = rc_dev_uevent,
977};
978
David Härdemand8b4b582010-10-29 16:08:23 -0300979struct rc_dev *rc_allocate_device(void)
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300980{
David Härdemand8b4b582010-10-29 16:08:23 -0300981 struct rc_dev *dev;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300982
David Härdemand8b4b582010-10-29 16:08:23 -0300983 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
984 if (!dev)
985 return NULL;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300986
David Härdemand8b4b582010-10-29 16:08:23 -0300987 dev->input_dev = input_allocate_device();
988 if (!dev->input_dev) {
989 kfree(dev);
990 return NULL;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300991 }
992
Dmitry Torokhovaebd6362011-01-31 21:06:39 -0800993 dev->input_dev->getkeycode = ir_getkeycode;
994 dev->input_dev->setkeycode = ir_setkeycode;
David Härdemand8b4b582010-10-29 16:08:23 -0300995 input_set_drvdata(dev->input_dev, dev);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -0300996
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -0300997 spin_lock_init(&dev->rc_map.lock);
David Härdemand8b4b582010-10-29 16:08:23 -0300998 spin_lock_init(&dev->keylock);
Jarod Wilson08aeb7c2011-05-11 15:14:31 -0300999 mutex_init(&dev->lock);
David Härdemand8b4b582010-10-29 16:08:23 -03001000 setup_timer(&dev->timer_keyup, ir_timer_keyup, (unsigned long)dev);
1001
1002 dev->dev.type = &rc_dev_type;
1003 dev->dev.class = &ir_input_class;
1004 device_initialize(&dev->dev);
1005
1006 __module_get(THIS_MODULE);
1007 return dev;
1008}
1009EXPORT_SYMBOL_GPL(rc_allocate_device);
1010
1011void rc_free_device(struct rc_dev *dev)
1012{
1013 if (dev) {
1014 input_free_device(dev->input_dev);
1015 put_device(&dev->dev);
1016 }
1017}
1018EXPORT_SYMBOL_GPL(rc_free_device);
1019
1020int rc_register_device(struct rc_dev *dev)
1021{
1022 static atomic_t devno = ATOMIC_INIT(0);
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -03001023 struct rc_map *rc_map;
David Härdemand8b4b582010-10-29 16:08:23 -03001024 const char *path;
1025 int rc;
1026
1027 if (!dev || !dev->map_name)
1028 return -EINVAL;
1029
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -03001030 rc_map = rc_map_get(dev->map_name);
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -03001031 if (!rc_map)
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -03001032 rc_map = rc_map_get(RC_MAP_EMPTY);
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -03001033 if (!rc_map || !rc_map->scan || rc_map->size == 0)
David Härdemand8b4b582010-10-29 16:08:23 -03001034 return -EINVAL;
1035
1036 set_bit(EV_KEY, dev->input_dev->evbit);
1037 set_bit(EV_REP, dev->input_dev->evbit);
1038 set_bit(EV_MSC, dev->input_dev->evbit);
1039 set_bit(MSC_SCAN, dev->input_dev->mscbit);
1040 if (dev->open)
1041 dev->input_dev->open = ir_open;
1042 if (dev->close)
1043 dev->input_dev->close = ir_close;
1044
Jarod Wilson08aeb7c2011-05-11 15:14:31 -03001045 /*
1046 * Take the lock here, as the device sysfs node will appear
1047 * when device_add() is called, which may trigger an ir-keytable udev
1048 * rule, which will in turn call show_protocols and access either
1049 * dev->rc_map.rc_type or dev->raw->enabled_protocols before it has
1050 * been initialized.
1051 */
1052 mutex_lock(&dev->lock);
1053
David Härdemand8b4b582010-10-29 16:08:23 -03001054 dev->devno = (unsigned long)(atomic_inc_return(&devno) - 1);
1055 dev_set_name(&dev->dev, "rc%ld", dev->devno);
1056 dev_set_drvdata(&dev->dev, dev);
1057 rc = device_add(&dev->dev);
1058 if (rc)
Jarod Wilson08aeb7c2011-05-11 15:14:31 -03001059 goto out_unlock;
David Härdemand8b4b582010-10-29 16:08:23 -03001060
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -03001061 rc = ir_setkeytable(dev, rc_map);
David Härdemand8b4b582010-10-29 16:08:23 -03001062 if (rc)
1063 goto out_dev;
1064
1065 dev->input_dev->dev.parent = &dev->dev;
1066 memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
1067 dev->input_dev->phys = dev->input_phys;
1068 dev->input_dev->name = dev->input_name;
1069 rc = input_register_device(dev->input_dev);
1070 if (rc)
1071 goto out_table;
1072
1073 /*
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001074 * Default delay of 250ms is too short for some protocols, especially
David Härdemand8b4b582010-10-29 16:08:23 -03001075 * since the timeout is currently set to 250ms. Increase it to 500ms,
1076 * to avoid wrong repetition of the keycodes. Note that this must be
1077 * set after the call to input_register_device().
1078 */
1079 dev->input_dev->rep[REP_DELAY] = 500;
1080
Mauro Carvalho Chehabca540c82011-05-11 22:36:47 -03001081 /*
1082 * As a repeat event on protocols like RC-5 and NEC take as long as
1083 * 110/114ms, using 33ms as a repeat period is not the right thing
1084 * to do.
1085 */
1086 dev->input_dev->rep[REP_PERIOD] = 125;
1087
David Härdemand8b4b582010-10-29 16:08:23 -03001088 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001089 printk(KERN_INFO "%s: %s as %s\n",
David Härdemand8b4b582010-10-29 16:08:23 -03001090 dev_name(&dev->dev),
1091 dev->input_name ? dev->input_name : "Unspecified device",
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001092 path ? path : "N/A");
1093 kfree(path);
1094
David Härdemand8b4b582010-10-29 16:08:23 -03001095 if (dev->driver_type == RC_DRIVER_IR_RAW) {
1096 rc = ir_raw_event_register(dev);
1097 if (rc < 0)
1098 goto out_input;
1099 }
Jarod Wilson08aeb7c2011-05-11 15:14:31 -03001100 mutex_unlock(&dev->lock);
David Härdemand8b4b582010-10-29 16:08:23 -03001101
1102 if (dev->change_protocol) {
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -03001103 rc = dev->change_protocol(dev, rc_map->rc_type);
David Härdemand8b4b582010-10-29 16:08:23 -03001104 if (rc < 0)
1105 goto out_raw;
1106 }
1107
1108 IR_dprintk(1, "Registered rc%ld (driver: %s, remote: %s, mode %s)\n",
1109 dev->devno,
1110 dev->driver_name ? dev->driver_name : "unknown",
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -03001111 rc_map->name ? rc_map->name : "unknown",
David Härdemand8b4b582010-10-29 16:08:23 -03001112 dev->driver_type == RC_DRIVER_IR_RAW ? "raw" : "cooked");
1113
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001114 return 0;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001115
David Härdemand8b4b582010-10-29 16:08:23 -03001116out_raw:
1117 if (dev->driver_type == RC_DRIVER_IR_RAW)
1118 ir_raw_event_unregister(dev);
1119out_input:
1120 input_unregister_device(dev->input_dev);
1121 dev->input_dev = NULL;
1122out_table:
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -03001123 ir_free_table(&dev->rc_map);
David Härdemand8b4b582010-10-29 16:08:23 -03001124out_dev:
1125 device_del(&dev->dev);
Jarod Wilson08aeb7c2011-05-11 15:14:31 -03001126out_unlock:
1127 mutex_unlock(&dev->lock);
David Härdemand8b4b582010-10-29 16:08:23 -03001128 return rc;
1129}
1130EXPORT_SYMBOL_GPL(rc_register_device);
1131
1132void rc_unregister_device(struct rc_dev *dev)
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001133{
David Härdemand8b4b582010-10-29 16:08:23 -03001134 if (!dev)
1135 return;
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001136
David Härdemand8b4b582010-10-29 16:08:23 -03001137 del_timer_sync(&dev->timer_keyup);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001138
David Härdemand8b4b582010-10-29 16:08:23 -03001139 if (dev->driver_type == RC_DRIVER_IR_RAW)
1140 ir_raw_event_unregister(dev);
1141
1142 input_unregister_device(dev->input_dev);
1143 dev->input_dev = NULL;
1144
Mauro Carvalho Chehabb088ba62010-11-17 14:28:27 -03001145 ir_free_table(&dev->rc_map);
David Härdemand8b4b582010-10-29 16:08:23 -03001146 IR_dprintk(1, "Freed keycode table\n");
1147
1148 device_unregister(&dev->dev);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001149}
David Härdemand8b4b582010-10-29 16:08:23 -03001150EXPORT_SYMBOL_GPL(rc_unregister_device);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001151
1152/*
1153 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
1154 */
1155
Mauro Carvalho Chehab6bda9642010-11-17 13:28:38 -03001156static int __init rc_core_init(void)
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001157{
1158 int rc = class_register(&ir_input_class);
1159 if (rc) {
Mauro Carvalho Chehab6bda9642010-11-17 13:28:38 -03001160 printk(KERN_ERR "rc_core: unable to register rc class\n");
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001161 return rc;
1162 }
1163
1164 /* Initialize/load the decoders/keymap code that will be used */
1165 ir_raw_init();
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -03001166 rc_map_register(&empty_map);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001167
1168 return 0;
1169}
1170
Mauro Carvalho Chehab6bda9642010-11-17 13:28:38 -03001171static void __exit rc_core_exit(void)
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001172{
1173 class_unregister(&ir_input_class);
Mauro Carvalho Chehabd100e652010-11-17 15:56:53 -03001174 rc_map_unregister(&empty_map);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001175}
1176
Mauro Carvalho Chehab6bda9642010-11-17 13:28:38 -03001177module_init(rc_core_init);
1178module_exit(rc_core_exit);
Mauro Carvalho Chehabbc2a6c52010-11-09 23:18:24 -03001179
Mauro Carvalho Chehab6bda9642010-11-17 13:28:38 -03001180int rc_core_debug; /* ir_debug level (0,1,2) */
1181EXPORT_SYMBOL_GPL(rc_core_debug);
1182module_param_named(debug, rc_core_debug, int, 0644);
Mauro Carvalho Chehab446e4a62009-12-11 08:34:07 -03001183
1184MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
1185MODULE_LICENSE("GPL");