2 * HID driver for Nintendo Wiimote devices
3 * Copyright (c) 2011 David Herrmann
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)
13 #include <linux/completion.h>
14 #include <linux/device.h>
15 #include <linux/hid.h>
16 #include <linux/input.h>
17 #include <linux/leds.h>
18 #include <linux/module.h>
19 #include <linux/mutex.h>
20 #include <linux/spinlock.h>
23 #define WIIMOTE_VERSION "0.1"
24 #define WIIMOTE_NAME "Nintendo Wii Remote"
25 #define WIIMOTE_BUFSIZE 32
28 __u8 data
[HID_MAX_BUFFER_SIZE
];
32 struct wiimote_state
{
37 /* synchronous cmd requests */
39 struct completion ready
;
43 /* results of synchronous requests */
48 struct hid_device
*hdev
;
49 struct input_dev
*input
;
50 struct led_classdev
*leds
[4];
51 struct input_dev
*accel
;
57 struct wiimote_buf outq
[WIIMOTE_BUFSIZE
];
58 struct work_struct worker
;
60 struct wiimote_state state
;
63 #define WIIPROTO_FLAG_LED1 0x01
64 #define WIIPROTO_FLAG_LED2 0x02
65 #define WIIPROTO_FLAG_LED3 0x04
66 #define WIIPROTO_FLAG_LED4 0x08
67 #define WIIPROTO_FLAG_RUMBLE 0x10
68 #define WIIPROTO_FLAG_ACCEL 0x20
69 #define WIIPROTO_FLAG_IR_BASIC 0x40
70 #define WIIPROTO_FLAG_IR_EXT 0x80
71 #define WIIPROTO_FLAG_IR_FULL 0xc0 /* IR_BASIC | IR_EXT */
72 #define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 | WIIPROTO_FLAG_LED2 | \
73 WIIPROTO_FLAG_LED3 | WIIPROTO_FLAG_LED4)
74 #define WIIPROTO_FLAGS_IR (WIIPROTO_FLAG_IR_BASIC | WIIPROTO_FLAG_IR_EXT | \
75 WIIPROTO_FLAG_IR_FULL)
77 /* return flag for led \num */
78 #define WIIPROTO_FLAG_LED(num) (WIIPROTO_FLAG_LED1 << (num - 1))
81 WIIPROTO_REQ_NULL
= 0x0,
82 WIIPROTO_REQ_RUMBLE
= 0x10,
83 WIIPROTO_REQ_LED
= 0x11,
84 WIIPROTO_REQ_DRM
= 0x12,
85 WIIPROTO_REQ_IR1
= 0x13,
86 WIIPROTO_REQ_WMEM
= 0x16,
87 WIIPROTO_REQ_RMEM
= 0x17,
88 WIIPROTO_REQ_IR2
= 0x1a,
89 WIIPROTO_REQ_STATUS
= 0x20,
90 WIIPROTO_REQ_DATA
= 0x21,
91 WIIPROTO_REQ_RETURN
= 0x22,
92 WIIPROTO_REQ_DRM_K
= 0x30,
93 WIIPROTO_REQ_DRM_KA
= 0x31,
94 WIIPROTO_REQ_DRM_KE
= 0x32,
95 WIIPROTO_REQ_DRM_KAI
= 0x33,
96 WIIPROTO_REQ_DRM_KEE
= 0x34,
97 WIIPROTO_REQ_DRM_KAE
= 0x35,
98 WIIPROTO_REQ_DRM_KIE
= 0x36,
99 WIIPROTO_REQ_DRM_KAIE
= 0x37,
100 WIIPROTO_REQ_DRM_E
= 0x3d,
101 WIIPROTO_REQ_DRM_SKAI1
= 0x3e,
102 WIIPROTO_REQ_DRM_SKAI2
= 0x3f,
120 static __u16 wiiproto_keymap
[] = {
121 KEY_LEFT
, /* WIIPROTO_KEY_LEFT */
122 KEY_RIGHT
, /* WIIPROTO_KEY_RIGHT */
123 KEY_UP
, /* WIIPROTO_KEY_UP */
124 KEY_DOWN
, /* WIIPROTO_KEY_DOWN */
125 KEY_NEXT
, /* WIIPROTO_KEY_PLUS */
126 KEY_PREVIOUS
, /* WIIPROTO_KEY_MINUS */
127 BTN_1
, /* WIIPROTO_KEY_ONE */
128 BTN_2
, /* WIIPROTO_KEY_TWO */
129 BTN_A
, /* WIIPROTO_KEY_A */
130 BTN_B
, /* WIIPROTO_KEY_B */
131 BTN_MODE
, /* WIIPROTO_KEY_HOME */
134 /* requires the state.lock spinlock to be held */
135 static inline bool wiimote_cmd_pending(struct wiimote_data
*wdata
, int cmd
,
138 return wdata
->state
.cmd
== cmd
&& wdata
->state
.opt
== opt
;
141 /* requires the state.lock spinlock to be held */
142 static inline void wiimote_cmd_complete(struct wiimote_data
*wdata
)
144 wdata
->state
.cmd
= WIIPROTO_REQ_NULL
;
145 complete(&wdata
->state
.ready
);
148 static inline int wiimote_cmd_acquire(struct wiimote_data
*wdata
)
150 return mutex_lock_interruptible(&wdata
->state
.sync
) ? -ERESTARTSYS
: 0;
153 /* requires the state.lock spinlock to be held */
154 static inline void wiimote_cmd_set(struct wiimote_data
*wdata
, int cmd
,
157 INIT_COMPLETION(wdata
->state
.ready
);
158 wdata
->state
.cmd
= cmd
;
159 wdata
->state
.opt
= opt
;
162 static inline void wiimote_cmd_release(struct wiimote_data
*wdata
)
164 mutex_unlock(&wdata
->state
.sync
);
167 static inline int wiimote_cmd_wait(struct wiimote_data
*wdata
)
171 ret
= wait_for_completion_interruptible_timeout(&wdata
->state
.ready
, HZ
);
180 static ssize_t
wiimote_hid_send(struct hid_device
*hdev
, __u8
*buffer
,
186 if (!hdev
->hid_output_raw_report
)
189 buf
= kmemdup(buffer
, count
, GFP_KERNEL
);
193 ret
= hdev
->hid_output_raw_report(hdev
, buf
, count
, HID_OUTPUT_REPORT
);
199 static void wiimote_worker(struct work_struct
*work
)
201 struct wiimote_data
*wdata
= container_of(work
, struct wiimote_data
,
205 spin_lock_irqsave(&wdata
->qlock
, flags
);
207 while (wdata
->head
!= wdata
->tail
) {
208 spin_unlock_irqrestore(&wdata
->qlock
, flags
);
209 wiimote_hid_send(wdata
->hdev
, wdata
->outq
[wdata
->tail
].data
,
210 wdata
->outq
[wdata
->tail
].size
);
211 spin_lock_irqsave(&wdata
->qlock
, flags
);
213 wdata
->tail
= (wdata
->tail
+ 1) % WIIMOTE_BUFSIZE
;
216 spin_unlock_irqrestore(&wdata
->qlock
, flags
);
219 static void wiimote_queue(struct wiimote_data
*wdata
, const __u8
*buffer
,
225 if (count
> HID_MAX_BUFFER_SIZE
) {
226 hid_warn(wdata
->hdev
, "Sending too large output report\n");
231 * Copy new request into our output queue and check whether the
232 * queue is full. If it is full, discard this request.
233 * If it is empty we need to start a new worker that will
234 * send out the buffer to the hid device.
235 * If the queue is not empty, then there must be a worker
236 * that is currently sending out our buffer and this worker
237 * will reschedule itself until the queue is empty.
240 spin_lock_irqsave(&wdata
->qlock
, flags
);
242 memcpy(wdata
->outq
[wdata
->head
].data
, buffer
, count
);
243 wdata
->outq
[wdata
->head
].size
= count
;
244 newhead
= (wdata
->head
+ 1) % WIIMOTE_BUFSIZE
;
246 if (wdata
->head
== wdata
->tail
) {
247 wdata
->head
= newhead
;
248 schedule_work(&wdata
->worker
);
249 } else if (newhead
!= wdata
->tail
) {
250 wdata
->head
= newhead
;
252 hid_warn(wdata
->hdev
, "Output queue is full");
255 spin_unlock_irqrestore(&wdata
->qlock
, flags
);
259 * This sets the rumble bit on the given output report if rumble is
261 * \cmd1 must point to the second byte in the output report => &cmd[1]
262 * This must be called on nearly every output report before passing it
263 * into the output queue!
265 static inline void wiiproto_keep_rumble(struct wiimote_data
*wdata
, __u8
*cmd1
)
267 if (wdata
->state
.flags
& WIIPROTO_FLAG_RUMBLE
)
271 static void wiiproto_req_rumble(struct wiimote_data
*wdata
, __u8 rumble
)
276 if (rumble
== !!(wdata
->state
.flags
& WIIPROTO_FLAG_RUMBLE
))
280 wdata
->state
.flags
|= WIIPROTO_FLAG_RUMBLE
;
282 wdata
->state
.flags
&= ~WIIPROTO_FLAG_RUMBLE
;
284 cmd
[0] = WIIPROTO_REQ_RUMBLE
;
287 wiiproto_keep_rumble(wdata
, &cmd
[1]);
288 wiimote_queue(wdata
, cmd
, sizeof(cmd
));
291 static void wiiproto_req_leds(struct wiimote_data
*wdata
, int leds
)
295 leds
&= WIIPROTO_FLAGS_LEDS
;
296 if ((wdata
->state
.flags
& WIIPROTO_FLAGS_LEDS
) == leds
)
298 wdata
->state
.flags
= (wdata
->state
.flags
& ~WIIPROTO_FLAGS_LEDS
) | leds
;
300 cmd
[0] = WIIPROTO_REQ_LED
;
303 if (leds
& WIIPROTO_FLAG_LED1
)
305 if (leds
& WIIPROTO_FLAG_LED2
)
307 if (leds
& WIIPROTO_FLAG_LED3
)
309 if (leds
& WIIPROTO_FLAG_LED4
)
312 wiiproto_keep_rumble(wdata
, &cmd
[1]);
313 wiimote_queue(wdata
, cmd
, sizeof(cmd
));
317 * Check what peripherals of the wiimote are currently
318 * active and select a proper DRM that supports all of
319 * the requested data inputs.
321 static __u8
select_drm(struct wiimote_data
*wdata
)
323 __u8 ir
= wdata
->state
.flags
& WIIPROTO_FLAGS_IR
;
325 if (ir
== WIIPROTO_FLAG_IR_BASIC
) {
326 if (wdata
->state
.flags
& WIIPROTO_FLAG_ACCEL
)
327 return WIIPROTO_REQ_DRM_KAIE
;
329 return WIIPROTO_REQ_DRM_KIE
;
330 } else if (ir
== WIIPROTO_FLAG_IR_EXT
) {
331 return WIIPROTO_REQ_DRM_KAI
;
332 } else if (ir
== WIIPROTO_FLAG_IR_FULL
) {
333 return WIIPROTO_REQ_DRM_SKAI1
;
335 if (wdata
->state
.flags
& WIIPROTO_FLAG_ACCEL
)
336 return WIIPROTO_REQ_DRM_KA
;
338 return WIIPROTO_REQ_DRM_K
;
342 static void wiiproto_req_drm(struct wiimote_data
*wdata
, __u8 drm
)
346 if (drm
== WIIPROTO_REQ_NULL
)
347 drm
= select_drm(wdata
);
349 cmd
[0] = WIIPROTO_REQ_DRM
;
353 wiiproto_keep_rumble(wdata
, &cmd
[1]);
354 wiimote_queue(wdata
, cmd
, sizeof(cmd
));
357 static void wiiproto_req_accel(struct wiimote_data
*wdata
, __u8 accel
)
360 if (accel
== !!(wdata
->state
.flags
& WIIPROTO_FLAG_ACCEL
))
364 wdata
->state
.flags
|= WIIPROTO_FLAG_ACCEL
;
366 wdata
->state
.flags
&= ~WIIPROTO_FLAG_ACCEL
;
368 wiiproto_req_drm(wdata
, WIIPROTO_REQ_NULL
);
371 static void wiiproto_req_ir1(struct wiimote_data
*wdata
, __u8 flags
)
375 cmd
[0] = WIIPROTO_REQ_IR1
;
378 wiiproto_keep_rumble(wdata
, &cmd
[1]);
379 wiimote_queue(wdata
, cmd
, sizeof(cmd
));
382 static void wiiproto_req_ir2(struct wiimote_data
*wdata
, __u8 flags
)
386 cmd
[0] = WIIPROTO_REQ_IR2
;
389 wiiproto_keep_rumble(wdata
, &cmd
[1]);
390 wiimote_queue(wdata
, cmd
, sizeof(cmd
));
393 #define wiiproto_req_wreg(wdata, os, buf, sz) \
394 wiiproto_req_wmem((wdata), false, (os), (buf), (sz))
396 #define wiiproto_req_weeprom(wdata, os, buf, sz) \
397 wiiproto_req_wmem((wdata), true, (os), (buf), (sz))
399 static void wiiproto_req_wmem(struct wiimote_data
*wdata
, bool eeprom
,
400 __u32 offset
, const __u8
*buf
, __u8 size
)
404 if (size
> 16 || size
== 0) {
405 hid_warn(wdata
->hdev
, "Invalid length %d wmem request\n", size
);
409 memset(cmd
, 0, sizeof(cmd
));
410 cmd
[0] = WIIPROTO_REQ_WMEM
;
411 cmd
[2] = (offset
>> 16) & 0xff;
412 cmd
[3] = (offset
>> 8) & 0xff;
413 cmd
[4] = offset
& 0xff;
415 memcpy(&cmd
[6], buf
, size
);
420 wiiproto_keep_rumble(wdata
, &cmd
[1]);
421 wiimote_queue(wdata
, cmd
, sizeof(cmd
));
424 /* requries the cmd-mutex to be held */
425 static int wiimote_cmd_write(struct wiimote_data
*wdata
, __u32 offset
,
426 const __u8
*wmem
, __u8 size
)
431 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
432 wiimote_cmd_set(wdata
, WIIPROTO_REQ_WMEM
, 0);
433 wiiproto_req_wreg(wdata
, offset
, wmem
, size
);
434 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
436 ret
= wiimote_cmd_wait(wdata
);
437 if (!ret
&& wdata
->state
.cmd_err
)
443 static int wiimote_init_ir(struct wiimote_data
*wdata
, __u16 mode
)
448 static const __u8 data_enable
[] = { 0x01 };
449 static const __u8 data_sens1
[] = { 0x02, 0x00, 0x00, 0x71, 0x01,
450 0x00, 0xaa, 0x00, 0x64 };
451 static const __u8 data_sens2
[] = { 0x63, 0x03 };
452 static const __u8 data_fin
[] = { 0x08 };
454 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
456 if (mode
== (wdata
->state
.flags
& WIIPROTO_FLAGS_IR
)) {
457 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
462 wdata
->state
.flags
&= ~WIIPROTO_FLAGS_IR
;
463 wiiproto_req_ir1(wdata
, 0);
464 wiiproto_req_ir2(wdata
, 0);
465 wiiproto_req_drm(wdata
, WIIPROTO_REQ_NULL
);
466 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
470 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
472 ret
= wiimote_cmd_acquire(wdata
);
476 /* send PIXEL CLOCK ENABLE cmd first */
477 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
478 wiimote_cmd_set(wdata
, WIIPROTO_REQ_IR1
, 0);
479 wiiproto_req_ir1(wdata
, 0x06);
480 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
482 ret
= wiimote_cmd_wait(wdata
);
485 if (wdata
->state
.cmd_err
) {
490 /* enable IR LOGIC */
491 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
492 wiimote_cmd_set(wdata
, WIIPROTO_REQ_IR2
, 0);
493 wiiproto_req_ir2(wdata
, 0x06);
494 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
496 ret
= wiimote_cmd_wait(wdata
);
499 if (wdata
->state
.cmd_err
) {
504 /* enable IR cam but do not make it send data, yet */
505 ret
= wiimote_cmd_write(wdata
, 0xb00030, data_enable
,
506 sizeof(data_enable
));
510 /* write first sensitivity block */
511 ret
= wiimote_cmd_write(wdata
, 0xb00000, data_sens1
,
516 /* write second sensitivity block */
517 ret
= wiimote_cmd_write(wdata
, 0xb0001a, data_sens2
,
522 /* put IR cam into desired state */
524 case WIIPROTO_FLAG_IR_FULL
:
527 case WIIPROTO_FLAG_IR_EXT
:
530 case WIIPROTO_FLAG_IR_BASIC
:
534 ret
= wiimote_cmd_write(wdata
, 0xb00033, &format
, sizeof(format
));
538 /* make IR cam send data */
539 ret
= wiimote_cmd_write(wdata
, 0xb00030, data_fin
, sizeof(data_fin
));
543 /* request new DRM mode compatible to IR mode */
544 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
545 wdata
->state
.flags
&= ~WIIPROTO_FLAGS_IR
;
546 wdata
->state
.flags
|= mode
& WIIPROTO_FLAGS_IR
;
547 wiiproto_req_drm(wdata
, WIIPROTO_REQ_NULL
);
548 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
551 wiimote_cmd_release(wdata
);
555 static enum led_brightness
wiimote_leds_get(struct led_classdev
*led_dev
)
557 struct wiimote_data
*wdata
;
558 struct device
*dev
= led_dev
->dev
->parent
;
563 wdata
= hid_get_drvdata(container_of(dev
, struct hid_device
, dev
));
565 for (i
= 0; i
< 4; ++i
) {
566 if (wdata
->leds
[i
] == led_dev
) {
567 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
568 value
= wdata
->state
.flags
& WIIPROTO_FLAG_LED(i
+ 1);
569 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
574 return value
? LED_FULL
: LED_OFF
;
577 static void wiimote_leds_set(struct led_classdev
*led_dev
,
578 enum led_brightness value
)
580 struct wiimote_data
*wdata
;
581 struct device
*dev
= led_dev
->dev
->parent
;
586 wdata
= hid_get_drvdata(container_of(dev
, struct hid_device
, dev
));
588 for (i
= 0; i
< 4; ++i
) {
589 if (wdata
->leds
[i
] == led_dev
) {
590 flag
= WIIPROTO_FLAG_LED(i
+ 1);
591 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
592 state
= wdata
->state
.flags
;
593 if (value
== LED_OFF
)
594 wiiproto_req_leds(wdata
, state
& ~flag
);
596 wiiproto_req_leds(wdata
, state
| flag
);
597 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
603 static int wiimote_ff_play(struct input_dev
*dev
, void *data
,
604 struct ff_effect
*eff
)
606 struct wiimote_data
*wdata
= input_get_drvdata(dev
);
611 * The wiimote supports only a single rumble motor so if any magnitude
612 * is set to non-zero then we start the rumble motor. If both are set to
613 * zero, we stop the rumble motor.
616 if (eff
->u
.rumble
.strong_magnitude
|| eff
->u
.rumble
.weak_magnitude
)
621 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
622 wiiproto_req_rumble(wdata
, value
);
623 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
628 static int wiimote_input_open(struct input_dev
*dev
)
630 struct wiimote_data
*wdata
= input_get_drvdata(dev
);
632 return hid_hw_open(wdata
->hdev
);
635 static void wiimote_input_close(struct input_dev
*dev
)
637 struct wiimote_data
*wdata
= input_get_drvdata(dev
);
639 hid_hw_close(wdata
->hdev
);
642 static int wiimote_accel_open(struct input_dev
*dev
)
644 struct wiimote_data
*wdata
= input_get_drvdata(dev
);
648 ret
= hid_hw_open(wdata
->hdev
);
652 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
653 wiiproto_req_accel(wdata
, true);
654 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
659 static void wiimote_accel_close(struct input_dev
*dev
)
661 struct wiimote_data
*wdata
= input_get_drvdata(dev
);
664 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
665 wiiproto_req_accel(wdata
, false);
666 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
668 hid_hw_close(wdata
->hdev
);
671 static void handler_keys(struct wiimote_data
*wdata
, const __u8
*payload
)
673 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_LEFT
],
674 !!(payload
[0] & 0x01));
675 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_RIGHT
],
676 !!(payload
[0] & 0x02));
677 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_DOWN
],
678 !!(payload
[0] & 0x04));
679 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_UP
],
680 !!(payload
[0] & 0x08));
681 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_PLUS
],
682 !!(payload
[0] & 0x10));
683 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_TWO
],
684 !!(payload
[1] & 0x01));
685 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_ONE
],
686 !!(payload
[1] & 0x02));
687 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_B
],
688 !!(payload
[1] & 0x04));
689 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_A
],
690 !!(payload
[1] & 0x08));
691 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_MINUS
],
692 !!(payload
[1] & 0x10));
693 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_HOME
],
694 !!(payload
[1] & 0x80));
695 input_sync(wdata
->input
);
698 static void handler_accel(struct wiimote_data
*wdata
, const __u8
*payload
)
702 if (!(wdata
->state
.flags
& WIIPROTO_FLAG_ACCEL
))
706 * payload is: BB BB XX YY ZZ
707 * Accelerometer data is encoded into 3 10bit values. XX, YY and ZZ
708 * contain the upper 8 bits of each value. The lower 2 bits are
709 * contained in the buttons data BB BB.
710 * Bits 6 and 7 of the first buttons byte BB is the lower 2 bits of the
711 * X accel value. Bit 5 of the second buttons byte is the 2nd bit of Y
712 * accel value and bit 6 is the second bit of the Z value.
713 * The first bit of Y and Z values is not available and always set to 0.
714 * 0x200 is returned on no movement.
721 x
|= (payload
[0] >> 5) & 0x3;
722 y
|= (payload
[1] >> 4) & 0x2;
723 z
|= (payload
[1] >> 5) & 0x2;
725 input_report_abs(wdata
->accel
, ABS_RX
, x
- 0x200);
726 input_report_abs(wdata
->accel
, ABS_RY
, y
- 0x200);
727 input_report_abs(wdata
->accel
, ABS_RZ
, z
- 0x200);
728 input_sync(wdata
->accel
);
731 #define ir_to_input0(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
732 ABS_HAT0X, ABS_HAT0Y)
733 #define ir_to_input1(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
734 ABS_HAT1X, ABS_HAT1Y)
735 #define ir_to_input2(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
736 ABS_HAT2X, ABS_HAT2Y)
737 #define ir_to_input3(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
738 ABS_HAT3X, ABS_HAT3Y)
740 static void __ir_to_input(struct wiimote_data
*wdata
, const __u8
*ir
,
741 bool packed
, __u8 xid
, __u8 yid
)
745 if (!(wdata
->state
.flags
& WIIPROTO_FLAGS_IR
))
749 * Basic IR data is encoded into 3 bytes. The first two bytes are the
750 * upper 8 bit of the X/Y data, the 3rd byte contains the lower 2 bits
752 * If data is packed, then the 3rd byte is put first and slightly
753 * reordered. This allows to interleave packed and non-packed data to
754 * have two IR sets in 5 bytes instead of 6.
755 * The resulting 10bit X/Y values are passed to the ABS_HATXY input dev.
763 y
|= (ir
[0] >> 2) & 0x3;
768 x
|= (ir
[2] >> 4) & 0x3;
769 y
|= (ir
[2] >> 6) & 0x3;
772 input_report_abs(wdata
->ir
, xid
, x
);
773 input_report_abs(wdata
->ir
, yid
, y
);
776 static void handler_status(struct wiimote_data
*wdata
, const __u8
*payload
)
778 handler_keys(wdata
, payload
);
780 /* on status reports the drm is reset so we need to resend the drm */
781 wiiproto_req_drm(wdata
, WIIPROTO_REQ_NULL
);
784 static void handler_data(struct wiimote_data
*wdata
, const __u8
*payload
)
786 handler_keys(wdata
, payload
);
789 static void handler_return(struct wiimote_data
*wdata
, const __u8
*payload
)
791 __u8 err
= payload
[3];
792 __u8 cmd
= payload
[2];
794 handler_keys(wdata
, payload
);
796 if (wiimote_cmd_pending(wdata
, cmd
, 0)) {
797 wdata
->state
.cmd_err
= err
;
798 wiimote_cmd_complete(wdata
);
800 hid_warn(wdata
->hdev
, "Remote error %hhu on req %hhu\n", err
,
805 static void handler_drm_KA(struct wiimote_data
*wdata
, const __u8
*payload
)
807 handler_keys(wdata
, payload
);
808 handler_accel(wdata
, payload
);
811 static void handler_drm_KE(struct wiimote_data
*wdata
, const __u8
*payload
)
813 handler_keys(wdata
, payload
);
816 static void handler_drm_KAI(struct wiimote_data
*wdata
, const __u8
*payload
)
818 handler_keys(wdata
, payload
);
819 handler_accel(wdata
, payload
);
820 ir_to_input0(wdata
, &payload
[5], false);
821 ir_to_input1(wdata
, &payload
[8], false);
822 ir_to_input2(wdata
, &payload
[11], false);
823 ir_to_input3(wdata
, &payload
[14], false);
824 input_sync(wdata
->ir
);
827 static void handler_drm_KEE(struct wiimote_data
*wdata
, const __u8
*payload
)
829 handler_keys(wdata
, payload
);
832 static void handler_drm_KIE(struct wiimote_data
*wdata
, const __u8
*payload
)
834 handler_keys(wdata
, payload
);
835 ir_to_input0(wdata
, &payload
[2], false);
836 ir_to_input1(wdata
, &payload
[4], true);
837 ir_to_input2(wdata
, &payload
[7], false);
838 ir_to_input3(wdata
, &payload
[9], true);
839 input_sync(wdata
->ir
);
842 static void handler_drm_KAE(struct wiimote_data
*wdata
, const __u8
*payload
)
844 handler_keys(wdata
, payload
);
845 handler_accel(wdata
, payload
);
848 static void handler_drm_KAIE(struct wiimote_data
*wdata
, const __u8
*payload
)
850 handler_keys(wdata
, payload
);
851 handler_accel(wdata
, payload
);
852 ir_to_input0(wdata
, &payload
[5], false);
853 ir_to_input1(wdata
, &payload
[7], true);
854 ir_to_input2(wdata
, &payload
[10], false);
855 ir_to_input3(wdata
, &payload
[12], true);
856 input_sync(wdata
->ir
);
859 static void handler_drm_E(struct wiimote_data
*wdata
, const __u8
*payload
)
863 static void handler_drm_SKAI1(struct wiimote_data
*wdata
, const __u8
*payload
)
865 handler_keys(wdata
, payload
);
867 wdata
->state
.accel_split
[0] = payload
[2];
868 wdata
->state
.accel_split
[1] = (payload
[0] >> 1) & (0x10 | 0x20);
869 wdata
->state
.accel_split
[1] |= (payload
[1] << 1) & (0x40 | 0x80);
871 ir_to_input0(wdata
, &payload
[3], false);
872 ir_to_input1(wdata
, &payload
[12], false);
873 input_sync(wdata
->ir
);
876 static void handler_drm_SKAI2(struct wiimote_data
*wdata
, const __u8
*payload
)
880 handler_keys(wdata
, payload
);
882 wdata
->state
.accel_split
[1] |= (payload
[0] >> 5) & (0x01 | 0x02);
883 wdata
->state
.accel_split
[1] |= (payload
[1] >> 3) & (0x04 | 0x08);
887 buf
[2] = wdata
->state
.accel_split
[0];
889 buf
[4] = wdata
->state
.accel_split
[1];
890 handler_accel(wdata
, buf
);
892 ir_to_input2(wdata
, &payload
[3], false);
893 ir_to_input3(wdata
, &payload
[12], false);
894 input_sync(wdata
->ir
);
897 struct wiiproto_handler
{
900 void (*func
)(struct wiimote_data
*wdata
, const __u8
*payload
);
903 static struct wiiproto_handler handlers
[] = {
904 { .id
= WIIPROTO_REQ_STATUS
, .size
= 6, .func
= handler_status
},
905 { .id
= WIIPROTO_REQ_DATA
, .size
= 21, .func
= handler_data
},
906 { .id
= WIIPROTO_REQ_RETURN
, .size
= 4, .func
= handler_return
},
907 { .id
= WIIPROTO_REQ_DRM_K
, .size
= 2, .func
= handler_keys
},
908 { .id
= WIIPROTO_REQ_DRM_KA
, .size
= 5, .func
= handler_drm_KA
},
909 { .id
= WIIPROTO_REQ_DRM_KE
, .size
= 10, .func
= handler_drm_KE
},
910 { .id
= WIIPROTO_REQ_DRM_KAI
, .size
= 17, .func
= handler_drm_KAI
},
911 { .id
= WIIPROTO_REQ_DRM_KEE
, .size
= 21, .func
= handler_drm_KEE
},
912 { .id
= WIIPROTO_REQ_DRM_KAE
, .size
= 21, .func
= handler_drm_KAE
},
913 { .id
= WIIPROTO_REQ_DRM_KIE
, .size
= 21, .func
= handler_drm_KIE
},
914 { .id
= WIIPROTO_REQ_DRM_KAIE
, .size
= 21, .func
= handler_drm_KAIE
},
915 { .id
= WIIPROTO_REQ_DRM_E
, .size
= 21, .func
= handler_drm_E
},
916 { .id
= WIIPROTO_REQ_DRM_SKAI1
, .size
= 21, .func
= handler_drm_SKAI1
},
917 { .id
= WIIPROTO_REQ_DRM_SKAI2
, .size
= 21, .func
= handler_drm_SKAI2
},
921 static int wiimote_hid_event(struct hid_device
*hdev
, struct hid_report
*report
,
922 u8
*raw_data
, int size
)
924 struct wiimote_data
*wdata
= hid_get_drvdata(hdev
);
925 struct wiiproto_handler
*h
;
928 bool handled
= false;
933 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
935 for (i
= 0; handlers
[i
].id
; ++i
) {
937 if (h
->id
== raw_data
[0] && h
->size
< size
) {
938 h
->func(wdata
, &raw_data
[1]);
944 hid_warn(hdev
, "Unhandled report %hhu size %d\n", raw_data
[0],
947 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
952 static void wiimote_leds_destroy(struct wiimote_data
*wdata
)
955 struct led_classdev
*led
;
957 for (i
= 0; i
< 4; ++i
) {
958 if (wdata
->leds
[i
]) {
959 led
= wdata
->leds
[i
];
960 wdata
->leds
[i
] = NULL
;
961 led_classdev_unregister(led
);
967 static int wiimote_leds_create(struct wiimote_data
*wdata
)
970 struct device
*dev
= &wdata
->hdev
->dev
;
971 size_t namesz
= strlen(dev_name(dev
)) + 9;
972 struct led_classdev
*led
;
975 for (i
= 0; i
< 4; ++i
) {
976 led
= kzalloc(sizeof(struct led_classdev
) + namesz
, GFP_KERNEL
);
981 name
= (void*)&led
[1];
982 snprintf(name
, namesz
, "%s:blue:p%d", dev_name(dev
), i
);
985 led
->max_brightness
= 1;
986 led
->brightness_get
= wiimote_leds_get
;
987 led
->brightness_set
= wiimote_leds_set
;
989 ret
= led_classdev_register(dev
, led
);
994 wdata
->leds
[i
] = led
;
1000 wiimote_leds_destroy(wdata
);
1004 static struct wiimote_data
*wiimote_create(struct hid_device
*hdev
)
1006 struct wiimote_data
*wdata
;
1009 wdata
= kzalloc(sizeof(*wdata
), GFP_KERNEL
);
1013 wdata
->input
= input_allocate_device();
1018 hid_set_drvdata(hdev
, wdata
);
1020 input_set_drvdata(wdata
->input
, wdata
);
1021 wdata
->input
->open
= wiimote_input_open
;
1022 wdata
->input
->close
= wiimote_input_close
;
1023 wdata
->input
->dev
.parent
= &wdata
->hdev
->dev
;
1024 wdata
->input
->id
.bustype
= wdata
->hdev
->bus
;
1025 wdata
->input
->id
.vendor
= wdata
->hdev
->vendor
;
1026 wdata
->input
->id
.product
= wdata
->hdev
->product
;
1027 wdata
->input
->id
.version
= wdata
->hdev
->version
;
1028 wdata
->input
->name
= WIIMOTE_NAME
;
1030 set_bit(EV_KEY
, wdata
->input
->evbit
);
1031 for (i
= 0; i
< WIIPROTO_KEY_COUNT
; ++i
)
1032 set_bit(wiiproto_keymap
[i
], wdata
->input
->keybit
);
1034 set_bit(FF_RUMBLE
, wdata
->input
->ffbit
);
1035 if (input_ff_create_memless(wdata
->input
, NULL
, wiimote_ff_play
))
1038 wdata
->accel
= input_allocate_device();
1042 input_set_drvdata(wdata
->accel
, wdata
);
1043 wdata
->accel
->open
= wiimote_accel_open
;
1044 wdata
->accel
->close
= wiimote_accel_close
;
1045 wdata
->accel
->dev
.parent
= &wdata
->hdev
->dev
;
1046 wdata
->accel
->id
.bustype
= wdata
->hdev
->bus
;
1047 wdata
->accel
->id
.vendor
= wdata
->hdev
->vendor
;
1048 wdata
->accel
->id
.product
= wdata
->hdev
->product
;
1049 wdata
->accel
->id
.version
= wdata
->hdev
->version
;
1050 wdata
->accel
->name
= WIIMOTE_NAME
" Accelerometer";
1052 set_bit(EV_ABS
, wdata
->accel
->evbit
);
1053 set_bit(ABS_RX
, wdata
->accel
->absbit
);
1054 set_bit(ABS_RY
, wdata
->accel
->absbit
);
1055 set_bit(ABS_RZ
, wdata
->accel
->absbit
);
1056 input_set_abs_params(wdata
->accel
, ABS_RX
, -500, 500, 2, 4);
1057 input_set_abs_params(wdata
->accel
, ABS_RY
, -500, 500, 2, 4);
1058 input_set_abs_params(wdata
->accel
, ABS_RZ
, -500, 500, 2, 4);
1060 wdata
->ir
= input_allocate_device();
1064 input_set_drvdata(wdata
->ir
, wdata
);
1065 wdata
->ir
->dev
.parent
= &wdata
->hdev
->dev
;
1066 wdata
->ir
->id
.bustype
= wdata
->hdev
->bus
;
1067 wdata
->ir
->id
.vendor
= wdata
->hdev
->vendor
;
1068 wdata
->ir
->id
.product
= wdata
->hdev
->product
;
1069 wdata
->ir
->id
.version
= wdata
->hdev
->version
;
1070 wdata
->ir
->name
= WIIMOTE_NAME
" IR";
1072 set_bit(EV_ABS
, wdata
->ir
->evbit
);
1073 set_bit(ABS_HAT0X
, wdata
->ir
->absbit
);
1074 set_bit(ABS_HAT0Y
, wdata
->ir
->absbit
);
1075 set_bit(ABS_HAT1X
, wdata
->ir
->absbit
);
1076 set_bit(ABS_HAT1Y
, wdata
->ir
->absbit
);
1077 set_bit(ABS_HAT2X
, wdata
->ir
->absbit
);
1078 set_bit(ABS_HAT2Y
, wdata
->ir
->absbit
);
1079 set_bit(ABS_HAT3X
, wdata
->ir
->absbit
);
1080 set_bit(ABS_HAT3Y
, wdata
->ir
->absbit
);
1081 input_set_abs_params(wdata
->ir
, ABS_HAT0X
, 0, 1023, 2, 4);
1082 input_set_abs_params(wdata
->ir
, ABS_HAT0Y
, 0, 767, 2, 4);
1083 input_set_abs_params(wdata
->ir
, ABS_HAT1X
, 0, 1023, 2, 4);
1084 input_set_abs_params(wdata
->ir
, ABS_HAT1Y
, 0, 767, 2, 4);
1085 input_set_abs_params(wdata
->ir
, ABS_HAT2X
, 0, 1023, 2, 4);
1086 input_set_abs_params(wdata
->ir
, ABS_HAT2Y
, 0, 767, 2, 4);
1087 input_set_abs_params(wdata
->ir
, ABS_HAT3X
, 0, 1023, 2, 4);
1088 input_set_abs_params(wdata
->ir
, ABS_HAT3Y
, 0, 767, 2, 4);
1090 spin_lock_init(&wdata
->qlock
);
1091 INIT_WORK(&wdata
->worker
, wiimote_worker
);
1093 spin_lock_init(&wdata
->state
.lock
);
1094 init_completion(&wdata
->state
.ready
);
1095 mutex_init(&wdata
->state
.sync
);
1100 input_free_device(wdata
->accel
);
1102 input_free_device(wdata
->input
);
1108 static void wiimote_destroy(struct wiimote_data
*wdata
)
1110 wiimote_leds_destroy(wdata
);
1112 input_unregister_device(wdata
->accel
);
1113 input_unregister_device(wdata
->ir
);
1114 input_unregister_device(wdata
->input
);
1115 cancel_work_sync(&wdata
->worker
);
1116 hid_hw_stop(wdata
->hdev
);
1121 static int wiimote_hid_probe(struct hid_device
*hdev
,
1122 const struct hid_device_id
*id
)
1124 struct wiimote_data
*wdata
;
1127 wdata
= wiimote_create(hdev
);
1129 hid_err(hdev
, "Can't alloc device\n");
1133 ret
= hid_parse(hdev
);
1135 hid_err(hdev
, "HID parse failed\n");
1139 ret
= hid_hw_start(hdev
, HID_CONNECT_HIDRAW
);
1141 hid_err(hdev
, "HW start failed\n");
1145 ret
= input_register_device(wdata
->accel
);
1147 hid_err(hdev
, "Cannot register input device\n");
1151 ret
= input_register_device(wdata
->ir
);
1153 hid_err(hdev
, "Cannot register input device\n");
1157 ret
= input_register_device(wdata
->input
);
1159 hid_err(hdev
, "Cannot register input device\n");
1163 ret
= wiimote_leds_create(wdata
);
1167 hid_info(hdev
, "New device registered\n");
1169 /* by default set led1 after device initialization */
1170 spin_lock_irq(&wdata
->state
.lock
);
1171 wiiproto_req_leds(wdata
, WIIPROTO_FLAG_LED1
);
1172 spin_unlock_irq(&wdata
->state
.lock
);
1177 wiimote_destroy(wdata
);
1181 input_unregister_device(wdata
->ir
);
1184 input_unregister_device(wdata
->accel
);
1185 wdata
->accel
= NULL
;
1189 input_free_device(wdata
->ir
);
1190 input_free_device(wdata
->accel
);
1191 input_free_device(wdata
->input
);
1196 static void wiimote_hid_remove(struct hid_device
*hdev
)
1198 struct wiimote_data
*wdata
= hid_get_drvdata(hdev
);
1200 hid_info(hdev
, "Device removed\n");
1201 wiimote_destroy(wdata
);
1204 static const struct hid_device_id wiimote_hid_devices
[] = {
1205 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO
,
1206 USB_DEVICE_ID_NINTENDO_WIIMOTE
) },
1209 MODULE_DEVICE_TABLE(hid
, wiimote_hid_devices
);
1211 static struct hid_driver wiimote_hid_driver
= {
1213 .id_table
= wiimote_hid_devices
,
1214 .probe
= wiimote_hid_probe
,
1215 .remove
= wiimote_hid_remove
,
1216 .raw_event
= wiimote_hid_event
,
1219 static int __init
wiimote_init(void)
1223 ret
= hid_register_driver(&wiimote_hid_driver
);
1225 pr_err("Can't register wiimote hid driver\n");
1230 static void __exit
wiimote_exit(void)
1232 hid_unregister_driver(&wiimote_hid_driver
);
1235 module_init(wiimote_init
);
1236 module_exit(wiimote_exit
);
1237 MODULE_LICENSE("GPL");
1238 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
1239 MODULE_DESCRIPTION(WIIMOTE_NAME
" Device Driver");
1240 MODULE_VERSION(WIIMOTE_VERSION
);