2 * HID driver for Nintendo Wii / Wii U peripherals
3 * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
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/module.h>
18 #include <linux/mutex.h>
19 #include <linux/spinlock.h>
21 #include "hid-wiimote.h"
23 /* output queue handling */
25 static int wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
31 if (!hdev->hid_output_raw_report)
34 buf = kmemdup(buffer, count, GFP_KERNEL);
38 ret = hdev->hid_output_raw_report(hdev, buf, count, HID_OUTPUT_REPORT);
44 static void wiimote_queue_worker(struct work_struct *work)
46 struct wiimote_queue *queue = container_of(work, struct wiimote_queue,
48 struct wiimote_data *wdata = container_of(queue, struct wiimote_data,
53 spin_lock_irqsave(&wdata->queue.lock, flags);
55 while (wdata->queue.head != wdata->queue.tail) {
56 spin_unlock_irqrestore(&wdata->queue.lock, flags);
57 ret = wiimote_hid_send(wdata->hdev,
58 wdata->queue.outq[wdata->queue.tail].data,
59 wdata->queue.outq[wdata->queue.tail].size);
61 spin_lock_irqsave(&wdata->state.lock, flags);
62 wiimote_cmd_abort(wdata);
63 spin_unlock_irqrestore(&wdata->state.lock, flags);
65 spin_lock_irqsave(&wdata->queue.lock, flags);
67 wdata->queue.tail = (wdata->queue.tail + 1) % WIIMOTE_BUFSIZE;
70 spin_unlock_irqrestore(&wdata->queue.lock, flags);
73 static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
79 if (count > HID_MAX_BUFFER_SIZE) {
80 hid_warn(wdata->hdev, "Sending too large output report\n");
82 spin_lock_irqsave(&wdata->queue.lock, flags);
87 * Copy new request into our output queue and check whether the
88 * queue is full. If it is full, discard this request.
89 * If it is empty we need to start a new worker that will
90 * send out the buffer to the hid device.
91 * If the queue is not empty, then there must be a worker
92 * that is currently sending out our buffer and this worker
93 * will reschedule itself until the queue is empty.
96 spin_lock_irqsave(&wdata->queue.lock, flags);
98 memcpy(wdata->queue.outq[wdata->queue.head].data, buffer, count);
99 wdata->queue.outq[wdata->queue.head].size = count;
100 newhead = (wdata->queue.head + 1) % WIIMOTE_BUFSIZE;
102 if (wdata->queue.head == wdata->queue.tail) {
103 wdata->queue.head = newhead;
104 schedule_work(&wdata->queue.worker);
105 } else if (newhead != wdata->queue.tail) {
106 wdata->queue.head = newhead;
108 hid_warn(wdata->hdev, "Output queue is full");
115 wiimote_cmd_abort(wdata);
117 spin_unlock_irqrestore(&wdata->queue.lock, flags);
121 * This sets the rumble bit on the given output report if rumble is
123 * \cmd1 must point to the second byte in the output report => &cmd[1]
124 * This must be called on nearly every output report before passing it
125 * into the output queue!
127 static inline void wiiproto_keep_rumble(struct wiimote_data *wdata, __u8 *cmd1)
129 if (wdata->state.flags & WIIPROTO_FLAG_RUMBLE)
133 void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
138 if (rumble == !!(wdata->state.flags & WIIPROTO_FLAG_RUMBLE))
142 wdata->state.flags |= WIIPROTO_FLAG_RUMBLE;
144 wdata->state.flags &= ~WIIPROTO_FLAG_RUMBLE;
146 cmd[0] = WIIPROTO_REQ_RUMBLE;
149 wiiproto_keep_rumble(wdata, &cmd[1]);
150 wiimote_queue(wdata, cmd, sizeof(cmd));
153 void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
157 leds &= WIIPROTO_FLAGS_LEDS;
158 if ((wdata->state.flags & WIIPROTO_FLAGS_LEDS) == leds)
160 wdata->state.flags = (wdata->state.flags & ~WIIPROTO_FLAGS_LEDS) | leds;
162 cmd[0] = WIIPROTO_REQ_LED;
165 if (leds & WIIPROTO_FLAG_LED1)
167 if (leds & WIIPROTO_FLAG_LED2)
169 if (leds & WIIPROTO_FLAG_LED3)
171 if (leds & WIIPROTO_FLAG_LED4)
174 wiiproto_keep_rumble(wdata, &cmd[1]);
175 wiimote_queue(wdata, cmd, sizeof(cmd));
179 * Check what peripherals of the wiimote are currently
180 * active and select a proper DRM that supports all of
181 * the requested data inputs.
183 static __u8 select_drm(struct wiimote_data *wdata)
185 __u8 ir = wdata->state.flags & WIIPROTO_FLAGS_IR;
186 bool ext = wiiext_active(wdata);
188 if (ir == WIIPROTO_FLAG_IR_BASIC) {
189 if (wdata->state.flags & WIIPROTO_FLAG_ACCEL)
190 return WIIPROTO_REQ_DRM_KAIE;
192 return WIIPROTO_REQ_DRM_KIE;
193 } else if (ir == WIIPROTO_FLAG_IR_EXT) {
194 return WIIPROTO_REQ_DRM_KAI;
195 } else if (ir == WIIPROTO_FLAG_IR_FULL) {
196 return WIIPROTO_REQ_DRM_SKAI1;
198 if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) {
200 return WIIPROTO_REQ_DRM_KAE;
202 return WIIPROTO_REQ_DRM_KA;
205 return WIIPROTO_REQ_DRM_KE;
207 return WIIPROTO_REQ_DRM_K;
212 void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
216 if (drm == WIIPROTO_REQ_NULL)
217 drm = select_drm(wdata);
219 cmd[0] = WIIPROTO_REQ_DRM;
223 wdata->state.drm = drm;
224 wiiproto_keep_rumble(wdata, &cmd[1]);
225 wiimote_queue(wdata, cmd, sizeof(cmd));
228 void wiiproto_req_status(struct wiimote_data *wdata)
232 cmd[0] = WIIPROTO_REQ_SREQ;
235 wiiproto_keep_rumble(wdata, &cmd[1]);
236 wiimote_queue(wdata, cmd, sizeof(cmd));
239 void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
242 if (accel == !!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
246 wdata->state.flags |= WIIPROTO_FLAG_ACCEL;
248 wdata->state.flags &= ~WIIPROTO_FLAG_ACCEL;
250 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
253 void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
257 cmd[0] = WIIPROTO_REQ_IR1;
260 wiiproto_keep_rumble(wdata, &cmd[1]);
261 wiimote_queue(wdata, cmd, sizeof(cmd));
264 void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags)
268 cmd[0] = WIIPROTO_REQ_IR2;
271 wiiproto_keep_rumble(wdata, &cmd[1]);
272 wiimote_queue(wdata, cmd, sizeof(cmd));
275 #define wiiproto_req_wreg(wdata, os, buf, sz) \
276 wiiproto_req_wmem((wdata), false, (os), (buf), (sz))
278 #define wiiproto_req_weeprom(wdata, os, buf, sz) \
279 wiiproto_req_wmem((wdata), true, (os), (buf), (sz))
281 static void wiiproto_req_wmem(struct wiimote_data *wdata, bool eeprom,
282 __u32 offset, const __u8 *buf, __u8 size)
286 if (size > 16 || size == 0) {
287 hid_warn(wdata->hdev, "Invalid length %d wmem request\n", size);
291 memset(cmd, 0, sizeof(cmd));
292 cmd[0] = WIIPROTO_REQ_WMEM;
293 cmd[2] = (offset >> 16) & 0xff;
294 cmd[3] = (offset >> 8) & 0xff;
295 cmd[4] = offset & 0xff;
297 memcpy(&cmd[6], buf, size);
302 wiiproto_keep_rumble(wdata, &cmd[1]);
303 wiimote_queue(wdata, cmd, sizeof(cmd));
306 void wiiproto_req_rmem(struct wiimote_data *wdata, bool eeprom, __u32 offset,
312 hid_warn(wdata->hdev, "Invalid length %d rmem request\n", size);
316 cmd[0] = WIIPROTO_REQ_RMEM;
318 cmd[2] = (offset >> 16) & 0xff;
319 cmd[3] = (offset >> 8) & 0xff;
320 cmd[4] = offset & 0xff;
321 cmd[5] = (size >> 8) & 0xff;
322 cmd[6] = size & 0xff;
327 wiiproto_keep_rumble(wdata, &cmd[1]);
328 wiimote_queue(wdata, cmd, sizeof(cmd));
331 /* requries the cmd-mutex to be held */
332 int wiimote_cmd_write(struct wiimote_data *wdata, __u32 offset,
333 const __u8 *wmem, __u8 size)
338 spin_lock_irqsave(&wdata->state.lock, flags);
339 wiimote_cmd_set(wdata, WIIPROTO_REQ_WMEM, 0);
340 wiiproto_req_wreg(wdata, offset, wmem, size);
341 spin_unlock_irqrestore(&wdata->state.lock, flags);
343 ret = wiimote_cmd_wait(wdata);
344 if (!ret && wdata->state.cmd_err)
350 /* requries the cmd-mutex to be held */
351 ssize_t wiimote_cmd_read(struct wiimote_data *wdata, __u32 offset, __u8 *rmem,
357 spin_lock_irqsave(&wdata->state.lock, flags);
358 wdata->state.cmd_read_size = size;
359 wdata->state.cmd_read_buf = rmem;
360 wiimote_cmd_set(wdata, WIIPROTO_REQ_RMEM, offset & 0xffff);
361 wiiproto_req_rreg(wdata, offset, size);
362 spin_unlock_irqrestore(&wdata->state.lock, flags);
364 ret = wiimote_cmd_wait(wdata);
366 spin_lock_irqsave(&wdata->state.lock, flags);
367 wdata->state.cmd_read_buf = NULL;
368 spin_unlock_irqrestore(&wdata->state.lock, flags);
371 if (wdata->state.cmd_read_size == 0)
374 ret = wdata->state.cmd_read_size;
380 /* requires the cmd-mutex to be held */
381 static int wiimote_cmd_init_ext(struct wiimote_data *wdata)
386 /* initialize extension */
388 ret = wiimote_cmd_write(wdata, 0xa400f0, &wmem, sizeof(wmem));
392 /* disable default encryption */
394 ret = wiimote_cmd_write(wdata, 0xa400fb, &wmem, sizeof(wmem));
401 /* requires the cmd-mutex to be held */
402 static __u8 wiimote_cmd_read_ext(struct wiimote_data *wdata)
407 /* read extension ID */
408 ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6);
410 return WIIMOTE_EXT_NONE;
412 if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff &&
413 rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff)
414 return WIIMOTE_EXT_NONE;
416 return WIIMOTE_EXT_UNKNOWN;
419 /* device module handling */
421 static const __u8 * const wiimote_devtype_mods[WIIMOTE_DEV_NUM] = {
422 [WIIMOTE_DEV_PENDING] = (const __u8[]){
425 [WIIMOTE_DEV_UNKNOWN] = (const __u8[]){
428 [WIIMOTE_DEV_GENERIC] = (const __u8[]){
440 [WIIMOTE_DEV_GEN10] = (const __u8[]){
452 [WIIMOTE_DEV_GEN20] = (const __u8[]){
466 static void wiimote_modules_load(struct wiimote_data *wdata,
467 unsigned int devtype)
469 bool need_input = false;
470 const __u8 *mods, *iter;
471 const struct wiimod_ops *ops;
474 mods = wiimote_devtype_mods[devtype];
476 for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
477 if (wiimod_table[*iter]->flags & WIIMOD_FLAG_INPUT) {
484 wdata->input = input_allocate_device();
488 input_set_drvdata(wdata->input, wdata);
489 wdata->input->dev.parent = &wdata->hdev->dev;
490 wdata->input->id.bustype = wdata->hdev->bus;
491 wdata->input->id.vendor = wdata->hdev->vendor;
492 wdata->input->id.product = wdata->hdev->product;
493 wdata->input->id.version = wdata->hdev->version;
494 wdata->input->name = WIIMOTE_NAME;
497 for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
498 ops = wiimod_table[*iter];
502 ret = ops->probe(ops, wdata);
508 ret = input_register_device(wdata->input);
513 spin_lock_irq(&wdata->state.lock);
514 wdata->state.devtype = devtype;
515 spin_unlock_irq(&wdata->state.lock);
519 for ( ; iter-- != mods; ) {
520 ops = wiimod_table[*iter];
522 ops->remove(ops, wdata);
526 input_free_device(wdata->input);
531 static void wiimote_modules_unload(struct wiimote_data *wdata)
533 const __u8 *mods, *iter;
534 const struct wiimod_ops *ops;
537 mods = wiimote_devtype_mods[wdata->state.devtype];
539 spin_lock_irqsave(&wdata->state.lock, flags);
540 wdata->state.devtype = WIIMOTE_DEV_UNKNOWN;
541 spin_unlock_irqrestore(&wdata->state.lock, flags);
543 /* find end of list */
544 for (iter = mods; *iter != WIIMOD_NULL; ++iter)
548 input_get_device(wdata->input);
549 input_unregister_device(wdata->input);
552 for ( ; iter-- != mods; ) {
553 ops = wiimod_table[*iter];
555 ops->remove(ops, wdata);
559 input_put_device(wdata->input);
564 /* device (re-)initialization and detection */
566 static const char *wiimote_devtype_names[WIIMOTE_DEV_NUM] = {
567 [WIIMOTE_DEV_PENDING] = "Pending",
568 [WIIMOTE_DEV_UNKNOWN] = "Unknown",
569 [WIIMOTE_DEV_GENERIC] = "Generic",
570 [WIIMOTE_DEV_GEN10] = "Nintendo Wii Remote (Gen 1)",
571 [WIIMOTE_DEV_GEN20] = "Nintendo Wii Remote Plus (Gen 2)",
574 /* Try to guess the device type based on all collected information. We
575 * first try to detect by static extension types, then VID/PID and the
576 * device name. If we cannot detect the device, we use
577 * WIIMOTE_DEV_GENERIC so all modules will get probed on the device. */
578 static void wiimote_init_set_type(struct wiimote_data *wdata,
581 __u8 devtype = WIIMOTE_DEV_GENERIC;
582 __u16 vendor, product;
585 vendor = wdata->hdev->vendor;
586 product = wdata->hdev->product;
587 name = wdata->hdev->name;
589 if (!strcmp(name, "Nintendo RVL-CNT-01")) {
590 devtype = WIIMOTE_DEV_GEN10;
592 } else if (!strcmp(name, "Nintendo RVL-CNT-01-TR")) {
593 devtype = WIIMOTE_DEV_GEN20;
597 if (vendor == USB_VENDOR_ID_NINTENDO) {
598 if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE) {
599 devtype = WIIMOTE_DEV_GEN10;
601 } else if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE2) {
602 devtype = WIIMOTE_DEV_GEN20;
608 if (devtype == WIIMOTE_DEV_GENERIC)
609 hid_info(wdata->hdev, "cannot detect device; NAME: %s VID: %04x PID: %04x EXT: %04x\n",
610 name, vendor, product, exttype);
612 hid_info(wdata->hdev, "detected device: %s\n",
613 wiimote_devtype_names[devtype]);
615 wiimote_modules_load(wdata, devtype);
618 static void wiimote_init_detect(struct wiimote_data *wdata)
620 __u8 exttype = WIIMOTE_EXT_NONE;
624 wiimote_cmd_acquire_noint(wdata);
626 spin_lock_irq(&wdata->state.lock);
627 wdata->state.devtype = WIIMOTE_DEV_UNKNOWN;
628 wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
629 wiiproto_req_status(wdata);
630 spin_unlock_irq(&wdata->state.lock);
632 ret = wiimote_cmd_wait_noint(wdata);
636 spin_lock_irq(&wdata->state.lock);
637 ext = wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED;
638 spin_unlock_irq(&wdata->state.lock);
643 wiimote_cmd_init_ext(wdata);
644 exttype = wiimote_cmd_read_ext(wdata);
647 wiimote_cmd_release(wdata);
648 wiimote_init_set_type(wdata, exttype);
651 static void wiimote_init_worker(struct work_struct *work)
653 struct wiimote_data *wdata = container_of(work, struct wiimote_data,
656 if (wdata->state.devtype == WIIMOTE_DEV_PENDING)
657 wiimote_init_detect(wdata);
660 /* protocol handlers */
662 static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
664 const __u8 *iter, *mods;
665 const struct wiimod_ops *ops;
667 mods = wiimote_devtype_mods[wdata->state.devtype];
668 for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
669 ops = wiimod_table[*iter];
671 ops->in_keys(wdata, payload);
677 static void handler_accel(struct wiimote_data *wdata, const __u8 *payload)
679 const __u8 *iter, *mods;
680 const struct wiimod_ops *ops;
682 mods = wiimote_devtype_mods[wdata->state.devtype];
683 for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
684 ops = wiimod_table[*iter];
686 ops->in_accel(wdata, payload);
692 #define ir_to_input0(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 0)
693 #define ir_to_input1(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 1)
694 #define ir_to_input2(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 2)
695 #define ir_to_input3(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 3)
697 static void handler_ir(struct wiimote_data *wdata, const __u8 *payload,
698 bool packed, unsigned int id)
700 const __u8 *iter, *mods;
701 const struct wiimod_ops *ops;
703 mods = wiimote_devtype_mods[wdata->state.devtype];
704 for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
705 ops = wiimod_table[*iter];
707 ops->in_ir(wdata, payload, packed, id);
713 /* reduced status report with "BB BB" key data only */
714 static void handler_status_K(struct wiimote_data *wdata,
717 handler_keys(wdata, payload);
719 /* on status reports the drm is reset so we need to resend the drm */
720 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
723 /* extended status report with "BB BB LF 00 00 VV" data */
724 static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
726 handler_status_K(wdata, payload);
728 /* update extension status */
729 if (payload[2] & 0x02) {
730 wdata->state.flags |= WIIPROTO_FLAG_EXT_PLUGGED;
731 wiiext_event(wdata, true);
733 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED;
734 wiiext_event(wdata, false);
737 wdata->state.cmd_battery = payload[5];
738 if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_SREQ, 0))
739 wiimote_cmd_complete(wdata);
742 /* reduced generic report with "BB BB" key data only */
743 static void handler_generic_K(struct wiimote_data *wdata, const __u8 *payload)
745 handler_keys(wdata, payload);
748 static void handler_data(struct wiimote_data *wdata, const __u8 *payload)
750 __u16 offset = payload[3] << 8 | payload[4];
751 __u8 size = (payload[2] >> 4) + 1;
752 __u8 err = payload[2] & 0x0f;
754 handler_keys(wdata, payload);
756 if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_RMEM, offset)) {
759 else if (size > wdata->state.cmd_read_size)
760 size = wdata->state.cmd_read_size;
762 wdata->state.cmd_read_size = size;
763 if (wdata->state.cmd_read_buf)
764 memcpy(wdata->state.cmd_read_buf, &payload[5], size);
765 wiimote_cmd_complete(wdata);
769 static void handler_return(struct wiimote_data *wdata, const __u8 *payload)
771 __u8 err = payload[3];
772 __u8 cmd = payload[2];
774 handler_keys(wdata, payload);
776 if (wiimote_cmd_pending(wdata, cmd, 0)) {
777 wdata->state.cmd_err = err;
778 wiimote_cmd_complete(wdata);
780 hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err,
785 static void handler_drm_KA(struct wiimote_data *wdata, const __u8 *payload)
787 handler_keys(wdata, payload);
788 handler_accel(wdata, payload);
791 static void handler_drm_KE(struct wiimote_data *wdata, const __u8 *payload)
793 handler_keys(wdata, payload);
794 wiiext_handle(wdata, &payload[2]);
797 static void handler_drm_KAI(struct wiimote_data *wdata, const __u8 *payload)
799 handler_keys(wdata, payload);
800 handler_accel(wdata, payload);
801 ir_to_input0(wdata, &payload[5], false);
802 ir_to_input1(wdata, &payload[8], false);
803 ir_to_input2(wdata, &payload[11], false);
804 ir_to_input3(wdata, &payload[14], false);
807 static void handler_drm_KEE(struct wiimote_data *wdata, const __u8 *payload)
809 handler_keys(wdata, payload);
810 wiiext_handle(wdata, &payload[2]);
813 static void handler_drm_KIE(struct wiimote_data *wdata, const __u8 *payload)
815 handler_keys(wdata, payload);
816 ir_to_input0(wdata, &payload[2], false);
817 ir_to_input1(wdata, &payload[4], true);
818 ir_to_input2(wdata, &payload[7], false);
819 ir_to_input3(wdata, &payload[9], true);
820 wiiext_handle(wdata, &payload[12]);
823 static void handler_drm_KAE(struct wiimote_data *wdata, const __u8 *payload)
825 handler_keys(wdata, payload);
826 handler_accel(wdata, payload);
827 wiiext_handle(wdata, &payload[5]);
830 static void handler_drm_KAIE(struct wiimote_data *wdata, const __u8 *payload)
832 handler_keys(wdata, payload);
833 handler_accel(wdata, payload);
834 ir_to_input0(wdata, &payload[5], false);
835 ir_to_input1(wdata, &payload[7], true);
836 ir_to_input2(wdata, &payload[10], false);
837 ir_to_input3(wdata, &payload[12], true);
838 wiiext_handle(wdata, &payload[15]);
841 static void handler_drm_E(struct wiimote_data *wdata, const __u8 *payload)
843 wiiext_handle(wdata, payload);
846 static void handler_drm_SKAI1(struct wiimote_data *wdata, const __u8 *payload)
848 handler_keys(wdata, payload);
850 wdata->state.accel_split[0] = payload[2];
851 wdata->state.accel_split[1] = (payload[0] >> 1) & (0x10 | 0x20);
852 wdata->state.accel_split[1] |= (payload[1] << 1) & (0x40 | 0x80);
854 ir_to_input0(wdata, &payload[3], false);
855 ir_to_input1(wdata, &payload[12], false);
858 static void handler_drm_SKAI2(struct wiimote_data *wdata, const __u8 *payload)
862 handler_keys(wdata, payload);
864 wdata->state.accel_split[1] |= (payload[0] >> 5) & (0x01 | 0x02);
865 wdata->state.accel_split[1] |= (payload[1] >> 3) & (0x04 | 0x08);
869 buf[2] = wdata->state.accel_split[0];
871 buf[4] = wdata->state.accel_split[1];
872 handler_accel(wdata, buf);
874 ir_to_input2(wdata, &payload[3], false);
875 ir_to_input3(wdata, &payload[12], false);
878 struct wiiproto_handler {
881 void (*func)(struct wiimote_data *wdata, const __u8 *payload);
884 static struct wiiproto_handler handlers[] = {
885 { .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
886 { .id = WIIPROTO_REQ_STATUS, .size = 2, .func = handler_status_K },
887 { .id = WIIPROTO_REQ_DATA, .size = 21, .func = handler_data },
888 { .id = WIIPROTO_REQ_DATA, .size = 2, .func = handler_generic_K },
889 { .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
890 { .id = WIIPROTO_REQ_RETURN, .size = 2, .func = handler_generic_K },
891 { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
892 { .id = WIIPROTO_REQ_DRM_KA, .size = 5, .func = handler_drm_KA },
893 { .id = WIIPROTO_REQ_DRM_KA, .size = 2, .func = handler_generic_K },
894 { .id = WIIPROTO_REQ_DRM_KE, .size = 10, .func = handler_drm_KE },
895 { .id = WIIPROTO_REQ_DRM_KE, .size = 2, .func = handler_generic_K },
896 { .id = WIIPROTO_REQ_DRM_KAI, .size = 17, .func = handler_drm_KAI },
897 { .id = WIIPROTO_REQ_DRM_KAI, .size = 2, .func = handler_generic_K },
898 { .id = WIIPROTO_REQ_DRM_KEE, .size = 21, .func = handler_drm_KEE },
899 { .id = WIIPROTO_REQ_DRM_KEE, .size = 2, .func = handler_generic_K },
900 { .id = WIIPROTO_REQ_DRM_KAE, .size = 21, .func = handler_drm_KAE },
901 { .id = WIIPROTO_REQ_DRM_KAE, .size = 2, .func = handler_generic_K },
902 { .id = WIIPROTO_REQ_DRM_KIE, .size = 21, .func = handler_drm_KIE },
903 { .id = WIIPROTO_REQ_DRM_KIE, .size = 2, .func = handler_generic_K },
904 { .id = WIIPROTO_REQ_DRM_KAIE, .size = 21, .func = handler_drm_KAIE },
905 { .id = WIIPROTO_REQ_DRM_KAIE, .size = 2, .func = handler_generic_K },
906 { .id = WIIPROTO_REQ_DRM_E, .size = 21, .func = handler_drm_E },
907 { .id = WIIPROTO_REQ_DRM_SKAI1, .size = 21, .func = handler_drm_SKAI1 },
908 { .id = WIIPROTO_REQ_DRM_SKAI2, .size = 21, .func = handler_drm_SKAI2 },
912 static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
913 u8 *raw_data, int size)
915 struct wiimote_data *wdata = hid_get_drvdata(hdev);
916 struct wiiproto_handler *h;
923 spin_lock_irqsave(&wdata->state.lock, flags);
925 for (i = 0; handlers[i].id; ++i) {
927 if (h->id == raw_data[0] && h->size < size) {
928 h->func(wdata, &raw_data[1]);
934 hid_warn(hdev, "Unhandled report %hhu size %d\n", raw_data[0],
937 spin_unlock_irqrestore(&wdata->state.lock, flags);
942 static struct wiimote_data *wiimote_create(struct hid_device *hdev)
944 struct wiimote_data *wdata;
946 wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
951 hid_set_drvdata(hdev, wdata);
953 spin_lock_init(&wdata->queue.lock);
954 INIT_WORK(&wdata->queue.worker, wiimote_queue_worker);
956 spin_lock_init(&wdata->state.lock);
957 init_completion(&wdata->state.ready);
958 mutex_init(&wdata->state.sync);
959 wdata->state.drm = WIIPROTO_REQ_DRM_K;
960 wdata->state.cmd_battery = 0xff;
962 INIT_WORK(&wdata->init_worker, wiimote_init_worker);
967 static void wiimote_destroy(struct wiimote_data *wdata)
969 wiidebug_deinit(wdata);
970 wiiext_deinit(wdata);
972 cancel_work_sync(&wdata->init_worker);
973 wiimote_modules_unload(wdata);
974 cancel_work_sync(&wdata->queue.worker);
975 hid_hw_close(wdata->hdev);
976 hid_hw_stop(wdata->hdev);
981 static int wiimote_hid_probe(struct hid_device *hdev,
982 const struct hid_device_id *id)
984 struct wiimote_data *wdata;
987 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
989 wdata = wiimote_create(hdev);
991 hid_err(hdev, "Can't alloc device\n");
995 ret = hid_parse(hdev);
997 hid_err(hdev, "HID parse failed\n");
1001 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1003 hid_err(hdev, "HW start failed\n");
1007 ret = hid_hw_open(hdev);
1009 hid_err(hdev, "cannot start hardware I/O\n");
1013 ret = wiiext_init(wdata);
1017 ret = wiidebug_init(wdata);
1021 hid_info(hdev, "New device registered\n");
1023 /* schedule device detection */
1024 schedule_work(&wdata->init_worker);
1029 wiimote_destroy(wdata);
1035 input_free_device(wdata->ir);
1036 input_free_device(wdata->accel);
1041 static void wiimote_hid_remove(struct hid_device *hdev)
1043 struct wiimote_data *wdata = hid_get_drvdata(hdev);
1045 hid_info(hdev, "Device removed\n");
1046 wiimote_destroy(wdata);
1049 static const struct hid_device_id wiimote_hid_devices[] = {
1050 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
1051 USB_DEVICE_ID_NINTENDO_WIIMOTE) },
1052 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
1053 USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
1056 MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
1058 static struct hid_driver wiimote_hid_driver = {
1060 .id_table = wiimote_hid_devices,
1061 .probe = wiimote_hid_probe,
1062 .remove = wiimote_hid_remove,
1063 .raw_event = wiimote_hid_event,
1065 module_hid_driver(wiimote_hid_driver);
1067 MODULE_LICENSE("GPL");
1068 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
1069 MODULE_DESCRIPTION("Driver for Nintendo Wii / Wii U peripherals");