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                                     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(map);
 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