1 /* 2 * Generic support for sparse keymaps 3 * 4 * Copyright (c) 2009 Dmitry Torokhov 5 * 6 * Derived from wistron button driver: 7 * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz> 8 * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org> 9 * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru> 10 * 11 * This program is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License version 2 as published by 13 * the Free Software Foundation. 14 */ 15 16 #include <linux/input.h> 17 #include <linux/input/sparse-keymap.h> 18 #include <linux/module.h> 19 #include <linux/slab.h> 20 21 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>"); 22 MODULE_DESCRIPTION("Generic support for sparse keymaps"); 23 MODULE_LICENSE("GPL v2"); 24 MODULE_VERSION("0.1"); 25 26 static unsigned int sparse_keymap_get_key_index(struct input_dev *dev, 27 const struct key_entry *k) 28 { 29 struct key_entry *key; 30 unsigned int idx = 0; 31 32 for (key = dev->keycode; key->type != KE_END; key++) { 33 if (key->type == KE_KEY) { 34 if (key == k) 35 break; 36 idx++; 37 } 38 } 39 40 return idx; 41 } 42 43 static struct key_entry *sparse_keymap_entry_by_index(struct input_dev *dev, 44 unsigned int index) 45 { 46 struct key_entry *key; 47 unsigned int key_cnt = 0; 48 49 for (key = dev->keycode; key->type != KE_END; key++) 50 if (key->type == KE_KEY) 51 if (key_cnt++ == index) 52 return key; 53 54 return NULL; 55 } 56 57 /** 58 * sparse_keymap_entry_from_scancode - perform sparse keymap lookup 59 * @dev: Input device using sparse keymap 60 * @code: Scan code 61 * 62 * This function is used to perform &struct key_entry lookup in an 63 * input device using sparse keymap. 64 */ 65 struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev, 66 unsigned int code) 67 { 68 struct key_entry *key; 69 70 for (key = dev->keycode; key->type != KE_END; key++) 71 if (code == key->code) 72 return key; 73 74 return NULL; 75 } 76 EXPORT_SYMBOL(sparse_keymap_entry_from_scancode); 77 78 /** 79 * sparse_keymap_entry_from_keycode - perform sparse keymap lookup 80 * @dev: Input device using sparse keymap 81 * @keycode: Key code 82 * 83 * This function is used to perform &struct key_entry lookup in an 84 * input device using sparse keymap. 85 */ 86 struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev, 87 unsigned int keycode) 88 { 89 struct key_entry *key; 90 91 for (key = dev->keycode; key->type != KE_END; key++) 92 if (key->type == KE_KEY && keycode == key->keycode) 93 return key; 94 95 return NULL; 96 } 97 EXPORT_SYMBOL(sparse_keymap_entry_from_keycode); 98 99 static struct key_entry *sparse_keymap_locate(struct input_dev *dev, 100 const struct input_keymap_entry *ke) 101 { 102 struct key_entry *key; 103 unsigned int scancode; 104 105 if (ke->flags & INPUT_KEYMAP_BY_INDEX) 106 key = sparse_keymap_entry_by_index(dev, ke->index); 107 else if (input_scancode_to_scalar(ke, &scancode) == 0) 108 key = sparse_keymap_entry_from_scancode(dev, scancode); 109 else 110 key = NULL; 111 112 return key; 113 } 114 115 static int sparse_keymap_getkeycode(struct input_dev *dev, 116 struct input_keymap_entry *ke) 117 { 118 const struct key_entry *key; 119 120 if (dev->keycode) { 121 key = sparse_keymap_locate(dev, ke); 122 if (key && key->type == KE_KEY) { 123 ke->keycode = key->keycode; 124 if (!(ke->flags & INPUT_KEYMAP_BY_INDEX)) 125 ke->index = 126 sparse_keymap_get_key_index(dev, key); 127 ke->len = sizeof(key->code); 128 memcpy(ke->scancode, &key->code, sizeof(key->code)); 129 return 0; 130 } 131 } 132 133 return -EINVAL; 134 } 135 136 static int sparse_keymap_setkeycode(struct input_dev *dev, 137 const struct input_keymap_entry *ke, 138 unsigned int *old_keycode) 139 { 140 struct key_entry *key; 141 142 if (dev->keycode) { 143 key = sparse_keymap_locate(dev, ke); 144 if (key && key->type == KE_KEY) { 145 *old_keycode = key->keycode; 146 key->keycode = ke->keycode; 147 set_bit(ke->keycode, dev->keybit); 148 if (!sparse_keymap_entry_from_keycode(dev, *old_keycode)) 149 clear_bit(*old_keycode, dev->keybit); 150 return 0; 151 } 152 } 153 154 return -EINVAL; 155 } 156 157 /** 158 * sparse_keymap_setup - set up sparse keymap for an input device 159 * @dev: Input device 160 * @keymap: Keymap in form of array of &key_entry structures ending 161 * with %KE_END type entry 162 * @setup: Function that can be used to adjust keymap entries 163 * depending on device's deeds, may be %NULL 164 * 165 * The function calculates size and allocates copy of the original 166 * keymap after which sets up input device event bits appropriately. 167 * Before destroying input device allocated keymap should be freed 168 * with a call to sparse_keymap_free(). 169 */ 170 int sparse_keymap_setup(struct input_dev *dev, 171 const struct key_entry *keymap, 172 int (*setup)(struct input_dev *, struct key_entry *)) 173 { 174 size_t map_size = 1; /* to account for the last KE_END entry */ 175 const struct key_entry *e; 176 struct key_entry *map, *entry; 177 int i; 178 int error; 179 180 for (e = keymap; e->type != KE_END; e++) 181 map_size++; 182 183 map = kcalloc(map_size, sizeof(struct key_entry), GFP_KERNEL); 184 if (!map) 185 return -ENOMEM; 186 187 memcpy(map, keymap, map_size * sizeof(struct key_entry)); 188 189 for (i = 0; i < map_size; i++) { 190 entry = &map[i]; 191 192 if (setup) { 193 error = setup(dev, entry); 194 if (error) 195 goto err_out; 196 } 197 198 switch (entry->type) { 199 case KE_KEY: 200 __set_bit(EV_KEY, dev->evbit); 201 __set_bit(entry->keycode, dev->keybit); 202 break; 203 204 case KE_SW: 205 case KE_VSW: 206 __set_bit(EV_SW, dev->evbit); 207 __set_bit(entry->sw.code, dev->swbit); 208 break; 209 } 210 } 211 212 if (test_bit(EV_KEY, dev->evbit)) { 213 __set_bit(KEY_UNKNOWN, dev->keybit); 214 __set_bit(EV_MSC, dev->evbit); 215 __set_bit(MSC_SCAN, dev->mscbit); 216 } 217 218 dev->keycode = map; 219 dev->keycodemax = map_size; 220 dev->getkeycode = sparse_keymap_getkeycode; 221 dev->setkeycode = sparse_keymap_setkeycode; 222 223 return 0; 224 225 err_out: 226 kfree(map); 227 return error; 228 } 229 EXPORT_SYMBOL(sparse_keymap_setup); 230 231 /** 232 * sparse_keymap_free - free memory allocated for sparse keymap 233 * @dev: Input device using sparse keymap 234 * 235 * This function is used to free memory allocated by sparse keymap 236 * in an input device that was set up by sparse_keymap_setup(). 237 * NOTE: It is safe to cal this function while input device is 238 * still registered (however the drivers should care not to try to 239 * use freed keymap and thus have to shut off interrupts/polling 240 * before freeing the keymap). 241 */ 242 void sparse_keymap_free(struct input_dev *dev) 243 { 244 unsigned long flags; 245 246 /* 247 * Take event lock to prevent racing with input_get_keycode() 248 * and input_set_keycode() if we are called while input device 249 * is still registered. 250 */ 251 spin_lock_irqsave(&dev->event_lock, flags); 252 253 kfree(dev->keycode); 254 dev->keycode = NULL; 255 dev->keycodemax = 0; 256 257 spin_unlock_irqrestore(&dev->event_lock, flags); 258 } 259 EXPORT_SYMBOL(sparse_keymap_free); 260 261 /** 262 * sparse_keymap_report_entry - report event corresponding to given key entry 263 * @dev: Input device for which event should be reported 264 * @ke: key entry describing event 265 * @value: Value that should be reported (ignored by %KE_SW entries) 266 * @autorelease: Signals whether release event should be emitted for %KE_KEY 267 * entries right after reporting press event, ignored by all other 268 * entries 269 * 270 * This function is used to report input event described by given 271 * &struct key_entry. 272 */ 273 void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke, 274 unsigned int value, bool autorelease) 275 { 276 switch (ke->type) { 277 case KE_KEY: 278 input_event(dev, EV_MSC, MSC_SCAN, ke->code); 279 input_report_key(dev, ke->keycode, value); 280 input_sync(dev); 281 if (value && autorelease) { 282 input_report_key(dev, ke->keycode, 0); 283 input_sync(dev); 284 } 285 break; 286 287 case KE_SW: 288 value = ke->sw.value; 289 /* fall through */ 290 291 case KE_VSW: 292 input_report_switch(dev, ke->sw.code, value); 293 break; 294 } 295 } 296 EXPORT_SYMBOL(sparse_keymap_report_entry); 297 298 /** 299 * sparse_keymap_report_event - report event corresponding to given scancode 300 * @dev: Input device using sparse keymap 301 * @code: Scan code 302 * @value: Value that should be reported (ignored by %KE_SW entries) 303 * @autorelease: Signals whether release event should be emitted for %KE_KEY 304 * entries right after reporting press event, ignored by all other 305 * entries 306 * 307 * This function is used to perform lookup in an input device using sparse 308 * keymap and report corresponding event. Returns %true if lookup was 309 * successful and %false otherwise. 310 */ 311 bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code, 312 unsigned int value, bool autorelease) 313 { 314 const struct key_entry *ke = 315 sparse_keymap_entry_from_scancode(dev, code); 316 struct key_entry unknown_ke; 317 318 if (ke) { 319 sparse_keymap_report_entry(dev, ke, value, autorelease); 320 return true; 321 } 322 323 /* Report an unknown key event as a debugging aid */ 324 unknown_ke.type = KE_KEY; 325 unknown_ke.code = code; 326 unknown_ke.keycode = KEY_UNKNOWN; 327 sparse_keymap_report_entry(dev, &unknown_ke, value, true); 328 329 return false; 330 } 331 EXPORT_SYMBOL(sparse_keymap_report_event); 332 333