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