]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
4ddfe028 BN |
2 | /* |
3 | * ION iCade input driver | |
4 | * | |
5 | * Copyright (c) 2012 Bastien Nocera <hadess@hadess.net> | |
6 | * Copyright (c) 2012 Benjamin Tissoires <benjamin.tissoires@gmail.com> | |
7 | */ | |
8 | ||
9 | /* | |
4ddfe028 BN |
10 | */ |
11 | ||
12 | #include <linux/device.h> | |
13 | #include <linux/hid.h> | |
14 | #include <linux/module.h> | |
15 | ||
16 | #include "hid-ids.h" | |
17 | ||
18 | /* | |
19 | * ↑ A C Y L | |
20 | * ← → | |
21 | * ↓ B X Z R | |
22 | * | |
23 | * | |
24 | * UP ON,OFF = w,e | |
25 | * RT ON,OFF = d,c | |
26 | * DN ON,OFF = x,z | |
27 | * LT ON,OFF = a,q | |
28 | * A ON,OFF = y,t | |
29 | * B ON,OFF = h,r | |
30 | * C ON,OFF = u,f | |
31 | * X ON,OFF = j,n | |
32 | * Y ON,OFF = i,m | |
33 | * Z ON,OFF = k,p | |
34 | * L ON,OFF = o,g | |
35 | * R ON,OFF = l,v | |
36 | */ | |
37 | ||
38 | /* The translation code uses HID usage instead of input layer | |
39 | * keys. This code generates a lookup table that makes | |
40 | * translation quick. | |
41 | * | |
42 | * #include <linux/input.h> | |
43 | * #include <stdio.h> | |
44 | * #include <assert.h> | |
45 | * | |
46 | * #define unk KEY_UNKNOWN | |
47 | * | |
48 | * < copy of hid_keyboard[] from hid-input.c > | |
49 | * | |
50 | * struct icade_key_translation { | |
51 | * int from; | |
52 | * const char *to; | |
53 | * int press; | |
54 | * }; | |
55 | * | |
56 | * static const struct icade_key_translation icade_keys[] = { | |
57 | * { KEY_W, "KEY_UP", 1 }, | |
58 | * { KEY_E, "KEY_UP", 0 }, | |
59 | * { KEY_D, "KEY_RIGHT", 1 }, | |
60 | * { KEY_C, "KEY_RIGHT", 0 }, | |
61 | * { KEY_X, "KEY_DOWN", 1 }, | |
62 | * { KEY_Z, "KEY_DOWN", 0 }, | |
63 | * { KEY_A, "KEY_LEFT", 1 }, | |
64 | * { KEY_Q, "KEY_LEFT", 0 }, | |
65 | * { KEY_Y, "BTN_A", 1 }, | |
66 | * { KEY_T, "BTN_A", 0 }, | |
67 | * { KEY_H, "BTN_B", 1 }, | |
68 | * { KEY_R, "BTN_B", 0 }, | |
69 | * { KEY_U, "BTN_C", 1 }, | |
70 | * { KEY_F, "BTN_C", 0 }, | |
71 | * { KEY_J, "BTN_X", 1 }, | |
72 | * { KEY_N, "BTN_X", 0 }, | |
73 | * { KEY_I, "BTN_Y", 1 }, | |
74 | * { KEY_M, "BTN_Y", 0 }, | |
75 | * { KEY_K, "BTN_Z", 1 }, | |
76 | * { KEY_P, "BTN_Z", 0 }, | |
77 | * { KEY_O, "BTN_THUMBL", 1 }, | |
78 | * { KEY_G, "BTN_THUMBL", 0 }, | |
79 | * { KEY_L, "BTN_THUMBR", 1 }, | |
80 | * { KEY_V, "BTN_THUMBR", 0 }, | |
81 | * | |
82 | * { } | |
83 | * }; | |
84 | * | |
85 | * static int | |
86 | * usage_for_key (int key) | |
87 | * { | |
88 | * int i; | |
89 | * for (i = 0; i < 256; i++) { | |
90 | * if (hid_keyboard[i] == key) | |
91 | * return i; | |
92 | * } | |
93 | * assert(0); | |
94 | * } | |
95 | * | |
96 | * int main (int argc, char **argv) | |
97 | * { | |
98 | * const struct icade_key_translation *trans; | |
99 | * int max_usage = 0; | |
100 | * | |
101 | * for (trans = icade_keys; trans->from; trans++) { | |
102 | * int usage = usage_for_key (trans->from); | |
103 | * max_usage = usage > max_usage ? usage : max_usage; | |
104 | * } | |
105 | * | |
106 | * printf ("#define ICADE_MAX_USAGE %d\n\n", max_usage); | |
107 | * printf ("struct icade_key {\n"); | |
108 | * printf ("\tu16 to;\n"); | |
109 | * printf ("\tu8 press:1;\n"); | |
110 | * printf ("};\n\n"); | |
111 | * printf ("static const struct icade_key " | |
112 | * "icade_usage_table[%d] = {\n", max_usage + 1); | |
113 | * for (trans = icade_keys; trans->from; trans++) { | |
114 | * printf ("\t[%d] = { %s, %d },\n", | |
115 | * usage_for_key (trans->from), trans->to, trans->press); | |
116 | * } | |
117 | * printf ("};\n"); | |
118 | * | |
119 | * return 0; | |
120 | * } | |
121 | */ | |
122 | ||
123 | #define ICADE_MAX_USAGE 29 | |
124 | ||
125 | struct icade_key { | |
126 | u16 to; | |
127 | u8 press:1; | |
128 | }; | |
129 | ||
130 | static const struct icade_key icade_usage_table[30] = { | |
131 | [26] = { KEY_UP, 1 }, | |
132 | [8] = { KEY_UP, 0 }, | |
133 | [7] = { KEY_RIGHT, 1 }, | |
134 | [6] = { KEY_RIGHT, 0 }, | |
135 | [27] = { KEY_DOWN, 1 }, | |
136 | [29] = { KEY_DOWN, 0 }, | |
137 | [4] = { KEY_LEFT, 1 }, | |
138 | [20] = { KEY_LEFT, 0 }, | |
139 | [28] = { BTN_A, 1 }, | |
140 | [23] = { BTN_A, 0 }, | |
141 | [11] = { BTN_B, 1 }, | |
142 | [21] = { BTN_B, 0 }, | |
143 | [24] = { BTN_C, 1 }, | |
144 | [9] = { BTN_C, 0 }, | |
145 | [13] = { BTN_X, 1 }, | |
146 | [17] = { BTN_X, 0 }, | |
147 | [12] = { BTN_Y, 1 }, | |
148 | [16] = { BTN_Y, 0 }, | |
149 | [14] = { BTN_Z, 1 }, | |
150 | [19] = { BTN_Z, 0 }, | |
151 | [18] = { BTN_THUMBL, 1 }, | |
152 | [10] = { BTN_THUMBL, 0 }, | |
153 | [15] = { BTN_THUMBR, 1 }, | |
154 | [25] = { BTN_THUMBR, 0 }, | |
155 | }; | |
156 | ||
157 | static const struct icade_key *icade_find_translation(u16 from) | |
158 | { | |
d8565014 | 159 | if (from > ICADE_MAX_USAGE) |
4ddfe028 BN |
160 | return NULL; |
161 | return &icade_usage_table[from]; | |
162 | } | |
163 | ||
164 | static int icade_event(struct hid_device *hdev, struct hid_field *field, | |
165 | struct hid_usage *usage, __s32 value) | |
166 | { | |
167 | const struct icade_key *trans; | |
168 | ||
169 | if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput || | |
170 | !usage->type) | |
171 | return 0; | |
172 | ||
173 | /* We ignore the fake key up, and act only on key down */ | |
174 | if (!value) | |
175 | return 1; | |
176 | ||
177 | trans = icade_find_translation(usage->hid & HID_USAGE); | |
178 | ||
179 | if (!trans) | |
180 | return 1; | |
181 | ||
182 | input_event(field->hidinput->input, usage->type, | |
183 | trans->to, trans->press); | |
184 | ||
185 | return 1; | |
186 | } | |
187 | ||
188 | static int icade_input_mapping(struct hid_device *hdev, struct hid_input *hi, | |
189 | struct hid_field *field, struct hid_usage *usage, | |
190 | unsigned long **bit, int *max) | |
191 | { | |
192 | const struct icade_key *trans; | |
193 | ||
194 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_KEYBOARD) { | |
195 | trans = icade_find_translation(usage->hid & HID_USAGE); | |
196 | ||
197 | if (!trans) | |
198 | return -1; | |
199 | ||
200 | hid_map_usage(hi, usage, bit, max, EV_KEY, trans->to); | |
201 | set_bit(trans->to, hi->input->keybit); | |
202 | ||
203 | return 1; | |
204 | } | |
205 | ||
206 | /* ignore others */ | |
207 | return -1; | |
208 | ||
209 | } | |
210 | ||
211 | static int icade_input_mapped(struct hid_device *hdev, struct hid_input *hi, | |
212 | struct hid_field *field, struct hid_usage *usage, | |
213 | unsigned long **bit, int *max) | |
214 | { | |
215 | if (usage->type == EV_KEY) | |
216 | set_bit(usage->type, hi->input->evbit); | |
217 | ||
218 | return -1; | |
219 | } | |
220 | ||
221 | static const struct hid_device_id icade_devices[] = { | |
222 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) }, | |
223 | ||
224 | { } | |
225 | }; | |
226 | MODULE_DEVICE_TABLE(hid, icade_devices); | |
227 | ||
228 | static struct hid_driver icade_driver = { | |
229 | .name = "icade", | |
230 | .id_table = icade_devices, | |
231 | .event = icade_event, | |
232 | .input_mapped = icade_input_mapped, | |
233 | .input_mapping = icade_input_mapping, | |
234 | }; | |
f425458e | 235 | module_hid_driver(icade_driver); |
4ddfe028 | 236 | |
4ddfe028 BN |
237 | MODULE_LICENSE("GPL"); |
238 | MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>"); | |
239 | MODULE_DESCRIPTION("ION iCade input driver"); |