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