?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target...
[linux-btrfs-devel.git] / drivers / hid / hid-wiimote.c
blob85a02e5f9fe873e5097a55861ec55c77f50ee05f
1 /*
2 * HID driver for Nintendo Wiimote devices
3 * Copyright (c) 2011 David Herrmann
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
13 #include <linux/device.h>
14 #include <linux/hid.h>
15 #include <linux/input.h>
16 #include <linux/leds.h>
17 #include <linux/module.h>
18 #include <linux/spinlock.h>
19 #include "hid-ids.h"
20
21 #define WIIMOTE_VERSION "0.1"
22 #define WIIMOTE_NAME "Nintendo Wii Remote"
23 #define WIIMOTE_BUFSIZE 32
24
25 struct wiimote_buf {
26 __u8 data[HID_MAX_BUFFER_SIZE];
27 size_t size;
28 };
29
30 struct wiimote_state {
31 spinlock_t lock;
32 __u8 flags;
33 };
34
35 struct wiimote_data {
36 struct hid_device *hdev;
37 struct input_dev *input;
38 struct led_classdev *leds[4];
39
40 spinlock_t qlock;
41 __u8 head;
42 __u8 tail;
43 struct wiimote_buf outq[WIIMOTE_BUFSIZE];
44 struct work_struct worker;
45
46 struct wiimote_state state;
47 };
48
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)
55
56 /* return flag for led \num */
57 #define WIIPROTO_FLAG_LED(num) (WIIPROTO_FLAG_LED1 << (num - 1))
58
59 enum wiiproto_reqs {
60 WIIPROTO_REQ_NULL = 0x0,
61 WIIPROTO_REQ_LED = 0x11,
62 WIIPROTO_REQ_DRM = 0x12,
63 WIIPROTO_REQ_STATUS = 0x20,
64 WIIPROTO_REQ_RETURN = 0x22,
65 WIIPROTO_REQ_DRM_K = 0x30,
66 };
67
68 enum wiiproto_keys {
69 WIIPROTO_KEY_LEFT,
70 WIIPROTO_KEY_RIGHT,
71 WIIPROTO_KEY_UP,
72 WIIPROTO_KEY_DOWN,
73 WIIPROTO_KEY_PLUS,
74 WIIPROTO_KEY_MINUS,
75 WIIPROTO_KEY_ONE,
76 WIIPROTO_KEY_TWO,
77 WIIPROTO_KEY_A,
78 WIIPROTO_KEY_B,
79 WIIPROTO_KEY_HOME,
80 WIIPROTO_KEY_COUNT
81 };
82
83 static __u16 wiiproto_keymap[] = {
84 KEY_LEFT, /* WIIPROTO_KEY_LEFT */
85 KEY_RIGHT, /* WIIPROTO_KEY_RIGHT */
86 KEY_UP, /* WIIPROTO_KEY_UP */
87 KEY_DOWN, /* WIIPROTO_KEY_DOWN */
88 KEY_NEXT, /* WIIPROTO_KEY_PLUS */
89 KEY_PREVIOUS, /* WIIPROTO_KEY_MINUS */
90 BTN_1, /* WIIPROTO_KEY_ONE */
91 BTN_2, /* WIIPROTO_KEY_TWO */
92 BTN_A, /* WIIPROTO_KEY_A */
93 BTN_B, /* WIIPROTO_KEY_B */
94 BTN_MODE, /* WIIPROTO_KEY_HOME */
95 };
96
97 static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
98 size_t count)
99 {
100 __u8 *buf;
101 ssize_t ret;
102
103 if (!hdev->hid_output_raw_report)
104 return -ENODEV;
105
106 buf = kmemdup(buffer, count, GFP_KERNEL);
107 if (!buf)
108 return -ENOMEM;
109
110 ret = hdev->hid_output_raw_report(hdev, buf, count, HID_OUTPUT_REPORT);
111
112 kfree(buf);
113 return ret;
114 }
115
116 static void wiimote_worker(struct work_struct *work)
117 {
118 struct wiimote_data *wdata = container_of(work, struct wiimote_data,
119 worker);
120 unsigned long flags;
121
122 spin_lock_irqsave(&wdata->qlock, flags);
123
124 while (wdata->head != wdata->tail) {
125 spin_unlock_irqrestore(&wdata->qlock, flags);
126 wiimote_hid_send(wdata->hdev, wdata->outq[wdata->tail].data,
127 wdata->outq[wdata->tail].size);
128 spin_lock_irqsave(&wdata->qlock, flags);
129
130 wdata->tail = (wdata->tail + 1) % WIIMOTE_BUFSIZE;
131 }
132
133 spin_unlock_irqrestore(&wdata->qlock, flags);
134 }
135
136 static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
137 size_t count)
138 {
139 unsigned long flags;
140 __u8 newhead;
141
142 if (count > HID_MAX_BUFFER_SIZE) {
143 hid_warn(wdata->hdev, "Sending too large output report\n");
144 return;
145 }
146
147 /*
148 * Copy new request into our output queue and check whether the
149 * queue is full. If it is full, discard this request.
150 * If it is empty we need to start a new worker that will
151 * send out the buffer to the hid device.
152 * If the queue is not empty, then there must be a worker
153 * that is currently sending out our buffer and this worker
154 * will reschedule itself until the queue is empty.
155 */
156
157 spin_lock_irqsave(&wdata->qlock, flags);
158
159 memcpy(wdata->outq[wdata->head].data, buffer, count);
160 wdata->outq[wdata->head].size = count;
161 newhead = (wdata->head + 1) % WIIMOTE_BUFSIZE;
162
163 if (wdata->head == wdata->tail) {
164 wdata->head = newhead;
165 schedule_work(&wdata->worker);
166 } else if (newhead != wdata->tail) {
167 wdata->head = newhead;
168 } else {
169 hid_warn(wdata->hdev, "Output queue is full");
170 }
171
172 spin_unlock_irqrestore(&wdata->qlock, flags);
173 }
174
175 static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
176 {
177 __u8 cmd[2];
178
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
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
196 wiimote_queue(wdata, cmd, sizeof(cmd));
197 }
198
199 /*
200 * Check what peripherals of the wiimote are currently
201 * active and select a proper DRM that supports all of
202 * the requested data inputs.
203 */
204 static __u8 select_drm(struct wiimote_data *wdata)
205 {
206 return WIIPROTO_REQ_DRM_K;
207 }
208
209 static void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
210 {
211 __u8 cmd[3];
212
213 if (drm == WIIPROTO_REQ_NULL)
214 drm = select_drm(wdata);
215
216 cmd[0] = WIIPROTO_REQ_DRM;
217 cmd[1] = 0;
218 cmd[2] = drm;
219
220 wiimote_queue(wdata, cmd, sizeof(cmd));
221 }
222
223 static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
224 {
225 struct wiimote_data *wdata;
226 struct device *dev = led_dev->dev->parent;
227 int i;
228 unsigned long flags;
229 bool value = false;
230
231 wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
232
233 for (i = 0; i < 4; ++i) {
234 if (wdata->leds[i] == led_dev) {
235 spin_lock_irqsave(&wdata->state.lock, flags);
236 value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
237 spin_unlock_irqrestore(&wdata->state.lock, flags);
238 break;
239 }
240 }
241
242 return value ? LED_FULL : LED_OFF;
243 }
244
245 static void wiimote_leds_set(struct led_classdev *led_dev,
246 enum led_brightness value)
247 {
248 struct wiimote_data *wdata;
249 struct device *dev = led_dev->dev->parent;
250 int i;
251 unsigned long flags;
252 __u8 state, flag;
253
254 wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
255
256 for (i = 0; i < 4; ++i) {
257 if (wdata->leds[i] == led_dev) {
258 flag = WIIPROTO_FLAG_LED(i + 1);
259 spin_lock_irqsave(&wdata->state.lock, flags);
260 state = wdata->state.flags;
261 if (value == LED_OFF)
262 wiiproto_req_leds(wdata, state & ~flag);
263 else
264 wiiproto_req_leds(wdata, state | flag);
265 spin_unlock_irqrestore(&wdata->state.lock, flags);
266 break;
267 }
268 }
269 }
270
271 static int wiimote_input_event(struct input_dev *dev, unsigned int type,
272 unsigned int code, int value)
273 {
274 return 0;
275 }
276
277 static int wiimote_input_open(struct input_dev *dev)
278 {
279 struct wiimote_data *wdata = input_get_drvdata(dev);
280
281 return hid_hw_open(wdata->hdev);
282 }
283
284 static void wiimote_input_close(struct input_dev *dev)
285 {
286 struct wiimote_data *wdata = input_get_drvdata(dev);
287
288 hid_hw_close(wdata->hdev);
289 }
290
291 static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
292 {
293 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_LEFT],
294 !!(payload[0] & 0x01));
295 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_RIGHT],
296 !!(payload[0] & 0x02));
297 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_DOWN],
298 !!(payload[0] & 0x04));
299 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_UP],
300 !!(payload[0] & 0x08));
301 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_PLUS],
302 !!(payload[0] & 0x10));
303 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_TWO],
304 !!(payload[1] & 0x01));
305 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_ONE],
306 !!(payload[1] & 0x02));
307 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_B],
308 !!(payload[1] & 0x04));
309 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_A],
310 !!(payload[1] & 0x08));
311 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_MINUS],
312 !!(payload[1] & 0x10));
313 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_HOME],
314 !!(payload[1] & 0x80));
315 input_sync(wdata->input);
316 }
317
318 static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
319 {
320 handler_keys(wdata, payload);
321
322 /* on status reports the drm is reset so we need to resend the drm */
323 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
324 }
325
326 static void handler_return(struct wiimote_data *wdata, const __u8 *payload)
327 {
328 __u8 err = payload[3];
329 __u8 cmd = payload[2];
330
331 handler_keys(wdata, payload);
332
333 if (err)
334 hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err,
335 cmd);
336 }
337
338 struct wiiproto_handler {
339 __u8 id;
340 size_t size;
341 void (*func)(struct wiimote_data *wdata, const __u8 *payload);
342 };
343
344 static struct wiiproto_handler handlers[] = {
345 { .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
346 { .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
347 { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
348 { .id = 0 }
349 };
350
351 static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
352 u8 *raw_data, int size)
353 {
354 struct wiimote_data *wdata = hid_get_drvdata(hdev);
355 struct wiiproto_handler *h;
356 int i;
357 unsigned long flags;
358
359 if (size < 1)
360 return -EINVAL;
361
362 spin_lock_irqsave(&wdata->state.lock, flags);
363
364 for (i = 0; handlers[i].id; ++i) {
365 h = &handlers[i];
366 if (h->id == raw_data[0] && h->size < size)
367 h->func(wdata, &raw_data[1]);
368 }
369
370 spin_unlock_irqrestore(&wdata->state.lock, flags);
371
372 return 0;
373 }
374
375 static void wiimote_leds_destroy(struct wiimote_data *wdata)
376 {
377 int i;
378 struct led_classdev *led;
379
380 for (i = 0; i < 4; ++i) {
381 if (wdata->leds[i]) {
382 led = wdata->leds[i];
383 wdata->leds[i] = NULL;
384 led_classdev_unregister(led);
385 kfree(led);
386 }
387 }
388 }
389
390 static int wiimote_leds_create(struct wiimote_data *wdata)
391 {
392 int i, ret;
393 struct device *dev = &wdata->hdev->dev;
394 size_t namesz = strlen(dev_name(dev)) + 9;
395 struct led_classdev *led;
396 char *name;
397
398 for (i = 0; i < 4; ++i) {
399 led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
400 if (!led) {
401 ret = -ENOMEM;
402 goto err;
403 }
404 name = (void*)&led[1];
405 snprintf(name, namesz, "%s:blue:p%d", dev_name(dev), i);
406 led->name = name;
407 led->brightness = 0;
408 led->max_brightness = 1;
409 led->brightness_get = wiimote_leds_get;
410 led->brightness_set = wiimote_leds_set;
411
412 ret = led_classdev_register(dev, led);
413 if (ret) {
414 kfree(led);
415 goto err;
416 }
417 wdata->leds[i] = led;
418 }
419
420 return 0;
421
422 err:
423 wiimote_leds_destroy(wdata);
424 return ret;
425 }
426
427 static struct wiimote_data *wiimote_create(struct hid_device *hdev)
428 {
429 struct wiimote_data *wdata;
430 int i;
431
432 wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
433 if (!wdata)
434 return NULL;
435
436 wdata->input = input_allocate_device();
437 if (!wdata->input) {
438 kfree(wdata);
439 return NULL;
440 }
441
442 wdata->hdev = hdev;
443 hid_set_drvdata(hdev, wdata);
444
445 input_set_drvdata(wdata->input, wdata);
446 wdata->input->event = wiimote_input_event;
447 wdata->input->open = wiimote_input_open;
448 wdata->input->close = wiimote_input_close;
449 wdata->input->dev.parent = &wdata->hdev->dev;
450 wdata->input->id.bustype = wdata->hdev->bus;
451 wdata->input->id.vendor = wdata->hdev->vendor;
452 wdata->input->id.product = wdata->hdev->product;
453 wdata->input->id.version = wdata->hdev->version;
454 wdata->input->name = WIIMOTE_NAME;
455
456 set_bit(EV_KEY, wdata->input->evbit);
457 for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
458 set_bit(wiiproto_keymap[i], wdata->input->keybit);
459
460 spin_lock_init(&wdata->qlock);
461 INIT_WORK(&wdata->worker, wiimote_worker);
462
463 spin_lock_init(&wdata->state.lock);
464
465 return wdata;
466 }
467
468 static void wiimote_destroy(struct wiimote_data *wdata)
469 {
470 wiimote_leds_destroy(wdata);
471
472 input_unregister_device(wdata->input);
473 cancel_work_sync(&wdata->worker);
474 hid_hw_stop(wdata->hdev);
475
476 kfree(wdata);
477 }
478
479 static int wiimote_hid_probe(struct hid_device *hdev,
480 const struct hid_device_id *id)
481 {
482 struct wiimote_data *wdata;
483 int ret;
484
485 wdata = wiimote_create(hdev);
486 if (!wdata) {
487 hid_err(hdev, "Can't alloc device\n");
488 return -ENOMEM;
489 }
490
491 ret = hid_parse(hdev);
492 if (ret) {
493 hid_err(hdev, "HID parse failed\n");
494 goto err;
495 }
496
497 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
498 if (ret) {
499 hid_err(hdev, "HW start failed\n");
500 goto err;
501 }
502
503 ret = input_register_device(wdata->input);
504 if (ret) {
505 hid_err(hdev, "Cannot register input device\n");
506 goto err_stop;
507 }
508
509 ret = wiimote_leds_create(wdata);
510 if (ret)
511 goto err_free;
512
513 hid_info(hdev, "New device registered\n");
514
515 /* by default set led1 after device initialization */
516 spin_lock_irq(&wdata->state.lock);
517 wiiproto_req_leds(wdata, WIIPROTO_FLAG_LED1);
518 spin_unlock_irq(&wdata->state.lock);
519
520 return 0;
521
522 err_free:
523 wiimote_destroy(wdata);
524 return ret;
525
526 err_stop:
527 hid_hw_stop(hdev);
528 err:
529 input_free_device(wdata->input);
530 kfree(wdata);
531 return ret;
532 }
533
534 static void wiimote_hid_remove(struct hid_device *hdev)
535 {
536 struct wiimote_data *wdata = hid_get_drvdata(hdev);
537
538 hid_info(hdev, "Device removed\n");
539 wiimote_destroy(wdata);
540 }
541
542 static const struct hid_device_id wiimote_hid_devices[] = {
543 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
544 USB_DEVICE_ID_NINTENDO_WIIMOTE) },
545 { }
546 };
547 MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
548
549 static struct hid_driver wiimote_hid_driver = {
550 .name = "wiimote",
551 .id_table = wiimote_hid_devices,
552 .probe = wiimote_hid_probe,
553 .remove = wiimote_hid_remove,
554 .raw_event = wiimote_hid_event,
555 };
556
557 static int __init wiimote_init(void)
558 {
559 int ret;
560
561 ret = hid_register_driver(&wiimote_hid_driver);
562 if (ret)
563 pr_err("Can't register wiimote hid driver\n");
564
565 return ret;
566 }
567
568 static void __exit wiimote_exit(void)
569 {
570 hid_unregister_driver(&wiimote_hid_driver);
571 }
572
573 module_init(wiimote_init);
574 module_exit(wiimote_exit);
575 MODULE_LICENSE("GPL");
576 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
577 MODULE_DESCRIPTION(WIIMOTE_NAME " Device Driver");
578 MODULE_VERSION(WIIMOTE_VERSION);
Linux Btrfs Development