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 19 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>"); 20 MODULE_DESCRIPTION("Generic support for sparse keymaps"); 21 MODULE_LICENSE("GPL v2"); 22 MODULE_VERSION("0.1"); 23 24 /** 25 * sparse_keymap_entry_from_scancode - perform sparse keymap lookup 26 * @dev: Input device using sparse keymap 27 * @code: Scan code 28 * 29 * This function is used to perform &struct key_entry lookup in an 30 * input device using sparse keymap. 31 */ 32 struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev, 33 unsigned int code) 34 { 35 struct key_entry *key; 36 37 for (key = dev->keycode; key->type != KE_END; key++) 38 if (code == key->code) 39 return key; 40 41 return NULL; 42 } 43 EXPORT_SYMBOL(sparse_keymap_entry_from_scancode); 44 45 /** 46 * sparse_keymap_entry_from_keycode - perform sparse keymap lookup 47 * @dev: Input device using sparse keymap 48 * @keycode: Key code 49 * 50 * This function is used to perform &struct key_entry lookup in an 51 * input device using sparse keymap. 52 */ 53 struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev, 54 unsigned int keycode) 55 { 56 struct key_entry *key; 57 58 for (key = dev->keycode; key->type != KE_END; key++) 59 if (key->type == KE_KEY && keycode == key->keycode) 60 return key; 61 62 return NULL; 63 } 64 EXPORT_SYMBOL(sparse_keymap_entry_from_keycode); 65 66 static int sparse_keymap_getkeycode(struct input_dev *dev, 67 int scancode, int *keycode) 68 { 69 const struct key_entry *key = 70 sparse_keymap_entry_from_scancode(dev, scancode); 71 72 if (key && key->type == KE_KEY) { 73 *keycode = key->keycode; 74 return 0; 75 } 76 77 return -EINVAL; 78 } 79 80 static int sparse_keymap_setkeycode(struct input_dev *dev, 81 int scancode, int keycode) 82 { 83 struct key_entry *key; 84 int old_keycode; 85 86 if (keycode < 0 || keycode > KEY_MAX) 87 return -EINVAL; 88 89 key = sparse_keymap_entry_from_scancode(dev, scancode); 90 if (key && key->type == KE_KEY) { 91 old_keycode = key->keycode; 92 key->keycode = keycode; 93 set_bit(keycode, dev->keybit); 94 if (!sparse_keymap_entry_from_keycode(dev, old_keycode)) 95 clear_bit(old_keycode, dev->keybit); 96 return 0; 97 } 98 99 return -EINVAL; 100 } 101 102 /** 103 * sparse_keymap_setup - set up sparse keymap for an input device 104 * @dev: Input device 105 * @keymap: Keymap in form of array of &key_entry structures ending 106 * with %KE_END type entry 107 * @setup: Function that can be used to adjust keymap entries 108 * depending on device's deeds, may be %NULL 109 * 110 * The function calculates size and allocates copy of the original 111 * keymap after which sets up input device event bits appropriately. 112 * Before destroying input device allocated keymap should be freed 113 * with a call to sparse_keymap_free(). 114 */ 115 int sparse_keymap_setup(struct input_dev *dev, 116 const struct key_entry *keymap, 117 int (*setup)(struct input_dev *, struct key_entry *)) 118 { 119 size_t map_size = 1; /* to account for the last KE_END entry */ 120 const struct key_entry *e; 121 struct key_entry *map, *entry; 122 int i; 123 int error; 124 125 for (e = keymap; e->type != KE_END; e++) 126 map_size++; 127 128 map = kcalloc(map_size, sizeof (struct key_entry), GFP_KERNEL); 129 if (!map) 130 return -ENOMEM; 131 132 memcpy(map, keymap, map_size * sizeof (struct key_entry)); 133 134 for (i = 0; i < map_size; i++) { 135 entry = &map[i]; 136 137 if (setup) { 138 error = setup(dev, entry); 139 if (error) 140 goto err_out; 141 } 142 143 switch (entry->type) { 144 case KE_KEY: 145 __set_bit(EV_KEY, dev->evbit); 146 __set_bit(entry->keycode, dev->keybit); 147 break; 148 149 case KE_SW: 150 __set_bit(EV_SW, dev->evbit); 151 __set_bit(entry->sw.code, dev->swbit); 152 break; 153 } 154 } 155 156 dev->keycode = map; 157 dev->keycodemax = map_size; 158 dev->getkeycode = sparse_keymap_getkeycode; 159 dev->setkeycode = sparse_keymap_setkeycode; 160 161 return 0; 162 163 err_out: 164 kfree(keymap); 165 return error; 166 167 } 168 EXPORT_SYMBOL(sparse_keymap_setup); 169 170 /** 171 * sparse_keymap_free - free memory allocated for sparse keymap 172 * @dev: Input device using sparse keymap 173 * 174 * This function is used to free memory allocated by sparse keymap 175 * in an input device that was set up by sparse_keymap_setup(). 176 */ 177 void sparse_keymap_free(struct input_dev *dev) 178 { 179 kfree(dev->keycode); 180 dev->keycode = NULL; 181 dev->keycodemax = 0; 182 dev->getkeycode = NULL; 183 dev->setkeycode = NULL; 184 } 185 EXPORT_SYMBOL(sparse_keymap_free); 186 187 /** 188 * sparse_keymap_report_entry - report event corresponding to given key entry 189 * @dev: Input device for which event should be reported 190 * @ke: key entry describing event 191 * @value: Value that should be reported (ignored by %KE_SW entries) 192 * @autorelease: Signals whether release event should be emitted for %KE_KEY 193 * entries right after reporting press event, ignored by all other 194 * entries 195 * 196 * This function is used to report input event described by given 197 * &struct key_entry. 198 */ 199 void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke, 200 unsigned int value, bool autorelease) 201 { 202 switch (ke->type) { 203 case KE_KEY: 204 input_report_key(dev, ke->keycode, value); 205 input_sync(dev); 206 if (value && autorelease) { 207 input_report_key(dev, ke->keycode, 0); 208 input_sync(dev); 209 } 210 break; 211 212 case KE_SW: 213 value = ke->sw.value; 214 /* fall through */ 215 216 case KE_VSW: 217 input_report_switch(dev, ke->sw.code, value); 218 break; 219 } 220 } 221 EXPORT_SYMBOL(sparse_keymap_report_entry); 222 223 /** 224 * sparse_keymap_report_event - report event corresponding to given scancode 225 * @dev: Input device using sparse keymap 226 * @code: Scan code 227 * @value: Value that should be reported (ignored by %KE_SW entries) 228 * @autorelease: Signals whether release event should be emitted for %KE_KEY 229 * entries right after reporting press event, ignored by all other 230 * entries 231 * 232 * This function is used to perform lookup in an input device using sparse 233 * keymap and report corresponding event. Returns %true if lookup was 234 * successful and %false otherwise. 235 */ 236 bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code, 237 unsigned int value, bool autorelease) 238 { 239 const struct key_entry *ke = 240 sparse_keymap_entry_from_scancode(dev, code); 241 242 if (ke) { 243 sparse_keymap_report_entry(dev, ke, value, autorelease); 244 return true; 245 } 246 247 return false; 248 } 249 EXPORT_SYMBOL(sparse_keymap_report_event); 250 251