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/atomic.h>
14 #include <linux/device.h>
15 #include <linux/hid.h>
16 #include <linux/input.h>
17 #include <linux/module.h>
18 #include <linux/spinlock.h>
21 #define WIIMOTE_VERSION "0.1"
22 #define WIIMOTE_NAME "Nintendo Wii Remote"
23 #define WIIMOTE_BUFSIZE 32
26 __u8 data
[HID_MAX_BUFFER_SIZE
];
30 struct wiimote_state
{
37 struct hid_device
*hdev
;
38 struct input_dev
*input
;
43 struct wiimote_buf outq
[WIIMOTE_BUFSIZE
];
44 struct work_struct worker
;
46 struct wiimote_state state
;
49 #define WIIPROTO_FLAG_LED1 0x01
50 #define WIIPROTO_FLAG_LED2 0x02
51 #define WIIPROTO_FLAG_LED3 0x04
52 #define WIIPROTO_FLAG_LED4 0x08
53 #define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 | WIIPROTO_FLAG_LED2 | \
54 WIIPROTO_FLAG_LED3 | WIIPROTO_FLAG_LED4)
57 WIIPROTO_REQ_LED
= 0x11,
58 WIIPROTO_REQ_DRM_K
= 0x30,
76 static __u16 wiiproto_keymap
[] = {
77 KEY_LEFT
, /* WIIPROTO_KEY_LEFT */
78 KEY_RIGHT
, /* WIIPROTO_KEY_RIGHT */
79 KEY_UP
, /* WIIPROTO_KEY_UP */
80 KEY_DOWN
, /* WIIPROTO_KEY_DOWN */
81 KEY_NEXT
, /* WIIPROTO_KEY_PLUS */
82 KEY_PREVIOUS
, /* WIIPROTO_KEY_MINUS */
83 BTN_1
, /* WIIPROTO_KEY_ONE */
84 BTN_2
, /* WIIPROTO_KEY_TWO */
85 BTN_A
, /* WIIPROTO_KEY_A */
86 BTN_B
, /* WIIPROTO_KEY_B */
87 BTN_MODE
, /* WIIPROTO_KEY_HOME */
90 #define dev_to_wii(pdev) hid_get_drvdata(container_of(pdev, struct hid_device, \
93 static ssize_t
wiimote_hid_send(struct hid_device
*hdev
, __u8
*buffer
,
99 if (!hdev
->hid_output_raw_report
)
102 buf
= kmemdup(buffer
, count
, GFP_KERNEL
);
106 ret
= hdev
->hid_output_raw_report(hdev
, buf
, count
, HID_OUTPUT_REPORT
);
112 static void wiimote_worker(struct work_struct
*work
)
114 struct wiimote_data
*wdata
= container_of(work
, struct wiimote_data
,
118 spin_lock_irqsave(&wdata
->qlock
, flags
);
120 while (wdata
->head
!= wdata
->tail
) {
121 spin_unlock_irqrestore(&wdata
->qlock
, flags
);
122 wiimote_hid_send(wdata
->hdev
, wdata
->outq
[wdata
->tail
].data
,
123 wdata
->outq
[wdata
->tail
].size
);
124 spin_lock_irqsave(&wdata
->qlock
, flags
);
126 wdata
->tail
= (wdata
->tail
+ 1) % WIIMOTE_BUFSIZE
;
129 spin_unlock_irqrestore(&wdata
->qlock
, flags
);
132 static void wiimote_queue(struct wiimote_data
*wdata
, const __u8
*buffer
,
138 if (count
> HID_MAX_BUFFER_SIZE
) {
139 hid_warn(wdata
->hdev
, "Sending too large output report\n");
144 * Copy new request into our output queue and check whether the
145 * queue is full. If it is full, discard this request.
146 * If it is empty we need to start a new worker that will
147 * send out the buffer to the hid device.
148 * If the queue is not empty, then there must be a worker
149 * that is currently sending out our buffer and this worker
150 * will reschedule itself until the queue is empty.
153 spin_lock_irqsave(&wdata
->qlock
, flags
);
155 memcpy(wdata
->outq
[wdata
->head
].data
, buffer
, count
);
156 wdata
->outq
[wdata
->head
].size
= count
;
157 newhead
= (wdata
->head
+ 1) % WIIMOTE_BUFSIZE
;
159 if (wdata
->head
== wdata
->tail
) {
160 wdata
->head
= newhead
;
161 schedule_work(&wdata
->worker
);
162 } else if (newhead
!= wdata
->tail
) {
163 wdata
->head
= newhead
;
165 hid_warn(wdata
->hdev
, "Output queue is full");
168 spin_unlock_irqrestore(&wdata
->qlock
, flags
);
171 static void wiiproto_req_leds(struct wiimote_data
*wdata
, int leds
)
175 leds
&= WIIPROTO_FLAGS_LEDS
;
176 if ((wdata
->state
.flags
& WIIPROTO_FLAGS_LEDS
) == leds
)
178 wdata
->state
.flags
= (wdata
->state
.flags
& ~WIIPROTO_FLAGS_LEDS
) | leds
;
180 cmd
[0] = WIIPROTO_REQ_LED
;
183 if (leds
& WIIPROTO_FLAG_LED1
)
185 if (leds
& WIIPROTO_FLAG_LED2
)
187 if (leds
& WIIPROTO_FLAG_LED3
)
189 if (leds
& WIIPROTO_FLAG_LED4
)
192 wiimote_queue(wdata
, cmd
, sizeof(cmd
));
195 #define wiifs_led_show_set(num) \
196 static ssize_t wiifs_led_show_##num(struct device *dev, \
197 struct device_attribute *attr, char *buf) \
199 struct wiimote_data *wdata = dev_to_wii(dev); \
200 unsigned long flags; \
203 if (!atomic_read(&wdata->ready)) \
206 spin_lock_irqsave(&wdata->state.lock, flags); \
207 state = !!(wdata->state.flags & WIIPROTO_FLAG_LED##num); \
208 spin_unlock_irqrestore(&wdata->state.lock, flags); \
210 return sprintf(buf, "%d\n", state); \
212 static ssize_t wiifs_led_set_##num(struct device *dev, \
213 struct device_attribute *attr, const char *buf, size_t count) \
215 struct wiimote_data *wdata = dev_to_wii(dev); \
216 int tmp = simple_strtoul(buf, NULL, 10); \
217 unsigned long flags; \
220 if (!atomic_read(&wdata->ready)) \
223 spin_lock_irqsave(&wdata->state.lock, flags); \
225 state = wdata->state.flags; \
228 wiiproto_req_leds(wdata, state | WIIPROTO_FLAG_LED##num);\
230 wiiproto_req_leds(wdata, state & ~WIIPROTO_FLAG_LED##num);\
232 spin_unlock_irqrestore(&wdata->state.lock, flags); \
236 static DEVICE_ATTR(led##num, S_IRUGO | S_IWUSR, wiifs_led_show_##num, \
239 wiifs_led_show_set(1);
240 wiifs_led_show_set(2);
241 wiifs_led_show_set(3);
242 wiifs_led_show_set(4);
244 static int wiimote_input_event(struct input_dev
*dev
, unsigned int type
,
245 unsigned int code
, int value
)
247 struct wiimote_data
*wdata
= input_get_drvdata(dev
);
249 if (!atomic_read(&wdata
->ready
))
251 /* smp_rmb: Make sure wdata->xy is available when wdata->ready is 1 */
257 static void handler_keys(struct wiimote_data
*wdata
, const __u8
*payload
)
259 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_LEFT
],
260 !!(payload
[0] & 0x01));
261 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_RIGHT
],
262 !!(payload
[0] & 0x02));
263 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_DOWN
],
264 !!(payload
[0] & 0x04));
265 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_UP
],
266 !!(payload
[0] & 0x08));
267 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_PLUS
],
268 !!(payload
[0] & 0x10));
269 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_TWO
],
270 !!(payload
[1] & 0x01));
271 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_ONE
],
272 !!(payload
[1] & 0x02));
273 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_B
],
274 !!(payload
[1] & 0x04));
275 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_A
],
276 !!(payload
[1] & 0x08));
277 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_MINUS
],
278 !!(payload
[1] & 0x10));
279 input_report_key(wdata
->input
, wiiproto_keymap
[WIIPROTO_KEY_HOME
],
280 !!(payload
[1] & 0x80));
281 input_sync(wdata
->input
);
284 struct wiiproto_handler
{
287 void (*func
)(struct wiimote_data
*wdata
, const __u8
*payload
);
290 static struct wiiproto_handler handlers
[] = {
291 { .id
= WIIPROTO_REQ_DRM_K
, .size
= 2, .func
= handler_keys
},
295 static int wiimote_hid_event(struct hid_device
*hdev
, struct hid_report
*report
,
296 u8
*raw_data
, int size
)
298 struct wiimote_data
*wdata
= hid_get_drvdata(hdev
);
299 struct wiiproto_handler
*h
;
303 if (!atomic_read(&wdata
->ready
))
305 /* smp_rmb: Make sure wdata->xy is available when wdata->ready is 1 */
311 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
313 for (i
= 0; handlers
[i
].id
; ++i
) {
315 if (h
->id
== raw_data
[0] && h
->size
< size
)
316 h
->func(wdata
, &raw_data
[1]);
319 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
324 static struct wiimote_data
*wiimote_create(struct hid_device
*hdev
)
326 struct wiimote_data
*wdata
;
329 wdata
= kzalloc(sizeof(*wdata
), GFP_KERNEL
);
333 wdata
->input
= input_allocate_device();
340 hid_set_drvdata(hdev
, wdata
);
342 input_set_drvdata(wdata
->input
, wdata
);
343 wdata
->input
->event
= wiimote_input_event
;
344 wdata
->input
->dev
.parent
= &wdata
->hdev
->dev
;
345 wdata
->input
->id
.bustype
= wdata
->hdev
->bus
;
346 wdata
->input
->id
.vendor
= wdata
->hdev
->vendor
;
347 wdata
->input
->id
.product
= wdata
->hdev
->product
;
348 wdata
->input
->id
.version
= wdata
->hdev
->version
;
349 wdata
->input
->name
= WIIMOTE_NAME
;
351 set_bit(EV_KEY
, wdata
->input
->evbit
);
352 for (i
= 0; i
< WIIPROTO_KEY_COUNT
; ++i
)
353 set_bit(wiiproto_keymap
[i
], wdata
->input
->keybit
);
355 spin_lock_init(&wdata
->qlock
);
356 INIT_WORK(&wdata
->worker
, wiimote_worker
);
358 spin_lock_init(&wdata
->state
.lock
);
363 static void wiimote_destroy(struct wiimote_data
*wdata
)
368 static int wiimote_hid_probe(struct hid_device
*hdev
,
369 const struct hid_device_id
*id
)
371 struct wiimote_data
*wdata
;
374 wdata
= wiimote_create(hdev
);
376 hid_err(hdev
, "Can't alloc device\n");
380 ret
= device_create_file(&hdev
->dev
, &dev_attr_led1
);
383 ret
= device_create_file(&hdev
->dev
, &dev_attr_led2
);
386 ret
= device_create_file(&hdev
->dev
, &dev_attr_led3
);
389 ret
= device_create_file(&hdev
->dev
, &dev_attr_led4
);
393 ret
= hid_parse(hdev
);
395 hid_err(hdev
, "HID parse failed\n");
399 ret
= hid_hw_start(hdev
, HID_CONNECT_HIDRAW
);
401 hid_err(hdev
, "HW start failed\n");
405 ret
= input_register_device(wdata
->input
);
407 hid_err(hdev
, "Cannot register input device\n");
411 /* smp_wmb: Write wdata->xy first before wdata->ready is set to 1 */
413 atomic_set(&wdata
->ready
, 1);
414 hid_info(hdev
, "New device registered\n");
416 /* by default set led1 after device initialization */
417 spin_lock_irq(&wdata
->state
.lock
);
418 wiiproto_req_leds(wdata
, WIIPROTO_FLAG_LED1
);
419 spin_unlock_irq(&wdata
->state
.lock
);
426 input_free_device(wdata
->input
);
427 device_remove_file(&hdev
->dev
, &dev_attr_led1
);
428 device_remove_file(&hdev
->dev
, &dev_attr_led2
);
429 device_remove_file(&hdev
->dev
, &dev_attr_led3
);
430 device_remove_file(&hdev
->dev
, &dev_attr_led4
);
431 wiimote_destroy(wdata
);
435 static void wiimote_hid_remove(struct hid_device
*hdev
)
437 struct wiimote_data
*wdata
= hid_get_drvdata(hdev
);
439 hid_info(hdev
, "Device removed\n");
441 device_remove_file(&hdev
->dev
, &dev_attr_led1
);
442 device_remove_file(&hdev
->dev
, &dev_attr_led2
);
443 device_remove_file(&hdev
->dev
, &dev_attr_led3
);
444 device_remove_file(&hdev
->dev
, &dev_attr_led4
);
447 input_unregister_device(wdata
->input
);
449 cancel_work_sync(&wdata
->worker
);
450 wiimote_destroy(wdata
);
453 static const struct hid_device_id wiimote_hid_devices
[] = {
454 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO
,
455 USB_DEVICE_ID_NINTENDO_WIIMOTE
) },
458 MODULE_DEVICE_TABLE(hid
, wiimote_hid_devices
);
460 static struct hid_driver wiimote_hid_driver
= {
462 .id_table
= wiimote_hid_devices
,
463 .probe
= wiimote_hid_probe
,
464 .remove
= wiimote_hid_remove
,
465 .raw_event
= wiimote_hid_event
,
468 static int __init
wiimote_init(void)
472 ret
= hid_register_driver(&wiimote_hid_driver
);
474 pr_err("Can't register wiimote hid driver\n");
479 static void __exit
wiimote_exit(void)
481 hid_unregister_driver(&wiimote_hid_driver
);
484 module_init(wiimote_init
);
485 module_exit(wiimote_exit
);
486 MODULE_LICENSE("GPL");
487 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
488 MODULE_DESCRIPTION(WIIMOTE_NAME
" Device Driver");
489 MODULE_VERSION(WIIMOTE_VERSION
);