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