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>
18 #include <linux/slab.h>
20 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
21 MODULE_DESCRIPTION("Generic support for sparse keymaps");
22 MODULE_LICENSE("GPL v2");
23 MODULE_VERSION("0.1");
26 * sparse_keymap_entry_from_scancode - perform sparse keymap lookup
27 * @dev: Input device using sparse keymap
30 * This function is used to perform &struct key_entry lookup in an
31 * input device using sparse keymap.
33 struct key_entry
*sparse_keymap_entry_from_scancode(struct input_dev
*dev
,
36 struct key_entry
*key
;
38 for (key
= dev
->keycode
; key
->type
!= KE_END
; key
++)
39 if (code
== key
->code
)
44 EXPORT_SYMBOL(sparse_keymap_entry_from_scancode
);
47 * sparse_keymap_entry_from_keycode - perform sparse keymap lookup
48 * @dev: Input device using sparse keymap
51 * This function is used to perform &struct key_entry lookup in an
52 * input device using sparse keymap.
54 struct key_entry
*sparse_keymap_entry_from_keycode(struct input_dev
*dev
,
57 struct key_entry
*key
;
59 for (key
= dev
->keycode
; key
->type
!= KE_END
; key
++)
60 if (key
->type
== KE_KEY
&& keycode
== key
->keycode
)
65 EXPORT_SYMBOL(sparse_keymap_entry_from_keycode
);
67 static int sparse_keymap_getkeycode(struct input_dev
*dev
,
68 unsigned int scancode
,
69 unsigned int *keycode
)
71 const struct key_entry
*key
=
72 sparse_keymap_entry_from_scancode(dev
, scancode
);
74 if (key
&& key
->type
== KE_KEY
) {
75 *keycode
= key
->keycode
;
82 static int sparse_keymap_setkeycode(struct input_dev
*dev
,
83 unsigned int scancode
,
86 struct key_entry
*key
;
89 if (keycode
< 0 || keycode
> KEY_MAX
)
92 key
= sparse_keymap_entry_from_scancode(dev
, scancode
);
93 if (key
&& key
->type
== KE_KEY
) {
94 old_keycode
= key
->keycode
;
95 key
->keycode
= keycode
;
96 set_bit(keycode
, dev
->keybit
);
97 if (!sparse_keymap_entry_from_keycode(dev
, old_keycode
))
98 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().
180 void sparse_keymap_free(struct input_dev
*dev
)
185 dev
->getkeycode
= NULL
;
186 dev
->setkeycode
= NULL
;
188 EXPORT_SYMBOL(sparse_keymap_free
);
191 * sparse_keymap_report_entry - report event corresponding to given key entry
192 * @dev: Input device for which event should be reported
193 * @ke: key entry describing event
194 * @value: Value that should be reported (ignored by %KE_SW entries)
195 * @autorelease: Signals whether release event should be emitted for %KE_KEY
196 * entries right after reporting press event, ignored by all other
199 * This function is used to report input event described by given
202 void sparse_keymap_report_entry(struct input_dev
*dev
, const struct key_entry
*ke
,
203 unsigned int value
, bool autorelease
)
207 input_report_key(dev
, ke
->keycode
, value
);
209 if (value
&& autorelease
) {
210 input_report_key(dev
, ke
->keycode
, 0);
216 value
= ke
->sw
.value
;
220 input_report_switch(dev
, ke
->sw
.code
, value
);
224 EXPORT_SYMBOL(sparse_keymap_report_entry
);
227 * sparse_keymap_report_event - report event corresponding to given scancode
228 * @dev: Input device using sparse keymap
230 * @value: Value that should be reported (ignored by %KE_SW entries)
231 * @autorelease: Signals whether release event should be emitted for %KE_KEY
232 * entries right after reporting press event, ignored by all other
235 * This function is used to perform lookup in an input device using sparse
236 * keymap and report corresponding event. Returns %true if lookup was
237 * successful and %false otherwise.
239 bool sparse_keymap_report_event(struct input_dev
*dev
, unsigned int code
,
240 unsigned int value
, bool autorelease
)
242 const struct key_entry
*ke
=
243 sparse_keymap_entry_from_scancode(dev
, code
);
246 sparse_keymap_report_entry(dev
, ke
, value
, autorelease
);
252 EXPORT_SYMBOL(sparse_keymap_report_event
);