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