2 * Generic support for sparse keymaps
4 * Copyright (c) 2009 Dmitry Torokhov
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>
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.
16 #include <linux/input.h>
17 #include <linux/input/sparse-keymap.h>
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");
25 * sparse_keymap_entry_from_scancode - perform sparse keymap lookup
26 * @dev: Input device using sparse keymap
29 * This function is used to perform &struct key_entry lookup in an
30 * input device using sparse keymap.
32 struct key_entry
*sparse_keymap_entry_from_scancode(struct input_dev
*dev
,
35 struct key_entry
*key
;
37 for (key
= dev
->keycode
; key
->type
!= KE_END
; key
++)
38 if (code
== key
->code
)
43 EXPORT_SYMBOL(sparse_keymap_entry_from_scancode
);
46 * sparse_keymap_entry_from_keycode - perform sparse keymap lookup
47 * @dev: Input device using sparse keymap
50 * This function is used to perform &struct key_entry lookup in an
51 * input device using sparse keymap.
53 struct key_entry
*sparse_keymap_entry_from_keycode(struct input_dev
*dev
,
56 struct key_entry
*key
;
58 for (key
= dev
->keycode
; key
->type
!= KE_END
; key
++)
59 if (key
->type
== KE_KEY
&& keycode
== key
->keycode
)
64 EXPORT_SYMBOL(sparse_keymap_entry_from_keycode
);
66 static int sparse_keymap_getkeycode(struct input_dev
*dev
,
67 unsigned int scancode
,
68 unsigned int *keycode
)
70 const struct key_entry
*key
;
73 key
= sparse_keymap_entry_from_scancode(dev
, scancode
);
74 if (key
&& key
->type
== KE_KEY
) {
75 *keycode
= key
->keycode
;
83 static int sparse_keymap_setkeycode(struct input_dev
*dev
,
84 unsigned int scancode
,
87 struct key_entry
*key
;
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
);
106 * sparse_keymap_setup - set up sparse keymap for an 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
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().
118 int sparse_keymap_setup(struct input_dev
*dev
,
119 const struct key_entry
*keymap
,
120 int (*setup
)(struct input_dev
*, struct key_entry
*))
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
;
128 for (e
= keymap
; e
->type
!= KE_END
; e
++)
131 map
= kcalloc(map_size
, sizeof (struct key_entry
), GFP_KERNEL
);
135 memcpy(map
, keymap
, map_size
* sizeof (struct key_entry
));
137 for (i
= 0; i
< map_size
; i
++) {
141 error
= setup(dev
, entry
);
146 switch (entry
->type
) {
148 __set_bit(EV_KEY
, dev
->evbit
);
149 __set_bit(entry
->keycode
, dev
->keybit
);
153 __set_bit(EV_SW
, dev
->evbit
);
154 __set_bit(entry
->sw
.code
, dev
->swbit
);
160 dev
->keycodemax
= map_size
;
161 dev
->getkeycode
= sparse_keymap_getkeycode
;
162 dev
->setkeycode
= sparse_keymap_setkeycode
;
171 EXPORT_SYMBOL(sparse_keymap_setup
);
174 * sparse_keymap_free - free memory allocated for sparse keymap
175 * @dev: Input device using sparse keymap
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).
184 void sparse_keymap_free(struct input_dev
*dev
)
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.
193 spin_lock_irqsave(&dev
->event_lock
, flags
);
199 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
201 EXPORT_SYMBOL(sparse_keymap_free
);
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
212 * This function is used to report input event described by given
215 void sparse_keymap_report_entry(struct input_dev
*dev
, const struct key_entry
*ke
,
216 unsigned int value
, bool autorelease
)
220 input_report_key(dev
, ke
->keycode
, value
);
222 if (value
&& autorelease
) {
223 input_report_key(dev
, ke
->keycode
, 0);
229 value
= ke
->sw
.value
;
233 input_report_switch(dev
, ke
->sw
.code
, value
);
237 EXPORT_SYMBOL(sparse_keymap_report_entry
);
240 * sparse_keymap_report_event - report event corresponding to given scancode
241 * @dev: Input device using sparse keymap
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
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.
252 bool sparse_keymap_report_event(struct input_dev
*dev
, unsigned int code
,
253 unsigned int value
, bool autorelease
)
255 const struct key_entry
*ke
=
256 sparse_keymap_entry_from_scancode(dev
, code
);
259 sparse_keymap_report_entry(dev
, ke
, value
, autorelease
);
265 EXPORT_SYMBOL(sparse_keymap_report_event
);