1 /* 2 * HID driver for Nintendo Wii / Wii U peripherals 3 * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com> 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/module.h> 18 #include <linux/mutex.h> 19 #include <linux/spinlock.h> 20 #include "hid-ids.h" 21 #include "hid-wiimote.h" 22 23 /* output queue handling */ 24 25 static int wiimote_hid_send(struct hid_device *hdev, __u8 *buffer, 26 size_t count) 27 { 28 __u8 *buf; 29 int ret; 30 31 if (!hdev->ll_driver->output_report) 32 return -ENODEV; 33 34 buf = kmemdup(buffer, count, GFP_KERNEL); 35 if (!buf) 36 return -ENOMEM; 37 38 ret = hid_hw_output_report(hdev, buf, count); 39 40 kfree(buf); 41 return ret; 42 } 43 44 static void wiimote_queue_worker(struct work_struct *work) 45 { 46 struct wiimote_queue *queue = container_of(work, struct wiimote_queue, 47 worker); 48 struct wiimote_data *wdata = container_of(queue, struct wiimote_data, 49 queue); 50 unsigned long flags; 51 int ret; 52 53 spin_lock_irqsave(&wdata->queue.lock, flags); 54 55 while (wdata->queue.head != wdata->queue.tail) { 56 spin_unlock_irqrestore(&wdata->queue.lock, flags); 57 ret = wiimote_hid_send(wdata->hdev, 58 wdata->queue.outq[wdata->queue.tail].data, 59 wdata->queue.outq[wdata->queue.tail].size); 60 if (ret < 0) { 61 spin_lock_irqsave(&wdata->state.lock, flags); 62 wiimote_cmd_abort(wdata); 63 spin_unlock_irqrestore(&wdata->state.lock, flags); 64 } 65 spin_lock_irqsave(&wdata->queue.lock, flags); 66 67 wdata->queue.tail = (wdata->queue.tail + 1) % WIIMOTE_BUFSIZE; 68 } 69 70 spin_unlock_irqrestore(&wdata->queue.lock, flags); 71 } 72 73 static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer, 74 size_t count) 75 { 76 unsigned long flags; 77 __u8 newhead; 78 79 if (count > HID_MAX_BUFFER_SIZE) { 80 hid_warn(wdata->hdev, "Sending too large output report\n"); 81 82 spin_lock_irqsave(&wdata->queue.lock, flags); 83 goto out_error; 84 } 85 86 /* 87 * Copy new request into our output queue and check whether the 88 * queue is full. If it is full, discard this request. 89 * If it is empty we need to start a new worker that will 90 * send out the buffer to the hid device. 91 * If the queue is not empty, then there must be a worker 92 * that is currently sending out our buffer and this worker 93 * will reschedule itself until the queue is empty. 94 */ 95 96 spin_lock_irqsave(&wdata->queue.lock, flags); 97 98 memcpy(wdata->queue.outq[wdata->queue.head].data, buffer, count); 99 wdata->queue.outq[wdata->queue.head].size = count; 100 newhead = (wdata->queue.head + 1) % WIIMOTE_BUFSIZE; 101 102 if (wdata->queue.head == wdata->queue.tail) { 103 wdata->queue.head = newhead; 104 schedule_work(&wdata->queue.worker); 105 } else if (newhead != wdata->queue.tail) { 106 wdata->queue.head = newhead; 107 } else { 108 hid_warn(wdata->hdev, "Output queue is full"); 109 goto out_error; 110 } 111 112 goto out_unlock; 113 114 out_error: 115 wiimote_cmd_abort(wdata); 116 out_unlock: 117 spin_unlock_irqrestore(&wdata->queue.lock, flags); 118 } 119 120 /* 121 * This sets the rumble bit on the given output report if rumble is 122 * currently enabled. 123 * \cmd1 must point to the second byte in the output report => &cmd[1] 124 * This must be called on nearly every output report before passing it 125 * into the output queue! 126 */ 127 static inline void wiiproto_keep_rumble(struct wiimote_data *wdata, __u8 *cmd1) 128 { 129 if (wdata->state.flags & WIIPROTO_FLAG_RUMBLE) 130 *cmd1 |= 0x01; 131 } 132 133 void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble) 134 { 135 __u8 cmd[2]; 136 137 rumble = !!rumble; 138 if (rumble == !!(wdata->state.flags & WIIPROTO_FLAG_RUMBLE)) 139 return; 140 141 if (rumble) 142 wdata->state.flags |= WIIPROTO_FLAG_RUMBLE; 143 else 144 wdata->state.flags &= ~WIIPROTO_FLAG_RUMBLE; 145 146 cmd[0] = WIIPROTO_REQ_RUMBLE; 147 cmd[1] = 0; 148 149 wiiproto_keep_rumble(wdata, &cmd[1]); 150 wiimote_queue(wdata, cmd, sizeof(cmd)); 151 } 152 153 void wiiproto_req_leds(struct wiimote_data *wdata, int leds) 154 { 155 __u8 cmd[2]; 156 157 leds &= WIIPROTO_FLAGS_LEDS; 158 if ((wdata->state.flags & WIIPROTO_FLAGS_LEDS) == leds) 159 return; 160 wdata->state.flags = (wdata->state.flags & ~WIIPROTO_FLAGS_LEDS) | leds; 161 162 cmd[0] = WIIPROTO_REQ_LED; 163 cmd[1] = 0; 164 165 if (leds & WIIPROTO_FLAG_LED1) 166 cmd[1] |= 0x10; 167 if (leds & WIIPROTO_FLAG_LED2) 168 cmd[1] |= 0x20; 169 if (leds & WIIPROTO_FLAG_LED3) 170 cmd[1] |= 0x40; 171 if (leds & WIIPROTO_FLAG_LED4) 172 cmd[1] |= 0x80; 173 174 wiiproto_keep_rumble(wdata, &cmd[1]); 175 wiimote_queue(wdata, cmd, sizeof(cmd)); 176 } 177 178 /* 179 * Check what peripherals of the wiimote are currently 180 * active and select a proper DRM that supports all of 181 * the requested data inputs. 182 * 183 * Not all combinations are actually supported. The following 184 * combinations work only with limitations: 185 * - IR cam in extended or full mode disables any data transmission 186 * of extension controllers. There is no DRM mode that supports 187 * extension bytes plus extended/full IR. 188 * - IR cam with accelerometer and extension *_EXT8 is not supported. 189 * However, all extensions that need *_EXT8 are devices that don't 190 * support IR cameras. Hence, this shouldn't happen under normal 191 * operation. 192 * - *_EXT16 is only supported in combination with buttons and 193 * accelerometer. No IR or similar can be active simultaneously. As 194 * above, all modules that require it are mutually exclusive with 195 * IR/etc. so this doesn't matter. 196 */ 197 static __u8 select_drm(struct wiimote_data *wdata) 198 { 199 __u8 ir = wdata->state.flags & WIIPROTO_FLAGS_IR; 200 bool ext; 201 202 ext = (wdata->state.flags & WIIPROTO_FLAG_EXT_USED) || 203 (wdata->state.flags & WIIPROTO_FLAG_MP_USED); 204 205 /* some 3rd-party balance-boards are hard-coded to KEE, *sigh* */ 206 if (wdata->state.devtype == WIIMOTE_DEV_BALANCE_BOARD) { 207 if (ext) 208 return WIIPROTO_REQ_DRM_KEE; 209 else 210 return WIIPROTO_REQ_DRM_K; 211 } 212 213 if (ir == WIIPROTO_FLAG_IR_BASIC) { 214 if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) { 215 /* GEN10 and ealier devices bind IR formats to DRMs. 216 * Hence, we cannot use DRM_KAI here as it might be 217 * bound to IR_EXT. Use DRM_KAIE unconditionally so we 218 * work with all devices and our parsers can use the 219 * fixed formats, too. */ 220 return WIIPROTO_REQ_DRM_KAIE; 221 } else { 222 return WIIPROTO_REQ_DRM_KIE; 223 } 224 } else if (ir == WIIPROTO_FLAG_IR_EXT) { 225 return WIIPROTO_REQ_DRM_KAI; 226 } else if (ir == WIIPROTO_FLAG_IR_FULL) { 227 return WIIPROTO_REQ_DRM_SKAI1; 228 } else { 229 if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) { 230 if (ext) 231 return WIIPROTO_REQ_DRM_KAE; 232 else 233 return WIIPROTO_REQ_DRM_KA; 234 } else { 235 if (ext) 236 return WIIPROTO_REQ_DRM_KEE; 237 else 238 return WIIPROTO_REQ_DRM_K; 239 } 240 } 241 } 242 243 void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm) 244 { 245 __u8 cmd[3]; 246 247 if (wdata->state.flags & WIIPROTO_FLAG_DRM_LOCKED) 248 drm = wdata->state.drm; 249 else if (drm == WIIPROTO_REQ_NULL) 250 drm = select_drm(wdata); 251 252 cmd[0] = WIIPROTO_REQ_DRM; 253 cmd[1] = 0; 254 cmd[2] = drm; 255 256 wdata->state.drm = drm; 257 wiiproto_keep_rumble(wdata, &cmd[1]); 258 wiimote_queue(wdata, cmd, sizeof(cmd)); 259 } 260 261 void wiiproto_req_status(struct wiimote_data *wdata) 262 { 263 __u8 cmd[2]; 264 265 cmd[0] = WIIPROTO_REQ_SREQ; 266 cmd[1] = 0; 267 268 wiiproto_keep_rumble(wdata, &cmd[1]); 269 wiimote_queue(wdata, cmd, sizeof(cmd)); 270 } 271 272 void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel) 273 { 274 accel = !!accel; 275 if (accel == !!(wdata->state.flags & WIIPROTO_FLAG_ACCEL)) 276 return; 277 278 if (accel) 279 wdata->state.flags |= WIIPROTO_FLAG_ACCEL; 280 else 281 wdata->state.flags &= ~WIIPROTO_FLAG_ACCEL; 282 283 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 284 } 285 286 void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags) 287 { 288 __u8 cmd[2]; 289 290 cmd[0] = WIIPROTO_REQ_IR1; 291 cmd[1] = flags; 292 293 wiiproto_keep_rumble(wdata, &cmd[1]); 294 wiimote_queue(wdata, cmd, sizeof(cmd)); 295 } 296 297 void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags) 298 { 299 __u8 cmd[2]; 300 301 cmd[0] = WIIPROTO_REQ_IR2; 302 cmd[1] = flags; 303 304 wiiproto_keep_rumble(wdata, &cmd[1]); 305 wiimote_queue(wdata, cmd, sizeof(cmd)); 306 } 307 308 #define wiiproto_req_wreg(wdata, os, buf, sz) \ 309 wiiproto_req_wmem((wdata), false, (os), (buf), (sz)) 310 311 #define wiiproto_req_weeprom(wdata, os, buf, sz) \ 312 wiiproto_req_wmem((wdata), true, (os), (buf), (sz)) 313 314 static void wiiproto_req_wmem(struct wiimote_data *wdata, bool eeprom, 315 __u32 offset, const __u8 *buf, __u8 size) 316 { 317 __u8 cmd[22]; 318 319 if (size > 16 || size == 0) { 320 hid_warn(wdata->hdev, "Invalid length %d wmem request\n", size); 321 return; 322 } 323 324 memset(cmd, 0, sizeof(cmd)); 325 cmd[0] = WIIPROTO_REQ_WMEM; 326 cmd[2] = (offset >> 16) & 0xff; 327 cmd[3] = (offset >> 8) & 0xff; 328 cmd[4] = offset & 0xff; 329 cmd[5] = size; 330 memcpy(&cmd[6], buf, size); 331 332 if (!eeprom) 333 cmd[1] |= 0x04; 334 335 wiiproto_keep_rumble(wdata, &cmd[1]); 336 wiimote_queue(wdata, cmd, sizeof(cmd)); 337 } 338 339 void wiiproto_req_rmem(struct wiimote_data *wdata, bool eeprom, __u32 offset, 340 __u16 size) 341 { 342 __u8 cmd[7]; 343 344 if (size == 0) { 345 hid_warn(wdata->hdev, "Invalid length %d rmem request\n", size); 346 return; 347 } 348 349 cmd[0] = WIIPROTO_REQ_RMEM; 350 cmd[1] = 0; 351 cmd[2] = (offset >> 16) & 0xff; 352 cmd[3] = (offset >> 8) & 0xff; 353 cmd[4] = offset & 0xff; 354 cmd[5] = (size >> 8) & 0xff; 355 cmd[6] = size & 0xff; 356 357 if (!eeprom) 358 cmd[1] |= 0x04; 359 360 wiiproto_keep_rumble(wdata, &cmd[1]); 361 wiimote_queue(wdata, cmd, sizeof(cmd)); 362 } 363 364 /* requries the cmd-mutex to be held */ 365 int wiimote_cmd_write(struct wiimote_data *wdata, __u32 offset, 366 const __u8 *wmem, __u8 size) 367 { 368 unsigned long flags; 369 int ret; 370 371 spin_lock_irqsave(&wdata->state.lock, flags); 372 wiimote_cmd_set(wdata, WIIPROTO_REQ_WMEM, 0); 373 wiiproto_req_wreg(wdata, offset, wmem, size); 374 spin_unlock_irqrestore(&wdata->state.lock, flags); 375 376 ret = wiimote_cmd_wait(wdata); 377 if (!ret && wdata->state.cmd_err) 378 ret = -EIO; 379 380 return ret; 381 } 382 383 /* requries the cmd-mutex to be held */ 384 ssize_t wiimote_cmd_read(struct wiimote_data *wdata, __u32 offset, __u8 *rmem, 385 __u8 size) 386 { 387 unsigned long flags; 388 ssize_t ret; 389 390 spin_lock_irqsave(&wdata->state.lock, flags); 391 wdata->state.cmd_read_size = size; 392 wdata->state.cmd_read_buf = rmem; 393 wiimote_cmd_set(wdata, WIIPROTO_REQ_RMEM, offset & 0xffff); 394 wiiproto_req_rreg(wdata, offset, size); 395 spin_unlock_irqrestore(&wdata->state.lock, flags); 396 397 ret = wiimote_cmd_wait(wdata); 398 399 spin_lock_irqsave(&wdata->state.lock, flags); 400 wdata->state.cmd_read_buf = NULL; 401 spin_unlock_irqrestore(&wdata->state.lock, flags); 402 403 if (!ret) { 404 if (wdata->state.cmd_read_size == 0) 405 ret = -EIO; 406 else 407 ret = wdata->state.cmd_read_size; 408 } 409 410 return ret; 411 } 412 413 /* requires the cmd-mutex to be held */ 414 static int wiimote_cmd_init_ext(struct wiimote_data *wdata) 415 { 416 __u8 wmem; 417 int ret; 418 419 /* initialize extension */ 420 wmem = 0x55; 421 ret = wiimote_cmd_write(wdata, 0xa400f0, &wmem, sizeof(wmem)); 422 if (ret) 423 return ret; 424 425 /* disable default encryption */ 426 wmem = 0x0; 427 ret = wiimote_cmd_write(wdata, 0xa400fb, &wmem, sizeof(wmem)); 428 if (ret) 429 return ret; 430 431 return 0; 432 } 433 434 /* requires the cmd-mutex to be held */ 435 static __u8 wiimote_cmd_read_ext(struct wiimote_data *wdata, __u8 *rmem) 436 { 437 int ret; 438 439 /* read extension ID */ 440 ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6); 441 if (ret != 6) 442 return WIIMOTE_EXT_NONE; 443 444 hid_dbg(wdata->hdev, "extension ID: %6phC\n", rmem); 445 446 if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff && 447 rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff) 448 return WIIMOTE_EXT_NONE; 449 450 if (rmem[4] == 0x00 && rmem[5] == 0x00) 451 return WIIMOTE_EXT_NUNCHUK; 452 if (rmem[4] == 0x01 && rmem[5] == 0x01) 453 return WIIMOTE_EXT_CLASSIC_CONTROLLER; 454 if (rmem[4] == 0x04 && rmem[5] == 0x02) 455 return WIIMOTE_EXT_BALANCE_BOARD; 456 if (rmem[4] == 0x01 && rmem[5] == 0x20) 457 return WIIMOTE_EXT_PRO_CONTROLLER; 458 459 return WIIMOTE_EXT_UNKNOWN; 460 } 461 462 /* requires the cmd-mutex to be held */ 463 static int wiimote_cmd_init_mp(struct wiimote_data *wdata) 464 { 465 __u8 wmem; 466 int ret; 467 468 /* initialize MP */ 469 wmem = 0x55; 470 ret = wiimote_cmd_write(wdata, 0xa600f0, &wmem, sizeof(wmem)); 471 if (ret) 472 return ret; 473 474 /* disable default encryption */ 475 wmem = 0x0; 476 ret = wiimote_cmd_write(wdata, 0xa600fb, &wmem, sizeof(wmem)); 477 if (ret) 478 return ret; 479 480 return 0; 481 } 482 483 /* requires the cmd-mutex to be held */ 484 static bool wiimote_cmd_map_mp(struct wiimote_data *wdata, __u8 exttype) 485 { 486 __u8 wmem; 487 488 /* map MP with correct pass-through mode */ 489 switch (exttype) { 490 case WIIMOTE_EXT_CLASSIC_CONTROLLER: 491 wmem = 0x07; 492 break; 493 case WIIMOTE_EXT_NUNCHUK: 494 wmem = 0x05; 495 break; 496 default: 497 wmem = 0x04; 498 break; 499 } 500 501 return wiimote_cmd_write(wdata, 0xa600fe, &wmem, sizeof(wmem)); 502 } 503 504 /* requires the cmd-mutex to be held */ 505 static bool wiimote_cmd_read_mp(struct wiimote_data *wdata, __u8 *rmem) 506 { 507 int ret; 508 509 /* read motion plus ID */ 510 ret = wiimote_cmd_read(wdata, 0xa600fa, rmem, 6); 511 if (ret != 6) 512 return false; 513 514 hid_dbg(wdata->hdev, "motion plus ID: %6phC\n", rmem); 515 516 if (rmem[5] == 0x05) 517 return true; 518 519 hid_info(wdata->hdev, "unknown motion plus ID: %6phC\n", rmem); 520 521 return false; 522 } 523 524 /* requires the cmd-mutex to be held */ 525 static __u8 wiimote_cmd_read_mp_mapped(struct wiimote_data *wdata) 526 { 527 int ret; 528 __u8 rmem[6]; 529 530 /* read motion plus ID */ 531 ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6); 532 if (ret != 6) 533 return WIIMOTE_MP_NONE; 534 535 hid_dbg(wdata->hdev, "mapped motion plus ID: %6phC\n", rmem); 536 537 if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff && 538 rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff) 539 return WIIMOTE_MP_NONE; 540 541 if (rmem[4] == 0x04 && rmem[5] == 0x05) 542 return WIIMOTE_MP_SINGLE; 543 else if (rmem[4] == 0x05 && rmem[5] == 0x05) 544 return WIIMOTE_MP_PASSTHROUGH_NUNCHUK; 545 else if (rmem[4] == 0x07 && rmem[5] == 0x05) 546 return WIIMOTE_MP_PASSTHROUGH_CLASSIC; 547 548 return WIIMOTE_MP_UNKNOWN; 549 } 550 551 /* device module handling */ 552 553 static const __u8 * const wiimote_devtype_mods[WIIMOTE_DEV_NUM] = { 554 [WIIMOTE_DEV_PENDING] = (const __u8[]){ 555 WIIMOD_NULL, 556 }, 557 [WIIMOTE_DEV_UNKNOWN] = (const __u8[]){ 558 WIIMOD_NO_MP, 559 WIIMOD_NULL, 560 }, 561 [WIIMOTE_DEV_GENERIC] = (const __u8[]){ 562 WIIMOD_KEYS, 563 WIIMOD_RUMBLE, 564 WIIMOD_BATTERY, 565 WIIMOD_LED1, 566 WIIMOD_LED2, 567 WIIMOD_LED3, 568 WIIMOD_LED4, 569 WIIMOD_ACCEL, 570 WIIMOD_IR, 571 WIIMOD_NULL, 572 }, 573 [WIIMOTE_DEV_GEN10] = (const __u8[]){ 574 WIIMOD_KEYS, 575 WIIMOD_RUMBLE, 576 WIIMOD_BATTERY, 577 WIIMOD_LED1, 578 WIIMOD_LED2, 579 WIIMOD_LED3, 580 WIIMOD_LED4, 581 WIIMOD_ACCEL, 582 WIIMOD_IR, 583 WIIMOD_NULL, 584 }, 585 [WIIMOTE_DEV_GEN20] = (const __u8[]){ 586 WIIMOD_KEYS, 587 WIIMOD_RUMBLE, 588 WIIMOD_BATTERY, 589 WIIMOD_LED1, 590 WIIMOD_LED2, 591 WIIMOD_LED3, 592 WIIMOD_LED4, 593 WIIMOD_ACCEL, 594 WIIMOD_IR, 595 WIIMOD_BUILTIN_MP, 596 WIIMOD_NULL, 597 }, 598 [WIIMOTE_DEV_BALANCE_BOARD] = (const __u8[]) { 599 WIIMOD_BATTERY, 600 WIIMOD_LED1, 601 WIIMOD_NO_MP, 602 WIIMOD_NULL, 603 }, 604 [WIIMOTE_DEV_PRO_CONTROLLER] = (const __u8[]) { 605 WIIMOD_BATTERY, 606 WIIMOD_LED1, 607 WIIMOD_LED2, 608 WIIMOD_LED3, 609 WIIMOD_LED4, 610 WIIMOD_NO_MP, 611 WIIMOD_NULL, 612 }, 613 }; 614 615 static void wiimote_modules_load(struct wiimote_data *wdata, 616 unsigned int devtype) 617 { 618 bool need_input = false; 619 const __u8 *mods, *iter; 620 const struct wiimod_ops *ops; 621 int ret; 622 623 mods = wiimote_devtype_mods[devtype]; 624 625 for (iter = mods; *iter != WIIMOD_NULL; ++iter) { 626 if (wiimod_table[*iter]->flags & WIIMOD_FLAG_INPUT) { 627 need_input = true; 628 break; 629 } 630 } 631 632 if (need_input) { 633 wdata->input = input_allocate_device(); 634 if (!wdata->input) 635 return; 636 637 input_set_drvdata(wdata->input, wdata); 638 wdata->input->dev.parent = &wdata->hdev->dev; 639 wdata->input->id.bustype = wdata->hdev->bus; 640 wdata->input->id.vendor = wdata->hdev->vendor; 641 wdata->input->id.product = wdata->hdev->product; 642 wdata->input->id.version = wdata->hdev->version; 643 wdata->input->name = WIIMOTE_NAME; 644 } 645 646 for (iter = mods; *iter != WIIMOD_NULL; ++iter) { 647 ops = wiimod_table[*iter]; 648 if (!ops->probe) 649 continue; 650 651 ret = ops->probe(ops, wdata); 652 if (ret) 653 goto error; 654 } 655 656 if (wdata->input) { 657 ret = input_register_device(wdata->input); 658 if (ret) 659 goto error; 660 } 661 662 spin_lock_irq(&wdata->state.lock); 663 wdata->state.devtype = devtype; 664 spin_unlock_irq(&wdata->state.lock); 665 return; 666 667 error: 668 for ( ; iter-- != mods; ) { 669 ops = wiimod_table[*iter]; 670 if (ops->remove) 671 ops->remove(ops, wdata); 672 } 673 674 if (wdata->input) { 675 input_free_device(wdata->input); 676 wdata->input = NULL; 677 } 678 } 679 680 static void wiimote_modules_unload(struct wiimote_data *wdata) 681 { 682 const __u8 *mods, *iter; 683 const struct wiimod_ops *ops; 684 unsigned long flags; 685 686 mods = wiimote_devtype_mods[wdata->state.devtype]; 687 688 spin_lock_irqsave(&wdata->state.lock, flags); 689 wdata->state.devtype = WIIMOTE_DEV_UNKNOWN; 690 spin_unlock_irqrestore(&wdata->state.lock, flags); 691 692 /* find end of list */ 693 for (iter = mods; *iter != WIIMOD_NULL; ++iter) 694 /* empty */ ; 695 696 if (wdata->input) { 697 input_get_device(wdata->input); 698 input_unregister_device(wdata->input); 699 } 700 701 for ( ; iter-- != mods; ) { 702 ops = wiimod_table[*iter]; 703 if (ops->remove) 704 ops->remove(ops, wdata); 705 } 706 707 if (wdata->input) { 708 input_put_device(wdata->input); 709 wdata->input = NULL; 710 } 711 } 712 713 /* device extension handling */ 714 715 static void wiimote_ext_load(struct wiimote_data *wdata, unsigned int ext) 716 { 717 unsigned long flags; 718 const struct wiimod_ops *ops; 719 int ret; 720 721 ops = wiimod_ext_table[ext]; 722 723 if (ops->probe) { 724 ret = ops->probe(ops, wdata); 725 if (ret) 726 ext = WIIMOTE_EXT_UNKNOWN; 727 } 728 729 spin_lock_irqsave(&wdata->state.lock, flags); 730 wdata->state.exttype = ext; 731 spin_unlock_irqrestore(&wdata->state.lock, flags); 732 } 733 734 static void wiimote_ext_unload(struct wiimote_data *wdata) 735 { 736 unsigned long flags; 737 const struct wiimod_ops *ops; 738 739 ops = wiimod_ext_table[wdata->state.exttype]; 740 741 spin_lock_irqsave(&wdata->state.lock, flags); 742 wdata->state.exttype = WIIMOTE_EXT_UNKNOWN; 743 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 744 spin_unlock_irqrestore(&wdata->state.lock, flags); 745 746 if (ops->remove) 747 ops->remove(ops, wdata); 748 } 749 750 static void wiimote_mp_load(struct wiimote_data *wdata) 751 { 752 unsigned long flags; 753 const struct wiimod_ops *ops; 754 int ret; 755 __u8 mode = 2; 756 757 ops = &wiimod_mp; 758 if (ops->probe) { 759 ret = ops->probe(ops, wdata); 760 if (ret) 761 mode = 1; 762 } 763 764 spin_lock_irqsave(&wdata->state.lock, flags); 765 wdata->state.mp = mode; 766 spin_unlock_irqrestore(&wdata->state.lock, flags); 767 } 768 769 static void wiimote_mp_unload(struct wiimote_data *wdata) 770 { 771 unsigned long flags; 772 const struct wiimod_ops *ops; 773 774 if (wdata->state.mp < 2) 775 return; 776 777 ops = &wiimod_mp; 778 779 spin_lock_irqsave(&wdata->state.lock, flags); 780 wdata->state.mp = 0; 781 wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED; 782 spin_unlock_irqrestore(&wdata->state.lock, flags); 783 784 if (ops->remove) 785 ops->remove(ops, wdata); 786 } 787 788 /* device (re-)initialization and detection */ 789 790 static const char *wiimote_devtype_names[WIIMOTE_DEV_NUM] = { 791 [WIIMOTE_DEV_PENDING] = "Pending", 792 [WIIMOTE_DEV_UNKNOWN] = "Unknown", 793 [WIIMOTE_DEV_GENERIC] = "Generic", 794 [WIIMOTE_DEV_GEN10] = "Nintendo Wii Remote (Gen 1)", 795 [WIIMOTE_DEV_GEN20] = "Nintendo Wii Remote Plus (Gen 2)", 796 [WIIMOTE_DEV_BALANCE_BOARD] = "Nintendo Wii Balance Board", 797 [WIIMOTE_DEV_PRO_CONTROLLER] = "Nintendo Wii U Pro Controller", 798 }; 799 800 /* Try to guess the device type based on all collected information. We 801 * first try to detect by static extension types, then VID/PID and the 802 * device name. If we cannot detect the device, we use 803 * WIIMOTE_DEV_GENERIC so all modules will get probed on the device. */ 804 static void wiimote_init_set_type(struct wiimote_data *wdata, 805 __u8 exttype) 806 { 807 __u8 devtype = WIIMOTE_DEV_GENERIC; 808 __u16 vendor, product; 809 const char *name; 810 811 vendor = wdata->hdev->vendor; 812 product = wdata->hdev->product; 813 name = wdata->hdev->name; 814 815 if (exttype == WIIMOTE_EXT_BALANCE_BOARD) { 816 devtype = WIIMOTE_DEV_BALANCE_BOARD; 817 goto done; 818 } else if (exttype == WIIMOTE_EXT_PRO_CONTROLLER) { 819 devtype = WIIMOTE_DEV_PRO_CONTROLLER; 820 goto done; 821 } 822 823 if (!strcmp(name, "Nintendo RVL-CNT-01")) { 824 devtype = WIIMOTE_DEV_GEN10; 825 goto done; 826 } else if (!strcmp(name, "Nintendo RVL-CNT-01-TR")) { 827 devtype = WIIMOTE_DEV_GEN20; 828 goto done; 829 } else if (!strcmp(name, "Nintendo RVL-WBC-01")) { 830 devtype = WIIMOTE_DEV_BALANCE_BOARD; 831 goto done; 832 } else if (!strcmp(name, "Nintendo RVL-CNT-01-UC")) { 833 devtype = WIIMOTE_DEV_PRO_CONTROLLER; 834 goto done; 835 } 836 837 if (vendor == USB_VENDOR_ID_NINTENDO) { 838 if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE) { 839 devtype = WIIMOTE_DEV_GEN10; 840 goto done; 841 } else if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE2) { 842 devtype = WIIMOTE_DEV_GEN20; 843 goto done; 844 } 845 } 846 847 done: 848 if (devtype == WIIMOTE_DEV_GENERIC) 849 hid_info(wdata->hdev, "cannot detect device; NAME: %s VID: %04x PID: %04x EXT: %04x\n", 850 name, vendor, product, exttype); 851 else 852 hid_info(wdata->hdev, "detected device: %s\n", 853 wiimote_devtype_names[devtype]); 854 855 wiimote_modules_load(wdata, devtype); 856 } 857 858 static void wiimote_init_detect(struct wiimote_data *wdata) 859 { 860 __u8 exttype = WIIMOTE_EXT_NONE, extdata[6]; 861 bool ext; 862 int ret; 863 864 wiimote_cmd_acquire_noint(wdata); 865 866 spin_lock_irq(&wdata->state.lock); 867 wdata->state.devtype = WIIMOTE_DEV_UNKNOWN; 868 wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0); 869 wiiproto_req_status(wdata); 870 spin_unlock_irq(&wdata->state.lock); 871 872 ret = wiimote_cmd_wait_noint(wdata); 873 if (ret) 874 goto out_release; 875 876 spin_lock_irq(&wdata->state.lock); 877 ext = wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED; 878 spin_unlock_irq(&wdata->state.lock); 879 880 if (!ext) 881 goto out_release; 882 883 wiimote_cmd_init_ext(wdata); 884 exttype = wiimote_cmd_read_ext(wdata, extdata); 885 886 out_release: 887 wiimote_cmd_release(wdata); 888 wiimote_init_set_type(wdata, exttype); 889 890 /* schedule MP timer */ 891 spin_lock_irq(&wdata->state.lock); 892 if (!(wdata->state.flags & WIIPROTO_FLAG_BUILTIN_MP) && 893 !(wdata->state.flags & WIIPROTO_FLAG_NO_MP)) 894 mod_timer(&wdata->timer, jiffies + HZ * 4); 895 spin_unlock_irq(&wdata->state.lock); 896 } 897 898 /* 899 * MP hotplug events are not generated by the wiimote. Therefore, we need 900 * polling to detect it. We use a 4s interval for polling MP registers. This 901 * seems reasonable considering applications can trigger it manually via 902 * sysfs requests. 903 */ 904 static void wiimote_init_poll_mp(struct wiimote_data *wdata) 905 { 906 bool mp; 907 __u8 mpdata[6]; 908 909 wiimote_cmd_acquire_noint(wdata); 910 wiimote_cmd_init_mp(wdata); 911 mp = wiimote_cmd_read_mp(wdata, mpdata); 912 wiimote_cmd_release(wdata); 913 914 /* load/unload MP module if it changed */ 915 if (mp) { 916 if (!wdata->state.mp) { 917 hid_info(wdata->hdev, "detected extension: Nintendo Wii Motion Plus\n"); 918 wiimote_mp_load(wdata); 919 } 920 } else if (wdata->state.mp) { 921 wiimote_mp_unload(wdata); 922 } 923 924 mod_timer(&wdata->timer, jiffies + HZ * 4); 925 } 926 927 /* 928 * Check whether the wiimote is in the expected state. The extension registers 929 * may change during hotplug and initialization so we might get hotplug events 930 * that we caused by remapping some memory. 931 * We use some heuristics here to check known states. If the wiimote is in the 932 * expected state, we can ignore the hotplug event. 933 * 934 * Returns "true" if the device is in expected state, "false" if we should 935 * redo hotplug handling and extension initialization. 936 */ 937 static bool wiimote_init_check(struct wiimote_data *wdata) 938 { 939 __u32 flags; 940 __u8 type, data[6]; 941 bool ret, poll_mp; 942 943 spin_lock_irq(&wdata->state.lock); 944 flags = wdata->state.flags; 945 spin_unlock_irq(&wdata->state.lock); 946 947 wiimote_cmd_acquire_noint(wdata); 948 949 /* If MP is used and active, but the extension is not, we expect: 950 * read_mp_mapped() == WIIMOTE_MP_SINGLE 951 * state.flags == !EXT_ACTIVE && !MP_PLUGGED && MP_ACTIVE 952 * We do not check EXT_PLUGGED because it might change during 953 * initialization of MP without extensions. 954 * - If MP is unplugged/replugged, read_mp_mapped() fails 955 * - If EXT is plugged, MP_PLUGGED will get set */ 956 if (wdata->state.exttype == WIIMOTE_EXT_NONE && 957 wdata->state.mp > 0 && (flags & WIIPROTO_FLAG_MP_USED)) { 958 type = wiimote_cmd_read_mp_mapped(wdata); 959 ret = type == WIIMOTE_MP_SINGLE; 960 961 spin_lock_irq(&wdata->state.lock); 962 ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE); 963 ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED); 964 ret = ret && (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE); 965 spin_unlock_irq(&wdata->state.lock); 966 967 if (!ret) 968 hid_dbg(wdata->hdev, "state left: !EXT && MP\n"); 969 970 /* while MP is mapped, we get EXT_PLUGGED events */ 971 poll_mp = false; 972 973 goto out_release; 974 } 975 976 /* If MP is unused, but the extension port is used, we expect: 977 * read_ext == state.exttype 978 * state.flags == !MP_ACTIVE && EXT_ACTIVE 979 * - If MP is plugged/unplugged, our timer detects it 980 * - If EXT is unplugged/replugged, EXT_ACTIVE will become unset */ 981 if (!(flags & WIIPROTO_FLAG_MP_USED) && 982 wdata->state.exttype != WIIMOTE_EXT_NONE) { 983 type = wiimote_cmd_read_ext(wdata, data); 984 ret = type == wdata->state.exttype; 985 986 spin_lock_irq(&wdata->state.lock); 987 ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE); 988 ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE); 989 spin_unlock_irq(&wdata->state.lock); 990 991 if (!ret) 992 hid_dbg(wdata->hdev, "state left: EXT && !MP\n"); 993 994 /* poll MP for hotplug events */ 995 poll_mp = true; 996 997 goto out_release; 998 } 999 1000 /* If neither MP nor an extension are used, we expect: 1001 * read_ext() == WIIMOTE_EXT_NONE 1002 * state.flags == !MP_ACTIVE && !EXT_ACTIVE && !EXT_PLUGGED 1003 * No need to perform any action in this case as everything is 1004 * disabled already. 1005 * - If MP is plugged/unplugged, our timer detects it 1006 * - If EXT is plugged, EXT_PLUGGED will be set */ 1007 if (!(flags & WIIPROTO_FLAG_MP_USED) && 1008 wdata->state.exttype == WIIMOTE_EXT_NONE) { 1009 type = wiimote_cmd_read_ext(wdata, data); 1010 ret = type == wdata->state.exttype; 1011 1012 spin_lock_irq(&wdata->state.lock); 1013 ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE); 1014 ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE); 1015 ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED); 1016 spin_unlock_irq(&wdata->state.lock); 1017 1018 if (!ret) 1019 hid_dbg(wdata->hdev, "state left: !EXT && !MP\n"); 1020 1021 /* poll MP for hotplug events */ 1022 poll_mp = true; 1023 1024 goto out_release; 1025 } 1026 1027 /* The trickiest part is if both EXT and MP are active. We cannot read 1028 * the EXT ID, anymore, because MP is mapped over it. However, we use 1029 * a handy trick here: 1030 * - EXT_ACTIVE is unset whenever !MP_PLUGGED is sent 1031 * MP_PLUGGED might be re-sent again before we are scheduled, but 1032 * EXT_ACTIVE will stay unset. 1033 * So it is enough to check for mp_mapped() and MP_ACTIVE and 1034 * EXT_ACTIVE. EXT_PLUGGED is a sanity check. */ 1035 if (wdata->state.exttype != WIIMOTE_EXT_NONE && 1036 wdata->state.mp > 0 && (flags & WIIPROTO_FLAG_MP_USED)) { 1037 type = wiimote_cmd_read_mp_mapped(wdata); 1038 ret = type != WIIMOTE_MP_NONE; 1039 ret = ret && type != WIIMOTE_MP_UNKNOWN; 1040 ret = ret && type != WIIMOTE_MP_SINGLE; 1041 1042 spin_lock_irq(&wdata->state.lock); 1043 ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED); 1044 ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE); 1045 ret = ret && (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE); 1046 spin_unlock_irq(&wdata->state.lock); 1047 1048 if (!ret) 1049 hid_dbg(wdata->hdev, "state left: EXT && MP\n"); 1050 1051 /* while MP is mapped, we get EXT_PLUGGED events */ 1052 poll_mp = false; 1053 1054 goto out_release; 1055 } 1056 1057 /* unknown state */ 1058 ret = false; 1059 1060 out_release: 1061 wiimote_cmd_release(wdata); 1062 1063 /* only poll for MP if requested and if state didn't change */ 1064 if (ret && poll_mp && !(flags & WIIPROTO_FLAG_BUILTIN_MP) && 1065 !(flags & WIIPROTO_FLAG_NO_MP)) 1066 wiimote_init_poll_mp(wdata); 1067 1068 return ret; 1069 } 1070 1071 static const char *wiimote_exttype_names[WIIMOTE_EXT_NUM] = { 1072 [WIIMOTE_EXT_NONE] = "None", 1073 [WIIMOTE_EXT_UNKNOWN] = "Unknown", 1074 [WIIMOTE_EXT_NUNCHUK] = "Nintendo Wii Nunchuk", 1075 [WIIMOTE_EXT_CLASSIC_CONTROLLER] = "Nintendo Wii Classic Controller", 1076 [WIIMOTE_EXT_BALANCE_BOARD] = "Nintendo Wii Balance Board", 1077 [WIIMOTE_EXT_PRO_CONTROLLER] = "Nintendo Wii U Pro Controller", 1078 }; 1079 1080 /* 1081 * Handle hotplug events 1082 * If we receive an hotplug event and the device-check failed, we deinitialize 1083 * the extension ports, re-read all extension IDs and set the device into 1084 * the desired state. This involves mapping MP into the main extension 1085 * registers, setting up extension passthrough modes and initializing the 1086 * requested extensions. 1087 */ 1088 static void wiimote_init_hotplug(struct wiimote_data *wdata) 1089 { 1090 __u8 exttype, extdata[6], mpdata[6]; 1091 __u32 flags; 1092 bool mp; 1093 1094 hid_dbg(wdata->hdev, "detect extensions..\n"); 1095 1096 wiimote_cmd_acquire_noint(wdata); 1097 1098 spin_lock_irq(&wdata->state.lock); 1099 1100 /* get state snapshot that we will then work on */ 1101 flags = wdata->state.flags; 1102 1103 /* disable event forwarding temporarily */ 1104 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE; 1105 wdata->state.flags &= ~WIIPROTO_FLAG_MP_ACTIVE; 1106 1107 spin_unlock_irq(&wdata->state.lock); 1108 1109 /* init extension and MP (deactivates current extension or MP) */ 1110 wiimote_cmd_init_ext(wdata); 1111 if (flags & WIIPROTO_FLAG_NO_MP) { 1112 mp = false; 1113 } else { 1114 wiimote_cmd_init_mp(wdata); 1115 mp = wiimote_cmd_read_mp(wdata, mpdata); 1116 } 1117 exttype = wiimote_cmd_read_ext(wdata, extdata); 1118 1119 wiimote_cmd_release(wdata); 1120 1121 /* load/unload extension module if it changed */ 1122 if (exttype != wdata->state.exttype) { 1123 /* unload previous extension */ 1124 wiimote_ext_unload(wdata); 1125 1126 if (exttype == WIIMOTE_EXT_UNKNOWN) { 1127 hid_info(wdata->hdev, "cannot detect extension; %6phC\n", 1128 extdata); 1129 } else if (exttype == WIIMOTE_EXT_NONE) { 1130 spin_lock_irq(&wdata->state.lock); 1131 wdata->state.exttype = WIIMOTE_EXT_NONE; 1132 spin_unlock_irq(&wdata->state.lock); 1133 } else { 1134 hid_info(wdata->hdev, "detected extension: %s\n", 1135 wiimote_exttype_names[exttype]); 1136 /* try loading new extension */ 1137 wiimote_ext_load(wdata, exttype); 1138 } 1139 } 1140 1141 /* load/unload MP module if it changed */ 1142 if (mp) { 1143 if (!wdata->state.mp) { 1144 hid_info(wdata->hdev, "detected extension: Nintendo Wii Motion Plus\n"); 1145 wiimote_mp_load(wdata); 1146 } 1147 } else if (wdata->state.mp) { 1148 wiimote_mp_unload(wdata); 1149 } 1150 1151 /* if MP is not used, do not map or activate it */ 1152 if (!(flags & WIIPROTO_FLAG_MP_USED)) 1153 mp = false; 1154 1155 /* map MP into main extension registers if used */ 1156 if (mp) { 1157 wiimote_cmd_acquire_noint(wdata); 1158 wiimote_cmd_map_mp(wdata, exttype); 1159 wiimote_cmd_release(wdata); 1160 1161 /* delete MP hotplug timer */ 1162 del_timer_sync(&wdata->timer); 1163 } else { 1164 /* reschedule MP hotplug timer */ 1165 if (!(flags & WIIPROTO_FLAG_BUILTIN_MP) && 1166 !(flags & WIIPROTO_FLAG_NO_MP)) 1167 mod_timer(&wdata->timer, jiffies + HZ * 4); 1168 } 1169 1170 spin_lock_irq(&wdata->state.lock); 1171 1172 /* enable data forwarding again and set expected hotplug state */ 1173 if (mp) { 1174 wdata->state.flags |= WIIPROTO_FLAG_MP_ACTIVE; 1175 if (wdata->state.exttype == WIIMOTE_EXT_NONE) { 1176 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED; 1177 wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED; 1178 } else { 1179 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED; 1180 wdata->state.flags |= WIIPROTO_FLAG_MP_PLUGGED; 1181 wdata->state.flags |= WIIPROTO_FLAG_EXT_ACTIVE; 1182 } 1183 } else if (wdata->state.exttype != WIIMOTE_EXT_NONE) { 1184 wdata->state.flags |= WIIPROTO_FLAG_EXT_ACTIVE; 1185 } 1186 1187 /* request status report for hotplug state updates */ 1188 wiiproto_req_status(wdata); 1189 1190 spin_unlock_irq(&wdata->state.lock); 1191 1192 hid_dbg(wdata->hdev, "detected extensions: MP: %d EXT: %d\n", 1193 wdata->state.mp, wdata->state.exttype); 1194 } 1195 1196 static void wiimote_init_worker(struct work_struct *work) 1197 { 1198 struct wiimote_data *wdata = container_of(work, struct wiimote_data, 1199 init_worker); 1200 bool changed = false; 1201 1202 if (wdata->state.devtype == WIIMOTE_DEV_PENDING) { 1203 wiimote_init_detect(wdata); 1204 changed = true; 1205 } 1206 1207 if (changed || !wiimote_init_check(wdata)) 1208 wiimote_init_hotplug(wdata); 1209 1210 if (changed) 1211 kobject_uevent(&wdata->hdev->dev.kobj, KOBJ_CHANGE); 1212 } 1213 1214 void __wiimote_schedule(struct wiimote_data *wdata) 1215 { 1216 if (!(wdata->state.flags & WIIPROTO_FLAG_EXITING)) 1217 schedule_work(&wdata->init_worker); 1218 } 1219 1220 static void wiimote_schedule(struct wiimote_data *wdata) 1221 { 1222 unsigned long flags; 1223 1224 spin_lock_irqsave(&wdata->state.lock, flags); 1225 __wiimote_schedule(wdata); 1226 spin_unlock_irqrestore(&wdata->state.lock, flags); 1227 } 1228 1229 static void wiimote_init_timeout(struct timer_list *t) 1230 { 1231 struct wiimote_data *wdata = from_timer(wdata, t, timer); 1232 1233 wiimote_schedule(wdata); 1234 } 1235 1236 /* protocol handlers */ 1237 1238 static void handler_keys(struct wiimote_data *wdata, const __u8 *payload) 1239 { 1240 const __u8 *iter, *mods; 1241 const struct wiimod_ops *ops; 1242 1243 ops = wiimod_ext_table[wdata->state.exttype]; 1244 if (ops->in_keys) { 1245 ops->in_keys(wdata, payload); 1246 return; 1247 } 1248 1249 mods = wiimote_devtype_mods[wdata->state.devtype]; 1250 for (iter = mods; *iter != WIIMOD_NULL; ++iter) { 1251 ops = wiimod_table[*iter]; 1252 if (ops->in_keys) { 1253 ops->in_keys(wdata, payload); 1254 break; 1255 } 1256 } 1257 } 1258 1259 static void handler_accel(struct wiimote_data *wdata, const __u8 *payload) 1260 { 1261 const __u8 *iter, *mods; 1262 const struct wiimod_ops *ops; 1263 1264 ops = wiimod_ext_table[wdata->state.exttype]; 1265 if (ops->in_accel) { 1266 ops->in_accel(wdata, payload); 1267 return; 1268 } 1269 1270 mods = wiimote_devtype_mods[wdata->state.devtype]; 1271 for (iter = mods; *iter != WIIMOD_NULL; ++iter) { 1272 ops = wiimod_table[*iter]; 1273 if (ops->in_accel) { 1274 ops->in_accel(wdata, payload); 1275 break; 1276 } 1277 } 1278 } 1279 1280 static bool valid_ext_handler(const struct wiimod_ops *ops, size_t len) 1281 { 1282 if (!ops->in_ext) 1283 return false; 1284 if ((ops->flags & WIIMOD_FLAG_EXT8) && len < 8) 1285 return false; 1286 if ((ops->flags & WIIMOD_FLAG_EXT16) && len < 16) 1287 return false; 1288 1289 return true; 1290 } 1291 1292 static void handler_ext(struct wiimote_data *wdata, const __u8 *payload, 1293 size_t len) 1294 { 1295 static const __u8 invalid[21] = { 0xff, 0xff, 0xff, 0xff, 1296 0xff, 0xff, 0xff, 0xff, 1297 0xff, 0xff, 0xff, 0xff, 1298 0xff, 0xff, 0xff, 0xff, 1299 0xff, 0xff, 0xff, 0xff, 1300 0xff }; 1301 const __u8 *iter, *mods; 1302 const struct wiimod_ops *ops; 1303 bool is_mp; 1304 1305 if (len > 21) 1306 len = 21; 1307 if (len < 6 || !memcmp(payload, invalid, len)) 1308 return; 1309 1310 /* if MP is active, track MP slot hotplugging */ 1311 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 1312 /* this bit is set for invalid events (eg. during hotplug) */ 1313 if (payload[5] & 0x01) 1314 return; 1315 1316 if (payload[4] & 0x01) { 1317 if (!(wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED)) { 1318 hid_dbg(wdata->hdev, "MP hotplug: 1\n"); 1319 wdata->state.flags |= WIIPROTO_FLAG_MP_PLUGGED; 1320 __wiimote_schedule(wdata); 1321 } 1322 } else { 1323 if (wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED) { 1324 hid_dbg(wdata->hdev, "MP hotplug: 0\n"); 1325 wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED; 1326 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE; 1327 __wiimote_schedule(wdata); 1328 } 1329 } 1330 1331 /* detect MP data that is sent interleaved with EXT data */ 1332 is_mp = payload[5] & 0x02; 1333 } else { 1334 is_mp = false; 1335 } 1336 1337 /* ignore EXT events if no extension is active */ 1338 if (!(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE) && !is_mp) 1339 return; 1340 1341 /* try forwarding to extension handler, first */ 1342 ops = wiimod_ext_table[wdata->state.exttype]; 1343 if (is_mp && ops->in_mp) { 1344 ops->in_mp(wdata, payload); 1345 return; 1346 } else if (!is_mp && valid_ext_handler(ops, len)) { 1347 ops->in_ext(wdata, payload); 1348 return; 1349 } 1350 1351 /* try forwarding to MP handler */ 1352 ops = &wiimod_mp; 1353 if (is_mp && ops->in_mp) { 1354 ops->in_mp(wdata, payload); 1355 return; 1356 } else if (!is_mp && valid_ext_handler(ops, len)) { 1357 ops->in_ext(wdata, payload); 1358 return; 1359 } 1360 1361 /* try forwarding to loaded modules */ 1362 mods = wiimote_devtype_mods[wdata->state.devtype]; 1363 for (iter = mods; *iter != WIIMOD_NULL; ++iter) { 1364 ops = wiimod_table[*iter]; 1365 if (is_mp && ops->in_mp) { 1366 ops->in_mp(wdata, payload); 1367 return; 1368 } else if (!is_mp && valid_ext_handler(ops, len)) { 1369 ops->in_ext(wdata, payload); 1370 return; 1371 } 1372 } 1373 } 1374 1375 #define ir_to_input0(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 0) 1376 #define ir_to_input1(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 1) 1377 #define ir_to_input2(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 2) 1378 #define ir_to_input3(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 3) 1379 1380 static void handler_ir(struct wiimote_data *wdata, const __u8 *payload, 1381 bool packed, unsigned int id) 1382 { 1383 const __u8 *iter, *mods; 1384 const struct wiimod_ops *ops; 1385 1386 ops = wiimod_ext_table[wdata->state.exttype]; 1387 if (ops->in_ir) { 1388 ops->in_ir(wdata, payload, packed, id); 1389 return; 1390 } 1391 1392 mods = wiimote_devtype_mods[wdata->state.devtype]; 1393 for (iter = mods; *iter != WIIMOD_NULL; ++iter) { 1394 ops = wiimod_table[*iter]; 1395 if (ops->in_ir) { 1396 ops->in_ir(wdata, payload, packed, id); 1397 break; 1398 } 1399 } 1400 } 1401 1402 /* reduced status report with "BB BB" key data only */ 1403 static void handler_status_K(struct wiimote_data *wdata, 1404 const __u8 *payload) 1405 { 1406 handler_keys(wdata, payload); 1407 1408 /* on status reports the drm is reset so we need to resend the drm */ 1409 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1410 } 1411 1412 /* extended status report with "BB BB LF 00 00 VV" data */ 1413 static void handler_status(struct wiimote_data *wdata, const __u8 *payload) 1414 { 1415 handler_status_K(wdata, payload); 1416 1417 /* update extension status */ 1418 if (payload[2] & 0x02) { 1419 if (!(wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED)) { 1420 hid_dbg(wdata->hdev, "EXT hotplug: 1\n"); 1421 wdata->state.flags |= WIIPROTO_FLAG_EXT_PLUGGED; 1422 __wiimote_schedule(wdata); 1423 } 1424 } else { 1425 if (wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED) { 1426 hid_dbg(wdata->hdev, "EXT hotplug: 0\n"); 1427 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED; 1428 wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED; 1429 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE; 1430 wdata->state.flags &= ~WIIPROTO_FLAG_MP_ACTIVE; 1431 __wiimote_schedule(wdata); 1432 } 1433 } 1434 1435 wdata->state.cmd_battery = payload[5]; 1436 if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_SREQ, 0)) 1437 wiimote_cmd_complete(wdata); 1438 } 1439 1440 /* reduced generic report with "BB BB" key data only */ 1441 static void handler_generic_K(struct wiimote_data *wdata, const __u8 *payload) 1442 { 1443 handler_keys(wdata, payload); 1444 } 1445 1446 static void handler_data(struct wiimote_data *wdata, const __u8 *payload) 1447 { 1448 __u16 offset = payload[3] << 8 | payload[4]; 1449 __u8 size = (payload[2] >> 4) + 1; 1450 __u8 err = payload[2] & 0x0f; 1451 1452 handler_keys(wdata, payload); 1453 1454 if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_RMEM, offset)) { 1455 if (err) 1456 size = 0; 1457 else if (size > wdata->state.cmd_read_size) 1458 size = wdata->state.cmd_read_size; 1459 1460 wdata->state.cmd_read_size = size; 1461 if (wdata->state.cmd_read_buf) 1462 memcpy(wdata->state.cmd_read_buf, &payload[5], size); 1463 wiimote_cmd_complete(wdata); 1464 } 1465 } 1466 1467 static void handler_return(struct wiimote_data *wdata, const __u8 *payload) 1468 { 1469 __u8 err = payload[3]; 1470 __u8 cmd = payload[2]; 1471 1472 handler_keys(wdata, payload); 1473 1474 if (wiimote_cmd_pending(wdata, cmd, 0)) { 1475 wdata->state.cmd_err = err; 1476 wiimote_cmd_complete(wdata); 1477 } else if (err) { 1478 hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err, 1479 cmd); 1480 } 1481 } 1482 1483 static void handler_drm_KA(struct wiimote_data *wdata, const __u8 *payload) 1484 { 1485 handler_keys(wdata, payload); 1486 handler_accel(wdata, payload); 1487 } 1488 1489 static void handler_drm_KE(struct wiimote_data *wdata, const __u8 *payload) 1490 { 1491 handler_keys(wdata, payload); 1492 handler_ext(wdata, &payload[2], 8); 1493 } 1494 1495 static void handler_drm_KAI(struct wiimote_data *wdata, const __u8 *payload) 1496 { 1497 handler_keys(wdata, payload); 1498 handler_accel(wdata, payload); 1499 ir_to_input0(wdata, &payload[5], false); 1500 ir_to_input1(wdata, &payload[8], false); 1501 ir_to_input2(wdata, &payload[11], false); 1502 ir_to_input3(wdata, &payload[14], false); 1503 } 1504 1505 static void handler_drm_KEE(struct wiimote_data *wdata, const __u8 *payload) 1506 { 1507 handler_keys(wdata, payload); 1508 handler_ext(wdata, &payload[2], 19); 1509 } 1510 1511 static void handler_drm_KIE(struct wiimote_data *wdata, const __u8 *payload) 1512 { 1513 handler_keys(wdata, payload); 1514 ir_to_input0(wdata, &payload[2], false); 1515 ir_to_input1(wdata, &payload[4], true); 1516 ir_to_input2(wdata, &payload[7], false); 1517 ir_to_input3(wdata, &payload[9], true); 1518 handler_ext(wdata, &payload[12], 9); 1519 } 1520 1521 static void handler_drm_KAE(struct wiimote_data *wdata, const __u8 *payload) 1522 { 1523 handler_keys(wdata, payload); 1524 handler_accel(wdata, payload); 1525 handler_ext(wdata, &payload[5], 16); 1526 } 1527 1528 static void handler_drm_KAIE(struct wiimote_data *wdata, const __u8 *payload) 1529 { 1530 handler_keys(wdata, payload); 1531 handler_accel(wdata, payload); 1532 ir_to_input0(wdata, &payload[5], false); 1533 ir_to_input1(wdata, &payload[7], true); 1534 ir_to_input2(wdata, &payload[10], false); 1535 ir_to_input3(wdata, &payload[12], true); 1536 handler_ext(wdata, &payload[15], 6); 1537 } 1538 1539 static void handler_drm_E(struct wiimote_data *wdata, const __u8 *payload) 1540 { 1541 handler_ext(wdata, payload, 21); 1542 } 1543 1544 static void handler_drm_SKAI1(struct wiimote_data *wdata, const __u8 *payload) 1545 { 1546 handler_keys(wdata, payload); 1547 1548 wdata->state.accel_split[0] = payload[2]; 1549 wdata->state.accel_split[1] = (payload[0] >> 1) & (0x10 | 0x20); 1550 wdata->state.accel_split[1] |= (payload[1] << 1) & (0x40 | 0x80); 1551 1552 ir_to_input0(wdata, &payload[3], false); 1553 ir_to_input1(wdata, &payload[12], false); 1554 } 1555 1556 static void handler_drm_SKAI2(struct wiimote_data *wdata, const __u8 *payload) 1557 { 1558 __u8 buf[5]; 1559 1560 handler_keys(wdata, payload); 1561 1562 wdata->state.accel_split[1] |= (payload[0] >> 5) & (0x01 | 0x02); 1563 wdata->state.accel_split[1] |= (payload[1] >> 3) & (0x04 | 0x08); 1564 1565 buf[0] = 0; 1566 buf[1] = 0; 1567 buf[2] = wdata->state.accel_split[0]; 1568 buf[3] = payload[2]; 1569 buf[4] = wdata->state.accel_split[1]; 1570 handler_accel(wdata, buf); 1571 1572 ir_to_input2(wdata, &payload[3], false); 1573 ir_to_input3(wdata, &payload[12], false); 1574 } 1575 1576 struct wiiproto_handler { 1577 __u8 id; 1578 size_t size; 1579 void (*func)(struct wiimote_data *wdata, const __u8 *payload); 1580 }; 1581 1582 static struct wiiproto_handler handlers[] = { 1583 { .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status }, 1584 { .id = WIIPROTO_REQ_STATUS, .size = 2, .func = handler_status_K }, 1585 { .id = WIIPROTO_REQ_DATA, .size = 21, .func = handler_data }, 1586 { .id = WIIPROTO_REQ_DATA, .size = 2, .func = handler_generic_K }, 1587 { .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return }, 1588 { .id = WIIPROTO_REQ_RETURN, .size = 2, .func = handler_generic_K }, 1589 { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys }, 1590 { .id = WIIPROTO_REQ_DRM_KA, .size = 5, .func = handler_drm_KA }, 1591 { .id = WIIPROTO_REQ_DRM_KA, .size = 2, .func = handler_generic_K }, 1592 { .id = WIIPROTO_REQ_DRM_KE, .size = 10, .func = handler_drm_KE }, 1593 { .id = WIIPROTO_REQ_DRM_KE, .size = 2, .func = handler_generic_K }, 1594 { .id = WIIPROTO_REQ_DRM_KAI, .size = 17, .func = handler_drm_KAI }, 1595 { .id = WIIPROTO_REQ_DRM_KAI, .size = 2, .func = handler_generic_K }, 1596 { .id = WIIPROTO_REQ_DRM_KEE, .size = 21, .func = handler_drm_KEE }, 1597 { .id = WIIPROTO_REQ_DRM_KEE, .size = 2, .func = handler_generic_K }, 1598 { .id = WIIPROTO_REQ_DRM_KAE, .size = 21, .func = handler_drm_KAE }, 1599 { .id = WIIPROTO_REQ_DRM_KAE, .size = 2, .func = handler_generic_K }, 1600 { .id = WIIPROTO_REQ_DRM_KIE, .size = 21, .func = handler_drm_KIE }, 1601 { .id = WIIPROTO_REQ_DRM_KIE, .size = 2, .func = handler_generic_K }, 1602 { .id = WIIPROTO_REQ_DRM_KAIE, .size = 21, .func = handler_drm_KAIE }, 1603 { .id = WIIPROTO_REQ_DRM_KAIE, .size = 2, .func = handler_generic_K }, 1604 { .id = WIIPROTO_REQ_DRM_E, .size = 21, .func = handler_drm_E }, 1605 { .id = WIIPROTO_REQ_DRM_SKAI1, .size = 21, .func = handler_drm_SKAI1 }, 1606 { .id = WIIPROTO_REQ_DRM_SKAI2, .size = 21, .func = handler_drm_SKAI2 }, 1607 { .id = 0 } 1608 }; 1609 1610 static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report, 1611 u8 *raw_data, int size) 1612 { 1613 struct wiimote_data *wdata = hid_get_drvdata(hdev); 1614 struct wiiproto_handler *h; 1615 int i; 1616 unsigned long flags; 1617 1618 if (size < 1) 1619 return -EINVAL; 1620 1621 spin_lock_irqsave(&wdata->state.lock, flags); 1622 1623 for (i = 0; handlers[i].id; ++i) { 1624 h = &handlers[i]; 1625 if (h->id == raw_data[0] && h->size < size) { 1626 h->func(wdata, &raw_data[1]); 1627 break; 1628 } 1629 } 1630 1631 if (!handlers[i].id) 1632 hid_warn(hdev, "Unhandled report %hhu size %d\n", raw_data[0], 1633 size); 1634 1635 spin_unlock_irqrestore(&wdata->state.lock, flags); 1636 1637 return 0; 1638 } 1639 1640 static ssize_t wiimote_ext_show(struct device *dev, 1641 struct device_attribute *attr, 1642 char *buf) 1643 { 1644 struct wiimote_data *wdata = dev_to_wii(dev); 1645 __u8 type; 1646 unsigned long flags; 1647 1648 spin_lock_irqsave(&wdata->state.lock, flags); 1649 type = wdata->state.exttype; 1650 spin_unlock_irqrestore(&wdata->state.lock, flags); 1651 1652 switch (type) { 1653 case WIIMOTE_EXT_NONE: 1654 return sprintf(buf, "none\n"); 1655 case WIIMOTE_EXT_NUNCHUK: 1656 return sprintf(buf, "nunchuk\n"); 1657 case WIIMOTE_EXT_CLASSIC_CONTROLLER: 1658 return sprintf(buf, "classic\n"); 1659 case WIIMOTE_EXT_BALANCE_BOARD: 1660 return sprintf(buf, "balanceboard\n"); 1661 case WIIMOTE_EXT_PRO_CONTROLLER: 1662 return sprintf(buf, "procontroller\n"); 1663 case WIIMOTE_EXT_UNKNOWN: 1664 /* fallthrough */ 1665 default: 1666 return sprintf(buf, "unknown\n"); 1667 } 1668 } 1669 1670 static ssize_t wiimote_ext_store(struct device *dev, 1671 struct device_attribute *attr, 1672 const char *buf, size_t count) 1673 { 1674 struct wiimote_data *wdata = dev_to_wii(dev); 1675 1676 if (!strcmp(buf, "scan")) { 1677 wiimote_schedule(wdata); 1678 } else { 1679 return -EINVAL; 1680 } 1681 1682 return strnlen(buf, PAGE_SIZE); 1683 } 1684 1685 static DEVICE_ATTR(extension, S_IRUGO | S_IWUSR | S_IWGRP, wiimote_ext_show, 1686 wiimote_ext_store); 1687 1688 static ssize_t wiimote_dev_show(struct device *dev, 1689 struct device_attribute *attr, 1690 char *buf) 1691 { 1692 struct wiimote_data *wdata = dev_to_wii(dev); 1693 __u8 type; 1694 unsigned long flags; 1695 1696 spin_lock_irqsave(&wdata->state.lock, flags); 1697 type = wdata->state.devtype; 1698 spin_unlock_irqrestore(&wdata->state.lock, flags); 1699 1700 switch (type) { 1701 case WIIMOTE_DEV_GENERIC: 1702 return sprintf(buf, "generic\n"); 1703 case WIIMOTE_DEV_GEN10: 1704 return sprintf(buf, "gen10\n"); 1705 case WIIMOTE_DEV_GEN20: 1706 return sprintf(buf, "gen20\n"); 1707 case WIIMOTE_DEV_BALANCE_BOARD: 1708 return sprintf(buf, "balanceboard\n"); 1709 case WIIMOTE_DEV_PRO_CONTROLLER: 1710 return sprintf(buf, "procontroller\n"); 1711 case WIIMOTE_DEV_PENDING: 1712 return sprintf(buf, "pending\n"); 1713 case WIIMOTE_DEV_UNKNOWN: 1714 /* fallthrough */ 1715 default: 1716 return sprintf(buf, "unknown\n"); 1717 } 1718 } 1719 1720 static DEVICE_ATTR(devtype, S_IRUGO, wiimote_dev_show, NULL); 1721 1722 static struct wiimote_data *wiimote_create(struct hid_device *hdev) 1723 { 1724 struct wiimote_data *wdata; 1725 1726 wdata = kzalloc(sizeof(*wdata), GFP_KERNEL); 1727 if (!wdata) 1728 return NULL; 1729 1730 wdata->hdev = hdev; 1731 hid_set_drvdata(hdev, wdata); 1732 1733 spin_lock_init(&wdata->queue.lock); 1734 INIT_WORK(&wdata->queue.worker, wiimote_queue_worker); 1735 1736 spin_lock_init(&wdata->state.lock); 1737 init_completion(&wdata->state.ready); 1738 mutex_init(&wdata->state.sync); 1739 wdata->state.drm = WIIPROTO_REQ_DRM_K; 1740 wdata->state.cmd_battery = 0xff; 1741 1742 INIT_WORK(&wdata->init_worker, wiimote_init_worker); 1743 timer_setup(&wdata->timer, wiimote_init_timeout, 0); 1744 1745 return wdata; 1746 } 1747 1748 static void wiimote_destroy(struct wiimote_data *wdata) 1749 { 1750 unsigned long flags; 1751 1752 wiidebug_deinit(wdata); 1753 1754 /* prevent init_worker from being scheduled again */ 1755 spin_lock_irqsave(&wdata->state.lock, flags); 1756 wdata->state.flags |= WIIPROTO_FLAG_EXITING; 1757 spin_unlock_irqrestore(&wdata->state.lock, flags); 1758 1759 cancel_work_sync(&wdata->init_worker); 1760 del_timer_sync(&wdata->timer); 1761 1762 device_remove_file(&wdata->hdev->dev, &dev_attr_devtype); 1763 device_remove_file(&wdata->hdev->dev, &dev_attr_extension); 1764 1765 wiimote_mp_unload(wdata); 1766 wiimote_ext_unload(wdata); 1767 wiimote_modules_unload(wdata); 1768 cancel_work_sync(&wdata->queue.worker); 1769 hid_hw_close(wdata->hdev); 1770 hid_hw_stop(wdata->hdev); 1771 1772 kfree(wdata); 1773 } 1774 1775 static int wiimote_hid_probe(struct hid_device *hdev, 1776 const struct hid_device_id *id) 1777 { 1778 struct wiimote_data *wdata; 1779 int ret; 1780 1781 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; 1782 1783 wdata = wiimote_create(hdev); 1784 if (!wdata) { 1785 hid_err(hdev, "Can't alloc device\n"); 1786 return -ENOMEM; 1787 } 1788 1789 ret = hid_parse(hdev); 1790 if (ret) { 1791 hid_err(hdev, "HID parse failed\n"); 1792 goto err; 1793 } 1794 1795 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW); 1796 if (ret) { 1797 hid_err(hdev, "HW start failed\n"); 1798 goto err; 1799 } 1800 1801 ret = hid_hw_open(hdev); 1802 if (ret) { 1803 hid_err(hdev, "cannot start hardware I/O\n"); 1804 goto err_stop; 1805 } 1806 1807 ret = device_create_file(&hdev->dev, &dev_attr_extension); 1808 if (ret) { 1809 hid_err(hdev, "cannot create sysfs attribute\n"); 1810 goto err_close; 1811 } 1812 1813 ret = device_create_file(&hdev->dev, &dev_attr_devtype); 1814 if (ret) { 1815 hid_err(hdev, "cannot create sysfs attribute\n"); 1816 goto err_ext; 1817 } 1818 1819 ret = wiidebug_init(wdata); 1820 if (ret) 1821 goto err_free; 1822 1823 hid_info(hdev, "New device registered\n"); 1824 1825 /* schedule device detection */ 1826 wiimote_schedule(wdata); 1827 1828 return 0; 1829 1830 err_free: 1831 wiimote_destroy(wdata); 1832 return ret; 1833 1834 err_ext: 1835 device_remove_file(&wdata->hdev->dev, &dev_attr_extension); 1836 err_close: 1837 hid_hw_close(hdev); 1838 err_stop: 1839 hid_hw_stop(hdev); 1840 err: 1841 input_free_device(wdata->ir); 1842 input_free_device(wdata->accel); 1843 kfree(wdata); 1844 return ret; 1845 } 1846 1847 static void wiimote_hid_remove(struct hid_device *hdev) 1848 { 1849 struct wiimote_data *wdata = hid_get_drvdata(hdev); 1850 1851 hid_info(hdev, "Device removed\n"); 1852 wiimote_destroy(wdata); 1853 } 1854 1855 static const struct hid_device_id wiimote_hid_devices[] = { 1856 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, 1857 USB_DEVICE_ID_NINTENDO_WIIMOTE) }, 1858 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, 1859 USB_DEVICE_ID_NINTENDO_WIIMOTE2) }, 1860 { } 1861 }; 1862 MODULE_DEVICE_TABLE(hid, wiimote_hid_devices); 1863 1864 static struct hid_driver wiimote_hid_driver = { 1865 .name = "wiimote", 1866 .id_table = wiimote_hid_devices, 1867 .probe = wiimote_hid_probe, 1868 .remove = wiimote_hid_remove, 1869 .raw_event = wiimote_hid_event, 1870 }; 1871 module_hid_driver(wiimote_hid_driver); 1872 1873 MODULE_LICENSE("GPL"); 1874 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>"); 1875 MODULE_DESCRIPTION("Driver for Nintendo Wii / Wii U peripherals"); 1876