?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
HID: wiimote: Register led class devices
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / hid / hid-wiimote.c
blob29edd55d4bb0e47c5bbc7fca3312a9369e0e1b21
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_LED = 0x11,
61 WIIPROTO_REQ_DRM_K = 0x30,
62 };
63
64 enum wiiproto_keys {
65 WIIPROTO_KEY_LEFT,
66 WIIPROTO_KEY_RIGHT,
67 WIIPROTO_KEY_UP,
68 WIIPROTO_KEY_DOWN,
69 WIIPROTO_KEY_PLUS,
70 WIIPROTO_KEY_MINUS,
71 WIIPROTO_KEY_ONE,
72 WIIPROTO_KEY_TWO,
73 WIIPROTO_KEY_A,
74 WIIPROTO_KEY_B,
75 WIIPROTO_KEY_HOME,
76 WIIPROTO_KEY_COUNT
77 };
78
79 static __u16 wiiproto_keymap[] = {
80 KEY_LEFT, /* WIIPROTO_KEY_LEFT */
81 KEY_RIGHT, /* WIIPROTO_KEY_RIGHT */
82 KEY_UP, /* WIIPROTO_KEY_UP */
83 KEY_DOWN, /* WIIPROTO_KEY_DOWN */
84 KEY_NEXT, /* WIIPROTO_KEY_PLUS */
85 KEY_PREVIOUS, /* WIIPROTO_KEY_MINUS */
86 BTN_1, /* WIIPROTO_KEY_ONE */
87 BTN_2, /* WIIPROTO_KEY_TWO */
88 BTN_A, /* WIIPROTO_KEY_A */
89 BTN_B, /* WIIPROTO_KEY_B */
90 BTN_MODE, /* WIIPROTO_KEY_HOME */
91 };
92
93 static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
94 size_t count)
95 {
96 __u8 *buf;
97 ssize_t ret;
98
99 if (!hdev->hid_output_raw_report)
100 return -ENODEV;
101
102 buf = kmemdup(buffer, count, GFP_KERNEL);
103 if (!buf)
104 return -ENOMEM;
105
106 ret = hdev->hid_output_raw_report(hdev, buf, count, HID_OUTPUT_REPORT);
107
108 kfree(buf);
109 return ret;
110 }
111
112 static void wiimote_worker(struct work_struct *work)
113 {
114 struct wiimote_data *wdata = container_of(work, struct wiimote_data,
115 worker);
116 unsigned long flags;
117
118 spin_lock_irqsave(&wdata->qlock, flags);
119
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);
125
126 wdata->tail = (wdata->tail + 1) % WIIMOTE_BUFSIZE;
127 }
128
129 spin_unlock_irqrestore(&wdata->qlock, flags);
130 }
131
132 static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
133 size_t count)
134 {
135 unsigned long flags;
136 __u8 newhead;
137
138 if (count > HID_MAX_BUFFER_SIZE) {
139 hid_warn(wdata->hdev, "Sending too large output report\n");
140 return;
141 }
142
143 /*
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.
151 */
152
153 spin_lock_irqsave(&wdata->qlock, flags);
154
155 memcpy(wdata->outq[wdata->head].data, buffer, count);
156 wdata->outq[wdata->head].size = count;
157 newhead = (wdata->head + 1) % WIIMOTE_BUFSIZE;
158
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;
164 } else {
165 hid_warn(wdata->hdev, "Output queue is full");
166 }
167
168 spin_unlock_irqrestore(&wdata->qlock, flags);
169 }
170
171 static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
172 {
173 __u8 cmd[2];
174
175 leds &= WIIPROTO_FLAGS_LEDS;
176 if ((wdata->state.flags & WIIPROTO_FLAGS_LEDS) == leds)
177 return;
178 wdata->state.flags = (wdata->state.flags & ~WIIPROTO_FLAGS_LEDS) | leds;
179
180 cmd[0] = WIIPROTO_REQ_LED;
181 cmd[1] = 0;
182
183 if (leds & WIIPROTO_FLAG_LED1)
184 cmd[1] |= 0x10;
185 if (leds & WIIPROTO_FLAG_LED2)
186 cmd[1] |= 0x20;
187 if (leds & WIIPROTO_FLAG_LED3)
188 cmd[1] |= 0x40;
189 if (leds & WIIPROTO_FLAG_LED4)
190 cmd[1] |= 0x80;
191
192 wiimote_queue(wdata, cmd, sizeof(cmd));
193 }
194
195 static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
196 {
197 struct wiimote_data *wdata;
198 struct device *dev = led_dev->dev->parent;
199 int i;
200 unsigned long flags;
201 bool value = false;
202
203 wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
204
205 for (i = 0; i < 4; ++i) {
206 if (wdata->leds[i] == led_dev) {
207 spin_lock_irqsave(&wdata->state.lock, flags);
208 value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
209 spin_unlock_irqrestore(&wdata->state.lock, flags);
210 break;
211 }
212 }
213
214 return value ? LED_FULL : LED_OFF;
215 }
216
217 static void wiimote_leds_set(struct led_classdev *led_dev,
218 enum led_brightness value)
219 {
220 struct wiimote_data *wdata;
221 struct device *dev = led_dev->dev->parent;
222 int i;
223 unsigned long flags;
224 __u8 state, flag;
225
226 wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
227
228 for (i = 0; i < 4; ++i) {
229 if (wdata->leds[i] == led_dev) {
230 flag = WIIPROTO_FLAG_LED(i + 1);
231 spin_lock_irqsave(&wdata->state.lock, flags);
232 state = wdata->state.flags;
233 if (value == LED_OFF)
234 wiiproto_req_leds(wdata, state & ~flag);
235 else
236 wiiproto_req_leds(wdata, state | flag);
237 spin_unlock_irqrestore(&wdata->state.lock, flags);
238 break;
239 }
240 }
241 }
242
243 static int wiimote_input_event(struct input_dev *dev, unsigned int type,
244 unsigned int code, int value)
245 {
246 return 0;
247 }
248
249 static int wiimote_input_open(struct input_dev *dev)
250 {
251 struct wiimote_data *wdata = input_get_drvdata(dev);
252
253 return hid_hw_open(wdata->hdev);
254 }
255
256 static void wiimote_input_close(struct input_dev *dev)
257 {
258 struct wiimote_data *wdata = input_get_drvdata(dev);
259
260 hid_hw_close(wdata->hdev);
261 }
262
263 static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
264 {
265 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_LEFT],
266 !!(payload[0] & 0x01));
267 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_RIGHT],
268 !!(payload[0] & 0x02));
269 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_DOWN],
270 !!(payload[0] & 0x04));
271 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_UP],
272 !!(payload[0] & 0x08));
273 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_PLUS],
274 !!(payload[0] & 0x10));
275 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_TWO],
276 !!(payload[1] & 0x01));
277 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_ONE],
278 !!(payload[1] & 0x02));
279 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_B],
280 !!(payload[1] & 0x04));
281 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_A],
282 !!(payload[1] & 0x08));
283 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_MINUS],
284 !!(payload[1] & 0x10));
285 input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_HOME],
286 !!(payload[1] & 0x80));
287 input_sync(wdata->input);
288 }
289
290 struct wiiproto_handler {
291 __u8 id;
292 size_t size;
293 void (*func)(struct wiimote_data *wdata, const __u8 *payload);
294 };
295
296 static struct wiiproto_handler handlers[] = {
297 { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
298 { .id = 0 }
299 };
300
301 static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
302 u8 *raw_data, int size)
303 {
304 struct wiimote_data *wdata = hid_get_drvdata(hdev);
305 struct wiiproto_handler *h;
306 int i;
307 unsigned long flags;
308
309 if (size < 1)
310 return -EINVAL;
311
312 spin_lock_irqsave(&wdata->state.lock, flags);
313
314 for (i = 0; handlers[i].id; ++i) {
315 h = &handlers[i];
316 if (h->id == raw_data[0] && h->size < size)
317 h->func(wdata, &raw_data[1]);
318 }
319
320 spin_unlock_irqrestore(&wdata->state.lock, flags);
321
322 return 0;
323 }
324
325 static void wiimote_leds_destroy(struct wiimote_data *wdata)
326 {
327 int i;
328 struct led_classdev *led;
329
330 for (i = 0; i < 4; ++i) {
331 if (wdata->leds[i]) {
332 led = wdata->leds[i];
333 wdata->leds[i] = NULL;
334 led_classdev_unregister(led);
335 kfree(led);
336 }
337 }
338 }
339
340 static int wiimote_leds_create(struct wiimote_data *wdata)
341 {
342 int i, ret;
343 struct device *dev = &wdata->hdev->dev;
344 size_t namesz = strlen(dev_name(dev)) + 9;
345 struct led_classdev *led;
346 char *name;
347
348 for (i = 0; i < 4; ++i) {
349 led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
350 if (!led) {
351 ret = -ENOMEM;
352 goto err;
353 }
354 name = (void*)&led[1];
355 snprintf(name, namesz, "%s:blue:p%d", dev_name(dev), i);
356 led->name = name;
357 led->brightness = 0;
358 led->max_brightness = 1;
359 led->brightness_get = wiimote_leds_get;
360 led->brightness_set = wiimote_leds_set;
361
362 ret = led_classdev_register(dev, led);
363 if (ret) {
364 kfree(led);
365 goto err;
366 }
367 wdata->leds[i] = led;
368 }
369
370 return 0;
371
372 err:
373 wiimote_leds_destroy(wdata);
374 return ret;
375 }
376
377 static struct wiimote_data *wiimote_create(struct hid_device *hdev)
378 {
379 struct wiimote_data *wdata;
380 int i;
381
382 wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
383 if (!wdata)
384 return NULL;
385
386 wdata->input = input_allocate_device();
387 if (!wdata->input) {
388 kfree(wdata);
389 return NULL;
390 }
391
392 wdata->hdev = hdev;
393 hid_set_drvdata(hdev, wdata);
394
395 input_set_drvdata(wdata->input, wdata);
396 wdata->input->event = wiimote_input_event;
397 wdata->input->open = wiimote_input_open;
398 wdata->input->close = wiimote_input_close;
399 wdata->input->dev.parent = &wdata->hdev->dev;
400 wdata->input->id.bustype = wdata->hdev->bus;
401 wdata->input->id.vendor = wdata->hdev->vendor;
402 wdata->input->id.product = wdata->hdev->product;
403 wdata->input->id.version = wdata->hdev->version;
404 wdata->input->name = WIIMOTE_NAME;
405
406 set_bit(EV_KEY, wdata->input->evbit);
407 for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
408 set_bit(wiiproto_keymap[i], wdata->input->keybit);
409
410 spin_lock_init(&wdata->qlock);
411 INIT_WORK(&wdata->worker, wiimote_worker);
412
413 spin_lock_init(&wdata->state.lock);
414
415 return wdata;
416 }
417
418 static void wiimote_destroy(struct wiimote_data *wdata)
419 {
420 wiimote_leds_destroy(wdata);
421
422 input_unregister_device(wdata->input);
423 cancel_work_sync(&wdata->worker);
424 hid_hw_stop(wdata->hdev);
425
426 kfree(wdata);
427 }
428
429 static int wiimote_hid_probe(struct hid_device *hdev,
430 const struct hid_device_id *id)
431 {
432 struct wiimote_data *wdata;
433 int ret;
434
435 wdata = wiimote_create(hdev);
436 if (!wdata) {
437 hid_err(hdev, "Can't alloc device\n");
438 return -ENOMEM;
439 }
440
441 ret = hid_parse(hdev);
442 if (ret) {
443 hid_err(hdev, "HID parse failed\n");
444 goto err;
445 }
446
447 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
448 if (ret) {
449 hid_err(hdev, "HW start failed\n");
450 goto err;
451 }
452
453 ret = input_register_device(wdata->input);
454 if (ret) {
455 hid_err(hdev, "Cannot register input device\n");
456 goto err_stop;
457 }
458
459 ret = wiimote_leds_create(wdata);
460 if (ret)
461 goto err_free;
462
463 hid_info(hdev, "New device registered\n");
464
465 /* by default set led1 after device initialization */
466 spin_lock_irq(&wdata->state.lock);
467 wiiproto_req_leds(wdata, WIIPROTO_FLAG_LED1);
468 spin_unlock_irq(&wdata->state.lock);
469
470 return 0;
471
472 err_free:
473 wiimote_destroy(wdata);
474 return ret;
475
476 err_stop:
477 hid_hw_stop(hdev);
478 err:
479 input_free_device(wdata->input);
480 kfree(wdata);
481 return ret;
482 }
483
484 static void wiimote_hid_remove(struct hid_device *hdev)
485 {
486 struct wiimote_data *wdata = hid_get_drvdata(hdev);
487
488 hid_info(hdev, "Device removed\n");
489 wiimote_destroy(wdata);
490 }
491
492 static const struct hid_device_id wiimote_hid_devices[] = {
493 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
494 USB_DEVICE_ID_NINTENDO_WIIMOTE) },
495 { }
496 };
497 MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
498
499 static struct hid_driver wiimote_hid_driver = {
500 .name = "wiimote",
501 .id_table = wiimote_hid_devices,
502 .probe = wiimote_hid_probe,
503 .remove = wiimote_hid_remove,
504 .raw_event = wiimote_hid_event,
505 };
506
507 static int __init wiimote_init(void)
508 {
509 int ret;
510
511 ret = hid_register_driver(&wiimote_hid_driver);
512 if (ret)
513 pr_err("Can't register wiimote hid driver\n");
514
515 return ret;
516 }
517
518 static void __exit wiimote_exit(void)
519 {
520 hid_unregister_driver(&wiimote_hid_driver);
521 }
522
523 module_init(wiimote_init);
524 module_exit(wiimote_exit);
525 MODULE_LICENSE("GPL");
526 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
527 MODULE_DESCRIPTION(WIIMOTE_NAME " Device Driver");
528 MODULE_VERSION(WIIMOTE_VERSION);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree