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