projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
HID: wiimote: add device detection
[deliverable/linux.git] / drivers / hid / hid-wiimote-core.c
CommitLineData
fb51b443 1/*
92eda7e4
DH		 2 * HID driver for Nintendo Wii / Wii U peripherals
3 * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
fb51b443
DH		 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
29d28064 13#include <linux/completion.h>
672bc4e0 14#include <linux/device.h>
02fb72a0 15#include <linux/hid.h>
672bc4e0 16#include <linux/input.h>
23a5a4a3 17#include <linux/leds.h>
fb51b443 18#include <linux/module.h>
29d28064 19#include <linux/mutex.h>
6591d758 20#include <linux/power_supply.h>
23c063cb 21#include <linux/spinlock.h>
02fb72a0 22#include "hid-ids.h"
7e274400 23#include "hid-wiimote.h"
fb51b443 24
1abb9ad3
DH		 25enum wiiproto_keys {
26 WIIPROTO_KEY_LEFT,
27 WIIPROTO_KEY_RIGHT,
28 WIIPROTO_KEY_UP,
29 WIIPROTO_KEY_DOWN,
30 WIIPROTO_KEY_PLUS,
31 WIIPROTO_KEY_MINUS,
32 WIIPROTO_KEY_ONE,
33 WIIPROTO_KEY_TWO,
34 WIIPROTO_KEY_A,
35 WIIPROTO_KEY_B,
36 WIIPROTO_KEY_HOME,
37 WIIPROTO_KEY_COUNT
38};
39
40static __u16 wiiproto_keymap[] = {
41 KEY_LEFT, /* WIIPROTO_KEY_LEFT */
42 KEY_RIGHT, /* WIIPROTO_KEY_RIGHT */
43 KEY_UP, /* WIIPROTO_KEY_UP */
44 KEY_DOWN, /* WIIPROTO_KEY_DOWN */
45 KEY_NEXT, /* WIIPROTO_KEY_PLUS */
46 KEY_PREVIOUS, /* WIIPROTO_KEY_MINUS */
47 BTN_1, /* WIIPROTO_KEY_ONE */
48 BTN_2, /* WIIPROTO_KEY_TWO */
49 BTN_A, /* WIIPROTO_KEY_A */
50 BTN_B, /* WIIPROTO_KEY_B */
51 BTN_MODE, /* WIIPROTO_KEY_HOME */
52};
53
6591d758 54static enum power_supply_property wiimote_battery_props[] = {
73db8813
JF		 55 POWER_SUPPLY_PROP_CAPACITY,
56 POWER_SUPPLY_PROP_SCOPE,
6591d758
DH		 57};
58
13938538
DH		 59/* output queue handling */
60
0c218f14
DH		 61static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
62 size_t count)
63{
64 __u8 *buf;
65 ssize_t ret;
66
67 if (!hdev->hid_output_raw_report)
68 return -ENODEV;
69
70 buf = kmemdup(buffer, count, GFP_KERNEL);
71 if (!buf)
72 return -ENOMEM;
73
74 ret = hdev->hid_output_raw_report(hdev, buf, count, HID_OUTPUT_REPORT);
75
76 kfree(buf);
77 return ret;
78}
79
13938538 80static void wiimote_queue_worker(struct work_struct *work)
23c063cb 81{
13938538
DH		 82 struct wiimote_queue *queue = container_of(work, struct wiimote_queue,
83 worker);
84 struct wiimote_data *wdata = container_of(queue, struct wiimote_data,
85 queue);
23c063cb
DH		 86 unsigned long flags;
87
13938538 88 spin_lock_irqsave(&wdata->queue.lock, flags);
23c063cb 89
13938538
DH		 90 while (wdata->queue.head != wdata->queue.tail) {
91 spin_unlock_irqrestore(&wdata->queue.lock, flags);
92 wiimote_hid_send(wdata->hdev,
93 wdata->queue.outq[wdata->queue.tail].data,
94 wdata->queue.outq[wdata->queue.tail].size);
95 spin_lock_irqsave(&wdata->queue.lock, flags);
23c063cb 96
13938538 97 wdata->queue.tail = (wdata->queue.tail + 1) % WIIMOTE_BUFSIZE;
23c063cb
DH		 98 }
99
13938538 100 spin_unlock_irqrestore(&wdata->queue.lock, flags);
23c063cb
DH		 101}
102
103static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
104 size_t count)
105{
106 unsigned long flags;
107 __u8 newhead;
108
109 if (count > HID_MAX_BUFFER_SIZE) {
110 hid_warn(wdata->hdev, "Sending too large output report\n");
111 return;
112 }
113
114 /*
115 * Copy new request into our output queue and check whether the
116 * queue is full. If it is full, discard this request.
117 * If it is empty we need to start a new worker that will
118 * send out the buffer to the hid device.
119 * If the queue is not empty, then there must be a worker
120 * that is currently sending out our buffer and this worker
121 * will reschedule itself until the queue is empty.
122 */
123
13938538 124 spin_lock_irqsave(&wdata->queue.lock, flags);
23c063cb 125
13938538
DH		 126 memcpy(wdata->queue.outq[wdata->queue.head].data, buffer, count);
127 wdata->queue.outq[wdata->queue.head].size = count;
128 newhead = (wdata->queue.head + 1) % WIIMOTE_BUFSIZE;
23c063cb 129
13938538
DH		 130 if (wdata->queue.head == wdata->queue.tail) {
131 wdata->queue.head = newhead;
132 schedule_work(&wdata->queue.worker);
133 } else if (newhead != wdata->queue.tail) {
134 wdata->queue.head = newhead;
23c063cb
DH		 135 } else {
136 hid_warn(wdata->hdev, "Output queue is full");
137 }
138
13938538 139 spin_unlock_irqrestore(&wdata->queue.lock, flags);
23c063cb
DH		 140}
141
c003ec21
DH		 142/*
143 * This sets the rumble bit on the given output report if rumble is
144 * currently enabled.
145 * \cmd1 must point to the second byte in the output report => &cmd[1]
146 * This must be called on nearly every output report before passing it
147 * into the output queue!
148 */
149static inline void wiiproto_keep_rumble(struct wiimote_data *wdata, __u8 *cmd1)
150{
151 if (wdata->state.flags & WIIPROTO_FLAG_RUMBLE)
152 *cmd1 |= 0x01;
153}
154
155static void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
156{
157 __u8 cmd[2];
158
159 rumble = !!rumble;
160 if (rumble == !!(wdata->state.flags & WIIPROTO_FLAG_RUMBLE))
161 return;
162
163 if (rumble)
164 wdata->state.flags |= WIIPROTO_FLAG_RUMBLE;
165 else
166 wdata->state.flags &= ~WIIPROTO_FLAG_RUMBLE;
167
168 cmd[0] = WIIPROTO_REQ_RUMBLE;
169 cmd[1] = 0;
170
171 wiiproto_keep_rumble(wdata, &cmd[1]);
172 wiimote_queue(wdata, cmd, sizeof(cmd));
173}
174
db308346
DH		 175static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
176{
177 __u8 cmd[2];
178
32a0d9a5
DH		 179 leds &= WIIPROTO_FLAGS_LEDS;
180 if ((wdata->state.flags & WIIPROTO_FLAGS_LEDS) == leds)
181 return;
182 wdata->state.flags = (wdata->state.flags & ~WIIPROTO_FLAGS_LEDS) | leds;
183
db308346
DH		 184 cmd[0] = WIIPROTO_REQ_LED;
185 cmd[1] = 0;
186
187 if (leds & WIIPROTO_FLAG_LED1)
188 cmd[1] |= 0x10;
189 if (leds & WIIPROTO_FLAG_LED2)
190 cmd[1] |= 0x20;
191 if (leds & WIIPROTO_FLAG_LED3)
192 cmd[1] |= 0x40;
193 if (leds & WIIPROTO_FLAG_LED4)
194 cmd[1] |= 0x80;
195
c003ec21 196 wiiproto_keep_rumble(wdata, &cmd[1]);
db308346
DH		 197 wiimote_queue(wdata, cmd, sizeof(cmd));
198}
199
2cb5e4bc
DH		 200/*
201 * Check what peripherals of the wiimote are currently
202 * active and select a proper DRM that supports all of
203 * the requested data inputs.
204 */
205static __u8 select_drm(struct wiimote_data *wdata)
206{
f363e4f6 207 __u8 ir = wdata->state.flags & WIIPROTO_FLAGS_IR;
cb99221b 208 bool ext = wiiext_active(wdata);
f363e4f6
DH		 209
210 if (ir == WIIPROTO_FLAG_IR_BASIC) {
211 if (wdata->state.flags & WIIPROTO_FLAG_ACCEL)
212 return WIIPROTO_REQ_DRM_KAIE;
213 else
214 return WIIPROTO_REQ_DRM_KIE;
215 } else if (ir == WIIPROTO_FLAG_IR_EXT) {
216 return WIIPROTO_REQ_DRM_KAI;
217 } else if (ir == WIIPROTO_FLAG_IR_FULL) {
218 return WIIPROTO_REQ_DRM_SKAI1;
219 } else {
cb99221b
DH		 220 if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) {
221 if (ext)
222 return WIIPROTO_REQ_DRM_KAE;
223 else
224 return WIIPROTO_REQ_DRM_KA;
225 } else {
226 if (ext)
227 return WIIPROTO_REQ_DRM_KE;
228 else
229 return WIIPROTO_REQ_DRM_K;
230 }
f363e4f6 231 }
2cb5e4bc
DH		 232}
233
7e274400 234void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
2cb5e4bc
DH		 235{
236 __u8 cmd[3];
237
238 if (drm == WIIPROTO_REQ_NULL)
239 drm = select_drm(wdata);
240
241 cmd[0] = WIIPROTO_REQ_DRM;
242 cmd[1] = 0;
243 cmd[2] = drm;
244
43d782ae 245 wdata->state.drm = drm;
c003ec21 246 wiiproto_keep_rumble(wdata, &cmd[1]);
2cb5e4bc
DH		 247 wiimote_queue(wdata, cmd, sizeof(cmd));
248}
249
e3979a91
DH		 250static void wiiproto_req_status(struct wiimote_data *wdata)
251{
252 __u8 cmd[2];
253
254 cmd[0] = WIIPROTO_REQ_SREQ;
255 cmd[1] = 0;
256
257 wiiproto_keep_rumble(wdata, &cmd[1]);
258 wiimote_queue(wdata, cmd, sizeof(cmd));
259}
260
98a558ae
DH		 261static void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
262{
263 accel = !!accel;
264 if (accel == !!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
265 return;
266
267 if (accel)
268 wdata->state.flags |= WIIPROTO_FLAG_ACCEL;
269 else
270 wdata->state.flags &= ~WIIPROTO_FLAG_ACCEL;
271
272 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
273}
274
fc221cda
DH		 275static void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
276{
277 __u8 cmd[2];
278
279 cmd[0] = WIIPROTO_REQ_IR1;
280 cmd[1] = flags;
281
282 wiiproto_keep_rumble(wdata, &cmd[1]);
283 wiimote_queue(wdata, cmd, sizeof(cmd));
284}
285
286static void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags)
287{
288 __u8 cmd[2];
289
290 cmd[0] = WIIPROTO_REQ_IR2;
291 cmd[1] = flags;
292
293 wiiproto_keep_rumble(wdata, &cmd[1]);
294 wiimote_queue(wdata, cmd, sizeof(cmd));
295}
296
be1ecd62
DH		 297#define wiiproto_req_wreg(wdata, os, buf, sz) \
298 wiiproto_req_wmem((wdata), false, (os), (buf), (sz))
299
300#define wiiproto_req_weeprom(wdata, os, buf, sz) \
301 wiiproto_req_wmem((wdata), true, (os), (buf), (sz))
302
303static void wiiproto_req_wmem(struct wiimote_data *wdata, bool eeprom,
304 __u32 offset, const __u8 *buf, __u8 size)
305{
306 __u8 cmd[22];
307
308 if (size > 16 || size == 0) {
309 hid_warn(wdata->hdev, "Invalid length %d wmem request\n", size);
310 return;
311 }
312
313 memset(cmd, 0, sizeof(cmd));
314 cmd[0] = WIIPROTO_REQ_WMEM;
315 cmd[2] = (offset >> 16) & 0xff;
316 cmd[3] = (offset >> 8) & 0xff;
317 cmd[4] = offset & 0xff;
318 cmd[5] = size;
319 memcpy(&cmd[6], buf, size);
320
321 if (!eeprom)
322 cmd[1] |= 0x04;
323
324 wiiproto_keep_rumble(wdata, &cmd[1]);
325 wiimote_queue(wdata, cmd, sizeof(cmd));
326}
327
1d3452c6
DH		 328void wiiproto_req_rmem(struct wiimote_data *wdata, bool eeprom, __u32 offset,
329 __u16 size)
fad8c0e3
DH		 330{
331 __u8 cmd[7];
332
333 if (size == 0) {
334 hid_warn(wdata->hdev, "Invalid length %d rmem request\n", size);
335 return;
336 }
337
338 cmd[0] = WIIPROTO_REQ_RMEM;
339 cmd[1] = 0;
340 cmd[2] = (offset >> 16) & 0xff;
341 cmd[3] = (offset >> 8) & 0xff;
342 cmd[4] = offset & 0xff;
343 cmd[5] = (size >> 8) & 0xff;
344 cmd[6] = size & 0xff;
345
346 if (!eeprom)
347 cmd[1] |= 0x04;
348
349 wiiproto_keep_rumble(wdata, &cmd[1]);
350 wiimote_queue(wdata, cmd, sizeof(cmd));
351}
352
33e84013 353/* requries the cmd-mutex to be held */
7e274400 354int wiimote_cmd_write(struct wiimote_data *wdata, __u32 offset,
33e84013
DH		 355 const __u8 *wmem, __u8 size)
356{
357 unsigned long flags;
358 int ret;
359
360 spin_lock_irqsave(&wdata->state.lock, flags);
361 wiimote_cmd_set(wdata, WIIPROTO_REQ_WMEM, 0);
362 wiiproto_req_wreg(wdata, offset, wmem, size);
363 spin_unlock_irqrestore(&wdata->state.lock, flags);
364
365 ret = wiimote_cmd_wait(wdata);
366 if (!ret && wdata->state.cmd_err)
367 ret = -EIO;
368
369 return ret;
370}
371
fad8c0e3
DH		 372/* requries the cmd-mutex to be held */
373ssize_t wiimote_cmd_read(struct wiimote_data *wdata, __u32 offset, __u8 *rmem,
374 __u8 size)
375{
376 unsigned long flags;
377 ssize_t ret;
378
379 spin_lock_irqsave(&wdata->state.lock, flags);
380 wdata->state.cmd_read_size = size;
381 wdata->state.cmd_read_buf = rmem;
382 wiimote_cmd_set(wdata, WIIPROTO_REQ_RMEM, offset & 0xffff);
383 wiiproto_req_rreg(wdata, offset, size);
384 spin_unlock_irqrestore(&wdata->state.lock, flags);
385
386 ret = wiimote_cmd_wait(wdata);
387
388 spin_lock_irqsave(&wdata->state.lock, flags);
389 wdata->state.cmd_read_buf = NULL;
390 spin_unlock_irqrestore(&wdata->state.lock, flags);
391
392 if (!ret) {
393 if (wdata->state.cmd_read_size == 0)
394 ret = -EIO;
395 else
396 ret = wdata->state.cmd_read_size;
397 }
398
399 return ret;
400}
401
c57ff761
DH		 402/* requires the cmd-mutex to be held */
403static int wiimote_cmd_init_ext(struct wiimote_data *wdata)
404{
405 __u8 wmem;
406 int ret;
407
408 /* initialize extension */
409 wmem = 0x55;
410 ret = wiimote_cmd_write(wdata, 0xa400f0, &wmem, sizeof(wmem));
411 if (ret)
412 return ret;
413
414 /* disable default encryption */
415 wmem = 0x0;
416 ret = wiimote_cmd_write(wdata, 0xa400fb, &wmem, sizeof(wmem));
417 if (ret)
418 return ret;
419
420 return 0;
421}
422
423/* requires the cmd-mutex to be held */
424static __u8 wiimote_cmd_read_ext(struct wiimote_data *wdata)
425{
426 __u8 rmem[6];
427 int ret;
428
429 /* read extension ID */
430 ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6);
431 if (ret != 6)
432 return WIIMOTE_EXT_NONE;
433
434 if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff &&
435 rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff)
436 return WIIMOTE_EXT_NONE;
437
438 return WIIMOTE_EXT_UNKNOWN;
439}
440
6591d758
DH		 441static int wiimote_battery_get_property(struct power_supply *psy,
442 enum power_supply_property psp,
443 union power_supply_propval *val)
444{
445 struct wiimote_data *wdata = container_of(psy,
446 struct wiimote_data, battery);
447 int ret = 0, state;
448 unsigned long flags;
449
73db8813
JF		 450 if (psp == POWER_SUPPLY_PROP_SCOPE) {
451 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
452 return 0;
453 }
454
6591d758
DH		 455 ret = wiimote_cmd_acquire(wdata);
456 if (ret)
457 return ret;
458
459 spin_lock_irqsave(&wdata->state.lock, flags);
460 wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
461 wiiproto_req_status(wdata);
462 spin_unlock_irqrestore(&wdata->state.lock, flags);
463
464 ret = wiimote_cmd_wait(wdata);
465 state = wdata->state.cmd_battery;
466 wiimote_cmd_release(wdata);
467
468 if (ret)
469 return ret;
470
471 switch (psp) {
472 case POWER_SUPPLY_PROP_CAPACITY:
473 val->intval = state * 100 / 255;
474 break;
475 default:
476 ret = -EINVAL;
477 break;
478 }
479
480 return ret;
481}
482
fc221cda
DH		 483static int wiimote_init_ir(struct wiimote_data *wdata, __u16 mode)
484{
485 int ret;
486 unsigned long flags;
487 __u8 format = 0;
488 static const __u8 data_enable[] = { 0x01 };
489 static const __u8 data_sens1[] = { 0x02, 0x00, 0x00, 0x71, 0x01,
490 0x00, 0xaa, 0x00, 0x64 };
491 static const __u8 data_sens2[] = { 0x63, 0x03 };
492 static const __u8 data_fin[] = { 0x08 };
493
494 spin_lock_irqsave(&wdata->state.lock, flags);
495
496 if (mode == (wdata->state.flags & WIIPROTO_FLAGS_IR)) {
497 spin_unlock_irqrestore(&wdata->state.lock, flags);
498 return 0;
499 }
500
501 if (mode == 0) {
502 wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
503 wiiproto_req_ir1(wdata, 0);
504 wiiproto_req_ir2(wdata, 0);
505 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
506 spin_unlock_irqrestore(&wdata->state.lock, flags);
507 return 0;
508 }
509
510 spin_unlock_irqrestore(&wdata->state.lock, flags);
511
512 ret = wiimote_cmd_acquire(wdata);
513 if (ret)
514 return ret;
515
516 /* send PIXEL CLOCK ENABLE cmd first */
517 spin_lock_irqsave(&wdata->state.lock, flags);
518 wiimote_cmd_set(wdata, WIIPROTO_REQ_IR1, 0);
519 wiiproto_req_ir1(wdata, 0x06);
520 spin_unlock_irqrestore(&wdata->state.lock, flags);
521
522 ret = wiimote_cmd_wait(wdata);
523 if (ret)
524 goto unlock;
525 if (wdata->state.cmd_err) {
526 ret = -EIO;
527 goto unlock;
528 }
529
530 /* enable IR LOGIC */
531 spin_lock_irqsave(&wdata->state.lock, flags);
532 wiimote_cmd_set(wdata, WIIPROTO_REQ_IR2, 0);
533 wiiproto_req_ir2(wdata, 0x06);
534 spin_unlock_irqrestore(&wdata->state.lock, flags);
535
536 ret = wiimote_cmd_wait(wdata);
537 if (ret)
538 goto unlock;
539 if (wdata->state.cmd_err) {
540 ret = -EIO;
541 goto unlock;
542 }
543
544 /* enable IR cam but do not make it send data, yet */
545 ret = wiimote_cmd_write(wdata, 0xb00030, data_enable,
546 sizeof(data_enable));
547 if (ret)
548 goto unlock;
549
550 /* write first sensitivity block */
551 ret = wiimote_cmd_write(wdata, 0xb00000, data_sens1,
552 sizeof(data_sens1));
553 if (ret)
554 goto unlock;
555
556 /* write second sensitivity block */
557 ret = wiimote_cmd_write(wdata, 0xb0001a, data_sens2,
558 sizeof(data_sens2));
559 if (ret)
560 goto unlock;
561
562 /* put IR cam into desired state */
563 switch (mode) {
564 case WIIPROTO_FLAG_IR_FULL:
565 format = 5;
566 break;
567 case WIIPROTO_FLAG_IR_EXT:
568 format = 3;
569 break;
570 case WIIPROTO_FLAG_IR_BASIC:
571 format = 1;
572 break;
573 }
574 ret = wiimote_cmd_write(wdata, 0xb00033, &format, sizeof(format));
575 if (ret)
576 goto unlock;
577
578 /* make IR cam send data */
579 ret = wiimote_cmd_write(wdata, 0xb00030, data_fin, sizeof(data_fin));
580 if (ret)
581 goto unlock;
582
583 /* request new DRM mode compatible to IR mode */
584 spin_lock_irqsave(&wdata->state.lock, flags);
585 wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
586 wdata->state.flags |= mode & WIIPROTO_FLAGS_IR;
587 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
588 spin_unlock_irqrestore(&wdata->state.lock, flags);
589
590unlock:
591 wiimote_cmd_release(wdata);
592 return ret;
593}
594
23a5a4a3
DH		 595static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
596{
597 struct wiimote_data *wdata;
598 struct device *dev = led_dev->dev->parent;
599 int i;
600 unsigned long flags;
601 bool value = false;
602
603 wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
604
605 for (i = 0; i < 4; ++i) {
606 if (wdata->leds[i] == led_dev) {
607 spin_lock_irqsave(&wdata->state.lock, flags);
608 value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
609 spin_unlock_irqrestore(&wdata->state.lock, flags);
610 break;
611 }
612 }
613
614 return value ? LED_FULL : LED_OFF;
615}
616
617static void wiimote_leds_set(struct led_classdev *led_dev,
618 enum led_brightness value)
619{
620 struct wiimote_data *wdata;
621 struct device *dev = led_dev->dev->parent;
622 int i;
623 unsigned long flags;
624 __u8 state, flag;
625
626 wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
627
628 for (i = 0; i < 4; ++i) {
629 if (wdata->leds[i] == led_dev) {
630 flag = WIIPROTO_FLAG_LED(i + 1);
631 spin_lock_irqsave(&wdata->state.lock, flags);
632 state = wdata->state.flags;
633 if (value == LED_OFF)
634 wiiproto_req_leds(wdata, state & ~flag);
635 else
636 wiiproto_req_leds(wdata, state | flag);
637 spin_unlock_irqrestore(&wdata->state.lock, flags);
638 break;
639 }
640 }
641}
3c1c2fce 642
d020be92
DH		 643static int wiimote_ff_play(struct input_dev *dev, void *data,
644 struct ff_effect *eff)
672bc4e0 645{
d020be92
DH		 646 struct wiimote_data *wdata = input_get_drvdata(dev);
647 __u8 value;
648 unsigned long flags;
649
650 /*
651 * The wiimote supports only a single rumble motor so if any magnitude
652 * is set to non-zero then we start the rumble motor. If both are set to
653 * zero, we stop the rumble motor.
654 */
655
656 if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)
657 value = 1;
658 else
659 value = 0;
660
661 spin_lock_irqsave(&wdata->state.lock, flags);
662 wiiproto_req_rumble(wdata, value);
663 spin_unlock_irqrestore(&wdata->state.lock, flags);
664
672bc4e0
DH		 665 return 0;
666}
667
98a558ae
DH		 668static int wiimote_accel_open(struct input_dev *dev)
669{
670 struct wiimote_data *wdata = input_get_drvdata(dev);
98a558ae
DH		 671 unsigned long flags;
672
98a558ae
DH		 673 spin_lock_irqsave(&wdata->state.lock, flags);
674 wiiproto_req_accel(wdata, true);
675 spin_unlock_irqrestore(&wdata->state.lock, flags);
676
677 return 0;
678}
679
680static void wiimote_accel_close(struct input_dev *dev)
681{
682 struct wiimote_data *wdata = input_get_drvdata(dev);
683 unsigned long flags;
684
685 spin_lock_irqsave(&wdata->state.lock, flags);
686 wiiproto_req_accel(wdata, false);
687 spin_unlock_irqrestore(&wdata->state.lock, flags);
98a558ae
DH		 688}
689
0370d7cb
DH		 690static int wiimote_ir_open(struct input_dev *dev)
691{
692 struct wiimote_data *wdata = input_get_drvdata(dev);
0370d7cb 693
5682b1a8 694 return wiimote_init_ir(wdata, WIIPROTO_FLAG_IR_BASIC);
0370d7cb
DH		 695}
696
697static void wiimote_ir_close(struct input_dev *dev)
698{
699 struct wiimote_data *wdata = input_get_drvdata(dev);
700
701 wiimote_init_ir(wdata, 0);
0370d7cb
DH		 702}
703
c57ff761
DH		 704/* device (re-)initialization and detection */
705
706static const char *wiimote_devtype_names[WIIMOTE_DEV_NUM] = {
707 [WIIMOTE_DEV_PENDING] = "Pending",
708 [WIIMOTE_DEV_UNKNOWN] = "Unknown",
709 [WIIMOTE_DEV_GENERIC] = "Generic",
710 [WIIMOTE_DEV_GEN10] = "Nintendo Wii Remote (Gen 1)",
711 [WIIMOTE_DEV_GEN20] = "Nintendo Wii Remote Plus (Gen 2)",
712};
713
714/* Try to guess the device type based on all collected information. We
715 * first try to detect by static extension types, then VID/PID and the
716 * device name. If we cannot detect the device, we use
717 * WIIMOTE_DEV_GENERIC so all modules will get probed on the device. */
718static void wiimote_init_set_type(struct wiimote_data *wdata,
719 __u8 exttype)
720{
721 __u8 devtype = WIIMOTE_DEV_GENERIC;
722 __u16 vendor, product;
723 const char *name;
724
725 vendor = wdata->hdev->vendor;
726 product = wdata->hdev->product;
727 name = wdata->hdev->name;
728
729 if (!strcmp(name, "Nintendo RVL-CNT-01")) {
730 devtype = WIIMOTE_DEV_GEN10;
731 goto done;
732 } else if (!strcmp(name, "Nintendo RVL-CNT-01-TR")) {
733 devtype = WIIMOTE_DEV_GEN20;
734 goto done;
735 }
736
737 if (vendor == USB_VENDOR_ID_NINTENDO) {
738 if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE) {
739 devtype = WIIMOTE_DEV_GEN10;
740 goto done;
741 } else if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE2) {
742 devtype = WIIMOTE_DEV_GEN20;
743 goto done;
744 }
745 }
746
747done:
748 if (devtype == WIIMOTE_DEV_GENERIC)
749 hid_info(wdata->hdev, "cannot detect device; NAME: %s VID: %04x PID: %04x EXT: %04x\n",
750 name, vendor, product, exttype);
751 else
752 hid_info(wdata->hdev, "detected device: %s\n",
753 wiimote_devtype_names[devtype]);
754
755 spin_lock_irq(&wdata->state.lock);
756 wdata->state.devtype = devtype;
757 spin_unlock_irq(&wdata->state.lock);
758}
759
760static void wiimote_init_detect(struct wiimote_data *wdata)
761{
762 __u8 exttype = WIIMOTE_EXT_NONE;
763 bool ext;
764 int ret;
765
766 wiimote_cmd_acquire_noint(wdata);
767
768 spin_lock_irq(&wdata->state.lock);
769 wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
770 wiiproto_req_status(wdata);
771 spin_unlock_irq(&wdata->state.lock);
772
773 ret = wiimote_cmd_wait_noint(wdata);
774 if (ret)
775 goto out_release;
776
777 spin_lock_irq(&wdata->state.lock);
778 ext = wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED;
779 spin_unlock_irq(&wdata->state.lock);
780
781 if (!ext)
782 goto out_release;
783
784 wiimote_cmd_init_ext(wdata);
785 exttype = wiimote_cmd_read_ext(wdata);
786
787out_release:
788 wiimote_cmd_release(wdata);
789 wiimote_init_set_type(wdata, exttype);
790}
791
792static void wiimote_init_worker(struct work_struct *work)
793{
794 struct wiimote_data *wdata = container_of(work, struct wiimote_data,
795 init_worker);
796
797 if (wdata->state.devtype == WIIMOTE_DEV_PENDING)
798 wiimote_init_detect(wdata);
799}
800
801/* protocol handlers */
802
1abb9ad3
DH		 803static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
804{
805 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_LEFT],
806 !!(payload[0] & 0x01));
807 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_RIGHT],
808 !!(payload[0] & 0x02));
809 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_DOWN],
810 !!(payload[0] & 0x04));
811 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_UP],
812 !!(payload[0] & 0x08));
813 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_PLUS],
814 !!(payload[0] & 0x10));
815 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_TWO],
816 !!(payload[1] & 0x01));
817 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_ONE],
818 !!(payload[1] & 0x02));
819 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_B],
820 !!(payload[1] & 0x04));
821 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_A],
822 !!(payload[1] & 0x08));
823 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_MINUS],
824 !!(payload[1] & 0x10));
825 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_HOME],
826 !!(payload[1] & 0x80));
827 input_sync(wdata->input);
828}
829
efcf9188
DH		 830static void handler_accel(struct wiimote_data *wdata, const __u8 *payload)
831{
832 __u16 x, y, z;
833
834 if (!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
835 return;
836
837 /*
838 * payload is: BB BB XX YY ZZ
839 * Accelerometer data is encoded into 3 10bit values. XX, YY and ZZ
840 * contain the upper 8 bits of each value. The lower 2 bits are
841 * contained in the buttons data BB BB.
842 * Bits 6 and 7 of the first buttons byte BB is the lower 2 bits of the
843 * X accel value. Bit 5 of the second buttons byte is the 2nd bit of Y
844 * accel value and bit 6 is the second bit of the Z value.
845 * The first bit of Y and Z values is not available and always set to 0.
846 * 0x200 is returned on no movement.
847 */
848
849 x = payload[2] << 2;
850 y = payload[3] << 2;
851 z = payload[4] << 2;
852
853 x |= (payload[0] >> 5) & 0x3;
854 y |= (payload[1] >> 4) & 0x2;
855 z |= (payload[1] >> 5) & 0x2;
856
857 input_report_abs(wdata->accel, ABS_RX, x - 0x200);
858 input_report_abs(wdata->accel, ABS_RY, y - 0x200);
859 input_report_abs(wdata->accel, ABS_RZ, z - 0x200);
860 input_sync(wdata->accel);
861}
862
eac39e7e
DH		 863#define ir_to_input0(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
864 ABS_HAT0X, ABS_HAT0Y)
865#define ir_to_input1(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
866 ABS_HAT1X, ABS_HAT1Y)
867#define ir_to_input2(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
868 ABS_HAT2X, ABS_HAT2Y)
869#define ir_to_input3(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
870 ABS_HAT3X, ABS_HAT3Y)
871
872static void __ir_to_input(struct wiimote_data *wdata, const __u8 *ir,
873 bool packed, __u8 xid, __u8 yid)
874{
875 __u16 x, y;
876
877 if (!(wdata->state.flags & WIIPROTO_FLAGS_IR))
878 return;
879
880 /*
881 * Basic IR data is encoded into 3 bytes. The first two bytes are the
74b89e8a 882 * lower 8 bit of the X/Y data, the 3rd byte contains the upper 2 bits
eac39e7e
DH		 883 * of both.
884 * If data is packed, then the 3rd byte is put first and slightly
885 * reordered. This allows to interleave packed and non-packed data to
886 * have two IR sets in 5 bytes instead of 6.
887 * The resulting 10bit X/Y values are passed to the ABS_HATXY input dev.
888 */
889
890 if (packed) {
74b89e8a
DH		 891 x = ir[1] | ((ir[0] & 0x03) << 8);
892 y = ir[2] | ((ir[0] & 0x0c) << 6);
eac39e7e 893 } else {
74b89e8a
DH		 894 x = ir[0] | ((ir[2] & 0x30) << 4);
895 y = ir[1] | ((ir[2] & 0xc0) << 2);
eac39e7e
DH		 896 }
897
898 input_report_abs(wdata->ir, xid, x);
899 input_report_abs(wdata->ir, yid, y);
900}
efcf9188 901
2d44e3d2
DH		 902/* reduced status report with "BB BB" key data only */
903static void handler_status_K(struct wiimote_data *wdata,
904 const __u8 *payload)
c87019e4
DH		 905{
906 handler_keys(wdata, payload);
907
908 /* on status reports the drm is reset so we need to resend the drm */
909 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
2d44e3d2
DH		 910}
911
912/* extended status report with "BB BB LF 00 00 VV" data */
913static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
914{
915 handler_status_K(wdata, payload);
e3979a91 916
c57ff761
DH		 917 /* update extension status */
918 if (payload[2] & 0x02) {
919 wdata->state.flags |= WIIPROTO_FLAG_EXT_PLUGGED;
920 wiiext_event(wdata, true);
921 } else {
922 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED;
923 wiiext_event(wdata, false);
924 }
cb99221b 925
e3979a91
DH		 926 if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_SREQ, 0)) {
927 wdata->state.cmd_battery = payload[5];
928 wiimote_cmd_complete(wdata);
929 }
c87019e4
DH		 930}
931
2d44e3d2
DH		 932/* reduced generic report with "BB BB" key data only */
933static void handler_generic_K(struct wiimote_data *wdata, const __u8 *payload)
934{
935 handler_keys(wdata, payload);
936}
937
be1ecd62
DH		 938static void handler_data(struct wiimote_data *wdata, const __u8 *payload)
939{
fad8c0e3
DH		 940 __u16 offset = payload[3] << 8 | payload[4];
941 __u8 size = (payload[2] >> 4) + 1;
942 __u8 err = payload[2] & 0x0f;
943
be1ecd62 944 handler_keys(wdata, payload);
fad8c0e3
DH		 945
946 if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_RMEM, offset)) {
947 if (err)
948 size = 0;
949 else if (size > wdata->state.cmd_read_size)
950 size = wdata->state.cmd_read_size;
951
952 wdata->state.cmd_read_size = size;
953 if (wdata->state.cmd_read_buf)
954 memcpy(wdata->state.cmd_read_buf, &payload[5], size);
955 wiimote_cmd_complete(wdata);
956 }
be1ecd62
DH		 957}
958
c87019e4
DH		 959static void handler_return(struct wiimote_data *wdata, const __u8 *payload)
960{
961 __u8 err = payload[3];
962 __u8 cmd = payload[2];
963
964 handler_keys(wdata, payload);
965
33e84013
DH		 966 if (wiimote_cmd_pending(wdata, cmd, 0)) {
967 wdata->state.cmd_err = err;
968 wiimote_cmd_complete(wdata);
969 } else if (err) {
c87019e4
DH		 970 hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err,
971 cmd);
33e84013 972 }
c87019e4
DH		 973}
974
efcf9188
DH		 975static void handler_drm_KA(struct wiimote_data *wdata, const __u8 *payload)
976{
977 handler_keys(wdata, payload);
978 handler_accel(wdata, payload);
979}
980
7336b9f9
DH		 981static void handler_drm_KE(struct wiimote_data *wdata, const __u8 *payload)
982{
983 handler_keys(wdata, payload);
0b6815d7 984 wiiext_handle(wdata, &payload[2]);
7336b9f9
DH		 985}
986
efcf9188
DH		 987static void handler_drm_KAI(struct wiimote_data *wdata, const __u8 *payload)
988{
989 handler_keys(wdata, payload);
990 handler_accel(wdata, payload);
eac39e7e
DH		 991 ir_to_input0(wdata, &payload[5], false);
992 ir_to_input1(wdata, &payload[8], false);
993 ir_to_input2(wdata, &payload[11], false);
994 ir_to_input3(wdata, &payload[14], false);
995 input_sync(wdata->ir);
996}
997
7336b9f9
DH		 998static void handler_drm_KEE(struct wiimote_data *wdata, const __u8 *payload)
999{
1000 handler_keys(wdata, payload);
0b6815d7 1001 wiiext_handle(wdata, &payload[2]);
7336b9f9
DH		 1002}
1003
eac39e7e
DH		 1004static void handler_drm_KIE(struct wiimote_data *wdata, const __u8 *payload)
1005{
1006 handler_keys(wdata, payload);
1007 ir_to_input0(wdata, &payload[2], false);
1008 ir_to_input1(wdata, &payload[4], true);
1009 ir_to_input2(wdata, &payload[7], false);
1010 ir_to_input3(wdata, &payload[9], true);
1011 input_sync(wdata->ir);
0b6815d7 1012 wiiext_handle(wdata, &payload[12]);
efcf9188
DH		 1013}
1014
1015static void handler_drm_KAE(struct wiimote_data *wdata, const __u8 *payload)
1016{
1017 handler_keys(wdata, payload);
1018 handler_accel(wdata, payload);
0b6815d7 1019 wiiext_handle(wdata, &payload[5]);
efcf9188
DH		 1020}
1021
1022static void handler_drm_KAIE(struct wiimote_data *wdata, const __u8 *payload)
1023{
1024 handler_keys(wdata, payload);
1025 handler_accel(wdata, payload);
eac39e7e
DH		 1026 ir_to_input0(wdata, &payload[5], false);
1027 ir_to_input1(wdata, &payload[7], true);
1028 ir_to_input2(wdata, &payload[10], false);
1029 ir_to_input3(wdata, &payload[12], true);
1030 input_sync(wdata->ir);
0b6815d7 1031 wiiext_handle(wdata, &payload[15]);
efcf9188
DH		 1032}
1033
7336b9f9
DH		 1034static void handler_drm_E(struct wiimote_data *wdata, const __u8 *payload)
1035{
0b6815d7 1036 wiiext_handle(wdata, payload);
7336b9f9
DH		 1037}
1038
efcf9188
DH		 1039static void handler_drm_SKAI1(struct wiimote_data *wdata, const __u8 *payload)
1040{
1041 handler_keys(wdata, payload);
1042
1043 wdata->state.accel_split[0] = payload[2];
1044 wdata->state.accel_split[1] = (payload[0] >> 1) & (0x10 | 0x20);
1045 wdata->state.accel_split[1] |= (payload[1] << 1) & (0x40 | 0x80);
eac39e7e
DH		 1046
1047 ir_to_input0(wdata, &payload[3], false);
1048 ir_to_input1(wdata, &payload[12], false);
1049 input_sync(wdata->ir);
efcf9188
DH		 1050}
1051
1052static void handler_drm_SKAI2(struct wiimote_data *wdata, const __u8 *payload)
1053{
1054 __u8 buf[5];
1055
1056 handler_keys(wdata, payload);
1057
1058 wdata->state.accel_split[1] |= (payload[0] >> 5) & (0x01 | 0x02);
1059 wdata->state.accel_split[1] |= (payload[1] >> 3) & (0x04 | 0x08);
1060
1061 buf[0] = 0;
1062 buf[1] = 0;
1063 buf[2] = wdata->state.accel_split[0];
1064 buf[3] = payload[2];
1065 buf[4] = wdata->state.accel_split[1];
1066 handler_accel(wdata, buf);
eac39e7e
DH		 1067
1068 ir_to_input2(wdata, &payload[3], false);
1069 ir_to_input3(wdata, &payload[12], false);
1070 input_sync(wdata->ir);
efcf9188
DH		 1071}
1072
a4d19197
DH		 1073struct wiiproto_handler {
1074 __u8 id;
1075 size_t size;
1076 void (*func)(struct wiimote_data *wdata, const __u8 *payload);
1077};
1078
1079static struct wiiproto_handler handlers[] = {
c87019e4 1080 { .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
2d44e3d2 1081 { .id = WIIPROTO_REQ_STATUS, .size = 2, .func = handler_status_K },
be1ecd62 1082 { .id = WIIPROTO_REQ_DATA, .size = 21, .func = handler_data },
2d44e3d2 1083 { .id = WIIPROTO_REQ_DATA, .size = 2, .func = handler_generic_K },
c87019e4 1084 { .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
2d44e3d2 1085 { .id = WIIPROTO_REQ_RETURN, .size = 2, .func = handler_generic_K },
1abb9ad3 1086 { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
efcf9188 1087 { .id = WIIPROTO_REQ_DRM_KA, .size = 5, .func = handler_drm_KA },
2d44e3d2 1088 { .id = WIIPROTO_REQ_DRM_KA, .size = 2, .func = handler_generic_K },
7336b9f9 1089 { .id = WIIPROTO_REQ_DRM_KE, .size = 10, .func = handler_drm_KE },
2d44e3d2 1090 { .id = WIIPROTO_REQ_DRM_KE, .size = 2, .func = handler_generic_K },
efcf9188 1091 { .id = WIIPROTO_REQ_DRM_KAI, .size = 17, .func = handler_drm_KAI },
2d44e3d2 1092 { .id = WIIPROTO_REQ_DRM_KAI, .size = 2, .func = handler_generic_K },
7336b9f9 1093 { .id = WIIPROTO_REQ_DRM_KEE, .size = 21, .func = handler_drm_KEE },
2d44e3d2 1094 { .id = WIIPROTO_REQ_DRM_KEE, .size = 2, .func = handler_generic_K },
efcf9188 1095 { .id = WIIPROTO_REQ_DRM_KAE, .size = 21, .func = handler_drm_KAE },
2d44e3d2 1096 { .id = WIIPROTO_REQ_DRM_KAE, .size = 2, .func = handler_generic_K },
eac39e7e 1097 { .id = WIIPROTO_REQ_DRM_KIE, .size = 21, .func = handler_drm_KIE },
2d44e3d2 1098 { .id = WIIPROTO_REQ_DRM_KIE, .size = 2, .func = handler_generic_K },
efcf9188 1099 { .id = WIIPROTO_REQ_DRM_KAIE, .size = 21, .func = handler_drm_KAIE },
2d44e3d2 1100 { .id = WIIPROTO_REQ_DRM_KAIE, .size = 2, .func = handler_generic_K },
7336b9f9 1101 { .id = WIIPROTO_REQ_DRM_E, .size = 21, .func = handler_drm_E },
efcf9188
DH		 1102 { .id = WIIPROTO_REQ_DRM_SKAI1, .size = 21, .func = handler_drm_SKAI1 },
1103 { .id = WIIPROTO_REQ_DRM_SKAI2, .size = 21, .func = handler_drm_SKAI2 },
a4d19197
DH		 1104 { .id = 0 }
1105};
1106
02fb72a0
DH		 1107static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
1108 u8 *raw_data, int size)
1109{
4d36e975 1110 struct wiimote_data *wdata = hid_get_drvdata(hdev);
a4d19197
DH		 1111 struct wiiproto_handler *h;
1112 int i;
32a0d9a5 1113 unsigned long flags;
4d36e975 1114
02fb72a0
DH		 1115 if (size < 1)
1116 return -EINVAL;
1117
32a0d9a5
DH		 1118 spin_lock_irqsave(&wdata->state.lock, flags);
1119
a4d19197
DH		 1120 for (i = 0; handlers[i].id; ++i) {
1121 h = &handlers[i];
7336b9f9 1122 if (h->id == raw_data[0] && h->size < size) {
a4d19197 1123 h->func(wdata, &raw_data[1]);
2d44e3d2 1124 break;
7336b9f9 1125 }
a4d19197
DH		 1126 }
1127
2d44e3d2 1128 if (!handlers[i].id)
7336b9f9
DH		 1129 hid_warn(hdev, "Unhandled report %hhu size %d\n", raw_data[0],
1130 size);
1131
32a0d9a5
DH		 1132 spin_unlock_irqrestore(&wdata->state.lock, flags);
1133
02fb72a0
DH		 1134 return 0;
1135}
1136
23a5a4a3
DH		 1137static void wiimote_leds_destroy(struct wiimote_data *wdata)
1138{
1139 int i;
1140 struct led_classdev *led;
1141
1142 for (i = 0; i < 4; ++i) {
1143 if (wdata->leds[i]) {
1144 led = wdata->leds[i];
1145 wdata->leds[i] = NULL;
1146 led_classdev_unregister(led);
1147 kfree(led);
1148 }
1149 }
1150}
1151
1152static int wiimote_leds_create(struct wiimote_data *wdata)
1153{
1154 int i, ret;
1155 struct device *dev = &wdata->hdev->dev;
1156 size_t namesz = strlen(dev_name(dev)) + 9;
1157 struct led_classdev *led;
1158 char *name;
1159
1160 for (i = 0; i < 4; ++i) {
1161 led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
1162 if (!led) {
1163 ret = -ENOMEM;
1164 goto err;
1165 }
1166 name = (void*)&led[1];
1167 snprintf(name, namesz, "%s:blue:p%d", dev_name(dev), i);
1168 led->name = name;
1169 led->brightness = 0;
1170 led->max_brightness = 1;
1171 led->brightness_get = wiimote_leds_get;
1172 led->brightness_set = wiimote_leds_set;
1173
1174 ret = led_classdev_register(dev, led);
1175 if (ret) {
1176 kfree(led);
1177 goto err;
1178 }
1179 wdata->leds[i] = led;
1180 }
1181
1182 return 0;
1183
1184err:
1185 wiimote_leds_destroy(wdata);
1186 return ret;
1187}
1188
e894d0e3
DH		 1189static struct wiimote_data *wiimote_create(struct hid_device *hdev)
1190{
1191 struct wiimote_data *wdata;
1abb9ad3 1192 int i;
e894d0e3
DH		 1193
1194 wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
1195 if (!wdata)
1196 return NULL;
1197
672bc4e0 1198 wdata->input = input_allocate_device();
98a558ae
DH		 1199 if (!wdata->input)
1200 goto err;
672bc4e0 1201
e894d0e3
DH		 1202 wdata->hdev = hdev;
1203 hid_set_drvdata(hdev, wdata);
1204
672bc4e0 1205 input_set_drvdata(wdata->input, wdata);
672bc4e0
DH		 1206 wdata->input->dev.parent = &wdata->hdev->dev;
1207 wdata->input->id.bustype = wdata->hdev->bus;
1208 wdata->input->id.vendor = wdata->hdev->vendor;
1209 wdata->input->id.product = wdata->hdev->product;
1210 wdata->input->id.version = wdata->hdev->version;
1211 wdata->input->name = WIIMOTE_NAME;
1212
1abb9ad3
DH		 1213 set_bit(EV_KEY, wdata->input->evbit);
1214 for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
1215 set_bit(wiiproto_keymap[i], wdata->input->keybit);
1216
d020be92 1217 set_bit(FF_RUMBLE, wdata->input->ffbit);
98a558ae
DH		 1218 if (input_ff_create_memless(wdata->input, NULL, wiimote_ff_play))
1219 goto err_input;
1220
1221 wdata->accel = input_allocate_device();
1222 if (!wdata->accel)
1223 goto err_input;
1224
1225 input_set_drvdata(wdata->accel, wdata);
1226 wdata->accel->open = wiimote_accel_open;
1227 wdata->accel->close = wiimote_accel_close;
1228 wdata->accel->dev.parent = &wdata->hdev->dev;
1229 wdata->accel->id.bustype = wdata->hdev->bus;
1230 wdata->accel->id.vendor = wdata->hdev->vendor;
1231 wdata->accel->id.product = wdata->hdev->product;
1232 wdata->accel->id.version = wdata->hdev->version;
1233 wdata->accel->name = WIIMOTE_NAME " Accelerometer";
1234
1235 set_bit(EV_ABS, wdata->accel->evbit);
1236 set_bit(ABS_RX, wdata->accel->absbit);
1237 set_bit(ABS_RY, wdata->accel->absbit);
1238 set_bit(ABS_RZ, wdata->accel->absbit);
1239 input_set_abs_params(wdata->accel, ABS_RX, -500, 500, 2, 4);
1240 input_set_abs_params(wdata->accel, ABS_RY, -500, 500, 2, 4);
1241 input_set_abs_params(wdata->accel, ABS_RZ, -500, 500, 2, 4);
d020be92 1242
f363e4f6
DH		 1243 wdata->ir = input_allocate_device();
1244 if (!wdata->ir)
1245 goto err_ir;
1246
1247 input_set_drvdata(wdata->ir, wdata);
0370d7cb
DH		 1248 wdata->ir->open = wiimote_ir_open;
1249 wdata->ir->close = wiimote_ir_close;
f363e4f6
DH		 1250 wdata->ir->dev.parent = &wdata->hdev->dev;
1251 wdata->ir->id.bustype = wdata->hdev->bus;
1252 wdata->ir->id.vendor = wdata->hdev->vendor;
1253 wdata->ir->id.product = wdata->hdev->product;
1254 wdata->ir->id.version = wdata->hdev->version;
1255 wdata->ir->name = WIIMOTE_NAME " IR";
1256
1257 set_bit(EV_ABS, wdata->ir->evbit);
1258 set_bit(ABS_HAT0X, wdata->ir->absbit);
1259 set_bit(ABS_HAT0Y, wdata->ir->absbit);
1260 set_bit(ABS_HAT1X, wdata->ir->absbit);
1261 set_bit(ABS_HAT1Y, wdata->ir->absbit);
1262 set_bit(ABS_HAT2X, wdata->ir->absbit);
1263 set_bit(ABS_HAT2Y, wdata->ir->absbit);
1264 set_bit(ABS_HAT3X, wdata->ir->absbit);
1265 set_bit(ABS_HAT3Y, wdata->ir->absbit);
1266 input_set_abs_params(wdata->ir, ABS_HAT0X, 0, 1023, 2, 4);
1267 input_set_abs_params(wdata->ir, ABS_HAT0Y, 0, 767, 2, 4);
1268 input_set_abs_params(wdata->ir, ABS_HAT1X, 0, 1023, 2, 4);
1269 input_set_abs_params(wdata->ir, ABS_HAT1Y, 0, 767, 2, 4);
1270 input_set_abs_params(wdata->ir, ABS_HAT2X, 0, 1023, 2, 4);
1271 input_set_abs_params(wdata->ir, ABS_HAT2Y, 0, 767, 2, 4);
1272 input_set_abs_params(wdata->ir, ABS_HAT3X, 0, 1023, 2, 4);
1273 input_set_abs_params(wdata->ir, ABS_HAT3Y, 0, 767, 2, 4);
1274
13938538
DH		 1275 spin_lock_init(&wdata->queue.lock);
1276 INIT_WORK(&wdata->queue.worker, wiimote_queue_worker);
23c063cb 1277
32a0d9a5 1278 spin_lock_init(&wdata->state.lock);
29d28064
DH		 1279 init_completion(&wdata->state.ready);
1280 mutex_init(&wdata->state.sync);
43d782ae 1281 wdata->state.drm = WIIPROTO_REQ_DRM_K;
32a0d9a5 1282
c57ff761
DH		 1283 INIT_WORK(&wdata->init_worker, wiimote_init_worker);
1284
e894d0e3 1285 return wdata;
98a558ae 1286
f363e4f6
DH		 1287err_ir:
1288 input_free_device(wdata->accel);
98a558ae
DH		 1289err_input:
1290 input_free_device(wdata->input);
1291err:
1292 kfree(wdata);
1293 return NULL;
e894d0e3
DH		 1294}
1295
1296static void wiimote_destroy(struct wiimote_data *wdata)
1297{
43e5e7c6 1298 wiidebug_deinit(wdata);
cb99221b 1299 wiiext_deinit(wdata);
23a5a4a3 1300 wiimote_leds_destroy(wdata);
3989ef6c 1301
6591d758 1302 power_supply_unregister(&wdata->battery);
001dac87 1303 kfree(wdata->battery.name);
98a558ae 1304 input_unregister_device(wdata->accel);
f363e4f6 1305 input_unregister_device(wdata->ir);
3989ef6c 1306 input_unregister_device(wdata->input);
c57ff761 1307 cancel_work_sync(&wdata->init_worker);
13938538 1308 cancel_work_sync(&wdata->queue.worker);
5682b1a8 1309 hid_hw_close(wdata->hdev);
3989ef6c
DH		 1310 hid_hw_stop(wdata->hdev);
1311
e894d0e3
DH		 1312 kfree(wdata);
1313}
1314
02fb72a0
DH		 1315static int wiimote_hid_probe(struct hid_device *hdev,
1316 const struct hid_device_id *id)
fb51b443 1317{
e894d0e3 1318 struct wiimote_data *wdata;
02fb72a0
DH		 1319 int ret;
1320
90120d66
DH		 1321 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
1322
e894d0e3
DH		 1323 wdata = wiimote_create(hdev);
1324 if (!wdata) {
1325 hid_err(hdev, "Can't alloc device\n");
1326 return -ENOMEM;
1327 }
1328
02fb72a0
DH		 1329 ret = hid_parse(hdev);
1330 if (ret) {
1331 hid_err(hdev, "HID parse failed\n");
e894d0e3 1332 goto err;
02fb72a0
DH		 1333 }
1334
1335 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1336 if (ret) {
1337 hid_err(hdev, "HW start failed\n");
e894d0e3 1338 goto err;
02fb72a0
DH		 1339 }
1340
5682b1a8
DH		 1341 ret = hid_hw_open(hdev);
1342 if (ret) {
1343 hid_err(hdev, "cannot start hardware I/O\n");
1344 goto err_stop;
1345 }
1346
98a558ae 1347 ret = input_register_device(wdata->accel);
672bc4e0
DH		 1348 if (ret) {
1349 hid_err(hdev, "Cannot register input device\n");
5682b1a8 1350 goto err_close;
672bc4e0
DH		 1351 }
1352
f363e4f6
DH		 1353 ret = input_register_device(wdata->ir);
1354 if (ret) {
1355 hid_err(hdev, "Cannot register input device\n");
1356 goto err_ir;
1357 }
1358
98a558ae
DH		 1359 ret = input_register_device(wdata->input);
1360 if (ret) {
1361 hid_err(hdev, "Cannot register input device\n");
1362 goto err_input;
1363 }
1364
6591d758
DH		 1365 wdata->battery.properties = wiimote_battery_props;
1366 wdata->battery.num_properties = ARRAY_SIZE(wiimote_battery_props);
1367 wdata->battery.get_property = wiimote_battery_get_property;
6591d758
DH		 1368 wdata->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1369 wdata->battery.use_for_apm = 0;
001dac87
DH		 1370 wdata->battery.name = kasprintf(GFP_KERNEL, "wiimote_battery_%s",
1371 wdata->hdev->uniq);
1372 if (!wdata->battery.name) {
1373 ret = -ENOMEM;
1374 goto err_battery_name;
1375 }
6591d758
DH		 1376
1377 ret = power_supply_register(&wdata->hdev->dev, &wdata->battery);
1378 if (ret) {
1379 hid_err(hdev, "Cannot register battery device\n");
1380 goto err_battery;
1381 }
1382
217c8b2b
JK		 1383 power_supply_powers(&wdata->battery, &hdev->dev);
1384
23a5a4a3 1385 ret = wiimote_leds_create(wdata);
3989ef6c
DH		 1386 if (ret)
1387 goto err_free;
1388
cb99221b
DH		 1389 ret = wiiext_init(wdata);
1390 if (ret)
1391 goto err_free;
1392
43e5e7c6
DH		 1393 ret = wiidebug_init(wdata);
1394 if (ret)
1395 goto err_free;
1396
02fb72a0 1397 hid_info(hdev, "New device registered\n");
32a0d9a5
DH		 1398
1399 /* by default set led1 after device initialization */
1400 spin_lock_irq(&wdata->state.lock);
db308346 1401 wiiproto_req_leds(wdata, WIIPROTO_FLAG_LED1);
32a0d9a5
DH		 1402 spin_unlock_irq(&wdata->state.lock);
1403
c57ff761
DH		 1404 /* schedule device detection */
1405 schedule_work(&wdata->init_worker);
1406
fb51b443 1407 return 0;
e894d0e3 1408
3989ef6c
DH		 1409err_free:
1410 wiimote_destroy(wdata);
1411 return ret;
1412
6591d758 1413err_battery:
001dac87
DH		 1414 kfree(wdata->battery.name);
1415err_battery_name:
6591d758
DH		 1416 input_unregister_device(wdata->input);
1417 wdata->input = NULL;
98a558ae 1418err_input:
f363e4f6
DH		 1419 input_unregister_device(wdata->ir);
1420 wdata->ir = NULL;
1421err_ir:
98a558ae
DH		 1422 input_unregister_device(wdata->accel);
1423 wdata->accel = NULL;
5682b1a8
DH		 1424err_close:
1425 hid_hw_close(hdev);
672bc4e0
DH		 1426err_stop:
1427 hid_hw_stop(hdev);
e894d0e3 1428err:
f363e4f6 1429 input_free_device(wdata->ir);
98a558ae 1430 input_free_device(wdata->accel);
672bc4e0 1431 input_free_device(wdata->input);
3989ef6c 1432 kfree(wdata);
e894d0e3 1433 return ret;
fb51b443
DH		 1434}
1435
02fb72a0
DH		 1436static void wiimote_hid_remove(struct hid_device *hdev)
1437{
e894d0e3
DH		 1438 struct wiimote_data *wdata = hid_get_drvdata(hdev);
1439
02fb72a0 1440 hid_info(hdev, "Device removed\n");
e894d0e3 1441 wiimote_destroy(wdata);
02fb72a0
DH		 1442}
1443
1444static const struct hid_device_id wiimote_hid_devices[] = {
1445 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
1446 USB_DEVICE_ID_NINTENDO_WIIMOTE) },
a33042fa
DH		 1447 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
1448 USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
02fb72a0
DH		 1449 { }
1450};
1451MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
1452
1453static struct hid_driver wiimote_hid_driver = {
1454 .name = "wiimote",
1455 .id_table = wiimote_hid_devices,
1456 .probe = wiimote_hid_probe,
1457 .remove = wiimote_hid_remove,
1458 .raw_event = wiimote_hid_event,
1459};
f425458e 1460module_hid_driver(wiimote_hid_driver);
02fb72a0 1461
fb51b443
DH		 1462MODULE_LICENSE("GPL");
1463MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
92eda7e4 1464MODULE_DESCRIPTION("Driver for Nintendo Wii / Wii U peripherals");
Linux kernel - Deliverables
This page took 0.214569 seconds and 5 git commands to generate.