drivers/hid/hid-wiimote.c

   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/module.h>
  17 #include <linux/spinlock.h>
  18 #include "hid-ids.h"
  19
  20 #define WIIMOTE_VERSION "0.1"
  21 #define WIIMOTE_NAME "Nintendo Wii Remote"
  22 #define WIIMOTE_BUFSIZE 32
  23
  24 struct wiimote_buf {
  25         __u8 data[HID_MAX_BUFFER_SIZE];
  26         size_t size;
  27 };
  28
  29 struct wiimote_state {
  30         spinlock_t lock;
  31         __u8 flags;
  32 };
  33
  34 struct wiimote_data {
  35         struct hid_device *hdev;
  36         struct input_dev *input;
  37
  38         spinlock_t qlock;
  39         __u8 head;
  40         __u8 tail;
  41         struct wiimote_buf outq[WIIMOTE_BUFSIZE];
  42         struct work_struct worker;
  43
  44         struct wiimote_state state;
  45 };
  46
  47 #define WIIPROTO_FLAG_LED1 0x01
  48 #define WIIPROTO_FLAG_LED2 0x02
  49 #define WIIPROTO_FLAG_LED3 0x04
  50 #define WIIPROTO_FLAG_LED4 0x08
  51 #define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 | WIIPROTO_FLAG_LED2 | \
  52                                         WIIPROTO_FLAG_LED3 | WIIPROTO_FLAG_LED4)
  53
  54 enum wiiproto_reqs {
  55         WIIPROTO_REQ_LED = 0x11,
  56         WIIPROTO_REQ_DRM_K = 0x30,
  57 };
  58
  59 enum wiiproto_keys {
  60         WIIPROTO_KEY_LEFT,
  61         WIIPROTO_KEY_RIGHT,
  62         WIIPROTO_KEY_UP,
  63         WIIPROTO_KEY_DOWN,
  64         WIIPROTO_KEY_PLUS,
  65         WIIPROTO_KEY_MINUS,
  66         WIIPROTO_KEY_ONE,
  67         WIIPROTO_KEY_TWO,
  68         WIIPROTO_KEY_A,
  69         WIIPROTO_KEY_B,
  70         WIIPROTO_KEY_HOME,
  71         WIIPROTO_KEY_COUNT
  72 };
  73
  74 static __u16 wiiproto_keymap[] = {
  75         KEY_LEFT,       /* WIIPROTO_KEY_LEFT */
  76         KEY_RIGHT,      /* WIIPROTO_KEY_RIGHT */
  77         KEY_UP,         /* WIIPROTO_KEY_UP */
  78         KEY_DOWN,       /* WIIPROTO_KEY_DOWN */
  79         KEY_NEXT,       /* WIIPROTO_KEY_PLUS */
  80         KEY_PREVIOUS,   /* WIIPROTO_KEY_MINUS */
  81         BTN_1,          /* WIIPROTO_KEY_ONE */
  82         BTN_2,          /* WIIPROTO_KEY_TWO */
  83         BTN_A,          /* WIIPROTO_KEY_A */
  84         BTN_B,          /* WIIPROTO_KEY_B */
  85         BTN_MODE,       /* WIIPROTO_KEY_HOME */
  86 };
  87
  88 #define dev_to_wii(pdev) hid_get_drvdata(container_of(pdev, struct hid_device, \
  89                                                                         dev))
  90
  91 static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
  92                                                                 size_t count)
  93 {
  94         __u8 *buf;
  95         ssize_t ret;
  96
  97         if (!hdev->hid_output_raw_report)
  98                 return -ENODEV;
  99
 100         buf = kmemdup(buffer, count, GFP_KERNEL);
 101         if (!buf)
 102                 return -ENOMEM;
 103
 104         ret = hdev->hid_output_raw_report(hdev, buf, count, HID_OUTPUT_REPORT);
 105
 106         kfree(buf);
 107         return ret;
 108 }
 109
 110 static void wiimote_worker(struct work_struct *work)
 111 {
 112         struct wiimote_data *wdata = container_of(work, struct wiimote_data,
 113                                                                         worker);
 114         unsigned long flags;
 115
 116         spin_lock_irqsave(&wdata->qlock, flags);
 117
 118         while (wdata->head != wdata->tail) {
 119                 spin_unlock_irqrestore(&wdata->qlock, flags);
 120                 wiimote_hid_send(wdata->hdev, wdata->outq[wdata->tail].data,
 121                                                 wdata->outq[wdata->tail].size);
 122                 spin_lock_irqsave(&wdata->qlock, flags);
 123
 124                 wdata->tail = (wdata->tail + 1) % WIIMOTE_BUFSIZE;
 125         }
 126
 127         spin_unlock_irqrestore(&wdata->qlock, flags);
 128 }
 129
 130 static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
 131                                                                 size_t count)
 132 {
 133         unsigned long flags;
 134         __u8 newhead;
 135
 136         if (count > HID_MAX_BUFFER_SIZE) {
 137                 hid_warn(wdata->hdev, "Sending too large output report\n");
 138                 return;
 139         }
 140
 141         /*
 142          * Copy new request into our output queue and check whether the
 143          * queue is full. If it is full, discard this request.
 144          * If it is empty we need to start a new worker that will
 145          * send out the buffer to the hid device.
 146          * If the queue is not empty, then there must be a worker
 147          * that is currently sending out our buffer and this worker
 148          * will reschedule itself until the queue is empty.
 149          */
 150
 151         spin_lock_irqsave(&wdata->qlock, flags);
 152
 153         memcpy(wdata->outq[wdata->head].data, buffer, count);
 154         wdata->outq[wdata->head].size = count;
 155         newhead = (wdata->head + 1) % WIIMOTE_BUFSIZE;
 156
 157         if (wdata->head == wdata->tail) {
 158                 wdata->head = newhead;
 159                 schedule_work(&wdata->worker);
 160         } else if (newhead != wdata->tail) {
 161                 wdata->head = newhead;
 162         } else {
 163                 hid_warn(wdata->hdev, "Output queue is full");
 164         }
 165
 166         spin_unlock_irqrestore(&wdata->qlock, flags);
 167 }
 168
 169 static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
 170 {
 171         __u8 cmd[2];
 172
 173         leds &= WIIPROTO_FLAGS_LEDS;
 174         if ((wdata->state.flags & WIIPROTO_FLAGS_LEDS) == leds)
 175                 return;
 176         wdata->state.flags = (wdata->state.flags & ~WIIPROTO_FLAGS_LEDS) | leds;
 177
 178         cmd[0] = WIIPROTO_REQ_LED;
 179         cmd[1] = 0;
 180
 181         if (leds & WIIPROTO_FLAG_LED1)
 182                 cmd[1] |= 0x10;
 183         if (leds & WIIPROTO_FLAG_LED2)
 184                 cmd[1] |= 0x20;
 185         if (leds & WIIPROTO_FLAG_LED3)
 186                 cmd[1] |= 0x40;
 187         if (leds & WIIPROTO_FLAG_LED4)
 188                 cmd[1] |= 0x80;
 189
 190         wiimote_queue(wdata, cmd, sizeof(cmd));
 191 }
 192
 193 #define wiifs_led_show_set(num)                                         \
 194 static ssize_t wiifs_led_show_##num(struct device *dev,                 \
 195                         struct device_attribute *attr, char *buf)       \
 196 {                                                                       \
 197         struct wiimote_data *wdata = dev_to_wii(dev);                   \
 198         unsigned long flags;                                            \
 199         int state;                                                      \
 200                                                                         \
 201         spin_lock_irqsave(&wdata->state.lock, flags);                   \
 202         state = !!(wdata->state.flags & WIIPROTO_FLAG_LED##num);        \
 203         spin_unlock_irqrestore(&wdata->state.lock, flags);              \
 204                                                                         \
 205         return sprintf(buf, "%d\n", state);                             \
 206 }                                                                       \
 207 static ssize_t wiifs_led_set_##num(struct device *dev,                  \
 208         struct device_attribute *attr, const char *buf, size_t count)   \
 209 {                                                                       \
 210         struct wiimote_data *wdata = dev_to_wii(dev);                   \
 211         int tmp = simple_strtoul(buf, NULL, 10);                        \
 212         unsigned long flags;                                            \
 213         __u8 state;                                                     \
 214                                                                         \
 215         spin_lock_irqsave(&wdata->state.lock, flags);                   \
 216                                                                         \
 217         state = wdata->state.flags;                                     \
 218                                                                         \
 219         if (tmp)                                                        \
 220                 wiiproto_req_leds(wdata, state | WIIPROTO_FLAG_LED##num);\
 221         else                                                            \
 222                 wiiproto_req_leds(wdata, state & ~WIIPROTO_FLAG_LED##num);\
 223                                                                         \
 224         spin_unlock_irqrestore(&wdata->state.lock, flags);              \
 225                                                                         \
 226         return count;                                                   \
 227 }                                                                       \
 228 static DEVICE_ATTR(led##num, S_IRUGO | S_IWUSR, wiifs_led_show_##num,   \
 229                                                 wiifs_led_set_##num)
 230
 231 wiifs_led_show_set(1);
 232 wiifs_led_show_set(2);
 233 wiifs_led_show_set(3);
 234 wiifs_led_show_set(4);
 235
 236 static int wiimote_input_event(struct input_dev *dev, unsigned int type,
 237                                                 unsigned int code, int value)
 238 {
 239         return 0;
 240 }
 241
 242 static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
 243 {
 244         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_LEFT],
 245                                                         !!(payload[0] & 0x01));
 246         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_RIGHT],
 247                                                         !!(payload[0] & 0x02));
 248         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_DOWN],
 249                                                         !!(payload[0] & 0x04));
 250         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_UP],
 251                                                         !!(payload[0] & 0x08));
 252         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_PLUS],
 253                                                         !!(payload[0] & 0x10));
 254         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_TWO],
 255                                                         !!(payload[1] & 0x01));
 256         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_ONE],
 257                                                         !!(payload[1] & 0x02));
 258         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_B],
 259                                                         !!(payload[1] & 0x04));
 260         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_A],
 261                                                         !!(payload[1] & 0x08));
 262         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_MINUS],
 263                                                         !!(payload[1] & 0x10));
 264         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_HOME],
 265                                                         !!(payload[1] & 0x80));
 266         input_sync(wdata->input);
 267 }
 268
 269 struct wiiproto_handler {
 270         __u8 id;
 271         size_t size;
 272         void (*func)(struct wiimote_data *wdata, const __u8 *payload);
 273 };
 274
 275 static struct wiiproto_handler handlers[] = {
 276         { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
 277         { .id = 0 }
 278 };
 279
 280 static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
 281                                                         u8 *raw_data, int size)
 282 {
 283         struct wiimote_data *wdata = hid_get_drvdata(hdev);
 284         struct wiiproto_handler *h;
 285         int i;
 286         unsigned long flags;
 287
 288         if (size < 1)
 289                 return -EINVAL;
 290
 291         spin_lock_irqsave(&wdata->state.lock, flags);
 292
 293         for (i = 0; handlers[i].id; ++i) {
 294                 h = &handlers[i];
 295                 if (h->id == raw_data[0] && h->size < size)
 296                         h->func(wdata, &raw_data[1]);
 297         }
 298
 299         spin_unlock_irqrestore(&wdata->state.lock, flags);
 300
 301         return 0;
 302 }
 303
 304 static struct wiimote_data *wiimote_create(struct hid_device *hdev)
 305 {
 306         struct wiimote_data *wdata;
 307         int i;
 308
 309         wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
 310         if (!wdata)
 311                 return NULL;
 312
 313         wdata->input = input_allocate_device();
 314         if (!wdata->input) {
 315                 kfree(wdata);
 316                 return NULL;
 317         }
 318
 319         wdata->hdev = hdev;
 320         hid_set_drvdata(hdev, wdata);
 321
 322         input_set_drvdata(wdata->input, wdata);
 323         wdata->input->event = wiimote_input_event;
 324         wdata->input->dev.parent = &wdata->hdev->dev;
 325         wdata->input->id.bustype = wdata->hdev->bus;
 326         wdata->input->id.vendor = wdata->hdev->vendor;
 327         wdata->input->id.product = wdata->hdev->product;
 328         wdata->input->id.version = wdata->hdev->version;
 329         wdata->input->name = WIIMOTE_NAME;
 330
 331         set_bit(EV_KEY, wdata->input->evbit);
 332         for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
 333                 set_bit(wiiproto_keymap[i], wdata->input->keybit);
 334
 335         spin_lock_init(&wdata->qlock);
 336         INIT_WORK(&wdata->worker, wiimote_worker);
 337
 338         spin_lock_init(&wdata->state.lock);
 339
 340         return wdata;
 341 }
 342
 343 static void wiimote_destroy(struct wiimote_data *wdata)
 344 {
 345         device_remove_file(&wdata->hdev->dev, &dev_attr_led1);
 346         device_remove_file(&wdata->hdev->dev, &dev_attr_led2);
 347         device_remove_file(&wdata->hdev->dev, &dev_attr_led3);
 348         device_remove_file(&wdata->hdev->dev, &dev_attr_led4);
 349
 350         input_unregister_device(wdata->input);
 351         cancel_work_sync(&wdata->worker);
 352         hid_hw_stop(wdata->hdev);
 353
 354         kfree(wdata);
 355 }
 356
 357 static int wiimote_hid_probe(struct hid_device *hdev,
 358                                 const struct hid_device_id *id)
 359 {
 360         struct wiimote_data *wdata;
 361         int ret;
 362
 363         wdata = wiimote_create(hdev);
 364         if (!wdata) {
 365                 hid_err(hdev, "Can't alloc device\n");
 366                 return -ENOMEM;
 367         }
 368
 369         ret = hid_parse(hdev);
 370         if (ret) {
 371                 hid_err(hdev, "HID parse failed\n");
 372                 goto err;
 373         }
 374
 375         ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
 376         if (ret) {
 377                 hid_err(hdev, "HW start failed\n");
 378                 goto err;
 379         }
 380
 381         ret = input_register_device(wdata->input);
 382         if (ret) {
 383                 hid_err(hdev, "Cannot register input device\n");
 384                 goto err_stop;
 385         }
 386
 387         ret = device_create_file(&hdev->dev, &dev_attr_led1);
 388         if (ret)
 389                 goto err_free;
 390         ret = device_create_file(&hdev->dev, &dev_attr_led2);
 391         if (ret)
 392                 goto err_free;
 393         ret = device_create_file(&hdev->dev, &dev_attr_led3);
 394         if (ret)
 395                 goto err_free;
 396         ret = device_create_file(&hdev->dev, &dev_attr_led4);
 397         if (ret)
 398                 goto err_free;
 399
 400         hid_info(hdev, "New device registered\n");
 401
 402         /* by default set led1 after device initialization */
 403         spin_lock_irq(&wdata->state.lock);
 404         wiiproto_req_leds(wdata, WIIPROTO_FLAG_LED1);
 405         spin_unlock_irq(&wdata->state.lock);
 406
 407         return 0;
 408
 409 err_free:
 410         wiimote_destroy(wdata);
 411         return ret;
 412
 413 err_stop:
 414         hid_hw_stop(hdev);
 415 err:
 416         input_free_device(wdata->input);
 417         kfree(wdata);
 418         return ret;
 419 }
 420
 421 static void wiimote_hid_remove(struct hid_device *hdev)
 422 {
 423         struct wiimote_data *wdata = hid_get_drvdata(hdev);
 424
 425         hid_info(hdev, "Device removed\n");
 426         wiimote_destroy(wdata);
 427 }
 428
 429 static const struct hid_device_id wiimote_hid_devices[] = {
 430         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
 431                                 USB_DEVICE_ID_NINTENDO_WIIMOTE) },
 432         { }
 433 };
 434 MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
 435
 436 static struct hid_driver wiimote_hid_driver = {
 437         .name = "wiimote",
 438         .id_table = wiimote_hid_devices,
 439         .probe = wiimote_hid_probe,
 440         .remove = wiimote_hid_remove,
 441         .raw_event = wiimote_hid_event,
 442 };
 443
 444 static int __init wiimote_init(void)
 445 {
 446         int ret;
 447
 448         ret = hid_register_driver(&wiimote_hid_driver);
 449         if (ret)
 450                 pr_err("Can't register wiimote hid driver\n");
 451
 452         return ret;
 453 }
 454
 455 static void __exit wiimote_exit(void)
 456 {
 457         hid_unregister_driver(&wiimote_hid_driver);
 458 }
 459
 460 module_init(wiimote_init);
 461 module_exit(wiimote_exit);
 462 MODULE_LICENSE("GPL");
 463 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
 464 MODULE_DESCRIPTION(WIIMOTE_NAME " Device Driver");
 465 MODULE_VERSION(WIIMOTE_VERSION);