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);