Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : // rc-main.c - Remote Controller core module
3 : : //
4 : : // Copyright (C) 2009-2010 by Mauro Carvalho Chehab
5 : :
6 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7 : :
8 : : #include <media/rc-core.h>
9 : : #include <linux/bsearch.h>
10 : : #include <linux/spinlock.h>
11 : : #include <linux/delay.h>
12 : : #include <linux/input.h>
13 : : #include <linux/leds.h>
14 : : #include <linux/slab.h>
15 : : #include <linux/idr.h>
16 : : #include <linux/device.h>
17 : : #include <linux/module.h>
18 : : #include "rc-core-priv.h"
19 : :
20 : : /* Sizes are in bytes, 256 bytes allows for 32 entries on x64 */
21 : : #define IR_TAB_MIN_SIZE 256
22 : : #define IR_TAB_MAX_SIZE 8192
23 : :
24 : : static const struct {
25 : : const char *name;
26 : : unsigned int repeat_period;
27 : : unsigned int scancode_bits;
28 : : } protocols[] = {
29 : : [RC_PROTO_UNKNOWN] = { .name = "unknown", .repeat_period = 125 },
30 : : [RC_PROTO_OTHER] = { .name = "other", .repeat_period = 125 },
31 : : [RC_PROTO_RC5] = { .name = "rc-5",
32 : : .scancode_bits = 0x1f7f, .repeat_period = 114 },
33 : : [RC_PROTO_RC5X_20] = { .name = "rc-5x-20",
34 : : .scancode_bits = 0x1f7f3f, .repeat_period = 114 },
35 : : [RC_PROTO_RC5_SZ] = { .name = "rc-5-sz",
36 : : .scancode_bits = 0x2fff, .repeat_period = 114 },
37 : : [RC_PROTO_JVC] = { .name = "jvc",
38 : : .scancode_bits = 0xffff, .repeat_period = 125 },
39 : : [RC_PROTO_SONY12] = { .name = "sony-12",
40 : : .scancode_bits = 0x1f007f, .repeat_period = 100 },
41 : : [RC_PROTO_SONY15] = { .name = "sony-15",
42 : : .scancode_bits = 0xff007f, .repeat_period = 100 },
43 : : [RC_PROTO_SONY20] = { .name = "sony-20",
44 : : .scancode_bits = 0x1fff7f, .repeat_period = 100 },
45 : : [RC_PROTO_NEC] = { .name = "nec",
46 : : .scancode_bits = 0xffff, .repeat_period = 110 },
47 : : [RC_PROTO_NECX] = { .name = "nec-x",
48 : : .scancode_bits = 0xffffff, .repeat_period = 110 },
49 : : [RC_PROTO_NEC32] = { .name = "nec-32",
50 : : .scancode_bits = 0xffffffff, .repeat_period = 110 },
51 : : [RC_PROTO_SANYO] = { .name = "sanyo",
52 : : .scancode_bits = 0x1fffff, .repeat_period = 125 },
53 : : [RC_PROTO_MCIR2_KBD] = { .name = "mcir2-kbd",
54 : : .scancode_bits = 0xffffff, .repeat_period = 100 },
55 : : [RC_PROTO_MCIR2_MSE] = { .name = "mcir2-mse",
56 : : .scancode_bits = 0x1fffff, .repeat_period = 100 },
57 : : [RC_PROTO_RC6_0] = { .name = "rc-6-0",
58 : : .scancode_bits = 0xffff, .repeat_period = 114 },
59 : : [RC_PROTO_RC6_6A_20] = { .name = "rc-6-6a-20",
60 : : .scancode_bits = 0xfffff, .repeat_period = 114 },
61 : : [RC_PROTO_RC6_6A_24] = { .name = "rc-6-6a-24",
62 : : .scancode_bits = 0xffffff, .repeat_period = 114 },
63 : : [RC_PROTO_RC6_6A_32] = { .name = "rc-6-6a-32",
64 : : .scancode_bits = 0xffffffff, .repeat_period = 114 },
65 : : [RC_PROTO_RC6_MCE] = { .name = "rc-6-mce",
66 : : .scancode_bits = 0xffff7fff, .repeat_period = 114 },
67 : : [RC_PROTO_SHARP] = { .name = "sharp",
68 : : .scancode_bits = 0x1fff, .repeat_period = 125 },
69 : : [RC_PROTO_XMP] = { .name = "xmp", .repeat_period = 125 },
70 : : [RC_PROTO_CEC] = { .name = "cec", .repeat_period = 0 },
71 : : [RC_PROTO_IMON] = { .name = "imon",
72 : : .scancode_bits = 0x7fffffff, .repeat_period = 114 },
73 : : [RC_PROTO_RCMM12] = { .name = "rc-mm-12",
74 : : .scancode_bits = 0x00000fff, .repeat_period = 114 },
75 : : [RC_PROTO_RCMM24] = { .name = "rc-mm-24",
76 : : .scancode_bits = 0x00ffffff, .repeat_period = 114 },
77 : : [RC_PROTO_RCMM32] = { .name = "rc-mm-32",
78 : : .scancode_bits = 0xffffffff, .repeat_period = 114 },
79 : : [RC_PROTO_XBOX_DVD] = { .name = "xbox-dvd", .repeat_period = 64 },
80 : : };
81 : :
82 : : /* Used to keep track of known keymaps */
83 : : static LIST_HEAD(rc_map_list);
84 : : static DEFINE_SPINLOCK(rc_map_lock);
85 : : static struct led_trigger *led_feedback;
86 : :
87 : : /* Used to keep track of rc devices */
88 : : static DEFINE_IDA(rc_ida);
89 : :
90 : 0 : static struct rc_map_list *seek_rc_map(const char *name)
91 : : {
92 : : struct rc_map_list *map = NULL;
93 : :
94 : : spin_lock(&rc_map_lock);
95 : 0 : list_for_each_entry(map, &rc_map_list, list) {
96 : 0 : if (!strcmp(name, map->map.name)) {
97 : : spin_unlock(&rc_map_lock);
98 : 0 : return map;
99 : : }
100 : : }
101 : : spin_unlock(&rc_map_lock);
102 : :
103 : 0 : return NULL;
104 : : }
105 : :
106 : 0 : struct rc_map *rc_map_get(const char *name)
107 : : {
108 : :
109 : : struct rc_map_list *map;
110 : :
111 : 0 : map = seek_rc_map(name);
112 : : #ifdef CONFIG_MODULES
113 : 0 : if (!map) {
114 : 0 : int rc = request_module("%s", name);
115 : 0 : if (rc < 0) {
116 : 0 : pr_err("Couldn't load IR keymap %s\n", name);
117 : 0 : return NULL;
118 : : }
119 : 0 : msleep(20); /* Give some time for IR to register */
120 : :
121 : 0 : map = seek_rc_map(name);
122 : : }
123 : : #endif
124 : 0 : if (!map) {
125 : 0 : pr_err("IR keymap %s not found\n", name);
126 : 0 : return NULL;
127 : : }
128 : :
129 : 0 : printk(KERN_INFO "Registered IR keymap %s\n", map->map.name);
130 : :
131 : 0 : return &map->map;
132 : : }
133 : : EXPORT_SYMBOL_GPL(rc_map_get);
134 : :
135 : 3 : int rc_map_register(struct rc_map_list *map)
136 : : {
137 : : spin_lock(&rc_map_lock);
138 : 3 : list_add_tail(&map->list, &rc_map_list);
139 : : spin_unlock(&rc_map_lock);
140 : 3 : return 0;
141 : : }
142 : : EXPORT_SYMBOL_GPL(rc_map_register);
143 : :
144 : 0 : void rc_map_unregister(struct rc_map_list *map)
145 : : {
146 : : spin_lock(&rc_map_lock);
147 : : list_del(&map->list);
148 : : spin_unlock(&rc_map_lock);
149 : 0 : }
150 : : EXPORT_SYMBOL_GPL(rc_map_unregister);
151 : :
152 : :
153 : : static struct rc_map_table empty[] = {
154 : : { 0x2a, KEY_COFFEE },
155 : : };
156 : :
157 : : static struct rc_map_list empty_map = {
158 : : .map = {
159 : : .scan = empty,
160 : : .size = ARRAY_SIZE(empty),
161 : : .rc_proto = RC_PROTO_UNKNOWN, /* Legacy IR type */
162 : : .name = RC_MAP_EMPTY,
163 : : }
164 : : };
165 : :
166 : : /**
167 : : * ir_create_table() - initializes a scancode table
168 : : * @dev: the rc_dev device
169 : : * @rc_map: the rc_map to initialize
170 : : * @name: name to assign to the table
171 : : * @rc_proto: ir type to assign to the new table
172 : : * @size: initial size of the table
173 : : *
174 : : * This routine will initialize the rc_map and will allocate
175 : : * memory to hold at least the specified number of elements.
176 : : *
177 : : * return: zero on success or a negative error code
178 : : */
179 : 0 : static int ir_create_table(struct rc_dev *dev, struct rc_map *rc_map,
180 : : const char *name, u64 rc_proto, size_t size)
181 : : {
182 : 0 : rc_map->name = kstrdup(name, GFP_KERNEL);
183 : 0 : if (!rc_map->name)
184 : : return -ENOMEM;
185 : 0 : rc_map->rc_proto = rc_proto;
186 : 0 : rc_map->alloc = roundup_pow_of_two(size * sizeof(struct rc_map_table));
187 : 0 : rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
188 : 0 : rc_map->scan = kmalloc(rc_map->alloc, GFP_KERNEL);
189 : 0 : if (!rc_map->scan) {
190 : 0 : kfree(rc_map->name);
191 : 0 : rc_map->name = NULL;
192 : 0 : return -ENOMEM;
193 : : }
194 : :
195 : : dev_dbg(&dev->dev, "Allocated space for %u keycode entries (%u bytes)\n",
196 : : rc_map->size, rc_map->alloc);
197 : : return 0;
198 : : }
199 : :
200 : : /**
201 : : * ir_free_table() - frees memory allocated by a scancode table
202 : : * @rc_map: the table whose mappings need to be freed
203 : : *
204 : : * This routine will free memory alloctaed for key mappings used by given
205 : : * scancode table.
206 : : */
207 : 0 : static void ir_free_table(struct rc_map *rc_map)
208 : : {
209 : 0 : rc_map->size = 0;
210 : 0 : kfree(rc_map->name);
211 : 0 : rc_map->name = NULL;
212 : 0 : kfree(rc_map->scan);
213 : 0 : rc_map->scan = NULL;
214 : 0 : }
215 : :
216 : : /**
217 : : * ir_resize_table() - resizes a scancode table if necessary
218 : : * @dev: the rc_dev device
219 : : * @rc_map: the rc_map to resize
220 : : * @gfp_flags: gfp flags to use when allocating memory
221 : : *
222 : : * This routine will shrink the rc_map if it has lots of
223 : : * unused entries and grow it if it is full.
224 : : *
225 : : * return: zero on success or a negative error code
226 : : */
227 : 0 : static int ir_resize_table(struct rc_dev *dev, struct rc_map *rc_map,
228 : : gfp_t gfp_flags)
229 : : {
230 : 0 : unsigned int oldalloc = rc_map->alloc;
231 : : unsigned int newalloc = oldalloc;
232 : 0 : struct rc_map_table *oldscan = rc_map->scan;
233 : : struct rc_map_table *newscan;
234 : :
235 : 0 : if (rc_map->size == rc_map->len) {
236 : : /* All entries in use -> grow keytable */
237 : 0 : if (rc_map->alloc >= IR_TAB_MAX_SIZE)
238 : : return -ENOMEM;
239 : :
240 : 0 : newalloc *= 2;
241 : : dev_dbg(&dev->dev, "Growing table to %u bytes\n", newalloc);
242 : : }
243 : :
244 : 0 : if ((rc_map->len * 3 < rc_map->size) && (oldalloc > IR_TAB_MIN_SIZE)) {
245 : : /* Less than 1/3 of entries in use -> shrink keytable */
246 : 0 : newalloc /= 2;
247 : : dev_dbg(&dev->dev, "Shrinking table to %u bytes\n", newalloc);
248 : : }
249 : :
250 : 0 : if (newalloc == oldalloc)
251 : : return 0;
252 : :
253 : : newscan = kmalloc(newalloc, gfp_flags);
254 : 0 : if (!newscan)
255 : : return -ENOMEM;
256 : :
257 : 0 : memcpy(newscan, rc_map->scan, rc_map->len * sizeof(struct rc_map_table));
258 : 0 : rc_map->scan = newscan;
259 : 0 : rc_map->alloc = newalloc;
260 : 0 : rc_map->size = rc_map->alloc / sizeof(struct rc_map_table);
261 : 0 : kfree(oldscan);
262 : 0 : return 0;
263 : : }
264 : :
265 : : /**
266 : : * ir_update_mapping() - set a keycode in the scancode->keycode table
267 : : * @dev: the struct rc_dev device descriptor
268 : : * @rc_map: scancode table to be adjusted
269 : : * @index: index of the mapping that needs to be updated
270 : : * @new_keycode: the desired keycode
271 : : *
272 : : * This routine is used to update scancode->keycode mapping at given
273 : : * position.
274 : : *
275 : : * return: previous keycode assigned to the mapping
276 : : *
277 : : */
278 : 0 : static unsigned int ir_update_mapping(struct rc_dev *dev,
279 : : struct rc_map *rc_map,
280 : : unsigned int index,
281 : : unsigned int new_keycode)
282 : : {
283 : 0 : int old_keycode = rc_map->scan[index].keycode;
284 : : int i;
285 : :
286 : : /* Did the user wish to remove the mapping? */
287 : 0 : if (new_keycode == KEY_RESERVED || new_keycode == KEY_UNKNOWN) {
288 : : dev_dbg(&dev->dev, "#%d: Deleting scan 0x%04x\n",
289 : : index, rc_map->scan[index].scancode);
290 : 0 : rc_map->len--;
291 : 0 : memmove(&rc_map->scan[index], &rc_map->scan[index+ 1],
292 : 0 : (rc_map->len - index) * sizeof(struct rc_map_table));
293 : : } else {
294 : : dev_dbg(&dev->dev, "#%d: %s scan 0x%04x with key 0x%04x\n",
295 : : index,
296 : : old_keycode == KEY_RESERVED ? "New" : "Replacing",
297 : : rc_map->scan[index].scancode, new_keycode);
298 : 0 : rc_map->scan[index].keycode = new_keycode;
299 : 0 : __set_bit(new_keycode, dev->input_dev->keybit);
300 : : }
301 : :
302 : 0 : if (old_keycode != KEY_RESERVED) {
303 : : /* A previous mapping was updated... */
304 : 0 : __clear_bit(old_keycode, dev->input_dev->keybit);
305 : : /* ... but another scancode might use the same keycode */
306 : 0 : for (i = 0; i < rc_map->len; i++) {
307 : 0 : if (rc_map->scan[i].keycode == old_keycode) {
308 : 0 : __set_bit(old_keycode, dev->input_dev->keybit);
309 : : break;
310 : : }
311 : : }
312 : :
313 : : /* Possibly shrink the keytable, failure is not a problem */
314 : 0 : ir_resize_table(dev, rc_map, GFP_ATOMIC);
315 : : }
316 : :
317 : 0 : return old_keycode;
318 : : }
319 : :
320 : : /**
321 : : * ir_establish_scancode() - set a keycode in the scancode->keycode table
322 : : * @dev: the struct rc_dev device descriptor
323 : : * @rc_map: scancode table to be searched
324 : : * @scancode: the desired scancode
325 : : * @resize: controls whether we allowed to resize the table to
326 : : * accommodate not yet present scancodes
327 : : *
328 : : * This routine is used to locate given scancode in rc_map.
329 : : * If scancode is not yet present the routine will allocate a new slot
330 : : * for it.
331 : : *
332 : : * return: index of the mapping containing scancode in question
333 : : * or -1U in case of failure.
334 : : */
335 : 0 : static unsigned int ir_establish_scancode(struct rc_dev *dev,
336 : : struct rc_map *rc_map,
337 : : unsigned int scancode,
338 : : bool resize)
339 : : {
340 : : unsigned int i;
341 : :
342 : : /*
343 : : * Unfortunately, some hardware-based IR decoders don't provide
344 : : * all bits for the complete IR code. In general, they provide only
345 : : * the command part of the IR code. Yet, as it is possible to replace
346 : : * the provided IR with another one, it is needed to allow loading
347 : : * IR tables from other remotes. So, we support specifying a mask to
348 : : * indicate the valid bits of the scancodes.
349 : : */
350 : 0 : if (dev->scancode_mask)
351 : 0 : scancode &= dev->scancode_mask;
352 : :
353 : : /* First check if we already have a mapping for this ir command */
354 : 0 : for (i = 0; i < rc_map->len; i++) {
355 : 0 : if (rc_map->scan[i].scancode == scancode)
356 : 0 : return i;
357 : :
358 : : /* Keytable is sorted from lowest to highest scancode */
359 : 0 : if (rc_map->scan[i].scancode >= scancode)
360 : : break;
361 : : }
362 : :
363 : : /* No previous mapping found, we might need to grow the table */
364 : 0 : if (rc_map->size == rc_map->len) {
365 : 0 : if (!resize || ir_resize_table(dev, rc_map, GFP_ATOMIC))
366 : : return -1U;
367 : : }
368 : :
369 : : /* i is the proper index to insert our new keycode */
370 : 0 : if (i < rc_map->len)
371 : 0 : memmove(&rc_map->scan[i + 1], &rc_map->scan[i],
372 : 0 : (rc_map->len - i) * sizeof(struct rc_map_table));
373 : 0 : rc_map->scan[i].scancode = scancode;
374 : 0 : rc_map->scan[i].keycode = KEY_RESERVED;
375 : 0 : rc_map->len++;
376 : :
377 : 0 : return i;
378 : : }
379 : :
380 : : /**
381 : : * ir_setkeycode() - set a keycode in the scancode->keycode table
382 : : * @idev: the struct input_dev device descriptor
383 : : * @ke: Input keymap entry
384 : : * @old_keycode: result
385 : : *
386 : : * This routine is used to handle evdev EVIOCSKEY ioctl.
387 : : *
388 : : * return: -EINVAL if the keycode could not be inserted, otherwise zero.
389 : : */
390 : 0 : static int ir_setkeycode(struct input_dev *idev,
391 : : const struct input_keymap_entry *ke,
392 : : unsigned int *old_keycode)
393 : : {
394 : : struct rc_dev *rdev = input_get_drvdata(idev);
395 : 0 : struct rc_map *rc_map = &rdev->rc_map;
396 : : unsigned int index;
397 : : unsigned int scancode;
398 : : int retval = 0;
399 : : unsigned long flags;
400 : :
401 : 0 : spin_lock_irqsave(&rc_map->lock, flags);
402 : :
403 : 0 : if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
404 : 0 : index = ke->index;
405 : 0 : if (index >= rc_map->len) {
406 : : retval = -EINVAL;
407 : : goto out;
408 : : }
409 : : } else {
410 : 0 : retval = input_scancode_to_scalar(ke, &scancode);
411 : 0 : if (retval)
412 : : goto out;
413 : :
414 : 0 : index = ir_establish_scancode(rdev, rc_map, scancode, true);
415 : 0 : if (index >= rc_map->len) {
416 : : retval = -ENOMEM;
417 : : goto out;
418 : : }
419 : : }
420 : :
421 : 0 : *old_keycode = ir_update_mapping(rdev, rc_map, index, ke->keycode);
422 : :
423 : : out:
424 : : spin_unlock_irqrestore(&rc_map->lock, flags);
425 : 0 : return retval;
426 : : }
427 : :
428 : : /**
429 : : * ir_setkeytable() - sets several entries in the scancode->keycode table
430 : : * @dev: the struct rc_dev device descriptor
431 : : * @from: the struct rc_map to copy entries from
432 : : *
433 : : * This routine is used to handle table initialization.
434 : : *
435 : : * return: -ENOMEM if all keycodes could not be inserted, otherwise zero.
436 : : */
437 : 0 : static int ir_setkeytable(struct rc_dev *dev,
438 : : const struct rc_map *from)
439 : : {
440 : 0 : struct rc_map *rc_map = &dev->rc_map;
441 : : unsigned int i, index;
442 : : int rc;
443 : :
444 : 0 : rc = ir_create_table(dev, rc_map, from->name, from->rc_proto,
445 : : from->size);
446 : 0 : if (rc)
447 : : return rc;
448 : :
449 : 0 : for (i = 0; i < from->size; i++) {
450 : 0 : index = ir_establish_scancode(dev, rc_map,
451 : 0 : from->scan[i].scancode, false);
452 : 0 : if (index >= rc_map->len) {
453 : : rc = -ENOMEM;
454 : : break;
455 : : }
456 : :
457 : 0 : ir_update_mapping(dev, rc_map, index,
458 : 0 : from->scan[i].keycode);
459 : : }
460 : :
461 : 0 : if (rc)
462 : 0 : ir_free_table(rc_map);
463 : :
464 : 0 : return rc;
465 : : }
466 : :
467 : 0 : static int rc_map_cmp(const void *key, const void *elt)
468 : : {
469 : : const unsigned int *scancode = key;
470 : : const struct rc_map_table *e = elt;
471 : :
472 : 0 : if (*scancode < e->scancode)
473 : : return -1;
474 : 0 : else if (*scancode > e->scancode)
475 : : return 1;
476 : 0 : return 0;
477 : : }
478 : :
479 : : /**
480 : : * ir_lookup_by_scancode() - locate mapping by scancode
481 : : * @rc_map: the struct rc_map to search
482 : : * @scancode: scancode to look for in the table
483 : : *
484 : : * This routine performs binary search in RC keykeymap table for
485 : : * given scancode.
486 : : *
487 : : * return: index in the table, -1U if not found
488 : : */
489 : 0 : static unsigned int ir_lookup_by_scancode(const struct rc_map *rc_map,
490 : : unsigned int scancode)
491 : : {
492 : : struct rc_map_table *res;
493 : :
494 : 0 : res = bsearch(&scancode, rc_map->scan, rc_map->len,
495 : : sizeof(struct rc_map_table), rc_map_cmp);
496 : 0 : if (!res)
497 : : return -1U;
498 : : else
499 : 0 : return res - rc_map->scan;
500 : : }
501 : :
502 : : /**
503 : : * ir_getkeycode() - get a keycode from the scancode->keycode table
504 : : * @idev: the struct input_dev device descriptor
505 : : * @ke: Input keymap entry
506 : : *
507 : : * This routine is used to handle evdev EVIOCGKEY ioctl.
508 : : *
509 : : * return: always returns zero.
510 : : */
511 : 0 : static int ir_getkeycode(struct input_dev *idev,
512 : : struct input_keymap_entry *ke)
513 : : {
514 : : struct rc_dev *rdev = input_get_drvdata(idev);
515 : 0 : struct rc_map *rc_map = &rdev->rc_map;
516 : : struct rc_map_table *entry;
517 : : unsigned long flags;
518 : : unsigned int index;
519 : : unsigned int scancode;
520 : : int retval;
521 : :
522 : 0 : spin_lock_irqsave(&rc_map->lock, flags);
523 : :
524 : 0 : if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
525 : 0 : index = ke->index;
526 : : } else {
527 : 0 : retval = input_scancode_to_scalar(ke, &scancode);
528 : 0 : if (retval)
529 : : goto out;
530 : :
531 : 0 : index = ir_lookup_by_scancode(rc_map, scancode);
532 : : }
533 : :
534 : 0 : if (index < rc_map->len) {
535 : 0 : entry = &rc_map->scan[index];
536 : :
537 : 0 : ke->index = index;
538 : 0 : ke->keycode = entry->keycode;
539 : 0 : ke->len = sizeof(entry->scancode);
540 : 0 : memcpy(ke->scancode, &entry->scancode, sizeof(entry->scancode));
541 : :
542 : 0 : } else if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) {
543 : : /*
544 : : * We do not really know the valid range of scancodes
545 : : * so let's respond with KEY_RESERVED to anything we
546 : : * do not have mapping for [yet].
547 : : */
548 : 0 : ke->index = index;
549 : 0 : ke->keycode = KEY_RESERVED;
550 : : } else {
551 : : retval = -EINVAL;
552 : : goto out;
553 : : }
554 : :
555 : : retval = 0;
556 : :
557 : : out:
558 : : spin_unlock_irqrestore(&rc_map->lock, flags);
559 : 0 : return retval;
560 : : }
561 : :
562 : : /**
563 : : * rc_g_keycode_from_table() - gets the keycode that corresponds to a scancode
564 : : * @dev: the struct rc_dev descriptor of the device
565 : : * @scancode: the scancode to look for
566 : : *
567 : : * This routine is used by drivers which need to convert a scancode to a
568 : : * keycode. Normally it should not be used since drivers should have no
569 : : * interest in keycodes.
570 : : *
571 : : * return: the corresponding keycode, or KEY_RESERVED
572 : : */
573 : 0 : u32 rc_g_keycode_from_table(struct rc_dev *dev, u32 scancode)
574 : : {
575 : 0 : struct rc_map *rc_map = &dev->rc_map;
576 : : unsigned int keycode;
577 : : unsigned int index;
578 : : unsigned long flags;
579 : :
580 : 0 : spin_lock_irqsave(&rc_map->lock, flags);
581 : :
582 : 0 : index = ir_lookup_by_scancode(rc_map, scancode);
583 : 0 : keycode = index < rc_map->len ?
584 : 0 : rc_map->scan[index].keycode : KEY_RESERVED;
585 : :
586 : : spin_unlock_irqrestore(&rc_map->lock, flags);
587 : :
588 : : if (keycode != KEY_RESERVED)
589 : : dev_dbg(&dev->dev, "%s: scancode 0x%04x keycode 0x%02x\n",
590 : : dev->device_name, scancode, keycode);
591 : :
592 : 0 : return keycode;
593 : : }
594 : : EXPORT_SYMBOL_GPL(rc_g_keycode_from_table);
595 : :
596 : : /**
597 : : * ir_do_keyup() - internal function to signal the release of a keypress
598 : : * @dev: the struct rc_dev descriptor of the device
599 : : * @sync: whether or not to call input_sync
600 : : *
601 : : * This function is used internally to release a keypress, it must be
602 : : * called with keylock held.
603 : : */
604 : 0 : static void ir_do_keyup(struct rc_dev *dev, bool sync)
605 : : {
606 : 0 : if (!dev->keypressed)
607 : 0 : return;
608 : :
609 : : dev_dbg(&dev->dev, "keyup key 0x%04x\n", dev->last_keycode);
610 : 0 : del_timer(&dev->timer_repeat);
611 : 0 : input_report_key(dev->input_dev, dev->last_keycode, 0);
612 : 0 : led_trigger_event(led_feedback, LED_OFF);
613 : 0 : if (sync)
614 : 0 : input_sync(dev->input_dev);
615 : 0 : dev->keypressed = false;
616 : : }
617 : :
618 : : /**
619 : : * rc_keyup() - signals the release of a keypress
620 : : * @dev: the struct rc_dev descriptor of the device
621 : : *
622 : : * This routine is used to signal that a key has been released on the
623 : : * remote control.
624 : : */
625 : 0 : void rc_keyup(struct rc_dev *dev)
626 : : {
627 : : unsigned long flags;
628 : :
629 : 0 : spin_lock_irqsave(&dev->keylock, flags);
630 : 0 : ir_do_keyup(dev, true);
631 : : spin_unlock_irqrestore(&dev->keylock, flags);
632 : 0 : }
633 : : EXPORT_SYMBOL_GPL(rc_keyup);
634 : :
635 : : /**
636 : : * ir_timer_keyup() - generates a keyup event after a timeout
637 : : *
638 : : * @t: a pointer to the struct timer_list
639 : : *
640 : : * This routine will generate a keyup event some time after a keydown event
641 : : * is generated when no further activity has been detected.
642 : : */
643 : 0 : static void ir_timer_keyup(struct timer_list *t)
644 : : {
645 : 0 : struct rc_dev *dev = from_timer(dev, t, timer_keyup);
646 : : unsigned long flags;
647 : :
648 : : /*
649 : : * ir->keyup_jiffies is used to prevent a race condition if a
650 : : * hardware interrupt occurs at this point and the keyup timer
651 : : * event is moved further into the future as a result.
652 : : *
653 : : * The timer will then be reactivated and this function called
654 : : * again in the future. We need to exit gracefully in that case
655 : : * to allow the input subsystem to do its auto-repeat magic or
656 : : * a keyup event might follow immediately after the keydown.
657 : : */
658 : 0 : spin_lock_irqsave(&dev->keylock, flags);
659 : 0 : if (time_is_before_eq_jiffies(dev->keyup_jiffies))
660 : 0 : ir_do_keyup(dev, true);
661 : : spin_unlock_irqrestore(&dev->keylock, flags);
662 : 0 : }
663 : :
664 : : /**
665 : : * ir_timer_repeat() - generates a repeat event after a timeout
666 : : *
667 : : * @t: a pointer to the struct timer_list
668 : : *
669 : : * This routine will generate a soft repeat event every REP_PERIOD
670 : : * milliseconds.
671 : : */
672 : 0 : static void ir_timer_repeat(struct timer_list *t)
673 : : {
674 : : struct rc_dev *dev = from_timer(dev, t, timer_repeat);
675 : 0 : struct input_dev *input = dev->input_dev;
676 : : unsigned long flags;
677 : :
678 : 0 : spin_lock_irqsave(&dev->keylock, flags);
679 : 0 : if (dev->keypressed) {
680 : 0 : input_event(input, EV_KEY, dev->last_keycode, 2);
681 : : input_sync(input);
682 : 0 : if (input->rep[REP_PERIOD])
683 : 0 : mod_timer(&dev->timer_repeat, jiffies +
684 : 0 : msecs_to_jiffies(input->rep[REP_PERIOD]));
685 : : }
686 : : spin_unlock_irqrestore(&dev->keylock, flags);
687 : 0 : }
688 : :
689 : : static unsigned int repeat_period(int protocol)
690 : : {
691 : 0 : if (protocol >= ARRAY_SIZE(protocols))
692 : : return 100;
693 : :
694 : 0 : return protocols[protocol].repeat_period;
695 : : }
696 : :
697 : : /**
698 : : * rc_repeat() - signals that a key is still pressed
699 : : * @dev: the struct rc_dev descriptor of the device
700 : : *
701 : : * This routine is used by IR decoders when a repeat message which does
702 : : * not include the necessary bits to reproduce the scancode has been
703 : : * received.
704 : : */
705 : 0 : void rc_repeat(struct rc_dev *dev)
706 : : {
707 : : unsigned long flags;
708 : 0 : unsigned int timeout = nsecs_to_jiffies(dev->timeout) +
709 : 0 : msecs_to_jiffies(repeat_period(dev->last_protocol));
710 : 0 : struct lirc_scancode sc = {
711 : 0 : .scancode = dev->last_scancode, .rc_proto = dev->last_protocol,
712 : 0 : .keycode = dev->keypressed ? dev->last_keycode : KEY_RESERVED,
713 : : .flags = LIRC_SCANCODE_FLAG_REPEAT |
714 : 0 : (dev->last_toggle ? LIRC_SCANCODE_FLAG_TOGGLE : 0)
715 : : };
716 : :
717 : 0 : if (dev->allowed_protocols != RC_PROTO_BIT_CEC)
718 : 0 : ir_lirc_scancode_event(dev, &sc);
719 : :
720 : 0 : spin_lock_irqsave(&dev->keylock, flags);
721 : :
722 : 0 : input_event(dev->input_dev, EV_MSC, MSC_SCAN, dev->last_scancode);
723 : 0 : input_sync(dev->input_dev);
724 : :
725 : 0 : if (dev->keypressed) {
726 : 0 : dev->keyup_jiffies = jiffies + timeout;
727 : 0 : mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
728 : : }
729 : :
730 : : spin_unlock_irqrestore(&dev->keylock, flags);
731 : 0 : }
732 : : EXPORT_SYMBOL_GPL(rc_repeat);
733 : :
734 : : /**
735 : : * ir_do_keydown() - internal function to process a keypress
736 : : * @dev: the struct rc_dev descriptor of the device
737 : : * @protocol: the protocol of the keypress
738 : : * @scancode: the scancode of the keypress
739 : : * @keycode: the keycode of the keypress
740 : : * @toggle: the toggle value of the keypress
741 : : *
742 : : * This function is used internally to register a keypress, it must be
743 : : * called with keylock held.
744 : : */
745 : 0 : static void ir_do_keydown(struct rc_dev *dev, enum rc_proto protocol,
746 : : u32 scancode, u32 keycode, u8 toggle)
747 : : {
748 : 0 : bool new_event = (!dev->keypressed ||
749 : 0 : dev->last_protocol != protocol ||
750 : 0 : dev->last_scancode != scancode ||
751 : 0 : dev->last_toggle != toggle);
752 : 0 : struct lirc_scancode sc = {
753 : : .scancode = scancode, .rc_proto = protocol,
754 : 0 : .flags = toggle ? LIRC_SCANCODE_FLAG_TOGGLE : 0,
755 : : .keycode = keycode
756 : : };
757 : :
758 : 0 : if (dev->allowed_protocols != RC_PROTO_BIT_CEC)
759 : 0 : ir_lirc_scancode_event(dev, &sc);
760 : :
761 : 0 : if (new_event && dev->keypressed)
762 : 0 : ir_do_keyup(dev, false);
763 : :
764 : 0 : input_event(dev->input_dev, EV_MSC, MSC_SCAN, scancode);
765 : :
766 : 0 : dev->last_protocol = protocol;
767 : 0 : dev->last_scancode = scancode;
768 : 0 : dev->last_toggle = toggle;
769 : 0 : dev->last_keycode = keycode;
770 : :
771 : 0 : if (new_event && keycode != KEY_RESERVED) {
772 : : /* Register a keypress */
773 : 0 : dev->keypressed = true;
774 : :
775 : : dev_dbg(&dev->dev, "%s: key down event, key 0x%04x, protocol 0x%04x, scancode 0x%08x\n",
776 : : dev->device_name, keycode, protocol, scancode);
777 : 0 : input_report_key(dev->input_dev, keycode, 1);
778 : :
779 : 0 : led_trigger_event(led_feedback, LED_FULL);
780 : : }
781 : :
782 : : /*
783 : : * For CEC, start sending repeat messages as soon as the first
784 : : * repeated message is sent, as long as REP_DELAY = 0 and REP_PERIOD
785 : : * is non-zero. Otherwise, the input layer will generate repeat
786 : : * messages.
787 : : */
788 : 0 : if (!new_event && keycode != KEY_RESERVED &&
789 : 0 : dev->allowed_protocols == RC_PROTO_BIT_CEC &&
790 : 0 : !timer_pending(&dev->timer_repeat) &&
791 : 0 : dev->input_dev->rep[REP_PERIOD] &&
792 : 0 : !dev->input_dev->rep[REP_DELAY]) {
793 : 0 : input_event(dev->input_dev, EV_KEY, keycode, 2);
794 : 0 : mod_timer(&dev->timer_repeat, jiffies +
795 : 0 : msecs_to_jiffies(dev->input_dev->rep[REP_PERIOD]));
796 : : }
797 : :
798 : 0 : input_sync(dev->input_dev);
799 : 0 : }
800 : :
801 : : /**
802 : : * rc_keydown() - generates input event for a key press
803 : : * @dev: the struct rc_dev descriptor of the device
804 : : * @protocol: the protocol for the keypress
805 : : * @scancode: the scancode for the keypress
806 : : * @toggle: the toggle value (protocol dependent, if the protocol doesn't
807 : : * support toggle values, this should be set to zero)
808 : : *
809 : : * This routine is used to signal that a key has been pressed on the
810 : : * remote control.
811 : : */
812 : 0 : void rc_keydown(struct rc_dev *dev, enum rc_proto protocol, u32 scancode,
813 : : u8 toggle)
814 : : {
815 : : unsigned long flags;
816 : 0 : u32 keycode = rc_g_keycode_from_table(dev, scancode);
817 : :
818 : 0 : spin_lock_irqsave(&dev->keylock, flags);
819 : 0 : ir_do_keydown(dev, protocol, scancode, keycode, toggle);
820 : :
821 : 0 : if (dev->keypressed) {
822 : 0 : dev->keyup_jiffies = jiffies + nsecs_to_jiffies(dev->timeout) +
823 : 0 : msecs_to_jiffies(repeat_period(protocol));
824 : 0 : mod_timer(&dev->timer_keyup, dev->keyup_jiffies);
825 : : }
826 : : spin_unlock_irqrestore(&dev->keylock, flags);
827 : 0 : }
828 : : EXPORT_SYMBOL_GPL(rc_keydown);
829 : :
830 : : /**
831 : : * rc_keydown_notimeout() - generates input event for a key press without
832 : : * an automatic keyup event at a later time
833 : : * @dev: the struct rc_dev descriptor of the device
834 : : * @protocol: the protocol for the keypress
835 : : * @scancode: the scancode for the keypress
836 : : * @toggle: the toggle value (protocol dependent, if the protocol doesn't
837 : : * support toggle values, this should be set to zero)
838 : : *
839 : : * This routine is used to signal that a key has been pressed on the
840 : : * remote control. The driver must manually call rc_keyup() at a later stage.
841 : : */
842 : 0 : void rc_keydown_notimeout(struct rc_dev *dev, enum rc_proto protocol,
843 : : u32 scancode, u8 toggle)
844 : : {
845 : : unsigned long flags;
846 : 0 : u32 keycode = rc_g_keycode_from_table(dev, scancode);
847 : :
848 : 0 : spin_lock_irqsave(&dev->keylock, flags);
849 : 0 : ir_do_keydown(dev, protocol, scancode, keycode, toggle);
850 : : spin_unlock_irqrestore(&dev->keylock, flags);
851 : 0 : }
852 : : EXPORT_SYMBOL_GPL(rc_keydown_notimeout);
853 : :
854 : : /**
855 : : * rc_validate_scancode() - checks that a scancode is valid for a protocol.
856 : : * For nec, it should do the opposite of ir_nec_bytes_to_scancode()
857 : : * @proto: protocol
858 : : * @scancode: scancode
859 : : */
860 : 0 : bool rc_validate_scancode(enum rc_proto proto, u32 scancode)
861 : : {
862 : 0 : switch (proto) {
863 : : /*
864 : : * NECX has a 16-bit address; if the lower 8 bits match the upper
865 : : * 8 bits inverted, then the address would match regular nec.
866 : : */
867 : : case RC_PROTO_NECX:
868 : 0 : if ((((scancode >> 16) ^ ~(scancode >> 8)) & 0xff) == 0)
869 : : return false;
870 : : break;
871 : : /*
872 : : * NEC32 has a 16 bit address and 16 bit command. If the lower 8 bits
873 : : * of the command match the upper 8 bits inverted, then it would
874 : : * be either NEC or NECX.
875 : : */
876 : : case RC_PROTO_NEC32:
877 : 0 : if ((((scancode >> 8) ^ ~scancode) & 0xff) == 0)
878 : : return false;
879 : : break;
880 : : /*
881 : : * If the customer code (top 32-bit) is 0x800f, it is MCE else it
882 : : * is regular mode-6a 32 bit
883 : : */
884 : : case RC_PROTO_RC6_MCE:
885 : 0 : if ((scancode & 0xffff0000) != 0x800f0000)
886 : : return false;
887 : : break;
888 : : case RC_PROTO_RC6_6A_32:
889 : 0 : if ((scancode & 0xffff0000) == 0x800f0000)
890 : : return false;
891 : : break;
892 : : default:
893 : : break;
894 : : }
895 : :
896 : 0 : return true;
897 : : }
898 : :
899 : : /**
900 : : * rc_validate_filter() - checks that the scancode and mask are valid and
901 : : * provides sensible defaults
902 : : * @dev: the struct rc_dev descriptor of the device
903 : : * @filter: the scancode and mask
904 : : *
905 : : * return: 0 or -EINVAL if the filter is not valid
906 : : */
907 : 0 : static int rc_validate_filter(struct rc_dev *dev,
908 : : struct rc_scancode_filter *filter)
909 : : {
910 : 0 : u32 mask, s = filter->data;
911 : 0 : enum rc_proto protocol = dev->wakeup_protocol;
912 : :
913 : 0 : if (protocol >= ARRAY_SIZE(protocols))
914 : : return -EINVAL;
915 : :
916 : 0 : mask = protocols[protocol].scancode_bits;
917 : :
918 : 0 : if (!rc_validate_scancode(protocol, s))
919 : : return -EINVAL;
920 : :
921 : 0 : filter->data &= mask;
922 : 0 : filter->mask &= mask;
923 : :
924 : : /*
925 : : * If we have to raw encode the IR for wakeup, we cannot have a mask
926 : : */
927 : 0 : if (dev->encode_wakeup && filter->mask != 0 && filter->mask != mask)
928 : : return -EINVAL;
929 : :
930 : 0 : return 0;
931 : : }
932 : :
933 : 0 : int rc_open(struct rc_dev *rdev)
934 : : {
935 : : int rval = 0;
936 : :
937 : 0 : if (!rdev)
938 : : return -EINVAL;
939 : :
940 : 0 : mutex_lock(&rdev->lock);
941 : :
942 : 0 : if (!rdev->registered) {
943 : : rval = -ENODEV;
944 : : } else {
945 : 0 : if (!rdev->users++ && rdev->open)
946 : 0 : rval = rdev->open(rdev);
947 : :
948 : 0 : if (rval)
949 : 0 : rdev->users--;
950 : : }
951 : :
952 : 0 : mutex_unlock(&rdev->lock);
953 : :
954 : 0 : return rval;
955 : : }
956 : :
957 : 0 : static int ir_open(struct input_dev *idev)
958 : : {
959 : : struct rc_dev *rdev = input_get_drvdata(idev);
960 : :
961 : 0 : return rc_open(rdev);
962 : : }
963 : :
964 : 0 : void rc_close(struct rc_dev *rdev)
965 : : {
966 : 0 : if (rdev) {
967 : 0 : mutex_lock(&rdev->lock);
968 : :
969 : 0 : if (!--rdev->users && rdev->close && rdev->registered)
970 : 0 : rdev->close(rdev);
971 : :
972 : 0 : mutex_unlock(&rdev->lock);
973 : : }
974 : 0 : }
975 : :
976 : 0 : static void ir_close(struct input_dev *idev)
977 : : {
978 : : struct rc_dev *rdev = input_get_drvdata(idev);
979 : 0 : rc_close(rdev);
980 : 0 : }
981 : :
982 : : /* class for /sys/class/rc */
983 : 0 : static char *rc_devnode(struct device *dev, umode_t *mode)
984 : : {
985 : 0 : return kasprintf(GFP_KERNEL, "rc/%s", dev_name(dev));
986 : : }
987 : :
988 : : static struct class rc_class = {
989 : : .name = "rc",
990 : : .devnode = rc_devnode,
991 : : };
992 : :
993 : : /*
994 : : * These are the protocol textual descriptions that are
995 : : * used by the sysfs protocols file. Note that the order
996 : : * of the entries is relevant.
997 : : */
998 : : static const struct {
999 : : u64 type;
1000 : : const char *name;
1001 : : const char *module_name;
1002 : : } proto_names[] = {
1003 : : { RC_PROTO_BIT_NONE, "none", NULL },
1004 : : { RC_PROTO_BIT_OTHER, "other", NULL },
1005 : : { RC_PROTO_BIT_UNKNOWN, "unknown", NULL },
1006 : : { RC_PROTO_BIT_RC5 |
1007 : : RC_PROTO_BIT_RC5X_20, "rc-5", "ir-rc5-decoder" },
1008 : : { RC_PROTO_BIT_NEC |
1009 : : RC_PROTO_BIT_NECX |
1010 : : RC_PROTO_BIT_NEC32, "nec", "ir-nec-decoder" },
1011 : : { RC_PROTO_BIT_RC6_0 |
1012 : : RC_PROTO_BIT_RC6_6A_20 |
1013 : : RC_PROTO_BIT_RC6_6A_24 |
1014 : : RC_PROTO_BIT_RC6_6A_32 |
1015 : : RC_PROTO_BIT_RC6_MCE, "rc-6", "ir-rc6-decoder" },
1016 : : { RC_PROTO_BIT_JVC, "jvc", "ir-jvc-decoder" },
1017 : : { RC_PROTO_BIT_SONY12 |
1018 : : RC_PROTO_BIT_SONY15 |
1019 : : RC_PROTO_BIT_SONY20, "sony", "ir-sony-decoder" },
1020 : : { RC_PROTO_BIT_RC5_SZ, "rc-5-sz", "ir-rc5-decoder" },
1021 : : { RC_PROTO_BIT_SANYO, "sanyo", "ir-sanyo-decoder" },
1022 : : { RC_PROTO_BIT_SHARP, "sharp", "ir-sharp-decoder" },
1023 : : { RC_PROTO_BIT_MCIR2_KBD |
1024 : : RC_PROTO_BIT_MCIR2_MSE, "mce_kbd", "ir-mce_kbd-decoder" },
1025 : : { RC_PROTO_BIT_XMP, "xmp", "ir-xmp-decoder" },
1026 : : { RC_PROTO_BIT_CEC, "cec", NULL },
1027 : : { RC_PROTO_BIT_IMON, "imon", "ir-imon-decoder" },
1028 : : { RC_PROTO_BIT_RCMM12 |
1029 : : RC_PROTO_BIT_RCMM24 |
1030 : : RC_PROTO_BIT_RCMM32, "rc-mm", "ir-rcmm-decoder" },
1031 : : { RC_PROTO_BIT_XBOX_DVD, "xbox-dvd", NULL },
1032 : : };
1033 : :
1034 : : /**
1035 : : * struct rc_filter_attribute - Device attribute relating to a filter type.
1036 : : * @attr: Device attribute.
1037 : : * @type: Filter type.
1038 : : * @mask: false for filter value, true for filter mask.
1039 : : */
1040 : : struct rc_filter_attribute {
1041 : : struct device_attribute attr;
1042 : : enum rc_filter_type type;
1043 : : bool mask;
1044 : : };
1045 : : #define to_rc_filter_attr(a) container_of(a, struct rc_filter_attribute, attr)
1046 : :
1047 : : #define RC_FILTER_ATTR(_name, _mode, _show, _store, _type, _mask) \
1048 : : struct rc_filter_attribute dev_attr_##_name = { \
1049 : : .attr = __ATTR(_name, _mode, _show, _store), \
1050 : : .type = (_type), \
1051 : : .mask = (_mask), \
1052 : : }
1053 : :
1054 : : /**
1055 : : * show_protocols() - shows the current IR protocol(s)
1056 : : * @device: the device descriptor
1057 : : * @mattr: the device attribute struct
1058 : : * @buf: a pointer to the output buffer
1059 : : *
1060 : : * This routine is a callback routine for input read the IR protocol type(s).
1061 : : * it is triggered by reading /sys/class/rc/rc?/protocols.
1062 : : * It returns the protocol names of supported protocols.
1063 : : * Enabled protocols are printed in brackets.
1064 : : *
1065 : : * dev->lock is taken to guard against races between
1066 : : * store_protocols and show_protocols.
1067 : : */
1068 : 0 : static ssize_t show_protocols(struct device *device,
1069 : : struct device_attribute *mattr, char *buf)
1070 : : {
1071 : : struct rc_dev *dev = to_rc_dev(device);
1072 : : u64 allowed, enabled;
1073 : : char *tmp = buf;
1074 : : int i;
1075 : :
1076 : 0 : mutex_lock(&dev->lock);
1077 : :
1078 : 0 : enabled = dev->enabled_protocols;
1079 : 0 : allowed = dev->allowed_protocols;
1080 : 0 : if (dev->raw && !allowed)
1081 : 0 : allowed = ir_raw_get_allowed_protocols();
1082 : :
1083 : 0 : mutex_unlock(&dev->lock);
1084 : :
1085 : : dev_dbg(&dev->dev, "%s: allowed - 0x%llx, enabled - 0x%llx\n",
1086 : : __func__, (long long)allowed, (long long)enabled);
1087 : :
1088 : 0 : for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
1089 : 0 : if (allowed & enabled & proto_names[i].type)
1090 : 0 : tmp += sprintf(tmp, "[%s] ", proto_names[i].name);
1091 : 0 : else if (allowed & proto_names[i].type)
1092 : 0 : tmp += sprintf(tmp, "%s ", proto_names[i].name);
1093 : :
1094 : 0 : if (allowed & proto_names[i].type)
1095 : 0 : allowed &= ~proto_names[i].type;
1096 : : }
1097 : :
1098 : : #ifdef CONFIG_LIRC
1099 : 0 : if (dev->driver_type == RC_DRIVER_IR_RAW)
1100 : 0 : tmp += sprintf(tmp, "[lirc] ");
1101 : : #endif
1102 : :
1103 : 0 : if (tmp != buf)
1104 : 0 : tmp--;
1105 : 0 : *tmp = '\n';
1106 : :
1107 : 0 : return tmp + 1 - buf;
1108 : : }
1109 : :
1110 : : /**
1111 : : * parse_protocol_change() - parses a protocol change request
1112 : : * @dev: rc_dev device
1113 : : * @protocols: pointer to the bitmask of current protocols
1114 : : * @buf: pointer to the buffer with a list of changes
1115 : : *
1116 : : * Writing "+proto" will add a protocol to the protocol mask.
1117 : : * Writing "-proto" will remove a protocol from protocol mask.
1118 : : * Writing "proto" will enable only "proto".
1119 : : * Writing "none" will disable all protocols.
1120 : : * Returns the number of changes performed or a negative error code.
1121 : : */
1122 : 0 : static int parse_protocol_change(struct rc_dev *dev, u64 *protocols,
1123 : : const char *buf)
1124 : : {
1125 : : const char *tmp;
1126 : : unsigned count = 0;
1127 : : bool enable, disable;
1128 : : u64 mask;
1129 : : int i;
1130 : :
1131 : 0 : while ((tmp = strsep((char **)&buf, " \n")) != NULL) {
1132 : 0 : if (!*tmp)
1133 : : break;
1134 : :
1135 : 0 : if (*tmp == '+') {
1136 : : enable = true;
1137 : : disable = false;
1138 : 0 : tmp++;
1139 : 0 : } else if (*tmp == '-') {
1140 : : enable = false;
1141 : : disable = true;
1142 : 0 : tmp++;
1143 : : } else {
1144 : : enable = false;
1145 : : disable = false;
1146 : : }
1147 : :
1148 : 0 : for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
1149 : 0 : if (!strcasecmp(tmp, proto_names[i].name)) {
1150 : 0 : mask = proto_names[i].type;
1151 : 0 : break;
1152 : : }
1153 : : }
1154 : :
1155 : 0 : if (i == ARRAY_SIZE(proto_names)) {
1156 : 0 : if (!strcasecmp(tmp, "lirc"))
1157 : : mask = 0;
1158 : : else {
1159 : : dev_dbg(&dev->dev, "Unknown protocol: '%s'\n",
1160 : : tmp);
1161 : : return -EINVAL;
1162 : : }
1163 : : }
1164 : :
1165 : 0 : count++;
1166 : :
1167 : 0 : if (enable)
1168 : 0 : *protocols |= mask;
1169 : 0 : else if (disable)
1170 : 0 : *protocols &= ~mask;
1171 : : else
1172 : 0 : *protocols = mask;
1173 : : }
1174 : :
1175 : 0 : if (!count) {
1176 : : dev_dbg(&dev->dev, "Protocol not specified\n");
1177 : : return -EINVAL;
1178 : : }
1179 : :
1180 : 0 : return count;
1181 : : }
1182 : :
1183 : 0 : void ir_raw_load_modules(u64 *protocols)
1184 : : {
1185 : : u64 available;
1186 : : int i, ret;
1187 : :
1188 : 0 : for (i = 0; i < ARRAY_SIZE(proto_names); i++) {
1189 : 0 : if (proto_names[i].type == RC_PROTO_BIT_NONE ||
1190 : 0 : proto_names[i].type & (RC_PROTO_BIT_OTHER |
1191 : : RC_PROTO_BIT_UNKNOWN))
1192 : 0 : continue;
1193 : :
1194 : 0 : available = ir_raw_get_allowed_protocols();
1195 : 0 : if (!(*protocols & proto_names[i].type & ~available))
1196 : 0 : continue;
1197 : :
1198 : 0 : if (!proto_names[i].module_name) {
1199 : 0 : pr_err("Can't enable IR protocol %s\n",
1200 : : proto_names[i].name);
1201 : 0 : *protocols &= ~proto_names[i].type;
1202 : 0 : continue;
1203 : : }
1204 : :
1205 : 0 : ret = request_module("%s", proto_names[i].module_name);
1206 : 0 : if (ret < 0) {
1207 : 0 : pr_err("Couldn't load IR protocol module %s\n",
1208 : : proto_names[i].module_name);
1209 : 0 : *protocols &= ~proto_names[i].type;
1210 : 0 : continue;
1211 : : }
1212 : 0 : msleep(20);
1213 : 0 : available = ir_raw_get_allowed_protocols();
1214 : 0 : if (!(*protocols & proto_names[i].type & ~available))
1215 : 0 : continue;
1216 : :
1217 : 0 : pr_err("Loaded IR protocol module %s, but protocol %s still not available\n",
1218 : : proto_names[i].module_name,
1219 : : proto_names[i].name);
1220 : 0 : *protocols &= ~proto_names[i].type;
1221 : : }
1222 : 0 : }
1223 : :
1224 : : /**
1225 : : * store_protocols() - changes the current/wakeup IR protocol(s)
1226 : : * @device: the device descriptor
1227 : : * @mattr: the device attribute struct
1228 : : * @buf: a pointer to the input buffer
1229 : : * @len: length of the input buffer
1230 : : *
1231 : : * This routine is for changing the IR protocol type.
1232 : : * It is triggered by writing to /sys/class/rc/rc?/[wakeup_]protocols.
1233 : : * See parse_protocol_change() for the valid commands.
1234 : : * Returns @len on success or a negative error code.
1235 : : *
1236 : : * dev->lock is taken to guard against races between
1237 : : * store_protocols and show_protocols.
1238 : : */
1239 : 0 : static ssize_t store_protocols(struct device *device,
1240 : : struct device_attribute *mattr,
1241 : : const char *buf, size_t len)
1242 : : {
1243 : : struct rc_dev *dev = to_rc_dev(device);
1244 : : u64 *current_protocols;
1245 : : struct rc_scancode_filter *filter;
1246 : : u64 old_protocols, new_protocols;
1247 : : ssize_t rc;
1248 : :
1249 : : dev_dbg(&dev->dev, "Normal protocol change requested\n");
1250 : : current_protocols = &dev->enabled_protocols;
1251 : 0 : filter = &dev->scancode_filter;
1252 : :
1253 : 0 : if (!dev->change_protocol) {
1254 : : dev_dbg(&dev->dev, "Protocol switching not supported\n");
1255 : : return -EINVAL;
1256 : : }
1257 : :
1258 : 0 : mutex_lock(&dev->lock);
1259 : :
1260 : 0 : old_protocols = *current_protocols;
1261 : 0 : new_protocols = old_protocols;
1262 : 0 : rc = parse_protocol_change(dev, &new_protocols, buf);
1263 : 0 : if (rc < 0)
1264 : : goto out;
1265 : :
1266 : 0 : if (dev->driver_type == RC_DRIVER_IR_RAW)
1267 : 0 : ir_raw_load_modules(&new_protocols);
1268 : :
1269 : 0 : rc = dev->change_protocol(dev, &new_protocols);
1270 : 0 : if (rc < 0) {
1271 : : dev_dbg(&dev->dev, "Error setting protocols to 0x%llx\n",
1272 : : (long long)new_protocols);
1273 : : goto out;
1274 : : }
1275 : :
1276 : 0 : if (new_protocols != old_protocols) {
1277 : 0 : *current_protocols = new_protocols;
1278 : : dev_dbg(&dev->dev, "Protocols changed to 0x%llx\n",
1279 : : (long long)new_protocols);
1280 : : }
1281 : :
1282 : : /*
1283 : : * If a protocol change was attempted the filter may need updating, even
1284 : : * if the actual protocol mask hasn't changed (since the driver may have
1285 : : * cleared the filter).
1286 : : * Try setting the same filter with the new protocol (if any).
1287 : : * Fall back to clearing the filter.
1288 : : */
1289 : 0 : if (dev->s_filter && filter->mask) {
1290 : 0 : if (new_protocols)
1291 : 0 : rc = dev->s_filter(dev, filter);
1292 : : else
1293 : : rc = -1;
1294 : :
1295 : 0 : if (rc < 0) {
1296 : 0 : filter->data = 0;
1297 : 0 : filter->mask = 0;
1298 : 0 : dev->s_filter(dev, filter);
1299 : : }
1300 : : }
1301 : :
1302 : 0 : rc = len;
1303 : :
1304 : : out:
1305 : 0 : mutex_unlock(&dev->lock);
1306 : 0 : return rc;
1307 : : }
1308 : :
1309 : : /**
1310 : : * show_filter() - shows the current scancode filter value or mask
1311 : : * @device: the device descriptor
1312 : : * @attr: the device attribute struct
1313 : : * @buf: a pointer to the output buffer
1314 : : *
1315 : : * This routine is a callback routine to read a scancode filter value or mask.
1316 : : * It is triggered by reading /sys/class/rc/rc?/[wakeup_]filter[_mask].
1317 : : * It prints the current scancode filter value or mask of the appropriate filter
1318 : : * type in hexadecimal into @buf and returns the size of the buffer.
1319 : : *
1320 : : * Bits of the filter value corresponding to set bits in the filter mask are
1321 : : * compared against input scancodes and non-matching scancodes are discarded.
1322 : : *
1323 : : * dev->lock is taken to guard against races between
1324 : : * store_filter and show_filter.
1325 : : */
1326 : 0 : static ssize_t show_filter(struct device *device,
1327 : : struct device_attribute *attr,
1328 : : char *buf)
1329 : : {
1330 : : struct rc_dev *dev = to_rc_dev(device);
1331 : : struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
1332 : : struct rc_scancode_filter *filter;
1333 : : u32 val;
1334 : :
1335 : 0 : mutex_lock(&dev->lock);
1336 : :
1337 : 0 : if (fattr->type == RC_FILTER_NORMAL)
1338 : 0 : filter = &dev->scancode_filter;
1339 : : else
1340 : 0 : filter = &dev->scancode_wakeup_filter;
1341 : :
1342 : 0 : if (fattr->mask)
1343 : 0 : val = filter->mask;
1344 : : else
1345 : 0 : val = filter->data;
1346 : 0 : mutex_unlock(&dev->lock);
1347 : :
1348 : 0 : return sprintf(buf, "%#x\n", val);
1349 : : }
1350 : :
1351 : : /**
1352 : : * store_filter() - changes the scancode filter value
1353 : : * @device: the device descriptor
1354 : : * @attr: the device attribute struct
1355 : : * @buf: a pointer to the input buffer
1356 : : * @len: length of the input buffer
1357 : : *
1358 : : * This routine is for changing a scancode filter value or mask.
1359 : : * It is triggered by writing to /sys/class/rc/rc?/[wakeup_]filter[_mask].
1360 : : * Returns -EINVAL if an invalid filter value for the current protocol was
1361 : : * specified or if scancode filtering is not supported by the driver, otherwise
1362 : : * returns @len.
1363 : : *
1364 : : * Bits of the filter value corresponding to set bits in the filter mask are
1365 : : * compared against input scancodes and non-matching scancodes are discarded.
1366 : : *
1367 : : * dev->lock is taken to guard against races between
1368 : : * store_filter and show_filter.
1369 : : */
1370 : 0 : static ssize_t store_filter(struct device *device,
1371 : : struct device_attribute *attr,
1372 : : const char *buf, size_t len)
1373 : : {
1374 : : struct rc_dev *dev = to_rc_dev(device);
1375 : : struct rc_filter_attribute *fattr = to_rc_filter_attr(attr);
1376 : : struct rc_scancode_filter new_filter, *filter;
1377 : : int ret;
1378 : : unsigned long val;
1379 : : int (*set_filter)(struct rc_dev *dev, struct rc_scancode_filter *filter);
1380 : :
1381 : : ret = kstrtoul(buf, 0, &val);
1382 : 0 : if (ret < 0)
1383 : : return ret;
1384 : :
1385 : 0 : if (fattr->type == RC_FILTER_NORMAL) {
1386 : 0 : set_filter = dev->s_filter;
1387 : 0 : filter = &dev->scancode_filter;
1388 : : } else {
1389 : 0 : set_filter = dev->s_wakeup_filter;
1390 : 0 : filter = &dev->scancode_wakeup_filter;
1391 : : }
1392 : :
1393 : 0 : if (!set_filter)
1394 : : return -EINVAL;
1395 : :
1396 : 0 : mutex_lock(&dev->lock);
1397 : :
1398 : 0 : new_filter = *filter;
1399 : 0 : if (fattr->mask)
1400 : 0 : new_filter.mask = val;
1401 : : else
1402 : 0 : new_filter.data = val;
1403 : :
1404 : 0 : if (fattr->type == RC_FILTER_WAKEUP) {
1405 : : /*
1406 : : * Refuse to set a filter unless a protocol is enabled
1407 : : * and the filter is valid for that protocol
1408 : : */
1409 : 0 : if (dev->wakeup_protocol != RC_PROTO_UNKNOWN)
1410 : 0 : ret = rc_validate_filter(dev, &new_filter);
1411 : : else
1412 : : ret = -EINVAL;
1413 : :
1414 : 0 : if (ret != 0)
1415 : : goto unlock;
1416 : : }
1417 : :
1418 : 0 : if (fattr->type == RC_FILTER_NORMAL && !dev->enabled_protocols &&
1419 : : val) {
1420 : : /* refuse to set a filter unless a protocol is enabled */
1421 : : ret = -EINVAL;
1422 : : goto unlock;
1423 : : }
1424 : :
1425 : 0 : ret = set_filter(dev, &new_filter);
1426 : 0 : if (ret < 0)
1427 : : goto unlock;
1428 : :
1429 : 0 : *filter = new_filter;
1430 : :
1431 : : unlock:
1432 : 0 : mutex_unlock(&dev->lock);
1433 : 0 : return (ret < 0) ? ret : len;
1434 : : }
1435 : :
1436 : : /**
1437 : : * show_wakeup_protocols() - shows the wakeup IR protocol
1438 : : * @device: the device descriptor
1439 : : * @mattr: the device attribute struct
1440 : : * @buf: a pointer to the output buffer
1441 : : *
1442 : : * This routine is a callback routine for input read the IR protocol type(s).
1443 : : * it is triggered by reading /sys/class/rc/rc?/wakeup_protocols.
1444 : : * It returns the protocol names of supported protocols.
1445 : : * The enabled protocols are printed in brackets.
1446 : : *
1447 : : * dev->lock is taken to guard against races between
1448 : : * store_wakeup_protocols and show_wakeup_protocols.
1449 : : */
1450 : 0 : static ssize_t show_wakeup_protocols(struct device *device,
1451 : : struct device_attribute *mattr,
1452 : : char *buf)
1453 : : {
1454 : : struct rc_dev *dev = to_rc_dev(device);
1455 : : u64 allowed;
1456 : : enum rc_proto enabled;
1457 : : char *tmp = buf;
1458 : : int i;
1459 : :
1460 : 0 : mutex_lock(&dev->lock);
1461 : :
1462 : 0 : allowed = dev->allowed_wakeup_protocols;
1463 : 0 : enabled = dev->wakeup_protocol;
1464 : :
1465 : 0 : mutex_unlock(&dev->lock);
1466 : :
1467 : : dev_dbg(&dev->dev, "%s: allowed - 0x%llx, enabled - %d\n",
1468 : : __func__, (long long)allowed, enabled);
1469 : :
1470 : 0 : for (i = 0; i < ARRAY_SIZE(protocols); i++) {
1471 : 0 : if (allowed & (1ULL << i)) {
1472 : 0 : if (i == enabled)
1473 : 0 : tmp += sprintf(tmp, "[%s] ", protocols[i].name);
1474 : : else
1475 : 0 : tmp += sprintf(tmp, "%s ", protocols[i].name);
1476 : : }
1477 : : }
1478 : :
1479 : 0 : if (tmp != buf)
1480 : 0 : tmp--;
1481 : 0 : *tmp = '\n';
1482 : :
1483 : 0 : return tmp + 1 - buf;
1484 : : }
1485 : :
1486 : : /**
1487 : : * store_wakeup_protocols() - changes the wakeup IR protocol(s)
1488 : : * @device: the device descriptor
1489 : : * @mattr: the device attribute struct
1490 : : * @buf: a pointer to the input buffer
1491 : : * @len: length of the input buffer
1492 : : *
1493 : : * This routine is for changing the IR protocol type.
1494 : : * It is triggered by writing to /sys/class/rc/rc?/wakeup_protocols.
1495 : : * Returns @len on success or a negative error code.
1496 : : *
1497 : : * dev->lock is taken to guard against races between
1498 : : * store_wakeup_protocols and show_wakeup_protocols.
1499 : : */
1500 : 0 : static ssize_t store_wakeup_protocols(struct device *device,
1501 : : struct device_attribute *mattr,
1502 : : const char *buf, size_t len)
1503 : : {
1504 : : struct rc_dev *dev = to_rc_dev(device);
1505 : : enum rc_proto protocol = RC_PROTO_UNKNOWN;
1506 : : ssize_t rc;
1507 : : u64 allowed;
1508 : : int i;
1509 : :
1510 : 0 : mutex_lock(&dev->lock);
1511 : :
1512 : 0 : allowed = dev->allowed_wakeup_protocols;
1513 : :
1514 : 0 : if (!sysfs_streq(buf, "none")) {
1515 : 0 : for (i = 0; i < ARRAY_SIZE(protocols); i++) {
1516 : 0 : if ((allowed & (1ULL << i)) &&
1517 : 0 : sysfs_streq(buf, protocols[i].name)) {
1518 : 0 : protocol = i;
1519 : 0 : break;
1520 : : }
1521 : : }
1522 : :
1523 : 0 : if (i == ARRAY_SIZE(protocols)) {
1524 : : rc = -EINVAL;
1525 : : goto out;
1526 : : }
1527 : :
1528 : 0 : if (dev->encode_wakeup) {
1529 : 0 : u64 mask = 1ULL << protocol;
1530 : :
1531 : 0 : ir_raw_load_modules(&mask);
1532 : 0 : if (!mask) {
1533 : : rc = -EINVAL;
1534 : 0 : goto out;
1535 : : }
1536 : : }
1537 : : }
1538 : :
1539 : 0 : if (dev->wakeup_protocol != protocol) {
1540 : 0 : dev->wakeup_protocol = protocol;
1541 : : dev_dbg(&dev->dev, "Wakeup protocol changed to %d\n", protocol);
1542 : :
1543 : 0 : if (protocol == RC_PROTO_RC6_MCE)
1544 : 0 : dev->scancode_wakeup_filter.data = 0x800f0000;
1545 : : else
1546 : 0 : dev->scancode_wakeup_filter.data = 0;
1547 : 0 : dev->scancode_wakeup_filter.mask = 0;
1548 : :
1549 : 0 : rc = dev->s_wakeup_filter(dev, &dev->scancode_wakeup_filter);
1550 : 0 : if (rc == 0)
1551 : 0 : rc = len;
1552 : : } else {
1553 : 0 : rc = len;
1554 : : }
1555 : :
1556 : : out:
1557 : 0 : mutex_unlock(&dev->lock);
1558 : 0 : return rc;
1559 : : }
1560 : :
1561 : 0 : static void rc_dev_release(struct device *device)
1562 : : {
1563 : : struct rc_dev *dev = to_rc_dev(device);
1564 : :
1565 : 0 : kfree(dev);
1566 : 0 : }
1567 : :
1568 : : #define ADD_HOTPLUG_VAR(fmt, val...) \
1569 : : do { \
1570 : : int err = add_uevent_var(env, fmt, val); \
1571 : : if (err) \
1572 : : return err; \
1573 : : } while (0)
1574 : :
1575 : 0 : static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1576 : : {
1577 : : struct rc_dev *dev = to_rc_dev(device);
1578 : :
1579 : 0 : if (dev->rc_map.name)
1580 : 0 : ADD_HOTPLUG_VAR("NAME=%s", dev->rc_map.name);
1581 : 0 : if (dev->driver_name)
1582 : 0 : ADD_HOTPLUG_VAR("DRV_NAME=%s", dev->driver_name);
1583 : 0 : if (dev->device_name)
1584 : 0 : ADD_HOTPLUG_VAR("DEV_NAME=%s", dev->device_name);
1585 : :
1586 : : return 0;
1587 : : }
1588 : :
1589 : : /*
1590 : : * Static device attribute struct with the sysfs attributes for IR's
1591 : : */
1592 : : static struct device_attribute dev_attr_ro_protocols =
1593 : : __ATTR(protocols, 0444, show_protocols, NULL);
1594 : : static struct device_attribute dev_attr_rw_protocols =
1595 : : __ATTR(protocols, 0644, show_protocols, store_protocols);
1596 : : static DEVICE_ATTR(wakeup_protocols, 0644, show_wakeup_protocols,
1597 : : store_wakeup_protocols);
1598 : : static RC_FILTER_ATTR(filter, S_IRUGO|S_IWUSR,
1599 : : show_filter, store_filter, RC_FILTER_NORMAL, false);
1600 : : static RC_FILTER_ATTR(filter_mask, S_IRUGO|S_IWUSR,
1601 : : show_filter, store_filter, RC_FILTER_NORMAL, true);
1602 : : static RC_FILTER_ATTR(wakeup_filter, S_IRUGO|S_IWUSR,
1603 : : show_filter, store_filter, RC_FILTER_WAKEUP, false);
1604 : : static RC_FILTER_ATTR(wakeup_filter_mask, S_IRUGO|S_IWUSR,
1605 : : show_filter, store_filter, RC_FILTER_WAKEUP, true);
1606 : :
1607 : : static struct attribute *rc_dev_rw_protocol_attrs[] = {
1608 : : &dev_attr_rw_protocols.attr,
1609 : : NULL,
1610 : : };
1611 : :
1612 : : static const struct attribute_group rc_dev_rw_protocol_attr_grp = {
1613 : : .attrs = rc_dev_rw_protocol_attrs,
1614 : : };
1615 : :
1616 : : static struct attribute *rc_dev_ro_protocol_attrs[] = {
1617 : : &dev_attr_ro_protocols.attr,
1618 : : NULL,
1619 : : };
1620 : :
1621 : : static const struct attribute_group rc_dev_ro_protocol_attr_grp = {
1622 : : .attrs = rc_dev_ro_protocol_attrs,
1623 : : };
1624 : :
1625 : : static struct attribute *rc_dev_filter_attrs[] = {
1626 : : &dev_attr_filter.attr.attr,
1627 : : &dev_attr_filter_mask.attr.attr,
1628 : : NULL,
1629 : : };
1630 : :
1631 : : static const struct attribute_group rc_dev_filter_attr_grp = {
1632 : : .attrs = rc_dev_filter_attrs,
1633 : : };
1634 : :
1635 : : static struct attribute *rc_dev_wakeup_filter_attrs[] = {
1636 : : &dev_attr_wakeup_filter.attr.attr,
1637 : : &dev_attr_wakeup_filter_mask.attr.attr,
1638 : : &dev_attr_wakeup_protocols.attr,
1639 : : NULL,
1640 : : };
1641 : :
1642 : : static const struct attribute_group rc_dev_wakeup_filter_attr_grp = {
1643 : : .attrs = rc_dev_wakeup_filter_attrs,
1644 : : };
1645 : :
1646 : : static const struct device_type rc_dev_type = {
1647 : : .release = rc_dev_release,
1648 : : .uevent = rc_dev_uevent,
1649 : : };
1650 : :
1651 : 0 : struct rc_dev *rc_allocate_device(enum rc_driver_type type)
1652 : : {
1653 : : struct rc_dev *dev;
1654 : :
1655 : 0 : dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1656 : 0 : if (!dev)
1657 : : return NULL;
1658 : :
1659 : 0 : if (type != RC_DRIVER_IR_RAW_TX) {
1660 : 0 : dev->input_dev = input_allocate_device();
1661 : 0 : if (!dev->input_dev) {
1662 : 0 : kfree(dev);
1663 : 0 : return NULL;
1664 : : }
1665 : :
1666 : 0 : dev->input_dev->getkeycode = ir_getkeycode;
1667 : 0 : dev->input_dev->setkeycode = ir_setkeycode;
1668 : 0 : input_set_drvdata(dev->input_dev, dev);
1669 : :
1670 : 0 : dev->timeout = IR_DEFAULT_TIMEOUT;
1671 : 0 : timer_setup(&dev->timer_keyup, ir_timer_keyup, 0);
1672 : 0 : timer_setup(&dev->timer_repeat, ir_timer_repeat, 0);
1673 : :
1674 : 0 : spin_lock_init(&dev->rc_map.lock);
1675 : 0 : spin_lock_init(&dev->keylock);
1676 : : }
1677 : 0 : mutex_init(&dev->lock);
1678 : :
1679 : 0 : dev->dev.type = &rc_dev_type;
1680 : 0 : dev->dev.class = &rc_class;
1681 : 0 : device_initialize(&dev->dev);
1682 : :
1683 : 0 : dev->driver_type = type;
1684 : :
1685 : 0 : __module_get(THIS_MODULE);
1686 : 0 : return dev;
1687 : : }
1688 : : EXPORT_SYMBOL_GPL(rc_allocate_device);
1689 : :
1690 : 0 : void rc_free_device(struct rc_dev *dev)
1691 : : {
1692 : 0 : if (!dev)
1693 : 0 : return;
1694 : :
1695 : 0 : input_free_device(dev->input_dev);
1696 : :
1697 : 0 : put_device(&dev->dev);
1698 : :
1699 : : /* kfree(dev) will be called by the callback function
1700 : : rc_dev_release() */
1701 : :
1702 : 0 : module_put(THIS_MODULE);
1703 : : }
1704 : : EXPORT_SYMBOL_GPL(rc_free_device);
1705 : :
1706 : 0 : static void devm_rc_alloc_release(struct device *dev, void *res)
1707 : : {
1708 : 0 : rc_free_device(*(struct rc_dev **)res);
1709 : 0 : }
1710 : :
1711 : 0 : struct rc_dev *devm_rc_allocate_device(struct device *dev,
1712 : : enum rc_driver_type type)
1713 : : {
1714 : : struct rc_dev **dr, *rc;
1715 : :
1716 : : dr = devres_alloc(devm_rc_alloc_release, sizeof(*dr), GFP_KERNEL);
1717 : 0 : if (!dr)
1718 : : return NULL;
1719 : :
1720 : 0 : rc = rc_allocate_device(type);
1721 : 0 : if (!rc) {
1722 : 0 : devres_free(dr);
1723 : 0 : return NULL;
1724 : : }
1725 : :
1726 : 0 : rc->dev.parent = dev;
1727 : 0 : rc->managed_alloc = true;
1728 : 0 : *dr = rc;
1729 : 0 : devres_add(dev, dr);
1730 : :
1731 : 0 : return rc;
1732 : : }
1733 : : EXPORT_SYMBOL_GPL(devm_rc_allocate_device);
1734 : :
1735 : 0 : static int rc_prepare_rx_device(struct rc_dev *dev)
1736 : : {
1737 : : int rc;
1738 : : struct rc_map *rc_map;
1739 : : u64 rc_proto;
1740 : :
1741 : 0 : if (!dev->map_name)
1742 : : return -EINVAL;
1743 : :
1744 : 0 : rc_map = rc_map_get(dev->map_name);
1745 : 0 : if (!rc_map)
1746 : 0 : rc_map = rc_map_get(RC_MAP_EMPTY);
1747 : 0 : if (!rc_map || !rc_map->scan || rc_map->size == 0)
1748 : : return -EINVAL;
1749 : :
1750 : 0 : rc = ir_setkeytable(dev, rc_map);
1751 : 0 : if (rc)
1752 : : return rc;
1753 : :
1754 : 0 : rc_proto = BIT_ULL(rc_map->rc_proto);
1755 : :
1756 : 0 : if (dev->driver_type == RC_DRIVER_SCANCODE && !dev->change_protocol)
1757 : 0 : dev->enabled_protocols = dev->allowed_protocols;
1758 : :
1759 : 0 : if (dev->driver_type == RC_DRIVER_IR_RAW)
1760 : 0 : ir_raw_load_modules(&rc_proto);
1761 : :
1762 : 0 : if (dev->change_protocol) {
1763 : 0 : rc = dev->change_protocol(dev, &rc_proto);
1764 : 0 : if (rc < 0)
1765 : : goto out_table;
1766 : 0 : dev->enabled_protocols = rc_proto;
1767 : : }
1768 : :
1769 : : /* Keyboard events */
1770 : 0 : set_bit(EV_KEY, dev->input_dev->evbit);
1771 : 0 : set_bit(EV_REP, dev->input_dev->evbit);
1772 : 0 : set_bit(EV_MSC, dev->input_dev->evbit);
1773 : 0 : set_bit(MSC_SCAN, dev->input_dev->mscbit);
1774 : :
1775 : : /* Pointer/mouse events */
1776 : 0 : set_bit(INPUT_PROP_POINTING_STICK, dev->input_dev->propbit);
1777 : 0 : set_bit(EV_REL, dev->input_dev->evbit);
1778 : 0 : set_bit(REL_X, dev->input_dev->relbit);
1779 : 0 : set_bit(REL_Y, dev->input_dev->relbit);
1780 : :
1781 : 0 : if (dev->open)
1782 : 0 : dev->input_dev->open = ir_open;
1783 : 0 : if (dev->close)
1784 : 0 : dev->input_dev->close = ir_close;
1785 : :
1786 : 0 : dev->input_dev->dev.parent = &dev->dev;
1787 : 0 : memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
1788 : 0 : dev->input_dev->phys = dev->input_phys;
1789 : 0 : dev->input_dev->name = dev->device_name;
1790 : :
1791 : 0 : return 0;
1792 : :
1793 : : out_table:
1794 : 0 : ir_free_table(&dev->rc_map);
1795 : :
1796 : 0 : return rc;
1797 : : }
1798 : :
1799 : 0 : static int rc_setup_rx_device(struct rc_dev *dev)
1800 : : {
1801 : : int rc;
1802 : :
1803 : : /* rc_open will be called here */
1804 : 0 : rc = input_register_device(dev->input_dev);
1805 : 0 : if (rc)
1806 : : return rc;
1807 : :
1808 : : /*
1809 : : * Default delay of 250ms is too short for some protocols, especially
1810 : : * since the timeout is currently set to 250ms. Increase it to 500ms,
1811 : : * to avoid wrong repetition of the keycodes. Note that this must be
1812 : : * set after the call to input_register_device().
1813 : : */
1814 : 0 : if (dev->allowed_protocols == RC_PROTO_BIT_CEC)
1815 : 0 : dev->input_dev->rep[REP_DELAY] = 0;
1816 : : else
1817 : 0 : dev->input_dev->rep[REP_DELAY] = 500;
1818 : :
1819 : : /*
1820 : : * As a repeat event on protocols like RC-5 and NEC take as long as
1821 : : * 110/114ms, using 33ms as a repeat period is not the right thing
1822 : : * to do.
1823 : : */
1824 : 0 : dev->input_dev->rep[REP_PERIOD] = 125;
1825 : :
1826 : 0 : return 0;
1827 : : }
1828 : :
1829 : 0 : static void rc_free_rx_device(struct rc_dev *dev)
1830 : : {
1831 : 0 : if (!dev)
1832 : 0 : return;
1833 : :
1834 : 0 : if (dev->input_dev) {
1835 : 0 : input_unregister_device(dev->input_dev);
1836 : 0 : dev->input_dev = NULL;
1837 : : }
1838 : :
1839 : 0 : ir_free_table(&dev->rc_map);
1840 : : }
1841 : :
1842 : 0 : int rc_register_device(struct rc_dev *dev)
1843 : : {
1844 : : const char *path;
1845 : : int attr = 0;
1846 : : int minor;
1847 : : int rc;
1848 : :
1849 : 0 : if (!dev)
1850 : : return -EINVAL;
1851 : :
1852 : 0 : minor = ida_simple_get(&rc_ida, 0, RC_DEV_MAX, GFP_KERNEL);
1853 : 0 : if (minor < 0)
1854 : : return minor;
1855 : :
1856 : 0 : dev->minor = minor;
1857 : 0 : dev_set_name(&dev->dev, "rc%u", dev->minor);
1858 : : dev_set_drvdata(&dev->dev, dev);
1859 : :
1860 : 0 : dev->dev.groups = dev->sysfs_groups;
1861 : 0 : if (dev->driver_type == RC_DRIVER_SCANCODE && !dev->change_protocol)
1862 : 0 : dev->sysfs_groups[attr++] = &rc_dev_ro_protocol_attr_grp;
1863 : 0 : else if (dev->driver_type != RC_DRIVER_IR_RAW_TX)
1864 : 0 : dev->sysfs_groups[attr++] = &rc_dev_rw_protocol_attr_grp;
1865 : 0 : if (dev->s_filter)
1866 : 0 : dev->sysfs_groups[attr++] = &rc_dev_filter_attr_grp;
1867 : 0 : if (dev->s_wakeup_filter)
1868 : 0 : dev->sysfs_groups[attr++] = &rc_dev_wakeup_filter_attr_grp;
1869 : 0 : dev->sysfs_groups[attr++] = NULL;
1870 : :
1871 : 0 : if (dev->driver_type == RC_DRIVER_IR_RAW) {
1872 : 0 : rc = ir_raw_event_prepare(dev);
1873 : 0 : if (rc < 0)
1874 : : goto out_minor;
1875 : : }
1876 : :
1877 : 0 : if (dev->driver_type != RC_DRIVER_IR_RAW_TX) {
1878 : 0 : rc = rc_prepare_rx_device(dev);
1879 : 0 : if (rc)
1880 : : goto out_raw;
1881 : : }
1882 : :
1883 : 0 : rc = device_add(&dev->dev);
1884 : 0 : if (rc)
1885 : : goto out_rx_free;
1886 : :
1887 : 0 : path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1888 : 0 : dev_info(&dev->dev, "%s as %s\n",
1889 : : dev->device_name ?: "Unspecified device", path ?: "N/A");
1890 : 0 : kfree(path);
1891 : :
1892 : 0 : dev->registered = true;
1893 : :
1894 : : /*
1895 : : * once the the input device is registered in rc_setup_rx_device,
1896 : : * userspace can open the input device and rc_open() will be called
1897 : : * as a result. This results in driver code being allowed to submit
1898 : : * keycodes with rc_keydown, so lirc must be registered first.
1899 : : */
1900 : 0 : if (dev->allowed_protocols != RC_PROTO_BIT_CEC) {
1901 : 0 : rc = ir_lirc_register(dev);
1902 : 0 : if (rc < 0)
1903 : : goto out_dev;
1904 : : }
1905 : :
1906 : 0 : if (dev->driver_type != RC_DRIVER_IR_RAW_TX) {
1907 : 0 : rc = rc_setup_rx_device(dev);
1908 : 0 : if (rc)
1909 : : goto out_lirc;
1910 : : }
1911 : :
1912 : 0 : if (dev->driver_type == RC_DRIVER_IR_RAW) {
1913 : 0 : rc = ir_raw_event_register(dev);
1914 : 0 : if (rc < 0)
1915 : : goto out_rx;
1916 : : }
1917 : :
1918 : : dev_dbg(&dev->dev, "Registered rc%u (driver: %s)\n", dev->minor,
1919 : : dev->driver_name ? dev->driver_name : "unknown");
1920 : :
1921 : : return 0;
1922 : :
1923 : : out_rx:
1924 : 0 : rc_free_rx_device(dev);
1925 : : out_lirc:
1926 : 0 : if (dev->allowed_protocols != RC_PROTO_BIT_CEC)
1927 : 0 : ir_lirc_unregister(dev);
1928 : : out_dev:
1929 : 0 : device_del(&dev->dev);
1930 : : out_rx_free:
1931 : 0 : ir_free_table(&dev->rc_map);
1932 : : out_raw:
1933 : 0 : ir_raw_event_free(dev);
1934 : : out_minor:
1935 : 0 : ida_simple_remove(&rc_ida, minor);
1936 : 0 : return rc;
1937 : : }
1938 : : EXPORT_SYMBOL_GPL(rc_register_device);
1939 : :
1940 : 0 : static void devm_rc_release(struct device *dev, void *res)
1941 : : {
1942 : 0 : rc_unregister_device(*(struct rc_dev **)res);
1943 : 0 : }
1944 : :
1945 : 0 : int devm_rc_register_device(struct device *parent, struct rc_dev *dev)
1946 : : {
1947 : : struct rc_dev **dr;
1948 : : int ret;
1949 : :
1950 : : dr = devres_alloc(devm_rc_release, sizeof(*dr), GFP_KERNEL);
1951 : 0 : if (!dr)
1952 : : return -ENOMEM;
1953 : :
1954 : 0 : ret = rc_register_device(dev);
1955 : 0 : if (ret) {
1956 : 0 : devres_free(dr);
1957 : 0 : return ret;
1958 : : }
1959 : :
1960 : 0 : *dr = dev;
1961 : 0 : devres_add(parent, dr);
1962 : :
1963 : 0 : return 0;
1964 : : }
1965 : : EXPORT_SYMBOL_GPL(devm_rc_register_device);
1966 : :
1967 : 0 : void rc_unregister_device(struct rc_dev *dev)
1968 : : {
1969 : 0 : if (!dev)
1970 : 0 : return;
1971 : :
1972 : 0 : if (dev->driver_type == RC_DRIVER_IR_RAW)
1973 : 0 : ir_raw_event_unregister(dev);
1974 : :
1975 : 0 : del_timer_sync(&dev->timer_keyup);
1976 : 0 : del_timer_sync(&dev->timer_repeat);
1977 : :
1978 : 0 : rc_free_rx_device(dev);
1979 : :
1980 : 0 : mutex_lock(&dev->lock);
1981 : 0 : if (dev->users && dev->close)
1982 : 0 : dev->close(dev);
1983 : 0 : dev->registered = false;
1984 : 0 : mutex_unlock(&dev->lock);
1985 : :
1986 : : /*
1987 : : * lirc device should be freed with dev->registered = false, so
1988 : : * that userspace polling will get notified.
1989 : : */
1990 : 0 : if (dev->allowed_protocols != RC_PROTO_BIT_CEC)
1991 : 0 : ir_lirc_unregister(dev);
1992 : :
1993 : 0 : device_del(&dev->dev);
1994 : :
1995 : 0 : ida_simple_remove(&rc_ida, dev->minor);
1996 : :
1997 : 0 : if (!dev->managed_alloc)
1998 : 0 : rc_free_device(dev);
1999 : : }
2000 : :
2001 : : EXPORT_SYMBOL_GPL(rc_unregister_device);
2002 : :
2003 : : /*
2004 : : * Init/exit code for the module. Basically, creates/removes /sys/class/rc
2005 : : */
2006 : :
2007 : 3 : static int __init rc_core_init(void)
2008 : : {
2009 : 3 : int rc = class_register(&rc_class);
2010 : 3 : if (rc) {
2011 : 0 : pr_err("rc_core: unable to register rc class\n");
2012 : 0 : return rc;
2013 : : }
2014 : :
2015 : 3 : rc = lirc_dev_init();
2016 : 3 : if (rc) {
2017 : 0 : pr_err("rc_core: unable to init lirc\n");
2018 : 0 : class_unregister(&rc_class);
2019 : 0 : return 0;
2020 : : }
2021 : :
2022 : 3 : led_trigger_register_simple("rc-feedback", &led_feedback);
2023 : 3 : rc_map_register(&empty_map);
2024 : :
2025 : 3 : return 0;
2026 : : }
2027 : :
2028 : 0 : static void __exit rc_core_exit(void)
2029 : : {
2030 : 0 : lirc_dev_exit();
2031 : 0 : class_unregister(&rc_class);
2032 : 0 : led_trigger_unregister_simple(led_feedback);
2033 : 0 : rc_map_unregister(&empty_map);
2034 : 0 : }
2035 : :
2036 : : subsys_initcall(rc_core_init);
2037 : : module_exit(rc_core_exit);
2038 : :
2039 : : MODULE_AUTHOR("Mauro Carvalho Chehab");
2040 : : MODULE_LICENSE("GPL v2");
|
