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