Pileus Git - ~andy/linux/blob - drivers/hid/hid-wiimote-core.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/completion.h>
  14 #include <linux/device.h>
  15 #include <linux/hid.h>
  16 #include <linux/input.h>
  17 #include <linux/leds.h>
  18 #include <linux/module.h>
  19 #include <linux/mutex.h>
  20 #include <linux/power_supply.h>
  21 #include <linux/spinlock.h>
  22 #include "hid-ids.h"
  23 #include "hid-wiimote.h"
  24
  25 #define WIIMOTE_VERSION "0.2"
  26
  27 enum wiiproto_keys {
  28         WIIPROTO_KEY_LEFT,
  29         WIIPROTO_KEY_RIGHT,
  30         WIIPROTO_KEY_UP,
  31         WIIPROTO_KEY_DOWN,
  32         WIIPROTO_KEY_PLUS,
  33         WIIPROTO_KEY_MINUS,
  34         WIIPROTO_KEY_ONE,
  35         WIIPROTO_KEY_TWO,
  36         WIIPROTO_KEY_A,
  37         WIIPROTO_KEY_B,
  38         WIIPROTO_KEY_HOME,
  39         WIIPROTO_KEY_COUNT
  40 };
  41
  42 static __u16 wiiproto_keymap[] = {
  43         KEY_LEFT,       /* WIIPROTO_KEY_LEFT */
  44         KEY_RIGHT,      /* WIIPROTO_KEY_RIGHT */
  45         KEY_UP,         /* WIIPROTO_KEY_UP */
  46         KEY_DOWN,       /* WIIPROTO_KEY_DOWN */
  47         KEY_NEXT,       /* WIIPROTO_KEY_PLUS */
  48         KEY_PREVIOUS,   /* WIIPROTO_KEY_MINUS */
  49         BTN_1,          /* WIIPROTO_KEY_ONE */
  50         BTN_2,          /* WIIPROTO_KEY_TWO */
  51         BTN_A,          /* WIIPROTO_KEY_A */
  52         BTN_B,          /* WIIPROTO_KEY_B */
  53         BTN_MODE,       /* WIIPROTO_KEY_HOME */
  54 };
  55
  56 static enum power_supply_property wiimote_battery_props[] = {
  57         POWER_SUPPLY_PROP_CAPACITY
  58 };
  59
  60 static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
  61                                                                 size_t count)
  62 {
  63         __u8 *buf;
  64         ssize_t ret;
  65
  66         if (!hdev->hid_output_raw_report)
  67                 return -ENODEV;
  68
  69         buf = kmemdup(buffer, count, GFP_KERNEL);
  70         if (!buf)
  71                 return -ENOMEM;
  72
  73         ret = hdev->hid_output_raw_report(hdev, buf, count, HID_OUTPUT_REPORT);
  74
  75         kfree(buf);
  76         return ret;
  77 }
  78
  79 static void wiimote_worker(struct work_struct *work)
  80 {
  81         struct wiimote_data *wdata = container_of(work, struct wiimote_data,
  82                                                                         worker);
  83         unsigned long flags;
  84
  85         spin_lock_irqsave(&wdata->qlock, flags);
  86
  87         while (wdata->head != wdata->tail) {
  88                 spin_unlock_irqrestore(&wdata->qlock, flags);
  89                 wiimote_hid_send(wdata->hdev, wdata->outq[wdata->tail].data,
  90                                                 wdata->outq[wdata->tail].size);
  91                 spin_lock_irqsave(&wdata->qlock, flags);
  92
  93                 wdata->tail = (wdata->tail + 1) % WIIMOTE_BUFSIZE;
  94         }
  95
  96         spin_unlock_irqrestore(&wdata->qlock, flags);
  97 }
  98
  99 static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
 100                                                                 size_t count)
 101 {
 102         unsigned long flags;
 103         __u8 newhead;
 104
 105         if (count > HID_MAX_BUFFER_SIZE) {
 106                 hid_warn(wdata->hdev, "Sending too large output report\n");
 107                 return;
 108         }
 109
 110         /*
 111          * Copy new request into our output queue and check whether the
 112          * queue is full. If it is full, discard this request.
 113          * If it is empty we need to start a new worker that will
 114          * send out the buffer to the hid device.
 115          * If the queue is not empty, then there must be a worker
 116          * that is currently sending out our buffer and this worker
 117          * will reschedule itself until the queue is empty.
 118          */
 119
 120         spin_lock_irqsave(&wdata->qlock, flags);
 121
 122         memcpy(wdata->outq[wdata->head].data, buffer, count);
 123         wdata->outq[wdata->head].size = count;
 124         newhead = (wdata->head + 1) % WIIMOTE_BUFSIZE;
 125
 126         if (wdata->head == wdata->tail) {
 127                 wdata->head = newhead;
 128                 schedule_work(&wdata->worker);
 129         } else if (newhead != wdata->tail) {
 130                 wdata->head = newhead;
 131         } else {
 132                 hid_warn(wdata->hdev, "Output queue is full");
 133         }
 134
 135         spin_unlock_irqrestore(&wdata->qlock, flags);
 136 }
 137
 138 /*
 139  * This sets the rumble bit on the given output report if rumble is
 140  * currently enabled.
 141  * \cmd1 must point to the second byte in the output report => &cmd[1]
 142  * This must be called on nearly every output report before passing it
 143  * into the output queue!
 144  */
 145 static inline void wiiproto_keep_rumble(struct wiimote_data *wdata, __u8 *cmd1)
 146 {
 147         if (wdata->state.flags & WIIPROTO_FLAG_RUMBLE)
 148                 *cmd1 |= 0x01;
 149 }
 150
 151 static void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
 152 {
 153         __u8 cmd[2];
 154
 155         rumble = !!rumble;
 156         if (rumble == !!(wdata->state.flags & WIIPROTO_FLAG_RUMBLE))
 157                 return;
 158
 159         if (rumble)
 160                 wdata->state.flags |= WIIPROTO_FLAG_RUMBLE;
 161         else
 162                 wdata->state.flags &= ~WIIPROTO_FLAG_RUMBLE;
 163
 164         cmd[0] = WIIPROTO_REQ_RUMBLE;
 165         cmd[1] = 0;
 166
 167         wiiproto_keep_rumble(wdata, &cmd[1]);
 168         wiimote_queue(wdata, cmd, sizeof(cmd));
 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         wiiproto_keep_rumble(wdata, &cmd[1]);
 193         wiimote_queue(wdata, cmd, sizeof(cmd));
 194 }
 195
 196 /*
 197  * Check what peripherals of the wiimote are currently
 198  * active and select a proper DRM that supports all of
 199  * the requested data inputs.
 200  */
 201 static __u8 select_drm(struct wiimote_data *wdata)
 202 {
 203         __u8 ir = wdata->state.flags & WIIPROTO_FLAGS_IR;
 204
 205         if (ir == WIIPROTO_FLAG_IR_BASIC) {
 206                 if (wdata->state.flags & WIIPROTO_FLAG_ACCEL)
 207                         return WIIPROTO_REQ_DRM_KAIE;
 208                 else
 209                         return WIIPROTO_REQ_DRM_KIE;
 210         } else if (ir == WIIPROTO_FLAG_IR_EXT) {
 211                 return WIIPROTO_REQ_DRM_KAI;
 212         } else if (ir == WIIPROTO_FLAG_IR_FULL) {
 213                 return WIIPROTO_REQ_DRM_SKAI1;
 214         } else {
 215                 if (wdata->state.flags & WIIPROTO_FLAG_ACCEL)
 216                         return WIIPROTO_REQ_DRM_KA;
 217                 else
 218                         return WIIPROTO_REQ_DRM_K;
 219         }
 220 }
 221
 222 void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
 223 {
 224         __u8 cmd[3];
 225
 226         if (drm == WIIPROTO_REQ_NULL)
 227                 drm = select_drm(wdata);
 228
 229         cmd[0] = WIIPROTO_REQ_DRM;
 230         cmd[1] = 0;
 231         cmd[2] = drm;
 232
 233         wiiproto_keep_rumble(wdata, &cmd[1]);
 234         wiimote_queue(wdata, cmd, sizeof(cmd));
 235 }
 236
 237 static void wiiproto_req_status(struct wiimote_data *wdata)
 238 {
 239         __u8 cmd[2];
 240
 241         cmd[0] = WIIPROTO_REQ_SREQ;
 242         cmd[1] = 0;
 243
 244         wiiproto_keep_rumble(wdata, &cmd[1]);
 245         wiimote_queue(wdata, cmd, sizeof(cmd));
 246 }
 247
 248 static void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
 249 {
 250         accel = !!accel;
 251         if (accel == !!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
 252                 return;
 253
 254         if (accel)
 255                 wdata->state.flags |= WIIPROTO_FLAG_ACCEL;
 256         else
 257                 wdata->state.flags &= ~WIIPROTO_FLAG_ACCEL;
 258
 259         wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
 260 }
 261
 262 static void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
 263 {
 264         __u8 cmd[2];
 265
 266         cmd[0] = WIIPROTO_REQ_IR1;
 267         cmd[1] = flags;
 268
 269         wiiproto_keep_rumble(wdata, &cmd[1]);
 270         wiimote_queue(wdata, cmd, sizeof(cmd));
 271 }
 272
 273 static void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags)
 274 {
 275         __u8 cmd[2];
 276
 277         cmd[0] = WIIPROTO_REQ_IR2;
 278         cmd[1] = flags;
 279
 280         wiiproto_keep_rumble(wdata, &cmd[1]);
 281         wiimote_queue(wdata, cmd, sizeof(cmd));
 282 }
 283
 284 #define wiiproto_req_wreg(wdata, os, buf, sz) \
 285                         wiiproto_req_wmem((wdata), false, (os), (buf), (sz))
 286
 287 #define wiiproto_req_weeprom(wdata, os, buf, sz) \
 288                         wiiproto_req_wmem((wdata), true, (os), (buf), (sz))
 289
 290 static void wiiproto_req_wmem(struct wiimote_data *wdata, bool eeprom,
 291                                 __u32 offset, const __u8 *buf, __u8 size)
 292 {
 293         __u8 cmd[22];
 294
 295         if (size > 16 || size == 0) {
 296                 hid_warn(wdata->hdev, "Invalid length %d wmem request\n", size);
 297                 return;
 298         }
 299
 300         memset(cmd, 0, sizeof(cmd));
 301         cmd[0] = WIIPROTO_REQ_WMEM;
 302         cmd[2] = (offset >> 16) & 0xff;
 303         cmd[3] = (offset >> 8) & 0xff;
 304         cmd[4] = offset & 0xff;
 305         cmd[5] = size;
 306         memcpy(&cmd[6], buf, size);
 307
 308         if (!eeprom)
 309                 cmd[1] |= 0x04;
 310
 311         wiiproto_keep_rumble(wdata, &cmd[1]);
 312         wiimote_queue(wdata, cmd, sizeof(cmd));
 313 }
 314
 315 /* requries the cmd-mutex to be held */
 316 int wiimote_cmd_write(struct wiimote_data *wdata, __u32 offset,
 317                                                 const __u8 *wmem, __u8 size)
 318 {
 319         unsigned long flags;
 320         int ret;
 321
 322         spin_lock_irqsave(&wdata->state.lock, flags);
 323         wiimote_cmd_set(wdata, WIIPROTO_REQ_WMEM, 0);
 324         wiiproto_req_wreg(wdata, offset, wmem, size);
 325         spin_unlock_irqrestore(&wdata->state.lock, flags);
 326
 327         ret = wiimote_cmd_wait(wdata);
 328         if (!ret && wdata->state.cmd_err)
 329                 ret = -EIO;
 330
 331         return ret;
 332 }
 333
 334 static int wiimote_battery_get_property(struct power_supply *psy,
 335                                                 enum power_supply_property psp,
 336                                                 union power_supply_propval *val)
 337 {
 338         struct wiimote_data *wdata = container_of(psy,
 339                                                 struct wiimote_data, battery);
 340         int ret = 0, state;
 341         unsigned long flags;
 342
 343         ret = wiimote_cmd_acquire(wdata);
 344         if (ret)
 345                 return ret;
 346
 347         spin_lock_irqsave(&wdata->state.lock, flags);
 348         wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
 349         wiiproto_req_status(wdata);
 350         spin_unlock_irqrestore(&wdata->state.lock, flags);
 351
 352         ret = wiimote_cmd_wait(wdata);
 353         state = wdata->state.cmd_battery;
 354         wiimote_cmd_release(wdata);
 355
 356         if (ret)
 357                 return ret;
 358
 359         switch (psp) {
 360                 case POWER_SUPPLY_PROP_CAPACITY:
 361                         val->intval = state * 100 / 255;
 362                         break;
 363                 default:
 364                         ret = -EINVAL;
 365                         break;
 366         }
 367
 368         return ret;
 369 }
 370
 371 static int wiimote_init_ir(struct wiimote_data *wdata, __u16 mode)
 372 {
 373         int ret;
 374         unsigned long flags;
 375         __u8 format = 0;
 376         static const __u8 data_enable[] = { 0x01 };
 377         static const __u8 data_sens1[] = { 0x02, 0x00, 0x00, 0x71, 0x01,
 378                                                 0x00, 0xaa, 0x00, 0x64 };
 379         static const __u8 data_sens2[] = { 0x63, 0x03 };
 380         static const __u8 data_fin[] = { 0x08 };
 381
 382         spin_lock_irqsave(&wdata->state.lock, flags);
 383
 384         if (mode == (wdata->state.flags & WIIPROTO_FLAGS_IR)) {
 385                 spin_unlock_irqrestore(&wdata->state.lock, flags);
 386                 return 0;
 387         }
 388
 389         if (mode == 0) {
 390                 wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
 391                 wiiproto_req_ir1(wdata, 0);
 392                 wiiproto_req_ir2(wdata, 0);
 393                 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
 394                 spin_unlock_irqrestore(&wdata->state.lock, flags);
 395                 return 0;
 396         }
 397
 398         spin_unlock_irqrestore(&wdata->state.lock, flags);
 399
 400         ret = wiimote_cmd_acquire(wdata);
 401         if (ret)
 402                 return ret;
 403
 404         /* send PIXEL CLOCK ENABLE cmd first */
 405         spin_lock_irqsave(&wdata->state.lock, flags);
 406         wiimote_cmd_set(wdata, WIIPROTO_REQ_IR1, 0);
 407         wiiproto_req_ir1(wdata, 0x06);
 408         spin_unlock_irqrestore(&wdata->state.lock, flags);
 409
 410         ret = wiimote_cmd_wait(wdata);
 411         if (ret)
 412                 goto unlock;
 413         if (wdata->state.cmd_err) {
 414                 ret = -EIO;
 415                 goto unlock;
 416         }
 417
 418         /* enable IR LOGIC */
 419         spin_lock_irqsave(&wdata->state.lock, flags);
 420         wiimote_cmd_set(wdata, WIIPROTO_REQ_IR2, 0);
 421         wiiproto_req_ir2(wdata, 0x06);
 422         spin_unlock_irqrestore(&wdata->state.lock, flags);
 423
 424         ret = wiimote_cmd_wait(wdata);
 425         if (ret)
 426                 goto unlock;
 427         if (wdata->state.cmd_err) {
 428                 ret = -EIO;
 429                 goto unlock;
 430         }
 431
 432         /* enable IR cam but do not make it send data, yet */
 433         ret = wiimote_cmd_write(wdata, 0xb00030, data_enable,
 434                                                         sizeof(data_enable));
 435         if (ret)
 436                 goto unlock;
 437
 438         /* write first sensitivity block */
 439         ret = wiimote_cmd_write(wdata, 0xb00000, data_sens1,
 440                                                         sizeof(data_sens1));
 441         if (ret)
 442                 goto unlock;
 443
 444         /* write second sensitivity block */
 445         ret = wiimote_cmd_write(wdata, 0xb0001a, data_sens2,
 446                                                         sizeof(data_sens2));
 447         if (ret)
 448                 goto unlock;
 449
 450         /* put IR cam into desired state */
 451         switch (mode) {
 452                 case WIIPROTO_FLAG_IR_FULL:
 453                         format = 5;
 454                         break;
 455                 case WIIPROTO_FLAG_IR_EXT:
 456                         format = 3;
 457                         break;
 458                 case WIIPROTO_FLAG_IR_BASIC:
 459                         format = 1;
 460                         break;
 461         }
 462         ret = wiimote_cmd_write(wdata, 0xb00033, &format, sizeof(format));
 463         if (ret)
 464                 goto unlock;
 465
 466         /* make IR cam send data */
 467         ret = wiimote_cmd_write(wdata, 0xb00030, data_fin, sizeof(data_fin));
 468         if (ret)
 469                 goto unlock;
 470
 471         /* request new DRM mode compatible to IR mode */
 472         spin_lock_irqsave(&wdata->state.lock, flags);
 473         wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
 474         wdata->state.flags |= mode & WIIPROTO_FLAGS_IR;
 475         wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
 476         spin_unlock_irqrestore(&wdata->state.lock, flags);
 477
 478 unlock:
 479         wiimote_cmd_release(wdata);
 480         return ret;
 481 }
 482
 483 static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
 484 {
 485         struct wiimote_data *wdata;
 486         struct device *dev = led_dev->dev->parent;
 487         int i;
 488         unsigned long flags;
 489         bool value = false;
 490
 491         wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
 492
 493         for (i = 0; i < 4; ++i) {
 494                 if (wdata->leds[i] == led_dev) {
 495                         spin_lock_irqsave(&wdata->state.lock, flags);
 496                         value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
 497                         spin_unlock_irqrestore(&wdata->state.lock, flags);
 498                         break;
 499                 }
 500         }
 501
 502         return value ? LED_FULL : LED_OFF;
 503 }
 504
 505 static void wiimote_leds_set(struct led_classdev *led_dev,
 506                                                 enum led_brightness value)
 507 {
 508         struct wiimote_data *wdata;
 509         struct device *dev = led_dev->dev->parent;
 510         int i;
 511         unsigned long flags;
 512         __u8 state, flag;
 513
 514         wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
 515
 516         for (i = 0; i < 4; ++i) {
 517                 if (wdata->leds[i] == led_dev) {
 518                         flag = WIIPROTO_FLAG_LED(i + 1);
 519                         spin_lock_irqsave(&wdata->state.lock, flags);
 520                         state = wdata->state.flags;
 521                         if (value == LED_OFF)
 522                                 wiiproto_req_leds(wdata, state & ~flag);
 523                         else
 524                                 wiiproto_req_leds(wdata, state | flag);
 525                         spin_unlock_irqrestore(&wdata->state.lock, flags);
 526                         break;
 527                 }
 528         }
 529 }
 530
 531 static int wiimote_ff_play(struct input_dev *dev, void *data,
 532                                                         struct ff_effect *eff)
 533 {
 534         struct wiimote_data *wdata = input_get_drvdata(dev);
 535         __u8 value;
 536         unsigned long flags;
 537
 538         /*
 539          * The wiimote supports only a single rumble motor so if any magnitude
 540          * is set to non-zero then we start the rumble motor. If both are set to
 541          * zero, we stop the rumble motor.
 542          */
 543
 544         if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)
 545                 value = 1;
 546         else
 547                 value = 0;
 548
 549         spin_lock_irqsave(&wdata->state.lock, flags);
 550         wiiproto_req_rumble(wdata, value);
 551         spin_unlock_irqrestore(&wdata->state.lock, flags);
 552
 553         return 0;
 554 }
 555
 556 static int wiimote_input_open(struct input_dev *dev)
 557 {
 558         struct wiimote_data *wdata = input_get_drvdata(dev);
 559
 560         return hid_hw_open(wdata->hdev);
 561 }
 562
 563 static void wiimote_input_close(struct input_dev *dev)
 564 {
 565         struct wiimote_data *wdata = input_get_drvdata(dev);
 566
 567         hid_hw_close(wdata->hdev);
 568 }
 569
 570 static int wiimote_accel_open(struct input_dev *dev)
 571 {
 572         struct wiimote_data *wdata = input_get_drvdata(dev);
 573         int ret;
 574         unsigned long flags;
 575
 576         ret = hid_hw_open(wdata->hdev);
 577         if (ret)
 578                 return ret;
 579
 580         spin_lock_irqsave(&wdata->state.lock, flags);
 581         wiiproto_req_accel(wdata, true);
 582         spin_unlock_irqrestore(&wdata->state.lock, flags);
 583
 584         return 0;
 585 }
 586
 587 static void wiimote_accel_close(struct input_dev *dev)
 588 {
 589         struct wiimote_data *wdata = input_get_drvdata(dev);
 590         unsigned long flags;
 591
 592         spin_lock_irqsave(&wdata->state.lock, flags);
 593         wiiproto_req_accel(wdata, false);
 594         spin_unlock_irqrestore(&wdata->state.lock, flags);
 595
 596         hid_hw_close(wdata->hdev);
 597 }
 598
 599 static int wiimote_ir_open(struct input_dev *dev)
 600 {
 601         struct wiimote_data *wdata = input_get_drvdata(dev);
 602         int ret;
 603
 604         ret = hid_hw_open(wdata->hdev);
 605         if (ret)
 606                 return ret;
 607
 608         ret = wiimote_init_ir(wdata, WIIPROTO_FLAG_IR_BASIC);
 609         if (ret) {
 610                 hid_hw_close(wdata->hdev);
 611                 return ret;
 612         }
 613
 614         return 0;
 615 }
 616
 617 static void wiimote_ir_close(struct input_dev *dev)
 618 {
 619         struct wiimote_data *wdata = input_get_drvdata(dev);
 620
 621         wiimote_init_ir(wdata, 0);
 622         hid_hw_close(wdata->hdev);
 623 }
 624
 625 static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
 626 {
 627         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_LEFT],
 628                                                         !!(payload[0] & 0x01));
 629         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_RIGHT],
 630                                                         !!(payload[0] & 0x02));
 631         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_DOWN],
 632                                                         !!(payload[0] & 0x04));
 633         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_UP],
 634                                                         !!(payload[0] & 0x08));
 635         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_PLUS],
 636                                                         !!(payload[0] & 0x10));
 637         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_TWO],
 638                                                         !!(payload[1] & 0x01));
 639         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_ONE],
 640                                                         !!(payload[1] & 0x02));
 641         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_B],
 642                                                         !!(payload[1] & 0x04));
 643         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_A],
 644                                                         !!(payload[1] & 0x08));
 645         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_MINUS],
 646                                                         !!(payload[1] & 0x10));
 647         input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_HOME],
 648                                                         !!(payload[1] & 0x80));
 649         input_sync(wdata->input);
 650 }
 651
 652 static void handler_accel(struct wiimote_data *wdata, const __u8 *payload)
 653 {
 654         __u16 x, y, z;
 655
 656         if (!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
 657                 return;
 658
 659         /*
 660          * payload is: BB BB XX YY ZZ
 661          * Accelerometer data is encoded into 3 10bit values. XX, YY and ZZ
 662          * contain the upper 8 bits of each value. The lower 2 bits are
 663          * contained in the buttons data BB BB.
 664          * Bits 6 and 7 of the first buttons byte BB is the lower 2 bits of the
 665          * X accel value. Bit 5 of the second buttons byte is the 2nd bit of Y
 666          * accel value and bit 6 is the second bit of the Z value.
 667          * The first bit of Y and Z values is not available and always set to 0.
 668          * 0x200 is returned on no movement.
 669          */
 670
 671         x = payload[2] << 2;
 672         y = payload[3] << 2;
 673         z = payload[4] << 2;
 674
 675         x |= (payload[0] >> 5) & 0x3;
 676         y |= (payload[1] >> 4) & 0x2;
 677         z |= (payload[1] >> 5) & 0x2;
 678
 679         input_report_abs(wdata->accel, ABS_RX, x - 0x200);
 680         input_report_abs(wdata->accel, ABS_RY, y - 0x200);
 681         input_report_abs(wdata->accel, ABS_RZ, z - 0x200);
 682         input_sync(wdata->accel);
 683 }
 684
 685 #define ir_to_input0(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
 686                                                         ABS_HAT0X, ABS_HAT0Y)
 687 #define ir_to_input1(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
 688                                                         ABS_HAT1X, ABS_HAT1Y)
 689 #define ir_to_input2(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
 690                                                         ABS_HAT2X, ABS_HAT2Y)
 691 #define ir_to_input3(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
 692                                                         ABS_HAT3X, ABS_HAT3Y)
 693
 694 static void __ir_to_input(struct wiimote_data *wdata, const __u8 *ir,
 695                                                 bool packed, __u8 xid, __u8 yid)
 696 {
 697         __u16 x, y;
 698
 699         if (!(wdata->state.flags & WIIPROTO_FLAGS_IR))
 700                 return;
 701
 702         /*
 703          * Basic IR data is encoded into 3 bytes. The first two bytes are the
 704          * upper 8 bit of the X/Y data, the 3rd byte contains the lower 2 bits
 705          * of both.
 706          * If data is packed, then the 3rd byte is put first and slightly
 707          * reordered. This allows to interleave packed and non-packed data to
 708          * have two IR sets in 5 bytes instead of 6.
 709          * The resulting 10bit X/Y values are passed to the ABS_HATXY input dev.
 710          */
 711
 712         if (packed) {
 713                 x = ir[1] << 2;
 714                 y = ir[2] << 2;
 715
 716                 x |= ir[0] & 0x3;
 717                 y |= (ir[0] >> 2) & 0x3;
 718         } else {
 719                 x = ir[0] << 2;
 720                 y = ir[1] << 2;
 721
 722                 x |= (ir[2] >> 4) & 0x3;
 723                 y |= (ir[2] >> 6) & 0x3;
 724         }
 725
 726         input_report_abs(wdata->ir, xid, x);
 727         input_report_abs(wdata->ir, yid, y);
 728 }
 729
 730 static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
 731 {
 732         handler_keys(wdata, payload);
 733
 734         /* on status reports the drm is reset so we need to resend the drm */
 735         wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
 736
 737         if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_SREQ, 0)) {
 738                 wdata->state.cmd_battery = payload[5];
 739                 wiimote_cmd_complete(wdata);
 740         }
 741 }
 742
 743 static void handler_data(struct wiimote_data *wdata, const __u8 *payload)
 744 {
 745         handler_keys(wdata, payload);
 746 }
 747
 748 static void handler_return(struct wiimote_data *wdata, const __u8 *payload)
 749 {
 750         __u8 err = payload[3];
 751         __u8 cmd = payload[2];
 752
 753         handler_keys(wdata, payload);
 754
 755         if (wiimote_cmd_pending(wdata, cmd, 0)) {
 756                 wdata->state.cmd_err = err;
 757                 wiimote_cmd_complete(wdata);
 758         } else if (err) {
 759                 hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err,
 760                                                                         cmd);
 761         }
 762 }
 763
 764 static void handler_drm_KA(struct wiimote_data *wdata, const __u8 *payload)
 765 {
 766         handler_keys(wdata, payload);
 767         handler_accel(wdata, payload);
 768 }
 769
 770 static void handler_drm_KE(struct wiimote_data *wdata, const __u8 *payload)
 771 {
 772         handler_keys(wdata, payload);
 773 }
 774
 775 static void handler_drm_KAI(struct wiimote_data *wdata, const __u8 *payload)
 776 {
 777         handler_keys(wdata, payload);
 778         handler_accel(wdata, payload);
 779         ir_to_input0(wdata, &payload[5], false);
 780         ir_to_input1(wdata, &payload[8], false);
 781         ir_to_input2(wdata, &payload[11], false);
 782         ir_to_input3(wdata, &payload[14], false);
 783         input_sync(wdata->ir);
 784 }
 785
 786 static void handler_drm_KEE(struct wiimote_data *wdata, const __u8 *payload)
 787 {
 788         handler_keys(wdata, payload);
 789 }
 790
 791 static void handler_drm_KIE(struct wiimote_data *wdata, const __u8 *payload)
 792 {
 793         handler_keys(wdata, payload);
 794         ir_to_input0(wdata, &payload[2], false);
 795         ir_to_input1(wdata, &payload[4], true);
 796         ir_to_input2(wdata, &payload[7], false);
 797         ir_to_input3(wdata, &payload[9], true);
 798         input_sync(wdata->ir);
 799 }
 800
 801 static void handler_drm_KAE(struct wiimote_data *wdata, const __u8 *payload)
 802 {
 803         handler_keys(wdata, payload);
 804         handler_accel(wdata, payload);
 805 }
 806
 807 static void handler_drm_KAIE(struct wiimote_data *wdata, const __u8 *payload)
 808 {
 809         handler_keys(wdata, payload);
 810         handler_accel(wdata, payload);
 811         ir_to_input0(wdata, &payload[5], false);
 812         ir_to_input1(wdata, &payload[7], true);
 813         ir_to_input2(wdata, &payload[10], false);
 814         ir_to_input3(wdata, &payload[12], true);
 815         input_sync(wdata->ir);
 816 }
 817
 818 static void handler_drm_E(struct wiimote_data *wdata, const __u8 *payload)
 819 {
 820 }
 821
 822 static void handler_drm_SKAI1(struct wiimote_data *wdata, const __u8 *payload)
 823 {
 824         handler_keys(wdata, payload);
 825
 826         wdata->state.accel_split[0] = payload[2];
 827         wdata->state.accel_split[1] = (payload[0] >> 1) & (0x10 | 0x20);
 828         wdata->state.accel_split[1] |= (payload[1] << 1) & (0x40 | 0x80);
 829
 830         ir_to_input0(wdata, &payload[3], false);
 831         ir_to_input1(wdata, &payload[12], false);
 832         input_sync(wdata->ir);
 833 }
 834
 835 static void handler_drm_SKAI2(struct wiimote_data *wdata, const __u8 *payload)
 836 {
 837         __u8 buf[5];
 838
 839         handler_keys(wdata, payload);
 840
 841         wdata->state.accel_split[1] |= (payload[0] >> 5) & (0x01 | 0x02);
 842         wdata->state.accel_split[1] |= (payload[1] >> 3) & (0x04 | 0x08);
 843
 844         buf[0] = 0;
 845         buf[1] = 0;
 846         buf[2] = wdata->state.accel_split[0];
 847         buf[3] = payload[2];
 848         buf[4] = wdata->state.accel_split[1];
 849         handler_accel(wdata, buf);
 850
 851         ir_to_input2(wdata, &payload[3], false);
 852         ir_to_input3(wdata, &payload[12], false);
 853         input_sync(wdata->ir);
 854 }
 855
 856 struct wiiproto_handler {
 857         __u8 id;
 858         size_t size;
 859         void (*func)(struct wiimote_data *wdata, const __u8 *payload);
 860 };
 861
 862 static struct wiiproto_handler handlers[] = {
 863         { .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
 864         { .id = WIIPROTO_REQ_DATA, .size = 21, .func = handler_data },
 865         { .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
 866         { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
 867         { .id = WIIPROTO_REQ_DRM_KA, .size = 5, .func = handler_drm_KA },
 868         { .id = WIIPROTO_REQ_DRM_KE, .size = 10, .func = handler_drm_KE },
 869         { .id = WIIPROTO_REQ_DRM_KAI, .size = 17, .func = handler_drm_KAI },
 870         { .id = WIIPROTO_REQ_DRM_KEE, .size = 21, .func = handler_drm_KEE },
 871         { .id = WIIPROTO_REQ_DRM_KAE, .size = 21, .func = handler_drm_KAE },
 872         { .id = WIIPROTO_REQ_DRM_KIE, .size = 21, .func = handler_drm_KIE },
 873         { .id = WIIPROTO_REQ_DRM_KAIE, .size = 21, .func = handler_drm_KAIE },
 874         { .id = WIIPROTO_REQ_DRM_E, .size = 21, .func = handler_drm_E },
 875         { .id = WIIPROTO_REQ_DRM_SKAI1, .size = 21, .func = handler_drm_SKAI1 },
 876         { .id = WIIPROTO_REQ_DRM_SKAI2, .size = 21, .func = handler_drm_SKAI2 },
 877         { .id = 0 }
 878 };
 879
 880 static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
 881                                                         u8 *raw_data, int size)
 882 {
 883         struct wiimote_data *wdata = hid_get_drvdata(hdev);
 884         struct wiiproto_handler *h;
 885         int i;
 886         unsigned long flags;
 887         bool handled = false;
 888
 889         if (size < 1)
 890                 return -EINVAL;
 891
 892         spin_lock_irqsave(&wdata->state.lock, flags);
 893
 894         for (i = 0; handlers[i].id; ++i) {
 895                 h = &handlers[i];
 896                 if (h->id == raw_data[0] && h->size < size) {
 897                         h->func(wdata, &raw_data[1]);
 898                         handled = true;
 899                 }
 900         }
 901
 902         if (!handled)
 903                 hid_warn(hdev, "Unhandled report %hhu size %d\n", raw_data[0],
 904                                                                         size);
 905
 906         spin_unlock_irqrestore(&wdata->state.lock, flags);
 907
 908         return 0;
 909 }
 910
 911 static void wiimote_leds_destroy(struct wiimote_data *wdata)
 912 {
 913         int i;
 914         struct led_classdev *led;
 915
 916         for (i = 0; i < 4; ++i) {
 917                 if (wdata->leds[i]) {
 918                         led = wdata->leds[i];
 919                         wdata->leds[i] = NULL;
 920                         led_classdev_unregister(led);
 921                         kfree(led);
 922                 }
 923         }
 924 }
 925
 926 static int wiimote_leds_create(struct wiimote_data *wdata)
 927 {
 928         int i, ret;
 929         struct device *dev = &wdata->hdev->dev;
 930         size_t namesz = strlen(dev_name(dev)) + 9;
 931         struct led_classdev *led;
 932         char *name;
 933
 934         for (i = 0; i < 4; ++i) {
 935                 led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
 936                 if (!led) {
 937                         ret = -ENOMEM;
 938                         goto err;
 939                 }
 940                 name = (void*)&led[1];
 941                 snprintf(name, namesz, "%s:blue:p%d", dev_name(dev), i);
 942                 led->name = name;
 943                 led->brightness = 0;
 944                 led->max_brightness = 1;
 945                 led->brightness_get = wiimote_leds_get;
 946                 led->brightness_set = wiimote_leds_set;
 947
 948                 ret = led_classdev_register(dev, led);
 949                 if (ret) {
 950                         kfree(led);
 951                         goto err;
 952                 }
 953                 wdata->leds[i] = led;
 954         }
 955
 956         return 0;
 957
 958 err:
 959         wiimote_leds_destroy(wdata);
 960         return ret;
 961 }
 962
 963 static struct wiimote_data *wiimote_create(struct hid_device *hdev)
 964 {
 965         struct wiimote_data *wdata;
 966         int i;
 967
 968         wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
 969         if (!wdata)
 970                 return NULL;
 971
 972         wdata->input = input_allocate_device();
 973         if (!wdata->input)
 974                 goto err;
 975
 976         wdata->hdev = hdev;
 977         hid_set_drvdata(hdev, wdata);
 978
 979         input_set_drvdata(wdata->input, wdata);
 980         wdata->input->open = wiimote_input_open;
 981         wdata->input->close = wiimote_input_close;
 982         wdata->input->dev.parent = &wdata->hdev->dev;
 983         wdata->input->id.bustype = wdata->hdev->bus;
 984         wdata->input->id.vendor = wdata->hdev->vendor;
 985         wdata->input->id.product = wdata->hdev->product;
 986         wdata->input->id.version = wdata->hdev->version;
 987         wdata->input->name = WIIMOTE_NAME;
 988
 989         set_bit(EV_KEY, wdata->input->evbit);
 990         for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
 991                 set_bit(wiiproto_keymap[i], wdata->input->keybit);
 992
 993         set_bit(FF_RUMBLE, wdata->input->ffbit);
 994         if (input_ff_create_memless(wdata->input, NULL, wiimote_ff_play))
 995                 goto err_input;
 996
 997         wdata->accel = input_allocate_device();
 998         if (!wdata->accel)
 999                 goto err_input;
1000
1001         input_set_drvdata(wdata->accel, wdata);
1002         wdata->accel->open = wiimote_accel_open;
1003         wdata->accel->close = wiimote_accel_close;
1004         wdata->accel->dev.parent = &wdata->hdev->dev;
1005         wdata->accel->id.bustype = wdata->hdev->bus;
1006         wdata->accel->id.vendor = wdata->hdev->vendor;
1007         wdata->accel->id.product = wdata->hdev->product;
1008         wdata->accel->id.version = wdata->hdev->version;
1009         wdata->accel->name = WIIMOTE_NAME " Accelerometer";
1010
1011         set_bit(EV_ABS, wdata->accel->evbit);
1012         set_bit(ABS_RX, wdata->accel->absbit);
1013         set_bit(ABS_RY, wdata->accel->absbit);
1014         set_bit(ABS_RZ, wdata->accel->absbit);
1015         input_set_abs_params(wdata->accel, ABS_RX, -500, 500, 2, 4);
1016         input_set_abs_params(wdata->accel, ABS_RY, -500, 500, 2, 4);
1017         input_set_abs_params(wdata->accel, ABS_RZ, -500, 500, 2, 4);
1018
1019         wdata->ir = input_allocate_device();
1020         if (!wdata->ir)
1021                 goto err_ir;
1022
1023         input_set_drvdata(wdata->ir, wdata);
1024         wdata->ir->open = wiimote_ir_open;
1025         wdata->ir->close = wiimote_ir_close;
1026         wdata->ir->dev.parent = &wdata->hdev->dev;
1027         wdata->ir->id.bustype = wdata->hdev->bus;
1028         wdata->ir->id.vendor = wdata->hdev->vendor;
1029         wdata->ir->id.product = wdata->hdev->product;
1030         wdata->ir->id.version = wdata->hdev->version;
1031         wdata->ir->name = WIIMOTE_NAME " IR";
1032
1033         set_bit(EV_ABS, wdata->ir->evbit);
1034         set_bit(ABS_HAT0X, wdata->ir->absbit);
1035         set_bit(ABS_HAT0Y, wdata->ir->absbit);
1036         set_bit(ABS_HAT1X, wdata->ir->absbit);
1037         set_bit(ABS_HAT1Y, wdata->ir->absbit);
1038         set_bit(ABS_HAT2X, wdata->ir->absbit);
1039         set_bit(ABS_HAT2Y, wdata->ir->absbit);
1040         set_bit(ABS_HAT3X, wdata->ir->absbit);
1041         set_bit(ABS_HAT3Y, wdata->ir->absbit);
1042         input_set_abs_params(wdata->ir, ABS_HAT0X, 0, 1023, 2, 4);
1043         input_set_abs_params(wdata->ir, ABS_HAT0Y, 0, 767, 2, 4);
1044         input_set_abs_params(wdata->ir, ABS_HAT1X, 0, 1023, 2, 4);
1045         input_set_abs_params(wdata->ir, ABS_HAT1Y, 0, 767, 2, 4);
1046         input_set_abs_params(wdata->ir, ABS_HAT2X, 0, 1023, 2, 4);
1047         input_set_abs_params(wdata->ir, ABS_HAT2Y, 0, 767, 2, 4);
1048         input_set_abs_params(wdata->ir, ABS_HAT3X, 0, 1023, 2, 4);
1049         input_set_abs_params(wdata->ir, ABS_HAT3Y, 0, 767, 2, 4);
1050
1051         spin_lock_init(&wdata->qlock);
1052         INIT_WORK(&wdata->worker, wiimote_worker);
1053
1054         spin_lock_init(&wdata->state.lock);
1055         init_completion(&wdata->state.ready);
1056         mutex_init(&wdata->state.sync);
1057
1058         return wdata;
1059
1060 err_ir:
1061         input_free_device(wdata->accel);
1062 err_input:
1063         input_free_device(wdata->input);
1064 err:
1065         kfree(wdata);
1066         return NULL;
1067 }
1068
1069 static void wiimote_destroy(struct wiimote_data *wdata)
1070 {
1071         wiimote_leds_destroy(wdata);
1072
1073         power_supply_unregister(&wdata->battery);
1074         input_unregister_device(wdata->accel);
1075         input_unregister_device(wdata->ir);
1076         input_unregister_device(wdata->input);
1077         cancel_work_sync(&wdata->worker);
1078         hid_hw_stop(wdata->hdev);
1079
1080         kfree(wdata);
1081 }
1082
1083 static int wiimote_hid_probe(struct hid_device *hdev,
1084                                 const struct hid_device_id *id)
1085 {
1086         struct wiimote_data *wdata;
1087         int ret;
1088
1089         wdata = wiimote_create(hdev);
1090         if (!wdata) {
1091                 hid_err(hdev, "Can't alloc device\n");
1092                 return -ENOMEM;
1093         }
1094
1095         ret = hid_parse(hdev);
1096         if (ret) {
1097                 hid_err(hdev, "HID parse failed\n");
1098                 goto err;
1099         }
1100
1101         ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1102         if (ret) {
1103                 hid_err(hdev, "HW start failed\n");
1104                 goto err;
1105         }
1106
1107         ret = input_register_device(wdata->accel);
1108         if (ret) {
1109                 hid_err(hdev, "Cannot register input device\n");
1110                 goto err_stop;
1111         }
1112
1113         ret = input_register_device(wdata->ir);
1114         if (ret) {
1115                 hid_err(hdev, "Cannot register input device\n");
1116                 goto err_ir;
1117         }
1118
1119         ret = input_register_device(wdata->input);
1120         if (ret) {
1121                 hid_err(hdev, "Cannot register input device\n");
1122                 goto err_input;
1123         }
1124
1125         wdata->battery.properties = wiimote_battery_props;
1126         wdata->battery.num_properties = ARRAY_SIZE(wiimote_battery_props);
1127         wdata->battery.get_property = wiimote_battery_get_property;
1128         wdata->battery.name = "wiimote_battery";
1129         wdata->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1130         wdata->battery.use_for_apm = 0;
1131
1132         ret = power_supply_register(&wdata->hdev->dev, &wdata->battery);
1133         if (ret) {
1134                 hid_err(hdev, "Cannot register battery device\n");
1135                 goto err_battery;
1136         }
1137
1138         ret = wiimote_leds_create(wdata);
1139         if (ret)
1140                 goto err_free;
1141
1142         hid_info(hdev, "New device registered\n");
1143
1144         /* by default set led1 after device initialization */
1145         spin_lock_irq(&wdata->state.lock);
1146         wiiproto_req_leds(wdata, WIIPROTO_FLAG_LED1);
1147         spin_unlock_irq(&wdata->state.lock);
1148
1149         return 0;
1150
1151 err_free:
1152         wiimote_destroy(wdata);
1153         return ret;
1154
1155 err_battery:
1156         input_unregister_device(wdata->input);
1157         wdata->input = NULL;
1158 err_input:
1159         input_unregister_device(wdata->ir);
1160         wdata->ir = NULL;
1161 err_ir:
1162         input_unregister_device(wdata->accel);
1163         wdata->accel = NULL;
1164 err_stop:
1165         hid_hw_stop(hdev);
1166 err:
1167         input_free_device(wdata->ir);
1168         input_free_device(wdata->accel);
1169         input_free_device(wdata->input);
1170         kfree(wdata);
1171         return ret;
1172 }
1173
1174 static void wiimote_hid_remove(struct hid_device *hdev)
1175 {
1176         struct wiimote_data *wdata = hid_get_drvdata(hdev);
1177
1178         hid_info(hdev, "Device removed\n");
1179         wiimote_destroy(wdata);
1180 }
1181
1182 static const struct hid_device_id wiimote_hid_devices[] = {
1183         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
1184                                 USB_DEVICE_ID_NINTENDO_WIIMOTE) },
1185         { }
1186 };
1187 MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
1188
1189 static struct hid_driver wiimote_hid_driver = {
1190         .name = "wiimote",
1191         .id_table = wiimote_hid_devices,
1192         .probe = wiimote_hid_probe,
1193         .remove = wiimote_hid_remove,
1194         .raw_event = wiimote_hid_event,
1195 };
1196
1197 static int __init wiimote_init(void)
1198 {
1199         int ret;
1200
1201         ret = hid_register_driver(&wiimote_hid_driver);
1202         if (ret)
1203                 pr_err("Can't register wiimote hid driver\n");
1204
1205         return ret;
1206 }
1207
1208 static void __exit wiimote_exit(void)
1209 {
1210         hid_unregister_driver(&wiimote_hid_driver);
1211 }
1212
1213 module_init(wiimote_init);
1214 module_exit(wiimote_exit);
1215 MODULE_LICENSE("GPL");
1216 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
1217 MODULE_DESCRIPTION(WIIMOTE_NAME " Device Driver");
1218 MODULE_VERSION(WIIMOTE_VERSION);