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