2886 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Device Modules for Nintendo Wii / Wii U HID Driver4 * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>5 */6 7/*8 */9 10/*11 * Wiimote Modules12 * Nintendo devices provide different peripherals and many new devices lack13 * initial features like the IR camera. Therefore, each peripheral device is14 * implemented as an independent module and we probe on each device only the15 * 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 trigger19 * re-detection which causes all modules to be unloaded and then reload the20 * modules for the new detected device.21 *22 * wdata->input is a shared input device. It is always initialized prior to23 * module registration. If at least one registered module is marked as24 * WIIMOD_FLAG_INPUT, then the input device will get registered after all25 * modules were registered.26 * Please note that it is unregistered _before_ the "remove" callbacks are27 * 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 only29 * after all modules were removed. It is safe to send events to unregistered30 * 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 * Keys41 * The initial Wii Remote provided a bunch of buttons that are reported as42 * part of the core protocol. Many later devices dropped these and report43 * invalid data in the core button reports. Load this only on devices which44 * correctly send button reports.45 * It uses the shared input device.46 */47 48static 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 62static 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 89static 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 101static 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 * Rumble111 * Nearly all devices provide a rumble feature. A small motor for112 * force-feedback effects. We provide an FF_RUMBLE memless ff device on the113 * shared input device if this module is loaded.114 * The rumble motor is controlled via a flag on almost every output report so115 * the wiimote core handles the rumble flag. But if a device doesn't provide116 * the rumble motor, this flag shouldn't be set.117 */118 119/* used by wiimod_rumble and wiipro_rumble */120static 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 130static 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 magnitude138 * is set to non-zero then we start the rumble motor. If both are set to139 * zero, we stop the rumble motor.140 */141 142 if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)143 value = 1;144 else145 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 155static 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 167static 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 179static 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 * Battery188 * 1 byte of battery capacity information is sent along every protocol status189 * report. The wiimote core caches it but we try to update it on every190 * user-space request.191 * This is supported by nearly every device so it's almost always enabled.192 */193 194static enum power_supply_property wiimod_battery_props[] = {195 POWER_SUPPLY_PROP_CAPACITY,196 POWER_SUPPLY_PROP_SCOPE,197};198 199static 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 234static 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 262err_free:263 kfree(wdata->battery_desc.name);264 wdata->battery_desc.name = NULL;265 return ret;266}267 268static 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 279static 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 * LED288 * 0 to 4 player LEDs are supported by devices. The "arg" field of the289 * wiimod_ops structure specifies which LED this module controls. This allows290 * to register a limited number of LEDs.291 * State is managed by wiimote core.292 */293 294static 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 314static 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 else331 wiiproto_req_leds(wdata, state | flag);332 spin_unlock_irqrestore(&wdata->state.lock, flags);333 break;334 }335 }336}337 338static 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 374err_free:375 wdata->leds[ops->arg] = NULL;376 kfree(led);377 return ret;378}379 380static 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 391static 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 * Accelerometer420 * 3 axis accelerometer data is part of nearly all DRMs. If not supported by a421 * device, it's mostly cleared to 0. This module parses this data and provides422 * it via a separate input device.423 */424 425static 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 ZZ435 * Accelerometer data is encoded into 3 10bit values. XX, YY and ZZ436 * contain the upper 8 bits of each value. The lower 2 bits are437 * contained in the buttons data BB BB.438 * Bits 6 and 7 of the first buttons byte BB is the lower 2 bits of the439 * X accel value. Bit 5 of the second buttons byte is the 2nd bit of Y440 * 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 459static 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 471static 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 481static 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 516err_free:517 input_free_device(wdata->accel);518 wdata->accel = NULL;519 return ret;520}521 522static 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 532static 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 Cam542 * Up to 4 IR sources can be tracked by a normal Wii Remote. The IR cam needs543 * to be initialized with a fairly complex procedure and consumes a lot of544 * power. Therefore, as long as no application uses the IR input device, it is545 * kept offline.546 * Nearly no other device than the normal Wii Remotes supports the IR cam so547 * you can disable this module for these devices.548 */549 550static 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 the584 * lower 8 bit of the X/Y data, the 3rd byte contains the upper 2 bits585 * of both.586 * If data is packed, then the 3rd byte is put first and slightly587 * reordered. This allows to interleave packed and non-packed data to588 * 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 607static 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 714unlock:715 wiimote_cmd_release(wdata);716 return ret;717}718 719static 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 726static 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 733static 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 778err_free:779 input_free_device(wdata->ir);780 wdata->ir = NULL;781 return ret;782}783 784static 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 794static 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 Extension804 * The Nintendo Wii Nunchuk was the first official extension published by805 * Nintendo. It provides two additional keys and a separate accelerometer. It806 * can be hotplugged to standard Wii Remotes.807 */808 809enum wiimod_nunchuk_keys {810 WIIMOD_NUNCHUK_KEY_C,811 WIIMOD_NUNCHUK_KEY_Z,812 WIIMOD_NUNCHUK_KEY_NUM,813};814 815static const __u16 wiimod_nunchuk_map[] = {816 BTN_C, /* WIIMOD_NUNCHUK_KEY_C */817 BTN_Z, /* WIIMOD_NUNCHUK_KEY_Z */818};819 820static 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 the836 * 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 pressed839 *840 * If reported interleaved with motionp, then the layout changes. The841 * 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 is848 * still available but slightly moved.849 *850 * Center data for button values is 128. Center value for accelerometer851 * values it 512 / 0x200852 */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 904static 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 917static 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 928static 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 975err_free:976 input_free_device(wdata->extension.input);977 wdata->extension.input = NULL;978 return ret;979}980 981static 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 991static 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 Controller1001 * Another official extension from Nintendo. It provides a classic1002 * gamecube-like controller that can be hotplugged on the Wii Remote.1003 * It has several hardware buttons and switches that are all reported via1004 * a normal extension device.1005 */1006 1007enum 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 1026static 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 1044static 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 pressed1062 * RX and RY are right analog stick1063 * LX and LY are left analog stick1064 * LT is left trigger, RT is right trigger1065 * BLT is 0 if left trigger is fully pressed1066 * BRT is 0 if right trigger is fully pressed1067 * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons1068 * BZL is left Z button and BZR is right Z button1069 * B-, BH, B+ are +, HOME and - buttons1070 * BB, BY, BA, BX are A, B, X, Y buttons1071 * 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 rest1088 * 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 1198static 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 1211static 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 1222static 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 1272err_free:1273 input_free_device(wdata->extension.input);1274 wdata->extension.input = NULL;1275 return ret;1276}1277 1278static 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 1288static 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 Extension1298 * The Nintendo Wii Balance Board provides four hardware weight sensor plus a1299 * single push button. No other peripherals are available. However, the1300 * balance-board data is sent via a standard Wii Remote extension. All other1301 * data for non-present hardware is zeroed out.1302 * Some 3rd party devices react allergic if we try to access normal Wii Remote1303 * hardware, so this extension module should be the only module that is loaded1304 * on balance boards.1305 * The balance board needs 8 bytes extension data instead of basic 6 bytes so1306 * it needs the WIIMOD_FLAG_EXT8 flag.1307 */1308 1309static 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 1316static 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-balance1342 * 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 1389static 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 1402static 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 1413static 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 else1458 ret += sprintf(&out[ret], "%04x:", val);1459 }1460 }1461 1462 return ret;1463}1464 1465static DEVICE_ATTR(bboard_calib, S_IRUGO, wiimod_bboard_calib_show, NULL);1466 1467static 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 1542err_file:1543 device_remove_file(&wdata->hdev->dev,1544 &dev_attr_bboard_calib);1545err_free:1546 input_free_device(wdata->extension.input);1547 wdata->extension.input = NULL;1548 return ret;1549}1550 1551static 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 1563static 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 Controller1574 * Released with the Wii U was the Nintendo Wii U Pro Controller. It does not1575 * work together with the classic Wii, but only with the new Wii U. However, it1576 * 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't1579 * feature an extension port.1580 */1581 1582enum 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 1603static 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 1623static 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 stick1653 * LX and LY are left analog stick1654 * BLT is left trigger, BRT is right trigger.1655 * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons1656 * BZL is left Z button and BZR is right Z button1657 * B-, BH, B+ are +, HOME and - buttons1658 * BB, BY, BA, BX are A, B, X, Y buttons1659 *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 charging1664 * USB: 1 if not connected, 0 if connected1665 * 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 data1680 * in the EEPROM so we must use the first report to calibrate the1681 * null-position of the analog sticks. Users can retrigger calibration1682 * 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 1764static 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 1777static 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 1788static 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 magnitude1796 * is set to non-zero then we start the rumble motor. If both are set to1797 * zero, we stop the rumble motor.1798 */1799 1800 if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)1801 value = 1;1802 else1803 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 1813static 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 1829static 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 1859static DEVICE_ATTR(pro_calib, S_IRUGO|S_IWUSR|S_IWGRP, wiimod_pro_calib_show,1860 wiimod_pro_calib_store);1861 1862static 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 1932err_file:1933 device_remove_file(&wdata->hdev->dev,1934 &dev_attr_pro_calib);1935err_free:1936 input_free_device(wdata->extension.input);1937 wdata->extension.input = NULL;1938 return ret;1939}1940 1941static 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 1960static 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 * Drums1970 * Guitar-Hero, Rock-Band and other games came bundled with drums which can1971 * be plugged as extension to a Wiimote. Drum-reports are still not entirely1972 * figured out, but the most important information is known.1973 * We create a separate device for drums and report all information via this1974 * input device.1975 */1976 1977static 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 1994static 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 pressed2013 *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 2084static 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 2097static 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 2108static 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 2166err_free:2167 input_free_device(wdata->extension.input);2168 wdata->extension.input = NULL;2169 return ret;2170}2171 2172static 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 2182static 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 * Guitar2192 * Guitar-Hero, Rock-Band and other games came bundled with guitars which can2193 * be plugged as extension to a Wiimote.2194 * We create a separate device for guitars and report all information via this2195 * input device.2196 */2197 2198enum 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 2211static 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 2223static 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 pressed2241 *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 2314static 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 2327static 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 2338static 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 2382err_free:2383 input_free_device(wdata->extension.input);2384 wdata->extension.input = NULL;2385 return ret;2386}2387 2388static 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 2398static 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 * Turntable2408 * DJ Hero came with a Turntable Controller that was plugged in2409 * as an extension.2410 * We create a separate device for turntables and report all information via this2411 * input device.2412*/2413 2414enum wiimod_turntable_keys {2415 WIIMOD_TURNTABLE_KEY_G_RIGHT,2416 WIIMOD_TURNTABLE_KEY_R_RIGHT,2417 WIIMOD_TURNTABLE_KEY_B_RIGHT,2418 WIIMOD_TURNTABLE_KEY_G_LEFT,2419 WIIMOD_TURNTABLE_KEY_R_LEFT,2420 WIIMOD_TURNTABLE_KEY_B_LEFT,2421 WIIMOD_TURNTABLE_KEY_EUPHORIA,2422 WIIMOD_TURNTABLE_KEY_PLUS,2423 WIIMOD_TURNTABLE_KEY_MINUS,2424 WIIMOD_TURNTABLE_KEY_NUM2425};2426 2427static const __u16 wiimod_turntable_map[] = {2428 BTN_1, /* WIIMOD_TURNTABLE_KEY_G_RIGHT */2429 BTN_2, /* WIIMOD_TURNTABLE_KEY_R_RIGHT */2430 BTN_3, /* WIIMOD_TURNTABLE_KEY_B_RIGHT */2431 BTN_4, /* WIIMOD_TURNTABLE_KEY_G_LEFT */2432 BTN_5, /* WIIMOD_TURNTABLE_KEY_R_LEFT */2433 BTN_6, /* WIIMOD_TURNTABLE_KEY_B_LEFT */2434 BTN_7, /* WIIMOD_TURNTABLE_KEY_EUPHORIA */2435 BTN_START, /* WIIMOD_TURNTABLE_KEY_PLUS */2436 BTN_SELECT, /* WIIMOD_TURNTABLE_KEY_MINUS */2437};2438 2439static void wiimod_turntable_in_ext(struct wiimote_data *wdata, const __u8 *ext)2440{2441 __u8 be, cs, sx, sy, ed, rtt, rbg, rbr, rbb, ltt, lbg, lbr, lbb, bp, bm;2442 /* 2443 * Byte | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |2444 *------+------+-----+-----+-----+-----+------+------+--------+2445 * 0 | RTT<4:3> | SX <5:0> |2446 * 1 | RTT<2:1> | SY <5:0> |2447 *------+------+-----+-----+-----+-----+------+------+--------+2448 * 2 |RTT<0>| ED<4:3> | CS<3:0> | RTT<5> |2449 *------+------+-----+-----+-----+-----+------+------+--------+2450 * 3 | ED<2:0> | LTT<4:0> |2451 *------+------+-----+-----+-----+-----+------+------+--------+2452 * 4 | 0 | 0 | LBR | B- | 0 | B+ | RBR | LTT<5> |2453 *------+------+-----+-----+-----+-----+------+------+--------+2454 * 5 | LBB | 0 | RBG | BE | LBG | RBB | 0 | 0 |2455 *------+------+-----+-----+-----+-----+------+------+--------+2456 * All pressed buttons are 02457 *2458 * With Motion+ enabled, it will look like this:2459 * Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 |2460 *------+------+-----+-----+-----+-----+------+------+--------+2461 * 1 | RTT<4:3> | SX <5:1> | 0 |2462 * 2 | RTT<2:1> | SY <5:1> | 0 |2463 *------+------+-----+-----+-----+-----+------+------+--------+2464 * 3 |RTT<0>| ED<4:3> | CS<3:0> | RTT<5> |2465 *------+------+-----+-----+-----+-----+------+------+--------+2466 * 4 | ED<2:0> | LTT<4:0> |2467 *------+------+-----+-----+-----+-----+------+------+--------+2468 * 5 | 0 | 0 | LBR | B- | 0 | B+ | RBR | XXXX |2469 *------+------+-----+-----+-----+-----+------+------+--------+2470 * 6 | LBB | 0 | RBG | BE | LBG | RBB | XXXX | XXXX |2471 *------+------+-----+-----+-----+-----+------+------+--------+2472 */2473 2474 be = !(ext[5] & 0x10); 2475 cs = ((ext[2] & 0x1e));2476 sx = ext[0] & 0x3f;2477 sy = ext[1] & 0x3f;2478 ed = (ext[3] & 0xe0) >> 5;2479 rtt = ((ext[2] & 0x01) << 5 | (ext[0] & 0xc0) >> 3 | (ext[1] & 0xc0) >> 5 | ( ext[2] & 0x80 ) >> 7);2480 ltt = ((ext[4] & 0x01) << 5 | (ext[3] & 0x1f));2481 rbg = !(ext[5] & 0x20);2482 rbr = !(ext[4] & 0x02);2483 rbb = !(ext[5] & 0x04);2484 lbg = !(ext[5] & 0x08);2485 lbb = !(ext[5] & 0x80);2486 lbr = !(ext[4] & 0x20);2487 bm = !(ext[4] & 0x10);2488 bp = !(ext[4] & 0x04);2489 2490 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {2491 ltt = (ext[4] & 0x01) << 5;2492 sx &= 0x3e;2493 sy &= 0x3e;2494 }2495 2496 input_report_abs(wdata->extension.input, ABS_X, sx);2497 input_report_abs(wdata->extension.input, ABS_Y, sy);2498 input_report_abs(wdata->extension.input, ABS_HAT0X, rtt);2499 input_report_abs(wdata->extension.input, ABS_HAT1X, ltt);2500 input_report_abs(wdata->extension.input, ABS_HAT2X, cs);2501 input_report_abs(wdata->extension.input, ABS_HAT3X, ed);2502 input_report_key(wdata->extension.input, 2503 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_G_RIGHT], 2504 rbg);2505 input_report_key(wdata->extension.input,2506 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_R_RIGHT],2507 rbr);2508 input_report_key(wdata->extension.input, 2509 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_B_RIGHT], 2510 rbb);2511 input_report_key(wdata->extension.input, 2512 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_G_LEFT], 2513 lbg);2514 input_report_key(wdata->extension.input, 2515 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_R_LEFT], 2516 lbr);2517 input_report_key(wdata->extension.input, 2518 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_B_LEFT], 2519 lbb);2520 input_report_key(wdata->extension.input, 2521 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_EUPHORIA], 2522 be);2523 input_report_key(wdata->extension.input, 2524 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_PLUS], 2525 bp);2526 input_report_key(wdata->extension.input, 2527 wiimod_turntable_map[WIIMOD_TURNTABLE_KEY_MINUS], 2528 bm);2529 2530 input_sync(wdata->extension.input);2531}2532 2533static int wiimod_turntable_open(struct input_dev *dev)2534{2535 struct wiimote_data *wdata = input_get_drvdata(dev);2536 unsigned long flags;2537 2538 spin_lock_irqsave(&wdata->state.lock, flags);2539 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;2540 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);2541 spin_unlock_irqrestore(&wdata->state.lock, flags);2542 2543 return 0;2544}2545 2546static void wiimod_turntable_close(struct input_dev *dev)2547{2548 struct wiimote_data *wdata = input_get_drvdata(dev);2549 unsigned long flags;2550 2551 spin_lock_irqsave(&wdata->state.lock, flags);2552 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;2553 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);2554 spin_unlock_irqrestore(&wdata->state.lock, flags);2555}2556 2557static int wiimod_turntable_probe(const struct wiimod_ops *ops,2558 struct wiimote_data *wdata)2559{2560 int ret, i;2561 2562 wdata->extension.input = input_allocate_device();2563 if (!wdata->extension.input)2564 return -ENOMEM;2565 2566 input_set_drvdata(wdata->extension.input, wdata);2567 wdata->extension.input->open = wiimod_turntable_open;2568 wdata->extension.input->close = wiimod_turntable_close;2569 wdata->extension.input->dev.parent = &wdata->hdev->dev;2570 wdata->extension.input->id.bustype = wdata->hdev->bus;2571 wdata->extension.input->id.vendor = wdata->hdev->vendor;2572 wdata->extension.input->id.product = wdata->hdev->product;2573 wdata->extension.input->id.version = wdata->hdev->version;2574 wdata->extension.input->name = WIIMOTE_NAME " Turntable";2575 2576 set_bit(EV_KEY, wdata->extension.input->evbit);2577 for (i = 0; i < WIIMOD_TURNTABLE_KEY_NUM; ++i)2578 set_bit(wiimod_turntable_map[i],2579 wdata->extension.input->keybit);2580 2581 set_bit(EV_ABS, wdata->extension.input->evbit);2582 set_bit(ABS_X, wdata->extension.input->absbit);2583 set_bit(ABS_Y, wdata->extension.input->absbit);2584 set_bit(ABS_HAT0X, wdata->extension.input->absbit);2585 set_bit(ABS_HAT1X, wdata->extension.input->absbit);2586 set_bit(ABS_HAT2X, wdata->extension.input->absbit);2587 set_bit(ABS_HAT3X, wdata->extension.input->absbit);2588 input_set_abs_params(wdata->extension.input,2589 ABS_X, 0, 63, 1, 0);2590 input_set_abs_params(wdata->extension.input,2591 ABS_Y, 63, 0, 1, 0);2592 input_set_abs_params(wdata->extension.input,2593 ABS_HAT0X, -8, 8, 0, 0);2594 input_set_abs_params(wdata->extension.input,2595 ABS_HAT1X, -8, 8, 0, 0);2596 input_set_abs_params(wdata->extension.input,2597 ABS_HAT2X, 0, 31, 1, 1); 2598 input_set_abs_params(wdata->extension.input,2599 ABS_HAT3X, 0, 7, 0, 0); 2600 ret = input_register_device(wdata->extension.input);2601 if (ret)2602 goto err_free;2603 2604 return 0;2605 2606err_free:2607 input_free_device(wdata->extension.input);2608 wdata->extension.input = NULL;2609 return ret;2610}2611 2612static void wiimod_turntable_remove(const struct wiimod_ops *ops,2613 struct wiimote_data *wdata)2614{2615 if (!wdata->extension.input)2616 return;2617 2618 input_unregister_device(wdata->extension.input);2619 wdata->extension.input = NULL;2620}2621 2622static const struct wiimod_ops wiimod_turntable = {2623 .flags = 0,2624 .arg = 0,2625 .probe = wiimod_turntable_probe,2626 .remove = wiimod_turntable_remove,2627 .in_ext = wiimod_turntable_in_ext,2628};2629 2630/*2631 * Builtin Motion Plus2632 * This module simply sets the WIIPROTO_FLAG_BUILTIN_MP protocol flag which2633 * disables polling for Motion-Plus. This should be set only for devices which2634 * don't allow MP hotplugging.2635 */2636 2637static int wiimod_builtin_mp_probe(const struct wiimod_ops *ops,2638 struct wiimote_data *wdata)2639{2640 unsigned long flags;2641 2642 spin_lock_irqsave(&wdata->state.lock, flags);2643 wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP;2644 spin_unlock_irqrestore(&wdata->state.lock, flags);2645 2646 return 0;2647}2648 2649static void wiimod_builtin_mp_remove(const struct wiimod_ops *ops,2650 struct wiimote_data *wdata)2651{2652 unsigned long flags;2653 2654 spin_lock_irqsave(&wdata->state.lock, flags);2655 wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP;2656 spin_unlock_irqrestore(&wdata->state.lock, flags);2657}2658 2659static const struct wiimod_ops wiimod_builtin_mp = {2660 .flags = 0,2661 .arg = 0,2662 .probe = wiimod_builtin_mp_probe,2663 .remove = wiimod_builtin_mp_remove,2664};2665 2666/*2667 * No Motion Plus2668 * This module simply sets the WIIPROTO_FLAG_NO_MP protocol flag which2669 * disables motion-plus. This is needed for devices that advertise this but we2670 * don't know how to use it (or whether it is actually present).2671 */2672 2673static int wiimod_no_mp_probe(const struct wiimod_ops *ops,2674 struct wiimote_data *wdata)2675{2676 unsigned long flags;2677 2678 spin_lock_irqsave(&wdata->state.lock, flags);2679 wdata->state.flags |= WIIPROTO_FLAG_NO_MP;2680 spin_unlock_irqrestore(&wdata->state.lock, flags);2681 2682 return 0;2683}2684 2685static void wiimod_no_mp_remove(const struct wiimod_ops *ops,2686 struct wiimote_data *wdata)2687{2688 unsigned long flags;2689 2690 spin_lock_irqsave(&wdata->state.lock, flags);2691 wdata->state.flags |= WIIPROTO_FLAG_NO_MP;2692 spin_unlock_irqrestore(&wdata->state.lock, flags);2693}2694 2695static const struct wiimod_ops wiimod_no_mp = {2696 .flags = 0,2697 .arg = 0,2698 .probe = wiimod_no_mp_probe,2699 .remove = wiimod_no_mp_remove,2700};2701 2702/*2703 * Motion Plus2704 * The Motion Plus extension provides rotation sensors (gyro) as a small2705 * extension device for Wii Remotes. Many devices have them built-in so2706 * you cannot see them from the outside.2707 * Motion Plus extensions are special because they are on a separate extension2708 * port and allow other extensions to be used simultaneously. This is all2709 * handled by the Wiimote Core so we don't have to deal with it.2710 */2711 2712static void wiimod_mp_in_mp(struct wiimote_data *wdata, const __u8 *ext)2713{2714 __s32 x, y, z;2715 2716 /* | 8 7 6 5 4 3 | 2 | 1 |2717 * -----+------------------------------+-----+-----+2718 * 1 | Yaw Speed <7:0> |2719 * 2 | Roll Speed <7:0> |2720 * 3 | Pitch Speed <7:0> |2721 * -----+------------------------------+-----+-----+2722 * 4 | Yaw Speed <13:8> | Yaw |Pitch|2723 * -----+------------------------------+-----+-----+2724 * 5 | Roll Speed <13:8> |Roll | Ext |2725 * -----+------------------------------+-----+-----+2726 * 6 | Pitch Speed <13:8> | 1 | 0 |2727 * -----+------------------------------+-----+-----+2728 * The single bits Yaw, Roll, Pitch in the lower right corner specify2729 * whether the wiimote is rotating fast (0) or slow (1). Speed for slow2730 * roation is 8192/440 units / deg/s and for fast rotation 8192/20002731 * units / deg/s. To get a linear scale for fast rotation we multiply2732 * by 2000/440 = ~4.5454 and scale both fast and slow by 9 to match the2733 * previous scale reported by this driver.2734 * This leaves a linear scale with 8192*9/440 (~167.564) units / deg/s.2735 * If the wiimote is not rotating the sensor reports 2^13 = 8192.2736 * Ext specifies whether an extension is connected to the motionp.2737 * which is parsed by wiimote-core.2738 */2739 2740 x = ext[0];2741 y = ext[1];2742 z = ext[2];2743 2744 x |= (((__u16)ext[3]) << 6) & 0xff00;2745 y |= (((__u16)ext[4]) << 6) & 0xff00;2746 z |= (((__u16)ext[5]) << 6) & 0xff00;2747 2748 x -= 8192;2749 y -= 8192;2750 z -= 8192;2751 2752 if (!(ext[3] & 0x02))2753 x = (x * 2000 * 9) / 440;2754 else2755 x *= 9;2756 if (!(ext[4] & 0x02))2757 y = (y * 2000 * 9) / 440;2758 else2759 y *= 9;2760 if (!(ext[3] & 0x01))2761 z = (z * 2000 * 9) / 440;2762 else2763 z *= 9;2764 2765 input_report_abs(wdata->mp, ABS_RX, x);2766 input_report_abs(wdata->mp, ABS_RY, y);2767 input_report_abs(wdata->mp, ABS_RZ, z);2768 input_sync(wdata->mp);2769}2770 2771static int wiimod_mp_open(struct input_dev *dev)2772{2773 struct wiimote_data *wdata = input_get_drvdata(dev);2774 unsigned long flags;2775 2776 spin_lock_irqsave(&wdata->state.lock, flags);2777 wdata->state.flags |= WIIPROTO_FLAG_MP_USED;2778 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);2779 __wiimote_schedule(wdata);2780 spin_unlock_irqrestore(&wdata->state.lock, flags);2781 2782 return 0;2783}2784 2785static void wiimod_mp_close(struct input_dev *dev)2786{2787 struct wiimote_data *wdata = input_get_drvdata(dev);2788 unsigned long flags;2789 2790 spin_lock_irqsave(&wdata->state.lock, flags);2791 wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED;2792 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);2793 __wiimote_schedule(wdata);2794 spin_unlock_irqrestore(&wdata->state.lock, flags);2795}2796 2797static int wiimod_mp_probe(const struct wiimod_ops *ops,2798 struct wiimote_data *wdata)2799{2800 int ret;2801 2802 wdata->mp = input_allocate_device();2803 if (!wdata->mp)2804 return -ENOMEM;2805 2806 input_set_drvdata(wdata->mp, wdata);2807 wdata->mp->open = wiimod_mp_open;2808 wdata->mp->close = wiimod_mp_close;2809 wdata->mp->dev.parent = &wdata->hdev->dev;2810 wdata->mp->id.bustype = wdata->hdev->bus;2811 wdata->mp->id.vendor = wdata->hdev->vendor;2812 wdata->mp->id.product = wdata->hdev->product;2813 wdata->mp->id.version = wdata->hdev->version;2814 wdata->mp->name = WIIMOTE_NAME " Motion Plus";2815 2816 set_bit(EV_ABS, wdata->mp->evbit);2817 set_bit(ABS_RX, wdata->mp->absbit);2818 set_bit(ABS_RY, wdata->mp->absbit);2819 set_bit(ABS_RZ, wdata->mp->absbit);2820 input_set_abs_params(wdata->mp,2821 ABS_RX, -16000, 16000, 4, 8);2822 input_set_abs_params(wdata->mp,2823 ABS_RY, -16000, 16000, 4, 8);2824 input_set_abs_params(wdata->mp,2825 ABS_RZ, -16000, 16000, 4, 8);2826 2827 ret = input_register_device(wdata->mp);2828 if (ret)2829 goto err_free;2830 2831 return 0;2832 2833err_free:2834 input_free_device(wdata->mp);2835 wdata->mp = NULL;2836 return ret;2837}2838 2839static void wiimod_mp_remove(const struct wiimod_ops *ops,2840 struct wiimote_data *wdata)2841{2842 if (!wdata->mp)2843 return;2844 2845 input_unregister_device(wdata->mp);2846 wdata->mp = NULL;2847}2848 2849const struct wiimod_ops wiimod_mp = {2850 .flags = 0,2851 .arg = 0,2852 .probe = wiimod_mp_probe,2853 .remove = wiimod_mp_remove,2854 .in_mp = wiimod_mp_in_mp,2855};2856 2857/* module table */2858 2859static const struct wiimod_ops wiimod_dummy;2860 2861const struct wiimod_ops *wiimod_table[WIIMOD_NUM] = {2862 [WIIMOD_KEYS] = &wiimod_keys,2863 [WIIMOD_RUMBLE] = &wiimod_rumble,2864 [WIIMOD_BATTERY] = &wiimod_battery,2865 [WIIMOD_LED1] = &wiimod_leds[0],2866 [WIIMOD_LED2] = &wiimod_leds[1],2867 [WIIMOD_LED3] = &wiimod_leds[2],2868 [WIIMOD_LED4] = &wiimod_leds[3],2869 [WIIMOD_ACCEL] = &wiimod_accel,2870 [WIIMOD_IR] = &wiimod_ir,2871 [WIIMOD_BUILTIN_MP] = &wiimod_builtin_mp,2872 [WIIMOD_NO_MP] = &wiimod_no_mp,2873};2874 2875const struct wiimod_ops *wiimod_ext_table[WIIMOTE_EXT_NUM] = {2876 [WIIMOTE_EXT_NONE] = &wiimod_dummy,2877 [WIIMOTE_EXT_UNKNOWN] = &wiimod_dummy,2878 [WIIMOTE_EXT_NUNCHUK] = &wiimod_nunchuk,2879 [WIIMOTE_EXT_CLASSIC_CONTROLLER] = &wiimod_classic,2880 [WIIMOTE_EXT_BALANCE_BOARD] = &wiimod_bboard,2881 [WIIMOTE_EXT_PRO_CONTROLLER] = &wiimod_pro,2882 [WIIMOTE_EXT_DRUMS] = &wiimod_drums,2883 [WIIMOTE_EXT_GUITAR] = &wiimod_guitar,2884 [WIIMOTE_EXT_TURNTABLE] = &wiimod_turntable,2885};2886