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 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 1092 lx = ext[0] & 0x3e; 1093 ly = ext[1] & 0x3e; 1094 } else { 1095 lx = ext[0] & 0x3f; 1096 ly = ext[1] & 0x3f; 1097 } 1098 1099 rx = (ext[0] >> 3) & 0x18; 1100 rx |= (ext[1] >> 5) & 0x06; 1101 rx |= (ext[2] >> 7) & 0x01; 1102 ry = ext[2] & 0x1f; 1103 1104 rt = ext[3] & 0x1f; 1105 lt = (ext[2] >> 2) & 0x18; 1106 lt |= (ext[3] >> 5) & 0x07; 1107 1108 rx <<= 1; 1109 ry <<= 1; 1110 rt <<= 1; 1111 lt <<= 1; 1112 1113 input_report_abs(wdata->extension.input, ABS_HAT1X, lx - 0x20); 1114 input_report_abs(wdata->extension.input, ABS_HAT1Y, ly - 0x20); 1115 input_report_abs(wdata->extension.input, ABS_HAT2X, rx - 0x20); 1116 input_report_abs(wdata->extension.input, ABS_HAT2Y, ry - 0x20); 1117 input_report_abs(wdata->extension.input, ABS_HAT3X, rt); 1118 input_report_abs(wdata->extension.input, ABS_HAT3Y, lt); 1119 1120 input_report_key(wdata->extension.input, 1121 wiimod_classic_map[WIIMOD_CLASSIC_KEY_RIGHT], 1122 !(ext[4] & 0x80)); 1123 input_report_key(wdata->extension.input, 1124 wiimod_classic_map[WIIMOD_CLASSIC_KEY_DOWN], 1125 !(ext[4] & 0x40)); 1126 input_report_key(wdata->extension.input, 1127 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LT], 1128 !(ext[4] & 0x20)); 1129 input_report_key(wdata->extension.input, 1130 wiimod_classic_map[WIIMOD_CLASSIC_KEY_MINUS], 1131 !(ext[4] & 0x10)); 1132 input_report_key(wdata->extension.input, 1133 wiimod_classic_map[WIIMOD_CLASSIC_KEY_HOME], 1134 !(ext[4] & 0x08)); 1135 input_report_key(wdata->extension.input, 1136 wiimod_classic_map[WIIMOD_CLASSIC_KEY_PLUS], 1137 !(ext[4] & 0x04)); 1138 input_report_key(wdata->extension.input, 1139 wiimod_classic_map[WIIMOD_CLASSIC_KEY_RT], 1140 !(ext[4] & 0x02)); 1141 input_report_key(wdata->extension.input, 1142 wiimod_classic_map[WIIMOD_CLASSIC_KEY_ZL], 1143 !(ext[5] & 0x80)); 1144 input_report_key(wdata->extension.input, 1145 wiimod_classic_map[WIIMOD_CLASSIC_KEY_B], 1146 !(ext[5] & 0x40)); 1147 input_report_key(wdata->extension.input, 1148 wiimod_classic_map[WIIMOD_CLASSIC_KEY_Y], 1149 !(ext[5] & 0x20)); 1150 input_report_key(wdata->extension.input, 1151 wiimod_classic_map[WIIMOD_CLASSIC_KEY_A], 1152 !(ext[5] & 0x10)); 1153 input_report_key(wdata->extension.input, 1154 wiimod_classic_map[WIIMOD_CLASSIC_KEY_X], 1155 !(ext[5] & 0x08)); 1156 input_report_key(wdata->extension.input, 1157 wiimod_classic_map[WIIMOD_CLASSIC_KEY_ZR], 1158 !(ext[5] & 0x04)); 1159 1160 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 1161 input_report_key(wdata->extension.input, 1162 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LEFT], 1163 !(ext[1] & 0x01)); 1164 input_report_key(wdata->extension.input, 1165 wiimod_classic_map[WIIMOD_CLASSIC_KEY_UP], 1166 !(ext[0] & 0x01)); 1167 } else { 1168 input_report_key(wdata->extension.input, 1169 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LEFT], 1170 !(ext[5] & 0x02)); 1171 input_report_key(wdata->extension.input, 1172 wiimod_classic_map[WIIMOD_CLASSIC_KEY_UP], 1173 !(ext[5] & 0x01)); 1174 } 1175 1176 input_sync(wdata->extension.input); 1177 } 1178 1179 static int wiimod_classic_open(struct input_dev *dev) 1180 { 1181 struct wiimote_data *wdata = input_get_drvdata(dev); 1182 unsigned long flags; 1183 1184 spin_lock_irqsave(&wdata->state.lock, flags); 1185 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 1186 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1187 spin_unlock_irqrestore(&wdata->state.lock, flags); 1188 1189 return 0; 1190 } 1191 1192 static void wiimod_classic_close(struct input_dev *dev) 1193 { 1194 struct wiimote_data *wdata = input_get_drvdata(dev); 1195 unsigned long flags; 1196 1197 spin_lock_irqsave(&wdata->state.lock, flags); 1198 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 1199 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1200 spin_unlock_irqrestore(&wdata->state.lock, flags); 1201 } 1202 1203 static int wiimod_classic_probe(const struct wiimod_ops *ops, 1204 struct wiimote_data *wdata) 1205 { 1206 int ret, i; 1207 1208 wdata->extension.input = input_allocate_device(); 1209 if (!wdata->extension.input) 1210 return -ENOMEM; 1211 1212 input_set_drvdata(wdata->extension.input, wdata); 1213 wdata->extension.input->open = wiimod_classic_open; 1214 wdata->extension.input->close = wiimod_classic_close; 1215 wdata->extension.input->dev.parent = &wdata->hdev->dev; 1216 wdata->extension.input->id.bustype = wdata->hdev->bus; 1217 wdata->extension.input->id.vendor = wdata->hdev->vendor; 1218 wdata->extension.input->id.product = wdata->hdev->product; 1219 wdata->extension.input->id.version = wdata->hdev->version; 1220 wdata->extension.input->name = WIIMOTE_NAME " Classic Controller"; 1221 1222 set_bit(EV_KEY, wdata->extension.input->evbit); 1223 for (i = 0; i < WIIMOD_CLASSIC_KEY_NUM; ++i) 1224 set_bit(wiimod_classic_map[i], 1225 wdata->extension.input->keybit); 1226 1227 set_bit(EV_ABS, wdata->extension.input->evbit); 1228 set_bit(ABS_HAT1X, wdata->extension.input->absbit); 1229 set_bit(ABS_HAT1Y, wdata->extension.input->absbit); 1230 set_bit(ABS_HAT2X, wdata->extension.input->absbit); 1231 set_bit(ABS_HAT2Y, wdata->extension.input->absbit); 1232 set_bit(ABS_HAT3X, wdata->extension.input->absbit); 1233 set_bit(ABS_HAT3Y, wdata->extension.input->absbit); 1234 input_set_abs_params(wdata->extension.input, 1235 ABS_HAT1X, -30, 30, 1, 1); 1236 input_set_abs_params(wdata->extension.input, 1237 ABS_HAT1Y, -30, 30, 1, 1); 1238 input_set_abs_params(wdata->extension.input, 1239 ABS_HAT2X, -30, 30, 1, 1); 1240 input_set_abs_params(wdata->extension.input, 1241 ABS_HAT2Y, -30, 30, 1, 1); 1242 input_set_abs_params(wdata->extension.input, 1243 ABS_HAT3X, -30, 30, 1, 1); 1244 input_set_abs_params(wdata->extension.input, 1245 ABS_HAT3Y, -30, 30, 1, 1); 1246 1247 ret = input_register_device(wdata->extension.input); 1248 if (ret) 1249 goto err_free; 1250 1251 return 0; 1252 1253 err_free: 1254 input_free_device(wdata->extension.input); 1255 wdata->extension.input = NULL; 1256 return ret; 1257 } 1258 1259 static void wiimod_classic_remove(const struct wiimod_ops *ops, 1260 struct wiimote_data *wdata) 1261 { 1262 if (!wdata->extension.input) 1263 return; 1264 1265 input_unregister_device(wdata->extension.input); 1266 wdata->extension.input = NULL; 1267 } 1268 1269 static const struct wiimod_ops wiimod_classic = { 1270 .flags = 0, 1271 .arg = 0, 1272 .probe = wiimod_classic_probe, 1273 .remove = wiimod_classic_remove, 1274 .in_ext = wiimod_classic_in_ext, 1275 }; 1276 1277 /* 1278 * Balance Board Extension 1279 * The Nintendo Wii Balance Board provides four hardware weight sensor plus a 1280 * single push button. No other peripherals are available. However, the 1281 * balance-board data is sent via a standard Wii Remote extension. All other 1282 * data for non-present hardware is zeroed out. 1283 * Some 3rd party devices react allergic if we try to access normal Wii Remote 1284 * hardware, so this extension module should be the only module that is loaded 1285 * on balance boards. 1286 * The balance board needs 8 bytes extension data instead of basic 6 bytes so 1287 * it needs the WIIMOD_FLAG_EXT8 flag. 1288 */ 1289 1290 static void wiimod_bboard_in_keys(struct wiimote_data *wdata, const __u8 *keys) 1291 { 1292 input_report_key(wdata->extension.input, BTN_A, 1293 !!(keys[1] & 0x08)); 1294 input_sync(wdata->extension.input); 1295 } 1296 1297 static void wiimod_bboard_in_ext(struct wiimote_data *wdata, 1298 const __u8 *ext) 1299 { 1300 __s32 val[4], tmp, div; 1301 unsigned int i; 1302 struct wiimote_state *s = &wdata->state; 1303 1304 /* 1305 * Balance board data layout: 1306 * 1307 * Byte | 8 7 6 5 4 3 2 1 | 1308 * -----+--------------------------+ 1309 * 1 | Top Right <15:8> | 1310 * 2 | Top Right <7:0> | 1311 * -----+--------------------------+ 1312 * 3 | Bottom Right <15:8> | 1313 * 4 | Bottom Right <7:0> | 1314 * -----+--------------------------+ 1315 * 5 | Top Left <15:8> | 1316 * 6 | Top Left <7:0> | 1317 * -----+--------------------------+ 1318 * 7 | Bottom Left <15:8> | 1319 * 8 | Bottom Left <7:0> | 1320 * -----+--------------------------+ 1321 * 1322 * These values represent the weight-measurements of the Wii-balance 1323 * board with 16bit precision. 1324 * 1325 * The balance-board is never reported interleaved with motionp. 1326 */ 1327 1328 val[0] = ext[0]; 1329 val[0] <<= 8; 1330 val[0] |= ext[1]; 1331 1332 val[1] = ext[2]; 1333 val[1] <<= 8; 1334 val[1] |= ext[3]; 1335 1336 val[2] = ext[4]; 1337 val[2] <<= 8; 1338 val[2] |= ext[5]; 1339 1340 val[3] = ext[6]; 1341 val[3] <<= 8; 1342 val[3] |= ext[7]; 1343 1344 /* apply calibration data */ 1345 for (i = 0; i < 4; i++) { 1346 if (val[i] <= s->calib_bboard[i][0]) { 1347 tmp = 0; 1348 } else if (val[i] < s->calib_bboard[i][1]) { 1349 tmp = val[i] - s->calib_bboard[i][0]; 1350 tmp *= 1700; 1351 div = s->calib_bboard[i][1] - s->calib_bboard[i][0]; 1352 tmp /= div ? div : 1; 1353 } else { 1354 tmp = val[i] - s->calib_bboard[i][1]; 1355 tmp *= 1700; 1356 div = s->calib_bboard[i][2] - s->calib_bboard[i][1]; 1357 tmp /= div ? div : 1; 1358 tmp += 1700; 1359 } 1360 val[i] = tmp; 1361 } 1362 1363 input_report_abs(wdata->extension.input, ABS_HAT0X, val[0]); 1364 input_report_abs(wdata->extension.input, ABS_HAT0Y, val[1]); 1365 input_report_abs(wdata->extension.input, ABS_HAT1X, val[2]); 1366 input_report_abs(wdata->extension.input, ABS_HAT1Y, val[3]); 1367 input_sync(wdata->extension.input); 1368 } 1369 1370 static int wiimod_bboard_open(struct input_dev *dev) 1371 { 1372 struct wiimote_data *wdata = input_get_drvdata(dev); 1373 unsigned long flags; 1374 1375 spin_lock_irqsave(&wdata->state.lock, flags); 1376 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 1377 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1378 spin_unlock_irqrestore(&wdata->state.lock, flags); 1379 1380 return 0; 1381 } 1382 1383 static void wiimod_bboard_close(struct input_dev *dev) 1384 { 1385 struct wiimote_data *wdata = input_get_drvdata(dev); 1386 unsigned long flags; 1387 1388 spin_lock_irqsave(&wdata->state.lock, flags); 1389 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 1390 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1391 spin_unlock_irqrestore(&wdata->state.lock, flags); 1392 } 1393 1394 static ssize_t wiimod_bboard_calib_show(struct device *dev, 1395 struct device_attribute *attr, 1396 char *out) 1397 { 1398 struct wiimote_data *wdata = dev_to_wii(dev); 1399 int i, j, ret; 1400 __u16 val; 1401 __u8 buf[24], offs; 1402 1403 ret = wiimote_cmd_acquire(wdata); 1404 if (ret) 1405 return ret; 1406 1407 ret = wiimote_cmd_read(wdata, 0xa40024, buf, 12); 1408 if (ret != 12) { 1409 wiimote_cmd_release(wdata); 1410 return ret < 0 ? ret : -EIO; 1411 } 1412 ret = wiimote_cmd_read(wdata, 0xa40024 + 12, buf + 12, 12); 1413 if (ret != 12) { 1414 wiimote_cmd_release(wdata); 1415 return ret < 0 ? ret : -EIO; 1416 } 1417 1418 wiimote_cmd_release(wdata); 1419 1420 spin_lock_irq(&wdata->state.lock); 1421 offs = 0; 1422 for (i = 0; i < 3; ++i) { 1423 for (j = 0; j < 4; ++j) { 1424 wdata->state.calib_bboard[j][i] = buf[offs]; 1425 wdata->state.calib_bboard[j][i] <<= 8; 1426 wdata->state.calib_bboard[j][i] |= buf[offs + 1]; 1427 offs += 2; 1428 } 1429 } 1430 spin_unlock_irq(&wdata->state.lock); 1431 1432 ret = 0; 1433 for (i = 0; i < 3; ++i) { 1434 for (j = 0; j < 4; ++j) { 1435 val = wdata->state.calib_bboard[j][i]; 1436 if (i == 2 && j == 3) 1437 ret += sprintf(&out[ret], "%04x\n", val); 1438 else 1439 ret += sprintf(&out[ret], "%04x:", val); 1440 } 1441 } 1442 1443 return ret; 1444 } 1445 1446 static DEVICE_ATTR(bboard_calib, S_IRUGO, wiimod_bboard_calib_show, NULL); 1447 1448 static int wiimod_bboard_probe(const struct wiimod_ops *ops, 1449 struct wiimote_data *wdata) 1450 { 1451 int ret, i, j; 1452 __u8 buf[24], offs; 1453 1454 wiimote_cmd_acquire_noint(wdata); 1455 1456 ret = wiimote_cmd_read(wdata, 0xa40024, buf, 12); 1457 if (ret != 12) { 1458 wiimote_cmd_release(wdata); 1459 return ret < 0 ? ret : -EIO; 1460 } 1461 ret = wiimote_cmd_read(wdata, 0xa40024 + 12, buf + 12, 12); 1462 if (ret != 12) { 1463 wiimote_cmd_release(wdata); 1464 return ret < 0 ? ret : -EIO; 1465 } 1466 1467 wiimote_cmd_release(wdata); 1468 1469 offs = 0; 1470 for (i = 0; i < 3; ++i) { 1471 for (j = 0; j < 4; ++j) { 1472 wdata->state.calib_bboard[j][i] = buf[offs]; 1473 wdata->state.calib_bboard[j][i] <<= 8; 1474 wdata->state.calib_bboard[j][i] |= buf[offs + 1]; 1475 offs += 2; 1476 } 1477 } 1478 1479 wdata->extension.input = input_allocate_device(); 1480 if (!wdata->extension.input) 1481 return -ENOMEM; 1482 1483 ret = device_create_file(&wdata->hdev->dev, 1484 &dev_attr_bboard_calib); 1485 if (ret) { 1486 hid_err(wdata->hdev, "cannot create sysfs attribute\n"); 1487 goto err_free; 1488 } 1489 1490 input_set_drvdata(wdata->extension.input, wdata); 1491 wdata->extension.input->open = wiimod_bboard_open; 1492 wdata->extension.input->close = wiimod_bboard_close; 1493 wdata->extension.input->dev.parent = &wdata->hdev->dev; 1494 wdata->extension.input->id.bustype = wdata->hdev->bus; 1495 wdata->extension.input->id.vendor = wdata->hdev->vendor; 1496 wdata->extension.input->id.product = wdata->hdev->product; 1497 wdata->extension.input->id.version = wdata->hdev->version; 1498 wdata->extension.input->name = WIIMOTE_NAME " Balance Board"; 1499 1500 set_bit(EV_KEY, wdata->extension.input->evbit); 1501 set_bit(BTN_A, wdata->extension.input->keybit); 1502 1503 set_bit(EV_ABS, wdata->extension.input->evbit); 1504 set_bit(ABS_HAT0X, wdata->extension.input->absbit); 1505 set_bit(ABS_HAT0Y, wdata->extension.input->absbit); 1506 set_bit(ABS_HAT1X, wdata->extension.input->absbit); 1507 set_bit(ABS_HAT1Y, wdata->extension.input->absbit); 1508 input_set_abs_params(wdata->extension.input, 1509 ABS_HAT0X, 0, 65535, 2, 4); 1510 input_set_abs_params(wdata->extension.input, 1511 ABS_HAT0Y, 0, 65535, 2, 4); 1512 input_set_abs_params(wdata->extension.input, 1513 ABS_HAT1X, 0, 65535, 2, 4); 1514 input_set_abs_params(wdata->extension.input, 1515 ABS_HAT1Y, 0, 65535, 2, 4); 1516 1517 ret = input_register_device(wdata->extension.input); 1518 if (ret) 1519 goto err_file; 1520 1521 return 0; 1522 1523 err_file: 1524 device_remove_file(&wdata->hdev->dev, 1525 &dev_attr_bboard_calib); 1526 err_free: 1527 input_free_device(wdata->extension.input); 1528 wdata->extension.input = NULL; 1529 return ret; 1530 } 1531 1532 static void wiimod_bboard_remove(const struct wiimod_ops *ops, 1533 struct wiimote_data *wdata) 1534 { 1535 if (!wdata->extension.input) 1536 return; 1537 1538 input_unregister_device(wdata->extension.input); 1539 wdata->extension.input = NULL; 1540 device_remove_file(&wdata->hdev->dev, 1541 &dev_attr_bboard_calib); 1542 } 1543 1544 static const struct wiimod_ops wiimod_bboard = { 1545 .flags = WIIMOD_FLAG_EXT8, 1546 .arg = 0, 1547 .probe = wiimod_bboard_probe, 1548 .remove = wiimod_bboard_remove, 1549 .in_keys = wiimod_bboard_in_keys, 1550 .in_ext = wiimod_bboard_in_ext, 1551 }; 1552 1553 /* 1554 * Pro Controller 1555 * Released with the Wii U was the Nintendo Wii U Pro Controller. It does not 1556 * work together with the classic Wii, but only with the new Wii U. However, it 1557 * uses the same protocol and provides a builtin "classic controller pro" 1558 * extension, few standard buttons, a rumble motor, 4 LEDs and a battery. 1559 * We provide all these via a standard extension device as the device doesn't 1560 * feature an extension port. 1561 */ 1562 1563 enum wiimod_pro_keys { 1564 WIIMOD_PRO_KEY_A, 1565 WIIMOD_PRO_KEY_B, 1566 WIIMOD_PRO_KEY_X, 1567 WIIMOD_PRO_KEY_Y, 1568 WIIMOD_PRO_KEY_PLUS, 1569 WIIMOD_PRO_KEY_MINUS, 1570 WIIMOD_PRO_KEY_HOME, 1571 WIIMOD_PRO_KEY_LEFT, 1572 WIIMOD_PRO_KEY_RIGHT, 1573 WIIMOD_PRO_KEY_UP, 1574 WIIMOD_PRO_KEY_DOWN, 1575 WIIMOD_PRO_KEY_TL, 1576 WIIMOD_PRO_KEY_TR, 1577 WIIMOD_PRO_KEY_ZL, 1578 WIIMOD_PRO_KEY_ZR, 1579 WIIMOD_PRO_KEY_THUMBL, 1580 WIIMOD_PRO_KEY_THUMBR, 1581 WIIMOD_PRO_KEY_NUM, 1582 }; 1583 1584 static const __u16 wiimod_pro_map[] = { 1585 BTN_EAST, /* WIIMOD_PRO_KEY_A */ 1586 BTN_SOUTH, /* WIIMOD_PRO_KEY_B */ 1587 BTN_NORTH, /* WIIMOD_PRO_KEY_X */ 1588 BTN_WEST, /* WIIMOD_PRO_KEY_Y */ 1589 BTN_START, /* WIIMOD_PRO_KEY_PLUS */ 1590 BTN_SELECT, /* WIIMOD_PRO_KEY_MINUS */ 1591 BTN_MODE, /* WIIMOD_PRO_KEY_HOME */ 1592 BTN_DPAD_LEFT, /* WIIMOD_PRO_KEY_LEFT */ 1593 BTN_DPAD_RIGHT, /* WIIMOD_PRO_KEY_RIGHT */ 1594 BTN_DPAD_UP, /* WIIMOD_PRO_KEY_UP */ 1595 BTN_DPAD_DOWN, /* WIIMOD_PRO_KEY_DOWN */ 1596 BTN_TL, /* WIIMOD_PRO_KEY_TL */ 1597 BTN_TR, /* WIIMOD_PRO_KEY_TR */ 1598 BTN_TL2, /* WIIMOD_PRO_KEY_ZL */ 1599 BTN_TR2, /* WIIMOD_PRO_KEY_ZR */ 1600 BTN_THUMBL, /* WIIMOD_PRO_KEY_THUMBL */ 1601 BTN_THUMBR, /* WIIMOD_PRO_KEY_THUMBR */ 1602 }; 1603 1604 static void wiimod_pro_in_ext(struct wiimote_data *wdata, const __u8 *ext) 1605 { 1606 __s16 rx, ry, lx, ly; 1607 1608 /* Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 1609 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1610 * 1 | LX <7:0> | 1611 * -----+-----------------------+-----------------------+ 1612 * 2 | 0 0 0 0 | LX <11:8> | 1613 * -----+-----------------------+-----------------------+ 1614 * 3 | RX <7:0> | 1615 * -----+-----------------------+-----------------------+ 1616 * 4 | 0 0 0 0 | RX <11:8> | 1617 * -----+-----------------------+-----------------------+ 1618 * 5 | LY <7:0> | 1619 * -----+-----------------------+-----------------------+ 1620 * 6 | 0 0 0 0 | LY <11:8> | 1621 * -----+-----------------------+-----------------------+ 1622 * 7 | RY <7:0> | 1623 * -----+-----------------------+-----------------------+ 1624 * 8 | 0 0 0 0 | RY <11:8> | 1625 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1626 * 9 | BDR | BDD | BLT | B- | BH | B+ | BRT | 1 | 1627 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1628 * 10 | BZL | BB | BY | BA | BX | BZR | BDL | BDU | 1629 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1630 * 11 | 1 | BATTERY | USB |CHARG|LTHUM|RTHUM| 1631 * -----+-----+-----------------+-----------+-----+-----+ 1632 * All buttons are low-active (0 if pressed) 1633 * RX and RY are right analog stick 1634 * LX and LY are left analog stick 1635 * BLT is left trigger, BRT is right trigger. 1636 * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons 1637 * BZL is left Z button and BZR is right Z button 1638 * B-, BH, B+ are +, HOME and - buttons 1639 * BB, BY, BA, BX are A, B, X, Y buttons 1640 * 1641 * Bits marked as 0/1 are unknown and never changed during tests. 1642 * 1643 * Not entirely verified: 1644 * CHARG: 1 if uncharging, 0 if charging 1645 * USB: 1 if not connected, 0 if connected 1646 * BATTERY: battery capacity from 000 (empty) to 100 (full) 1647 */ 1648 1649 lx = (ext[0] & 0xff) | ((ext[1] & 0x0f) << 8); 1650 rx = (ext[2] & 0xff) | ((ext[3] & 0x0f) << 8); 1651 ly = (ext[4] & 0xff) | ((ext[5] & 0x0f) << 8); 1652 ry = (ext[6] & 0xff) | ((ext[7] & 0x0f) << 8); 1653 1654 /* zero-point offsets */ 1655 lx -= 0x800; 1656 ly = 0x800 - ly; 1657 rx -= 0x800; 1658 ry = 0x800 - ry; 1659 1660 /* Trivial automatic calibration. We don't know any calibration data 1661 * in the EEPROM so we must use the first report to calibrate the 1662 * null-position of the analog sticks. Users can retrigger calibration 1663 * via sysfs, or set it explicitly. If data is off more than abs(500), 1664 * we skip calibration as the sticks are likely to be moved already. */ 1665 if (!(wdata->state.flags & WIIPROTO_FLAG_PRO_CALIB_DONE)) { 1666 wdata->state.flags |= WIIPROTO_FLAG_PRO_CALIB_DONE; 1667 if (abs(lx) < 500) 1668 wdata->state.calib_pro_sticks[0] = -lx; 1669 if (abs(ly) < 500) 1670 wdata->state.calib_pro_sticks[1] = -ly; 1671 if (abs(rx) < 500) 1672 wdata->state.calib_pro_sticks[2] = -rx; 1673 if (abs(ry) < 500) 1674 wdata->state.calib_pro_sticks[3] = -ry; 1675 } 1676 1677 /* apply calibration data */ 1678 lx += wdata->state.calib_pro_sticks[0]; 1679 ly += wdata->state.calib_pro_sticks[1]; 1680 rx += wdata->state.calib_pro_sticks[2]; 1681 ry += wdata->state.calib_pro_sticks[3]; 1682 1683 input_report_abs(wdata->extension.input, ABS_X, lx); 1684 input_report_abs(wdata->extension.input, ABS_Y, ly); 1685 input_report_abs(wdata->extension.input, ABS_RX, rx); 1686 input_report_abs(wdata->extension.input, ABS_RY, ry); 1687 1688 input_report_key(wdata->extension.input, 1689 wiimod_pro_map[WIIMOD_PRO_KEY_RIGHT], 1690 !(ext[8] & 0x80)); 1691 input_report_key(wdata->extension.input, 1692 wiimod_pro_map[WIIMOD_PRO_KEY_DOWN], 1693 !(ext[8] & 0x40)); 1694 input_report_key(wdata->extension.input, 1695 wiimod_pro_map[WIIMOD_PRO_KEY_TL], 1696 !(ext[8] & 0x20)); 1697 input_report_key(wdata->extension.input, 1698 wiimod_pro_map[WIIMOD_PRO_KEY_MINUS], 1699 !(ext[8] & 0x10)); 1700 input_report_key(wdata->extension.input, 1701 wiimod_pro_map[WIIMOD_PRO_KEY_HOME], 1702 !(ext[8] & 0x08)); 1703 input_report_key(wdata->extension.input, 1704 wiimod_pro_map[WIIMOD_PRO_KEY_PLUS], 1705 !(ext[8] & 0x04)); 1706 input_report_key(wdata->extension.input, 1707 wiimod_pro_map[WIIMOD_PRO_KEY_TR], 1708 !(ext[8] & 0x02)); 1709 1710 input_report_key(wdata->extension.input, 1711 wiimod_pro_map[WIIMOD_PRO_KEY_ZL], 1712 !(ext[9] & 0x80)); 1713 input_report_key(wdata->extension.input, 1714 wiimod_pro_map[WIIMOD_PRO_KEY_B], 1715 !(ext[9] & 0x40)); 1716 input_report_key(wdata->extension.input, 1717 wiimod_pro_map[WIIMOD_PRO_KEY_Y], 1718 !(ext[9] & 0x20)); 1719 input_report_key(wdata->extension.input, 1720 wiimod_pro_map[WIIMOD_PRO_KEY_A], 1721 !(ext[9] & 0x10)); 1722 input_report_key(wdata->extension.input, 1723 wiimod_pro_map[WIIMOD_PRO_KEY_X], 1724 !(ext[9] & 0x08)); 1725 input_report_key(wdata->extension.input, 1726 wiimod_pro_map[WIIMOD_PRO_KEY_ZR], 1727 !(ext[9] & 0x04)); 1728 input_report_key(wdata->extension.input, 1729 wiimod_pro_map[WIIMOD_PRO_KEY_LEFT], 1730 !(ext[9] & 0x02)); 1731 input_report_key(wdata->extension.input, 1732 wiimod_pro_map[WIIMOD_PRO_KEY_UP], 1733 !(ext[9] & 0x01)); 1734 1735 input_report_key(wdata->extension.input, 1736 wiimod_pro_map[WIIMOD_PRO_KEY_THUMBL], 1737 !(ext[10] & 0x02)); 1738 input_report_key(wdata->extension.input, 1739 wiimod_pro_map[WIIMOD_PRO_KEY_THUMBR], 1740 !(ext[10] & 0x01)); 1741 1742 input_sync(wdata->extension.input); 1743 } 1744 1745 static int wiimod_pro_open(struct input_dev *dev) 1746 { 1747 struct wiimote_data *wdata = input_get_drvdata(dev); 1748 unsigned long flags; 1749 1750 spin_lock_irqsave(&wdata->state.lock, flags); 1751 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 1752 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1753 spin_unlock_irqrestore(&wdata->state.lock, flags); 1754 1755 return 0; 1756 } 1757 1758 static void wiimod_pro_close(struct input_dev *dev) 1759 { 1760 struct wiimote_data *wdata = input_get_drvdata(dev); 1761 unsigned long flags; 1762 1763 spin_lock_irqsave(&wdata->state.lock, flags); 1764 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 1765 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 1766 spin_unlock_irqrestore(&wdata->state.lock, flags); 1767 } 1768 1769 static int wiimod_pro_play(struct input_dev *dev, void *data, 1770 struct ff_effect *eff) 1771 { 1772 struct wiimote_data *wdata = input_get_drvdata(dev); 1773 __u8 value; 1774 1775 /* 1776 * The wiimote supports only a single rumble motor so if any magnitude 1777 * is set to non-zero then we start the rumble motor. If both are set to 1778 * zero, we stop the rumble motor. 1779 */ 1780 1781 if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude) 1782 value = 1; 1783 else 1784 value = 0; 1785 1786 /* Locking state.lock here might deadlock with input_event() calls. 1787 * schedule_work acts as barrier. Merging multiple changes is fine. */ 1788 wdata->state.cache_rumble = value; 1789 schedule_work(&wdata->rumble_worker); 1790 1791 return 0; 1792 } 1793 1794 static ssize_t wiimod_pro_calib_show(struct device *dev, 1795 struct device_attribute *attr, 1796 char *out) 1797 { 1798 struct wiimote_data *wdata = dev_to_wii(dev); 1799 int r; 1800 1801 r = 0; 1802 r += sprintf(&out[r], "%+06hd:", wdata->state.calib_pro_sticks[0]); 1803 r += sprintf(&out[r], "%+06hd ", wdata->state.calib_pro_sticks[1]); 1804 r += sprintf(&out[r], "%+06hd:", wdata->state.calib_pro_sticks[2]); 1805 r += sprintf(&out[r], "%+06hd\n", wdata->state.calib_pro_sticks[3]); 1806 1807 return r; 1808 } 1809 1810 static ssize_t wiimod_pro_calib_store(struct device *dev, 1811 struct device_attribute *attr, 1812 const char *buf, size_t count) 1813 { 1814 struct wiimote_data *wdata = dev_to_wii(dev); 1815 int r; 1816 s16 x1, y1, x2, y2; 1817 1818 if (!strncmp(buf, "scan\n", 5)) { 1819 spin_lock_irq(&wdata->state.lock); 1820 wdata->state.flags &= ~WIIPROTO_FLAG_PRO_CALIB_DONE; 1821 spin_unlock_irq(&wdata->state.lock); 1822 } else { 1823 r = sscanf(buf, "%hd:%hd %hd:%hd", &x1, &y1, &x2, &y2); 1824 if (r != 4) 1825 return -EINVAL; 1826 1827 spin_lock_irq(&wdata->state.lock); 1828 wdata->state.flags |= WIIPROTO_FLAG_PRO_CALIB_DONE; 1829 spin_unlock_irq(&wdata->state.lock); 1830 1831 wdata->state.calib_pro_sticks[0] = x1; 1832 wdata->state.calib_pro_sticks[1] = y1; 1833 wdata->state.calib_pro_sticks[2] = x2; 1834 wdata->state.calib_pro_sticks[3] = y2; 1835 } 1836 1837 return strnlen(buf, PAGE_SIZE); 1838 } 1839 1840 static DEVICE_ATTR(pro_calib, S_IRUGO|S_IWUSR|S_IWGRP, wiimod_pro_calib_show, 1841 wiimod_pro_calib_store); 1842 1843 static int wiimod_pro_probe(const struct wiimod_ops *ops, 1844 struct wiimote_data *wdata) 1845 { 1846 int ret, i; 1847 unsigned long flags; 1848 1849 INIT_WORK(&wdata->rumble_worker, wiimod_rumble_worker); 1850 wdata->state.calib_pro_sticks[0] = 0; 1851 wdata->state.calib_pro_sticks[1] = 0; 1852 wdata->state.calib_pro_sticks[2] = 0; 1853 wdata->state.calib_pro_sticks[3] = 0; 1854 1855 spin_lock_irqsave(&wdata->state.lock, flags); 1856 wdata->state.flags &= ~WIIPROTO_FLAG_PRO_CALIB_DONE; 1857 spin_unlock_irqrestore(&wdata->state.lock, flags); 1858 1859 wdata->extension.input = input_allocate_device(); 1860 if (!wdata->extension.input) 1861 return -ENOMEM; 1862 1863 set_bit(FF_RUMBLE, wdata->extension.input->ffbit); 1864 input_set_drvdata(wdata->extension.input, wdata); 1865 1866 if (input_ff_create_memless(wdata->extension.input, NULL, 1867 wiimod_pro_play)) { 1868 ret = -ENOMEM; 1869 goto err_free; 1870 } 1871 1872 ret = device_create_file(&wdata->hdev->dev, 1873 &dev_attr_pro_calib); 1874 if (ret) { 1875 hid_err(wdata->hdev, "cannot create sysfs attribute\n"); 1876 goto err_free; 1877 } 1878 1879 wdata->extension.input->open = wiimod_pro_open; 1880 wdata->extension.input->close = wiimod_pro_close; 1881 wdata->extension.input->dev.parent = &wdata->hdev->dev; 1882 wdata->extension.input->id.bustype = wdata->hdev->bus; 1883 wdata->extension.input->id.vendor = wdata->hdev->vendor; 1884 wdata->extension.input->id.product = wdata->hdev->product; 1885 wdata->extension.input->id.version = wdata->hdev->version; 1886 wdata->extension.input->name = WIIMOTE_NAME " Pro Controller"; 1887 1888 set_bit(EV_KEY, wdata->extension.input->evbit); 1889 for (i = 0; i < WIIMOD_PRO_KEY_NUM; ++i) 1890 set_bit(wiimod_pro_map[i], 1891 wdata->extension.input->keybit); 1892 1893 set_bit(EV_ABS, wdata->extension.input->evbit); 1894 set_bit(ABS_X, wdata->extension.input->absbit); 1895 set_bit(ABS_Y, wdata->extension.input->absbit); 1896 set_bit(ABS_RX, wdata->extension.input->absbit); 1897 set_bit(ABS_RY, wdata->extension.input->absbit); 1898 input_set_abs_params(wdata->extension.input, 1899 ABS_X, -0x400, 0x400, 4, 100); 1900 input_set_abs_params(wdata->extension.input, 1901 ABS_Y, -0x400, 0x400, 4, 100); 1902 input_set_abs_params(wdata->extension.input, 1903 ABS_RX, -0x400, 0x400, 4, 100); 1904 input_set_abs_params(wdata->extension.input, 1905 ABS_RY, -0x400, 0x400, 4, 100); 1906 1907 ret = input_register_device(wdata->extension.input); 1908 if (ret) 1909 goto err_file; 1910 1911 return 0; 1912 1913 err_file: 1914 device_remove_file(&wdata->hdev->dev, 1915 &dev_attr_pro_calib); 1916 err_free: 1917 input_free_device(wdata->extension.input); 1918 wdata->extension.input = NULL; 1919 return ret; 1920 } 1921 1922 static void wiimod_pro_remove(const struct wiimod_ops *ops, 1923 struct wiimote_data *wdata) 1924 { 1925 unsigned long flags; 1926 1927 if (!wdata->extension.input) 1928 return; 1929 1930 input_unregister_device(wdata->extension.input); 1931 wdata->extension.input = NULL; 1932 cancel_work_sync(&wdata->rumble_worker); 1933 device_remove_file(&wdata->hdev->dev, 1934 &dev_attr_pro_calib); 1935 1936 spin_lock_irqsave(&wdata->state.lock, flags); 1937 wiiproto_req_rumble(wdata, 0); 1938 spin_unlock_irqrestore(&wdata->state.lock, flags); 1939 } 1940 1941 static const struct wiimod_ops wiimod_pro = { 1942 .flags = WIIMOD_FLAG_EXT16, 1943 .arg = 0, 1944 .probe = wiimod_pro_probe, 1945 .remove = wiimod_pro_remove, 1946 .in_ext = wiimod_pro_in_ext, 1947 }; 1948 1949 /* 1950 * Drums 1951 * Guitar-Hero, Rock-Band and other games came bundled with drums which can 1952 * be plugged as extension to a Wiimote. Drum-reports are still not entirely 1953 * figured out, but the most important information is known. 1954 * We create a separate device for drums and report all information via this 1955 * input device. 1956 */ 1957 1958 static inline void wiimod_drums_report_pressure(struct wiimote_data *wdata, 1959 __u8 none, __u8 which, 1960 __u8 pressure, __u8 onoff, 1961 __u8 *store, __u16 code, 1962 __u8 which_code) 1963 { 1964 static const __u8 default_pressure = 3; 1965 1966 if (!none && which == which_code) { 1967 *store = pressure; 1968 input_report_abs(wdata->extension.input, code, *store); 1969 } else if (onoff != !!*store) { 1970 *store = onoff ? default_pressure : 0; 1971 input_report_abs(wdata->extension.input, code, *store); 1972 } 1973 } 1974 1975 static void wiimod_drums_in_ext(struct wiimote_data *wdata, const __u8 *ext) 1976 { 1977 __u8 pressure, which, none, hhp, sx, sy; 1978 __u8 o, r, y, g, b, bass, bm, bp; 1979 1980 /* Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 1981 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1982 * 1 | 0 | 0 | SX <5:0> | 1983 * 2 | 0 | 0 | SY <5:0> | 1984 * -----+-----+-----+-----------------------------+-----+ 1985 * 3 | HPP | NON | WHICH <5:1> | ? | 1986 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1987 * 4 | SOFT <7:5> | 0 | 1 | 1 | 0 | ? | 1988 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1989 * 5 | ? | 1 | 1 | B- | 1 | B+ | 1 | ? | 1990 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1991 * 6 | O | R | Y | G | B | BSS | 1 | 1 | 1992 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1993 * All buttons are 0 if pressed 1994 * 1995 * With Motion+ enabled, the following bits will get invalid: 1996 * Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 1997 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 1998 * 1 | 0 | 0 | SX <5:1> |XXXXX| 1999 * 2 | 0 | 0 | SY <5:1> |XXXXX| 2000 * -----+-----+-----+-----------------------------+-----+ 2001 * 3 | HPP | NON | WHICH <5:1> | ? | 2002 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2003 * 4 | SOFT <7:5> | 0 | 1 | 1 | 0 | ? | 2004 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2005 * 5 | ? | 1 | 1 | B- | 1 | B+ | 1 |XXXXX| 2006 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2007 * 6 | O | R | Y | G | B | BSS |XXXXX|XXXXX| 2008 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2009 */ 2010 2011 pressure = 7 - (ext[3] >> 5); 2012 which = (ext[2] >> 1) & 0x1f; 2013 none = !!(ext[2] & 0x40); 2014 hhp = !(ext[2] & 0x80); 2015 sx = ext[0] & 0x3f; 2016 sy = ext[1] & 0x3f; 2017 o = !(ext[5] & 0x80); 2018 r = !(ext[5] & 0x40); 2019 y = !(ext[5] & 0x20); 2020 g = !(ext[5] & 0x10); 2021 b = !(ext[5] & 0x08); 2022 bass = !(ext[5] & 0x04); 2023 bm = !(ext[4] & 0x10); 2024 bp = !(ext[4] & 0x04); 2025 2026 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 2027 sx &= 0x3e; 2028 sy &= 0x3e; 2029 } 2030 2031 wiimod_drums_report_pressure(wdata, none, which, pressure, 2032 o, &wdata->state.pressure_drums[0], 2033 ABS_HAT2Y, 0x0e); 2034 wiimod_drums_report_pressure(wdata, none, which, pressure, 2035 r, &wdata->state.pressure_drums[1], 2036 ABS_HAT0X, 0x19); 2037 wiimod_drums_report_pressure(wdata, none, which, pressure, 2038 y, &wdata->state.pressure_drums[2], 2039 ABS_HAT2X, 0x11); 2040 wiimod_drums_report_pressure(wdata, none, which, pressure, 2041 g, &wdata->state.pressure_drums[3], 2042 ABS_HAT1X, 0x12); 2043 wiimod_drums_report_pressure(wdata, none, which, pressure, 2044 b, &wdata->state.pressure_drums[4], 2045 ABS_HAT0Y, 0x0f); 2046 2047 /* Bass shares pressure with hi-hat (set via hhp) */ 2048 wiimod_drums_report_pressure(wdata, none, hhp ? 0xff : which, pressure, 2049 bass, &wdata->state.pressure_drums[5], 2050 ABS_HAT3X, 0x1b); 2051 /* Hi-hat has no on/off values, just pressure. Force to off/0. */ 2052 wiimod_drums_report_pressure(wdata, none, hhp ? which : 0xff, pressure, 2053 0, &wdata->state.pressure_drums[6], 2054 ABS_HAT3Y, 0x0e); 2055 2056 input_report_abs(wdata->extension.input, ABS_X, sx - 0x20); 2057 input_report_abs(wdata->extension.input, ABS_Y, sy - 0x20); 2058 2059 input_report_key(wdata->extension.input, BTN_START, bp); 2060 input_report_key(wdata->extension.input, BTN_SELECT, bm); 2061 2062 input_sync(wdata->extension.input); 2063 } 2064 2065 static int wiimod_drums_open(struct input_dev *dev) 2066 { 2067 struct wiimote_data *wdata = input_get_drvdata(dev); 2068 unsigned long flags; 2069 2070 spin_lock_irqsave(&wdata->state.lock, flags); 2071 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 2072 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2073 spin_unlock_irqrestore(&wdata->state.lock, flags); 2074 2075 return 0; 2076 } 2077 2078 static void wiimod_drums_close(struct input_dev *dev) 2079 { 2080 struct wiimote_data *wdata = input_get_drvdata(dev); 2081 unsigned long flags; 2082 2083 spin_lock_irqsave(&wdata->state.lock, flags); 2084 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 2085 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2086 spin_unlock_irqrestore(&wdata->state.lock, flags); 2087 } 2088 2089 static int wiimod_drums_probe(const struct wiimod_ops *ops, 2090 struct wiimote_data *wdata) 2091 { 2092 int ret; 2093 2094 wdata->extension.input = input_allocate_device(); 2095 if (!wdata->extension.input) 2096 return -ENOMEM; 2097 2098 input_set_drvdata(wdata->extension.input, wdata); 2099 wdata->extension.input->open = wiimod_drums_open; 2100 wdata->extension.input->close = wiimod_drums_close; 2101 wdata->extension.input->dev.parent = &wdata->hdev->dev; 2102 wdata->extension.input->id.bustype = wdata->hdev->bus; 2103 wdata->extension.input->id.vendor = wdata->hdev->vendor; 2104 wdata->extension.input->id.product = wdata->hdev->product; 2105 wdata->extension.input->id.version = wdata->hdev->version; 2106 wdata->extension.input->name = WIIMOTE_NAME " Drums"; 2107 2108 set_bit(EV_KEY, wdata->extension.input->evbit); 2109 set_bit(BTN_START, wdata->extension.input->keybit); 2110 set_bit(BTN_SELECT, wdata->extension.input->keybit); 2111 2112 set_bit(EV_ABS, wdata->extension.input->evbit); 2113 set_bit(ABS_X, wdata->extension.input->absbit); 2114 set_bit(ABS_Y, wdata->extension.input->absbit); 2115 set_bit(ABS_HAT0X, wdata->extension.input->absbit); 2116 set_bit(ABS_HAT0Y, wdata->extension.input->absbit); 2117 set_bit(ABS_HAT1X, wdata->extension.input->absbit); 2118 set_bit(ABS_HAT2X, wdata->extension.input->absbit); 2119 set_bit(ABS_HAT2Y, wdata->extension.input->absbit); 2120 set_bit(ABS_HAT3X, wdata->extension.input->absbit); 2121 set_bit(ABS_HAT3Y, wdata->extension.input->absbit); 2122 input_set_abs_params(wdata->extension.input, 2123 ABS_X, -32, 31, 1, 1); 2124 input_set_abs_params(wdata->extension.input, 2125 ABS_Y, -32, 31, 1, 1); 2126 input_set_abs_params(wdata->extension.input, 2127 ABS_HAT0X, 0, 7, 0, 0); 2128 input_set_abs_params(wdata->extension.input, 2129 ABS_HAT0Y, 0, 7, 0, 0); 2130 input_set_abs_params(wdata->extension.input, 2131 ABS_HAT1X, 0, 7, 0, 0); 2132 input_set_abs_params(wdata->extension.input, 2133 ABS_HAT2X, 0, 7, 0, 0); 2134 input_set_abs_params(wdata->extension.input, 2135 ABS_HAT2Y, 0, 7, 0, 0); 2136 input_set_abs_params(wdata->extension.input, 2137 ABS_HAT3X, 0, 7, 0, 0); 2138 input_set_abs_params(wdata->extension.input, 2139 ABS_HAT3Y, 0, 7, 0, 0); 2140 2141 ret = input_register_device(wdata->extension.input); 2142 if (ret) 2143 goto err_free; 2144 2145 return 0; 2146 2147 err_free: 2148 input_free_device(wdata->extension.input); 2149 wdata->extension.input = NULL; 2150 return ret; 2151 } 2152 2153 static void wiimod_drums_remove(const struct wiimod_ops *ops, 2154 struct wiimote_data *wdata) 2155 { 2156 if (!wdata->extension.input) 2157 return; 2158 2159 input_unregister_device(wdata->extension.input); 2160 wdata->extension.input = NULL; 2161 } 2162 2163 static const struct wiimod_ops wiimod_drums = { 2164 .flags = 0, 2165 .arg = 0, 2166 .probe = wiimod_drums_probe, 2167 .remove = wiimod_drums_remove, 2168 .in_ext = wiimod_drums_in_ext, 2169 }; 2170 2171 /* 2172 * Guitar 2173 * Guitar-Hero, Rock-Band and other games came bundled with guitars which can 2174 * be plugged as extension to a Wiimote. 2175 * We create a separate device for guitars and report all information via this 2176 * input device. 2177 */ 2178 2179 enum wiimod_guitar_keys { 2180 WIIMOD_GUITAR_KEY_G, 2181 WIIMOD_GUITAR_KEY_R, 2182 WIIMOD_GUITAR_KEY_Y, 2183 WIIMOD_GUITAR_KEY_B, 2184 WIIMOD_GUITAR_KEY_O, 2185 WIIMOD_GUITAR_KEY_UP, 2186 WIIMOD_GUITAR_KEY_DOWN, 2187 WIIMOD_GUITAR_KEY_PLUS, 2188 WIIMOD_GUITAR_KEY_MINUS, 2189 WIIMOD_GUITAR_KEY_NUM, 2190 }; 2191 2192 static const __u16 wiimod_guitar_map[] = { 2193 BTN_1, /* WIIMOD_GUITAR_KEY_G */ 2194 BTN_2, /* WIIMOD_GUITAR_KEY_R */ 2195 BTN_3, /* WIIMOD_GUITAR_KEY_Y */ 2196 BTN_4, /* WIIMOD_GUITAR_KEY_B */ 2197 BTN_5, /* WIIMOD_GUITAR_KEY_O */ 2198 BTN_DPAD_UP, /* WIIMOD_GUITAR_KEY_UP */ 2199 BTN_DPAD_DOWN, /* WIIMOD_GUITAR_KEY_DOWN */ 2200 BTN_START, /* WIIMOD_GUITAR_KEY_PLUS */ 2201 BTN_SELECT, /* WIIMOD_GUITAR_KEY_MINUS */ 2202 }; 2203 2204 static void wiimod_guitar_in_ext(struct wiimote_data *wdata, const __u8 *ext) 2205 { 2206 __u8 sx, sy, tb, wb, bd, bm, bp, bo, br, bb, bg, by, bu; 2207 2208 /* Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 2209 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2210 * 1 | 0 | 0 | SX <5:0> | 2211 * 2 | 0 | 0 | SY <5:0> | 2212 * -----+-----+-----+-----+-----------------------------+ 2213 * 3 | 0 | 0 | 0 | TB <4:0> | 2214 * -----+-----+-----+-----+-----------------------------+ 2215 * 4 | 0 | 0 | 0 | WB <4:0> | 2216 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2217 * 5 | 1 | BD | 1 | B- | 1 | B+ | 1 | 1 | 2218 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2219 * 6 | BO | BR | BB | BG | BY | 1 | 1 | BU | 2220 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2221 * All buttons are 0 if pressed 2222 * 2223 * With Motion+ enabled, it will look like this: 2224 * Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 2225 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2226 * 1 | 0 | 0 | SX <5:1> | BU | 2227 * 2 | 0 | 0 | SY <5:1> | 1 | 2228 * -----+-----+-----+-----+-----------------------+-----+ 2229 * 3 | 0 | 0 | 0 | TB <4:0> | 2230 * -----+-----+-----+-----+-----------------------------+ 2231 * 4 | 0 | 0 | 0 | WB <4:0> | 2232 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2233 * 5 | 1 | BD | 1 | B- | 1 | B+ | 1 |XXXXX| 2234 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2235 * 6 | BO | BR | BB | BG | BY | 1 |XXXXX|XXXXX| 2236 * -----+-----+-----+-----+-----+-----+-----+-----+-----+ 2237 */ 2238 2239 sx = ext[0] & 0x3f; 2240 sy = ext[1] & 0x3f; 2241 tb = ext[2] & 0x1f; 2242 wb = ext[3] & 0x1f; 2243 bd = !(ext[4] & 0x40); 2244 bm = !(ext[4] & 0x10); 2245 bp = !(ext[4] & 0x04); 2246 bo = !(ext[5] & 0x80); 2247 br = !(ext[5] & 0x40); 2248 bb = !(ext[5] & 0x20); 2249 bg = !(ext[5] & 0x10); 2250 by = !(ext[5] & 0x08); 2251 bu = !(ext[5] & 0x01); 2252 2253 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) { 2254 bu = !(ext[0] & 0x01); 2255 sx &= 0x3e; 2256 sy &= 0x3e; 2257 } 2258 2259 input_report_abs(wdata->extension.input, ABS_X, sx - 0x20); 2260 input_report_abs(wdata->extension.input, ABS_Y, sy - 0x20); 2261 input_report_abs(wdata->extension.input, ABS_HAT0X, tb); 2262 input_report_abs(wdata->extension.input, ABS_HAT1X, wb - 0x10); 2263 2264 input_report_key(wdata->extension.input, 2265 wiimod_guitar_map[WIIMOD_GUITAR_KEY_G], 2266 bg); 2267 input_report_key(wdata->extension.input, 2268 wiimod_guitar_map[WIIMOD_GUITAR_KEY_R], 2269 br); 2270 input_report_key(wdata->extension.input, 2271 wiimod_guitar_map[WIIMOD_GUITAR_KEY_Y], 2272 by); 2273 input_report_key(wdata->extension.input, 2274 wiimod_guitar_map[WIIMOD_GUITAR_KEY_B], 2275 bb); 2276 input_report_key(wdata->extension.input, 2277 wiimod_guitar_map[WIIMOD_GUITAR_KEY_O], 2278 bo); 2279 input_report_key(wdata->extension.input, 2280 wiimod_guitar_map[WIIMOD_GUITAR_KEY_UP], 2281 bu); 2282 input_report_key(wdata->extension.input, 2283 wiimod_guitar_map[WIIMOD_GUITAR_KEY_DOWN], 2284 bd); 2285 input_report_key(wdata->extension.input, 2286 wiimod_guitar_map[WIIMOD_GUITAR_KEY_PLUS], 2287 bp); 2288 input_report_key(wdata->extension.input, 2289 wiimod_guitar_map[WIIMOD_GUITAR_KEY_MINUS], 2290 bm); 2291 2292 input_sync(wdata->extension.input); 2293 } 2294 2295 static int wiimod_guitar_open(struct input_dev *dev) 2296 { 2297 struct wiimote_data *wdata = input_get_drvdata(dev); 2298 unsigned long flags; 2299 2300 spin_lock_irqsave(&wdata->state.lock, flags); 2301 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED; 2302 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2303 spin_unlock_irqrestore(&wdata->state.lock, flags); 2304 2305 return 0; 2306 } 2307 2308 static void wiimod_guitar_close(struct input_dev *dev) 2309 { 2310 struct wiimote_data *wdata = input_get_drvdata(dev); 2311 unsigned long flags; 2312 2313 spin_lock_irqsave(&wdata->state.lock, flags); 2314 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED; 2315 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2316 spin_unlock_irqrestore(&wdata->state.lock, flags); 2317 } 2318 2319 static int wiimod_guitar_probe(const struct wiimod_ops *ops, 2320 struct wiimote_data *wdata) 2321 { 2322 int ret, i; 2323 2324 wdata->extension.input = input_allocate_device(); 2325 if (!wdata->extension.input) 2326 return -ENOMEM; 2327 2328 input_set_drvdata(wdata->extension.input, wdata); 2329 wdata->extension.input->open = wiimod_guitar_open; 2330 wdata->extension.input->close = wiimod_guitar_close; 2331 wdata->extension.input->dev.parent = &wdata->hdev->dev; 2332 wdata->extension.input->id.bustype = wdata->hdev->bus; 2333 wdata->extension.input->id.vendor = wdata->hdev->vendor; 2334 wdata->extension.input->id.product = wdata->hdev->product; 2335 wdata->extension.input->id.version = wdata->hdev->version; 2336 wdata->extension.input->name = WIIMOTE_NAME " Guitar"; 2337 2338 set_bit(EV_KEY, wdata->extension.input->evbit); 2339 for (i = 0; i < WIIMOD_GUITAR_KEY_NUM; ++i) 2340 set_bit(wiimod_guitar_map[i], 2341 wdata->extension.input->keybit); 2342 2343 set_bit(EV_ABS, wdata->extension.input->evbit); 2344 set_bit(ABS_X, wdata->extension.input->absbit); 2345 set_bit(ABS_Y, wdata->extension.input->absbit); 2346 set_bit(ABS_HAT0X, wdata->extension.input->absbit); 2347 set_bit(ABS_HAT1X, wdata->extension.input->absbit); 2348 input_set_abs_params(wdata->extension.input, 2349 ABS_X, -32, 31, 1, 1); 2350 input_set_abs_params(wdata->extension.input, 2351 ABS_Y, -32, 31, 1, 1); 2352 input_set_abs_params(wdata->extension.input, 2353 ABS_HAT0X, 0, 0x1f, 1, 1); 2354 input_set_abs_params(wdata->extension.input, 2355 ABS_HAT1X, 0, 0x0f, 1, 1); 2356 2357 ret = input_register_device(wdata->extension.input); 2358 if (ret) 2359 goto err_free; 2360 2361 return 0; 2362 2363 err_free: 2364 input_free_device(wdata->extension.input); 2365 wdata->extension.input = NULL; 2366 return ret; 2367 } 2368 2369 static void wiimod_guitar_remove(const struct wiimod_ops *ops, 2370 struct wiimote_data *wdata) 2371 { 2372 if (!wdata->extension.input) 2373 return; 2374 2375 input_unregister_device(wdata->extension.input); 2376 wdata->extension.input = NULL; 2377 } 2378 2379 static const struct wiimod_ops wiimod_guitar = { 2380 .flags = 0, 2381 .arg = 0, 2382 .probe = wiimod_guitar_probe, 2383 .remove = wiimod_guitar_remove, 2384 .in_ext = wiimod_guitar_in_ext, 2385 }; 2386 2387 /* 2388 * Builtin Motion Plus 2389 * This module simply sets the WIIPROTO_FLAG_BUILTIN_MP protocol flag which 2390 * disables polling for Motion-Plus. This should be set only for devices which 2391 * don't allow MP hotplugging. 2392 */ 2393 2394 static int wiimod_builtin_mp_probe(const struct wiimod_ops *ops, 2395 struct wiimote_data *wdata) 2396 { 2397 unsigned long flags; 2398 2399 spin_lock_irqsave(&wdata->state.lock, flags); 2400 wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP; 2401 spin_unlock_irqrestore(&wdata->state.lock, flags); 2402 2403 return 0; 2404 } 2405 2406 static void wiimod_builtin_mp_remove(const struct wiimod_ops *ops, 2407 struct wiimote_data *wdata) 2408 { 2409 unsigned long flags; 2410 2411 spin_lock_irqsave(&wdata->state.lock, flags); 2412 wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP; 2413 spin_unlock_irqrestore(&wdata->state.lock, flags); 2414 } 2415 2416 static const struct wiimod_ops wiimod_builtin_mp = { 2417 .flags = 0, 2418 .arg = 0, 2419 .probe = wiimod_builtin_mp_probe, 2420 .remove = wiimod_builtin_mp_remove, 2421 }; 2422 2423 /* 2424 * No Motion Plus 2425 * This module simply sets the WIIPROTO_FLAG_NO_MP protocol flag which 2426 * disables motion-plus. This is needed for devices that advertise this but we 2427 * don't know how to use it (or whether it is actually present). 2428 */ 2429 2430 static int wiimod_no_mp_probe(const struct wiimod_ops *ops, 2431 struct wiimote_data *wdata) 2432 { 2433 unsigned long flags; 2434 2435 spin_lock_irqsave(&wdata->state.lock, flags); 2436 wdata->state.flags |= WIIPROTO_FLAG_NO_MP; 2437 spin_unlock_irqrestore(&wdata->state.lock, flags); 2438 2439 return 0; 2440 } 2441 2442 static void wiimod_no_mp_remove(const struct wiimod_ops *ops, 2443 struct wiimote_data *wdata) 2444 { 2445 unsigned long flags; 2446 2447 spin_lock_irqsave(&wdata->state.lock, flags); 2448 wdata->state.flags |= WIIPROTO_FLAG_NO_MP; 2449 spin_unlock_irqrestore(&wdata->state.lock, flags); 2450 } 2451 2452 static const struct wiimod_ops wiimod_no_mp = { 2453 .flags = 0, 2454 .arg = 0, 2455 .probe = wiimod_no_mp_probe, 2456 .remove = wiimod_no_mp_remove, 2457 }; 2458 2459 /* 2460 * Motion Plus 2461 * The Motion Plus extension provides rotation sensors (gyro) as a small 2462 * extension device for Wii Remotes. Many devices have them built-in so 2463 * you cannot see them from the outside. 2464 * Motion Plus extensions are special because they are on a separate extension 2465 * port and allow other extensions to be used simultaneously. This is all 2466 * handled by the Wiimote Core so we don't have to deal with it. 2467 */ 2468 2469 static void wiimod_mp_in_mp(struct wiimote_data *wdata, const __u8 *ext) 2470 { 2471 __s32 x, y, z; 2472 2473 /* | 8 7 6 5 4 3 | 2 | 1 | 2474 * -----+------------------------------+-----+-----+ 2475 * 1 | Yaw Speed <7:0> | 2476 * 2 | Roll Speed <7:0> | 2477 * 3 | Pitch Speed <7:0> | 2478 * -----+------------------------------+-----+-----+ 2479 * 4 | Yaw Speed <13:8> | Yaw |Pitch| 2480 * -----+------------------------------+-----+-----+ 2481 * 5 | Roll Speed <13:8> |Roll | Ext | 2482 * -----+------------------------------+-----+-----+ 2483 * 6 | Pitch Speed <13:8> | 1 | 0 | 2484 * -----+------------------------------+-----+-----+ 2485 * The single bits Yaw, Roll, Pitch in the lower right corner specify 2486 * whether the wiimote is rotating fast (0) or slow (1). Speed for slow 2487 * roation is 8192/440 units / deg/s and for fast rotation 8192/2000 2488 * units / deg/s. To get a linear scale for fast rotation we multiply 2489 * by 2000/440 = ~4.5454 and scale both fast and slow by 9 to match the 2490 * previous scale reported by this driver. 2491 * This leaves a linear scale with 8192*9/440 (~167.564) units / deg/s. 2492 * If the wiimote is not rotating the sensor reports 2^13 = 8192. 2493 * Ext specifies whether an extension is connected to the motionp. 2494 * which is parsed by wiimote-core. 2495 */ 2496 2497 x = ext[0]; 2498 y = ext[1]; 2499 z = ext[2]; 2500 2501 x |= (((__u16)ext[3]) << 6) & 0xff00; 2502 y |= (((__u16)ext[4]) << 6) & 0xff00; 2503 z |= (((__u16)ext[5]) << 6) & 0xff00; 2504 2505 x -= 8192; 2506 y -= 8192; 2507 z -= 8192; 2508 2509 if (!(ext[3] & 0x02)) 2510 x = (x * 2000 * 9) / 440; 2511 else 2512 x *= 9; 2513 if (!(ext[4] & 0x02)) 2514 y = (y * 2000 * 9) / 440; 2515 else 2516 y *= 9; 2517 if (!(ext[3] & 0x01)) 2518 z = (z * 2000 * 9) / 440; 2519 else 2520 z *= 9; 2521 2522 input_report_abs(wdata->mp, ABS_RX, x); 2523 input_report_abs(wdata->mp, ABS_RY, y); 2524 input_report_abs(wdata->mp, ABS_RZ, z); 2525 input_sync(wdata->mp); 2526 } 2527 2528 static int wiimod_mp_open(struct input_dev *dev) 2529 { 2530 struct wiimote_data *wdata = input_get_drvdata(dev); 2531 unsigned long flags; 2532 2533 spin_lock_irqsave(&wdata->state.lock, flags); 2534 wdata->state.flags |= WIIPROTO_FLAG_MP_USED; 2535 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2536 __wiimote_schedule(wdata); 2537 spin_unlock_irqrestore(&wdata->state.lock, flags); 2538 2539 return 0; 2540 } 2541 2542 static void wiimod_mp_close(struct input_dev *dev) 2543 { 2544 struct wiimote_data *wdata = input_get_drvdata(dev); 2545 unsigned long flags; 2546 2547 spin_lock_irqsave(&wdata->state.lock, flags); 2548 wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED; 2549 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL); 2550 __wiimote_schedule(wdata); 2551 spin_unlock_irqrestore(&wdata->state.lock, flags); 2552 } 2553 2554 static int wiimod_mp_probe(const struct wiimod_ops *ops, 2555 struct wiimote_data *wdata) 2556 { 2557 int ret; 2558 2559 wdata->mp = input_allocate_device(); 2560 if (!wdata->mp) 2561 return -ENOMEM; 2562 2563 input_set_drvdata(wdata->mp, wdata); 2564 wdata->mp->open = wiimod_mp_open; 2565 wdata->mp->close = wiimod_mp_close; 2566 wdata->mp->dev.parent = &wdata->hdev->dev; 2567 wdata->mp->id.bustype = wdata->hdev->bus; 2568 wdata->mp->id.vendor = wdata->hdev->vendor; 2569 wdata->mp->id.product = wdata->hdev->product; 2570 wdata->mp->id.version = wdata->hdev->version; 2571 wdata->mp->name = WIIMOTE_NAME " Motion Plus"; 2572 2573 set_bit(EV_ABS, wdata->mp->evbit); 2574 set_bit(ABS_RX, wdata->mp->absbit); 2575 set_bit(ABS_RY, wdata->mp->absbit); 2576 set_bit(ABS_RZ, wdata->mp->absbit); 2577 input_set_abs_params(wdata->mp, 2578 ABS_RX, -16000, 16000, 4, 8); 2579 input_set_abs_params(wdata->mp, 2580 ABS_RY, -16000, 16000, 4, 8); 2581 input_set_abs_params(wdata->mp, 2582 ABS_RZ, -16000, 16000, 4, 8); 2583 2584 ret = input_register_device(wdata->mp); 2585 if (ret) 2586 goto err_free; 2587 2588 return 0; 2589 2590 err_free: 2591 input_free_device(wdata->mp); 2592 wdata->mp = NULL; 2593 return ret; 2594 } 2595 2596 static void wiimod_mp_remove(const struct wiimod_ops *ops, 2597 struct wiimote_data *wdata) 2598 { 2599 if (!wdata->mp) 2600 return; 2601 2602 input_unregister_device(wdata->mp); 2603 wdata->mp = NULL; 2604 } 2605 2606 const struct wiimod_ops wiimod_mp = { 2607 .flags = 0, 2608 .arg = 0, 2609 .probe = wiimod_mp_probe, 2610 .remove = wiimod_mp_remove, 2611 .in_mp = wiimod_mp_in_mp, 2612 }; 2613 2614 /* module table */ 2615 2616 static const struct wiimod_ops wiimod_dummy; 2617 2618 const struct wiimod_ops *wiimod_table[WIIMOD_NUM] = { 2619 [WIIMOD_KEYS] = &wiimod_keys, 2620 [WIIMOD_RUMBLE] = &wiimod_rumble, 2621 [WIIMOD_BATTERY] = &wiimod_battery, 2622 [WIIMOD_LED1] = &wiimod_leds[0], 2623 [WIIMOD_LED2] = &wiimod_leds[1], 2624 [WIIMOD_LED3] = &wiimod_leds[2], 2625 [WIIMOD_LED4] = &wiimod_leds[3], 2626 [WIIMOD_ACCEL] = &wiimod_accel, 2627 [WIIMOD_IR] = &wiimod_ir, 2628 [WIIMOD_BUILTIN_MP] = &wiimod_builtin_mp, 2629 [WIIMOD_NO_MP] = &wiimod_no_mp, 2630 }; 2631 2632 const struct wiimod_ops *wiimod_ext_table[WIIMOTE_EXT_NUM] = { 2633 [WIIMOTE_EXT_NONE] = &wiimod_dummy, 2634 [WIIMOTE_EXT_UNKNOWN] = &wiimod_dummy, 2635 [WIIMOTE_EXT_NUNCHUK] = &wiimod_nunchuk, 2636 [WIIMOTE_EXT_CLASSIC_CONTROLLER] = &wiimod_classic, 2637 [WIIMOTE_EXT_BALANCE_BOARD] = &wiimod_bboard, 2638 [WIIMOTE_EXT_PRO_CONTROLLER] = &wiimod_pro, 2639 [WIIMOTE_EXT_DRUMS] = &wiimod_drums, 2640 [WIIMOTE_EXT_GUITAR] = &wiimod_guitar, 2641 }; 2642