Commit | Line | Data |
---|---|---|
cb99221b DH |
1 | /* |
2 | * HID driver for Nintendo Wiimote extension devices | |
3 | * Copyright (c) 2011 David Herrmann | |
4 | */ | |
5 | ||
6 | /* | |
7 | * This program is free software; you can redistribute it and/or modify it | |
8 | * under the terms of the GNU General Public License as published by the Free | |
9 | * Software Foundation; either version 2 of the License, or (at your option) | |
10 | * any later version. | |
11 | */ | |
12 | ||
13 | #include <linux/atomic.h> | |
14 | #include <linux/module.h> | |
15 | #include <linux/spinlock.h> | |
16 | #include <linux/workqueue.h> | |
17 | #include "hid-wiimote.h" | |
18 | ||
19 | struct wiimote_ext { | |
20 | struct wiimote_data *wdata; | |
21 | struct work_struct worker; | |
479901ba DH |
22 | struct input_dev *input; |
23 | struct input_dev *mp_input; | |
cb99221b DH |
24 | |
25 | atomic_t opened; | |
26 | atomic_t mp_opened; | |
27 | bool plugged; | |
b17b57a5 | 28 | bool mp_plugged; |
cb99221b DH |
29 | bool motionp; |
30 | __u8 ext_type; | |
31 | }; | |
32 | ||
33 | enum wiiext_type { | |
34 | WIIEXT_NONE, /* placeholder */ | |
35 | WIIEXT_CLASSIC, /* Nintendo classic controller */ | |
36 | WIIEXT_NUNCHUCK, /* Nintendo nunchuck controller */ | |
37 | }; | |
38 | ||
a5353501 DH |
39 | enum wiiext_keys { |
40 | WIIEXT_KEY_C, | |
41 | WIIEXT_KEY_Z, | |
5906215b DH |
42 | WIIEXT_KEY_A, |
43 | WIIEXT_KEY_B, | |
44 | WIIEXT_KEY_X, | |
45 | WIIEXT_KEY_Y, | |
46 | WIIEXT_KEY_ZL, | |
47 | WIIEXT_KEY_ZR, | |
48 | WIIEXT_KEY_PLUS, | |
49 | WIIEXT_KEY_MINUS, | |
50 | WIIEXT_KEY_HOME, | |
51 | WIIEXT_KEY_LEFT, | |
52 | WIIEXT_KEY_RIGHT, | |
53 | WIIEXT_KEY_UP, | |
54 | WIIEXT_KEY_DOWN, | |
55 | WIIEXT_KEY_LT, | |
56 | WIIEXT_KEY_RT, | |
a5353501 DH |
57 | WIIEXT_KEY_COUNT |
58 | }; | |
59 | ||
60 | static __u16 wiiext_keymap[] = { | |
61 | BTN_C, /* WIIEXT_KEY_C */ | |
62 | BTN_Z, /* WIIEXT_KEY_Z */ | |
5906215b DH |
63 | BTN_A, /* WIIEXT_KEY_A */ |
64 | BTN_B, /* WIIEXT_KEY_B */ | |
65 | BTN_X, /* WIIEXT_KEY_X */ | |
66 | BTN_Y, /* WIIEXT_KEY_Y */ | |
67 | BTN_TL2, /* WIIEXT_KEY_ZL */ | |
68 | BTN_TR2, /* WIIEXT_KEY_ZR */ | |
69 | KEY_NEXT, /* WIIEXT_KEY_PLUS */ | |
70 | KEY_PREVIOUS, /* WIIEXT_KEY_MINUS */ | |
71 | BTN_MODE, /* WIIEXT_KEY_HOME */ | |
72 | KEY_LEFT, /* WIIEXT_KEY_LEFT */ | |
73 | KEY_RIGHT, /* WIIEXT_KEY_RIGHT */ | |
74 | KEY_UP, /* WIIEXT_KEY_UP */ | |
75 | KEY_DOWN, /* WIIEXT_KEY_DOWN */ | |
76 | BTN_TL, /* WIIEXT_KEY_LT */ | |
77 | BTN_TR, /* WIIEXT_KEY_RT */ | |
a5353501 DH |
78 | }; |
79 | ||
82fb1b39 DH |
80 | /* diable all extensions */ |
81 | static void ext_disable(struct wiimote_ext *ext) | |
82 | { | |
83 | unsigned long flags; | |
492ba955 DH |
84 | __u8 wmem = 0x55; |
85 | ||
86 | if (!wiimote_cmd_acquire(ext->wdata)) { | |
87 | wiimote_cmd_write(ext->wdata, 0xa400f0, &wmem, sizeof(wmem)); | |
88 | wiimote_cmd_release(ext->wdata); | |
89 | } | |
82fb1b39 DH |
90 | |
91 | spin_lock_irqsave(&ext->wdata->state.lock, flags); | |
92 | ext->motionp = false; | |
93 | ext->ext_type = WIIEXT_NONE; | |
492ba955 | 94 | wiiproto_req_drm(ext->wdata, WIIPROTO_REQ_NULL); |
82fb1b39 DH |
95 | spin_unlock_irqrestore(&ext->wdata->state.lock, flags); |
96 | } | |
97 | ||
98 | static bool motionp_read(struct wiimote_ext *ext) | |
99 | { | |
492ba955 DH |
100 | __u8 rmem[2], wmem; |
101 | ssize_t ret; | |
102 | bool avail = false; | |
103 | ||
479901ba DH |
104 | if (!atomic_read(&ext->mp_opened)) |
105 | return false; | |
106 | ||
492ba955 DH |
107 | if (wiimote_cmd_acquire(ext->wdata)) |
108 | return false; | |
109 | ||
110 | /* initialize motion plus */ | |
111 | wmem = 0x55; | |
112 | ret = wiimote_cmd_write(ext->wdata, 0xa600f0, &wmem, sizeof(wmem)); | |
113 | if (ret) | |
114 | goto error; | |
115 | ||
116 | /* read motion plus ID */ | |
117 | ret = wiimote_cmd_read(ext->wdata, 0xa600fe, rmem, 2); | |
118 | if (ret == 2 || rmem[1] == 0x5) | |
119 | avail = true; | |
120 | ||
121 | error: | |
122 | wiimote_cmd_release(ext->wdata); | |
123 | return avail; | |
82fb1b39 DH |
124 | } |
125 | ||
126 | static __u8 ext_read(struct wiimote_ext *ext) | |
127 | { | |
492ba955 DH |
128 | ssize_t ret; |
129 | __u8 rmem[2], wmem; | |
130 | __u8 type = WIIEXT_NONE; | |
131 | ||
479901ba | 132 | if (!ext->plugged || !atomic_read(&ext->opened)) |
492ba955 DH |
133 | return WIIEXT_NONE; |
134 | ||
135 | if (wiimote_cmd_acquire(ext->wdata)) | |
136 | return WIIEXT_NONE; | |
137 | ||
138 | /* initialize extension */ | |
139 | wmem = 0x55; | |
140 | ret = wiimote_cmd_write(ext->wdata, 0xa400f0, &wmem, sizeof(wmem)); | |
141 | if (!ret) { | |
142 | /* disable encryption */ | |
143 | wmem = 0x0; | |
144 | wiimote_cmd_write(ext->wdata, 0xa400fb, &wmem, sizeof(wmem)); | |
145 | } | |
146 | ||
147 | /* read extension ID */ | |
148 | ret = wiimote_cmd_read(ext->wdata, 0xa400fe, rmem, 2); | |
149 | if (ret == 2) { | |
150 | if (rmem[0] == 0 && rmem[1] == 0) | |
151 | type = WIIEXT_NUNCHUCK; | |
152 | else if (rmem[0] == 0x01 && rmem[1] == 0x01) | |
153 | type = WIIEXT_CLASSIC; | |
154 | } | |
155 | ||
156 | wiimote_cmd_release(ext->wdata); | |
157 | ||
158 | return type; | |
82fb1b39 DH |
159 | } |
160 | ||
161 | static void ext_enable(struct wiimote_ext *ext, bool motionp, __u8 ext_type) | |
162 | { | |
163 | unsigned long flags; | |
492ba955 DH |
164 | __u8 wmem; |
165 | int ret; | |
166 | ||
167 | if (motionp) { | |
168 | if (wiimote_cmd_acquire(ext->wdata)) | |
169 | return; | |
170 | ||
171 | if (ext_type == WIIEXT_CLASSIC) | |
172 | wmem = 0x07; | |
173 | else if (ext_type == WIIEXT_NUNCHUCK) | |
174 | wmem = 0x05; | |
175 | else | |
176 | wmem = 0x04; | |
177 | ||
178 | ret = wiimote_cmd_write(ext->wdata, 0xa600fe, &wmem, sizeof(wmem)); | |
179 | wiimote_cmd_release(ext->wdata); | |
180 | if (ret) | |
181 | return; | |
182 | } | |
82fb1b39 DH |
183 | |
184 | spin_lock_irqsave(&ext->wdata->state.lock, flags); | |
185 | ext->motionp = motionp; | |
186 | ext->ext_type = ext_type; | |
492ba955 | 187 | wiiproto_req_drm(ext->wdata, WIIPROTO_REQ_NULL); |
82fb1b39 DH |
188 | spin_unlock_irqrestore(&ext->wdata->state.lock, flags); |
189 | } | |
190 | ||
cb99221b DH |
191 | static void wiiext_worker(struct work_struct *work) |
192 | { | |
193 | struct wiimote_ext *ext = container_of(work, struct wiimote_ext, | |
194 | worker); | |
82fb1b39 DH |
195 | bool motionp; |
196 | __u8 ext_type; | |
197 | ||
198 | ext_disable(ext); | |
199 | motionp = motionp_read(ext); | |
200 | ext_type = ext_read(ext); | |
201 | ext_enable(ext, motionp, ext_type); | |
cb99221b DH |
202 | } |
203 | ||
204 | /* schedule work only once, otherwise mark for reschedule */ | |
205 | static void wiiext_schedule(struct wiimote_ext *ext) | |
206 | { | |
207 | queue_work(system_nrt_wq, &ext->worker); | |
208 | } | |
209 | ||
210 | /* | |
211 | * Reacts on extension port events | |
212 | * Whenever the driver gets an event from the wiimote that an extension has been | |
213 | * plugged or unplugged, this funtion shall be called. It checks what extensions | |
214 | * are connected and initializes and activates them. | |
215 | * This can be called in atomic context. The initialization is done in a | |
216 | * separate worker thread. The state.lock spinlock must be held by the caller. | |
217 | */ | |
218 | void wiiext_event(struct wiimote_data *wdata, bool plugged) | |
219 | { | |
220 | if (!wdata->ext) | |
221 | return; | |
222 | ||
223 | if (wdata->ext->plugged == plugged) | |
224 | return; | |
225 | ||
226 | wdata->ext->plugged = plugged; | |
b17b57a5 DH |
227 | |
228 | if (!plugged) | |
229 | wdata->ext->mp_plugged = false; | |
230 | ||
cb99221b DH |
231 | /* |
232 | * We need to call wiiext_schedule(wdata->ext) here, however, the | |
233 | * extension initialization logic is not fully understood and so | |
234 | * automatic initialization is not supported, yet. | |
235 | */ | |
236 | } | |
237 | ||
238 | /* | |
239 | * Returns true if the current DRM mode should contain extension data and false | |
240 | * if there is no interest in extension data. | |
241 | * All supported extensions send 6 byte extension data so any DRM that contains | |
242 | * extension bytes is fine. | |
243 | * The caller must hold the state.lock spinlock. | |
244 | */ | |
245 | bool wiiext_active(struct wiimote_data *wdata) | |
246 | { | |
247 | if (!wdata->ext) | |
248 | return false; | |
249 | ||
250 | return wdata->ext->motionp || wdata->ext->ext_type; | |
251 | } | |
252 | ||
0b6815d7 DH |
253 | static void handler_motionp(struct wiimote_ext *ext, const __u8 *payload) |
254 | { | |
b17b57a5 DH |
255 | __s32 x, y, z; |
256 | bool plugged; | |
257 | ||
258 | /* | 8 7 6 5 4 3 | 2 | 1 | | |
259 | * -----+------------------------------+-----+-----+ | |
260 | * 1 | Yaw Speed <7:0> | | |
261 | * 2 | Roll Speed <7:0> | | |
262 | * 3 | Pitch Speed <7:0> | | |
263 | * -----+------------------------------+-----+-----+ | |
264 | * 4 | Yaw Speed <13:8> | Yaw |Pitch| | |
265 | * -----+------------------------------+-----+-----+ | |
266 | * 5 | Roll Speed <13:8> |Roll | Ext | | |
267 | * -----+------------------------------+-----+-----+ | |
268 | * 6 | Pitch Speed <13:8> | 1 | 0 | | |
269 | * -----+------------------------------+-----+-----+ | |
270 | * The single bits Yaw, Roll, Pitch in the lower right corner specify | |
271 | * whether the wiimote is rotating fast (0) or slow (1). Speed for slow | |
272 | * roation is 440 deg/s and for fast rotation 2000 deg/s. To get a | |
273 | * linear scale we multiply by 2000/440 = ~4.5454 which is 18 for fast | |
274 | * and 9 for slow. | |
275 | * If the wiimote is not rotating the sensor reports 2^13 = 8192. | |
276 | * Ext specifies whether an extension is connected to the motionp. | |
277 | */ | |
278 | ||
279 | x = payload[0]; | |
280 | y = payload[1]; | |
281 | z = payload[2]; | |
282 | ||
283 | x |= (((__u16)payload[3]) << 6) & 0xff00; | |
284 | y |= (((__u16)payload[4]) << 6) & 0xff00; | |
285 | z |= (((__u16)payload[5]) << 6) & 0xff00; | |
286 | ||
287 | x -= 8192; | |
288 | y -= 8192; | |
289 | z -= 8192; | |
290 | ||
291 | if (!(payload[3] & 0x02)) | |
292 | x *= 18; | |
293 | else | |
294 | x *= 9; | |
295 | if (!(payload[4] & 0x02)) | |
296 | y *= 18; | |
297 | else | |
298 | y *= 9; | |
299 | if (!(payload[3] & 0x01)) | |
300 | z *= 18; | |
301 | else | |
302 | z *= 9; | |
303 | ||
304 | input_report_abs(ext->mp_input, ABS_RX, x); | |
305 | input_report_abs(ext->mp_input, ABS_RY, y); | |
306 | input_report_abs(ext->mp_input, ABS_RZ, z); | |
307 | input_sync(ext->mp_input); | |
308 | ||
309 | plugged = payload[5] & 0x01; | |
310 | if (plugged != ext->mp_plugged) | |
311 | ext->mp_plugged = plugged; | |
0b6815d7 DH |
312 | } |
313 | ||
314 | static void handler_nunchuck(struct wiimote_ext *ext, const __u8 *payload) | |
315 | { | |
a5353501 DH |
316 | __s16 x, y, z, bx, by; |
317 | ||
318 | /* Byte | 8 7 | 6 5 | 4 3 | 2 | 1 | | |
319 | * -----+----------+---------+---------+----+-----+ | |
320 | * 1 | Button X <7:0> | | |
321 | * 2 | Button Y <7:0> | | |
322 | * -----+----------+---------+---------+----+-----+ | |
323 | * 3 | Speed X <9:2> | | |
324 | * 4 | Speed Y <9:2> | | |
325 | * 5 | Speed Z <9:2> | | |
326 | * -----+----------+---------+---------+----+-----+ | |
327 | * 6 | Z <1:0> | Y <1:0> | X <1:0> | BC | BZ | | |
328 | * -----+----------+---------+---------+----+-----+ | |
329 | * Button X/Y is the analog stick. Speed X, Y and Z are the | |
330 | * accelerometer data in the same format as the wiimote's accelerometer. | |
331 | * The 6th byte contains the LSBs of the accelerometer data. | |
332 | * BC and BZ are the C and Z buttons: 0 means pressed | |
333 | * | |
334 | * If reported interleaved with motionp, then the layout changes. The | |
335 | * 5th and 6th byte changes to: | |
336 | * -----+-----------------------------------+-----+ | |
337 | * 5 | Speed Z <9:3> | EXT | | |
338 | * -----+--------+-----+-----+----+----+----+-----+ | |
339 | * 6 |Z <2:1> |Y <1>|X <1>| BC | BZ | 0 | 0 | | |
340 | * -----+--------+-----+-----+----+----+----+-----+ | |
341 | * All three accelerometer values lose their LSB. The other data is | |
342 | * still available but slightly moved. | |
343 | * | |
344 | * Center data for button values is 128. Center value for accelerometer | |
345 | * values it 512 / 0x200 | |
346 | */ | |
347 | ||
348 | bx = payload[0]; | |
349 | by = payload[1]; | |
350 | bx -= 128; | |
351 | by -= 128; | |
352 | ||
353 | x = payload[2] << 2; | |
354 | y = payload[3] << 2; | |
355 | z = payload[4] << 2; | |
356 | ||
357 | if (ext->motionp) { | |
358 | x |= (payload[5] >> 3) & 0x02; | |
359 | y |= (payload[5] >> 4) & 0x02; | |
360 | z &= ~0x4; | |
361 | z |= (payload[5] >> 5) & 0x06; | |
362 | } else { | |
363 | x |= (payload[5] >> 2) & 0x03; | |
364 | y |= (payload[5] >> 4) & 0x03; | |
365 | z |= (payload[5] >> 6) & 0x03; | |
366 | } | |
367 | ||
368 | x -= 0x200; | |
369 | y -= 0x200; | |
370 | z -= 0x200; | |
371 | ||
372 | input_report_abs(ext->input, ABS_HAT0X, bx); | |
373 | input_report_abs(ext->input, ABS_HAT0Y, by); | |
374 | ||
375 | input_report_abs(ext->input, ABS_RX, x); | |
376 | input_report_abs(ext->input, ABS_RY, y); | |
377 | input_report_abs(ext->input, ABS_RZ, z); | |
378 | ||
379 | if (ext->motionp) { | |
380 | input_report_key(ext->input, | |
381 | wiiext_keymap[WIIEXT_KEY_Z], !!(payload[5] & 0x04)); | |
382 | input_report_key(ext->input, | |
383 | wiiext_keymap[WIIEXT_KEY_C], !!(payload[5] & 0x08)); | |
384 | } else { | |
385 | input_report_key(ext->input, | |
386 | wiiext_keymap[WIIEXT_KEY_Z], !!(payload[5] & 0x01)); | |
387 | input_report_key(ext->input, | |
388 | wiiext_keymap[WIIEXT_KEY_C], !!(payload[5] & 0x02)); | |
389 | } | |
390 | ||
391 | input_sync(ext->input); | |
0b6815d7 DH |
392 | } |
393 | ||
394 | static void handler_classic(struct wiimote_ext *ext, const __u8 *payload) | |
395 | { | |
5906215b DH |
396 | __s8 rx, ry, lx, ly, lt, rt; |
397 | ||
398 | /* Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | | |
399 | * -----+-----+-----+-----+-----+-----+-----+-----+-----+ | |
400 | * 1 | RX <5:4> | LX <5:0> | | |
401 | * 2 | RX <3:2> | LY <5:0> | | |
402 | * -----+-----+-----+-----+-----------------------------+ | |
403 | * 3 |RX<1>| LT <5:4> | RY <5:1> | | |
404 | * -----+-----+-----------+-----------------------------+ | |
405 | * 4 | LT <3:1> | RT <5:1> | | |
406 | * -----+-----+-----+-----+-----+-----+-----+-----+-----+ | |
407 | * 5 | BDR | BDD | BLT | B- | BH | B+ | BRT | 1 | | |
408 | * -----+-----+-----+-----+-----+-----+-----+-----+-----+ | |
409 | * 6 | BZL | BB | BY | BA | BX | BZR | BDL | BDU | | |
410 | * -----+-----+-----+-----+-----+-----+-----+-----+-----+ | |
411 | * All buttons are 0 if pressed | |
412 | * RX and RY are right analog stick | |
413 | * LX and LY are left analog stick | |
414 | * LT is left trigger, RT is right trigger | |
415 | * BLT is 0 if left trigger is fully pressed | |
416 | * BRT is 0 if right trigger is fully pressed | |
417 | * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons | |
418 | * BZL is left Z button and BZR is right Z button | |
419 | * B-, BH, B+ are +, HOME and - buttons | |
420 | * BB, BY, BA, BX are A, B, X, Y buttons | |
421 | * LSB of RX, RY, LT, and RT are not transmitted and always 0. | |
422 | * | |
423 | * With motionp enabled it changes slightly to this: | |
424 | * Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | | |
425 | * -----+-----+-----+-----+-----+-----+-----+-----+-----+ | |
426 | * 1 | RX <4:3> | LX <5:1> | BDU | | |
427 | * 2 | RX <2:1> | LY <5:1> | BDL | | |
428 | * -----+-----+-----+-----+-----------------------+-----+ | |
429 | * 3 |RX<0>| LT <4:3> | RY <4:0> | | |
430 | * -----+-----+-----------+-----------------------------+ | |
431 | * 4 | LT <2:0> | RT <4:0> | | |
432 | * -----+-----+-----+-----+-----+-----+-----+-----+-----+ | |
433 | * 5 | BDR | BDD | BLT | B- | BH | B+ | BRT | EXT | | |
434 | * -----+-----+-----+-----+-----+-----+-----+-----+-----+ | |
435 | * 6 | BZL | BB | BY | BA | BX | BZR | 0 | 0 | | |
436 | * -----+-----+-----+-----+-----+-----+-----+-----+-----+ | |
437 | * Only the LSBs of LX and LY are lost. BDU and BDL are moved, the rest | |
438 | * is the same as before. | |
439 | */ | |
440 | ||
441 | if (ext->motionp) { | |
442 | lx = payload[0] & 0x3e; | |
443 | ly = payload[0] & 0x3e; | |
444 | } else { | |
445 | lx = payload[0] & 0x3f; | |
446 | ly = payload[0] & 0x3f; | |
447 | } | |
448 | ||
449 | rx = (payload[0] >> 3) & 0x14; | |
450 | rx |= (payload[1] >> 5) & 0x06; | |
451 | rx |= (payload[2] >> 7) & 0x01; | |
452 | ry = payload[2] & 0x1f; | |
453 | ||
454 | rt = payload[3] & 0x1f; | |
455 | lt = (payload[2] >> 2) & 0x18; | |
456 | lt |= (payload[3] >> 5) & 0x07; | |
457 | ||
458 | rx <<= 1; | |
459 | ry <<= 1; | |
460 | rt <<= 1; | |
461 | lt <<= 1; | |
462 | ||
463 | input_report_abs(ext->input, ABS_HAT1X, lx - 0x20); | |
464 | input_report_abs(ext->input, ABS_HAT1Y, ly - 0x20); | |
465 | input_report_abs(ext->input, ABS_HAT2X, rx - 0x20); | |
466 | input_report_abs(ext->input, ABS_HAT2Y, ry - 0x20); | |
467 | input_report_abs(ext->input, ABS_HAT3X, rt - 0x20); | |
468 | input_report_abs(ext->input, ABS_HAT3Y, lt - 0x20); | |
469 | ||
470 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_RIGHT], | |
471 | !!(payload[4] & 0x80)); | |
472 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_DOWN], | |
473 | !!(payload[4] & 0x40)); | |
474 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LT], | |
475 | !!(payload[4] & 0x20)); | |
476 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_MINUS], | |
477 | !!(payload[4] & 0x10)); | |
478 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_HOME], | |
479 | !!(payload[4] & 0x08)); | |
480 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_PLUS], | |
481 | !!(payload[4] & 0x04)); | |
482 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_RT], | |
483 | !!(payload[4] & 0x02)); | |
484 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_ZL], | |
485 | !!(payload[5] & 0x80)); | |
486 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_B], | |
487 | !!(payload[5] & 0x40)); | |
488 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_Y], | |
489 | !!(payload[5] & 0x20)); | |
490 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_A], | |
491 | !!(payload[5] & 0x10)); | |
492 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_X], | |
493 | !!(payload[5] & 0x08)); | |
494 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_ZR], | |
495 | !!(payload[5] & 0x04)); | |
496 | ||
497 | if (ext->motionp) { | |
498 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_UP], | |
499 | !!(payload[0] & 0x01)); | |
500 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LEFT], | |
501 | !!(payload[1] & 0x01)); | |
502 | } else { | |
503 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_UP], | |
504 | !!(payload[5] & 0x01)); | |
505 | input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LEFT], | |
506 | !!(payload[5] & 0x02)); | |
507 | } | |
508 | ||
509 | input_sync(ext->input); | |
0b6815d7 DH |
510 | } |
511 | ||
512 | /* call this with state.lock spinlock held */ | |
513 | void wiiext_handle(struct wiimote_data *wdata, const __u8 *payload) | |
514 | { | |
515 | struct wiimote_ext *ext = wdata->ext; | |
516 | ||
517 | if (!ext) | |
518 | return; | |
519 | ||
520 | if (ext->motionp && (payload[5] & 0x02)) { | |
521 | handler_motionp(ext, payload); | |
522 | } else if (ext->ext_type == WIIEXT_NUNCHUCK) { | |
523 | handler_nunchuck(ext, payload); | |
524 | } else if (ext->ext_type == WIIEXT_CLASSIC) { | |
525 | handler_classic(ext, payload); | |
526 | } | |
527 | } | |
528 | ||
c1e51398 DH |
529 | static ssize_t wiiext_show(struct device *dev, struct device_attribute *attr, |
530 | char *buf) | |
531 | { | |
532 | struct wiimote_data *wdata = dev_to_wii(dev); | |
533 | __u8 type = WIIEXT_NONE; | |
534 | bool motionp = false; | |
535 | unsigned long flags; | |
536 | ||
537 | spin_lock_irqsave(&wdata->state.lock, flags); | |
538 | if (wdata->ext) { | |
539 | motionp = wdata->ext->motionp; | |
540 | type = wdata->ext->ext_type; | |
541 | } | |
542 | spin_unlock_irqrestore(&wdata->state.lock, flags); | |
543 | ||
544 | if (type == WIIEXT_NUNCHUCK) { | |
545 | if (motionp) | |
546 | return sprintf(buf, "motionp+nunchuck\n"); | |
547 | else | |
548 | return sprintf(buf, "nunchuck\n"); | |
549 | } else if (type == WIIEXT_CLASSIC) { | |
550 | if (motionp) | |
551 | return sprintf(buf, "motionp+classic\n"); | |
552 | else | |
553 | return sprintf(buf, "classic\n"); | |
554 | } else { | |
555 | if (motionp) | |
556 | return sprintf(buf, "motionp\n"); | |
557 | else | |
558 | return sprintf(buf, "none\n"); | |
559 | } | |
560 | } | |
561 | ||
562 | static DEVICE_ATTR(extension, S_IRUGO, wiiext_show, NULL); | |
563 | ||
479901ba DH |
564 | static int wiiext_input_open(struct input_dev *dev) |
565 | { | |
566 | struct wiimote_ext *ext = input_get_drvdata(dev); | |
567 | int ret; | |
568 | ||
569 | ret = hid_hw_open(ext->wdata->hdev); | |
570 | if (ret) | |
571 | return ret; | |
572 | ||
573 | atomic_inc(&ext->opened); | |
574 | wiiext_schedule(ext); | |
575 | ||
576 | return 0; | |
577 | } | |
578 | ||
579 | static void wiiext_input_close(struct input_dev *dev) | |
580 | { | |
581 | struct wiimote_ext *ext = input_get_drvdata(dev); | |
582 | ||
583 | atomic_dec(&ext->opened); | |
584 | wiiext_schedule(ext); | |
585 | hid_hw_close(ext->wdata->hdev); | |
586 | } | |
587 | ||
588 | static int wiiext_mp_open(struct input_dev *dev) | |
589 | { | |
590 | struct wiimote_ext *ext = input_get_drvdata(dev); | |
591 | int ret; | |
592 | ||
593 | ret = hid_hw_open(ext->wdata->hdev); | |
594 | if (ret) | |
595 | return ret; | |
596 | ||
597 | atomic_inc(&ext->mp_opened); | |
598 | wiiext_schedule(ext); | |
599 | ||
600 | return 0; | |
601 | } | |
602 | ||
603 | static void wiiext_mp_close(struct input_dev *dev) | |
604 | { | |
605 | struct wiimote_ext *ext = input_get_drvdata(dev); | |
606 | ||
607 | atomic_dec(&ext->mp_opened); | |
608 | wiiext_schedule(ext); | |
609 | hid_hw_close(ext->wdata->hdev); | |
610 | } | |
611 | ||
cb99221b DH |
612 | /* Initializes the extension driver of a wiimote */ |
613 | int wiiext_init(struct wiimote_data *wdata) | |
614 | { | |
615 | struct wiimote_ext *ext; | |
616 | unsigned long flags; | |
a5353501 | 617 | int ret, i; |
cb99221b DH |
618 | |
619 | ext = kzalloc(sizeof(*ext), GFP_KERNEL); | |
620 | if (!ext) | |
621 | return -ENOMEM; | |
622 | ||
623 | ext->wdata = wdata; | |
624 | INIT_WORK(&ext->worker, wiiext_worker); | |
625 | ||
479901ba DH |
626 | ext->input = input_allocate_device(); |
627 | if (!ext->input) { | |
628 | ret = -ENOMEM; | |
629 | goto err_input; | |
630 | } | |
631 | ||
632 | input_set_drvdata(ext->input, ext); | |
633 | ext->input->open = wiiext_input_open; | |
634 | ext->input->close = wiiext_input_close; | |
635 | ext->input->dev.parent = &wdata->hdev->dev; | |
636 | ext->input->id.bustype = wdata->hdev->bus; | |
637 | ext->input->id.vendor = wdata->hdev->vendor; | |
638 | ext->input->id.product = wdata->hdev->product; | |
639 | ext->input->id.version = wdata->hdev->version; | |
640 | ext->input->name = WIIMOTE_NAME " Extension"; | |
641 | ||
a5353501 DH |
642 | set_bit(EV_KEY, ext->input->evbit); |
643 | for (i = 0; i < WIIEXT_KEY_COUNT; ++i) | |
644 | set_bit(wiiext_keymap[i], ext->input->keybit); | |
645 | ||
646 | set_bit(EV_ABS, ext->input->evbit); | |
647 | set_bit(ABS_HAT0X, ext->input->absbit); | |
648 | set_bit(ABS_HAT0Y, ext->input->absbit); | |
5906215b DH |
649 | set_bit(ABS_HAT1X, ext->input->absbit); |
650 | set_bit(ABS_HAT1Y, ext->input->absbit); | |
651 | set_bit(ABS_HAT2X, ext->input->absbit); | |
652 | set_bit(ABS_HAT2Y, ext->input->absbit); | |
653 | set_bit(ABS_HAT3X, ext->input->absbit); | |
654 | set_bit(ABS_HAT3Y, ext->input->absbit); | |
a5353501 DH |
655 | input_set_abs_params(ext->input, ABS_HAT0X, -120, 120, 2, 4); |
656 | input_set_abs_params(ext->input, ABS_HAT0Y, -120, 120, 2, 4); | |
5906215b DH |
657 | input_set_abs_params(ext->input, ABS_HAT1X, -30, 30, 1, 1); |
658 | input_set_abs_params(ext->input, ABS_HAT1Y, -30, 30, 1, 1); | |
659 | input_set_abs_params(ext->input, ABS_HAT2X, -30, 30, 1, 1); | |
660 | input_set_abs_params(ext->input, ABS_HAT2Y, -30, 30, 1, 1); | |
661 | input_set_abs_params(ext->input, ABS_HAT3X, -30, 30, 1, 1); | |
662 | input_set_abs_params(ext->input, ABS_HAT3Y, -30, 30, 1, 1); | |
a5353501 DH |
663 | set_bit(ABS_RX, ext->input->absbit); |
664 | set_bit(ABS_RY, ext->input->absbit); | |
665 | set_bit(ABS_RZ, ext->input->absbit); | |
666 | input_set_abs_params(ext->input, ABS_RX, -500, 500, 2, 4); | |
667 | input_set_abs_params(ext->input, ABS_RY, -500, 500, 2, 4); | |
668 | input_set_abs_params(ext->input, ABS_RZ, -500, 500, 2, 4); | |
669 | ||
479901ba DH |
670 | ret = input_register_device(ext->input); |
671 | if (ret) { | |
672 | input_free_device(ext->input); | |
673 | goto err_input; | |
674 | } | |
675 | ||
676 | ext->mp_input = input_allocate_device(); | |
677 | if (!ext->mp_input) { | |
678 | ret = -ENOMEM; | |
679 | goto err_mp; | |
680 | } | |
681 | ||
682 | input_set_drvdata(ext->mp_input, ext); | |
683 | ext->mp_input->open = wiiext_mp_open; | |
684 | ext->mp_input->close = wiiext_mp_close; | |
685 | ext->mp_input->dev.parent = &wdata->hdev->dev; | |
686 | ext->mp_input->id.bustype = wdata->hdev->bus; | |
687 | ext->mp_input->id.vendor = wdata->hdev->vendor; | |
688 | ext->mp_input->id.product = wdata->hdev->product; | |
689 | ext->mp_input->id.version = wdata->hdev->version; | |
690 | ext->mp_input->name = WIIMOTE_NAME " Motion+"; | |
691 | ||
b17b57a5 DH |
692 | set_bit(EV_ABS, ext->mp_input->evbit); |
693 | set_bit(ABS_RX, ext->mp_input->absbit); | |
694 | set_bit(ABS_RY, ext->mp_input->absbit); | |
695 | set_bit(ABS_RZ, ext->mp_input->absbit); | |
696 | input_set_abs_params(ext->mp_input, ABS_RX, -160000, 160000, 4, 8); | |
697 | input_set_abs_params(ext->mp_input, ABS_RY, -160000, 160000, 4, 8); | |
698 | input_set_abs_params(ext->mp_input, ABS_RZ, -160000, 160000, 4, 8); | |
699 | ||
479901ba DH |
700 | ret = input_register_device(ext->mp_input); |
701 | if (ret) { | |
702 | input_free_device(ext->mp_input); | |
703 | goto err_mp; | |
704 | } | |
705 | ||
c1e51398 DH |
706 | ret = device_create_file(&wdata->hdev->dev, &dev_attr_extension); |
707 | if (ret) | |
479901ba | 708 | goto err_dev; |
c1e51398 | 709 | |
cb99221b DH |
710 | spin_lock_irqsave(&wdata->state.lock, flags); |
711 | wdata->ext = ext; | |
712 | spin_unlock_irqrestore(&wdata->state.lock, flags); | |
713 | ||
714 | return 0; | |
c1e51398 | 715 | |
479901ba DH |
716 | err_dev: |
717 | input_unregister_device(ext->mp_input); | |
718 | err_mp: | |
719 | input_unregister_device(ext->input); | |
720 | err_input: | |
c1e51398 DH |
721 | kfree(ext); |
722 | return ret; | |
cb99221b DH |
723 | } |
724 | ||
725 | /* Deinitializes the extension driver of a wiimote */ | |
726 | void wiiext_deinit(struct wiimote_data *wdata) | |
727 | { | |
728 | struct wiimote_ext *ext = wdata->ext; | |
729 | unsigned long flags; | |
730 | ||
731 | if (!ext) | |
732 | return; | |
733 | ||
734 | /* | |
735 | * We first unset wdata->ext to avoid further input from the wiimote | |
736 | * core. The worker thread does not access this pointer so it is not | |
737 | * affected by this. | |
738 | * We kill the worker after this so it does not get respawned during | |
739 | * deinitialization. | |
740 | */ | |
741 | ||
742 | spin_lock_irqsave(&wdata->state.lock, flags); | |
743 | wdata->ext = NULL; | |
744 | spin_unlock_irqrestore(&wdata->state.lock, flags); | |
745 | ||
c1e51398 | 746 | device_remove_file(&wdata->hdev->dev, &dev_attr_extension); |
479901ba DH |
747 | input_unregister_device(ext->mp_input); |
748 | input_unregister_device(ext->input); | |
c1e51398 | 749 | |
cb99221b DH |
750 | cancel_work_sync(&ext->worker); |
751 | kfree(ext); | |
752 | } |