1 // SPDX-License-Identifier: GPL-2.0-or-later
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 /*
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 {
159 if (from > ICADE_MAX_USAGE)
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 };
235 module_hid_driver(icade_driver);
236
237 MODULE_LICENSE("GPL");
238 MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
239 MODULE_DESCRIPTION("ION iCade input driver");