drivers/input/sparse-keymap.c

   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 interrups/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