-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Input: add generic support for sparse keymaps
More and more devices choose to reimplement support for sparse keymaps first introduced by wistron driver. Move it into a library module so it can be easily used by interested parties. Reviewed-by: Anisse Astier <anisse@astier.eu> Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
- Loading branch information
Dmitry Torokhov
committed
Dec 7, 2009
1 parent
6a47081
commit 36203c4
Showing
6 changed files
with
347 additions
and
12 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,250 @@ | ||
| /* | ||
| * Generic support for sparse keymaps | ||
| * | ||
| * Copyright (c) 2009 Dmitry Torokhov | ||
| * | ||
| * Derived from wistron button driver: | ||
| * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz> | ||
| * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org> | ||
| * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru> | ||
| * | ||
| * This program is free software; you can redistribute it and/or modify it | ||
| * under the terms of the GNU General Public License version 2 as published by | ||
| * the Free Software Foundation. | ||
| */ | ||
|
|
||
| #include <linux/input.h> | ||
| #include <linux/input/sparse-keymap.h> | ||
|
|
||
| MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>"); | ||
| MODULE_DESCRIPTION("Generic support for sparse keymaps"); | ||
| MODULE_LICENSE("GPL v2"); | ||
| MODULE_VERSION("0.1"); | ||
|
|
||
| /** | ||
| * sparse_keymap_entry_from_scancode - perform sparse keymap lookup | ||
| * @dev: Input device using sparse keymap | ||
| * @code: Scan code | ||
| * | ||
| * This function is used to perform &struct key_entry lookup in an | ||
| * input device using sparse keymap. | ||
| */ | ||
| struct key_entry *sparse_keymap_entry_from_scancode(struct input_dev *dev, | ||
| unsigned int code) | ||
| { | ||
| struct key_entry *key; | ||
|
|
||
| for (key = dev->keycode; key->type != KE_END; key++) | ||
| if (code == key->code) | ||
| return key; | ||
|
|
||
| return NULL; | ||
| } | ||
| EXPORT_SYMBOL(sparse_keymap_entry_from_scancode); | ||
|
|
||
| /** | ||
| * sparse_keymap_entry_from_keycode - perform sparse keymap lookup | ||
| * @dev: Input device using sparse keymap | ||
| * @keycode: Key code | ||
| * | ||
| * This function is used to perform &struct key_entry lookup in an | ||
| * input device using sparse keymap. | ||
| */ | ||
| struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev, | ||
| unsigned int keycode) | ||
| { | ||
| struct key_entry *key; | ||
|
|
||
| for (key = dev->keycode; key->type != KE_END; key++) | ||
| if (key->type == KE_KEY && keycode == key->keycode) | ||
| return key; | ||
|
|
||
| return NULL; | ||
| } | ||
| EXPORT_SYMBOL(sparse_keymap_entry_from_keycode); | ||
|
|
||
| static int sparse_keymap_getkeycode(struct input_dev *dev, | ||
| int scancode, int *keycode) | ||
| { | ||
| const struct key_entry *key = | ||
| sparse_keymap_entry_from_scancode(dev, scancode); | ||
|
|
||
| if (key && key->type == KE_KEY) { | ||
| *keycode = key->keycode; | ||
| return 0; | ||
| } | ||
|
|
||
| return -EINVAL; | ||
| } | ||
|
|
||
| static int sparse_keymap_setkeycode(struct input_dev *dev, | ||
| int scancode, int keycode) | ||
| { | ||
| struct key_entry *key; | ||
| int old_keycode; | ||
|
|
||
| if (keycode < 0 || keycode > KEY_MAX) | ||
| return -EINVAL; | ||
|
|
||
| key = sparse_keymap_entry_from_scancode(dev, scancode); | ||
| if (key && key->type == KE_KEY) { | ||
| old_keycode = key->keycode; | ||
| key->keycode = keycode; | ||
| set_bit(keycode, dev->keybit); | ||
| if (!sparse_keymap_entry_from_keycode(dev, old_keycode)) | ||
| clear_bit(old_keycode, dev->keybit); | ||
| return 0; | ||
| } | ||
|
|
||
| return -EINVAL; | ||
| } | ||
|
|
||
| /** | ||
| * sparse_keymap_setup - set up sparse keymap for an input device | ||
| * @dev: Input device | ||
| * @keymap: Keymap in form of array of &key_entry structures ending | ||
| * with %KE_END type entry | ||
| * @setup: Function that can be used to adjust keymap entries | ||
| * depending on device's deeds, may be %NULL | ||
| * | ||
| * The function calculates size and allocates copy of the original | ||
| * keymap after which sets up input device event bits appropriately. | ||
| * Before destroying input device allocated keymap should be freed | ||
| * with a call to sparse_keymap_free(). | ||
| */ | ||
| int sparse_keymap_setup(struct input_dev *dev, | ||
| const struct key_entry *keymap, | ||
| int (*setup)(struct input_dev *, struct key_entry *)) | ||
| { | ||
| size_t map_size = 1; /* to account for the last KE_END entry */ | ||
| const struct key_entry *e; | ||
| struct key_entry *map, *entry; | ||
| int i; | ||
| int error; | ||
|
|
||
| for (e = keymap; e->type != KE_END; e++) | ||
| map_size++; | ||
|
|
||
| map = kcalloc(map_size, sizeof (struct key_entry), GFP_KERNEL); | ||
| if (!map) | ||
| return -ENOMEM; | ||
|
|
||
| memcpy(map, keymap, map_size * sizeof (struct key_entry)); | ||
|
|
||
| for (i = 0; i < map_size; i++) { | ||
| entry = &map[i]; | ||
|
|
||
| if (setup) { | ||
| error = setup(dev, entry); | ||
| if (error) | ||
| goto err_out; | ||
| } | ||
|
|
||
| switch (entry->type) { | ||
| case KE_KEY: | ||
| __set_bit(EV_KEY, dev->evbit); | ||
| __set_bit(entry->keycode, dev->keybit); | ||
| break; | ||
|
|
||
| case KE_SW: | ||
| __set_bit(EV_SW, dev->evbit); | ||
| __set_bit(entry->sw.code, dev->swbit); | ||
| break; | ||
| } | ||
| } | ||
|
|
||
| dev->keycode = map; | ||
| dev->keycodemax = map_size; | ||
| dev->getkeycode = sparse_keymap_getkeycode; | ||
| dev->setkeycode = sparse_keymap_setkeycode; | ||
|
|
||
| return 0; | ||
|
|
||
| err_out: | ||
| kfree(keymap); | ||
| return error; | ||
|
|
||
| } | ||
| EXPORT_SYMBOL(sparse_keymap_setup); | ||
|
|
||
| /** | ||
| * sparse_keymap_free - free memory allocated for sparse keymap | ||
| * @dev: Input device using sparse keymap | ||
| * | ||
| * This function is used to free memory allocated by sparse keymap | ||
| * in an input device that was set up by sparse_keymap_setup(). | ||
| */ | ||
| void sparse_keymap_free(struct input_dev *dev) | ||
| { | ||
| kfree(dev->keycode); | ||
| dev->keycode = NULL; | ||
| dev->keycodemax = 0; | ||
| dev->getkeycode = NULL; | ||
| dev->setkeycode = NULL; | ||
| } | ||
| EXPORT_SYMBOL(sparse_keymap_free); | ||
|
|
||
| /** | ||
| * sparse_keymap_report_entry - report event corresponding to given key entry | ||
| * @dev: Input device for which event should be reported | ||
| * @ke: key entry describing event | ||
| * @value: Value that should be reported (ignored by %KE_SW entries) | ||
| * @autorelease: Signals whether release event should be emitted for %KE_KEY | ||
| * entries right after reporting press event, ignored by all other | ||
| * entries | ||
| * | ||
| * This function is used to report input event described by given | ||
| * &struct key_entry. | ||
| */ | ||
| void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *ke, | ||
| unsigned int value, bool autorelease) | ||
| { | ||
| switch (ke->type) { | ||
| case KE_KEY: | ||
| input_report_key(dev, ke->keycode, value); | ||
| input_sync(dev); | ||
| if (value && autorelease) { | ||
| input_report_key(dev, ke->keycode, 0); | ||
| input_sync(dev); | ||
| } | ||
| break; | ||
|
|
||
| case KE_SW: | ||
| value = ke->sw.value; | ||
| /* fall through */ | ||
|
|
||
| case KE_VSW: | ||
| input_report_switch(dev, ke->sw.code, value); | ||
| break; | ||
| } | ||
| } | ||
| EXPORT_SYMBOL(sparse_keymap_report_entry); | ||
|
|
||
| /** | ||
| * sparse_keymap_report_event - report event corresponding to given scancode | ||
| * @dev: Input device using sparse keymap | ||
| * @code: Scan code | ||
| * @value: Value that should be reported (ignored by %KE_SW entries) | ||
| * @autorelease: Signals whether release event should be emitted for %KE_KEY | ||
| * entries right after reporting press event, ignored by all other | ||
| * entries | ||
| * | ||
| * This function is used to perform lookup in an input device using sparse | ||
| * keymap and report corresponding event. Returns %true if lookup was | ||
| * successful and %false otherwise. | ||
| */ | ||
| bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code, | ||
| unsigned int value, bool autorelease) | ||
| { | ||
| const struct key_entry *ke = | ||
| sparse_keymap_entry_from_scancode(dev, code); | ||
|
|
||
| if (ke) { | ||
| sparse_keymap_report_entry(dev, ke, value, autorelease); | ||
| return true; | ||
| } | ||
|
|
||
| return false; | ||
| } | ||
| EXPORT_SYMBOL(sparse_keymap_report_event); | ||
|
|
Oops, something went wrong.