1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Device Modules for Nintendo Wii / Wii U HID Driver 4 * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com> 5 */ 6 7 /* 8 */ 9 10 /* 11 * Wiimote Modules 12 * Nintendo devices provide different peripherals and many new devices lack 13 * initial features like the IR camera. Therefore, each peripheral device is 14 * implemented as an independent module and we probe on each device only the 15 * modules for the hardware that really is available. 16 * 17 * Module registration is sequential. Unregistration is done in reverse order. 18 * After device detection, the needed modules are loaded. Users can trigger 19 * re-detection which causes all modules to be unloaded and then reload the 20 * modules for the new detected device. 21 * 22 * wdata->input is a shared input device. It is always initialized prior to 23 * module registration. If at least one registered module is marked as 24 * WIIMOD_FLAG_INPUT, then the input device will get registered after all 25 * modules were registered. 26 * Please note that it is unregistered _before_ the "remove" callbacks are 27 * called. This guarantees that no input interaction is done, anymore. However, 28 * the wiimote core keeps a reference to the input device so it is freed only 29 * after all modules were removed. It is safe to send events to unregistered 30 * input devices. 31 */ 32 33 #include <linux/cleanup.h> 34 #include <linux/device.h> 35 #include <linux/hid.h> 36 #include <linux/input.h> 37 #include <linux/spinlock.h> 38 #include "hid-wiimote.h" 39 40 /* 41 * Keys 42 * The initial Wii Remote provided a bunch of buttons that are reported as 43 * part of the core protocol. Many later devices dropped these and report 44 * invalid data in the core button reports. Load this only on devices which 45 * correctly send button reports. 46 * It uses the shared input device. 47 */ 48 49 static const __u16 wiimod_keys_map[] = { 50 KEY_LEFT, /* WIIPROTO_KEY_LEFT */ 51 KEY_RIGHT, /* WIIPROTO_KEY_RIGHT */ 52 KEY_UP, /* WIIPROTO_KEY_UP */ 53 KEY_DOWN, /* WIIPROTO_KEY_DOWN */ 54 KEY_NEXT, /* WIIPROTO_KEY_PLUS */ 55 KEY_PREVIOUS, /* WIIPROTO_KEY_MINUS */ 56 BTN_1, /* WIIPROTO_KEY_ONE */ 57 BTN_2, /* WIIPROTO_KEY_TWO */ 58 BTN_A, /* WIIPROTO_KEY_A */ 59 BTN_B, /* WIIPROTO_KEY_B */ 60 BTN_MODE, /* WIIPROTO_KEY_HOME */ 61 }; 62 63 static void wiimod_keys_in_keys(struct wiimote_data *wdata, const __u8 *keys) 64 { 65 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_LEFT], 66 !!(keys[0] & 0x01)); 67 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_RIGHT], 68 !!(keys[0] & 0x02)); 69 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_DOWN], 70 !!(keys[0] & 0x04)); 71 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_UP], 72 !!(keys[0] & 0x08)); 73 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_PLUS], 74 !!(keys[0] & 0x10)); 75 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_TWO], 76 !!(keys[1] & 0x01)); 77 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_ONE], 78 !!(keys[1] & 0x02)); 79 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_B], 80 !!(keys[1] & 0x04)); 81 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_A], 82 !!(keys[1] & 0x08)); 83 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_MINUS], 84 !!(keys[1] & 0x10)); 85 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_HOME], 86 !!(keys[1] & 0x80)); 87 input_sync(wdata->input); 88 } 89 90 static int wiimod_keys_probe(const struct wiimod_ops *ops, 91 struct wiimote_data *wdata) 92 { 93 unsigned int i; 94 95 set_bit(EV_KEY, wdata->input->evbit); 96 for (i = 0; i < WIIPROTO_KEY_COUNT; ++i) 97 set_bit(wiimod_keys_map[i], wdata->input->keybit); 98 99 return 0; 100 } 101 102 static const struct wiimod_ops wiimod_keys = { 103 .flags = WIIMOD_FLAG_INPUT, 104 .arg = 0, 105 .probe = wiimod_keys_probe, 106 .remove = NULL, 107 .in_keys = wiimod_keys_in_keys, 108 }; 109 110 /* 111 * Rumble 112 * Nearly all devices provide a rumble feature. A small motor for 113 * force-feedback effects. We provide an FF_RUMBLE memless ff device on the 114 * shared input device if this module is loaded. 115 * The rumble motor is controlled via a flag on almost every output report so 116 * the wiimote core handles the rumble flag. But if a device doesn't provide 117 * the rumble motor, this flag shouldn't be set. 118 */ 119 120 /* used by wiimod_rumble and wiipro_rumble */ 121 static void wiimod_rumble_worker(struct work_struct *work) 122 { 123 struct wiimote_data *wdata = container_of(work, struct wiimote_data, 124 rumble_worker); 125 126 spin_lock_irq(&wdata->state.lock); 127 wiiproto_req_rumble(wdata, wdata->state.cache_rumble); 128 spin_unlock_irq(&wdata->state.lock); 129 } 130 131 static int wiimod_rumble_play(struct input_dev *dev, void *data, 132 struct ff_effect *eff) 133 { 134 struct wiimote_data *wdata = input_get_drvdata(dev); 135 __u8 value; 136 137 /* 138 * The wiimote supports only a single rumble motor so if any magnitude 139 * is set to non-zero then we start the rumble motor. If both are set to 140 * zero, we stop the rumble motor. 141 */ 142 143 if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude) 144 value = 1; 145 else 146 value = 0; 147 148 /* Locking state.lock here might deadlock with input_event() calls. 149 * schedule_work acts as barrier. Merging multiple changes is fine. */ 150 wdata->state.cache_rumble = value; 151 schedule_work(&wdata->rumble_worker); 152 153 return 0; 154 } 155 156 static int wiimod_rumble_probe(const struct wiimod_ops *ops, 157 struct wiimote_data *wdata) 158 { 159 INIT_WORK(&wdata->rumble_worker, wiimod_rumble_worker); 160 161 set_bit(FF_RUMBLE, wdata->input->ffbit); 162 if (input_ff_create_memless(wdata->input, NULL, wiimod_rumble_play)) 163 return -ENOMEM; 164 165 return 0; 166 } 167 168 static void wiimod_rumble_remove(const struct wiimod_ops *ops, 169 struct wiimote_data *wdata) 170 { 171 unsigned long flags; 172 173 cancel_work_sync(&wdata->rumble_worker); 174 175 spin_lock_irqsave(&wdata->state.lock, flags); 176 wiiproto_req_rumble(wdata, 0); 177 spin_unlock_irqrestore(&wdata->state.lock, flags); 178 } 179 180 static const struct wiimod_ops wiimod_rumble = { 181 .flags = WIIMOD_FLAG_INPUT, 182 .arg = 0, 183 .probe = wiimod_rumble_probe, 184 .remove = wiimod_rumble_remove, 185 }; 186 187 /* 188 * Battery 189 * 1 byte of battery capacity information is sent along every protocol status 190 * report. The wiimote core caches it but we try to update it on every 191 * user-space request. 192 * This is supported by nearly every device so it's almost always enabled. 193 */ 194 195 static enum power_supply_property wiimod_battery_props[] = { 196 POWER_SUPPLY_PROP_CAPACITY, 197 POWER_SUPPLY_PROP_SCOPE, 198 }; 199 200 static int wiimod_battery_get_property(struct power_supply *psy, 201 enum power_supply_property psp, 202 union power_supply_propval *val) 203 { 204 struct wiimote_data *wdata = power_supply_get_drvdata(psy); 205 int ret = 0, state; 206 unsigned long flags; 207 208 if (psp == POWER_SUPPLY_PROP_SCOPE) { 209 val->intval = POWER_SUPPLY_SCOPE_DEVICE; 210 return 0; 211 } else if (psp != POWER_SUPPLY_PROP_CAPACITY) { 212 return -EINVAL; 213 } 214 215 ret = wiimote_cmd_acquire(wdata); 216 if (ret) 217 return ret; 218 219 spin_lock_irqsave(&wdata->state.lock, flags); 220 wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0); 221 wiiproto_req_status(wdata); 222 spin_unlock_irqrestore(&wdata->state.lock, flags); 223 224 wiimote_cmd_wait(wdata); 225 wiimote_cmd_release(wdata); 226 227 spin_lock_irqsave(&wdata->state.lock, flags); 228 state = wdata->state.cmd_battery; 229 spin_unlock_irqrestore(&wdata->state.lock, flags); 230 231 val->intval = state * 100 / 255; 232 return ret; 233 } 234 235 static int wiimod_battery_probe(const struct wiimod_ops *ops, 236 struct wiimote_data *wdata) 237 { 238 struct power_supply_config psy_cfg = { .drv_data = wdata, }; 239 int ret; 240 241 wdata->battery_desc.properties = wiimod_battery_props; 242 wdata->battery_desc.num_properties = ARRAY_SIZE(wiimod_battery_props); 243 wdata->battery_desc.get_property = wiimod_battery_get_property; 244 wdata->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY; 245 wdata->battery_desc.use_for_apm = 0; 246 wdata->battery_desc.name = kasprintf(GFP_KERNEL, "wiimote_battery_%s", 247 wdata->hdev->uniq); 248 if (!wdata->battery_desc.name) 249 return -ENOMEM; 250 251 wdata->battery = power_supply_register(&wdata->hdev->dev, 252 &wdata->battery_desc, 253 &psy_cfg); 254 if (IS_ERR(wdata->battery)) { 255 hid_err(wdata->hdev, "cannot register battery device\n"); 256 ret = PTR_ERR(wdata->battery); 257 goto err_free; 258 } 259 260 power_supply_powers(wdata->battery, &wdata->hdev->dev); 261 return 0; 262 263 err_free: 264 kfree(wdata->battery_desc.name); 265 wdata->battery_desc.name = NULL; 266 return ret; 267 } 268 269 static void wiimod_battery_remove(const struct wiimod_ops *ops, 270 struct wiimote_data *wdata) 271 { 272 if (!wdata->battery_desc.name) 273 return; 274 275 power_supply_unregister(wdata->battery); 276 kfree(wdata->battery_desc.name); 277 wdata->battery_desc.name = NULL; 278 } 279 280 static const struct wiimod_ops wiimod_battery = { 281 .flags = 0, 282 .arg = 0, 283 .probe = wiimod_battery_probe, 284 .remove = wiimod_battery_remove, 285 }; 286 287 /* 288 * LED 289 * 0 to 4 player LEDs are supported by devices. The "arg" field of the 290 * wiimod_ops structure specifies which LED this module controls. This allows 291 * to register a limited number of LEDs. 292 * State is managed by wiimote core. 293 */ 294 295 static enum led_brightness wiimod_led_get(struct led_classdev *led_dev) 296 { 297 struct device *dev = led_dev->dev->parent; 298 struct wiimote_data *wdata = dev_to_wii(dev); 299 int i; 300 unsigned long flags; 301 bool value = false; 302 303 for (i = 0; i < 4; ++i) { 304 if (wdata->leds[i] == led_dev) { 305 spin_lock_irqsave(&wdata->state.lock, flags); 306 value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1); 307 spin_unlock_irqrestore(&wdata->state.lock, flags); 308 break; 309 } 310 } 311 312 return value ? LED_FULL : LED_OFF; 313 } 314 315 static void wiimod_led_set(struct led_classdev *led_dev, 316 enum led_brightness value) 317 { 318 struct device *dev = led_dev->dev->parent; 319 struct wiimote_data *wdata = dev_to_wii(dev); 320 int i; 321 unsigned long flags; 322 __u8 state, flag; 323 324 for (i = 0; i < 4; ++i) { 325 if (wdata->leds[i] == led_dev) { 326 flag = WIIPROTO_FLAG_LED(i + 1); 327 spin_lock_irqsave(&wdata->state.lock, flags); 328 state = wdata->state.flags; 329 if (value == LED_OFF) 330 wiiproto_req_leds(wdata, state & ~flag); 331 else 332 wiiproto_req_leds(wdata, state | flag); 333 spin_unlock_irqrestore(&wdata->state.lock, flags); 334 break; 335 } 336 } 337 } 338 339 static int wiimod_led_probe(const struct wiimod_ops *ops, 340 struct wiimote_data *wdata) 341 { 342 struct led_classdev *led __free(kfree) = NULL; 343 struct device *dev = &wdata->hdev->dev; 344 size_t namesz = strlen(dev_name(dev)) + 9; 345 char *name; 346 int ret; 347 348 led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL); 349 if (!led) 350 return -ENOMEM; 351 352 name = (void*)&led[1]; 353 snprintf(name, namesz, "%s:blue:p%lu", dev_name(dev), ops->arg); 354 led->name = name; 355 led->brightness = 0; 356 led->max_brightness = 1; 357 led->brightness_get = wiimod_led_get; 358 led->brightness_set = wiimod_led_set; 359 360 wdata->leds[ops->arg] = led; 361 ret = led_classdev_register(dev, led); 362 if (ret) { 363 wdata->leds[ops->arg] = NULL; 364 return ret; 365 } 366 367 retain_and_null_ptr(led); 368 369 return 0; 370 } 371 372 static void wiimod_led_remove(const struct wiimod_ops *ops, 373 struct wiimote_data *wdata) 374 { 375 if (!wdata->leds[ops->arg]) 376 return; 377 378 led_classdev_unregister(wdata->leds[ops->arg]); 379 kfree(wdata->leds[ops->arg]); 380 wdata->leds[ops->arg] = NULL; 381 } 382 383 static const struct wiimod_ops wiimod_leds[4] = { 384 { 385 .flags = 0, 386 .arg = 0, 387 .probe = wiimod_led_probe, 388 .remove = wiimod_led_remove, 389 }, 390 { 391 .flags = 0, 392 .arg = 1, 393 .probe = wiimod_led_probe, 394 .remove = wiimod_led_remove, 395 }, 396 { 397 .flags = 0, 398 .arg = 2, 399 .probe = wiimod_led_probe, 400 .remove = wiimod_led_remove, 401 }, 402 { 403 .flags = 0, 404 .arg = 3, 405 .probe = wiimod_led_probe, 406 .remove = wiimod_led_remove, 407 }, 408 }; 409 410 /* 411 * Accelerometer 412 * 3 axis accelerometer data is part of nearly all DRMs. If not supported by a 413 * device, it's mostly cleared to 0. This module parses this data and provides 414 * it via a separate input device. 415 */ 416 417 static void wiimod_accel_in_accel(struct wiimote_data *wdata, 418 const __u8 *accel) 419 { 420 __u16 x, y, z; 421 422 if (!(wdata->state.flags & WIIPROTO_FLAG_ACCEL)) 423 return; 424 425 /* 426 * payload is: BB BB XX YY ZZ 427 * Accelerometer data is encoded into 3 10bit values. XX, YY and ZZ 428 * contain the upper 8 bits of each value. The lower 2 bits are 429 * contained in the buttons data BB BB. 430 * Bits 6 and 7 of the first buttons byte BB is the lower 2 bits of the 431 * X accel value. Bit 5 of the second buttons byte is the 2nd bit of Y 432 * accel value and bit 6 is the second bit of the Z value. 433 * The first bit of Y and Z values is not available and always set to 0. 434 * 0x200 is returned on no movement. 435 */ 436 437 x = accel[2] << 2; 438 y = accel[3] << 2; 439 z = accel[4] << 2; 440 441 x |= (accel[0] >> 5) & 0x3; 442 y |= (accel[1] >> 4) & 0x2; 443 z |= (accel[1] >> 5) & 0x2; 444 445 input_report_abs(wdata->accel, ABS_RX, x - 0x200); 446 input_report_abs(wdata->accel, ABS_RY, y - 0x200); 447 input_report_abs(wdata->accel, ABS_RZ, z - 0x200); 448 input_sync(wdata->accel); 449 } 450 451 static int wiimod_accel_open(struct input_dev *dev) 452 { 453 struct wiimote_data *wdata = input_get_drvdata(dev); 454 unsigned long flags; 455 456 spin_lock_irqsave(&wdata->state.lock, flags); 457 wiiproto_req_accel(wdata, true); 458 spin_unlock_irqrestore(&wdata->state.lock, flags); 459 460 return 0; 461 } 462 463 static void wiimod_accel_close(struct input_dev *dev) 464 { 465 struct wiimote_data *wdata = input_get_drvdata(dev); 466 unsigned long flags; 467 468 spin_lock_irqsave(&wdata->state.lock, flags); 469 wiiproto_req_accel(wdata, false); 470 spin_unlock_irqrestore(&wdata->state.lock, flags); 471 } 472 473 static int wiimod_accel_probe(const struct wiimod_ops *ops, 474 struct wiimote_data *wdata) 475 { 476 int ret; 477 478 wdata->accel = input_allocate_device(); 479 if (!wdata->accel) 480 return -ENOMEM; 481 482 input_set_drvdata(wdata->accel, wdata); 483 wdata->accel->open = wiimod_accel_open; 484 wdata->accel->close = wiimod_accel_close; 485 wdata->accel->dev.parent = &wdata->hdev->dev; 486 wdata->accel->id.bustype = wdata->hdev->bus; 487 wdata->accel->id.vendor = wdata->hdev->vendor; 488 wdata->accel->id.product = wdata->hdev->product; 489 wdata->accel->id.version = wdata->hdev->version; 490 wdata->accel->name = WIIMOTE_NAME " Accelerometer"; 491 492 set_bit(EV_ABS, wdata->accel->evbit); 493 set_bit(ABS_RX, wdata->accel->absbit); 494 set_bit(ABS_RY, wdata->accel->absbit); 495 set_bit(ABS_RZ, wdata->accel->absbit); 496 input_set_abs_params(wdata->accel, ABS_RX, -500, 500, 2, 4); 497 input_set_abs_params(wdata->accel, ABS_RY, -500, 500, 2, 4); 498 input_set_abs_params(wdata->accel, ABS_RZ, -500, 500, 2, 4); 499 500 ret = input_register_device(wdata->accel); 501 if (ret) { 502 hid_err(wdata->hdev, "cannot register input device\n"); 503 goto err_free; 504 } 505 506 return 0; 507 508 err_free: 509 input_free_device(wdata->accel); 510 wdata->accel = NULL; 511 return ret; 512 } 513 514 static void wiimod_accel_remove(const struct wiimod_ops *ops, 515 struct wiimote_data *wdata) 516 { 517 if (!wdata->accel) 518 return; 519 520 input_unregister_device(wdata->accel); 521 wdata->accel = NULL; 522 } 523 524 static const struct wiimod_ops wiimod_accel = { 525 .flags = 0, 526 .arg = 0, 527 .probe = wiimod_accel_probe, 528 .remove = wiimod_accel_remove, 529 .in_accel = wiimod_accel_in_accel, 530 }; 531 532 /* 533 * IR Cam 534 * Up to 4 IR sources can be tracked by a normal Wii Remote. The IR cam needs 535 * to be initialized with a fairly complex procedure and consumes a lot of 536 * power. Therefore, as long as no application uses the IR input device, it is 537 * kept offline. 538 * Nearly no other device than the normal Wii Remotes supports the IR cam so 539 * you can disable this module for these devices. 540 */ 541 542 static void wiimod_ir_in_ir(struct wiimote_data *wdata, const __u8 *ir, 543 bool packed, unsigned int id) 544 { 545 __u16 x, y; 546 __u8 xid, yid; 547 bool sync = false; 548 549 if (!(wdata->state.flags & WIIPROTO_FLAGS_IR)) 550 return; 551 552 switch (id) { 553 case 0: 554 xid = ABS_HAT0X; 555 yid = ABS_HAT0Y; 556 break; 557 case 1: 558 xid = ABS_HAT1X; 559 yid = ABS_HAT1Y; 560 break; 561 case 2: 562 xid = ABS_HAT2X; 563 yid = ABS_HAT2Y; 564 break; 565 case 3: 566 xid = ABS_HAT3X; 567 yid = ABS_HAT3Y; 568 sync = true; 569 break; 570 default: 571 return; 572 } 573 574 /* 575 * Basic IR data is encoded into 3 bytes. The first two bytes are the 576 * lower 8 bit of the X/Y data, the 3rd byte contains the upper 2 bits 577 * of both. 578 * If data is packed, then the 3rd byte is put first and slightly 579 * reordered. This allows to interleave packed and non-packed data to 580 * have two IR sets in 5 bytes instead of 6. 581 * The resulting 10bit X/Y values are passed to the ABS_HAT? input dev. 582 */ 583 584 if (packed) { 585 x = ir[1] | ((ir[0] & 0x03) << 8); 586 y = ir[2] | ((ir[0] & 0x0c) << 6); 587 } else { 588 x = ir[0] | ((ir[2] & 0x30) << 4); 589 y = ir[1] | ((ir[2] & 0xc0) << 2); 590 } 591 592 input_report_abs(wdata->ir, xid, x); 593 input_report_abs(wdata->ir, yid, y); 594 595 if (sync) 596 input_sync(wdata->ir); 597 } 598 599 static int wiimod_ir_change(struct wiimote_data *wdata, __u16 mode) 600 { 601 int ret; 602 unsigned long flags; 603 __u8 format = 0; 604 static const __u8 data_enable[] = { 0x01 }; 605 static const __u8 data_sens1[] = { 0x02, 0x00, 0x00, 0x71, 0x01, 606 0x00, 0xaa, 0x00, 0x64 }; 607 static const __u8 data_sens2[] = { 0x63, 0x03 }; 608 static const __u8 data_fin[] = { 0x08 }; 609 610 spin_lock_irqsave(&wdata->state.lock, flags); 611 612 if (mode == (wdata->state.flags & WIIPROTO_FLAGS_IR)) { 613 spin_unlock_irqrestore(&wdata->state.lock, flags); 614 return 0; 615 } 616 617 if (mode == 0) { 618 wdata->state.flags &= ~WIIPROTO_FLAGS_IR; 619 wiiproto_req_ir1(wdata, 0); 620 wiiproto_req_ir2(wdata, 0); 621 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 622 spin_unlock_irqrestore(&wdata->state.lock, flags); 623 return 0; 624 } 625 626 spin_unlock_irqrestore(&wdata->state.lock, flags); 627 628 ret = wiimote_cmd_acquire(wdata); 629 if (ret) 630 return ret; 631 632 /* send PIXEL CLOCK ENABLE cmd first */ 633 spin_lock_irqsave(&wdata->state.lock, flags); 634 wiimote_cmd_set(wdata, WIIPROTO_REQ_IR1, 0); 635 wiiproto_req_ir1(wdata, 0x06); 636 spin_unlock_irqrestore(&wdata->state.lock, flags); 637 638 ret = wiimote_cmd_wait(wdata); 639 if (ret) 640 goto unlock; 641 if (wdata->state.cmd_err) { 642 ret = -EIO; 643 goto unlock; 644 } 645 646 /* enable IR LOGIC */ 647 spin_lock_irqsave(&wdata->state.lock, flags); 648 wiimote_cmd_set(wdata, WIIPROTO_REQ_IR2, 0); 649 wiiproto_req_ir2(wdata, 0x06); 650 spin_unlock_irqrestore(&wdata->state.lock, flags); 651 652 ret = wiimote_cmd_wait(wdata); 653 if (ret) 654 goto unlock; 655 if (wdata->state.cmd_err) { 656 ret = -EIO; 657 goto unlock; 658 } 659 660 /* enable IR cam but do not make it send data, yet */ 661 ret = wiimote_cmd_write(wdata, 0xb00030, data_enable, 662 sizeof(data_enable)); 663 if (ret) 664 goto unlock; 665 666 /* write first sensitivity block */ 667 ret = wiimote_cmd_write(wdata, 0xb00000, data_sens1, 668 sizeof(data_sens1)); 669 if (ret) 670 goto unlock; 671 672 /* write second sensitivity block */ 673 ret = wiimote_cmd_write(wdata, 0xb0001a, data_sens2, 674 sizeof(data_sens2)); 675 if (ret) 676 goto unlock; 677 678 /* put IR cam into desired state */ 679 switch (mode) { 680 case WIIPROTO_FLAG_IR_FULL: 681 format = 5; 682 break; 683 case WIIPROTO_FLAG_IR_EXT: 684 format = 3; 685 break; 686 case WIIPROTO_FLAG_IR_BASIC: 687 format = 1; 688 break; 689 } 690 ret = wiimote_cmd_write(wdata, 0xb00033, &format, sizeof(format)); 691 if (ret) 692 goto unlock; 693 694 /* make IR cam send data */ 695 ret = wiimote_cmd_write(wdata, 0xb00030, data_fin, sizeof(data_fin)); 696 if (ret) 697 goto unlock; 698 699 /* request new DRM mode compatible to IR mode */ 700 spin_lock_irqsave(&wdata->state.lock, flags); 701 wdata->state.flags &= ~WIIPROTO_FLAGS_IR; 702 wdata->state.flags |= mode & WIIPROTO_FLAGS_IR; 703 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 704 spin_unlock_irqrestore(&wdata->state.lock, flags); 705 706 unlock: 707 wiimote_cmd_release(wdata); 708 return ret; 709 } 710 711 static int wiimod_ir_open(struct input_dev *dev) 712 { 713 struct wiimote_data *wdata = input_get_drvdata(dev); 714 715 return wiimod_ir_change(wdata, WIIPROTO_FLAG_IR_BASIC); 716 } 717 718 static void wiimod_ir_close(struct input_dev *dev) 719 { 720 struct wiimote_data *wdata = input_get_drvdata(dev); 721 722 wiimod_ir_change(wdata, 0); 723 } 724 725 static int wiimod_ir_probe(const struct wiimod_ops *ops, 726 struct wiimote_data *wdata) 727 { 728 int ret; 729 730 wdata->ir = input_allocate_device(); 731 if (!wdata->ir) 732 return -ENOMEM; 733 734 input_set_drvdata(wdata->ir, wdata); 735 wdata->ir->open = wiimod_ir_open; 736 wdata->ir->close = wiimod_ir_close; 737 wdata->ir->dev.parent = &wdata->hdev->dev; 738 wdata->ir->id.bustype = wdata->hdev->bus; 739 wdata->ir->id.vendor = wdata->hdev->vendor; 740 wdata->ir->id.product = wdata->hdev->product; 741 wdata->ir->id.version = wdata->hdev->version; 742 wdata->ir->name = WIIMOTE_NAME " IR"; 743 744 set_bit(EV_ABS, wdata->ir->evbit); 745 set_bit(ABS_HAT0X, wdata->ir->absbit); 746 set_bit(ABS_HAT0Y, wdata->ir->absbit); 747 set_bit(ABS_HAT1X, wdata->ir->absbit); 748 set_bit(ABS_HAT1Y, wdata->ir->absbit); 749 set_bit(ABS_HAT2X, wdata->ir->absbit); 750 set_bit(ABS_HAT2Y, wdata->ir->absbit); 751 set_bit(ABS_HAT3X, wdata->ir->absbit); 752 set_bit(ABS_HAT3Y, wdata->ir->absbit); 753 input_set_abs_params(wdata->ir, ABS_HAT0X, 0, 1023, 2, 4); 754 input_set_abs_params(wdata->ir, ABS_HAT0Y, 0, 767, 2, 4); 755 input_set_abs_params(wdata->ir, ABS_HAT1X, 0, 1023, 2, 4); 756 input_set_abs_params(wdata->ir, ABS_HAT1Y, 0, 767, 2, 4); 757 input_set_abs_params(wdata->ir, ABS_HAT2X, 0, 1023, 2, 4); 758 input_set_abs_params(wdata->ir, ABS_HAT2Y, 0, 767, 2, 4); 759 input_set_abs_params(wdata->ir, ABS_HAT3X, 0, 1023, 2, 4); 760 input_set_abs_params(wdata->ir, ABS_HAT3Y, 0, 767, 2, 4); 761 762 ret = input_register_device(wdata->ir); 763 if (ret) { 764 hid_err(wdata->hdev, "cannot register input device\n"); 765 goto err_free; 766 } 767 768 return 0; 769 770 err_free: 771 input_free_device(wdata->ir); 772 wdata->ir = NULL; 773 return ret; 774 } 775 776 static void wiimod_ir_remove(const struct wiimod_ops *ops, 777 struct wiimote_data *wdata) 778 { 779 if (!wdata->ir) 780 return; 781 782 input_unregister_device(wdata->ir); 783 wdata->ir = NULL; 784 } 785 786 static const struct wiimod_ops wiimod_ir = { 787 .flags = 0, 788 .arg = 0, 789 .probe = wiimod_ir_probe, 790 .remove = wiimod_ir_remove, 791 .in_ir = wiimod_ir_in_ir, 792 }; 793 794 /* 795 * Nunchuk Extension 796 * The Nintendo Wii Nunchuk was the first official extension published by 797 * Nintendo. It provides two additional keys and a separate accelerometer. It 798 * can be hotplugged to standard Wii Remotes. 799 */ 800 801 enum wiimod_nunchuk_keys { 802 WIIMOD_NUNCHUK_KEY_C, 803 WIIMOD_NUNCHUK_KEY_Z, 804 WIIMOD_NUNCHUK_KEY_NUM, 805 }; 806 807 static const __u16 wiimod_nunchuk_map[] = { 808 BTN_C, /* WIIMOD_NUNCHUK_KEY_C */ 809 BTN_Z, /* WIIMOD_NUNCHUK_KEY_Z */ 810 }; 811 812 static void wiimod_nunchuk_in_ext(struct wiimote_data *wdata, const __u8 *ext) 813 { 814 __s16 x, y, z, bx, by; 815 816 /* Byte | 8 7 | 6 5 | 4 3 | 2 | 1 | 817 * -----+----------+---------+---------+----+-----+ 818 * 1 | Button X <7:0> | 819 * 2 | Button Y <7:0> | 820 * -----+----------+---------+---------+----+-----+ 821 * 3 | Speed X <9:2> | 822 * 4 | Speed Y <9:2> | 823 * 5 | Speed Z <9:2> | 824 * -----+----------+---------+---------+----+-----+ 825 * 6 | Z <1:0> | Y <1:0> | X <1:0> | BC | BZ | 826 * -----+----------+---------+---------+----+-----+ 827 * Button X/Y is the analog stick. Speed X, Y and Z are the 828 * accelerometer data in the same format as the wiimote's accelerometer. 829 * The 6th byte contains the LSBs of the accelerometer data. 830 * BC and BZ are the C and Z buttons: 0 means pressed 831 * 832 * If reported interleaved with motionp, then the layout changes. The 833 * 5th and 6th byte changes to: 834 * -----+-----------------------------------+-----+ 835 * 5 | Speed Z <9:3> | EXT | 836 * -----+--------+-----+-----+----+----+----+-----+ 837 * 6 |Z <2:1> |Y <1>|X <1>| BC | BZ | 0 | 0 | 838 * -----+--------+-----+-----+----+----+----+-----+ 839 * All three accelerometer values lose their LSB. The other data is 840 * still available but slightly moved. 841 * 842 * Center data for button values is 128. Center value for accelerometer 843 * values it 512 / 0x200 844 */ 845 846 bx = ext[0]; 847 by = ext[1]; 848 bx -= 128; 849 by -= 128; 850 851 x = ext[2] << 2; 852 y = ext[3] << 2; 853 z = ext[4] << 2; 854 855 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 856 x |= (ext[5] >> 3) & 0x02; 857 y |= (ext[5] >> 4) & 0x02; 858 z &= ~0x4; 859 z |= (ext[5] >> 5) & 0x06; 860 } else { 861 x |= (ext[5] >> 2) & 0x03; 862 y |= (ext[5] >> 4) & 0x03; 863 z |= (ext[5] >> 6) & 0x03; 864 } 865 866 x -= 0x200; 867 y -= 0x200; 868 z -= 0x200; 869 870 input_report_abs(wdata->extension.input, ABS_HAT0X, bx); 871 input_report_abs(wdata->extension.input, ABS_HAT0Y, by); 872 873 input_report_abs(wdata->extension.input, ABS_RX, x); 874 input_report_abs(wdata->extension.input, ABS_RY, y); 875 input_report_abs(wdata->extension.input, ABS_RZ, z); 876 877 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 878 input_report_key(wdata->extension.input, 879 wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_Z], 880 !(ext[5] & 0x04)); 881 input_report_key(wdata->extension.input, 882 wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_C], 883 !(ext[5] & 0x08)); 884 } else { 885 input_report_key(wdata->extension.input, 886 wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_Z], 887 !(ext[5] & 0x01)); 888 input_report_key(wdata->extension.input, 889 wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_C], 890 !(ext[5] & 0x02)); 891 } 892 893 input_sync(wdata->extension.input); 894 } 895 896 static int wiimod_nunchuk_open(struct input_dev *dev) 897 { 898 struct wiimote_data *wdata = input_get_drvdata(dev); 899 unsigned long flags; 900 901 spin_lock_irqsave(&wdata->state.lock, flags); 902 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 903 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 904 spin_unlock_irqrestore(&wdata->state.lock, flags); 905 906 return 0; 907 } 908 909 static void wiimod_nunchuk_close(struct input_dev *dev) 910 { 911 struct wiimote_data *wdata = input_get_drvdata(dev); 912 unsigned long flags; 913 914 spin_lock_irqsave(&wdata->state.lock, flags); 915 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 916 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 917 spin_unlock_irqrestore(&wdata->state.lock, flags); 918 } 919 920 static int wiimod_nunchuk_probe(const struct wiimod_ops *ops, 921 struct wiimote_data *wdata) 922 { 923 int ret, i; 924 925 wdata->extension.input = input_allocate_device(); 926 if (!wdata->extension.input) 927 return -ENOMEM; 928 929 input_set_drvdata(wdata->extension.input, wdata); 930 wdata->extension.input->open = wiimod_nunchuk_open; 931 wdata->extension.input->close = wiimod_nunchuk_close; 932 wdata->extension.input->dev.parent = &wdata->hdev->dev; 933 wdata->extension.input->id.bustype = wdata->hdev->bus; 934 wdata->extension.input->id.vendor = wdata->hdev->vendor; 935 wdata->extension.input->id.product = wdata->hdev->product; 936 wdata->extension.input->id.version = wdata->hdev->version; 937 wdata->extension.input->name = WIIMOTE_NAME " Nunchuk"; 938 939 set_bit(EV_KEY, wdata->extension.input->evbit); 940 for (i = 0; i < WIIMOD_NUNCHUK_KEY_NUM; ++i) 941 set_bit(wiimod_nunchuk_map[i], 942 wdata->extension.input->keybit); 943 944 set_bit(EV_ABS, wdata->extension.input->evbit); 945 set_bit(ABS_HAT0X, wdata->extension.input->absbit); 946 set_bit(ABS_HAT0Y, wdata->extension.input->absbit); 947 input_set_abs_params(wdata->extension.input, 948 ABS_HAT0X, -120, 120, 2, 4); 949 input_set_abs_params(wdata->extension.input, 950 ABS_HAT0Y, -120, 120, 2, 4); 951 set_bit(ABS_RX, wdata->extension.input->absbit); 952 set_bit(ABS_RY, wdata->extension.input->absbit); 953 set_bit(ABS_RZ, wdata->extension.input->absbit); 954 input_set_abs_params(wdata->extension.input, 955 ABS_RX, -500, 500, 2, 4); 956 input_set_abs_params(wdata->extension.input, 957 ABS_RY, -500, 500, 2, 4); 958 input_set_abs_params(wdata->extension.input, 959 ABS_RZ, -500, 500, 2, 4); 960 961 ret = input_register_device(wdata->extension.input); 962 if (ret) 963 goto err_free; 964 965 return 0; 966 967 err_free: 968 input_free_device(wdata->extension.input); 969 wdata->extension.input = NULL; 970 return ret; 971 } 972 973 static void wiimod_nunchuk_remove(const struct wiimod_ops *ops, 974 struct wiimote_data *wdata) 975 { 976 if (!wdata->extension.input) 977 return; 978 979 input_unregister_device(wdata->extension.input); 980 wdata->extension.input = NULL; 981 } 982 983 static const struct wiimod_ops wiimod_nunchuk = { 984 .flags = 0, 985 .arg = 0, 986 .probe = wiimod_nunchuk_probe, 987 .remove = wiimod_nunchuk_remove, 988 .in_ext = wiimod_nunchuk_in_ext, 989 }; 990 991 /* 992 * Classic Controller 993 * Another official extension from Nintendo. It provides a classic 994 * gamecube-like controller that can be hotplugged on the Wii Remote. 995 * It has several hardware buttons and switches that are all reported via 996 * a normal extension device. 997 */ 998 999 enum wiimod_classic_keys { 1000 WIIMOD_CLASSIC_KEY_A, 1001 WIIMOD_CLASSIC_KEY_B, 1002 WIIMOD_CLASSIC_KEY_X, 1003 WIIMOD_CLASSIC_KEY_Y, 1004 WIIMOD_CLASSIC_KEY_ZL, 1005 WIIMOD_CLASSIC_KEY_ZR, 1006 WIIMOD_CLASSIC_KEY_PLUS, 1007 WIIMOD_CLASSIC_KEY_MINUS, 1008 WIIMOD_CLASSIC_KEY_HOME, 1009 WIIMOD_CLASSIC_KEY_LEFT, 1010 WIIMOD_CLASSIC_KEY_RIGHT, 1011 WIIMOD_CLASSIC_KEY_UP, 1012 WIIMOD_CLASSIC_KEY_DOWN, 1013 WIIMOD_CLASSIC_KEY_LT, 1014 WIIMOD_CLASSIC_KEY_RT, 1015 WIIMOD_CLASSIC_KEY_NUM, 1016 }; 1017 1018 static const __u16 wiimod_classic_map[] = { 1019 BTN_A, /* WIIMOD_CLASSIC_KEY_A */ 1020 BTN_B, /* WIIMOD_CLASSIC_KEY_B */ 1021 BTN_X, /* WIIMOD_CLASSIC_KEY_X */ 1022 BTN_Y, /* WIIMOD_CLASSIC_KEY_Y */ 1023 BTN_TL2, /* WIIMOD_CLASSIC_KEY_ZL */ 1024 BTN_TR2, /* WIIMOD_CLASSIC_KEY_ZR */ 1025 KEY_NEXT, /* WIIMOD_CLASSIC_KEY_PLUS */ 1026 KEY_PREVIOUS, /* WIIMOD_CLASSIC_KEY_MINUS */ 1027 BTN_MODE, /* WIIMOD_CLASSIC_KEY_HOME */ 1028 KEY_LEFT, /* WIIMOD_CLASSIC_KEY_LEFT */ 1029 KEY_RIGHT, /* WIIMOD_CLASSIC_KEY_RIGHT */ 1030 KEY_UP, /* WIIMOD_CLASSIC_KEY_UP */ 1031 KEY_DOWN, /* WIIMOD_CLASSIC_KEY_DOWN */ 1032 BTN_TL, /* WIIMOD_CLASSIC_KEY_LT */ 1033 BTN_TR, /* WIIMOD_CLASSIC_KEY_RT */ 1034 }; 1035 1036 static void wiimod_classic_in_ext(struct wiimote_data *wdata, const __u8 *ext) 1037 { 1038 __s8 rx, ry, lx, ly, lt, rt; 1039 1040 /* Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 1041 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1042 * 1 | RX <5:4> | LX <5:0> | 1043 * 2 | RX <3:2> | LY <5:0> | 1044 * -----+-----+-----+-----+-----------------------------+ 1045 * 3 |RX<1>| LT <5:4> | RY <5:1> | 1046 * -----+-----+-----------+-----------------------------+ 1047 * 4 | LT <3:1> | RT <5:1> | 1048 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1049 * 5 | BDR | BDD | BLT | B- | BH | B+ | BRT | 1 | 1050 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1051 * 6 | BZL | BB | BY | BA | BX | BZR | BDL | BDU | 1052 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1053 * All buttons are 0 if pressed 1054 * RX and RY are right analog stick 1055 * LX and LY are left analog stick 1056 * LT is left trigger, RT is right trigger 1057 * BLT is 0 if left trigger is fully pressed 1058 * BRT is 0 if right trigger is fully pressed 1059 * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons 1060 * BZL is left Z button and BZR is right Z button 1061 * B-, BH, B+ are +, HOME and - buttons 1062 * BB, BY, BA, BX are A, B, X, Y buttons 1063 * LSB of RX, RY, LT, and RT are not transmitted and always 0. 1064 * 1065 * With motionp enabled it changes slightly to this: 1066 * Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 1067 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1068 * 1 | RX <5:4> | LX <5:1> | BDU | 1069 * 2 | RX <3:2> | LY <5:1> | BDL | 1070 * -----+-----+-----+-----+-----------------------+-----+ 1071 * 3 |RX<1>| LT <5:4> | RY <5:1> | 1072 * -----+-----+-----------+-----------------------------+ 1073 * 4 | LT <3:1> | RT <5:1> | 1074 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1075 * 5 | BDR | BDD | BLT | B- | BH | B+ | BRT | EXT | 1076 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1077 * 6 | BZL | BB | BY | BA | BX | BZR | 0 | 0 | 1078 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1079 * Only the LSBs of LX and LY are lost. BDU and BDL are moved, the rest 1080 * is the same as before. 1081 */ 1082 1083 static const s8 digital_to_analog[3] = {0x20, 0, -0x20}; 1084 1085 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 1086 if (wiimote_dpad_as_analog) { 1087 lx = digital_to_analog[1 - !(ext[4] & 0x80) 1088 + !(ext[1] & 0x01)]; 1089 ly = digital_to_analog[1 - !(ext[4] & 0x40) 1090 + !(ext[0] & 0x01)]; 1091 } else { 1092 lx = (ext[0] & 0x3e) - 0x20; 1093 ly = (ext[1] & 0x3e) - 0x20; 1094 } 1095 } else { 1096 if (wiimote_dpad_as_analog) { 1097 lx = digital_to_analog[1 - !(ext[4] & 0x80) 1098 + !(ext[5] & 0x02)]; 1099 ly = digital_to_analog[1 - !(ext[4] & 0x40) 1100 + !(ext[5] & 0x01)]; 1101 } else { 1102 lx = (ext[0] & 0x3f) - 0x20; 1103 ly = (ext[1] & 0x3f) - 0x20; 1104 } 1105 } 1106 1107 rx = (ext[0] >> 3) & 0x18; 1108 rx |= (ext[1] >> 5) & 0x06; 1109 rx |= (ext[2] >> 7) & 0x01; 1110 ry = ext[2] & 0x1f; 1111 1112 rt = ext[3] & 0x1f; 1113 lt = (ext[2] >> 2) & 0x18; 1114 lt |= (ext[3] >> 5) & 0x07; 1115 1116 rx <<= 1; 1117 ry <<= 1; 1118 rt <<= 1; 1119 lt <<= 1; 1120 1121 input_report_abs(wdata->extension.input, ABS_HAT1X, lx); 1122 input_report_abs(wdata->extension.input, ABS_HAT1Y, ly); 1123 input_report_abs(wdata->extension.input, ABS_HAT2X, rx - 0x20); 1124 input_report_abs(wdata->extension.input, ABS_HAT2Y, ry - 0x20); 1125 input_report_abs(wdata->extension.input, ABS_HAT3X, rt); 1126 input_report_abs(wdata->extension.input, ABS_HAT3Y, lt); 1127 1128 input_report_key(wdata->extension.input, 1129 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LT], 1130 !(ext[4] & 0x20)); 1131 input_report_key(wdata->extension.input, 1132 wiimod_classic_map[WIIMOD_CLASSIC_KEY_MINUS], 1133 !(ext[4] & 0x10)); 1134 input_report_key(wdata->extension.input, 1135 wiimod_classic_map[WIIMOD_CLASSIC_KEY_HOME], 1136 !(ext[4] & 0x08)); 1137 input_report_key(wdata->extension.input, 1138 wiimod_classic_map[WIIMOD_CLASSIC_KEY_PLUS], 1139 !(ext[4] & 0x04)); 1140 input_report_key(wdata->extension.input, 1141 wiimod_classic_map[WIIMOD_CLASSIC_KEY_RT], 1142 !(ext[4] & 0x02)); 1143 input_report_key(wdata->extension.input, 1144 wiimod_classic_map[WIIMOD_CLASSIC_KEY_ZL], 1145 !(ext[5] & 0x80)); 1146 input_report_key(wdata->extension.input, 1147 wiimod_classic_map[WIIMOD_CLASSIC_KEY_B], 1148 !(ext[5] & 0x40)); 1149 input_report_key(wdata->extension.input, 1150 wiimod_classic_map[WIIMOD_CLASSIC_KEY_Y], 1151 !(ext[5] & 0x20)); 1152 input_report_key(wdata->extension.input, 1153 wiimod_classic_map[WIIMOD_CLASSIC_KEY_A], 1154 !(ext[5] & 0x10)); 1155 input_report_key(wdata->extension.input, 1156 wiimod_classic_map[WIIMOD_CLASSIC_KEY_X], 1157 !(ext[5] & 0x08)); 1158 input_report_key(wdata->extension.input, 1159 wiimod_classic_map[WIIMOD_CLASSIC_KEY_ZR], 1160 !(ext[5] & 0x04)); 1161 1162 if (!wiimote_dpad_as_analog) { 1163 input_report_key(wdata->extension.input, 1164 wiimod_classic_map[WIIMOD_CLASSIC_KEY_RIGHT], 1165 !(ext[4] & 0x80)); 1166 input_report_key(wdata->extension.input, 1167 wiimod_classic_map[WIIMOD_CLASSIC_KEY_DOWN], 1168 !(ext[4] & 0x40)); 1169 1170 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 1171 input_report_key(wdata->extension.input, 1172 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LEFT], 1173 !(ext[1] & 0x01)); 1174 input_report_key(wdata->extension.input, 1175 wiimod_classic_map[WIIMOD_CLASSIC_KEY_UP], 1176 !(ext[0] & 0x01)); 1177 } else { 1178 input_report_key(wdata->extension.input, 1179 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LEFT], 1180 !(ext[5] & 0x02)); 1181 input_report_key(wdata->extension.input, 1182 wiimod_classic_map[WIIMOD_CLASSIC_KEY_UP], 1183 !(ext[5] & 0x01)); 1184 } 1185 } 1186 1187 input_sync(wdata->extension.input); 1188 } 1189 1190 static int wiimod_classic_open(struct input_dev *dev) 1191 { 1192 struct wiimote_data *wdata = input_get_drvdata(dev); 1193 unsigned long flags; 1194 1195 spin_lock_irqsave(&wdata->state.lock, flags); 1196 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 1197 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1198 spin_unlock_irqrestore(&wdata->state.lock, flags); 1199 1200 return 0; 1201 } 1202 1203 static void wiimod_classic_close(struct input_dev *dev) 1204 { 1205 struct wiimote_data *wdata = input_get_drvdata(dev); 1206 unsigned long flags; 1207 1208 spin_lock_irqsave(&wdata->state.lock, flags); 1209 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 1210 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1211 spin_unlock_irqrestore(&wdata->state.lock, flags); 1212 } 1213 1214 static int wiimod_classic_probe(const struct wiimod_ops *ops, 1215 struct wiimote_data *wdata) 1216 { 1217 int ret, i; 1218 1219 wdata->extension.input = input_allocate_device(); 1220 if (!wdata->extension.input) 1221 return -ENOMEM; 1222 1223 input_set_drvdata(wdata->extension.input, wdata); 1224 wdata->extension.input->open = wiimod_classic_open; 1225 wdata->extension.input->close = wiimod_classic_close; 1226 wdata->extension.input->dev.parent = &wdata->hdev->dev; 1227 wdata->extension.input->id.bustype = wdata->hdev->bus; 1228 wdata->extension.input->id.vendor = wdata->hdev->vendor; 1229 wdata->extension.input->id.product = wdata->hdev->product; 1230 wdata->extension.input->id.version = wdata->hdev->version; 1231 wdata->extension.input->name = WIIMOTE_NAME " Classic Controller"; 1232 1233 set_bit(EV_KEY, wdata->extension.input->evbit); 1234 for (i = 0; i < WIIMOD_CLASSIC_KEY_NUM; ++i) 1235 set_bit(wiimod_classic_map[i], 1236 wdata->extension.input->keybit); 1237 1238 set_bit(EV_ABS, wdata->extension.input->evbit); 1239 set_bit(ABS_HAT1X, wdata->extension.input->absbit); 1240 set_bit(ABS_HAT1Y, wdata->extension.input->absbit); 1241 set_bit(ABS_HAT2X, wdata->extension.input->absbit); 1242 set_bit(ABS_HAT2Y, wdata->extension.input->absbit); 1243 set_bit(ABS_HAT3X, wdata->extension.input->absbit); 1244 set_bit(ABS_HAT3Y, wdata->extension.input->absbit); 1245 input_set_abs_params(wdata->extension.input, 1246 ABS_HAT1X, -30, 30, 1, 1); 1247 input_set_abs_params(wdata->extension.input, 1248 ABS_HAT1Y, -30, 30, 1, 1); 1249 input_set_abs_params(wdata->extension.input, 1250 ABS_HAT2X, -30, 30, 1, 1); 1251 input_set_abs_params(wdata->extension.input, 1252 ABS_HAT2Y, -30, 30, 1, 1); 1253 input_set_abs_params(wdata->extension.input, 1254 ABS_HAT3X, -30, 30, 1, 1); 1255 input_set_abs_params(wdata->extension.input, 1256 ABS_HAT3Y, -30, 30, 1, 1); 1257 1258 ret = input_register_device(wdata->extension.input); 1259 if (ret) 1260 goto err_free; 1261 1262 return 0; 1263 1264 err_free: 1265 input_free_device(wdata->extension.input); 1266 wdata->extension.input = NULL; 1267 return ret; 1268 } 1269 1270 static void wiimod_classic_remove(const struct wiimod_ops *ops, 1271 struct wiimote_data *wdata) 1272 { 1273 if (!wdata->extension.input) 1274 return; 1275 1276 input_unregister_device(wdata->extension.input); 1277 wdata->extension.input = NULL; 1278 } 1279 1280 static const struct wiimod_ops wiimod_classic = { 1281 .flags = 0, 1282 .arg = 0, 1283 .probe = wiimod_classic_probe, 1284 .remove = wiimod_classic_remove, 1285 .in_ext = wiimod_classic_in_ext, 1286 }; 1287 1288 /* 1289 * Balance Board Extension 1290 * The Nintendo Wii Balance Board provides four hardware weight sensor plus a 1291 * single push button. No other peripherals are available. However, the 1292 * balance-board data is sent via a standard Wii Remote extension. All other 1293 * data for non-present hardware is zeroed out. 1294 * Some 3rd party devices react allergic if we try to access normal Wii Remote 1295 * hardware, so this extension module should be the only module that is loaded 1296 * on balance boards. 1297 * The balance board needs 8 bytes extension data instead of basic 6 bytes so 1298 * it needs the WIIMOD_FLAG_EXT8 flag. 1299 */ 1300 1301 static void wiimod_bboard_in_keys(struct wiimote_data *wdata, const __u8 *keys) 1302 { 1303 input_report_key(wdata->extension.input, BTN_A, 1304 !!(keys[1] & 0x08)); 1305 input_sync(wdata->extension.input); 1306 } 1307 1308 static void wiimod_bboard_in_ext(struct wiimote_data *wdata, 1309 const __u8 *ext) 1310 { 1311 __s32 val[4], tmp, div; 1312 unsigned int i; 1313 struct wiimote_state *s = &wdata->state; 1314 1315 /* 1316 * Balance board data layout: 1317 * 1318 * Byte | 8 7 6 5 4 3 2 1 | 1319 * -----+--------------------------+ 1320 * 1 | Top Right <15:8> | 1321 * 2 | Top Right <7:0> | 1322 * -----+--------------------------+ 1323 * 3 | Bottom Right <15:8> | 1324 * 4 | Bottom Right <7:0> | 1325 * -----+--------------------------+ 1326 * 5 | Top Left <15:8> | 1327 * 6 | Top Left <7:0> | 1328 * -----+--------------------------+ 1329 * 7 | Bottom Left <15:8> | 1330 * 8 | Bottom Left <7:0> | 1331 * -----+--------------------------+ 1332 * 1333 * These values represent the weight-measurements of the Wii-balance 1334 * board with 16bit precision. 1335 * 1336 * The balance-board is never reported interleaved with motionp. 1337 */ 1338 1339 val[0] = ext[0]; 1340 val[0] <<= 8; 1341 val[0] |= ext[1]; 1342 1343 val[1] = ext[2]; 1344 val[1] <<= 8; 1345 val[1] |= ext[3]; 1346 1347 val[2] = ext[4]; 1348 val[2] <<= 8; 1349 val[2] |= ext[5]; 1350 1351 val[3] = ext[6]; 1352 val[3] <<= 8; 1353 val[3] |= ext[7]; 1354 1355 /* apply calibration data */ 1356 for (i = 0; i < 4; i++) { 1357 if (val[i] <= s->calib_bboard[i][0]) { 1358 tmp = 0; 1359 } else if (val[i] < s->calib_bboard[i][1]) { 1360 tmp = val[i] - s->calib_bboard[i][0]; 1361 tmp *= 1700; 1362 div = s->calib_bboard[i][1] - s->calib_bboard[i][0]; 1363 tmp /= div ? div : 1; 1364 } else { 1365 tmp = val[i] - s->calib_bboard[i][1]; 1366 tmp *= 1700; 1367 div = s->calib_bboard[i][2] - s->calib_bboard[i][1]; 1368 tmp /= div ? div : 1; 1369 tmp += 1700; 1370 } 1371 val[i] = tmp; 1372 } 1373 1374 input_report_abs(wdata->extension.input, ABS_HAT0X, val[0]); 1375 input_report_abs(wdata->extension.input, ABS_HAT0Y, val[1]); 1376 input_report_abs(wdata->extension.input, ABS_HAT1X, val[2]); 1377 input_report_abs(wdata->extension.input, ABS_HAT1Y, val[3]); 1378 input_sync(wdata->extension.input); 1379 } 1380 1381 static int wiimod_bboard_open(struct input_dev *dev) 1382 { 1383 struct wiimote_data *wdata = input_get_drvdata(dev); 1384 unsigned long flags; 1385 1386 spin_lock_irqsave(&wdata->state.lock, flags); 1387 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 1388 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1389 spin_unlock_irqrestore(&wdata->state.lock, flags); 1390 1391 return 0; 1392 } 1393 1394 static void wiimod_bboard_close(struct input_dev *dev) 1395 { 1396 struct wiimote_data *wdata = input_get_drvdata(dev); 1397 unsigned long flags; 1398 1399 spin_lock_irqsave(&wdata->state.lock, flags); 1400 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 1401 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1402 spin_unlock_irqrestore(&wdata->state.lock, flags); 1403 } 1404 1405 static ssize_t wiimod_bboard_calib_show(struct device *dev, 1406 struct device_attribute *attr, 1407 char *out) 1408 { 1409 struct wiimote_data *wdata = dev_to_wii(dev); 1410 int i, j, ret; 1411 __u16 val; 1412 __u8 buf[24], offs; 1413 1414 ret = wiimote_cmd_acquire(wdata); 1415 if (ret) 1416 return ret; 1417 1418 ret = wiimote_cmd_read(wdata, 0xa40024, buf, 12); 1419 if (ret != 12) { 1420 wiimote_cmd_release(wdata); 1421 return ret < 0 ? ret : -EIO; 1422 } 1423 ret = wiimote_cmd_read(wdata, 0xa40024 + 12, buf + 12, 12); 1424 if (ret != 12) { 1425 wiimote_cmd_release(wdata); 1426 return ret < 0 ? ret : -EIO; 1427 } 1428 1429 wiimote_cmd_release(wdata); 1430 1431 spin_lock_irq(&wdata->state.lock); 1432 offs = 0; 1433 for (i = 0; i < 3; ++i) { 1434 for (j = 0; j < 4; ++j) { 1435 wdata->state.calib_bboard[j][i] = buf[offs]; 1436 wdata->state.calib_bboard[j][i] <<= 8; 1437 wdata->state.calib_bboard[j][i] |= buf[offs + 1]; 1438 offs += 2; 1439 } 1440 } 1441 spin_unlock_irq(&wdata->state.lock); 1442 1443 ret = 0; 1444 for (i = 0; i < 3; ++i) { 1445 for (j = 0; j < 4; ++j) { 1446 val = wdata->state.calib_bboard[j][i]; 1447 if (i == 2 && j == 3) 1448 ret += sprintf(&out[ret], "%04x\n", val); 1449 else 1450 ret += sprintf(&out[ret], "%04x:", val); 1451 } 1452 } 1453 1454 return ret; 1455 } 1456 1457 static DEVICE_ATTR(bboard_calib, S_IRUGO, wiimod_bboard_calib_show, NULL); 1458 1459 static int wiimod_bboard_probe(const struct wiimod_ops *ops, 1460 struct wiimote_data *wdata) 1461 { 1462 int ret, i, j; 1463 __u8 buf[24], offs; 1464 1465 wiimote_cmd_acquire_noint(wdata); 1466 1467 ret = wiimote_cmd_read(wdata, 0xa40024, buf, 12); 1468 if (ret != 12) { 1469 wiimote_cmd_release(wdata); 1470 return ret < 0 ? ret : -EIO; 1471 } 1472 ret = wiimote_cmd_read(wdata, 0xa40024 + 12, buf + 12, 12); 1473 if (ret != 12) { 1474 wiimote_cmd_release(wdata); 1475 return ret < 0 ? ret : -EIO; 1476 } 1477 1478 wiimote_cmd_release(wdata); 1479 1480 offs = 0; 1481 for (i = 0; i < 3; ++i) { 1482 for (j = 0; j < 4; ++j) { 1483 wdata->state.calib_bboard[j][i] = buf[offs]; 1484 wdata->state.calib_bboard[j][i] <<= 8; 1485 wdata->state.calib_bboard[j][i] |= buf[offs + 1]; 1486 offs += 2; 1487 } 1488 } 1489 1490 wdata->extension.input = input_allocate_device(); 1491 if (!wdata->extension.input) 1492 return -ENOMEM; 1493 1494 ret = device_create_file(&wdata->hdev->dev, 1495 &dev_attr_bboard_calib); 1496 if (ret) { 1497 hid_err(wdata->hdev, "cannot create sysfs attribute\n"); 1498 goto err_free; 1499 } 1500 1501 input_set_drvdata(wdata->extension.input, wdata); 1502 wdata->extension.input->open = wiimod_bboard_open; 1503 wdata->extension.input->close = wiimod_bboard_close; 1504 wdata->extension.input->dev.parent = &wdata->hdev->dev; 1505 wdata->extension.input->id.bustype = wdata->hdev->bus; 1506 wdata->extension.input->id.vendor = wdata->hdev->vendor; 1507 wdata->extension.input->id.product = wdata->hdev->product; 1508 wdata->extension.input->id.version = wdata->hdev->version; 1509 wdata->extension.input->name = WIIMOTE_NAME " Balance Board"; 1510 1511 set_bit(EV_KEY, wdata->extension.input->evbit); 1512 set_bit(BTN_A, wdata->extension.input->keybit); 1513 1514 set_bit(EV_ABS, wdata->extension.input->evbit); 1515 set_bit(ABS_HAT0X, wdata->extension.input->absbit); 1516 set_bit(ABS_HAT0Y, wdata->extension.input->absbit); 1517 set_bit(ABS_HAT1X, wdata->extension.input->absbit); 1518 set_bit(ABS_HAT1Y, wdata->extension.input->absbit); 1519 input_set_abs_params(wdata->extension.input, 1520 ABS_HAT0X, 0, 65535, 2, 4); 1521 input_set_abs_params(wdata->extension.input, 1522 ABS_HAT0Y, 0, 65535, 2, 4); 1523 input_set_abs_params(wdata->extension.input, 1524 ABS_HAT1X, 0, 65535, 2, 4); 1525 input_set_abs_params(wdata->extension.input, 1526 ABS_HAT1Y, 0, 65535, 2, 4); 1527 1528 ret = input_register_device(wdata->extension.input); 1529 if (ret) 1530 goto err_file; 1531 1532 return 0; 1533 1534 err_file: 1535 device_remove_file(&wdata->hdev->dev, 1536 &dev_attr_bboard_calib); 1537 err_free: 1538 input_free_device(wdata->extension.input); 1539 wdata->extension.input = NULL; 1540 return ret; 1541 } 1542 1543 static void wiimod_bboard_remove(const struct wiimod_ops *ops, 1544 struct wiimote_data *wdata) 1545 { 1546 if (!wdata->extension.input) 1547 return; 1548 1549 input_unregister_device(wdata->extension.input); 1550 wdata->extension.input = NULL; 1551 device_remove_file(&wdata->hdev->dev, 1552 &dev_attr_bboard_calib); 1553 } 1554 1555 static const struct wiimod_ops wiimod_bboard = { 1556 .flags = WIIMOD_FLAG_EXT8, 1557 .arg = 0, 1558 .probe = wiimod_bboard_probe, 1559 .remove = wiimod_bboard_remove, 1560 .in_keys = wiimod_bboard_in_keys, 1561 .in_ext = wiimod_bboard_in_ext, 1562 }; 1563 1564 /* 1565 * Pro Controller 1566 * Released with the Wii U was the Nintendo Wii U Pro Controller. It does not 1567 * work together with the classic Wii, but only with the new Wii U. However, it 1568 * uses the same protocol and provides a builtin "classic controller pro" 1569 * extension, few standard buttons, a rumble motor, 4 LEDs and a battery. 1570 * We provide all these via a standard extension device as the device doesn't 1571 * feature an extension port. 1572 */ 1573 1574 enum wiimod_pro_keys { 1575 WIIMOD_PRO_KEY_A, 1576 WIIMOD_PRO_KEY_B, 1577 WIIMOD_PRO_KEY_X, 1578 WIIMOD_PRO_KEY_Y, 1579 WIIMOD_PRO_KEY_PLUS, 1580 WIIMOD_PRO_KEY_MINUS, 1581 WIIMOD_PRO_KEY_HOME, 1582 WIIMOD_PRO_KEY_LEFT, 1583 WIIMOD_PRO_KEY_RIGHT, 1584 WIIMOD_PRO_KEY_UP, 1585 WIIMOD_PRO_KEY_DOWN, 1586 WIIMOD_PRO_KEY_TL, 1587 WIIMOD_PRO_KEY_TR, 1588 WIIMOD_PRO_KEY_ZL, 1589 WIIMOD_PRO_KEY_ZR, 1590 WIIMOD_PRO_KEY_THUMBL, 1591 WIIMOD_PRO_KEY_THUMBR, 1592 WIIMOD_PRO_KEY_NUM, 1593 }; 1594 1595 static const __u16 wiimod_pro_map[] = { 1596 BTN_EAST, /* WIIMOD_PRO_KEY_A */ 1597 BTN_SOUTH, /* WIIMOD_PRO_KEY_B */ 1598 BTN_NORTH, /* WIIMOD_PRO_KEY_X */ 1599 BTN_WEST, /* WIIMOD_PRO_KEY_Y */ 1600 BTN_START, /* WIIMOD_PRO_KEY_PLUS */ 1601 BTN_SELECT, /* WIIMOD_PRO_KEY_MINUS */ 1602 BTN_MODE, /* WIIMOD_PRO_KEY_HOME */ 1603 BTN_DPAD_LEFT, /* WIIMOD_PRO_KEY_LEFT */ 1604 BTN_DPAD_RIGHT, /* WIIMOD_PRO_KEY_RIGHT */ 1605 BTN_DPAD_UP, /* WIIMOD_PRO_KEY_UP */ 1606 BTN_DPAD_DOWN, /* WIIMOD_PRO_KEY_DOWN */ 1607 BTN_TL, /* WIIMOD_PRO_KEY_TL */ 1608 BTN_TR, /* WIIMOD_PRO_KEY_TR */ 1609 BTN_TL2, /* WIIMOD_PRO_KEY_ZL */ 1610 BTN_TR2, /* WIIMOD_PRO_KEY_ZR */ 1611 BTN_THUMBL, /* WIIMOD_PRO_KEY_THUMBL */ 1612 BTN_THUMBR, /* WIIMOD_PRO_KEY_THUMBR */ 1613 }; 1614 1615 static void wiimod_pro_in_ext(struct wiimote_data *wdata, const __u8 *ext) 1616 { 1617 __s16 rx, ry, lx, ly; 1618 1619 /* Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 1620 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1621 * 1 | LX <7:0> | 1622 * -----+-----------------------+-----------------------+ 1623 * 2 | 0 0 0 0 | LX <11:8> | 1624 * -----+-----------------------+-----------------------+ 1625 * 3 | RX <7:0> | 1626 * -----+-----------------------+-----------------------+ 1627 * 4 | 0 0 0 0 | RX <11:8> | 1628 * -----+-----------------------+-----------------------+ 1629 * 5 | LY <7:0> | 1630 * -----+-----------------------+-----------------------+ 1631 * 6 | 0 0 0 0 | LY <11:8> | 1632 * -----+-----------------------+-----------------------+ 1633 * 7 | RY <7:0> | 1634 * -----+-----------------------+-----------------------+ 1635 * 8 | 0 0 0 0 | RY <11:8> | 1636 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1637 * 9 | BDR | BDD | BLT | B- | BH | B+ | BRT | 1 | 1638 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1639 * 10 | BZL | BB | BY | BA | BX | BZR | BDL | BDU | 1640 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1641 * 11 | 1 | BATTERY | USB |CHARG|LTHUM|RTHUM| 1642 * -----+-----+-----------------+-----------+-----+-----+ 1643 * All buttons are low-active (0 if pressed) 1644 * RX and RY are right analog stick 1645 * LX and LY are left analog stick 1646 * BLT is left trigger, BRT is right trigger. 1647 * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons 1648 * BZL is left Z button and BZR is right Z button 1649 * B-, BH, B+ are +, HOME and - buttons 1650 * BB, BY, BA, BX are A, B, X, Y buttons 1651 * 1652 * Bits marked as 0/1 are unknown and never changed during tests. 1653 * 1654 * Not entirely verified: 1655 * CHARG: 1 if uncharging, 0 if charging 1656 * USB: 1 if not connected, 0 if connected 1657 * BATTERY: battery capacity from 000 (empty) to 100 (full) 1658 */ 1659 1660 lx = (ext[0] & 0xff) | ((ext[1] & 0x0f) << 8); 1661 rx = (ext[2] & 0xff) | ((ext[3] & 0x0f) << 8); 1662 ly = (ext[4] & 0xff) | ((ext[5] & 0x0f) << 8); 1663 ry = (ext[6] & 0xff) | ((ext[7] & 0x0f) << 8); 1664 1665 /* zero-point offsets */ 1666 lx -= 0x800; 1667 ly = 0x800 - ly; 1668 rx -= 0x800; 1669 ry = 0x800 - ry; 1670 1671 /* Trivial automatic calibration. We don't know any calibration data 1672 * in the EEPROM so we must use the first report to calibrate the 1673 * null-position of the analog sticks. Users can retrigger calibration 1674 * via sysfs, or set it explicitly. If data is off more than abs(500), 1675 * we skip calibration as the sticks are likely to be moved already. */ 1676 if (!(wdata->state.flags & WIIPROTO_FLAG_PRO_CALIB_DONE)) { 1677 wdata->state.flags |= WIIPROTO_FLAG_PRO_CALIB_DONE; 1678 if (abs(lx) < 500) 1679 wdata->state.calib_pro_sticks[0] = -lx; 1680 if (abs(ly) < 500) 1681 wdata->state.calib_pro_sticks[1] = -ly; 1682 if (abs(rx) < 500) 1683 wdata->state.calib_pro_sticks[2] = -rx; 1684 if (abs(ry) < 500) 1685 wdata->state.calib_pro_sticks[3] = -ry; 1686 } 1687 1688 /* apply calibration data */ 1689 lx += wdata->state.calib_pro_sticks[0]; 1690 ly += wdata->state.calib_pro_sticks[1]; 1691 rx += wdata->state.calib_pro_sticks[2]; 1692 ry += wdata->state.calib_pro_sticks[3]; 1693 1694 input_report_abs(wdata->extension.input, ABS_X, lx); 1695 input_report_abs(wdata->extension.input, ABS_Y, ly); 1696 input_report_abs(wdata->extension.input, ABS_RX, rx); 1697 input_report_abs(wdata->extension.input, ABS_RY, ry); 1698 1699 input_report_key(wdata->extension.input, 1700 wiimod_pro_map[WIIMOD_PRO_KEY_RIGHT], 1701 !(ext[8] & 0x80)); 1702 input_report_key(wdata->extension.input, 1703 wiimod_pro_map[WIIMOD_PRO_KEY_DOWN], 1704 !(ext[8] & 0x40)); 1705 input_report_key(wdata->extension.input, 1706 wiimod_pro_map[WIIMOD_PRO_KEY_TL], 1707 !(ext[8] & 0x20)); 1708 input_report_key(wdata->extension.input, 1709 wiimod_pro_map[WIIMOD_PRO_KEY_MINUS], 1710 !(ext[8] & 0x10)); 1711 input_report_key(wdata->extension.input, 1712 wiimod_pro_map[WIIMOD_PRO_KEY_HOME], 1713 !(ext[8] & 0x08)); 1714 input_report_key(wdata->extension.input, 1715 wiimod_pro_map[WIIMOD_PRO_KEY_PLUS], 1716 !(ext[8] & 0x04)); 1717 input_report_key(wdata->extension.input, 1718 wiimod_pro_map[WIIMOD_PRO_KEY_TR], 1719 !(ext[8] & 0x02)); 1720 1721 input_report_key(wdata->extension.input, 1722 wiimod_pro_map[WIIMOD_PRO_KEY_ZL], 1723 !(ext[9] & 0x80)); 1724 input_report_key(wdata->extension.input, 1725 wiimod_pro_map[WIIMOD_PRO_KEY_B], 1726 !(ext[9] & 0x40)); 1727 input_report_key(wdata->extension.input, 1728 wiimod_pro_map[WIIMOD_PRO_KEY_Y], 1729 !(ext[9] & 0x20)); 1730 input_report_key(wdata->extension.input, 1731 wiimod_pro_map[WIIMOD_PRO_KEY_A], 1732 !(ext[9] & 0x10)); 1733 input_report_key(wdata->extension.input, 1734 wiimod_pro_map[WIIMOD_PRO_KEY_X], 1735 !(ext[9] & 0x08)); 1736 input_report_key(wdata->extension.input, 1737 wiimod_pro_map[WIIMOD_PRO_KEY_ZR], 1738 !(ext[9] & 0x04)); 1739 input_report_key(wdata->extension.input, 1740 wiimod_pro_map[WIIMOD_PRO_KEY_LEFT], 1741 !(ext[9] & 0x02)); 1742 input_report_key(wdata->extension.input, 1743 wiimod_pro_map[WIIMOD_PRO_KEY_UP], 1744 !(ext[9] & 0x01)); 1745 1746 input_report_key(wdata->extension.input, 1747 wiimod_pro_map[WIIMOD_PRO_KEY_THUMBL], 1748 !(ext[10] & 0x02)); 1749 input_report_key(wdata->extension.input, 1750 wiimod_pro_map[WIIMOD_PRO_KEY_THUMBR], 1751 !(ext[10] & 0x01)); 1752 1753 input_sync(wdata->extension.input); 1754 } 1755 1756 static int wiimod_pro_open(struct input_dev *dev) 1757 { 1758 struct wiimote_data *wdata = input_get_drvdata(dev); 1759 unsigned long flags; 1760 1761 spin_lock_irqsave(&wdata->state.lock, flags); 1762 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 1763 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1764 spin_unlock_irqrestore(&wdata->state.lock, flags); 1765 1766 return 0; 1767 } 1768 1769 static void wiimod_pro_close(struct input_dev *dev) 1770 { 1771 struct wiimote_data *wdata = input_get_drvdata(dev); 1772 unsigned long flags; 1773 1774 spin_lock_irqsave(&wdata->state.lock, flags); 1775 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 1776 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1777 spin_unlock_irqrestore(&wdata->state.lock, flags); 1778 } 1779 1780 static int wiimod_pro_play(struct input_dev *dev, void *data, 1781 struct ff_effect *eff) 1782 { 1783 struct wiimote_data *wdata = input_get_drvdata(dev); 1784 __u8 value; 1785 1786 /* 1787 * The wiimote supports only a single rumble motor so if any magnitude 1788 * is set to non-zero then we start the rumble motor. If both are set to 1789 * zero, we stop the rumble motor. 1790 */ 1791 1792 if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude) 1793 value = 1; 1794 else 1795 value = 0; 1796 1797 /* Locking state.lock here might deadlock with input_event() calls. 1798 * schedule_work acts as barrier. Merging multiple changes is fine. */ 1799 wdata->state.cache_rumble = value; 1800 schedule_work(&wdata->rumble_worker); 1801 1802 return 0; 1803 } 1804 1805 static ssize_t wiimod_pro_calib_show(struct device *dev, 1806 struct device_attribute *attr, 1807 char *out) 1808 { 1809 struct wiimote_data *wdata = dev_to_wii(dev); 1810 int r; 1811 1812 r = 0; 1813 r += sprintf(&out[r], "%+06hd:", wdata->state.calib_pro_sticks[0]); 1814 r += sprintf(&out[r], "%+06hd ", wdata->state.calib_pro_sticks[1]); 1815 r += sprintf(&out[r], "%+06hd:", wdata->state.calib_pro_sticks[2]); 1816 r += sprintf(&out[r], "%+06hd\n", wdata->state.calib_pro_sticks[3]); 1817 1818 return r; 1819 } 1820 1821 static ssize_t wiimod_pro_calib_store(struct device *dev, 1822 struct device_attribute *attr, 1823 const char *buf, size_t count) 1824 { 1825 struct wiimote_data *wdata = dev_to_wii(dev); 1826 int r; 1827 s16 x1, y1, x2, y2; 1828 1829 if (!strncmp(buf, "scan\n", 5)) { 1830 spin_lock_irq(&wdata->state.lock); 1831 wdata->state.flags &= ~WIIPROTO_FLAG_PRO_CALIB_DONE; 1832 spin_unlock_irq(&wdata->state.lock); 1833 } else { 1834 r = sscanf(buf, "%hd:%hd %hd:%hd", &x1, &y1, &x2, &y2); 1835 if (r != 4) 1836 return -EINVAL; 1837 1838 spin_lock_irq(&wdata->state.lock); 1839 wdata->state.flags |= WIIPROTO_FLAG_PRO_CALIB_DONE; 1840 spin_unlock_irq(&wdata->state.lock); 1841 1842 wdata->state.calib_pro_sticks[0] = x1; 1843 wdata->state.calib_pro_sticks[1] = y1; 1844 wdata->state.calib_pro_sticks[2] = x2; 1845 wdata->state.calib_pro_sticks[3] = y2; 1846 } 1847 1848 return strnlen(buf, PAGE_SIZE); 1849 } 1850 1851 static DEVICE_ATTR(pro_calib, S_IRUGO|S_IWUSR|S_IWGRP, wiimod_pro_calib_show, 1852 wiimod_pro_calib_store); 1853 1854 static int wiimod_pro_probe(const struct wiimod_ops *ops, 1855 struct wiimote_data *wdata) 1856 { 1857 int ret, i; 1858 unsigned long flags; 1859 1860 INIT_WORK(&wdata->rumble_worker, wiimod_rumble_worker); 1861 wdata->state.calib_pro_sticks[0] = 0; 1862 wdata->state.calib_pro_sticks[1] = 0; 1863 wdata->state.calib_pro_sticks[2] = 0; 1864 wdata->state.calib_pro_sticks[3] = 0; 1865 1866 spin_lock_irqsave(&wdata->state.lock, flags); 1867 wdata->state.flags &= ~WIIPROTO_FLAG_PRO_CALIB_DONE; 1868 spin_unlock_irqrestore(&wdata->state.lock, flags); 1869 1870 wdata->extension.input = input_allocate_device(); 1871 if (!wdata->extension.input) 1872 return -ENOMEM; 1873 1874 set_bit(FF_RUMBLE, wdata->extension.input->ffbit); 1875 input_set_drvdata(wdata->extension.input, wdata); 1876 1877 if (input_ff_create_memless(wdata->extension.input, NULL, 1878 wiimod_pro_play)) { 1879 ret = -ENOMEM; 1880 goto err_free; 1881 } 1882 1883 ret = device_create_file(&wdata->hdev->dev, 1884 &dev_attr_pro_calib); 1885 if (ret) { 1886 hid_err(wdata->hdev, "cannot create sysfs attribute\n"); 1887 goto err_free; 1888 } 1889 1890 wdata->extension.input->open = wiimod_pro_open; 1891 wdata->extension.input->close = wiimod_pro_close; 1892 wdata->extension.input->dev.parent = &wdata->hdev->dev; 1893 wdata->extension.input->id.bustype = wdata->hdev->bus; 1894 wdata->extension.input->id.vendor = wdata->hdev->vendor; 1895 wdata->extension.input->id.product = wdata->hdev->product; 1896 wdata->extension.input->id.version = wdata->hdev->version; 1897 wdata->extension.input->name = WIIMOTE_NAME " Pro Controller"; 1898 1899 set_bit(EV_KEY, wdata->extension.input->evbit); 1900 for (i = 0; i < WIIMOD_PRO_KEY_NUM; ++i) 1901 set_bit(wiimod_pro_map[i], 1902 wdata->extension.input->keybit); 1903 1904 set_bit(EV_ABS, wdata->extension.input->evbit); 1905 set_bit(ABS_X, wdata->extension.input->absbit); 1906 set_bit(ABS_Y, wdata->extension.input->absbit); 1907 set_bit(ABS_RX, wdata->extension.input->absbit); 1908 set_bit(ABS_RY, wdata->extension.input->absbit); 1909 input_set_abs_params(wdata->extension.input, 1910 ABS_X, -0x400, 0x400, 4, 100); 1911 input_set_abs_params(wdata->extension.input, 1912 ABS_Y, -0x400, 0x400, 4, 100); 1913 input_set_abs_params(wdata->extension.input, 1914 ABS_RX, -0x400, 0x400, 4, 100); 1915 input_set_abs_params(wdata->extension.input, 1916 ABS_RY, -0x400, 0x400, 4, 100); 1917 1918 ret = input_register_device(wdata->extension.input); 1919 if (ret) 1920 goto err_file; 1921 1922 return 0; 1923 1924 err_file: 1925 device_remove_file(&wdata->hdev->dev, 1926 &dev_attr_pro_calib); 1927 err_free: 1928 input_free_device(wdata->extension.input); 1929 wdata->extension.input = NULL; 1930 return ret; 1931 } 1932 1933 static void wiimod_pro_remove(const struct wiimod_ops *ops, 1934 struct wiimote_data *wdata) 1935 { 1936 unsigned long flags; 1937 1938 if (!wdata->extension.input) 1939 return; 1940 1941 input_unregister_device(wdata->extension.input); 1942 wdata->extension.input = NULL; 1943 cancel_work_sync(&wdata->rumble_worker); 1944 device_remove_file(&wdata->hdev->dev, 1945 &dev_attr_pro_calib); 1946 1947 spin_lock_irqsave(&wdata->state.lock, flags); 1948 wiiproto_req_rumble(wdata, 0); 1949 spin_unlock_irqrestore(&wdata->state.lock, flags); 1950 } 1951 1952 static const struct wiimod_ops wiimod_pro = { 1953 .flags = WIIMOD_FLAG_EXT16, 1954 .arg = 0, 1955 .probe = wiimod_pro_probe, 1956 .remove = wiimod_pro_remove, 1957 .in_ext = wiimod_pro_in_ext, 1958 }; 1959 1960 /* 1961 * Drums 1962 * Guitar-Hero, Rock-Band and other games came bundled with drums which can 1963 * be plugged as extension to a Wiimote. Drum-reports are still not entirely 1964 * figured out, but the most important information is known. 1965 * We create a separate device for drums and report all information via this 1966 * input device. 1967 */ 1968 1969 static inline void wiimod_drums_report_pressure(struct wiimote_data *wdata, 1970 __u8 none, __u8 which, 1971 __u8 pressure, __u8 onoff, 1972 __u8 *store, __u16 code, 1973 __u8 which_code) 1974 { 1975 static const __u8 default_pressure = 3; 1976 1977 if (!none && which == which_code) { 1978 *store = pressure; 1979 input_report_abs(wdata->extension.input, code, *store); 1980 } else if (onoff != !!*store) { 1981 *store = onoff ? default_pressure : 0; 1982 input_report_abs(wdata->extension.input, code, *store); 1983 } 1984 } 1985 1986 static void wiimod_drums_in_ext(struct wiimote_data *wdata, const __u8 *ext) 1987 { 1988 __u8 pressure, which, none, hhp, sx, sy; 1989 __u8 o, r, y, g, b, bass, bm, bp; 1990 1991 /* Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 1992 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1993 * 1 | 0 | 0 | SX <5:0> | 1994 * 2 | 0 | 0 | SY <5:0> | 1995 * -----+-----+-----+-----------------------------+-----+ 1996 * 3 | HPP | NON | WHICH <5:1> | ? | 1997 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1998 * 4 | SOFT <7:5> | 0 | 1 | 1 | 0 | ? | 1999 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2000 * 5 | ? | 1 | 1 | B- | 1 | B+ | 1 | ? | 2001 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2002 * 6 | O | R | Y | G | B | BSS | 1 | 1 | 2003 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2004 * All buttons are 0 if pressed 2005 * 2006 * With Motion+ enabled, the following bits will get invalid: 2007 * Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 2008 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2009 * 1 | 0 | 0 | SX <5:1> |XXXXX| 2010 * 2 | 0 | 0 | SY <5:1> |XXXXX| 2011 * -----+-----+-----+-----------------------------+-----+ 2012 * 3 | HPP | NON | WHICH <5:1> | ? | 2013 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2014 * 4 | SOFT <7:5> | 0 | 1 | 1 | 0 | ? | 2015 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2016 * 5 | ? | 1 | 1 | B- | 1 | B+ | 1 |XXXXX| 2017 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2018 * 6 | O | R | Y | G | B | BSS |XXXXX|XXXXX| 2019 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2020 */ 2021 2022 pressure = 7 - (ext[3] >> 5); 2023 which = (ext[2] >> 1) & 0x1f; 2024 none = !!(ext[2] & 0x40); 2025 hhp = !(ext[2] & 0x80); 2026 sx = ext[0] & 0x3f; 2027 sy = ext[1] & 0x3f; 2028 o = !(ext[5] & 0x80); 2029 r = !(ext[5] & 0x40); 2030 y = !(ext[5] & 0x20); 2031 g = !(ext[5] & 0x10); 2032 b = !(ext[5] & 0x08); 2033 bass = !(ext[5] & 0x04); 2034 bm = !(ext[4] & 0x10); 2035 bp = !(ext[4] & 0x04); 2036 2037 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 2038 sx &= 0x3e; 2039 sy &= 0x3e; 2040 } 2041 2042 wiimod_drums_report_pressure(wdata, none, which, pressure, 2043 o, &wdata->state.pressure_drums[0], 2044 ABS_HAT2Y, 0x0e); 2045 wiimod_drums_report_pressure(wdata, none, which, pressure, 2046 r, &wdata->state.pressure_drums[1], 2047 ABS_HAT0X, 0x19); 2048 wiimod_drums_report_pressure(wdata, none, which, pressure, 2049 y, &wdata->state.pressure_drums[2], 2050 ABS_HAT2X, 0x11); 2051 wiimod_drums_report_pressure(wdata, none, which, pressure, 2052 g, &wdata->state.pressure_drums[3], 2053 ABS_HAT1X, 0x12); 2054 wiimod_drums_report_pressure(wdata, none, which, pressure, 2055 b, &wdata->state.pressure_drums[4], 2056 ABS_HAT0Y, 0x0f); 2057 2058 /* Bass shares pressure with hi-hat (set via hhp) */ 2059 wiimod_drums_report_pressure(wdata, none, hhp ? 0xff : which, pressure, 2060 bass, &wdata->state.pressure_drums[5], 2061 ABS_HAT3X, 0x1b); 2062 /* Hi-hat has no on/off values, just pressure. Force to off/0. */ 2063 wiimod_drums_report_pressure(wdata, none, hhp ? which : 0xff, pressure, 2064 0, &wdata->state.pressure_drums[6], 2065 ABS_HAT3Y, 0x0e); 2066 2067 input_report_abs(wdata->extension.input, ABS_X, sx - 0x20); 2068 input_report_abs(wdata->extension.input, ABS_Y, sy - 0x20); 2069 2070 input_report_key(wdata->extension.input, BTN_START, bp); 2071 input_report_key(wdata->extension.input, BTN_SELECT, bm); 2072 2073 input_sync(wdata->extension.input); 2074 } 2075 2076 static int wiimod_drums_open(struct input_dev *dev) 2077 { 2078 struct wiimote_data *wdata = input_get_drvdata(dev); 2079 unsigned long flags; 2080 2081 spin_lock_irqsave(&wdata->state.lock, flags); 2082 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 2083 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2084 spin_unlock_irqrestore(&wdata->state.lock, flags); 2085 2086 return 0; 2087 } 2088 2089 static void wiimod_drums_close(struct input_dev *dev) 2090 { 2091 struct wiimote_data *wdata = input_get_drvdata(dev); 2092 unsigned long flags; 2093 2094 spin_lock_irqsave(&wdata->state.lock, flags); 2095 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 2096 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2097 spin_unlock_irqrestore(&wdata->state.lock, flags); 2098 } 2099 2100 static int wiimod_drums_probe(const struct wiimod_ops *ops, 2101 struct wiimote_data *wdata) 2102 { 2103 int ret; 2104 2105 wdata->extension.input = input_allocate_device(); 2106 if (!wdata->extension.input) 2107 return -ENOMEM; 2108 2109 input_set_drvdata(wdata->extension.input, wdata); 2110 wdata->extension.input->open = wiimod_drums_open; 2111 wdata->extension.input->close = wiimod_drums_close; 2112 wdata->extension.input->dev.parent = &wdata->hdev->dev; 2113 wdata->extension.input->id.bustype = wdata->hdev->bus; 2114 wdata->extension.input->id.vendor = wdata->hdev->vendor; 2115 wdata->extension.input->id.product = wdata->hdev->product; 2116 wdata->extension.input->id.version = wdata->hdev->version; 2117 wdata->extension.input->name = WIIMOTE_NAME " Drums"; 2118 2119 set_bit(EV_KEY, wdata->extension.input->evbit); 2120 set_bit(BTN_START, wdata->extension.input->keybit); 2121 set_bit(BTN_SELECT, wdata->extension.input->keybit); 2122 2123 set_bit(EV_ABS, wdata->extension.input->evbit); 2124 set_bit(ABS_X, wdata->extension.input->absbit); 2125 set_bit(ABS_Y, wdata->extension.input->absbit); 2126 set_bit(ABS_HAT0X, wdata->extension.input->absbit); 2127 set_bit(ABS_HAT0Y, wdata->extension.input->absbit); 2128 set_bit(ABS_HAT1X, wdata->extension.input->absbit); 2129 set_bit(ABS_HAT2X, wdata->extension.input->absbit); 2130 set_bit(ABS_HAT2Y, wdata->extension.input->absbit); 2131 set_bit(ABS_HAT3X, wdata->extension.input->absbit); 2132 set_bit(ABS_HAT3Y, wdata->extension.input->absbit); 2133 input_set_abs_params(wdata->extension.input, 2134 ABS_X, -32, 31, 1, 1); 2135 input_set_abs_params(wdata->extension.input, 2136 ABS_Y, -32, 31, 1, 1); 2137 input_set_abs_params(wdata->extension.input, 2138 ABS_HAT0X, 0, 7, 0, 0); 2139 input_set_abs_params(wdata->extension.input, 2140 ABS_HAT0Y, 0, 7, 0, 0); 2141 input_set_abs_params(wdata->extension.input, 2142 ABS_HAT1X, 0, 7, 0, 0); 2143 input_set_abs_params(wdata->extension.input, 2144 ABS_HAT2X, 0, 7, 0, 0); 2145 input_set_abs_params(wdata->extension.input, 2146 ABS_HAT2Y, 0, 7, 0, 0); 2147 input_set_abs_params(wdata->extension.input, 2148 ABS_HAT3X, 0, 7, 0, 0); 2149 input_set_abs_params(wdata->extension.input, 2150 ABS_HAT3Y, 0, 7, 0, 0); 2151 2152 ret = input_register_device(wdata->extension.input); 2153 if (ret) 2154 goto err_free; 2155 2156 return 0; 2157 2158 err_free: 2159 input_free_device(wdata->extension.input); 2160 wdata->extension.input = NULL; 2161 return ret; 2162 } 2163 2164 static void wiimod_drums_remove(const struct wiimod_ops *ops, 2165 struct wiimote_data *wdata) 2166 { 2167 if (!wdata->extension.input) 2168 return; 2169 2170 input_unregister_device(wdata->extension.input); 2171 wdata->extension.input = NULL; 2172 } 2173 2174 static const struct wiimod_ops wiimod_drums = { 2175 .flags = 0, 2176 .arg = 0, 2177 .probe = wiimod_drums_probe, 2178 .remove = wiimod_drums_remove, 2179 .in_ext = wiimod_drums_in_ext, 2180 }; 2181 2182 /* 2183 * Guitar 2184 * Guitar-Hero, Rock-Band and other games came bundled with guitars which can 2185 * be plugged as extension to a Wiimote. 2186 * We create a separate device for guitars and report all information via this 2187 * input device. 2188 */ 2189 2190 enum wiimod_guitar_keys { 2191 WIIMOD_GUITAR_KEY_G, 2192 WIIMOD_GUITAR_KEY_R, 2193 WIIMOD_GUITAR_KEY_Y, 2194 WIIMOD_GUITAR_KEY_B, 2195 WIIMOD_GUITAR_KEY_O, 2196 WIIMOD_GUITAR_KEY_UP, 2197 WIIMOD_GUITAR_KEY_DOWN, 2198 WIIMOD_GUITAR_KEY_PLUS, 2199 WIIMOD_GUITAR_KEY_MINUS, 2200 WIIMOD_GUITAR_KEY_NUM, 2201 }; 2202 2203 static const __u16 wiimod_guitar_map[] = { 2204 BTN_1, /* WIIMOD_GUITAR_KEY_G */ 2205 BTN_2, /* WIIMOD_GUITAR_KEY_R */ 2206 BTN_3, /* WIIMOD_GUITAR_KEY_Y */ 2207 BTN_4, /* WIIMOD_GUITAR_KEY_B */ 2208 BTN_5, /* WIIMOD_GUITAR_KEY_O */ 2209 BTN_DPAD_UP, /* WIIMOD_GUITAR_KEY_UP */ 2210 BTN_DPAD_DOWN, /* WIIMOD_GUITAR_KEY_DOWN */ 2211 BTN_START, /* WIIMOD_GUITAR_KEY_PLUS */ 2212 BTN_SELECT, /* WIIMOD_GUITAR_KEY_MINUS */ 2213 }; 2214 2215 static void wiimod_guitar_in_ext(struct wiimote_data *wdata, const __u8 *ext) 2216 { 2217 __u8 sx, sy, tb, wb, bd, bm, bp, bo, br, bb, bg, by, bu; 2218 2219 /* Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 2220 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2221 * 1 | 0 | 0 | SX <5:0> | 2222 * 2 | 0 | 0 | SY <5:0> | 2223 * -----+-----+-----+-----+-----------------------------+ 2224 * 3 | 0 | 0 | 0 | TB <4:0> | 2225 * -----+-----+-----+-----+-----------------------------+ 2226 * 4 | 0 | 0 | 0 | WB <4:0> | 2227 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2228 * 5 | 1 | BD | 1 | B- | 1 | B+ | 1 | 1 | 2229 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2230 * 6 | BO | BR | BB | BG | BY | 1 | 1 | BU | 2231 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2232 * All buttons are 0 if pressed 2233 * 2234 * With Motion+ enabled, it will look like this: 2235 * Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 2236 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2237 * 1 | 0 | 0 | SX <5:1> | BU | 2238 * 2 | 0 | 0 | SY <5:1> | 1 | 2239 * -----+-----+-----+-----+-----------------------+-----+ 2240 * 3 | 0 | 0 | 0 | TB <4:0> | 2241 * -----+-----+-----+-----+-----------------------------+ 2242 * 4 | 0 | 0 | 0 | WB <4:0> | 2243 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2244 * 5 | 1 | BD | 1 | B- | 1 | B+ | 1 |XXXXX| 2245 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2246 * 6 | BO | BR | BB | BG | BY | 1 |XXXXX|XXXXX| 2247 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2248 */ 2249 2250 sx = ext[0] & 0x3f; 2251 sy = ext[1] & 0x3f; 2252 tb = ext[2] & 0x1f; 2253 wb = ext[3] & 0x1f; 2254 bd = !(ext[4] & 0x40); 2255 bm = !(ext[4] & 0x10); 2256 bp = !(ext[4] & 0x04); 2257 bo = !(ext[5] & 0x80); 2258 br = !(ext[5] & 0x40); 2259 bb = !(ext[5] & 0x20); 2260 bg = !(ext[5] & 0x10); 2261 by = !(ext[5] & 0x08); 2262 bu = !(ext[5] & 0x01); 2263 2264 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 2265 bu = !(ext[0] & 0x01); 2266 sx &= 0x3e; 2267 sy &= 0x3e; 2268 } 2269 2270 input_report_abs(wdata->extension.input, ABS_X, sx - 0x20); 2271 input_report_abs(wdata->extension.input, ABS_Y, sy - 0x20); 2272 input_report_abs(wdata->extension.input, ABS_HAT0X, tb); 2273 input_report_abs(wdata->extension.input, ABS_HAT1X, wb - 0x10); 2274 2275 input_report_key(wdata->extension.input, 2276 wiimod_guitar_map[WIIMOD_GUITAR_KEY_G], 2277 bg); 2278 input_report_key(wdata->extension.input, 2279 wiimod_guitar_map[WIIMOD_GUITAR_KEY_R], 2280 br); 2281 input_report_key(wdata->extension.input, 2282 wiimod_guitar_map[WIIMOD_GUITAR_KEY_Y], 2283 by); 2284 input_report_key(wdata->extension.input, 2285 wiimod_guitar_map[WIIMOD_GUITAR_KEY_B], 2286 bb); 2287 input_report_key(wdata->extension.input, 2288 wiimod_guitar_map[WIIMOD_GUITAR_KEY_O], 2289 bo); 2290 input_report_key(wdata->extension.input, 2291 wiimod_guitar_map[WIIMOD_GUITAR_KEY_UP], 2292 bu); 2293 input_report_key(wdata->extension.input, 2294 wiimod_guitar_map[WIIMOD_GUITAR_KEY_DOWN], 2295 bd); 2296 input_report_key(wdata->extension.input, 2297 wiimod_guitar_map[WIIMOD_GUITAR_KEY_PLUS], 2298 bp); 2299 input_report_key(wdata->extension.input, 2300 wiimod_guitar_map[WIIMOD_GUITAR_KEY_MINUS], 2301 bm); 2302 2303 input_sync(wdata->extension.input); 2304 } 2305 2306 static int wiimod_guitar_open(struct input_dev *dev) 2307 { 2308 struct wiimote_data *wdata = input_get_drvdata(dev); 2309 unsigned long flags; 2310 2311 spin_lock_irqsave(&wdata->state.lock, flags); 2312 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 2313 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2314 spin_unlock_irqrestore(&wdata->state.lock, flags); 2315 2316 return 0; 2317 } 2318 2319 static void wiimod_guitar_close(struct input_dev *dev) 2320 { 2321 struct wiimote_data *wdata = input_get_drvdata(dev); 2322 unsigned long flags; 2323 2324 spin_lock_irqsave(&wdata->state.lock, flags); 2325 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 2326 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2327 spin_unlock_irqrestore(&wdata->state.lock, flags); 2328 } 2329 2330 static int wiimod_guitar_probe(const struct wiimod_ops *ops, 2331 struct wiimote_data *wdata) 2332 { 2333 int ret, i; 2334 2335 wdata->extension.input = input_allocate_device(); 2336 if (!wdata->extension.input) 2337 return -ENOMEM; 2338 2339 input_set_drvdata(wdata->extension.input, wdata); 2340 wdata->extension.input->open = wiimod_guitar_open; 2341 wdata->extension.input->close = wiimod_guitar_close; 2342 wdata->extension.input->dev.parent = &wdata->hdev->dev; 2343 wdata->extension.input->id.bustype = wdata->hdev->bus; 2344 wdata->extension.input->id.vendor = wdata->hdev->vendor; 2345 wdata->extension.input->id.product = wdata->hdev->product; 2346 wdata->extension.input->id.version = wdata->hdev->version; 2347 wdata->extension.input->name = WIIMOTE_NAME " Guitar"; 2348 2349 set_bit(EV_KEY, wdata->extension.input->evbit); 2350 for (i = 0; i < WIIMOD_GUITAR_KEY_NUM; ++i) 2351 set_bit(wiimod_guitar_map[i], 2352 wdata->extension.input->keybit); 2353 2354 set_bit(EV_ABS, wdata->extension.input->evbit); 2355 set_bit(ABS_X, wdata->extension.input->absbit); 2356 set_bit(ABS_Y, wdata->extension.input->absbit); 2357 set_bit(ABS_HAT0X, wdata->extension.input->absbit); 2358 set_bit(ABS_HAT1X, wdata->extension.input->absbit); 2359 input_set_abs_params(wdata->extension.input, 2360 ABS_X, -32, 31, 1, 1); 2361 input_set_abs_params(wdata->extension.input, 2362 ABS_Y, -32, 31, 1, 1); 2363 input_set_abs_params(wdata->extension.input, 2364 ABS_HAT0X, 0, 0x1f, 1, 1); 2365 input_set_abs_params(wdata->extension.input, 2366 ABS_HAT1X, 0, 0x0f, 1, 1); 2367 2368 ret = input_register_device(wdata->extension.input); 2369 if (ret) 2370 goto err_free; 2371 2372 return 0; 2373 2374 err_free: 2375 input_free_device(wdata->extension.input); 2376 wdata->extension.input = NULL; 2377 return ret; 2378 } 2379 2380 static void wiimod_guitar_remove(const struct wiimod_ops *ops, 2381 struct wiimote_data *wdata) 2382 { 2383 if (!wdata->extension.input) 2384 return; 2385 2386 input_unregister_device(wdata->extension.input); 2387 wdata->extension.input = NULL; 2388 } 2389 2390 static const struct wiimod_ops wiimod_guitar = { 2391 .flags = 0, 2392 .arg = 0, 2393 .probe = wiimod_guitar_probe, 2394 .remove = wiimod_guitar_remove, 2395 .in_ext = wiimod_guitar_in_ext, 2396 }; 2397 2398 /* 2399 * Turntable 2400 * DJ Hero came with a Turntable Controller that was plugged in 2401 * as an extension. 2402 * We create a separate device for turntables and report all information via this 2403 * input device. 2404 */ 2405 2406 enum wiimod_turntable_keys { 2407 WIIMOD_TURNTABLE_KEY_G_RIGHT, 2408 WIIMOD_TURNTABLE_KEY_R_RIGHT, 2409 WIIMOD_TURNTABLE_KEY_B_RIGHT, 2410 WIIMOD_TURNTABLE_KEY_G_LEFT, 2411 WIIMOD_TURNTABLE_KEY_R_LEFT, 2412 WIIMOD_TURNTABLE_KEY_B_LEFT, 2413 WIIMOD_TURNTABLE_KEY_EUPHORIA, 2414 WIIMOD_TURNTABLE_KEY_PLUS, 2415 WIIMOD_TURNTABLE_KEY_MINUS, 2416 WIIMOD_TURNTABLE_KEY_NUM 2417 }; 2418 2419 static const __u16 wiimod_turntable_map[] = { 2420 BTN_1, /* WIIMOD_TURNTABLE_KEY_G_RIGHT */ 2421 BTN_2, /* WIIMOD_TURNTABLE_KEY_R_RIGHT */ 2422 BTN_3, /* WIIMOD_TURNTABLE_KEY_B_RIGHT */ 2423 BTN_4, /* WIIMOD_TURNTABLE_KEY_G_LEFT */ 2424 BTN_5, /* WIIMOD_TURNTABLE_KEY_R_LEFT */ 2425 BTN_6, /* WIIMOD_TURNTABLE_KEY_B_LEFT */ 2426 BTN_7, /* WIIMOD_TURNTABLE_KEY_EUPHORIA */ 2427 BTN_START, /* WIIMOD_TURNTABLE_KEY_PLUS */ 2428 BTN_SELECT, /* WIIMOD_TURNTABLE_KEY_MINUS */ 2429 }; 2430 2431 static void wiimod_turntable_in_ext(struct wiimote_data *wdata, const __u8 *ext) 2432 { 2433 __u8 be, cs, sx, sy, ed, rtt, rbg, rbr, rbb, ltt, lbg, lbr, lbb, bp, bm; 2434 /* 2435 * Byte | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | 2436 *------+------+-----+-----+-----+-----+------+------+--------+ 2437 * 0 | RTT<4:3> | SX <5:0> | 2438 * 1 | RTT<2:1> | SY <5:0> | 2439 *------+------+-----+-----+-----+-----+------+------+--------+ 2440 * 2 |RTT<0>| ED<4:3> | CS<3:0> | RTT<5> | 2441 *------+------+-----+-----+-----+-----+------+------+--------+ 2442 * 3 | ED<2:0> | LTT<4:0> | 2443 *------+------+-----+-----+-----+-----+------+------+--------+ 2444 * 4 | 0 | 0 | LBR | B- | 0 | B+ | RBR | LTT<5> | 2445 *------+------+-----+-----+-----+-----+------+------+--------+ 2446 * 5 | LBB | 0 | RBG | BE | LBG | RBB | 0 | 0 | 2447 *------+------+-----+-----+-----+-----+------+------+--------+ 2448 * All pressed buttons are 0 2449 * 2450 * With Motion+ enabled, it will look like this: 2451 * Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 2452 *------+------+-----+-----+-----+-----+------+------+--------+ 2453 * 1 | RTT<4:3> | SX <5:1> | 0 | 2454 * 2 | RTT<2:1> | SY <5:1> | 0 | 2455 *------+------+-----+-----+-----+-----+------+------+--------+ 2456 * 3 |RTT<0>| ED<4:3> | CS<3:0> | RTT<5> | 2457 *------+------+-----+-----+-----+-----+------+------+--------+ 2458 * 4 | ED<2:0> | LTT<4:0> | 2459 *------+------+-----+-----+-----+-----+------+------+--------+ 2460 * 5 | 0 | 0 | LBR | B- | 0 | B+ | RBR | XXXX | 2461 *------+------+-----+-----+-----+-----+------+------+--------+ 2462 * 6 | LBB | 0 | RBG | BE | LBG | RBB | XXXX | XXXX | 2463 *------+------+-----+-----+-----+-----+------+------+--------+ 2464 */ 2465 2466 be = !(ext[5] & 0x10); 2467 cs = ((ext[2] & 0x1e)); 2468 sx = ext[0] & 0x3f; 2469 sy = ext[1] & 0x3f; 2470 ed = (ext[3] & 0xe0) >> 5; 2471 rtt = ((ext[2] & 0x01) << 5 | (ext[0] & 0xc0) >> 3 | (ext[1] & 0xc0) >> 5 | ( ext[2] & 0x80 ) >> 7); 2472 ltt = ((ext[4] & 0x01) << 5 | (ext[3] & 0x1f)); 2473 rbg = !(ext[5] & 0x20); 2474 rbr = !(ext[4] & 0x02); 2475 rbb = !(ext[5] & 0x04); 2476 lbg = !(ext[5] & 0x08); 2477 lbb = !(ext[5] & 0x80); 2478 lbr = !(ext[4] & 0x20); 2479 bm = !(ext[4] & 0x10); 2480 bp = !(ext[4] & 0x04); 2481 2482 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 2483 ltt = (ext[4] & 0x01) << 5; 2484 sx &= 0x3e; 2485 sy &= 0x3e; 2486 } 2487 2488 input_report_abs(wdata->extension.input, ABS_X, sx); 2489 input_report_abs(wdata->extension.input, ABS_Y, sy); 2490 input_report_abs(wdata->extension.input, ABS_HAT0X, rtt); 2491 input_report_abs(wdata->extension.input, ABS_HAT1X, ltt); 2492 input_report_abs(wdata->extension.input, ABS_HAT2X, cs); 2493 input_report_abs(wdata->extension.input, ABS_HAT3X, ed); 2494 input_report_key(wdata->extension.input, 2495 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_G_RIGHT], 2496 rbg); 2497 input_report_key(wdata->extension.input, 2498 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_R_RIGHT], 2499 rbr); 2500 input_report_key(wdata->extension.input, 2501 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_B_RIGHT], 2502 rbb); 2503 input_report_key(wdata->extension.input, 2504 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_G_LEFT], 2505 lbg); 2506 input_report_key(wdata->extension.input, 2507 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_R_LEFT], 2508 lbr); 2509 input_report_key(wdata->extension.input, 2510 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_B_LEFT], 2511 lbb); 2512 input_report_key(wdata->extension.input, 2513 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_EUPHORIA], 2514 be); 2515 input_report_key(wdata->extension.input, 2516 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_PLUS], 2517 bp); 2518 input_report_key(wdata->extension.input, 2519 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_MINUS], 2520 bm); 2521 2522 input_sync(wdata->extension.input); 2523 } 2524 2525 static int wiimod_turntable_open(struct input_dev *dev) 2526 { 2527 struct wiimote_data *wdata = input_get_drvdata(dev); 2528 unsigned long flags; 2529 2530 spin_lock_irqsave(&wdata->state.lock, flags); 2531 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 2532 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2533 spin_unlock_irqrestore(&wdata->state.lock, flags); 2534 2535 return 0; 2536 } 2537 2538 static void wiimod_turntable_close(struct input_dev *dev) 2539 { 2540 struct wiimote_data *wdata = input_get_drvdata(dev); 2541 unsigned long flags; 2542 2543 spin_lock_irqsave(&wdata->state.lock, flags); 2544 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 2545 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2546 spin_unlock_irqrestore(&wdata->state.lock, flags); 2547 } 2548 2549 static int wiimod_turntable_probe(const struct wiimod_ops *ops, 2550 struct wiimote_data *wdata) 2551 { 2552 int ret, i; 2553 2554 wdata->extension.input = input_allocate_device(); 2555 if (!wdata->extension.input) 2556 return -ENOMEM; 2557 2558 input_set_drvdata(wdata->extension.input, wdata); 2559 wdata->extension.input->open = wiimod_turntable_open; 2560 wdata->extension.input->close = wiimod_turntable_close; 2561 wdata->extension.input->dev.parent = &wdata->hdev->dev; 2562 wdata->extension.input->id.bustype = wdata->hdev->bus; 2563 wdata->extension.input->id.vendor = wdata->hdev->vendor; 2564 wdata->extension.input->id.product = wdata->hdev->product; 2565 wdata->extension.input->id.version = wdata->hdev->version; 2566 wdata->extension.input->name = WIIMOTE_NAME " Turntable"; 2567 2568 set_bit(EV_KEY, wdata->extension.input->evbit); 2569 for (i = 0; i < WIIMOD_TURNTABLE_KEY_NUM; ++i) 2570 set_bit(wiimod_turntable_map[i], 2571 wdata->extension.input->keybit); 2572 2573 set_bit(EV_ABS, wdata->extension.input->evbit); 2574 set_bit(ABS_X, wdata->extension.input->absbit); 2575 set_bit(ABS_Y, wdata->extension.input->absbit); 2576 set_bit(ABS_HAT0X, wdata->extension.input->absbit); 2577 set_bit(ABS_HAT1X, wdata->extension.input->absbit); 2578 set_bit(ABS_HAT2X, wdata->extension.input->absbit); 2579 set_bit(ABS_HAT3X, wdata->extension.input->absbit); 2580 input_set_abs_params(wdata->extension.input, 2581 ABS_X, 0, 63, 1, 0); 2582 input_set_abs_params(wdata->extension.input, 2583 ABS_Y, 63, 0, 1, 0); 2584 input_set_abs_params(wdata->extension.input, 2585 ABS_HAT0X, -8, 8, 0, 0); 2586 input_set_abs_params(wdata->extension.input, 2587 ABS_HAT1X, -8, 8, 0, 0); 2588 input_set_abs_params(wdata->extension.input, 2589 ABS_HAT2X, 0, 31, 1, 1); 2590 input_set_abs_params(wdata->extension.input, 2591 ABS_HAT3X, 0, 7, 0, 0); 2592 ret = input_register_device(wdata->extension.input); 2593 if (ret) 2594 goto err_free; 2595 2596 return 0; 2597 2598 err_free: 2599 input_free_device(wdata->extension.input); 2600 wdata->extension.input = NULL; 2601 return ret; 2602 } 2603 2604 static void wiimod_turntable_remove(const struct wiimod_ops *ops, 2605 struct wiimote_data *wdata) 2606 { 2607 if (!wdata->extension.input) 2608 return; 2609 2610 input_unregister_device(wdata->extension.input); 2611 wdata->extension.input = NULL; 2612 } 2613 2614 static const struct wiimod_ops wiimod_turntable = { 2615 .flags = 0, 2616 .arg = 0, 2617 .probe = wiimod_turntable_probe, 2618 .remove = wiimod_turntable_remove, 2619 .in_ext = wiimod_turntable_in_ext, 2620 }; 2621 2622 /* 2623 * Builtin Motion Plus 2624 * This module simply sets the WIIPROTO_FLAG_BUILTIN_MP protocol flag which 2625 * disables polling for Motion-Plus. This should be set only for devices which 2626 * don't allow MP hotplugging. 2627 */ 2628 2629 static int wiimod_builtin_mp_probe(const struct wiimod_ops *ops, 2630 struct wiimote_data *wdata) 2631 { 2632 unsigned long flags; 2633 2634 spin_lock_irqsave(&wdata->state.lock, flags); 2635 wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP; 2636 spin_unlock_irqrestore(&wdata->state.lock, flags); 2637 2638 return 0; 2639 } 2640 2641 static void wiimod_builtin_mp_remove(const struct wiimod_ops *ops, 2642 struct wiimote_data *wdata) 2643 { 2644 unsigned long flags; 2645 2646 spin_lock_irqsave(&wdata->state.lock, flags); 2647 wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP; 2648 spin_unlock_irqrestore(&wdata->state.lock, flags); 2649 } 2650 2651 static const struct wiimod_ops wiimod_builtin_mp = { 2652 .flags = 0, 2653 .arg = 0, 2654 .probe = wiimod_builtin_mp_probe, 2655 .remove = wiimod_builtin_mp_remove, 2656 }; 2657 2658 /* 2659 * No Motion Plus 2660 * This module simply sets the WIIPROTO_FLAG_NO_MP protocol flag which 2661 * disables motion-plus. This is needed for devices that advertise this but we 2662 * don't know how to use it (or whether it is actually present). 2663 */ 2664 2665 static int wiimod_no_mp_probe(const struct wiimod_ops *ops, 2666 struct wiimote_data *wdata) 2667 { 2668 unsigned long flags; 2669 2670 spin_lock_irqsave(&wdata->state.lock, flags); 2671 wdata->state.flags |= WIIPROTO_FLAG_NO_MP; 2672 spin_unlock_irqrestore(&wdata->state.lock, flags); 2673 2674 return 0; 2675 } 2676 2677 static void wiimod_no_mp_remove(const struct wiimod_ops *ops, 2678 struct wiimote_data *wdata) 2679 { 2680 unsigned long flags; 2681 2682 spin_lock_irqsave(&wdata->state.lock, flags); 2683 wdata->state.flags |= WIIPROTO_FLAG_NO_MP; 2684 spin_unlock_irqrestore(&wdata->state.lock, flags); 2685 } 2686 2687 static const struct wiimod_ops wiimod_no_mp = { 2688 .flags = 0, 2689 .arg = 0, 2690 .probe = wiimod_no_mp_probe, 2691 .remove = wiimod_no_mp_remove, 2692 }; 2693 2694 /* 2695 * Motion Plus 2696 * The Motion Plus extension provides rotation sensors (gyro) as a small 2697 * extension device for Wii Remotes. Many devices have them built-in so 2698 * you cannot see them from the outside. 2699 * Motion Plus extensions are special because they are on a separate extension 2700 * port and allow other extensions to be used simultaneously. This is all 2701 * handled by the Wiimote Core so we don't have to deal with it. 2702 */ 2703 2704 static void wiimod_mp_in_mp(struct wiimote_data *wdata, const __u8 *ext) 2705 { 2706 __s32 x, y, z; 2707 2708 /* | 8 7 6 5 4 3 | 2 | 1 | 2709 * -----+------------------------------+-----+-----+ 2710 * 1 | Yaw Speed <7:0> | 2711 * 2 | Roll Speed <7:0> | 2712 * 3 | Pitch Speed <7:0> | 2713 * -----+------------------------------+-----+-----+ 2714 * 4 | Yaw Speed <13:8> | Yaw |Pitch| 2715 * -----+------------------------------+-----+-----+ 2716 * 5 | Roll Speed <13:8> |Roll | Ext | 2717 * -----+------------------------------+-----+-----+ 2718 * 6 | Pitch Speed <13:8> | 1 | 0 | 2719 * -----+------------------------------+-----+-----+ 2720 * The single bits Yaw, Roll, Pitch in the lower right corner specify 2721 * whether the wiimote is rotating fast (0) or slow (1). Speed for slow 2722 * roation is 8192/440 units / deg/s and for fast rotation 8192/2000 2723 * units / deg/s. To get a linear scale for fast rotation we multiply 2724 * by 2000/440 = ~4.5454 and scale both fast and slow by 9 to match the 2725 * previous scale reported by this driver. 2726 * This leaves a linear scale with 8192*9/440 (~167.564) units / deg/s. 2727 * If the wiimote is not rotating the sensor reports 2^13 = 8192. 2728 * Ext specifies whether an extension is connected to the motionp. 2729 * which is parsed by wiimote-core. 2730 */ 2731 2732 x = ext[0]; 2733 y = ext[1]; 2734 z = ext[2]; 2735 2736 x |= (((__u16)ext[3]) << 6) & 0xff00; 2737 y |= (((__u16)ext[4]) << 6) & 0xff00; 2738 z |= (((__u16)ext[5]) << 6) & 0xff00; 2739 2740 x -= 8192; 2741 y -= 8192; 2742 z -= 8192; 2743 2744 if (!(ext[3] & 0x02)) 2745 x = (x * 2000 * 9) / 440; 2746 else 2747 x *= 9; 2748 if (!(ext[4] & 0x02)) 2749 y = (y * 2000 * 9) / 440; 2750 else 2751 y *= 9; 2752 if (!(ext[3] & 0x01)) 2753 z = (z * 2000 * 9) / 440; 2754 else 2755 z *= 9; 2756 2757 input_report_abs(wdata->mp, ABS_RX, x); 2758 input_report_abs(wdata->mp, ABS_RY, y); 2759 input_report_abs(wdata->mp, ABS_RZ, z); 2760 input_sync(wdata->mp); 2761 } 2762 2763 static int wiimod_mp_open(struct input_dev *dev) 2764 { 2765 struct wiimote_data *wdata = input_get_drvdata(dev); 2766 unsigned long flags; 2767 2768 spin_lock_irqsave(&wdata->state.lock, flags); 2769 wdata->state.flags |= WIIPROTO_FLAG_MP_USED; 2770 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2771 __wiimote_schedule(wdata); 2772 spin_unlock_irqrestore(&wdata->state.lock, flags); 2773 2774 return 0; 2775 } 2776 2777 static void wiimod_mp_close(struct input_dev *dev) 2778 { 2779 struct wiimote_data *wdata = input_get_drvdata(dev); 2780 unsigned long flags; 2781 2782 spin_lock_irqsave(&wdata->state.lock, flags); 2783 wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED; 2784 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2785 __wiimote_schedule(wdata); 2786 spin_unlock_irqrestore(&wdata->state.lock, flags); 2787 } 2788 2789 static int wiimod_mp_probe(const struct wiimod_ops *ops, 2790 struct wiimote_data *wdata) 2791 { 2792 int ret; 2793 2794 wdata->mp = input_allocate_device(); 2795 if (!wdata->mp) 2796 return -ENOMEM; 2797 2798 input_set_drvdata(wdata->mp, wdata); 2799 wdata->mp->open = wiimod_mp_open; 2800 wdata->mp->close = wiimod_mp_close; 2801 wdata->mp->dev.parent = &wdata->hdev->dev; 2802 wdata->mp->id.bustype = wdata->hdev->bus; 2803 wdata->mp->id.vendor = wdata->hdev->vendor; 2804 wdata->mp->id.product = wdata->hdev->product; 2805 wdata->mp->id.version = wdata->hdev->version; 2806 wdata->mp->name = WIIMOTE_NAME " Motion Plus"; 2807 2808 set_bit(EV_ABS, wdata->mp->evbit); 2809 set_bit(ABS_RX, wdata->mp->absbit); 2810 set_bit(ABS_RY, wdata->mp->absbit); 2811 set_bit(ABS_RZ, wdata->mp->absbit); 2812 input_set_abs_params(wdata->mp, 2813 ABS_RX, -16000, 16000, 4, 8); 2814 input_set_abs_params(wdata->mp, 2815 ABS_RY, -16000, 16000, 4, 8); 2816 input_set_abs_params(wdata->mp, 2817 ABS_RZ, -16000, 16000, 4, 8); 2818 2819 ret = input_register_device(wdata->mp); 2820 if (ret) 2821 goto err_free; 2822 2823 return 0; 2824 2825 err_free: 2826 input_free_device(wdata->mp); 2827 wdata->mp = NULL; 2828 return ret; 2829 } 2830 2831 static void wiimod_mp_remove(const struct wiimod_ops *ops, 2832 struct wiimote_data *wdata) 2833 { 2834 if (!wdata->mp) 2835 return; 2836 2837 input_unregister_device(wdata->mp); 2838 wdata->mp = NULL; 2839 } 2840 2841 const struct wiimod_ops wiimod_mp = { 2842 .flags = 0, 2843 .arg = 0, 2844 .probe = wiimod_mp_probe, 2845 .remove = wiimod_mp_remove, 2846 .in_mp = wiimod_mp_in_mp, 2847 }; 2848 2849 /* module table */ 2850 2851 static const struct wiimod_ops wiimod_dummy; 2852 2853 const struct wiimod_ops *wiimod_table[WIIMOD_NUM] = { 2854 [WIIMOD_KEYS] = &wiimod_keys, 2855 [WIIMOD_RUMBLE] = &wiimod_rumble, 2856 [WIIMOD_BATTERY] = &wiimod_battery, 2857 [WIIMOD_LED1] = &wiimod_leds[0], 2858 [WIIMOD_LED2] = &wiimod_leds[1], 2859 [WIIMOD_LED3] = &wiimod_leds[2], 2860 [WIIMOD_LED4] = &wiimod_leds[3], 2861 [WIIMOD_ACCEL] = &wiimod_accel, 2862 [WIIMOD_IR] = &wiimod_ir, 2863 [WIIMOD_BUILTIN_MP] = &wiimod_builtin_mp, 2864 [WIIMOD_NO_MP] = &wiimod_no_mp, 2865 }; 2866 2867 const struct wiimod_ops *wiimod_ext_table[WIIMOTE_EXT_NUM] = { 2868 [WIIMOTE_EXT_NONE] = &wiimod_dummy, 2869 [WIIMOTE_EXT_UNKNOWN] = &wiimod_dummy, 2870 [WIIMOTE_EXT_NUNCHUK] = &wiimod_nunchuk, 2871 [WIIMOTE_EXT_CLASSIC_CONTROLLER] = &wiimod_classic, 2872 [WIIMOTE_EXT_BALANCE_BOARD] = &wiimod_bboard, 2873 [WIIMOTE_EXT_PRO_CONTROLLER] = &wiimod_pro, 2874 [WIIMOTE_EXT_DRUMS] = &wiimod_drums, 2875 [WIIMOTE_EXT_GUITAR] = &wiimod_guitar, 2876 [WIIMOTE_EXT_TURNTABLE] = &wiimod_turntable, 2877 }; 2878