21 files changed, 4540 insertions, 1714 deletions

diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index fb52f3f6de80..14ef6ab69790 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -217,6 +217,13 @@ config HID_ELECOM
         ---help---
         Support for the ELECOM BM084 (bluetooth mouse).
 
+config HID_ELO
+        tristate "ELO USB 4000/4500 touchscreen"
+        depends on USB_HID
+        ---help---
+        Support for the ELO USB 4000/4500 touchscreens. Note that this is for
+        different devices than those handled by CONFIG_TOUCHSCREEN_USB_ELO.
+
 config HID_EZKEY
         tristate "Ezkey BTC 8193 keyboard" if EXPERT
         depends on HID
@@ -231,6 +238,9 @@ config HID_HOLTEK
         Support for Holtek based devices:
           - Holtek On Line Grip based game controller
           - Trust GXT 18 Gaming Keyboard
+          - Sharkoon Drakonia / Perixx MX-2000 gaming mice
+          - Tracer Sniper TRM-503 / NOVA Gaming Slider X200 /
+            Zalman ZM-GM1
 
 config HOLTEK_FF
         bool "Holtek On Line Grip force feedback support"
@@ -240,6 +250,12 @@ config HOLTEK_FF
           Say Y here if you have a Holtek On Line Grip based game controller
           and want to have force feedback support for it.
 
+config HID_HUION
+        tristate "Huion tablets"
+        depends on USB_HID
+        ---help---
+        Support for Huion 580 tablet.
+
 config HID_KEYTOUCH
         tristate "Keytouch HID devices"
         depends on HID
@@ -561,15 +577,6 @@ config HID_PRIMAX
         Support for Primax devices that are not fully compliant with the
         HID standard.
 
-config HID_PS3REMOTE
-        tristate "Sony PS3 BD Remote Control"
-        depends on HID
-        ---help---
-        Support for the Sony PS3 Blue-ray Disk Remote Control and Logitech
-        Harmony Adapter for PS3, which connect over Bluetooth.
-
-        Support for the 6-axis controllers is provided by HID_SONY.
-
 config HID_ROCCAT
         tristate "Roccat device support"
         depends on USB_HID
@@ -594,12 +601,17 @@ config HID_SAMSUNG
         Support for Samsung InfraRed remote control or keyboards.
 
 config HID_SONY
-        tristate "Sony PS3 controller"
+        tristate "Sony PS2/3 accessories"
         depends on USB_HID
+        depends on NEW_LEDS
+        depends on LEDS_CLASS
         ---help---
-        Support for Sony PS3 6-axis controllers.
+        Support for
 
-        Support for the Sony PS3 BD Remote is provided by HID_PS3REMOTE.
+          * Sony PS3 6-axis controllers
+          * Buzz controllers
+          * Sony PS3 Blue-ray Disk Remote Control (Bluetooth)
+          * Logitech Harmony adapter for Sony Playstation 3 (Bluetooth)
 
 config HID_SPEEDLINK
         tristate "Speedlink VAD Cezanne mouse support"
@@ -707,22 +719,29 @@ config HID_WACOM
         Support for Wacom Graphire Bluetooth and Intuos4 WL tablets.
 
 config HID_WIIMOTE
-        tristate "Nintendo Wii Remote support"
+        tristate "Nintendo Wii / Wii U peripherals"
         depends on HID
         depends on LEDS_CLASS
         select POWER_SUPPLY
         select INPUT_FF_MEMLESS
         ---help---
-        Support for the Nintendo Wii Remote bluetooth device.
+        Support for Nintendo Wii and Wii U Bluetooth peripherals. Supported
+        devices are the Wii Remote and its extension devices, but also devices
+        based on the Wii Remote like the Wii U Pro Controller or the
+        Wii Balance Board.
 
-config HID_WIIMOTE_EXT
-        bool "Nintendo Wii Remote Extension support"
-        depends on HID_WIIMOTE
-        default HID_WIIMOTE
-        ---help---
-        Support for extension controllers of the Nintendo Wii Remote. Say yes
-        here if you want to use the Nintendo Motion+, Nunchuck or Classic
-        extension controllers with your Wii Remote.
+        Support for all official Nintendo extensions is available, however, 3rd
+        party extensions might not be supported. Please report these devices to:
+          http://github.com/dvdhrm/xwiimote/issues
+
+        Other Nintendo Wii U peripherals that are IEEE 802.11 based (including
+        the Wii U Gamepad) might be supported in the future. But currently
+        support is limited to Bluetooth based devices.
+
+        If unsure, say N.
+
+        To compile this driver as a module, choose M here: the
+        module will be called hid-wiimote.
 
 config HID_ZEROPLUS
         tristate "Zeroplus based game controller support"
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 2065694f57ab..6f687287e212 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -28,10 +28,7 @@ ifdef CONFIG_LOGIWHEELS_FF
         hid-logitech-y  += hid-lg4ff.o
 endif
 
-hid-wiimote-y           := hid-wiimote-core.o
-ifdef CONFIG_HID_WIIMOTE_EXT
-        hid-wiimote-y   += hid-wiimote-ext.o
-endif
+hid-wiimote-y           := hid-wiimote-core.o hid-wiimote-modules.o
 ifdef CONFIG_DEBUG_FS
         hid-wiimote-y   += hid-wiimote-debug.o
 endif
@@ -48,10 +45,13 @@ obj-$(CONFIG_HID_CYPRESS)	+= hid-cypress.o
 obj-$(CONFIG_HID_DRAGONRISE)    += hid-dr.o
 obj-$(CONFIG_HID_EMS_FF)        += hid-emsff.o
 obj-$(CONFIG_HID_ELECOM)        += hid-elecom.o
+obj-$(CONFIG_HID_ELO)           += hid-elo.o
 obj-$(CONFIG_HID_EZKEY)         += hid-ezkey.o
 obj-$(CONFIG_HID_GYRATION)      += hid-gyration.o
 obj-$(CONFIG_HID_HOLTEK)        += hid-holtek-kbd.o
+obj-$(CONFIG_HID_HOLTEK)        += hid-holtek-mouse.o
 obj-$(CONFIG_HID_HOLTEK)        += hid-holtekff.o
+obj-$(CONFIG_HID_HUION)         += hid-huion.o
 obj-$(CONFIG_HID_HYPERV_MOUSE)  += hid-hyperv.o
 obj-$(CONFIG_HID_ICADE)         += hid-icade.o
 obj-$(CONFIG_HID_KENSINGTON)    += hid-kensington.o
@@ -92,7 +92,6 @@ hid-picolcd-y			+= hid-picolcd_debugfs.o
 endif
 
 obj-$(CONFIG_HID_PRIMAX)        += hid-primax.o
-obj-$(CONFIG_HID_PS3REMOTE)     += hid-ps3remote.o
 obj-$(CONFIG_HID_ROCCAT)        += hid-roccat.o hid-roccat-common.o \
         hid-roccat-arvo.o hid-roccat-isku.o hid-roccat-kone.o \
         hid-roccat-koneplus.o hid-roccat-konepure.o hid-roccat-kovaplus.o \
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 264f55099940..e39dac68063c 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1293,7 +1293,7 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
 
         if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
                 ret = hdrv->raw_event(hid, report, data, size);
-                if (ret != 0) {
+                if (ret < 0) {
                         ret = ret < 0 ? ret : 0;
                         goto unlock;
                 }
@@ -1573,6 +1573,8 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },
         { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030) },
         { HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
         { HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
@@ -1584,10 +1586,14 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
         { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },
         { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_HUION, USB_DEVICE_ID_HUION_580) },
         { HID_USB_DEVICE(USB_VENDOR_ID_JESS2, USB_DEVICE_ID_JESS2_COLOR_RUMBLE_PAD) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_I405X) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },
@@ -1680,6 +1686,8 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER) },
@@ -2042,6 +2050,8 @@ static const struct hid_device_id hid_ignore_list[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1007) },
         { HID_USB_DEVICE(USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_SPEAK_410) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_SPEAK_510) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KWORLD, USB_DEVICE_ID_KWORLD_RADIO_FM700) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },
diff --git a/drivers/hid/hid-elo.c b/drivers/hid/hid-elo.c
new file mode 100644
index 000000000000..f042a6cf8b18
--- /dev/null
+++ b/drivers/hid/hid-elo.c
@@ -0,0 +1,273 @@
+/*
+ * HID driver for ELO usb touchscreen 4000/4500
+ *
+ * Copyright (c) 2013 Jiri Slaby
+ *
+ * Data parsing taken from elousb driver by Vojtech Pavlik.
+ *
+ * This driver is licensed under the terms of GPLv2.
+ */
+
+#include <linux/hid.h>
+#include <linux/input.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/workqueue.h>
+
+#include "hid-ids.h"
+
+#define ELO_PERIODIC_READ_INTERVAL      HZ
+#define ELO_SMARTSET_CMD_TIMEOUT        2000 /* msec */
+
+/* Elo SmartSet commands */
+#define ELO_FLUSH_SMARTSET_RESPONSES    0x02 /* Flush all pending smartset responses */
+#define ELO_SEND_SMARTSET_COMMAND       0x05 /* Send a smartset command */
+#define ELO_GET_SMARTSET_RESPONSE       0x06 /* Get a smartset response */
+#define ELO_DIAG                        0x64 /* Diagnostics command */
+#define ELO_SMARTSET_PACKET_SIZE        8
+
+struct elo_priv {
+        struct usb_device *usbdev;
+        struct delayed_work work;
+        unsigned char buffer[ELO_SMARTSET_PACKET_SIZE];
+};
+
+static struct workqueue_struct *wq;
+static bool use_fw_quirk = true;
+module_param(use_fw_quirk, bool, S_IRUGO);
+MODULE_PARM_DESC(use_fw_quirk, "Do periodic pokes for broken M firmwares (default = true)");
+
+static void elo_input_configured(struct hid_device *hdev,
+                struct hid_input *hidinput)
+{
+        struct input_dev *input = hidinput->input;
+
+        set_bit(BTN_TOUCH, input->keybit);
+        set_bit(ABS_PRESSURE, input->absbit);
+        input_set_abs_params(input, ABS_PRESSURE, 0, 256, 0, 0);
+}
+
+static void elo_process_data(struct input_dev *input, const u8 *data, int size)
+{
+        int press;
+
+        input_report_abs(input, ABS_X, (data[3] << 8) | data[2]);
+        input_report_abs(input, ABS_Y, (data[5] << 8) | data[4]);
+
+        press = 0;
+        if (data[1] & 0x80)
+                press = (data[7] << 8) | data[6];
+        input_report_abs(input, ABS_PRESSURE, press);
+
+        if (data[1] & 0x03) {
+                input_report_key(input, BTN_TOUCH, 1);
+                input_sync(input);
+        }
+
+        if (data[1] & 0x04)
+                input_report_key(input, BTN_TOUCH, 0);
+
+        input_sync(input);
+}
+
+static int elo_raw_event(struct hid_device *hdev, struct hid_report *report,
+         u8 *data, int size)
+{
+        struct hid_input *hidinput;
+
+        if (!(hdev->claimed & HID_CLAIMED_INPUT) || list_empty(&hdev->inputs))
+                return 0;
+
+        hidinput = list_first_entry(&hdev->inputs, struct hid_input, list);
+
+        switch (report->id) {
+        case 0:
+                if (data[0] == 'T') {   /* Mandatory ELO packet marker */
+                        elo_process_data(hidinput->input, data, size);
+                        return 1;
+                }
+                break;
+        default:        /* unknown report */
+                /* Unknown report type; pass upstream */
+                hid_info(hdev, "unknown report type %d\n", report->id);
+                break;
+        }
+
+        return 0;
+}
+
+static int elo_smartset_send_get(struct usb_device *dev, u8 command,
+                void *data)
+{
+        unsigned int pipe;
+        u8 dir;
+
+        if (command == ELO_SEND_SMARTSET_COMMAND) {
+                pipe = usb_sndctrlpipe(dev, 0);
+                dir = USB_DIR_OUT;
+        } else if (command == ELO_GET_SMARTSET_RESPONSE) {
+                pipe = usb_rcvctrlpipe(dev, 0);
+                dir = USB_DIR_IN;
+        } else
+                return -EINVAL;
+
+        return usb_control_msg(dev, pipe, command,
+                        dir | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                        0, 0, data, ELO_SMARTSET_PACKET_SIZE,
+                        ELO_SMARTSET_CMD_TIMEOUT);
+}
+
+static int elo_flush_smartset_responses(struct usb_device *dev)
+{
+        return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+                        ELO_FLUSH_SMARTSET_RESPONSES,
+                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                        0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
+}
+
+static void elo_work(struct work_struct *work)
+{
+        struct elo_priv *priv = container_of(work, struct elo_priv, work.work);
+        struct usb_device *dev = priv->usbdev;
+        unsigned char *buffer = priv->buffer;
+        int ret;
+
+        ret = elo_flush_smartset_responses(dev);
+        if (ret < 0) {
+                dev_err(&dev->dev, "initial FLUSH_SMARTSET_RESPONSES failed, error %d\n",
+                                ret);
+                goto fail;
+        }
+
+        /* send Diagnostics command */
+        *buffer = ELO_DIAG;
+        ret = elo_smartset_send_get(dev, ELO_SEND_SMARTSET_COMMAND, buffer);
+        if (ret < 0) {
+                dev_err(&dev->dev, "send Diagnostics Command failed, error %d\n",
+                                ret);
+                goto fail;
+        }
+
+        /* get the result */
+        ret = elo_smartset_send_get(dev, ELO_GET_SMARTSET_RESPONSE, buffer);
+        if (ret < 0) {
+                dev_err(&dev->dev, "get Diagnostics Command response failed, error %d\n",
+                                ret);
+                goto fail;
+        }
+
+        /* read the ack */
+        if (*buffer != 'A') {
+                ret = elo_smartset_send_get(dev, ELO_GET_SMARTSET_RESPONSE,
+                                buffer);
+                if (ret < 0) {
+                        dev_err(&dev->dev, "get acknowledge response failed, error %d\n",
+                                        ret);
+                        goto fail;
+                }
+        }
+
+fail:
+        ret = elo_flush_smartset_responses(dev);
+        if (ret < 0)
+                dev_err(&dev->dev, "final FLUSH_SMARTSET_RESPONSES failed, error %d\n",
+                                ret);
+        queue_delayed_work(wq, &priv->work, ELO_PERIODIC_READ_INTERVAL);
+}
+
+/*
+ * Not all Elo devices need the periodic HID descriptor reads.
+ * Only firmware version M needs this.
+ */
+static bool elo_broken_firmware(struct usb_device *dev)
+{
+        return use_fw_quirk && le16_to_cpu(dev->descriptor.bcdDevice) == 0x10d;
+}
+
+static int elo_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        struct elo_priv *priv;
+        int ret;
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        INIT_DELAYED_WORK(&priv->work, elo_work);
+        priv->usbdev = interface_to_usbdev(to_usb_interface(hdev->dev.parent));
+
+        hid_set_drvdata(hdev, priv);
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                hid_err(hdev, "parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                hid_err(hdev, "hw start failed\n");
+                goto err_free;
+        }
+
+        if (elo_broken_firmware(priv->usbdev)) {
+                hid_info(hdev, "broken firmware found, installing workaround\n");
+                queue_delayed_work(wq, &priv->work, ELO_PERIODIC_READ_INTERVAL);
+        }
+
+        return 0;
+err_free:
+        kfree(priv);
+        return ret;
+}
+
+static void elo_remove(struct hid_device *hdev)
+{
+        struct elo_priv *priv = hid_get_drvdata(hdev);
+
+        hid_hw_stop(hdev);
+        flush_workqueue(wq);
+        kfree(priv);
+}
+
+static const struct hid_device_id elo_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009), },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030), },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, elo_devices);
+
+static struct hid_driver elo_driver = {
+        .name = "elo",
+        .id_table = elo_devices,
+        .probe = elo_probe,
+        .remove = elo_remove,
+        .raw_event = elo_raw_event,
+        .input_configured = elo_input_configured,
+};
+
+static int __init elo_driver_init(void)
+{
+        int ret;
+
+        wq = create_singlethread_workqueue("elousb");
+        if (!wq)
+                return -ENOMEM;
+
+        ret = hid_register_driver(&elo_driver);
+        if (ret)
+                destroy_workqueue(wq);
+
+        return ret;
+}
+module_init(elo_driver_init);
+
+static void __exit elo_driver_exit(void)
+{
+        hid_unregister_driver(&elo_driver);
+        destroy_workqueue(wq);
+}
+module_exit(elo_driver_exit);
+
+MODULE_AUTHOR("Jiri Slaby <jslaby@suse.cz>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hid/hid-holtek-mouse.c b/drivers/hid/hid-holtek-mouse.c
new file mode 100644
index 000000000000..7e6db3cf46f9
--- /dev/null
+++ b/drivers/hid/hid-holtek-mouse.c
@@ -0,0 +1,77 @@
+/*
+ * HID driver for Holtek gaming mice
+ * Copyright (c) 2013 Christian Ohm
+ * Heavily inspired by various other HID drivers that adjust the report
+ * descriptor.
+*/
+
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+
+#include "hid-ids.h"
+
+/*
+ * The report descriptor of some Holtek based gaming mice specifies an
+ * excessively large number of consumer usages (2^15), which is more than
+ * HID_MAX_USAGES. This prevents proper parsing of the report descriptor.
+ *
+ * This driver fixes the report descriptor for:
+ * - USB ID 04d9:a067, sold as Sharkoon Drakonia and Perixx MX-2000
+ * - USB ID 04d9:a04a, sold as Tracer Sniper TRM-503, NOVA Gaming Slider X200
+ *   and Zalman ZM-GM1
+ */
+
+static __u8 *holtek_mouse_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int *rsize)
+{
+        struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
+
+        if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
+                /* Change usage maximum and logical maximum from 0x7fff to
+                 * 0x2fff, so they don't exceed HID_MAX_USAGES */
+                switch (hdev->product) {
+                case USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067:
+                        if (*rsize >= 122 && rdesc[115] == 0xff && rdesc[116] == 0x7f
+                                        && rdesc[120] == 0xff && rdesc[121] == 0x7f) {
+                                hid_info(hdev, "Fixing up report descriptor\n");
+                                rdesc[116] = rdesc[121] = 0x2f;
+                        }
+                        break;
+                case USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A:
+                        if (*rsize >= 113 && rdesc[106] == 0xff && rdesc[107] == 0x7f
+                                        && rdesc[111] == 0xff && rdesc[112] == 0x7f) {
+                                hid_info(hdev, "Fixing up report descriptor\n");
+                                rdesc[107] = rdesc[112] = 0x2f;
+                        }
+                        break;
+                }
+
+        }
+        return rdesc;
+}
+
+static const struct hid_device_id holtek_mouse_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT,
+                        USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT,
+                        USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, holtek_mouse_devices);
+
+static struct hid_driver holtek_mouse_driver = {
+        .name = "holtek_mouse",
+        .id_table = holtek_mouse_devices,
+        .report_fixup = holtek_mouse_report_fixup,
+};
+
+module_hid_driver(holtek_mouse_driver);
+MODULE_LICENSE("GPL");
diff --git a/drivers/hid/hid-huion.c b/drivers/hid/hid-huion.c
new file mode 100644
index 000000000000..cbf4da4689ba
--- /dev/null
+++ b/drivers/hid/hid-huion.c
@@ -0,0 +1,177 @@
+/*
+ *  HID driver for Huion devices not fully compliant with HID standard
+ *
+ *  Copyright (c) 2013 Martin Rusko
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include "usbhid/usbhid.h"
+
+#include "hid-ids.h"
+
+/* Original Huion 580 report descriptor size */
+#define HUION_580_RDESC_ORIG_SIZE       177
+
+/* Fixed Huion 580 report descriptor */
+static __u8 huion_580_rdesc_fixed[] = {
+        0x05, 0x0D,         /*  Usage Page (Digitizer),             */
+        0x09, 0x02,         /*  Usage (Pen),                        */
+        0xA1, 0x01,         /*  Collection (Application),           */
+        0x85, 0x07,         /*      Report ID (7),                  */
+        0x09, 0x20,         /*      Usage (Stylus),                 */
+        0xA0,               /*      Collection (Physical),          */
+        0x14,               /*          Logical Minimum (0),        */
+        0x25, 0x01,         /*          Logical Maximum (1),        */
+        0x75, 0x01,         /*          Report Size (1),            */
+        0x09, 0x42,         /*          Usage (Tip Switch),         */
+        0x09, 0x44,         /*          Usage (Barrel Switch),      */
+        0x09, 0x46,         /*          Usage (Tablet Pick),        */
+        0x95, 0x03,         /*          Report Count (3),           */
+        0x81, 0x02,         /*          Input (Variable),           */
+        0x95, 0x03,         /*          Report Count (3),           */
+        0x81, 0x03,         /*          Input (Constant, Variable), */
+        0x09, 0x32,         /*          Usage (In Range),           */
+        0x95, 0x01,         /*          Report Count (1),           */
+        0x81, 0x02,         /*          Input (Variable),           */
+        0x95, 0x01,         /*          Report Count (1),           */
+        0x81, 0x03,         /*          Input (Constant, Variable), */
+        0x75, 0x10,         /*          Report Size (16),           */
+        0x95, 0x01,         /*          Report Count (1),           */
+        0xA4,               /*          Push,                       */
+        0x05, 0x01,         /*          Usage Page (Desktop),       */
+        0x65, 0x13,         /*          Unit (Inch),                */
+        0x55, 0xFD,         /*          Unit Exponent (-3),         */
+        0x34,               /*          Physical Minimum (0),       */
+        0x09, 0x30,         /*          Usage (X),                  */
+        0x46, 0x40, 0x1F,   /*          Physical Maximum (8000),    */
+        0x26, 0x00, 0x7D,   /*          Logical Maximum (32000),    */
+        0x81, 0x02,         /*          Input (Variable),           */
+        0x09, 0x31,         /*          Usage (Y),                  */
+        0x46, 0x88, 0x13,   /*          Physical Maximum (5000),    */
+        0x26, 0x20, 0x4E,   /*          Logical Maximum (20000),    */
+        0x81, 0x02,         /*          Input (Variable),           */
+        0xB4,               /*          Pop,                        */
+        0x09, 0x30,         /*          Usage (Tip Pressure),       */
+        0x26, 0xFF, 0x07,   /*          Logical Maximum (2047),     */
+        0x81, 0x02,         /*          Input (Variable),           */
+        0xC0,               /*      End Collection,                 */
+        0xC0                /*  End Collection                      */
+};
+
+static __u8 *huion_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int *rsize)
+{
+        switch (hdev->product) {
+        case USB_DEVICE_ID_HUION_580:
+                if (*rsize == HUION_580_RDESC_ORIG_SIZE) {
+                        rdesc = huion_580_rdesc_fixed;
+                        *rsize = sizeof(huion_580_rdesc_fixed);
+                }
+                break;
+        }
+        return rdesc;
+}
+
+/**
+ * Enable fully-functional tablet mode by reading special string
+ * descriptor.
+ *
+ * @hdev:       HID device
+ *
+ * The specific string descriptor and data were discovered by sniffing
+ * the Windows driver traffic.
+ */
+static int huion_tablet_enable(struct hid_device *hdev)
+{
+        int rc;
+        char buf[22];
+
+        rc = usb_string(hid_to_usb_dev(hdev), 0x64, buf, sizeof(buf));
+        if (rc < 0)
+                return rc;
+
+        return 0;
+}
+
+static int huion_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+        struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
+
+        /* Ignore interfaces 1 (mouse) and 2 (keyboard) for Huion 580 tablet,
+         * as they are not used
+         */
+        switch (id->product) {
+        case USB_DEVICE_ID_HUION_580:
+                if (intf->cur_altsetting->desc.bInterfaceNumber != 0x00)
+                        return -ENODEV;
+                break;
+        }
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                hid_err(hdev, "parse failed\n");
+                goto err;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                hid_err(hdev, "hw start failed\n");
+                goto err;
+        }
+
+        switch (id->product) {
+        case USB_DEVICE_ID_HUION_580:
+                ret = huion_tablet_enable(hdev);
+                if (ret) {
+                        hid_err(hdev, "tablet enabling failed\n");
+                        goto enabling_err;
+                }
+                break;
+        }
+
+        return 0;
+enabling_err:
+        hid_hw_stop(hdev);
+err:
+        return ret;
+}
+
+static int huion_raw_event(struct hid_device *hdev, struct hid_report *report,
+                        u8 *data, int size)
+{
+        /* If this is a pen input report then invert the in-range bit */
+        if (report->type == HID_INPUT_REPORT && report->id == 0x07 && size >= 2)
+                data[1] ^= 0x40;
+
+        return 0;
+}
+
+static const struct hid_device_id huion_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_HUION, USB_DEVICE_ID_HUION_580) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, huion_devices);
+
+static struct hid_driver huion_driver = {
+        .name = "huion",
+        .id_table = huion_devices,
+        .probe = huion_probe,
+        .report_fixup = huion_report_fixup,
+        .raw_event = huion_raw_event,
+};
+module_hid_driver(huion_driver);
+
+MODULE_AUTHOR("Martin Rusko");
+MODULE_DESCRIPTION("Huion HID driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hid/hid-hyperv.c b/drivers/hid/hid-hyperv.c
index aa3fec0d9dc6..713217380b44 100644
--- a/drivers/hid/hid-hyperv.c
+++ b/drivers/hid/hid-hyperv.c
@@ -199,13 +199,11 @@ static void mousevsc_on_receive_device_info(struct mousevsc_dev *input_device,
         if (desc->bLength == 0)
                 goto cleanup;
 
-        input_device->hid_desc = kzalloc(desc->bLength, GFP_ATOMIC);
+        input_device->hid_desc = kmemdup(desc, desc->bLength, GFP_ATOMIC);
 
         if (!input_device->hid_desc)
                 goto cleanup;
 
-        memcpy(input_device->hid_desc, desc, desc->bLength);
-
         input_device->report_desc_size = desc->desc[0].wDescriptorLength;
         if (input_device->report_desc_size == 0) {
                 input_device->dev_info_status = -EINVAL;
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 38535c9243d5..c5aea29f164f 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -248,6 +248,9 @@
 #define USB_DEVICE_ID_CYPRESS_BARCODE_4 0xed81
 #define USB_DEVICE_ID_CYPRESS_TRUETOUCH 0xc001
 
+#define USB_VENDOR_ID_DATA_MODUL        0x7374
+#define USB_VENDOR_ID_DATA_MODUL_EASYMAXTOUCH   0x1201
+
 #define USB_VENDOR_ID_DEALEXTREAME      0x10c5
 #define USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701 0x819a
 
@@ -272,16 +275,15 @@
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E       0x725e
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262       0x7262
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B       0x726b
-#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA       0x72aa
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1       0x72a1
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA       0x72aa
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4       0x72c4
+#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0       0x72d0
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA       0x72fa
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302       0x7302
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349       0x7349
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7       0x73f7
 #define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001       0xa001
-#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224      0x7224
-#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0      0x72d0
-#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4      0x72c4
 
 #define USB_VENDOR_ID_ELECOM            0x056e
 #define USB_DEVICE_ID_ELECOM_BM084      0x0061
@@ -425,6 +427,9 @@
 #define USB_DEVICE_ID_UGCI_FLYING       0x0020
 #define USB_DEVICE_ID_UGCI_FIGHTING     0x0030
 
+#define USB_VENDOR_ID_HUION             0x256c
+#define USB_DEVICE_ID_HUION_580         0x006e
+
 #define USB_VENDOR_ID_IDEACOM           0x1cb6
 #define USB_DEVICE_ID_IDEACOM_IDC6650   0x6650
 #define USB_DEVICE_ID_IDEACOM_IDC6651   0x6651
@@ -440,6 +445,8 @@
 
 #define USB_VENDOR_ID_HOLTEK_ALT                0x04d9
 #define USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD       0xa055
+#define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067     0xa067
+#define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A     0xa04a
 
 #define USB_VENDOR_ID_IMATION           0x0718
 #define USB_DEVICE_ID_DISC_STAKKA       0xd000
@@ -447,6 +454,10 @@
 #define USB_VENDOR_ID_IRTOUCHSYSTEMS    0x6615
 #define USB_DEVICE_ID_IRTOUCH_INFRARED_USB      0x0070
 
+#define USB_VENDOR_ID_JABRA             0x0b0e
+#define USB_DEVICE_ID_JABRA_SPEAK_410   0x0412
+#define USB_DEVICE_ID_JABRA_SPEAK_510   0x0420
+
 #define USB_VENDOR_ID_JESS              0x0c45
 #define USB_DEVICE_ID_JESS_YUREX        0x1010
 
@@ -467,6 +478,7 @@
 
 #define USB_VENDOR_ID_KYE               0x0458
 #define USB_DEVICE_ID_KYE_ERGO_525V     0x0087
+#define USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE  0x0138
 #define USB_DEVICE_ID_KYE_GPEN_560      0x5003
 #define USB_DEVICE_ID_KYE_EASYPEN_I405X 0x5010
 #define USB_DEVICE_ID_KYE_MOUSEPEN_I608X        0x5011
@@ -734,6 +746,8 @@
 #define USB_DEVICE_ID_SONY_PS3_BDREMOTE         0x0306
 #define USB_DEVICE_ID_SONY_PS3_CONTROLLER       0x0268
 #define USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER        0x042f
+#define USB_DEVICE_ID_SONY_BUZZ_CONTROLLER              0x0002
+#define USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER     0x1000
 
 #define USB_VENDOR_ID_SOUNDGRAPH        0x15c2
 #define USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST     0x0034
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index 945b8158ec4c..7480799e535c 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -354,10 +354,10 @@ static int hidinput_get_battery_property(struct power_supply *psy,
                                               dev->battery_report_type);
 
                 if (ret != 2) {
-                        if (ret >= 0)
-                                ret = -EINVAL;
+                        ret = -ENODATA;
                         break;
                 }
+                ret = 0;
 
                 if (dev->battery_min < dev->battery_max &&
                     buf[1] >= dev->battery_min &&
@@ -1042,9 +1042,14 @@ void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct
 
         /*
          * Ignore out-of-range values as per HID specification,
-         * section 5.10 and 6.2.25
+         * section 5.10 and 6.2.25.
+         *
+         * The logical_minimum < logical_maximum check is done so that we
+         * don't unintentionally discard values sent by devices which
+         * don't specify logical min and max.
          */
         if ((field->flags & HID_MAIN_ITEM_VARIABLE) &&
+            (field->logical_minimum < field->logical_maximum) &&
             (value < field->logical_minimum ||
              value > field->logical_maximum)) {
                 dbg_hid("Ignoring out-of-range value %x\n", value);
diff --git a/drivers/hid/hid-kye.c b/drivers/hid/hid-kye.c
index 6af90dbdc3d4..1e2ee2aa84a0 100644
--- a/drivers/hid/hid-kye.c
+++ b/drivers/hid/hid-kye.c
@@ -314,6 +314,25 @@ static __u8 *kye_report_fixup(struct hid_device *hdev, __u8 *rdesc,
                         *rsize = sizeof(easypen_m610x_rdesc_fixed);
                 }
                 break;
+        case USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE:
+                /*
+                 * the fixup that need to be done:
+                 *   - change Usage Maximum in the Comsumer Control
+                 *     (report ID 3) to a reasonable value
+                 */
+                if (*rsize >= 135 &&
+                        /* Usage Page (Consumer Devices) */
+                        rdesc[104] == 0x05 && rdesc[105] == 0x0c &&
+                        /* Usage (Consumer Control) */
+                        rdesc[106] == 0x09 && rdesc[107] == 0x01 &&
+                        /*   Usage Maximum > 12287 */
+                        rdesc[114] == 0x2a && rdesc[116] > 0x2f) {
+                        hid_info(hdev,
+                                 "fixing up Genius Gila Gaming Mouse "
+                                 "report descriptor\n");
+                        rdesc[116] = 0x2f;
+                }
+                break;
         }
         return rdesc;
 }
@@ -407,6 +426,8 @@ static const struct hid_device_id kye_devices[] = {
                                 USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE,
                                 USB_DEVICE_ID_KYE_EASYPEN_M610X) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_KYE,
+                                USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE) },
         { }
 };
 MODULE_DEVICE_TABLE(hid, kye_devices);
diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
index d39a5cede0b0..cb0e361d7a4b 100644
--- a/drivers/hid/hid-multitouch.c
+++ b/drivers/hid/hid-multitouch.c
@@ -1111,6 +1111,11 @@ static const struct hid_device_id mt_devices[] = {
                 HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
                         USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
 
+        /* Data Modul easyMaxTouch */
+        { .driver_data = MT_CLS_DEFAULT,
+                MT_USB_DEVICE(USB_VENDOR_ID_DATA_MODUL,
+                        USB_VENDOR_ID_DATA_MODUL_EASYMAXTOUCH) },
+
         /* eGalax devices (resistive) */
         { .driver_data = MT_CLS_EGALAX,
                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
@@ -1120,34 +1125,40 @@ static const struct hid_device_id mt_devices[] = {
                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
 
         /* eGalax devices (capacitive) */
-        { .driver_data = MT_CLS_EGALAX,
-                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
-                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
         { .driver_data = MT_CLS_EGALAX_SERIAL,
                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
-        { .driver_data = MT_CLS_EGALAX_SERIAL,
+        { .driver_data = MT_CLS_EGALAX,
                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
-                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
+                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
         { .driver_data = MT_CLS_EGALAX_SERIAL,
                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
         { .driver_data = MT_CLS_EGALAX_SERIAL,
                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
-        { .driver_data = MT_CLS_EGALAX,
+        { .driver_data = MT_CLS_EGALAX_SERIAL,
                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
-                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
+                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
         { .driver_data = MT_CLS_EGALAX_SERIAL,
                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
         { .driver_data = MT_CLS_EGALAX,
                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
+                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
+        { .driver_data = MT_CLS_EGALAX,
+                MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
         { .driver_data = MT_CLS_EGALAX_SERIAL,
                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
         { .driver_data = MT_CLS_EGALAX,
+                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
+                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) },
+        { .driver_data = MT_CLS_EGALAX,
+                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
+                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) },
+        { .driver_data = MT_CLS_EGALAX,
                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
         { .driver_data = MT_CLS_EGALAX,
@@ -1162,15 +1173,6 @@ static const struct hid_device_id mt_devices[] = {
         { .driver_data = MT_CLS_EGALAX_SERIAL,
                 MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
                         USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
-        { .driver_data = MT_CLS_EGALAX,
-                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
-                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
-        { .driver_data = MT_CLS_EGALAX,
-                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
-                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) },
-        { .driver_data = MT_CLS_EGALAX,
-                HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
-                        USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) },
 
         /* Elo TouchSystems IntelliTouch Plus panel */
         { .driver_data = MT_CLS_DUAL_CONTACT_ID,
diff --git a/drivers/hid/hid-ps3remote.c b/drivers/hid/hid-ps3remote.c
deleted file mode 100644
index f1239d3c5b14..000000000000
--- a/drivers/hid/hid-ps3remote.c
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * HID driver for Sony PS3 BD Remote Control
- *
- * Copyright (c) 2012 David Dillow <dave@thedillows.org>
- * Based on a blend of the bluez fakehid user-space code by Marcel Holtmann
- * and other kernel HID drivers.
- */
-
-/*
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- */
-
-/* NOTE: in order for the Sony PS3 BD Remote Control to be found by
- * a Bluetooth host, the key combination Start+Enter has to be kept pressed
- * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
- *
- * There will be no PIN request from the device.
- */
-
-#include <linux/device.h>
-#include <linux/hid.h>
-#include <linux/module.h>
-
-#include "hid-ids.h"
-
-static __u8 ps3remote_rdesc[] = {
-        0x05, 0x01,          /* GUsagePage Generic Desktop */
-        0x09, 0x05,          /* LUsage 0x05 [Game Pad] */
-        0xA1, 0x01,          /* MCollection Application (mouse, keyboard) */
-
-         /* Use collection 1 for joypad buttons */
-         0xA1, 0x02,         /* MCollection Logical (interrelated data) */
-
-          /* Ignore the 1st byte, maybe it is used for a controller
-           * number but it's not needed for correct operation */
-          0x75, 0x08,        /* GReportSize 0x08 [8] */
-          0x95, 0x01,        /* GReportCount 0x01 [1] */
-          0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
-
-          /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
-           * buttons multiple keypresses are allowed */
-          0x05, 0x09,        /* GUsagePage Button */
-          0x19, 0x01,        /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
-          0x29, 0x18,        /* LUsageMaximum 0x18 [Button 24] */
-          0x14,              /* GLogicalMinimum [0] */
-          0x25, 0x01,        /* GLogicalMaximum 0x01 [1] */
-          0x75, 0x01,        /* GReportSize 0x01 [1] */
-          0x95, 0x18,        /* GReportCount 0x18 [24] */
-          0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
-
-          0xC0,              /* MEndCollection */
-
-         /* Use collection 2 for remote control buttons */
-         0xA1, 0x02,         /* MCollection Logical (interrelated data) */
-
-          /* 5th byte is used for remote control buttons */
-          0x05, 0x09,        /* GUsagePage Button */
-          0x18,              /* LUsageMinimum [No button pressed] */
-          0x29, 0xFE,        /* LUsageMaximum 0xFE [Button 254] */
-          0x14,              /* GLogicalMinimum [0] */
-          0x26, 0xFE, 0x00,  /* GLogicalMaximum 0x00FE [254] */
-          0x75, 0x08,        /* GReportSize 0x08 [8] */
-          0x95, 0x01,        /* GReportCount 0x01 [1] */
-          0x80,              /* MInput  */
-
-          /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
-           * 0xff and 11th is for press indication */
-          0x75, 0x08,        /* GReportSize 0x08 [8] */
-          0x95, 0x06,        /* GReportCount 0x06 [6] */
-          0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
-
-          /* 12th byte is for battery strength */
-          0x05, 0x06,        /* GUsagePage Generic Device Controls */
-          0x09, 0x20,        /* LUsage 0x20 [Battery Strength] */
-          0x14,              /* GLogicalMinimum [0] */
-          0x25, 0x05,        /* GLogicalMaximum 0x05 [5] */
-          0x75, 0x08,        /* GReportSize 0x08 [8] */
-          0x95, 0x01,        /* GReportCount 0x01 [1] */
-          0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
-
-          0xC0,              /* MEndCollection */
-
-         0xC0                /* MEndCollection [Game Pad] */
-};
-
-static const unsigned int ps3remote_keymap_joypad_buttons[] = {
-        [0x01] = KEY_SELECT,
-        [0x02] = BTN_THUMBL,            /* L3 */
-        [0x03] = BTN_THUMBR,            /* R3 */
-        [0x04] = BTN_START,
-        [0x05] = KEY_UP,
-        [0x06] = KEY_RIGHT,
-        [0x07] = KEY_DOWN,
-        [0x08] = KEY_LEFT,
-        [0x09] = BTN_TL2,               /* L2 */
-        [0x0a] = BTN_TR2,               /* R2 */
-        [0x0b] = BTN_TL,                /* L1 */
-        [0x0c] = BTN_TR,                /* R1 */
-        [0x0d] = KEY_OPTION,            /* options/triangle */
-        [0x0e] = KEY_BACK,              /* back/circle */
-        [0x0f] = BTN_0,                 /* cross */
-        [0x10] = KEY_SCREEN,            /* view/square */
-        [0x11] = KEY_HOMEPAGE,          /* PS button */
-        [0x14] = KEY_ENTER,
-};
-static const unsigned int ps3remote_keymap_remote_buttons[] = {
-        [0x00] = KEY_1,
-        [0x01] = KEY_2,
-        [0x02] = KEY_3,
-        [0x03] = KEY_4,
-        [0x04] = KEY_5,
-        [0x05] = KEY_6,
-        [0x06] = KEY_7,
-        [0x07] = KEY_8,
-        [0x08] = KEY_9,
-        [0x09] = KEY_0,
-        [0x0e] = KEY_ESC,               /* return */
-        [0x0f] = KEY_CLEAR,
-        [0x16] = KEY_EJECTCD,
-        [0x1a] = KEY_MENU,              /* top menu */
-        [0x28] = KEY_TIME,
-        [0x30] = KEY_PREVIOUS,
-        [0x31] = KEY_NEXT,
-        [0x32] = KEY_PLAY,
-        [0x33] = KEY_REWIND,            /* scan back */
-        [0x34] = KEY_FORWARD,           /* scan forward */
-        [0x38] = KEY_STOP,
-        [0x39] = KEY_PAUSE,
-        [0x40] = KEY_CONTEXT_MENU,      /* pop up/menu */
-        [0x60] = KEY_FRAMEBACK,         /* slow/step back */
-        [0x61] = KEY_FRAMEFORWARD,      /* slow/step forward */
-        [0x63] = KEY_SUBTITLE,
-        [0x64] = KEY_AUDIO,
-        [0x65] = KEY_ANGLE,
-        [0x70] = KEY_INFO,              /* display */
-        [0x80] = KEY_BLUE,
-        [0x81] = KEY_RED,
-        [0x82] = KEY_GREEN,
-        [0x83] = KEY_YELLOW,
-};
-
-static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
-                             unsigned int *rsize)
-{
-        *rsize = sizeof(ps3remote_rdesc);
-        return ps3remote_rdesc;
-}
-
-static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
-                             struct hid_field *field, struct hid_usage *usage,
-                             unsigned long **bit, int *max)
-{
-        unsigned int key = usage->hid & HID_USAGE;
-
-        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
-                return -1;
-
-        switch (usage->collection_index) {
-        case 1:
-                if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
-                        return -1;
-
-                key = ps3remote_keymap_joypad_buttons[key];
-                if (!key)
-                        return -1;
-                break;
-        case 2:
-                if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
-                        return -1;
-
-                key = ps3remote_keymap_remote_buttons[key];
-                if (!key)
-                        return -1;
-                break;
-        default:
-                return -1;
-        }
-
-        hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
-        return 1;
-}
-
-static const struct hid_device_id ps3remote_devices[] = {
-        /* PS3 BD Remote Control */
-        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE) },
-        /* Logitech Harmony Adapter for PS3 */
-        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3) },
-        { }
-};
-MODULE_DEVICE_TABLE(hid, ps3remote_devices);
-
-static struct hid_driver ps3remote_driver = {
-        .name          = "ps3_remote",
-        .id_table      = ps3remote_devices,
-        .report_fixup  = ps3remote_fixup,
-        .input_mapping = ps3remote_mapping,
-};
-module_hid_driver(ps3remote_driver);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("David Dillow <dave@thedillows.org>, Antonio Ospite <ospite@studenti.unina.it>");
diff --git a/drivers/hid/hid-roccat.c b/drivers/hid/hid-roccat.c
index b59b3df9ca95..65c4ccfcbd29 100644
--- a/drivers/hid/hid-roccat.c
+++ b/drivers/hid/hid-roccat.c
@@ -366,7 +366,7 @@ void roccat_disconnect(int minor)
         mutex_lock(&devices_lock);
         devices[minor] = NULL;
         mutex_unlock(&devices_lock);
-        
+
         if (device->open) {
                 hid_hw_close(device->hid);
                 wake_up_interruptible(&device->wait);
@@ -426,13 +426,23 @@ static int __init roccat_init(void)
 
         if (retval < 0) {
                 pr_warn("can't get major number\n");
-                return retval;
+                goto error;
         }
 
         cdev_init(&roccat_cdev, &roccat_ops);
-        cdev_add(&roccat_cdev, dev_id, ROCCAT_MAX_DEVICES);
+        retval = cdev_add(&roccat_cdev, dev_id, ROCCAT_MAX_DEVICES);
 
+        if (retval < 0) {
+                pr_warn("cannot add cdev\n");
+                goto cleanup_alloc_chrdev_region;
+        }
         return 0;
+
+
+ cleanup_alloc_chrdev_region:
+        unregister_chrdev_region(dev_id, ROCCAT_MAX_DEVICES);
+ error:
+        return retval;
 }
 
 static void __exit roccat_exit(void)
diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c
index 312098e4af4f..ecbc74923d06 100644
--- a/drivers/hid/hid-sony.c
+++ b/drivers/hid/hid-sony.c
@@ -1,11 +1,13 @@
 /*
- *  HID driver for some sony "special" devices
+ *  HID driver for Sony / PS2 / PS3 BD devices.
  *
  *  Copyright (c) 1999 Andreas Gal
  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
  *  Copyright (c) 2008 Jiri Slaby
- *  Copyright (c) 2006-2008 Jiri Kosina
+ *  Copyright (c) 2012 David Dillow <dave@thedillows.org>
+ *  Copyright (c) 2006-2013 Jiri Kosina
+ *  Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
  */
 
 /*
@@ -15,17 +17,27 @@
  * any later version.
  */
 
+/* NOTE: in order for the Sony PS3 BD Remote Control to be found by
+ * a Bluetooth host, the key combination Start+Enter has to be kept pressed
+ * for about 7 seconds with the Bluetooth Host Controller in discovering mode.
+ *
+ * There will be no PIN request from the device.
+ */
+
 #include <linux/device.h>
 #include <linux/hid.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/usb.h>
+#include <linux/leds.h>
 
 #include "hid-ids.h"
 
 #define VAIO_RDESC_CONSTANT     (1 << 0)
 #define SIXAXIS_CONTROLLER_USB  (1 << 1)
 #define SIXAXIS_CONTROLLER_BT   (1 << 2)
+#define BUZZ_CONTROLLER         (1 << 3)
+#define PS3REMOTE               (1 << 4)
 
 static const u8 sixaxis_rdesc_fixup[] = {
         0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
@@ -55,10 +67,214 @@ static const u8 sixaxis_rdesc_fixup2[] = {
         0xb1, 0x02, 0xc0, 0xc0,
 };
 
+static __u8 ps3remote_rdesc[] = {
+        0x05, 0x01,          /* GUsagePage Generic Desktop */
+        0x09, 0x05,          /* LUsage 0x05 [Game Pad] */
+        0xA1, 0x01,          /* MCollection Application (mouse, keyboard) */
+
+         /* Use collection 1 for joypad buttons */
+         0xA1, 0x02,         /* MCollection Logical (interrelated data) */
+
+          /* Ignore the 1st byte, maybe it is used for a controller
+           * number but it's not needed for correct operation */
+          0x75, 0x08,        /* GReportSize 0x08 [8] */
+          0x95, 0x01,        /* GReportCount 0x01 [1] */
+          0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
+
+          /* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
+           * buttons multiple keypresses are allowed */
+          0x05, 0x09,        /* GUsagePage Button */
+          0x19, 0x01,        /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
+          0x29, 0x18,        /* LUsageMaximum 0x18 [Button 24] */
+          0x14,              /* GLogicalMinimum [0] */
+          0x25, 0x01,        /* GLogicalMaximum 0x01 [1] */
+          0x75, 0x01,        /* GReportSize 0x01 [1] */
+          0x95, 0x18,        /* GReportCount 0x18 [24] */
+          0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
+
+          0xC0,              /* MEndCollection */
+
+         /* Use collection 2 for remote control buttons */
+         0xA1, 0x02,         /* MCollection Logical (interrelated data) */
+
+          /* 5th byte is used for remote control buttons */
+          0x05, 0x09,        /* GUsagePage Button */
+          0x18,              /* LUsageMinimum [No button pressed] */
+          0x29, 0xFE,        /* LUsageMaximum 0xFE [Button 254] */
+          0x14,              /* GLogicalMinimum [0] */
+          0x26, 0xFE, 0x00,  /* GLogicalMaximum 0x00FE [254] */
+          0x75, 0x08,        /* GReportSize 0x08 [8] */
+          0x95, 0x01,        /* GReportCount 0x01 [1] */
+          0x80,              /* MInput  */
+
+          /* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
+           * 0xff and 11th is for press indication */
+          0x75, 0x08,        /* GReportSize 0x08 [8] */
+          0x95, 0x06,        /* GReportCount 0x06 [6] */
+          0x81, 0x01,        /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
+
+          /* 12th byte is for battery strength */
+          0x05, 0x06,        /* GUsagePage Generic Device Controls */
+          0x09, 0x20,        /* LUsage 0x20 [Battery Strength] */
+          0x14,              /* GLogicalMinimum [0] */
+          0x25, 0x05,        /* GLogicalMaximum 0x05 [5] */
+          0x75, 0x08,        /* GReportSize 0x08 [8] */
+          0x95, 0x01,        /* GReportCount 0x01 [1] */
+          0x81, 0x02,        /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
+
+          0xC0,              /* MEndCollection */
+
+         0xC0                /* MEndCollection [Game Pad] */
+};
+
+static const unsigned int ps3remote_keymap_joypad_buttons[] = {
+        [0x01] = KEY_SELECT,
+        [0x02] = BTN_THUMBL,            /* L3 */
+        [0x03] = BTN_THUMBR,            /* R3 */
+        [0x04] = BTN_START,
+        [0x05] = KEY_UP,
+        [0x06] = KEY_RIGHT,
+        [0x07] = KEY_DOWN,
+        [0x08] = KEY_LEFT,
+        [0x09] = BTN_TL2,               /* L2 */
+        [0x0a] = BTN_TR2,               /* R2 */
+        [0x0b] = BTN_TL,                /* L1 */
+        [0x0c] = BTN_TR,                /* R1 */
+        [0x0d] = KEY_OPTION,            /* options/triangle */
+        [0x0e] = KEY_BACK,              /* back/circle */
+        [0x0f] = BTN_0,                 /* cross */
+        [0x10] = KEY_SCREEN,            /* view/square */
+        [0x11] = KEY_HOMEPAGE,          /* PS button */
+        [0x14] = KEY_ENTER,
+};
+static const unsigned int ps3remote_keymap_remote_buttons[] = {
+        [0x00] = KEY_1,
+        [0x01] = KEY_2,
+        [0x02] = KEY_3,
+        [0x03] = KEY_4,
+        [0x04] = KEY_5,
+        [0x05] = KEY_6,
+        [0x06] = KEY_7,
+        [0x07] = KEY_8,
+        [0x08] = KEY_9,
+        [0x09] = KEY_0,
+        [0x0e] = KEY_ESC,               /* return */
+        [0x0f] = KEY_CLEAR,
+        [0x16] = KEY_EJECTCD,
+        [0x1a] = KEY_MENU,              /* top menu */
+        [0x28] = KEY_TIME,
+        [0x30] = KEY_PREVIOUS,
+        [0x31] = KEY_NEXT,
+        [0x32] = KEY_PLAY,
+        [0x33] = KEY_REWIND,            /* scan back */
+        [0x34] = KEY_FORWARD,           /* scan forward */
+        [0x38] = KEY_STOP,
+        [0x39] = KEY_PAUSE,
+        [0x40] = KEY_CONTEXT_MENU,      /* pop up/menu */
+        [0x60] = KEY_FRAMEBACK,         /* slow/step back */
+        [0x61] = KEY_FRAMEFORWARD,      /* slow/step forward */
+        [0x63] = KEY_SUBTITLE,
+        [0x64] = KEY_AUDIO,
+        [0x65] = KEY_ANGLE,
+        [0x70] = KEY_INFO,              /* display */
+        [0x80] = KEY_BLUE,
+        [0x81] = KEY_RED,
+        [0x82] = KEY_GREEN,
+        [0x83] = KEY_YELLOW,
+};
+
+static const unsigned int buzz_keymap[] = {
+        /* The controller has 4 remote buzzers, each with one LED and 5
+         * buttons.
+         * 
+         * We use the mapping chosen by the controller, which is:
+         *
+         * Key          Offset
+         * -------------------
+         * Buzz              1
+         * Blue              5
+         * Orange            4
+         * Green             3
+         * Yellow            2
+         *
+         * So, for example, the orange button on the third buzzer is mapped to
+         * BTN_TRIGGER_HAPPY14
+         */
+        [ 1] = BTN_TRIGGER_HAPPY1,
+        [ 2] = BTN_TRIGGER_HAPPY2,
+        [ 3] = BTN_TRIGGER_HAPPY3,
+        [ 4] = BTN_TRIGGER_HAPPY4,
+        [ 5] = BTN_TRIGGER_HAPPY5,
+        [ 6] = BTN_TRIGGER_HAPPY6,
+        [ 7] = BTN_TRIGGER_HAPPY7,
+        [ 8] = BTN_TRIGGER_HAPPY8,
+        [ 9] = BTN_TRIGGER_HAPPY9,
+        [10] = BTN_TRIGGER_HAPPY10,
+        [11] = BTN_TRIGGER_HAPPY11,
+        [12] = BTN_TRIGGER_HAPPY12,
+        [13] = BTN_TRIGGER_HAPPY13,
+        [14] = BTN_TRIGGER_HAPPY14,
+        [15] = BTN_TRIGGER_HAPPY15,
+        [16] = BTN_TRIGGER_HAPPY16,
+        [17] = BTN_TRIGGER_HAPPY17,
+        [18] = BTN_TRIGGER_HAPPY18,
+        [19] = BTN_TRIGGER_HAPPY19,
+        [20] = BTN_TRIGGER_HAPPY20,
+};
+
 struct sony_sc {
         unsigned long quirks;
+
+        void *extra;
 };
 
+struct buzz_extra {
+        int led_state;
+        struct led_classdev *leds[4];
+};
+
+static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
+                             unsigned int *rsize)
+{
+        *rsize = sizeof(ps3remote_rdesc);
+        return ps3remote_rdesc;
+}
+
+static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
+                             struct hid_field *field, struct hid_usage *usage,
+                             unsigned long **bit, int *max)
+{
+        unsigned int key = usage->hid & HID_USAGE;
+
+        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
+                return -1;
+
+        switch (usage->collection_index) {
+        case 1:
+                if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
+                        return -1;
+
+                key = ps3remote_keymap_joypad_buttons[key];
+                if (!key)
+                        return -1;
+                break;
+        case 2:
+                if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
+                        return -1;
+
+                key = ps3remote_keymap_remote_buttons[key];
+                if (!key)
+                        return -1;
+                break;
+        default:
+                return -1;
+        }
+
+        hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
+        return 1;
+}
+
+
 /* Sony Vaio VGX has wrongly mouse pointer declared as constant */
 static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
                 unsigned int *rsize)
@@ -95,6 +311,10 @@ static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
                 *rsize = sizeof(sixaxis_rdesc_fixup2);
                 memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
         }
+
+        if (sc->quirks & PS3REMOTE)
+                return ps3remote_fixup(hdev, rdesc, rsize);
+
         return rdesc;
 }
 
@@ -117,6 +337,41 @@ static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
         return 0;
 }
 
+static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
+                        struct hid_field *field, struct hid_usage *usage,
+                        unsigned long **bit, int *max)
+{
+        struct sony_sc *sc = hid_get_drvdata(hdev);
+
+        if (sc->quirks & BUZZ_CONTROLLER) {
+                unsigned int key = usage->hid & HID_USAGE;
+
+                if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
+                        return -1;
+
+                switch (usage->collection_index) {
+                case 1:
+                        if (key >= ARRAY_SIZE(buzz_keymap))
+                                return -1;
+
+                        key = buzz_keymap[key];
+                        if (!key)
+                                return -1;
+                        break;
+                default:
+                        return -1;
+                }
+
+                hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
+                return 1;
+        }
+
+        if (sc->quirks & PS3REMOTE)
+                return ps3remote_mapping(hdev, hi, field, usage, bit, max);
+
+        return -1;
+}
+
 /*
  * The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP
  * like it should according to usbhid/hid-core.c::usbhid_output_raw_report()
@@ -192,11 +447,181 @@ static int sixaxis_set_operational_bt(struct hid_device *hdev)
         return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
 }
 
+static void buzz_set_leds(struct hid_device *hdev, int leds)
+{
+        struct list_head *report_list =
+                &hdev->report_enum[HID_OUTPUT_REPORT].report_list;
+        struct hid_report *report = list_entry(report_list->next,
+                struct hid_report, list);
+        __s32 *value = report->field[0]->value;
+
+        value[0] = 0x00;
+        value[1] = (leds & 1) ? 0xff : 0x00;
+        value[2] = (leds & 2) ? 0xff : 0x00;
+        value[3] = (leds & 4) ? 0xff : 0x00;
+        value[4] = (leds & 8) ? 0xff : 0x00;
+        value[5] = 0x00;
+        value[6] = 0x00;
+        hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
+}
+
+static void buzz_led_set_brightness(struct led_classdev *led,
+                                    enum led_brightness value)
+{
+        struct device *dev = led->dev->parent;
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+        struct sony_sc *drv_data;
+        struct buzz_extra *buzz;
+
+        int n;
+
+        drv_data = hid_get_drvdata(hdev);
+        if (!drv_data || !drv_data->extra) {
+                hid_err(hdev, "No device data\n");
+                return;
+        }
+        buzz = drv_data->extra;
+
+        for (n = 0; n < 4; n++) {
+                if (led == buzz->leds[n]) {
+                        int on = !! (buzz->led_state & (1 << n));
+                        if (value == LED_OFF && on) {
+                                buzz->led_state &= ~(1 << n);
+                                buzz_set_leds(hdev, buzz->led_state);
+                        } else if (value != LED_OFF && !on) {
+                                buzz->led_state |= (1 << n);
+                                buzz_set_leds(hdev, buzz->led_state);
+                        }
+                        break;
+                }
+        }
+}
+
+static enum led_brightness buzz_led_get_brightness(struct led_classdev *led)
+{
+        struct device *dev = led->dev->parent;
+        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
+        struct sony_sc *drv_data;
+        struct buzz_extra *buzz;
+
+        int n;
+        int on = 0;
+
+        drv_data = hid_get_drvdata(hdev);
+        if (!drv_data || !drv_data->extra) {
+                hid_err(hdev, "No device data\n");
+                return LED_OFF;
+        }
+        buzz = drv_data->extra;
+
+        for (n = 0; n < 4; n++) {
+                if (led == buzz->leds[n]) {
+                        on = !! (buzz->led_state & (1 << n));
+                        break;
+                }
+        }
+
+        return on ? LED_FULL : LED_OFF;
+}
+
+static int buzz_init(struct hid_device *hdev)
+{
+        struct sony_sc *drv_data;
+        struct buzz_extra *buzz;
+        int n, ret = 0;
+        struct led_classdev *led;
+        size_t name_sz;
+        char *name;
+
+        drv_data = hid_get_drvdata(hdev);
+        BUG_ON(!(drv_data->quirks & BUZZ_CONTROLLER));
+
+        buzz = kzalloc(sizeof(*buzz), GFP_KERNEL);
+        if (!buzz) {
+                hid_err(hdev, "Insufficient memory, cannot allocate driver data\n");
+                return -ENOMEM;
+        }
+        drv_data->extra = buzz;
+
+        /* Clear LEDs as we have no way of reading their initial state. This is
+         * only relevant if the driver is loaded after somebody actively set the
+         * LEDs to on */
+        buzz_set_leds(hdev, 0x00);
+
+        name_sz = strlen(dev_name(&hdev->dev)) + strlen("::buzz#") + 1;
+
+        for (n = 0; n < 4; n++) {
+                led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
+                if (!led) {
+                        hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
+                        goto error_leds;
+                }
+
+                name = (void *)(&led[1]);
+                snprintf(name, name_sz, "%s::buzz%d", dev_name(&hdev->dev), n + 1);
+                led->name = name;
+                led->brightness = 0;
+                led->max_brightness = 1;
+                led->brightness_get = buzz_led_get_brightness;
+                led->brightness_set = buzz_led_set_brightness;
+
+                if (led_classdev_register(&hdev->dev, led)) {
+                        hid_err(hdev, "Failed to register LED %d\n", n);
+                        kfree(led);
+                        goto error_leds;
+                }
+
+                buzz->leds[n] = led;
+        }
+
+        return ret;
+
+error_leds:
+        for (n = 0; n < 4; n++) {
+                led = buzz->leds[n];
+                buzz->leds[n] = NULL;
+                if (!led)
+                        continue;
+                led_classdev_unregister(led);
+                kfree(led);
+        }
+
+        kfree(drv_data->extra);
+        drv_data->extra = NULL;
+        return ret;
+}
+
+static void buzz_remove(struct hid_device *hdev)
+{
+        struct sony_sc *drv_data;
+        struct buzz_extra *buzz;
+        struct led_classdev *led;
+        int n;
+
+        drv_data = hid_get_drvdata(hdev);
+        BUG_ON(!(drv_data->quirks & BUZZ_CONTROLLER));
+
+        buzz = drv_data->extra;
+
+        for (n = 0; n < 4; n++) {
+                led = buzz->leds[n];
+                buzz->leds[n] = NULL;
+                if (!led)
+                        continue;
+                led_classdev_unregister(led);
+                kfree(led);
+        }
+
+        kfree(drv_data->extra);
+        drv_data->extra = NULL;
+}
+
 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
         int ret;
         unsigned long quirks = id->driver_data;
         struct sony_sc *sc;
+        unsigned int connect_mask = HID_CONNECT_DEFAULT;
 
         sc = kzalloc(sizeof(*sc), GFP_KERNEL);
         if (sc == NULL) {
@@ -213,8 +638,14 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
                 goto err_free;
         }
 
-        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT |
-                        HID_CONNECT_HIDDEV_FORCE);
+        if (sc->quirks & VAIO_RDESC_CONSTANT)
+                connect_mask |= HID_CONNECT_HIDDEV_FORCE;
+        else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
+                connect_mask |= HID_CONNECT_HIDDEV_FORCE;
+        else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
+                connect_mask |= HID_CONNECT_HIDDEV_FORCE;
+
+        ret = hid_hw_start(hdev, connect_mask);
         if (ret) {
                 hid_err(hdev, "hw start failed\n");
                 goto err_free;
@@ -226,6 +657,8 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
         }
         else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
                 ret = sixaxis_set_operational_bt(hdev);
+        else if (sc->quirks & BUZZ_CONTROLLER)
+                ret = buzz_init(hdev);
         else
                 ret = 0;
 
@@ -242,8 +675,13 @@ err_free:
 
 static void sony_remove(struct hid_device *hdev)
 {
+        struct sony_sc *sc = hid_get_drvdata(hdev);
+
+        if (sc->quirks & BUZZ_CONTROLLER)
+                buzz_remove(hdev);
+
         hid_hw_stop(hdev);
-        kfree(hid_get_drvdata(hdev));
+        kfree(sc);
 }
 
 static const struct hid_device_id sony_devices[] = {
@@ -257,17 +695,30 @@ static const struct hid_device_id sony_devices[] = {
                 .driver_data = VAIO_RDESC_CONSTANT },
         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
                 .driver_data = VAIO_RDESC_CONSTANT },
+        /* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
+         * Logitech joystick from the device descriptor. */
+        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
+                .driver_data = BUZZ_CONTROLLER },
+        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
+                .driver_data = BUZZ_CONTROLLER },
+        /* PS3 BD Remote Control */
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
+                .driver_data = PS3REMOTE },
+        /* Logitech Harmony Adapter for PS3 */
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
+                .driver_data = PS3REMOTE },
         { }
 };
 MODULE_DEVICE_TABLE(hid, sony_devices);
 
 static struct hid_driver sony_driver = {
-        .name = "sony",
-        .id_table = sony_devices,
-        .probe = sony_probe,
-        .remove = sony_remove,
-        .report_fixup = sony_report_fixup,
-        .raw_event = sony_raw_event
+        .name          = "sony",
+        .id_table      = sony_devices,
+        .input_mapping = sony_mapping,
+        .probe         = sony_probe,
+        .remove        = sony_remove,
+        .report_fixup  = sony_report_fixup,
+        .raw_event     = sony_raw_event
 };
 module_hid_driver(sony_driver);
 
diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c
index a4a8bb0da688..60c75dcbbdb8 100644
--- a/drivers/hid/hid-wacom.c
+++ b/drivers/hid/hid-wacom.c
@@ -46,6 +46,7 @@ struct wacom_data {
         __u8 battery_capacity;
         __u8 power_raw;
         __u8 ps_connected;
+        __u8 bat_charging;
         struct power_supply battery;
         struct power_supply ac;
         __u8 led_selector;
@@ -62,6 +63,7 @@ static enum power_supply_property wacom_battery_props[] = {
         POWER_SUPPLY_PROP_PRESENT,
         POWER_SUPPLY_PROP_CAPACITY,
         POWER_SUPPLY_PROP_SCOPE,
+        POWER_SUPPLY_PROP_STATUS,
 };
 
 static enum power_supply_property wacom_ac_props[] = {
@@ -287,6 +289,15 @@ static int wacom_battery_get_property(struct power_supply *psy,
         case POWER_SUPPLY_PROP_CAPACITY:
                 val->intval = wdata->battery_capacity;
                 break;
+        case POWER_SUPPLY_PROP_STATUS:
+                if (wdata->bat_charging)
+                        val->intval = POWER_SUPPLY_STATUS_CHARGING;
+                else
+                        if (wdata->battery_capacity == 100 && wdata->ps_connected)
+                                val->intval = POWER_SUPPLY_STATUS_FULL;
+                        else
+                                val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
+                break;
         default:
                 ret = -EINVAL;
                 break;
@@ -727,7 +738,8 @@ static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
                         if (power_raw != wdata->power_raw) {
                                 wdata->power_raw = power_raw;
                                 wdata->battery_capacity = batcap_i4[power_raw & 0x07];
-                                wdata->ps_connected = power_raw & 0x08;
+                                wdata->bat_charging = (power_raw & 0x08) ? 1 : 0;
+                                wdata->ps_connected = (power_raw & 0x10) ? 1 : 0;
                         }
 
                         break;
diff --git a/drivers/hid/hid-wiimote-core.c b/drivers/hid/hid-wiimote-core.c
index e5ee1f20bbd9..0c06054cab8f 100644
--- a/drivers/hid/hid-wiimote-core.c
+++ b/drivers/hid/hid-wiimote-core.c
@@ -1,6 +1,6 @@
 /*
- * HID driver for Nintendo Wiimote devices
- * Copyright (c) 2011 David Herrmann
+ * HID driver for Nintendo Wii / Wii U peripherals
+ * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
  */
 
 /*
@@ -14,53 +14,19 @@
 #include <linux/device.h>
 #include <linux/hid.h>
 #include <linux/input.h>
-#include <linux/leds.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
-#include <linux/power_supply.h>
 #include <linux/spinlock.h>
 #include "hid-ids.h"
 #include "hid-wiimote.h"
 
-enum wiiproto_keys {
-        WIIPROTO_KEY_LEFT,
-        WIIPROTO_KEY_RIGHT,
-        WIIPROTO_KEY_UP,
-        WIIPROTO_KEY_DOWN,
-        WIIPROTO_KEY_PLUS,
-        WIIPROTO_KEY_MINUS,
-        WIIPROTO_KEY_ONE,
-        WIIPROTO_KEY_TWO,
-        WIIPROTO_KEY_A,
-        WIIPROTO_KEY_B,
-        WIIPROTO_KEY_HOME,
-        WIIPROTO_KEY_COUNT
-};
-
-static __u16 wiiproto_keymap[] = {
-        KEY_LEFT,       /* WIIPROTO_KEY_LEFT */
-        KEY_RIGHT,      /* WIIPROTO_KEY_RIGHT */
-        KEY_UP,         /* WIIPROTO_KEY_UP */
-        KEY_DOWN,       /* WIIPROTO_KEY_DOWN */
-        KEY_NEXT,       /* WIIPROTO_KEY_PLUS */
-        KEY_PREVIOUS,   /* WIIPROTO_KEY_MINUS */
-        BTN_1,          /* WIIPROTO_KEY_ONE */
-        BTN_2,          /* WIIPROTO_KEY_TWO */
-        BTN_A,          /* WIIPROTO_KEY_A */
-        BTN_B,          /* WIIPROTO_KEY_B */
-        BTN_MODE,       /* WIIPROTO_KEY_HOME */
-};
+/* output queue handling */
 
-static enum power_supply_property wiimote_battery_props[] = {
-        POWER_SUPPLY_PROP_CAPACITY,
-        POWER_SUPPLY_PROP_SCOPE,
-};
-
-static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
-                                                                size_t count)
+static int wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
+                            size_t count)
 {
         __u8 *buf;
-        ssize_t ret;
+        int ret;
 
         if (!hdev->hid_output_raw_report)
                 return -ENODEV;
@@ -75,24 +41,33 @@ static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
         return ret;
 }
 
-static void wiimote_worker(struct work_struct *work)
+static void wiimote_queue_worker(struct work_struct *work)
 {
-        struct wiimote_data *wdata = container_of(work, struct wiimote_data,
-                                                                        worker);
+        struct wiimote_queue *queue = container_of(work, struct wiimote_queue,
+                                                   worker);
+        struct wiimote_data *wdata = container_of(queue, struct wiimote_data,
+                                                  queue);
         unsigned long flags;
+        int ret;
 
-        spin_lock_irqsave(&wdata->qlock, flags);
+        spin_lock_irqsave(&wdata->queue.lock, flags);
 
-        while (wdata->head != wdata->tail) {
-                spin_unlock_irqrestore(&wdata->qlock, flags);
-                wiimote_hid_send(wdata->hdev, wdata->outq[wdata->tail].data,
-                                                wdata->outq[wdata->tail].size);
-                spin_lock_irqsave(&wdata->qlock, flags);
+        while (wdata->queue.head != wdata->queue.tail) {
+                spin_unlock_irqrestore(&wdata->queue.lock, flags);
+                ret = wiimote_hid_send(wdata->hdev,
+                                 wdata->queue.outq[wdata->queue.tail].data,
+                                 wdata->queue.outq[wdata->queue.tail].size);
+                if (ret < 0) {
+                        spin_lock_irqsave(&wdata->state.lock, flags);
+                        wiimote_cmd_abort(wdata);
+                        spin_unlock_irqrestore(&wdata->state.lock, flags);
+                }
+                spin_lock_irqsave(&wdata->queue.lock, flags);
 
-                wdata->tail = (wdata->tail + 1) % WIIMOTE_BUFSIZE;
+                wdata->queue.tail = (wdata->queue.tail + 1) % WIIMOTE_BUFSIZE;
         }
 
-        spin_unlock_irqrestore(&wdata->qlock, flags);
+        spin_unlock_irqrestore(&wdata->queue.lock, flags);
 }
 
 static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
@@ -103,7 +78,9 @@ static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
 
         if (count > HID_MAX_BUFFER_SIZE) {
                 hid_warn(wdata->hdev, "Sending too large output report\n");
-                return;
+
+                spin_lock_irqsave(&wdata->queue.lock, flags);
+                goto out_error;
         }
 
         /*
@@ -116,22 +93,28 @@ static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
          * will reschedule itself until the queue is empty.
          */
 
-        spin_lock_irqsave(&wdata->qlock, flags);
+        spin_lock_irqsave(&wdata->queue.lock, flags);
 
-        memcpy(wdata->outq[wdata->head].data, buffer, count);
-        wdata->outq[wdata->head].size = count;
-        newhead = (wdata->head + 1) % WIIMOTE_BUFSIZE;
+        memcpy(wdata->queue.outq[wdata->queue.head].data, buffer, count);
+        wdata->queue.outq[wdata->queue.head].size = count;
+        newhead = (wdata->queue.head + 1) % WIIMOTE_BUFSIZE;
 
-        if (wdata->head == wdata->tail) {
-                wdata->head = newhead;
-                schedule_work(&wdata->worker);
-        } else if (newhead != wdata->tail) {
-                wdata->head = newhead;
+        if (wdata->queue.head == wdata->queue.tail) {
+                wdata->queue.head = newhead;
+                schedule_work(&wdata->queue.worker);
+        } else if (newhead != wdata->queue.tail) {
+                wdata->queue.head = newhead;
         } else {
                 hid_warn(wdata->hdev, "Output queue is full");
+                goto out_error;
         }
 
-        spin_unlock_irqrestore(&wdata->qlock, flags);
+        goto out_unlock;
+
+out_error:
+        wiimote_cmd_abort(wdata);
+out_unlock:
+        spin_unlock_irqrestore(&wdata->queue.lock, flags);
 }
 
 /*
@@ -147,7 +130,7 @@ static inline void wiiproto_keep_rumble(struct wiimote_data *wdata, __u8 *cmd1)
                 *cmd1 |= 0x01;
 }
 
-static void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
+void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
 {
         __u8 cmd[2];
 
@@ -167,7 +150,7 @@ static void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
         wiimote_queue(wdata, cmd, sizeof(cmd));
 }
 
-static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
+void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
 {
         __u8 cmd[2];
 
@@ -196,17 +179,46 @@ static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
  * Check what peripherals of the wiimote are currently
  * active and select a proper DRM that supports all of
  * the requested data inputs.
+ *
+ * Not all combinations are actually supported. The following
+ * combinations work only with limitations:
+ *  - IR cam in extended or full mode disables any data transmission
+ *    of extension controllers. There is no DRM mode that supports
+ *    extension bytes plus extended/full IR.
+ *  - IR cam with accelerometer and extension *_EXT8 is not supported.
+ *    However, all extensions that need *_EXT8 are devices that don't
+ *    support IR cameras. Hence, this shouldn't happen under normal
+ *    operation.
+ *  - *_EXT16 is only supported in combination with buttons and
+ *    accelerometer. No IR or similar can be active simultaneously. As
+ *    above, all modules that require it are mutually exclusive with
+ *    IR/etc. so this doesn't matter.
  */
 static __u8 select_drm(struct wiimote_data *wdata)
 {
         __u8 ir = wdata->state.flags & WIIPROTO_FLAGS_IR;
-        bool ext = wiiext_active(wdata);
+        bool ext;
 
-        if (ir == WIIPROTO_FLAG_IR_BASIC) {
-                if (wdata->state.flags & WIIPROTO_FLAG_ACCEL)
-                        return WIIPROTO_REQ_DRM_KAIE;
+        ext = (wdata->state.flags & WIIPROTO_FLAG_EXT_USED) ||
+              (wdata->state.flags & WIIPROTO_FLAG_MP_USED);
+
+        /* some 3rd-party balance-boards are hard-coded to KEE, *sigh* */
+        if (wdata->state.devtype == WIIMOTE_DEV_BALANCE_BOARD) {
+                if (ext)
+                        return WIIPROTO_REQ_DRM_KEE;
                 else
+                        return WIIPROTO_REQ_DRM_K;
+        }
+
+        if (ir == WIIPROTO_FLAG_IR_BASIC) {
+                if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) {
+                        if (ext)
+                                return WIIPROTO_REQ_DRM_KAIE;
+                        else
+                                return WIIPROTO_REQ_DRM_KAI;
+                } else {
                         return WIIPROTO_REQ_DRM_KIE;
+                }
         } else if (ir == WIIPROTO_FLAG_IR_EXT) {
                 return WIIPROTO_REQ_DRM_KAI;
         } else if (ir == WIIPROTO_FLAG_IR_FULL) {
@@ -219,7 +231,7 @@ static __u8 select_drm(struct wiimote_data *wdata)
                                 return WIIPROTO_REQ_DRM_KA;
                 } else {
                         if (ext)
-                                return WIIPROTO_REQ_DRM_KE;
+                                return WIIPROTO_REQ_DRM_KEE;
                         else
                                 return WIIPROTO_REQ_DRM_K;
                 }
@@ -230,7 +242,9 @@ void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
 {
         __u8 cmd[3];
 
-        if (drm == WIIPROTO_REQ_NULL)
+        if (wdata->state.flags & WIIPROTO_FLAG_DRM_LOCKED)
+                drm = wdata->state.drm;
+        else if (drm == WIIPROTO_REQ_NULL)
                 drm = select_drm(wdata);
 
         cmd[0] = WIIPROTO_REQ_DRM;
@@ -242,7 +256,7 @@ void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
         wiimote_queue(wdata, cmd, sizeof(cmd));
 }
 
-static void wiiproto_req_status(struct wiimote_data *wdata)
+void wiiproto_req_status(struct wiimote_data *wdata)
 {
         __u8 cmd[2];
 
@@ -253,7 +267,7 @@ static void wiiproto_req_status(struct wiimote_data *wdata)
         wiimote_queue(wdata, cmd, sizeof(cmd));
 }
 
-static void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
+void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
 {
         accel = !!accel;
         if (accel == !!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
@@ -267,7 +281,7 @@ static void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
         wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
 }
 
-static void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
+void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
 {
         __u8 cmd[2];
 
@@ -278,7 +292,7 @@ static void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
         wiimote_queue(wdata, cmd, sizeof(cmd));
 }
 
-static void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags)
+void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags)
 {
         __u8 cmd[2];
 
@@ -394,399 +408,998 @@ ssize_t wiimote_cmd_read(struct wiimote_data *wdata, __u32 offset, __u8 *rmem,
         return ret;
 }
 
-static int wiimote_battery_get_property(struct power_supply *psy,
-                                                enum power_supply_property psp,
-                                                union power_supply_propval *val)
+/* requires the cmd-mutex to be held */
+static int wiimote_cmd_init_ext(struct wiimote_data *wdata)
 {
-        struct wiimote_data *wdata = container_of(psy,
-                                                struct wiimote_data, battery);
-        int ret = 0, state;
-        unsigned long flags;
+        __u8 wmem;
+        int ret;
 
-        if (psp == POWER_SUPPLY_PROP_SCOPE) {
-                val->intval = POWER_SUPPLY_SCOPE_DEVICE;
-                return 0;
-        }
+        /* initialize extension */
+        wmem = 0x55;
+        ret = wiimote_cmd_write(wdata, 0xa400f0, &wmem, sizeof(wmem));
+        if (ret)
+                return ret;
 
-        ret = wiimote_cmd_acquire(wdata);
+        /* disable default encryption */
+        wmem = 0x0;
+        ret = wiimote_cmd_write(wdata, 0xa400fb, &wmem, sizeof(wmem));
         if (ret)
                 return ret;
 
-        spin_lock_irqsave(&wdata->state.lock, flags);
-        wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
-        wiiproto_req_status(wdata);
-        spin_unlock_irqrestore(&wdata->state.lock, flags);
+        return 0;
+}
 
-        ret = wiimote_cmd_wait(wdata);
-        state = wdata->state.cmd_battery;
-        wiimote_cmd_release(wdata);
+/* requires the cmd-mutex to be held */
+static __u8 wiimote_cmd_read_ext(struct wiimote_data *wdata, __u8 *rmem)
+{
+        int ret;
+
+        /* read extension ID */
+        ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6);
+        if (ret != 6)
+                return WIIMOTE_EXT_NONE;
+
+        hid_dbg(wdata->hdev, "extension ID: %02x:%02x %02x:%02x %02x:%02x\n",
+                rmem[0], rmem[1], rmem[2], rmem[3], rmem[4], rmem[5]);
 
+        if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff &&
+            rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff)
+                return WIIMOTE_EXT_NONE;
+
+        if (rmem[4] == 0x00 && rmem[5] == 0x00)
+                return WIIMOTE_EXT_NUNCHUK;
+        if (rmem[4] == 0x01 && rmem[5] == 0x01)
+                return WIIMOTE_EXT_CLASSIC_CONTROLLER;
+        if (rmem[4] == 0x04 && rmem[5] == 0x02)
+                return WIIMOTE_EXT_BALANCE_BOARD;
+        if (rmem[4] == 0x01 && rmem[5] == 0x20)
+                return WIIMOTE_EXT_PRO_CONTROLLER;
+
+        return WIIMOTE_EXT_UNKNOWN;
+}
+
+/* requires the cmd-mutex to be held */
+static int wiimote_cmd_init_mp(struct wiimote_data *wdata)
+{
+        __u8 wmem;
+        int ret;
+
+        /* initialize MP */
+        wmem = 0x55;
+        ret = wiimote_cmd_write(wdata, 0xa600f0, &wmem, sizeof(wmem));
         if (ret)
                 return ret;
 
-        switch (psp) {
-                case POWER_SUPPLY_PROP_CAPACITY:
-                        val->intval = state * 100 / 255;
-                        break;
-                default:
-                        ret = -EINVAL;
-                        break;
+        /* disable default encryption */
+        wmem = 0x0;
+        ret = wiimote_cmd_write(wdata, 0xa600fb, &wmem, sizeof(wmem));
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+/* requires the cmd-mutex to be held */
+static bool wiimote_cmd_map_mp(struct wiimote_data *wdata, __u8 exttype)
+{
+        __u8 wmem;
+
+        /* map MP with correct pass-through mode */
+        switch (exttype) {
+        case WIIMOTE_EXT_CLASSIC_CONTROLLER:
+                wmem = 0x07;
+                break;
+        case WIIMOTE_EXT_NUNCHUK:
+                wmem = 0x05;
+                break;
+        default:
+                wmem = 0x04;
+                break;
         }
 
-        return ret;
+        return wiimote_cmd_write(wdata, 0xa600fe, &wmem, sizeof(wmem));
 }
 
-static int wiimote_init_ir(struct wiimote_data *wdata, __u16 mode)
+/* requires the cmd-mutex to be held */
+static bool wiimote_cmd_read_mp(struct wiimote_data *wdata, __u8 *rmem)
 {
         int ret;
-        unsigned long flags;
-        __u8 format = 0;
-        static const __u8 data_enable[] = { 0x01 };
-        static const __u8 data_sens1[] = { 0x02, 0x00, 0x00, 0x71, 0x01,
-                                                0x00, 0xaa, 0x00, 0x64 };
-        static const __u8 data_sens2[] = { 0x63, 0x03 };
-        static const __u8 data_fin[] = { 0x08 };
 
-        spin_lock_irqsave(&wdata->state.lock, flags);
+        /* read motion plus ID */
+        ret = wiimote_cmd_read(wdata, 0xa600fa, rmem, 6);
+        if (ret != 6)
+                return false;
 
-        if (mode == (wdata->state.flags & WIIPROTO_FLAGS_IR)) {
-                spin_unlock_irqrestore(&wdata->state.lock, flags);
-                return 0;
-        }
+        hid_dbg(wdata->hdev, "motion plus ID: %02x:%02x %02x:%02x %02x:%02x\n",
+                rmem[0], rmem[1], rmem[2], rmem[3], rmem[4], rmem[5]);
 
-        if (mode == 0) {
-                wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
-                wiiproto_req_ir1(wdata, 0);
-                wiiproto_req_ir2(wdata, 0);
-                wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
-                spin_unlock_irqrestore(&wdata->state.lock, flags);
-                return 0;
-        }
+        if (rmem[5] == 0x05)
+                return true;
 
-        spin_unlock_irqrestore(&wdata->state.lock, flags);
+        hid_info(wdata->hdev, "unknown motion plus ID: %02x:%02x %02x:%02x %02x:%02x\n",
+                 rmem[0], rmem[1], rmem[2], rmem[3], rmem[4], rmem[5]);
 
-        ret = wiimote_cmd_acquire(wdata);
-        if (ret)
-                return ret;
+        return false;
+}
 
-        /* send PIXEL CLOCK ENABLE cmd first */
-        spin_lock_irqsave(&wdata->state.lock, flags);
-        wiimote_cmd_set(wdata, WIIPROTO_REQ_IR1, 0);
-        wiiproto_req_ir1(wdata, 0x06);
-        spin_unlock_irqrestore(&wdata->state.lock, flags);
+/* requires the cmd-mutex to be held */
+static __u8 wiimote_cmd_read_mp_mapped(struct wiimote_data *wdata)
+{
+        int ret;
+        __u8 rmem[6];
 
-        ret = wiimote_cmd_wait(wdata);
-        if (ret)
-                goto unlock;
-        if (wdata->state.cmd_err) {
-                ret = -EIO;
-                goto unlock;
+        /* read motion plus ID */
+        ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6);
+        if (ret != 6)
+                return WIIMOTE_MP_NONE;
+
+        hid_dbg(wdata->hdev, "mapped motion plus ID: %02x:%02x %02x:%02x %02x:%02x\n",
+                rmem[0], rmem[1], rmem[2], rmem[3], rmem[4], rmem[5]);
+
+        if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff &&
+            rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff)
+                return WIIMOTE_MP_NONE;
+
+        if (rmem[4] == 0x04 && rmem[5] == 0x05)
+                return WIIMOTE_MP_SINGLE;
+        else if (rmem[4] == 0x05 && rmem[5] == 0x05)
+                return WIIMOTE_MP_PASSTHROUGH_NUNCHUK;
+        else if (rmem[4] == 0x07 && rmem[5] == 0x05)
+                return WIIMOTE_MP_PASSTHROUGH_CLASSIC;
+
+        return WIIMOTE_MP_UNKNOWN;
+}
+
+/* device module handling */
+
+static const __u8 * const wiimote_devtype_mods[WIIMOTE_DEV_NUM] = {
+        [WIIMOTE_DEV_PENDING] = (const __u8[]){
+                WIIMOD_NULL,
+        },
+        [WIIMOTE_DEV_UNKNOWN] = (const __u8[]){
+                WIIMOD_NO_MP,
+                WIIMOD_NULL,
+        },
+        [WIIMOTE_DEV_GENERIC] = (const __u8[]){
+                WIIMOD_KEYS,
+                WIIMOD_RUMBLE,
+                WIIMOD_BATTERY,
+                WIIMOD_LED1,
+                WIIMOD_LED2,
+                WIIMOD_LED3,
+                WIIMOD_LED4,
+                WIIMOD_ACCEL,
+                WIIMOD_IR,
+                WIIMOD_NULL,
+        },
+        [WIIMOTE_DEV_GEN10] = (const __u8[]){
+                WIIMOD_KEYS,
+                WIIMOD_RUMBLE,
+                WIIMOD_BATTERY,
+                WIIMOD_LED1,
+                WIIMOD_LED2,
+                WIIMOD_LED3,
+                WIIMOD_LED4,
+                WIIMOD_ACCEL,
+                WIIMOD_IR,
+                WIIMOD_NULL,
+        },
+        [WIIMOTE_DEV_GEN20] = (const __u8[]){
+                WIIMOD_KEYS,
+                WIIMOD_RUMBLE,
+                WIIMOD_BATTERY,
+                WIIMOD_LED1,
+                WIIMOD_LED2,
+                WIIMOD_LED3,
+                WIIMOD_LED4,
+                WIIMOD_ACCEL,
+                WIIMOD_IR,
+                WIIMOD_BUILTIN_MP,
+                WIIMOD_NULL,
+        },
+        [WIIMOTE_DEV_BALANCE_BOARD] = (const __u8[]) {
+                WIIMOD_BATTERY,
+                WIIMOD_LED1,
+                WIIMOD_NO_MP,
+                WIIMOD_NULL,
+        },
+        [WIIMOTE_DEV_PRO_CONTROLLER] = (const __u8[]) {
+                WIIMOD_BATTERY,
+                WIIMOD_LED1,
+                WIIMOD_LED2,
+                WIIMOD_LED3,
+                WIIMOD_LED4,
+                WIIMOD_NO_MP,
+                WIIMOD_NULL,
+        },
+};
+
+static void wiimote_modules_load(struct wiimote_data *wdata,
+                                 unsigned int devtype)
+{
+        bool need_input = false;
+        const __u8 *mods, *iter;
+        const struct wiimod_ops *ops;
+        int ret;
+
+        mods = wiimote_devtype_mods[devtype];
+
+        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
+                if (wiimod_table[*iter]->flags & WIIMOD_FLAG_INPUT) {
+                        need_input = true;
+                        break;
+                }
         }
 
-        /* enable IR LOGIC */
-        spin_lock_irqsave(&wdata->state.lock, flags);
-        wiimote_cmd_set(wdata, WIIPROTO_REQ_IR2, 0);
-        wiiproto_req_ir2(wdata, 0x06);
-        spin_unlock_irqrestore(&wdata->state.lock, flags);
+        if (need_input) {
+                wdata->input = input_allocate_device();
+                if (!wdata->input)
+                        return;
+
+                input_set_drvdata(wdata->input, wdata);
+                wdata->input->dev.parent = &wdata->hdev->dev;
+                wdata->input->id.bustype = wdata->hdev->bus;
+                wdata->input->id.vendor = wdata->hdev->vendor;
+                wdata->input->id.product = wdata->hdev->product;
+                wdata->input->id.version = wdata->hdev->version;
+                wdata->input->name = WIIMOTE_NAME;
+        }
 
-        ret = wiimote_cmd_wait(wdata);
-        if (ret)
-                goto unlock;
-        if (wdata->state.cmd_err) {
-                ret = -EIO;
-                goto unlock;
+        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
+                ops = wiimod_table[*iter];
+                if (!ops->probe)
+                        continue;
+
+                ret = ops->probe(ops, wdata);
+                if (ret)
+                        goto error;
         }
 
-        /* enable IR cam but do not make it send data, yet */
-        ret = wiimote_cmd_write(wdata, 0xb00030, data_enable,
-                                                        sizeof(data_enable));
-        if (ret)
-                goto unlock;
+        if (wdata->input) {
+                ret = input_register_device(wdata->input);
+                if (ret)
+                        goto error;
+        }
 
-        /* write first sensitivity block */
-        ret = wiimote_cmd_write(wdata, 0xb00000, data_sens1,
-                                                        sizeof(data_sens1));
-        if (ret)
-                goto unlock;
+        spin_lock_irq(&wdata->state.lock);
+        wdata->state.devtype = devtype;
+        spin_unlock_irq(&wdata->state.lock);
+        return;
 
-        /* write second sensitivity block */
-        ret = wiimote_cmd_write(wdata, 0xb0001a, data_sens2,
-                                                        sizeof(data_sens2));
-        if (ret)
-                goto unlock;
+error:
+        for ( ; iter-- != mods; ) {
+                ops = wiimod_table[*iter];
+                if (ops->remove)
+                        ops->remove(ops, wdata);
+        }
 
-        /* put IR cam into desired state */
-        switch (mode) {
-                case WIIPROTO_FLAG_IR_FULL:
-                        format = 5;
-                        break;
-                case WIIPROTO_FLAG_IR_EXT:
-                        format = 3;
-                        break;
-                case WIIPROTO_FLAG_IR_BASIC:
-                        format = 1;
-                        break;
+        if (wdata->input) {
+                input_free_device(wdata->input);
+                wdata->input = NULL;
         }
-        ret = wiimote_cmd_write(wdata, 0xb00033, &format, sizeof(format));
-        if (ret)
-                goto unlock;
+}
 
-        /* make IR cam send data */
-        ret = wiimote_cmd_write(wdata, 0xb00030, data_fin, sizeof(data_fin));
-        if (ret)
-                goto unlock;
+static void wiimote_modules_unload(struct wiimote_data *wdata)
+{
+        const __u8 *mods, *iter;
+        const struct wiimod_ops *ops;
+        unsigned long flags;
+
+        mods = wiimote_devtype_mods[wdata->state.devtype];
 
-        /* request new DRM mode compatible to IR mode */
         spin_lock_irqsave(&wdata->state.lock, flags);
-        wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
-        wdata->state.flags |= mode & WIIPROTO_FLAGS_IR;
-        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        wdata->state.devtype = WIIMOTE_DEV_UNKNOWN;
         spin_unlock_irqrestore(&wdata->state.lock, flags);
 
-unlock:
-        wiimote_cmd_release(wdata);
-        return ret;
+        /* find end of list */
+        for (iter = mods; *iter != WIIMOD_NULL; ++iter)
+                /* empty */ ;
+
+        if (wdata->input) {
+                input_get_device(wdata->input);
+                input_unregister_device(wdata->input);
+        }
+
+        for ( ; iter-- != mods; ) {
+                ops = wiimod_table[*iter];
+                if (ops->remove)
+                        ops->remove(ops, wdata);
+        }
+
+        if (wdata->input) {
+                input_put_device(wdata->input);
+                wdata->input = NULL;
+        }
 }
 
-static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
+/* device extension handling */
+
+static void wiimote_ext_load(struct wiimote_data *wdata, unsigned int ext)
 {
-        struct wiimote_data *wdata;
-        struct device *dev = led_dev->dev->parent;
-        int i;
         unsigned long flags;
-        bool value = false;
+        const struct wiimod_ops *ops;
+        int ret;
 
-        wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
+        ops = wiimod_ext_table[ext];
 
-        for (i = 0; i < 4; ++i) {
-                if (wdata->leds[i] == led_dev) {
-                        spin_lock_irqsave(&wdata->state.lock, flags);
-                        value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
-                        spin_unlock_irqrestore(&wdata->state.lock, flags);
-                        break;
-                }
+        if (ops->probe) {
+                ret = ops->probe(ops, wdata);
+                if (ret)
+                        ext = WIIMOTE_EXT_UNKNOWN;
         }
 
-        return value ? LED_FULL : LED_OFF;
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.exttype = ext;
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
 }
 
-static void wiimote_leds_set(struct led_classdev *led_dev,
-                                                enum led_brightness value)
+static void wiimote_ext_unload(struct wiimote_data *wdata)
 {
-        struct wiimote_data *wdata;
-        struct device *dev = led_dev->dev->parent;
-        int i;
         unsigned long flags;
-        __u8 state, flag;
+        const struct wiimod_ops *ops;
 
-        wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
+        ops = wiimod_ext_table[wdata->state.exttype];
 
-        for (i = 0; i < 4; ++i) {
-                if (wdata->leds[i] == led_dev) {
-                        flag = WIIPROTO_FLAG_LED(i + 1);
-                        spin_lock_irqsave(&wdata->state.lock, flags);
-                        state = wdata->state.flags;
-                        if (value == LED_OFF)
-                                wiiproto_req_leds(wdata, state & ~flag);
-                        else
-                                wiiproto_req_leds(wdata, state | flag);
-                        spin_unlock_irqrestore(&wdata->state.lock, flags);
-                        break;
-                }
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.exttype = WIIMOTE_EXT_UNKNOWN;
+        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        if (ops->remove)
+                ops->remove(ops, wdata);
+}
+
+static void wiimote_mp_load(struct wiimote_data *wdata)
+{
+        unsigned long flags;
+        const struct wiimod_ops *ops;
+        int ret;
+        __u8 mode = 2;
+
+        ops = &wiimod_mp;
+        if (ops->probe) {
+                ret = ops->probe(ops, wdata);
+                if (ret)
+                        mode = 1;
         }
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.mp = mode;
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
 }
 
-static int wiimote_ff_play(struct input_dev *dev, void *data,
-                                                        struct ff_effect *eff)
+static void wiimote_mp_unload(struct wiimote_data *wdata)
 {
-        struct wiimote_data *wdata = input_get_drvdata(dev);
-        __u8 value;
         unsigned long flags;
+        const struct wiimod_ops *ops;
 
-        /*
-         * The wiimote supports only a single rumble motor so if any magnitude
-         * is set to non-zero then we start the rumble motor. If both are set to
-         * zero, we stop the rumble motor.
-         */
+        if (wdata->state.mp < 2)
+                return;
 
-        if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)
-                value = 1;
-        else
-                value = 0;
+        ops = &wiimod_mp;
 
         spin_lock_irqsave(&wdata->state.lock, flags);
-        wiiproto_req_rumble(wdata, value);
+        wdata->state.mp = 0;
+        wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED;
         spin_unlock_irqrestore(&wdata->state.lock, flags);
 
-        return 0;
+        if (ops->remove)
+                ops->remove(ops, wdata);
 }
 
-static int wiimote_input_open(struct input_dev *dev)
-{
-        struct wiimote_data *wdata = input_get_drvdata(dev);
+/* device (re-)initialization and detection */
 
-        return hid_hw_open(wdata->hdev);
-}
+static const char *wiimote_devtype_names[WIIMOTE_DEV_NUM] = {
+        [WIIMOTE_DEV_PENDING] = "Pending",
+        [WIIMOTE_DEV_UNKNOWN] = "Unknown",
+        [WIIMOTE_DEV_GENERIC] = "Generic",
+        [WIIMOTE_DEV_GEN10] = "Nintendo Wii Remote (Gen 1)",
+        [WIIMOTE_DEV_GEN20] = "Nintendo Wii Remote Plus (Gen 2)",
+        [WIIMOTE_DEV_BALANCE_BOARD] = "Nintendo Wii Balance Board",
+        [WIIMOTE_DEV_PRO_CONTROLLER] = "Nintendo Wii U Pro Controller",
+};
 
-static void wiimote_input_close(struct input_dev *dev)
+/* Try to guess the device type based on all collected information. We
+ * first try to detect by static extension types, then VID/PID and the
+ * device name. If we cannot detect the device, we use
+ * WIIMOTE_DEV_GENERIC so all modules will get probed on the device. */
+static void wiimote_init_set_type(struct wiimote_data *wdata,
+                                  __u8 exttype)
 {
-        struct wiimote_data *wdata = input_get_drvdata(dev);
+        __u8 devtype = WIIMOTE_DEV_GENERIC;
+        __u16 vendor, product;
+        const char *name;
+
+        vendor = wdata->hdev->vendor;
+        product = wdata->hdev->product;
+        name = wdata->hdev->name;
+
+        if (exttype == WIIMOTE_EXT_BALANCE_BOARD) {
+                devtype = WIIMOTE_DEV_BALANCE_BOARD;
+                goto done;
+        } else if (exttype == WIIMOTE_EXT_PRO_CONTROLLER) {
+                devtype = WIIMOTE_DEV_PRO_CONTROLLER;
+                goto done;
+        }
 
-        hid_hw_close(wdata->hdev);
+        if (!strcmp(name, "Nintendo RVL-CNT-01")) {
+                devtype = WIIMOTE_DEV_GEN10;
+                goto done;
+        } else if (!strcmp(name, "Nintendo RVL-CNT-01-TR")) {
+                devtype = WIIMOTE_DEV_GEN20;
+                goto done;
+        } else if (!strcmp(name, "Nintendo RVL-WBC-01")) {
+                devtype = WIIMOTE_DEV_BALANCE_BOARD;
+                goto done;
+        } else if (!strcmp(name, "Nintendo RVL-CNT-01-UC")) {
+                devtype = WIIMOTE_DEV_PRO_CONTROLLER;
+                goto done;
+        }
+
+        if (vendor == USB_VENDOR_ID_NINTENDO) {
+                if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE) {
+                        devtype = WIIMOTE_DEV_GEN10;
+                        goto done;
+                } else if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE2) {
+                        devtype = WIIMOTE_DEV_GEN20;
+                        goto done;
+                }
+        }
+
+done:
+        if (devtype == WIIMOTE_DEV_GENERIC)
+                hid_info(wdata->hdev, "cannot detect device; NAME: %s VID: %04x PID: %04x EXT: %04x\n",
+                        name, vendor, product, exttype);
+        else
+                hid_info(wdata->hdev, "detected device: %s\n",
+                         wiimote_devtype_names[devtype]);
+
+        wiimote_modules_load(wdata, devtype);
 }
 
-static int wiimote_accel_open(struct input_dev *dev)
+static void wiimote_init_detect(struct wiimote_data *wdata)
 {
-        struct wiimote_data *wdata = input_get_drvdata(dev);
+        __u8 exttype = WIIMOTE_EXT_NONE, extdata[6];
+        bool ext;
         int ret;
-        unsigned long flags;
 
-        ret = hid_hw_open(wdata->hdev);
+        wiimote_cmd_acquire_noint(wdata);
+
+        spin_lock_irq(&wdata->state.lock);
+        wdata->state.devtype = WIIMOTE_DEV_UNKNOWN;
+        wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
+        wiiproto_req_status(wdata);
+        spin_unlock_irq(&wdata->state.lock);
+
+        ret = wiimote_cmd_wait_noint(wdata);
         if (ret)
-                return ret;
+                goto out_release;
 
-        spin_lock_irqsave(&wdata->state.lock, flags);
-        wiiproto_req_accel(wdata, true);
-        spin_unlock_irqrestore(&wdata->state.lock, flags);
+        spin_lock_irq(&wdata->state.lock);
+        ext = wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED;
+        spin_unlock_irq(&wdata->state.lock);
 
-        return 0;
+        if (!ext)
+                goto out_release;
+
+        wiimote_cmd_init_ext(wdata);
+        exttype = wiimote_cmd_read_ext(wdata, extdata);
+
+out_release:
+        wiimote_cmd_release(wdata);
+        wiimote_init_set_type(wdata, exttype);
+
+        /* schedule MP timer */
+        spin_lock_irq(&wdata->state.lock);
+        if (!(wdata->state.flags & WIIPROTO_FLAG_BUILTIN_MP) &&
+            !(wdata->state.flags & WIIPROTO_FLAG_NO_MP))
+                mod_timer(&wdata->timer, jiffies + HZ * 4);
+        spin_unlock_irq(&wdata->state.lock);
 }
 
-static void wiimote_accel_close(struct input_dev *dev)
+/*
+ * MP hotplug events are not generated by the wiimote. Therefore, we need
+ * polling to detect it. We use a 4s interval for polling MP registers. This
+ * seems reasonable considering applications can trigger it manually via
+ * sysfs requests.
+ */
+static void wiimote_init_poll_mp(struct wiimote_data *wdata)
 {
-        struct wiimote_data *wdata = input_get_drvdata(dev);
-        unsigned long flags;
+        bool mp;
+        __u8 mpdata[6];
 
-        spin_lock_irqsave(&wdata->state.lock, flags);
-        wiiproto_req_accel(wdata, false);
-        spin_unlock_irqrestore(&wdata->state.lock, flags);
+        wiimote_cmd_acquire_noint(wdata);
+        wiimote_cmd_init_mp(wdata);
+        mp = wiimote_cmd_read_mp(wdata, mpdata);
+        wiimote_cmd_release(wdata);
 
-        hid_hw_close(wdata->hdev);
+        /* load/unload MP module if it changed */
+        if (mp) {
+                if (!wdata->state.mp) {
+                        hid_info(wdata->hdev, "detected extension: Nintendo Wii Motion Plus\n");
+                        wiimote_mp_load(wdata);
+                }
+        } else if (wdata->state.mp) {
+                wiimote_mp_unload(wdata);
+        }
+
+        mod_timer(&wdata->timer, jiffies + HZ * 4);
 }
 
-static int wiimote_ir_open(struct input_dev *dev)
+/*
+ * Check whether the wiimote is in the expected state. The extension registers
+ * may change during hotplug and initialization so we might get hotplug events
+ * that we caused by remapping some memory.
+ * We use some heuristics here to check known states. If the wiimote is in the
+ * expected state, we can ignore the hotplug event.
+ *
+ * Returns "true" if the device is in expected state, "false" if we should
+ * redo hotplug handling and extension initialization.
+ */
+static bool wiimote_init_check(struct wiimote_data *wdata)
 {
-        struct wiimote_data *wdata = input_get_drvdata(dev);
-        int ret;
+        __u32 flags;
+        __u8 type, data[6];
+        bool ret, poll_mp;
 
-        ret = hid_hw_open(wdata->hdev);
-        if (ret)
-                return ret;
+        spin_lock_irq(&wdata->state.lock);
+        flags = wdata->state.flags;
+        spin_unlock_irq(&wdata->state.lock);
 
-        ret = wiimote_init_ir(wdata, WIIPROTO_FLAG_IR_BASIC);
-        if (ret) {
-                hid_hw_close(wdata->hdev);
-                return ret;
+        wiimote_cmd_acquire_noint(wdata);
+
+        /* If MP is used and active, but the extension is not, we expect:
+         *   read_mp_mapped() == WIIMOTE_MP_SINGLE
+         *   state.flags == !EXT_ACTIVE && !MP_PLUGGED && MP_ACTIVE
+         * We do not check EXT_PLUGGED because it might change during
+         * initialization of MP without extensions.
+         *  - If MP is unplugged/replugged, read_mp_mapped() fails
+         *  - If EXT is plugged, MP_PLUGGED will get set */
+        if (wdata->state.exttype == WIIMOTE_EXT_NONE &&
+            wdata->state.mp > 0 && (flags & WIIPROTO_FLAG_MP_USED)) {
+                type = wiimote_cmd_read_mp_mapped(wdata);
+                ret = type == WIIMOTE_MP_SINGLE;
+
+                spin_lock_irq(&wdata->state.lock);
+                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
+                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED);
+                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
+                spin_unlock_irq(&wdata->state.lock);
+
+                if (!ret)
+                        hid_dbg(wdata->hdev, "state left: !EXT && MP\n");
+
+                /* while MP is mapped, we get EXT_PLUGGED events */
+                poll_mp = false;
+
+                goto out_release;
         }
 
-        return 0;
+        /* If MP is unused, but the extension port is used, we expect:
+         *   read_ext == state.exttype
+         *   state.flags == !MP_ACTIVE && EXT_ACTIVE
+         * - If MP is plugged/unplugged, our timer detects it
+         * - If EXT is unplugged/replugged, EXT_ACTIVE will become unset */
+        if (!(flags & WIIPROTO_FLAG_MP_USED) &&
+            wdata->state.exttype != WIIMOTE_EXT_NONE) {
+                type = wiimote_cmd_read_ext(wdata, data);
+                ret = type == wdata->state.exttype;
+
+                spin_lock_irq(&wdata->state.lock);
+                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
+                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
+                spin_unlock_irq(&wdata->state.lock);
+
+                if (!ret)
+                        hid_dbg(wdata->hdev, "state left: EXT && !MP\n");
+
+                /* poll MP for hotplug events */
+                poll_mp = true;
+
+                goto out_release;
+        }
+
+        /* If neither MP nor an extension are used, we expect:
+         *   read_ext() == WIIMOTE_EXT_NONE
+         *   state.flags == !MP_ACTIVE && !EXT_ACTIVE && !EXT_PLUGGED
+         * No need to perform any action in this case as everything is
+         * disabled already.
+         * - If MP is plugged/unplugged, our timer detects it
+         * - If EXT is plugged, EXT_PLUGGED will be set */
+        if (!(flags & WIIPROTO_FLAG_MP_USED) &&
+            wdata->state.exttype == WIIMOTE_EXT_NONE) {
+                type = wiimote_cmd_read_ext(wdata, data);
+                ret = type == wdata->state.exttype;
+
+                spin_lock_irq(&wdata->state.lock);
+                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
+                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
+                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED);
+                spin_unlock_irq(&wdata->state.lock);
+
+                if (!ret)
+                        hid_dbg(wdata->hdev, "state left: !EXT && !MP\n");
+
+                /* poll MP for hotplug events */
+                poll_mp = true;
+
+                goto out_release;
+        }
+
+        /* The trickiest part is if both EXT and MP are active. We cannot read
+         * the EXT ID, anymore, because MP is mapped over it. However, we use
+         * a handy trick here:
+         *   - EXT_ACTIVE is unset whenever !MP_PLUGGED is sent
+         * MP_PLUGGED might be re-sent again before we are scheduled, but
+         * EXT_ACTIVE will stay unset.
+         * So it is enough to check for mp_mapped() and MP_ACTIVE and
+         * EXT_ACTIVE. EXT_PLUGGED is a sanity check. */
+        if (wdata->state.exttype != WIIMOTE_EXT_NONE &&
+            wdata->state.mp > 0 && (flags & WIIPROTO_FLAG_MP_USED)) {
+                type = wiimote_cmd_read_mp_mapped(wdata);
+                ret = type != WIIMOTE_MP_NONE;
+                ret = ret && type != WIIMOTE_MP_UNKNOWN;
+                ret = ret && type != WIIMOTE_MP_SINGLE;
+
+                spin_lock_irq(&wdata->state.lock);
+                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED);
+                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
+                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
+                spin_unlock_irq(&wdata->state.lock);
+
+                if (!ret)
+                        hid_dbg(wdata->hdev, "state left: EXT && MP\n");
+
+                /* while MP is mapped, we get EXT_PLUGGED events */
+                poll_mp = false;
+
+                goto out_release;
+        }
+
+        /* unknown state */
+        ret = false;
+
+out_release:
+        wiimote_cmd_release(wdata);
+
+        /* only poll for MP if requested and if state didn't change */
+        if (ret && poll_mp && !(flags & WIIPROTO_FLAG_BUILTIN_MP) &&
+            !(flags & WIIPROTO_FLAG_NO_MP))
+                wiimote_init_poll_mp(wdata);
+
+        return ret;
 }
 
-static void wiimote_ir_close(struct input_dev *dev)
+static const char *wiimote_exttype_names[WIIMOTE_EXT_NUM] = {
+        [WIIMOTE_EXT_NONE] = "None",
+        [WIIMOTE_EXT_UNKNOWN] = "Unknown",
+        [WIIMOTE_EXT_NUNCHUK] = "Nintendo Wii Nunchuk",
+        [WIIMOTE_EXT_CLASSIC_CONTROLLER] = "Nintendo Wii Classic Controller",
+        [WIIMOTE_EXT_BALANCE_BOARD] = "Nintendo Wii Balance Board",
+        [WIIMOTE_EXT_PRO_CONTROLLER] = "Nintendo Wii U Pro Controller",
+};
+
+/*
+ * Handle hotplug events
+ * If we receive an hotplug event and the device-check failed, we deinitialize
+ * the extension ports, re-read all extension IDs and set the device into
+ * the desired state. This involves mapping MP into the main extension
+ * registers, setting up extension passthrough modes and initializing the
+ * requested extensions.
+ */
+static void wiimote_init_hotplug(struct wiimote_data *wdata)
 {
-        struct wiimote_data *wdata = input_get_drvdata(dev);
+        __u8 exttype, extdata[6], mpdata[6];
+        __u32 flags;
+        bool mp;
 
-        wiimote_init_ir(wdata, 0);
-        hid_hw_close(wdata->hdev);
+        hid_dbg(wdata->hdev, "detect extensions..\n");
+
+        wiimote_cmd_acquire_noint(wdata);
+
+        spin_lock_irq(&wdata->state.lock);
+
+        /* get state snapshot that we will then work on */
+        flags = wdata->state.flags;
+
+        /* disable event forwarding temporarily */
+        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE;
+        wdata->state.flags &= ~WIIPROTO_FLAG_MP_ACTIVE;
+
+        spin_unlock_irq(&wdata->state.lock);
+
+        /* init extension and MP (deactivates current extension or MP) */
+        wiimote_cmd_init_ext(wdata);
+        if (flags & WIIPROTO_FLAG_NO_MP) {
+                mp = false;
+        } else {
+                wiimote_cmd_init_mp(wdata);
+                mp = wiimote_cmd_read_mp(wdata, mpdata);
+        }
+        exttype = wiimote_cmd_read_ext(wdata, extdata);
+
+        wiimote_cmd_release(wdata);
+
+        /* load/unload extension module if it changed */
+        if (exttype != wdata->state.exttype) {
+                /* unload previous extension */
+                wiimote_ext_unload(wdata);
+
+                if (exttype == WIIMOTE_EXT_UNKNOWN) {
+                        hid_info(wdata->hdev, "cannot detect extension; %02x:%02x %02x:%02x %02x:%02x\n",
+                                 extdata[0], extdata[1], extdata[2],
+                                 extdata[3], extdata[4], extdata[5]);
+                } else if (exttype == WIIMOTE_EXT_NONE) {
+                        spin_lock_irq(&wdata->state.lock);
+                        wdata->state.exttype = WIIMOTE_EXT_NONE;
+                        spin_unlock_irq(&wdata->state.lock);
+                } else {
+                        hid_info(wdata->hdev, "detected extension: %s\n",
+                                 wiimote_exttype_names[exttype]);
+                        /* try loading new extension */
+                        wiimote_ext_load(wdata, exttype);
+                }
+        }
+
+        /* load/unload MP module if it changed */
+        if (mp) {
+                if (!wdata->state.mp) {
+                        hid_info(wdata->hdev, "detected extension: Nintendo Wii Motion Plus\n");
+                        wiimote_mp_load(wdata);
+                }
+        } else if (wdata->state.mp) {
+                wiimote_mp_unload(wdata);
+        }
+
+        /* if MP is not used, do not map or activate it */
+        if (!(flags & WIIPROTO_FLAG_MP_USED))
+                mp = false;
+
+        /* map MP into main extension registers if used */
+        if (mp) {
+                wiimote_cmd_acquire_noint(wdata);
+                wiimote_cmd_map_mp(wdata, exttype);
+                wiimote_cmd_release(wdata);
+
+                /* delete MP hotplug timer */
+                del_timer_sync(&wdata->timer);
+        } else {
+                /* reschedule MP hotplug timer */
+                if (!(flags & WIIPROTO_FLAG_BUILTIN_MP) &&
+                    !(flags & WIIPROTO_FLAG_NO_MP))
+                        mod_timer(&wdata->timer, jiffies + HZ * 4);
+        }
+
+        spin_lock_irq(&wdata->state.lock);
+
+        /* enable data forwarding again and set expected hotplug state */
+        if (mp) {
+                wdata->state.flags |= WIIPROTO_FLAG_MP_ACTIVE;
+                if (wdata->state.exttype == WIIMOTE_EXT_NONE) {
+                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED;
+                        wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED;
+                } else {
+                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED;
+                        wdata->state.flags |= WIIPROTO_FLAG_MP_PLUGGED;
+                        wdata->state.flags |= WIIPROTO_FLAG_EXT_ACTIVE;
+                }
+        } else if (wdata->state.exttype != WIIMOTE_EXT_NONE) {
+                wdata->state.flags |= WIIPROTO_FLAG_EXT_ACTIVE;
+        }
+
+        /* request status report for hotplug state updates */
+        wiiproto_req_status(wdata);
+
+        spin_unlock_irq(&wdata->state.lock);
+
+        hid_dbg(wdata->hdev, "detected extensions: MP: %d EXT: %d\n",
+                wdata->state.mp, wdata->state.exttype);
 }
 
-static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
+static void wiimote_init_worker(struct work_struct *work)
+{
+        struct wiimote_data *wdata = container_of(work, struct wiimote_data,
+                                                  init_worker);
+        bool changed = false;
+
+        if (wdata->state.devtype == WIIMOTE_DEV_PENDING) {
+                wiimote_init_detect(wdata);
+                changed = true;
+        }
+
+        if (changed || !wiimote_init_check(wdata))
+                wiimote_init_hotplug(wdata);
+
+        if (changed)
+                kobject_uevent(&wdata->hdev->dev.kobj, KOBJ_CHANGE);
+}
+
+void __wiimote_schedule(struct wiimote_data *wdata)
 {
-        input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_LEFT],
-                                                        !!(payload[0] & 0x01));
-        input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_RIGHT],
-                                                        !!(payload[0] & 0x02));
-        input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_DOWN],
-                                                        !!(payload[0] & 0x04));
-        input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_UP],
-                                                        !!(payload[0] & 0x08));
-        input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_PLUS],
-                                                        !!(payload[0] & 0x10));
-        input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_TWO],
-                                                        !!(payload[1] & 0x01));
-        input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_ONE],
-                                                        !!(payload[1] & 0x02));
-        input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_B],
-                                                        !!(payload[1] & 0x04));
-        input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_A],
-                                                        !!(payload[1] & 0x08));
-        input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_MINUS],
-                                                        !!(payload[1] & 0x10));
-        input_report_key(wdata->input, wiiproto_keymap[WIIPROTO_KEY_HOME],
-                                                        !!(payload[1] & 0x80));
-        input_sync(wdata->input);
+        if (!(wdata->state.flags & WIIPROTO_FLAG_EXITING))
+                schedule_work(&wdata->init_worker);
 }
 
-static void handler_accel(struct wiimote_data *wdata, const __u8 *payload)
+static void wiimote_schedule(struct wiimote_data *wdata)
 {
-        __u16 x, y, z;
+        unsigned long flags;
 
-        if (!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
-                return;
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        __wiimote_schedule(wdata);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+}
 
-        /*
-         * payload is: BB BB XX YY ZZ
-         * Accelerometer data is encoded into 3 10bit values. XX, YY and ZZ
-         * contain the upper 8 bits of each value. The lower 2 bits are
-         * contained in the buttons data BB BB.
-         * Bits 6 and 7 of the first buttons byte BB is the lower 2 bits of the
-         * X accel value. Bit 5 of the second buttons byte is the 2nd bit of Y
-         * accel value and bit 6 is the second bit of the Z value.
-         * The first bit of Y and Z values is not available and always set to 0.
-         * 0x200 is returned on no movement.
-         */
+static void wiimote_init_timeout(unsigned long arg)
+{
+        struct wiimote_data *wdata = (void*)arg;
 
-        x = payload[2] << 2;
-        y = payload[3] << 2;
-        z = payload[4] << 2;
+        wiimote_schedule(wdata);
+}
+
+/* protocol handlers */
+
+static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
+{
+        const __u8 *iter, *mods;
+        const struct wiimod_ops *ops;
 
-        x |= (payload[0] >> 5) & 0x3;
-        y |= (payload[1] >> 4) & 0x2;
-        z |= (payload[1] >> 5) & 0x2;
+        ops = wiimod_ext_table[wdata->state.exttype];
+        if (ops->in_keys) {
+                ops->in_keys(wdata, payload);
+                return;
+        }
 
-        input_report_abs(wdata->accel, ABS_RX, x - 0x200);
-        input_report_abs(wdata->accel, ABS_RY, y - 0x200);
-        input_report_abs(wdata->accel, ABS_RZ, z - 0x200);
-        input_sync(wdata->accel);
+        mods = wiimote_devtype_mods[wdata->state.devtype];
+        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
+                ops = wiimod_table[*iter];
+                if (ops->in_keys) {
+                        ops->in_keys(wdata, payload);
+                        break;
+                }
+        }
 }
 
-#define ir_to_input0(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
-                                                        ABS_HAT0X, ABS_HAT0Y)
-#define ir_to_input1(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
-                                                        ABS_HAT1X, ABS_HAT1Y)
-#define ir_to_input2(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
-                                                        ABS_HAT2X, ABS_HAT2Y)
-#define ir_to_input3(wdata, ir, packed) __ir_to_input((wdata), (ir), (packed), \
-                                                        ABS_HAT3X, ABS_HAT3Y)
+static void handler_accel(struct wiimote_data *wdata, const __u8 *payload)
+{
+        const __u8 *iter, *mods;
+        const struct wiimod_ops *ops;
+
+        ops = wiimod_ext_table[wdata->state.exttype];
+        if (ops->in_accel) {
+                ops->in_accel(wdata, payload);
+                return;
+        }
 
-static void __ir_to_input(struct wiimote_data *wdata, const __u8 *ir,
-                                                bool packed, __u8 xid, __u8 yid)
+        mods = wiimote_devtype_mods[wdata->state.devtype];
+        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
+                ops = wiimod_table[*iter];
+                if (ops->in_accel) {
+                        ops->in_accel(wdata, payload);
+                        break;
+                }
+        }
+}
+
+static bool valid_ext_handler(const struct wiimod_ops *ops, size_t len)
 {
-        __u16 x, y;
+        if (!ops->in_ext)
+                return false;
+        if ((ops->flags & WIIMOD_FLAG_EXT8) && len < 8)
+                return false;
+        if ((ops->flags & WIIMOD_FLAG_EXT16) && len < 16)
+                return false;
+
+        return true;
+}
 
-        if (!(wdata->state.flags & WIIPROTO_FLAGS_IR))
+static void handler_ext(struct wiimote_data *wdata, const __u8 *payload,
+                        size_t len)
+{
+        static const __u8 invalid[21] = { 0xff, 0xff, 0xff, 0xff,
+                                          0xff, 0xff, 0xff, 0xff,
+                                          0xff, 0xff, 0xff, 0xff,
+                                          0xff, 0xff, 0xff, 0xff,
+                                          0xff, 0xff, 0xff, 0xff,
+                                          0xff };
+        const __u8 *iter, *mods;
+        const struct wiimod_ops *ops;
+        bool is_mp;
+
+        if (len > 21)
+                len = 21;
+        if (len < 6 || !memcmp(payload, invalid, len))
                 return;
 
-        /*
-         * Basic IR data is encoded into 3 bytes. The first two bytes are the
-         * lower 8 bit of the X/Y data, the 3rd byte contains the upper 2 bits
-         * of both.
-         * If data is packed, then the 3rd byte is put first and slightly
-         * reordered. This allows to interleave packed and non-packed data to
-         * have two IR sets in 5 bytes instead of 6.
-         * The resulting 10bit X/Y values are passed to the ABS_HATXY input dev.
-         */
+        /* if MP is active, track MP slot hotplugging */
+        if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
+                /* this bit is set for invalid events (eg. during hotplug) */
+                if (payload[5] & 0x01)
+                        return;
+
+                if (payload[4] & 0x01) {
+                        if (!(wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED)) {
+                                hid_dbg(wdata->hdev, "MP hotplug: 1\n");
+                                wdata->state.flags |= WIIPROTO_FLAG_MP_PLUGGED;
+                                __wiimote_schedule(wdata);
+                        }
+                } else {
+                        if (wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED) {
+                                hid_dbg(wdata->hdev, "MP hotplug: 0\n");
+                                wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED;
+                                wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE;
+                                __wiimote_schedule(wdata);
+                        }
+                }
 
-        if (packed) {
-                x = ir[1] | ((ir[0] & 0x03) << 8);
-                y = ir[2] | ((ir[0] & 0x0c) << 6);
+                /* detect MP data that is sent interleaved with EXT data */
+                is_mp = payload[5] & 0x02;
         } else {
-                x = ir[0] | ((ir[2] & 0x30) << 4);
-                y = ir[1] | ((ir[2] & 0xc0) << 2);
+                is_mp = false;
+        }
+
+        /* ignore EXT events if no extension is active */
+        if (!(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE) && !is_mp)
+                return;
+
+        /* try forwarding to extension handler, first */
+        ops = wiimod_ext_table[wdata->state.exttype];
+        if (is_mp && ops->in_mp) {
+                ops->in_mp(wdata, payload);
+                return;
+        } else if (!is_mp && valid_ext_handler(ops, len)) {
+                ops->in_ext(wdata, payload);
+                return;
+        }
+
+        /* try forwarding to MP handler */
+        ops = &wiimod_mp;
+        if (is_mp && ops->in_mp) {
+                ops->in_mp(wdata, payload);
+                return;
+        } else if (!is_mp && valid_ext_handler(ops, len)) {
+                ops->in_ext(wdata, payload);
+                return;
         }
 
-        input_report_abs(wdata->ir, xid, x);
-        input_report_abs(wdata->ir, yid, y);
+        /* try forwarding to loaded modules */
+        mods = wiimote_devtype_mods[wdata->state.devtype];
+        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
+                ops = wiimod_table[*iter];
+                if (is_mp && ops->in_mp) {
+                        ops->in_mp(wdata, payload);
+                        return;
+                } else if (!is_mp && valid_ext_handler(ops, len)) {
+                        ops->in_ext(wdata, payload);
+                        return;
+                }
+        }
+}
+
+#define ir_to_input0(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 0)
+#define ir_to_input1(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 1)
+#define ir_to_input2(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 2)
+#define ir_to_input3(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 3)
+
+static void handler_ir(struct wiimote_data *wdata, const __u8 *payload,
+                       bool packed, unsigned int id)
+{
+        const __u8 *iter, *mods;
+        const struct wiimod_ops *ops;
+
+        ops = wiimod_ext_table[wdata->state.exttype];
+        if (ops->in_ir) {
+                ops->in_ir(wdata, payload, packed, id);
+                return;
+        }
+
+        mods = wiimote_devtype_mods[wdata->state.devtype];
+        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
+                ops = wiimod_table[*iter];
+                if (ops->in_ir) {
+                        ops->in_ir(wdata, payload, packed, id);
+                        break;
+                }
+        }
 }
 
 /* reduced status report with "BB BB" key data only */
@@ -804,12 +1417,27 @@ static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
 {
         handler_status_K(wdata, payload);
 
-        wiiext_event(wdata, payload[2] & 0x02);
+        /* update extension status */
+        if (payload[2] & 0x02) {
+                if (!(wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED)) {
+                        hid_dbg(wdata->hdev, "EXT hotplug: 1\n");
+                        wdata->state.flags |= WIIPROTO_FLAG_EXT_PLUGGED;
+                        __wiimote_schedule(wdata);
+                }
+        } else {
+                if (wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED) {
+                        hid_dbg(wdata->hdev, "EXT hotplug: 0\n");
+                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED;
+                        wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED;
+                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE;
+                        wdata->state.flags &= ~WIIPROTO_FLAG_MP_ACTIVE;
+                        __wiimote_schedule(wdata);
+                }
+        }
 
-        if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_SREQ, 0)) {
-                wdata->state.cmd_battery = payload[5];
+        wdata->state.cmd_battery = payload[5];
+        if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_SREQ, 0))
                 wiimote_cmd_complete(wdata);
-        }
 }
 
 /* reduced generic report with "BB BB" key data only */
@@ -864,7 +1492,7 @@ static void handler_drm_KA(struct wiimote_data *wdata, const __u8 *payload)
 static void handler_drm_KE(struct wiimote_data *wdata, const __u8 *payload)
 {
         handler_keys(wdata, payload);
-        wiiext_handle(wdata, &payload[2]);
+        handler_ext(wdata, &payload[2], 8);
 }
 
 static void handler_drm_KAI(struct wiimote_data *wdata, const __u8 *payload)
@@ -875,13 +1503,12 @@ static void handler_drm_KAI(struct wiimote_data *wdata, const __u8 *payload)
         ir_to_input1(wdata, &payload[8], false);
         ir_to_input2(wdata, &payload[11], false);
         ir_to_input3(wdata, &payload[14], false);
-        input_sync(wdata->ir);
 }
 
 static void handler_drm_KEE(struct wiimote_data *wdata, const __u8 *payload)
 {
         handler_keys(wdata, payload);
-        wiiext_handle(wdata, &payload[2]);
+        handler_ext(wdata, &payload[2], 19);
 }
 
 static void handler_drm_KIE(struct wiimote_data *wdata, const __u8 *payload)
@@ -891,15 +1518,14 @@ static void handler_drm_KIE(struct wiimote_data *wdata, const __u8 *payload)
         ir_to_input1(wdata, &payload[4], true);
         ir_to_input2(wdata, &payload[7], false);
         ir_to_input3(wdata, &payload[9], true);
-        input_sync(wdata->ir);
-        wiiext_handle(wdata, &payload[12]);
+        handler_ext(wdata, &payload[12], 9);
 }
 
 static void handler_drm_KAE(struct wiimote_data *wdata, const __u8 *payload)
 {
         handler_keys(wdata, payload);
         handler_accel(wdata, payload);
-        wiiext_handle(wdata, &payload[5]);
+        handler_ext(wdata, &payload[5], 16);
 }
 
 static void handler_drm_KAIE(struct wiimote_data *wdata, const __u8 *payload)
@@ -910,13 +1536,12 @@ static void handler_drm_KAIE(struct wiimote_data *wdata, const __u8 *payload)
         ir_to_input1(wdata, &payload[7], true);
         ir_to_input2(wdata, &payload[10], false);
         ir_to_input3(wdata, &payload[12], true);
-        input_sync(wdata->ir);
-        wiiext_handle(wdata, &payload[15]);
+        handler_ext(wdata, &payload[15], 6);
 }
 
 static void handler_drm_E(struct wiimote_data *wdata, const __u8 *payload)
 {
-        wiiext_handle(wdata, payload);
+        handler_ext(wdata, payload, 21);
 }
 
 static void handler_drm_SKAI1(struct wiimote_data *wdata, const __u8 *payload)
@@ -929,7 +1554,6 @@ static void handler_drm_SKAI1(struct wiimote_data *wdata, const __u8 *payload)
 
         ir_to_input0(wdata, &payload[3], false);
         ir_to_input1(wdata, &payload[12], false);
-        input_sync(wdata->ir);
 }
 
 static void handler_drm_SKAI2(struct wiimote_data *wdata, const __u8 *payload)
@@ -950,7 +1574,6 @@ static void handler_drm_SKAI2(struct wiimote_data *wdata, const __u8 *payload)
 
         ir_to_input2(wdata, &payload[3], false);
         ir_to_input3(wdata, &payload[12], false);
-        input_sync(wdata->ir);
 }
 
 struct wiiproto_handler {
@@ -1017,177 +1640,136 @@ static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
         return 0;
 }
 
-static void wiimote_leds_destroy(struct wiimote_data *wdata)
+static ssize_t wiimote_ext_show(struct device *dev,
+                                struct device_attribute *attr,
+                                char *buf)
 {
-        int i;
-        struct led_classdev *led;
-
-        for (i = 0; i < 4; ++i) {
-                if (wdata->leds[i]) {
-                        led = wdata->leds[i];
-                        wdata->leds[i] = NULL;
-                        led_classdev_unregister(led);
-                        kfree(led);
-                }
+        struct wiimote_data *wdata = dev_to_wii(dev);
+        __u8 type;
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        type = wdata->state.exttype;
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        switch (type) {
+        case WIIMOTE_EXT_NONE:
+                return sprintf(buf, "none\n");
+        case WIIMOTE_EXT_NUNCHUK:
+                return sprintf(buf, "nunchuk\n");
+        case WIIMOTE_EXT_CLASSIC_CONTROLLER:
+                return sprintf(buf, "classic\n");
+        case WIIMOTE_EXT_BALANCE_BOARD:
+                return sprintf(buf, "balanceboard\n");
+        case WIIMOTE_EXT_PRO_CONTROLLER:
+                return sprintf(buf, "procontroller\n");
+        case WIIMOTE_EXT_UNKNOWN:
+                /* fallthrough */
+        default:
+                return sprintf(buf, "unknown\n");
         }
 }
 
-static int wiimote_leds_create(struct wiimote_data *wdata)
+static ssize_t wiimote_ext_store(struct device *dev,
+                                 struct device_attribute *attr,
+                                 const char *buf, size_t count)
 {
-        int i, ret;
-        struct device *dev = &wdata->hdev->dev;
-        size_t namesz = strlen(dev_name(dev)) + 9;
-        struct led_classdev *led;
-        char *name;
+        struct wiimote_data *wdata = dev_to_wii(dev);
 
-        for (i = 0; i < 4; ++i) {
-                led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
-                if (!led) {
-                        ret = -ENOMEM;
-                        goto err;
-                }
-                name = (void*)&led[1];
-                snprintf(name, namesz, "%s:blue:p%d", dev_name(dev), i);
-                led->name = name;
-                led->brightness = 0;
-                led->max_brightness = 1;
-                led->brightness_get = wiimote_leds_get;
-                led->brightness_set = wiimote_leds_set;
-
-                ret = led_classdev_register(dev, led);
-                if (ret) {
-                        kfree(led);
-                        goto err;
-                }
-                wdata->leds[i] = led;
+        if (!strcmp(buf, "scan")) {
+                wiimote_schedule(wdata);
+        } else {
+                return -EINVAL;
         }
 
-        return 0;
+        return strnlen(buf, PAGE_SIZE);
+}
 
-err:
-        wiimote_leds_destroy(wdata);
-        return ret;
+static DEVICE_ATTR(extension, S_IRUGO | S_IWUSR | S_IWGRP, wiimote_ext_show,
+                   wiimote_ext_store);
+
+static ssize_t wiimote_dev_show(struct device *dev,
+                                struct device_attribute *attr,
+                                char *buf)
+{
+        struct wiimote_data *wdata = dev_to_wii(dev);
+        __u8 type;
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        type = wdata->state.devtype;
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        switch (type) {
+        case WIIMOTE_DEV_GENERIC:
+                return sprintf(buf, "generic\n");
+        case WIIMOTE_DEV_GEN10:
+                return sprintf(buf, "gen10\n");
+        case WIIMOTE_DEV_GEN20:
+                return sprintf(buf, "gen20\n");
+        case WIIMOTE_DEV_BALANCE_BOARD:
+                return sprintf(buf, "balanceboard\n");
+        case WIIMOTE_DEV_PRO_CONTROLLER:
+                return sprintf(buf, "procontroller\n");
+        case WIIMOTE_DEV_PENDING:
+                return sprintf(buf, "pending\n");
+        case WIIMOTE_DEV_UNKNOWN:
+                /* fallthrough */
+        default:
+                return sprintf(buf, "unknown\n");
+        }
 }
 
+static DEVICE_ATTR(devtype, S_IRUGO, wiimote_dev_show, NULL);
+
 static struct wiimote_data *wiimote_create(struct hid_device *hdev)
 {
         struct wiimote_data *wdata;
-        int i;
 
         wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
         if (!wdata)
                 return NULL;
 
-        wdata->input = input_allocate_device();
-        if (!wdata->input)
-                goto err;
-
         wdata->hdev = hdev;
         hid_set_drvdata(hdev, wdata);
 
-        input_set_drvdata(wdata->input, wdata);
-        wdata->input->open = wiimote_input_open;
-        wdata->input->close = wiimote_input_close;
-        wdata->input->dev.parent = &wdata->hdev->dev;
-        wdata->input->id.bustype = wdata->hdev->bus;
-        wdata->input->id.vendor = wdata->hdev->vendor;
-        wdata->input->id.product = wdata->hdev->product;
-        wdata->input->id.version = wdata->hdev->version;
-        wdata->input->name = WIIMOTE_NAME;
-
-        set_bit(EV_KEY, wdata->input->evbit);
-        for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
-                set_bit(wiiproto_keymap[i], wdata->input->keybit);
-
-        set_bit(FF_RUMBLE, wdata->input->ffbit);
-        if (input_ff_create_memless(wdata->input, NULL, wiimote_ff_play))
-                goto err_input;
-
-        wdata->accel = input_allocate_device();
-        if (!wdata->accel)
-                goto err_input;
-
-        input_set_drvdata(wdata->accel, wdata);
-        wdata->accel->open = wiimote_accel_open;
-        wdata->accel->close = wiimote_accel_close;
-        wdata->accel->dev.parent = &wdata->hdev->dev;
-        wdata->accel->id.bustype = wdata->hdev->bus;
-        wdata->accel->id.vendor = wdata->hdev->vendor;
-        wdata->accel->id.product = wdata->hdev->product;
-        wdata->accel->id.version = wdata->hdev->version;
-        wdata->accel->name = WIIMOTE_NAME " Accelerometer";
-
-        set_bit(EV_ABS, wdata->accel->evbit);
-        set_bit(ABS_RX, wdata->accel->absbit);
-        set_bit(ABS_RY, wdata->accel->absbit);
-        set_bit(ABS_RZ, wdata->accel->absbit);
-        input_set_abs_params(wdata->accel, ABS_RX, -500, 500, 2, 4);
-        input_set_abs_params(wdata->accel, ABS_RY, -500, 500, 2, 4);
-        input_set_abs_params(wdata->accel, ABS_RZ, -500, 500, 2, 4);
-
-        wdata->ir = input_allocate_device();
-        if (!wdata->ir)
-                goto err_ir;
-
-        input_set_drvdata(wdata->ir, wdata);
-        wdata->ir->open = wiimote_ir_open;
-        wdata->ir->close = wiimote_ir_close;
-        wdata->ir->dev.parent = &wdata->hdev->dev;
-        wdata->ir->id.bustype = wdata->hdev->bus;
-        wdata->ir->id.vendor = wdata->hdev->vendor;
-        wdata->ir->id.product = wdata->hdev->product;
-        wdata->ir->id.version = wdata->hdev->version;
-        wdata->ir->name = WIIMOTE_NAME " IR";
-
-        set_bit(EV_ABS, wdata->ir->evbit);
-        set_bit(ABS_HAT0X, wdata->ir->absbit);
-        set_bit(ABS_HAT0Y, wdata->ir->absbit);
-        set_bit(ABS_HAT1X, wdata->ir->absbit);
-        set_bit(ABS_HAT1Y, wdata->ir->absbit);
-        set_bit(ABS_HAT2X, wdata->ir->absbit);
-        set_bit(ABS_HAT2Y, wdata->ir->absbit);
-        set_bit(ABS_HAT3X, wdata->ir->absbit);
-        set_bit(ABS_HAT3Y, wdata->ir->absbit);
-        input_set_abs_params(wdata->ir, ABS_HAT0X, 0, 1023, 2, 4);
-        input_set_abs_params(wdata->ir, ABS_HAT0Y, 0, 767, 2, 4);
-        input_set_abs_params(wdata->ir, ABS_HAT1X, 0, 1023, 2, 4);
-        input_set_abs_params(wdata->ir, ABS_HAT1Y, 0, 767, 2, 4);
-        input_set_abs_params(wdata->ir, ABS_HAT2X, 0, 1023, 2, 4);
-        input_set_abs_params(wdata->ir, ABS_HAT2Y, 0, 767, 2, 4);
-        input_set_abs_params(wdata->ir, ABS_HAT3X, 0, 1023, 2, 4);
-        input_set_abs_params(wdata->ir, ABS_HAT3Y, 0, 767, 2, 4);
-
-        spin_lock_init(&wdata->qlock);
-        INIT_WORK(&wdata->worker, wiimote_worker);
+        spin_lock_init(&wdata->queue.lock);
+        INIT_WORK(&wdata->queue.worker, wiimote_queue_worker);
 
         spin_lock_init(&wdata->state.lock);
         init_completion(&wdata->state.ready);
         mutex_init(&wdata->state.sync);
         wdata->state.drm = WIIPROTO_REQ_DRM_K;
+        wdata->state.cmd_battery = 0xff;
 
-        return wdata;
+        INIT_WORK(&wdata->init_worker, wiimote_init_worker);
+        setup_timer(&wdata->timer, wiimote_init_timeout, (long)wdata);
 
-err_ir:
-        input_free_device(wdata->accel);
-err_input:
-        input_free_device(wdata->input);
-err:
-        kfree(wdata);
-        return NULL;
+        return wdata;
 }
 
 static void wiimote_destroy(struct wiimote_data *wdata)
 {
+        unsigned long flags;
+
         wiidebug_deinit(wdata);
-        wiiext_deinit(wdata);
-        wiimote_leds_destroy(wdata);
-
-        power_supply_unregister(&wdata->battery);
-        kfree(wdata->battery.name);
-        input_unregister_device(wdata->accel);
-        input_unregister_device(wdata->ir);
-        input_unregister_device(wdata->input);
-        cancel_work_sync(&wdata->worker);
+
+        /* prevent init_worker from being scheduled again */
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags |= WIIPROTO_FLAG_EXITING;
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        cancel_work_sync(&wdata->init_worker);
+        del_timer_sync(&wdata->timer);
+
+        device_remove_file(&wdata->hdev->dev, &dev_attr_devtype);
+        device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
+
+        wiimote_mp_unload(wdata);
+        wiimote_ext_unload(wdata);
+        wiimote_modules_unload(wdata);
+        cancel_work_sync(&wdata->queue.worker);
+        hid_hw_close(wdata->hdev);
         hid_hw_stop(wdata->hdev);
 
         kfree(wdata);
@@ -1219,62 +1801,32 @@ static int wiimote_hid_probe(struct hid_device *hdev,
                 goto err;
         }
 
-        ret = input_register_device(wdata->accel);
+        ret = hid_hw_open(hdev);
         if (ret) {
-                hid_err(hdev, "Cannot register input device\n");
+                hid_err(hdev, "cannot start hardware I/O\n");
                 goto err_stop;
         }
 
-        ret = input_register_device(wdata->ir);
-        if (ret) {
-                hid_err(hdev, "Cannot register input device\n");
-                goto err_ir;
-        }
-
-        ret = input_register_device(wdata->input);
+        ret = device_create_file(&hdev->dev, &dev_attr_extension);
         if (ret) {
-                hid_err(hdev, "Cannot register input device\n");
-                goto err_input;
-        }
-
-        wdata->battery.properties = wiimote_battery_props;
-        wdata->battery.num_properties = ARRAY_SIZE(wiimote_battery_props);
-        wdata->battery.get_property = wiimote_battery_get_property;
-        wdata->battery.type = POWER_SUPPLY_TYPE_BATTERY;
-        wdata->battery.use_for_apm = 0;
-        wdata->battery.name = kasprintf(GFP_KERNEL, "wiimote_battery_%s",
-                                        wdata->hdev->uniq);
-        if (!wdata->battery.name) {
-                ret = -ENOMEM;
-                goto err_battery_name;
+                hid_err(hdev, "cannot create sysfs attribute\n");
+                goto err_close;
         }
 
-        ret = power_supply_register(&wdata->hdev->dev, &wdata->battery);
+        ret = device_create_file(&hdev->dev, &dev_attr_devtype);
         if (ret) {
-                hid_err(hdev, "Cannot register battery device\n");
-                goto err_battery;
+                hid_err(hdev, "cannot create sysfs attribute\n");
+                goto err_ext;
         }
 
-        power_supply_powers(&wdata->battery, &hdev->dev);
-
-        ret = wiimote_leds_create(wdata);
-        if (ret)
-                goto err_free;
-
-        ret = wiiext_init(wdata);
-        if (ret)
-                goto err_free;
-
         ret = wiidebug_init(wdata);
         if (ret)
                 goto err_free;
 
         hid_info(hdev, "New device registered\n");
 
-        /* by default set led1 after device initialization */
-        spin_lock_irq(&wdata->state.lock);
-        wiiproto_req_leds(wdata, WIIPROTO_FLAG_LED1);
-        spin_unlock_irq(&wdata->state.lock);
+        /* schedule device detection */
+        wiimote_schedule(wdata);
 
         return 0;
 
@@ -1282,23 +1834,15 @@ err_free:
         wiimote_destroy(wdata);
         return ret;
 
-err_battery:
-        kfree(wdata->battery.name);
-err_battery_name:
-        input_unregister_device(wdata->input);
-        wdata->input = NULL;
-err_input:
-        input_unregister_device(wdata->ir);
-        wdata->ir = NULL;
-err_ir:
-        input_unregister_device(wdata->accel);
-        wdata->accel = NULL;
+err_ext:
+        device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
+err_close:
+        hid_hw_close(hdev);
 err_stop:
         hid_hw_stop(hdev);
 err:
         input_free_device(wdata->ir);
         input_free_device(wdata->accel);
-        input_free_device(wdata->input);
         kfree(wdata);
         return ret;
 }
@@ -1331,4 +1875,4 @@ module_hid_driver(wiimote_hid_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
-MODULE_DESCRIPTION(WIIMOTE_NAME " Device Driver");
+MODULE_DESCRIPTION("Driver for Nintendo Wii / Wii U peripherals");
diff --git a/drivers/hid/hid-wiimote-debug.c b/drivers/hid/hid-wiimote-debug.c
index 90124ffaa2a5..c13fb5bd79e8 100644
--- a/drivers/hid/hid-wiimote-debug.c
+++ b/drivers/hid/hid-wiimote-debug.c
@@ -1,6 +1,6 @@
 /*
- * Debug support for HID Nintendo Wiimote devices
- * Copyright (c) 2011 David Herrmann
+ * Debug support for HID Nintendo Wii / Wii U peripherals
+ * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
  */
 
 /*
@@ -127,7 +127,8 @@ static int wiidebug_drm_open(struct inode *i, struct file *f)
 static ssize_t wiidebug_drm_write(struct file *f, const char __user *u,
                                                         size_t s, loff_t *off)
 {
-        struct wiimote_debug *dbg = f->private_data;
+        struct seq_file *sf = f->private_data;
+        struct wiimote_debug *dbg = sf->private;
         unsigned long flags;
         char buf[16];
         ssize_t len;
@@ -140,7 +141,7 @@ static ssize_t wiidebug_drm_write(struct file *f, const char __user *u,
         if (copy_from_user(buf, u, len))
                 return -EFAULT;
 
-        buf[15] = 0;
+        buf[len] = 0;
 
         for (i = 0; i < WIIPROTO_REQ_MAX; ++i) {
                 if (!wiidebug_drmmap[i])
@@ -150,10 +151,13 @@ static ssize_t wiidebug_drm_write(struct file *f, const char __user *u,
         }
 
         if (i == WIIPROTO_REQ_MAX)
-                i = simple_strtoul(buf, NULL, 10);
+                i = simple_strtoul(buf, NULL, 16);
 
         spin_lock_irqsave(&dbg->wdata->state.lock, flags);
+        dbg->wdata->state.flags &= ~WIIPROTO_FLAG_DRM_LOCKED;
         wiiproto_req_drm(dbg->wdata, (__u8) i);
+        if (i != WIIPROTO_REQ_NULL)
+                dbg->wdata->state.flags |= WIIPROTO_FLAG_DRM_LOCKED;
         spin_unlock_irqrestore(&dbg->wdata->state.lock, flags);
 
         return len;
diff --git a/drivers/hid/hid-wiimote-ext.c b/drivers/hid/hid-wiimote-ext.c
deleted file mode 100644
index 0472191d4a72..000000000000
--- a/drivers/hid/hid-wiimote-ext.c
+++ /dev/null
@@ -1,849 +0,0 @@
-/*
- * HID driver for Nintendo Wiimote extension devices
- * Copyright (c) 2011 David Herrmann
- */
-
-/*
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 2 of the License, or (at your option)
- * any later version.
- */
-
-#include <linux/atomic.h>
-#include <linux/module.h>
-#include <linux/spinlock.h>
-#include <linux/workqueue.h>
-#include "hid-wiimote.h"
-
-struct wiimote_ext {
-        struct wiimote_data *wdata;
-        struct work_struct worker;
-        struct input_dev *input;
-        struct input_dev *mp_input;
-
-        atomic_t opened;
-        atomic_t mp_opened;
-        bool plugged;
-        bool mp_plugged;
-        bool motionp;
-        __u8 ext_type;
-        __u16 calib[4][3];
-};
-
-enum wiiext_type {
-        WIIEXT_NONE,            /* placeholder */
-        WIIEXT_CLASSIC,         /* Nintendo classic controller */
-        WIIEXT_NUNCHUCK,        /* Nintendo nunchuck controller */
-        WIIEXT_BALANCE_BOARD,   /* Nintendo balance board controller */
-};
-
-enum wiiext_keys {
-        WIIEXT_KEY_C,
-        WIIEXT_KEY_Z,
-        WIIEXT_KEY_A,
-        WIIEXT_KEY_B,
-        WIIEXT_KEY_X,
-        WIIEXT_KEY_Y,
-        WIIEXT_KEY_ZL,
-        WIIEXT_KEY_ZR,
-        WIIEXT_KEY_PLUS,
-        WIIEXT_KEY_MINUS,
-        WIIEXT_KEY_HOME,
-        WIIEXT_KEY_LEFT,
-        WIIEXT_KEY_RIGHT,
-        WIIEXT_KEY_UP,
-        WIIEXT_KEY_DOWN,
-        WIIEXT_KEY_LT,
-        WIIEXT_KEY_RT,
-        WIIEXT_KEY_COUNT
-};
-
-static __u16 wiiext_keymap[] = {
-        BTN_C,          /* WIIEXT_KEY_C */
-        BTN_Z,          /* WIIEXT_KEY_Z */
-        BTN_A,          /* WIIEXT_KEY_A */
-        BTN_B,          /* WIIEXT_KEY_B */
-        BTN_X,          /* WIIEXT_KEY_X */
-        BTN_Y,          /* WIIEXT_KEY_Y */
-        BTN_TL2,        /* WIIEXT_KEY_ZL */
-        BTN_TR2,        /* WIIEXT_KEY_ZR */
-        KEY_NEXT,       /* WIIEXT_KEY_PLUS */
-        KEY_PREVIOUS,   /* WIIEXT_KEY_MINUS */
-        BTN_MODE,       /* WIIEXT_KEY_HOME */
-        KEY_LEFT,       /* WIIEXT_KEY_LEFT */
-        KEY_RIGHT,      /* WIIEXT_KEY_RIGHT */
-        KEY_UP,         /* WIIEXT_KEY_UP */
-        KEY_DOWN,       /* WIIEXT_KEY_DOWN */
-        BTN_TL,         /* WIIEXT_KEY_LT */
-        BTN_TR,         /* WIIEXT_KEY_RT */
-};
-
-/* disable all extensions */
-static void ext_disable(struct wiimote_ext *ext)
-{
-        unsigned long flags;
-        __u8 wmem = 0x55;
-
-        if (!wiimote_cmd_acquire(ext->wdata)) {
-                wiimote_cmd_write(ext->wdata, 0xa400f0, &wmem, sizeof(wmem));
-                wiimote_cmd_release(ext->wdata);
-        }
-
-        spin_lock_irqsave(&ext->wdata->state.lock, flags);
-        ext->motionp = false;
-        ext->ext_type = WIIEXT_NONE;
-        wiiproto_req_drm(ext->wdata, WIIPROTO_REQ_NULL);
-        spin_unlock_irqrestore(&ext->wdata->state.lock, flags);
-}
-
-static bool motionp_read(struct wiimote_ext *ext)
-{
-        __u8 rmem[2], wmem;
-        ssize_t ret;
-        bool avail = false;
-
-        if (!atomic_read(&ext->mp_opened))
-                return false;
-
-        if (wiimote_cmd_acquire(ext->wdata))
-                return false;
-
-        /* initialize motion plus */
-        wmem = 0x55;
-        ret = wiimote_cmd_write(ext->wdata, 0xa600f0, &wmem, sizeof(wmem));
-        if (ret)
-                goto error;
-
-        /* read motion plus ID */
-        ret = wiimote_cmd_read(ext->wdata, 0xa600fe, rmem, 2);
-        if (ret == 2 || rmem[1] == 0x5)
-                avail = true;
-
-error:
-        wiimote_cmd_release(ext->wdata);
-        return avail;
-}
-
-static __u8 ext_read(struct wiimote_ext *ext)
-{
-        ssize_t ret;
-        __u8 buf[24], i, j, offs = 0;
-        __u8 rmem[2], wmem;
-        __u8 type = WIIEXT_NONE;
-
-        if (!ext->plugged || !atomic_read(&ext->opened))
-                return WIIEXT_NONE;
-
-        if (wiimote_cmd_acquire(ext->wdata))
-                return WIIEXT_NONE;
-
-        /* initialize extension */
-        wmem = 0x55;
-        ret = wiimote_cmd_write(ext->wdata, 0xa400f0, &wmem, sizeof(wmem));
-        if (!ret) {
-                /* disable encryption */
-                wmem = 0x0;
-                wiimote_cmd_write(ext->wdata, 0xa400fb, &wmem, sizeof(wmem));
-        }
-
-        /* read extension ID */
-        ret = wiimote_cmd_read(ext->wdata, 0xa400fe, rmem, 2);
-        if (ret == 2) {
-                if (rmem[0] == 0 && rmem[1] == 0)
-                        type = WIIEXT_NUNCHUCK;
-                else if (rmem[0] == 0x01 && rmem[1] == 0x01)
-                        type = WIIEXT_CLASSIC;
-                else if (rmem[0] == 0x04 && rmem[1] == 0x02)
-                        type = WIIEXT_BALANCE_BOARD;
-        }
-
-        /* get balance board calibration data */
-        if (type == WIIEXT_BALANCE_BOARD) {
-                ret = wiimote_cmd_read(ext->wdata, 0xa40024, buf, 12);
-                ret += wiimote_cmd_read(ext->wdata, 0xa40024 + 12,
-                                        buf + 12, 12);
-
-                if (ret != 24) {
-                        type = WIIEXT_NONE;
-                } else {
-                        for (i = 0; i < 3; i++) {
-                                for (j = 0; j < 4; j++) {
-                                        ext->calib[j][i] = buf[offs];
-                                        ext->calib[j][i] <<= 8;
-                                        ext->calib[j][i] |= buf[offs + 1];
-                                        offs += 2;
-                                }
-                        }
-                }
-        }
-
-        wiimote_cmd_release(ext->wdata);
-
-        return type;
-}
-
-static void ext_enable(struct wiimote_ext *ext, bool motionp, __u8 ext_type)
-{
-        unsigned long flags;
-        __u8 wmem;
-        int ret;
-
-        if (motionp) {
-                if (wiimote_cmd_acquire(ext->wdata))
-                        return;
-
-                if (ext_type == WIIEXT_CLASSIC)
-                        wmem = 0x07;
-                else if (ext_type == WIIEXT_NUNCHUCK)
-                        wmem = 0x05;
-                else
-                        wmem = 0x04;
-
-                ret = wiimote_cmd_write(ext->wdata, 0xa600fe, &wmem, sizeof(wmem));
-                wiimote_cmd_release(ext->wdata);
-                if (ret)
-                        return;
-        }
-
-        spin_lock_irqsave(&ext->wdata->state.lock, flags);
-        ext->motionp = motionp;
-        ext->ext_type = ext_type;
-        wiiproto_req_drm(ext->wdata, WIIPROTO_REQ_NULL);
-        spin_unlock_irqrestore(&ext->wdata->state.lock, flags);
-}
-
-static void wiiext_worker(struct work_struct *work)
-{
-        struct wiimote_ext *ext = container_of(work, struct wiimote_ext,
-                                                                        worker);
-        bool motionp;
-        __u8 ext_type;
-
-        ext_disable(ext);
-        motionp = motionp_read(ext);
-        ext_type = ext_read(ext);
-        ext_enable(ext, motionp, ext_type);
-}
-
-/* schedule work only once, otherwise mark for reschedule */
-static void wiiext_schedule(struct wiimote_ext *ext)
-{
-        schedule_work(&ext->worker);
-}
-
-/*
- * Reacts on extension port events
- * Whenever the driver gets an event from the wiimote that an extension has been
- * plugged or unplugged, this funtion shall be called. It checks what extensions
- * are connected and initializes and activates them.
- * This can be called in atomic context. The initialization is done in a
- * separate worker thread. The state.lock spinlock must be held by the caller.
- */
-void wiiext_event(struct wiimote_data *wdata, bool plugged)
-{
-        if (!wdata->ext)
-                return;
-
-        if (wdata->ext->plugged == plugged)
-                return;
-
-        wdata->ext->plugged = plugged;
-
-        if (!plugged)
-                wdata->ext->mp_plugged = false;
-
-        /*
-         * We need to call wiiext_schedule(wdata->ext) here, however, the
-         * extension initialization logic is not fully understood and so
-         * automatic initialization is not supported, yet.
-         */
-}
-
-/*
- * Returns true if the current DRM mode should contain extension data and false
- * if there is no interest in extension data.
- * All supported extensions send 6 byte extension data so any DRM that contains
- * extension bytes is fine.
- * The caller must hold the state.lock spinlock.
- */
-bool wiiext_active(struct wiimote_data *wdata)
-{
-        if (!wdata->ext)
-                return false;
-
-        return wdata->ext->motionp || wdata->ext->ext_type;
-}
-
-static void handler_motionp(struct wiimote_ext *ext, const __u8 *payload)
-{
-        __s32 x, y, z;
-        bool plugged;
-
-        /*        |   8    7    6    5    4    3 |  2  |  1  |
-         *   -----+------------------------------+-----+-----+
-         *    1   |               Yaw Speed <7:0>            |
-         *    2   |              Roll Speed <7:0>            |
-         *    3   |             Pitch Speed <7:0>            |
-         *   -----+------------------------------+-----+-----+
-         *    4   |       Yaw Speed <13:8>       | Yaw |Pitch|
-         *   -----+------------------------------+-----+-----+
-         *    5   |      Roll Speed <13:8>       |Roll | Ext |
-         *   -----+------------------------------+-----+-----+
-         *    6   |     Pitch Speed <13:8>       |  1  |  0  |
-         *   -----+------------------------------+-----+-----+
-         * The single bits Yaw, Roll, Pitch in the lower right corner specify
-         * whether the wiimote is rotating fast (0) or slow (1). Speed for slow
-         * roation is 440 deg/s and for fast rotation 2000 deg/s. To get a
-         * linear scale we multiply by 2000/440 = ~4.5454 which is 18 for fast
-         * and 9 for slow.
-         * If the wiimote is not rotating the sensor reports 2^13 = 8192.
-         * Ext specifies whether an extension is connected to the motionp.
-         */
-
-        x = payload[0];
-        y = payload[1];
-        z = payload[2];
-
-        x |= (((__u16)payload[3]) << 6) & 0xff00;
-        y |= (((__u16)payload[4]) << 6) & 0xff00;
-        z |= (((__u16)payload[5]) << 6) & 0xff00;
-
-        x -= 8192;
-        y -= 8192;
-        z -= 8192;
-
-        if (!(payload[3] & 0x02))
-                x *= 18;
-        else
-                x *= 9;
-        if (!(payload[4] & 0x02))
-                y *= 18;
-        else
-                y *= 9;
-        if (!(payload[3] & 0x01))
-                z *= 18;
-        else
-                z *= 9;
-
-        input_report_abs(ext->mp_input, ABS_RX, x);
-        input_report_abs(ext->mp_input, ABS_RY, y);
-        input_report_abs(ext->mp_input, ABS_RZ, z);
-        input_sync(ext->mp_input);
-
-        plugged = payload[5] & 0x01;
-        if (plugged != ext->mp_plugged)
-                ext->mp_plugged = plugged;
-}
-
-static void handler_nunchuck(struct wiimote_ext *ext, const __u8 *payload)
-{
-        __s16 x, y, z, bx, by;
-
-        /*   Byte |   8    7 |  6    5 |  4    3 |  2 |  1  |
-         *   -----+----------+---------+---------+----+-----+
-         *    1   |              Button X <7:0>             |
-         *    2   |              Button Y <7:0>             |
-         *   -----+----------+---------+---------+----+-----+
-         *    3   |               Speed X <9:2>             |
-         *    4   |               Speed Y <9:2>             |
-         *    5   |               Speed Z <9:2>             |
-         *   -----+----------+---------+---------+----+-----+
-         *    6   | Z <1:0>  | Y <1:0> | X <1:0> | BC | BZ  |
-         *   -----+----------+---------+---------+----+-----+
-         * Button X/Y is the analog stick. Speed X, Y and Z are the
-         * accelerometer data in the same format as the wiimote's accelerometer.
-         * The 6th byte contains the LSBs of the accelerometer data.
-         * BC and BZ are the C and Z buttons: 0 means pressed
-         *
-         * If reported interleaved with motionp, then the layout changes. The
-         * 5th and 6th byte changes to:
-         *   -----+-----------------------------------+-----+
-         *    5   |            Speed Z <9:3>          | EXT |
-         *   -----+--------+-----+-----+----+----+----+-----+
-         *    6   |Z <2:1> |Y <1>|X <1>| BC | BZ | 0  |  0  |
-         *   -----+--------+-----+-----+----+----+----+-----+
-         * All three accelerometer values lose their LSB. The other data is
-         * still available but slightly moved.
-         *
-         * Center data for button values is 128. Center value for accelerometer
-         * values it 512 / 0x200
-         */
-
-        bx = payload[0];
-        by = payload[1];
-        bx -= 128;
-        by -= 128;
-
-        x = payload[2] << 2;
-        y = payload[3] << 2;
-        z = payload[4] << 2;
-
-        if (ext->motionp) {
-                x |= (payload[5] >> 3) & 0x02;
-                y |= (payload[5] >> 4) & 0x02;
-                z &= ~0x4;
-                z |= (payload[5] >> 5) & 0x06;
-        } else {
-                x |= (payload[5] >> 2) & 0x03;
-                y |= (payload[5] >> 4) & 0x03;
-                z |= (payload[5] >> 6) & 0x03;
-        }
-
-        x -= 0x200;
-        y -= 0x200;
-        z -= 0x200;
-
-        input_report_abs(ext->input, ABS_HAT0X, bx);
-        input_report_abs(ext->input, ABS_HAT0Y, by);
-
-        input_report_abs(ext->input, ABS_RX, x);
-        input_report_abs(ext->input, ABS_RY, y);
-        input_report_abs(ext->input, ABS_RZ, z);
-
-        if (ext->motionp) {
-                input_report_key(ext->input,
-                        wiiext_keymap[WIIEXT_KEY_Z], !(payload[5] & 0x04));
-                input_report_key(ext->input,
-                        wiiext_keymap[WIIEXT_KEY_C], !(payload[5] & 0x08));
-        } else {
-                input_report_key(ext->input,
-                        wiiext_keymap[WIIEXT_KEY_Z], !(payload[5] & 0x01));
-                input_report_key(ext->input,
-                        wiiext_keymap[WIIEXT_KEY_C], !(payload[5] & 0x02));
-        }
-
-        input_sync(ext->input);
-}
-
-static void handler_classic(struct wiimote_ext *ext, const __u8 *payload)
-{
-        __s8 rx, ry, lx, ly, lt, rt;
-
-        /*   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
-         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
-         *    1   | RX <5:4>  |              LX <5:0>             |
-         *    2   | RX <3:2>  |              LY <5:0>             |
-         *   -----+-----+-----+-----+-----------------------------+
-         *    3   |RX<1>| LT <5:4>  |         RY <5:1>            |
-         *   -----+-----+-----------+-----------------------------+
-         *    4   |     LT <3:1>    |         RT <5:1>            |
-         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
-         *    5   | BDR | BDD | BLT | B-  | BH  | B+  | BRT |  1  |
-         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
-         *    6   | BZL | BB  | BY  | BA  | BX  | BZR | BDL | BDU |
-         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
-         * All buttons are 0 if pressed
-         * RX and RY are right analog stick
-         * LX and LY are left analog stick
-         * LT is left trigger, RT is right trigger
-         * BLT is 0 if left trigger is fully pressed
-         * BRT is 0 if right trigger is fully pressed
-         * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons
-         * BZL is left Z button and BZR is right Z button
-         * B-, BH, B+ are +, HOME and - buttons
-         * BB, BY, BA, BX are A, B, X, Y buttons
-         * LSB of RX, RY, LT, and RT are not transmitted and always 0.
-         *
-         * With motionp enabled it changes slightly to this:
-         *   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
-         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
-         *    1   | RX <4:3>  |          LX <5:1>           | BDU |
-         *    2   | RX <2:1>  |          LY <5:1>           | BDL |
-         *   -----+-----+-----+-----+-----------------------+-----+
-         *    3   |RX<0>| LT <4:3>  |         RY <4:0>            |
-         *   -----+-----+-----------+-----------------------------+
-         *    4   |     LT <2:0>    |         RT <4:0>            |
-         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
-         *    5   | BDR | BDD | BLT | B-  | BH  | B+  | BRT | EXT |
-         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
-         *    6   | BZL | BB  | BY  | BA  | BX  | BZR |  0  |  0  |
-         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
-         * Only the LSBs of LX and LY are lost. BDU and BDL are moved, the rest
-         * is the same as before.
-         */
-
-        if (ext->motionp) {
-                lx = payload[0] & 0x3e;
-                ly = payload[0] & 0x3e;
-        } else {
-                lx = payload[0] & 0x3f;
-                ly = payload[0] & 0x3f;
-        }
-
-        rx = (payload[0] >> 3) & 0x14;
-        rx |= (payload[1] >> 5) & 0x06;
-        rx |= (payload[2] >> 7) & 0x01;
-        ry = payload[2] & 0x1f;
-
-        rt = payload[3] & 0x1f;
-        lt = (payload[2] >> 2) & 0x18;
-        lt |= (payload[3] >> 5) & 0x07;
-
-        rx <<= 1;
-        ry <<= 1;
-        rt <<= 1;
-        lt <<= 1;
-
-        input_report_abs(ext->input, ABS_HAT1X, lx - 0x20);
-        input_report_abs(ext->input, ABS_HAT1Y, ly - 0x20);
-        input_report_abs(ext->input, ABS_HAT2X, rx - 0x20);
-        input_report_abs(ext->input, ABS_HAT2Y, ry - 0x20);
-        input_report_abs(ext->input, ABS_HAT3X, rt - 0x20);
-        input_report_abs(ext->input, ABS_HAT3Y, lt - 0x20);
-
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_RIGHT],
-                                                        !!(payload[4] & 0x80));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_DOWN],
-                                                        !!(payload[4] & 0x40));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LT],
-                                                        !!(payload[4] & 0x20));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_MINUS],
-                                                        !!(payload[4] & 0x10));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_HOME],
-                                                        !!(payload[4] & 0x08));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_PLUS],
-                                                        !!(payload[4] & 0x04));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_RT],
-                                                        !!(payload[4] & 0x02));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_ZL],
-                                                        !!(payload[5] & 0x80));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_B],
-                                                        !!(payload[5] & 0x40));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_Y],
-                                                        !!(payload[5] & 0x20));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_A],
-                                                        !!(payload[5] & 0x10));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_X],
-                                                        !!(payload[5] & 0x08));
-        input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_ZR],
-                                                        !!(payload[5] & 0x04));
-
-        if (ext->motionp) {
-                input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_UP],
-                                                        !!(payload[0] & 0x01));
-                input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LEFT],
-                                                        !!(payload[1] & 0x01));
-        } else {
-                input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_UP],
-                                                        !!(payload[5] & 0x01));
-                input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LEFT],
-                                                        !!(payload[5] & 0x02));
-        }
-
-        input_sync(ext->input);
-}
-
-static void handler_balance_board(struct wiimote_ext *ext, const __u8 *payload)
-{
-        __s32 val[4], tmp;
-        unsigned int i;
-
-        /*   Byte |  8  7  6  5  4  3  2  1  |
-         *   -----+--------------------------+
-         *    1   |    Top Right <15:8>      |
-         *    2   |    Top Right  <7:0>      |
-         *   -----+--------------------------+
-         *    3   | Bottom Right <15:8>      |
-         *    4   | Bottom Right  <7:0>      |
-         *   -----+--------------------------+
-         *    5   |     Top Left <15:8>      |
-         *    6   |     Top Left  <7:0>      |
-         *   -----+--------------------------+
-         *    7   |  Bottom Left <15:8>      |
-         *    8   |  Bottom Left  <7:0>      |
-         *   -----+--------------------------+
-         *
-         * These values represent the weight-measurements of the Wii-balance
-         * board with 16bit precision.
-         *
-         * The balance-board is never reported interleaved with motionp.
-         */
-
-        val[0] = payload[0];
-        val[0] <<= 8;
-        val[0] |= payload[1];
-
-        val[1] = payload[2];
-        val[1] <<= 8;
-        val[1] |= payload[3];
-
-        val[2] = payload[4];
-        val[2] <<= 8;
-        val[2] |= payload[5];
-
-        val[3] = payload[6];
-        val[3] <<= 8;
-        val[3] |= payload[7];
-
-        /* apply calibration data */
-        for (i = 0; i < 4; i++) {
-                if (val[i] < ext->calib[i][1]) {
-                        tmp = val[i] - ext->calib[i][0];
-                        tmp *= 1700;
-                        tmp /= ext->calib[i][1] - ext->calib[i][0];
-                } else {
-                        tmp = val[i] - ext->calib[i][1];
-                        tmp *= 1700;
-                        tmp /= ext->calib[i][2] - ext->calib[i][1];
-                        tmp += 1700;
-                }
-                val[i] = tmp;
-        }
-
-        input_report_abs(ext->input, ABS_HAT0X, val[0]);
-        input_report_abs(ext->input, ABS_HAT0Y, val[1]);
-        input_report_abs(ext->input, ABS_HAT1X, val[2]);
-        input_report_abs(ext->input, ABS_HAT1Y, val[3]);
-
-        input_sync(ext->input);
-}
-
-/* call this with state.lock spinlock held */
-void wiiext_handle(struct wiimote_data *wdata, const __u8 *payload)
-{
-        struct wiimote_ext *ext = wdata->ext;
-
-        if (!ext)
-                return;
-
-        if (ext->motionp && (payload[5] & 0x02)) {
-                handler_motionp(ext, payload);
-        } else if (ext->ext_type == WIIEXT_NUNCHUCK) {
-                handler_nunchuck(ext, payload);
-        } else if (ext->ext_type == WIIEXT_CLASSIC) {
-                handler_classic(ext, payload);
-        } else if (ext->ext_type == WIIEXT_BALANCE_BOARD) {
-                handler_balance_board(ext, payload);
-        }
-}
-
-static ssize_t wiiext_show(struct device *dev, struct device_attribute *attr,
-                                                                char *buf)
-{
-        struct wiimote_data *wdata = dev_to_wii(dev);
-        __u8 type = WIIEXT_NONE;
-        bool motionp = false;
-        unsigned long flags;
-
-        spin_lock_irqsave(&wdata->state.lock, flags);
-        if (wdata->ext) {
-                motionp = wdata->ext->motionp;
-                type = wdata->ext->ext_type;
-        }
-        spin_unlock_irqrestore(&wdata->state.lock, flags);
-
-        if (type == WIIEXT_NUNCHUCK) {
-                if (motionp)
-                        return sprintf(buf, "motionp+nunchuck\n");
-                else
-                        return sprintf(buf, "nunchuck\n");
-        } else if (type == WIIEXT_CLASSIC) {
-                if (motionp)
-                        return sprintf(buf, "motionp+classic\n");
-                else
-                        return sprintf(buf, "classic\n");
-        } else if (type == WIIEXT_BALANCE_BOARD) {
-                if (motionp)
-                        return sprintf(buf, "motionp+balanceboard\n");
-                else
-                        return sprintf(buf, "balanceboard\n");
-        } else {
-                if (motionp)
-                        return sprintf(buf, "motionp\n");
-                else
-                        return sprintf(buf, "none\n");
-        }
-}
-
-static DEVICE_ATTR(extension, S_IRUGO, wiiext_show, NULL);
-
-static int wiiext_input_open(struct input_dev *dev)
-{
-        struct wiimote_ext *ext = input_get_drvdata(dev);
-        int ret;
-
-        ret = hid_hw_open(ext->wdata->hdev);
-        if (ret)
-                return ret;
-
-        atomic_inc(&ext->opened);
-        wiiext_schedule(ext);
-
-        return 0;
-}
-
-static void wiiext_input_close(struct input_dev *dev)
-{
-        struct wiimote_ext *ext = input_get_drvdata(dev);
-
-        atomic_dec(&ext->opened);
-        wiiext_schedule(ext);
-        hid_hw_close(ext->wdata->hdev);
-}
-
-static int wiiext_mp_open(struct input_dev *dev)
-{
-        struct wiimote_ext *ext = input_get_drvdata(dev);
-        int ret;
-
-        ret = hid_hw_open(ext->wdata->hdev);
-        if (ret)
-                return ret;
-
-        atomic_inc(&ext->mp_opened);
-        wiiext_schedule(ext);
-
-        return 0;
-}
-
-static void wiiext_mp_close(struct input_dev *dev)
-{
-        struct wiimote_ext *ext = input_get_drvdata(dev);
-
-        atomic_dec(&ext->mp_opened);
-        wiiext_schedule(ext);
-        hid_hw_close(ext->wdata->hdev);
-}
-
-/* Initializes the extension driver of a wiimote */
-int wiiext_init(struct wiimote_data *wdata)
-{
-        struct wiimote_ext *ext;
-        unsigned long flags;
-        int ret, i;
-
-        ext = kzalloc(sizeof(*ext), GFP_KERNEL);
-        if (!ext)
-                return -ENOMEM;
-
-        ext->wdata = wdata;
-        INIT_WORK(&ext->worker, wiiext_worker);
-
-        ext->input = input_allocate_device();
-        if (!ext->input) {
-                ret = -ENOMEM;
-                goto err_input;
-        }
-
-        input_set_drvdata(ext->input, ext);
-        ext->input->open = wiiext_input_open;
-        ext->input->close = wiiext_input_close;
-        ext->input->dev.parent = &wdata->hdev->dev;
-        ext->input->id.bustype = wdata->hdev->bus;
-        ext->input->id.vendor = wdata->hdev->vendor;
-        ext->input->id.product = wdata->hdev->product;
-        ext->input->id.version = wdata->hdev->version;
-        ext->input->name = WIIMOTE_NAME " Extension";
-
-        set_bit(EV_KEY, ext->input->evbit);
-        for (i = 0; i < WIIEXT_KEY_COUNT; ++i)
-                set_bit(wiiext_keymap[i], ext->input->keybit);
-
-        set_bit(EV_ABS, ext->input->evbit);
-        set_bit(ABS_HAT0X, ext->input->absbit);
-        set_bit(ABS_HAT0Y, ext->input->absbit);
-        set_bit(ABS_HAT1X, ext->input->absbit);
-        set_bit(ABS_HAT1Y, ext->input->absbit);
-        set_bit(ABS_HAT2X, ext->input->absbit);
-        set_bit(ABS_HAT2Y, ext->input->absbit);
-        set_bit(ABS_HAT3X, ext->input->absbit);
-        set_bit(ABS_HAT3Y, ext->input->absbit);
-        input_set_abs_params(ext->input, ABS_HAT0X, -120, 120, 2, 4);
-        input_set_abs_params(ext->input, ABS_HAT0Y, -120, 120, 2, 4);
-        input_set_abs_params(ext->input, ABS_HAT1X, -30, 30, 1, 1);
-        input_set_abs_params(ext->input, ABS_HAT1Y, -30, 30, 1, 1);
-        input_set_abs_params(ext->input, ABS_HAT2X, -30, 30, 1, 1);
-        input_set_abs_params(ext->input, ABS_HAT2Y, -30, 30, 1, 1);
-        input_set_abs_params(ext->input, ABS_HAT3X, -30, 30, 1, 1);
-        input_set_abs_params(ext->input, ABS_HAT3Y, -30, 30, 1, 1);
-        set_bit(ABS_RX, ext->input->absbit);
-        set_bit(ABS_RY, ext->input->absbit);
-        set_bit(ABS_RZ, ext->input->absbit);
-        input_set_abs_params(ext->input, ABS_RX, -500, 500, 2, 4);
-        input_set_abs_params(ext->input, ABS_RY, -500, 500, 2, 4);
-        input_set_abs_params(ext->input, ABS_RZ, -500, 500, 2, 4);
-
-        ret = input_register_device(ext->input);
-        if (ret) {
-                input_free_device(ext->input);
-                goto err_input;
-        }
-
-        ext->mp_input = input_allocate_device();
-        if (!ext->mp_input) {
-                ret = -ENOMEM;
-                goto err_mp;
-        }
-
-        input_set_drvdata(ext->mp_input, ext);
-        ext->mp_input->open = wiiext_mp_open;
-        ext->mp_input->close = wiiext_mp_close;
-        ext->mp_input->dev.parent = &wdata->hdev->dev;
-        ext->mp_input->id.bustype = wdata->hdev->bus;
-        ext->mp_input->id.vendor = wdata->hdev->vendor;
-        ext->mp_input->id.product = wdata->hdev->product;
-        ext->mp_input->id.version = wdata->hdev->version;
-        ext->mp_input->name = WIIMOTE_NAME " Motion+";
-
-        set_bit(EV_ABS, ext->mp_input->evbit);
-        set_bit(ABS_RX, ext->mp_input->absbit);
-        set_bit(ABS_RY, ext->mp_input->absbit);
-        set_bit(ABS_RZ, ext->mp_input->absbit);
-        input_set_abs_params(ext->mp_input, ABS_RX, -160000, 160000, 4, 8);
-        input_set_abs_params(ext->mp_input, ABS_RY, -160000, 160000, 4, 8);
-        input_set_abs_params(ext->mp_input, ABS_RZ, -160000, 160000, 4, 8);
-
-        ret = input_register_device(ext->mp_input);
-        if (ret) {
-                input_free_device(ext->mp_input);
-                goto err_mp;
-        }
-
-        ret = device_create_file(&wdata->hdev->dev, &dev_attr_extension);
-        if (ret)
-                goto err_dev;
-
-        spin_lock_irqsave(&wdata->state.lock, flags);
-        wdata->ext = ext;
-        spin_unlock_irqrestore(&wdata->state.lock, flags);
-
-        return 0;
-
-err_dev:
-        input_unregister_device(ext->mp_input);
-err_mp:
-        input_unregister_device(ext->input);
-err_input:
-        kfree(ext);
-        return ret;
-}
-
-/* Deinitializes the extension driver of a wiimote */
-void wiiext_deinit(struct wiimote_data *wdata)
-{
-        struct wiimote_ext *ext = wdata->ext;
-        unsigned long flags;
-
-        if (!ext)
-                return;
-
-        /*
-         * We first unset wdata->ext to avoid further input from the wiimote
-         * core. The worker thread does not access this pointer so it is not
-         * affected by this.
-         * We kill the worker after this so it does not get respawned during
-         * deinitialization.
-         */
-
-        spin_lock_irqsave(&wdata->state.lock, flags);
-        wdata->ext = NULL;
-        spin_unlock_irqrestore(&wdata->state.lock, flags);
-
-        device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
-        input_unregister_device(ext->mp_input);
-        input_unregister_device(ext->input);
-
-        cancel_work_sync(&ext->worker);
-        kfree(ext);
-}
diff --git a/drivers/hid/hid-wiimote-modules.c b/drivers/hid/hid-wiimote-modules.c
new file mode 100644
index 000000000000..2e7d644dba18
--- /dev/null
+++ b/drivers/hid/hid-wiimote-modules.c
@@ -0,0 +1,2086 @@
+/*
+ * Device Modules for Nintendo Wii / Wii U HID Driver
+ * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+/*
+ * Wiimote Modules
+ * Nintendo devices provide different peripherals and many new devices lack
+ * initial features like the IR camera. Therefore, each peripheral device is
+ * implemented as an independent module and we probe on each device only the
+ * modules for the hardware that really is available.
+ *
+ * Module registration is sequential. Unregistration is done in reverse order.
+ * After device detection, the needed modules are loaded. Users can trigger
+ * re-detection which causes all modules to be unloaded and then reload the
+ * modules for the new detected device.
+ *
+ * wdata->input is a shared input device. It is always initialized prior to
+ * module registration. If at least one registered module is marked as
+ * WIIMOD_FLAG_INPUT, then the input device will get registered after all
+ * modules were registered.
+ * Please note that it is unregistered _before_ the "remove" callbacks are
+ * called. This guarantees that no input interaction is done, anymore. However,
+ * the wiimote core keeps a reference to the input device so it is freed only
+ * after all modules were removed. It is safe to send events to unregistered
+ * input devices.
+ */
+
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/input.h>
+#include <linux/spinlock.h>
+#include "hid-wiimote.h"
+
+/*
+ * Keys
+ * The initial Wii Remote provided a bunch of buttons that are reported as
+ * part of the core protocol. Many later devices dropped these and report
+ * invalid data in the core button reports. Load this only on devices which
+ * correctly send button reports.
+ * It uses the shared input device.
+ */
+
+static const __u16 wiimod_keys_map[] = {
+        KEY_LEFT,       /* WIIPROTO_KEY_LEFT */
+        KEY_RIGHT,      /* WIIPROTO_KEY_RIGHT */
+        KEY_UP,         /* WIIPROTO_KEY_UP */
+        KEY_DOWN,       /* WIIPROTO_KEY_DOWN */
+        KEY_NEXT,       /* WIIPROTO_KEY_PLUS */
+        KEY_PREVIOUS,   /* WIIPROTO_KEY_MINUS */
+        BTN_1,          /* WIIPROTO_KEY_ONE */
+        BTN_2,          /* WIIPROTO_KEY_TWO */
+        BTN_A,          /* WIIPROTO_KEY_A */
+        BTN_B,          /* WIIPROTO_KEY_B */
+        BTN_MODE,       /* WIIPROTO_KEY_HOME */
+};
+
+static void wiimod_keys_in_keys(struct wiimote_data *wdata, const __u8 *keys)
+{
+        input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_LEFT],
+                                                        !!(keys[0] & 0x01));
+        input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_RIGHT],
+                                                        !!(keys[0] & 0x02));
+        input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_DOWN],
+                                                        !!(keys[0] & 0x04));
+        input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_UP],
+                                                        !!(keys[0] & 0x08));
+        input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_PLUS],
+                                                        !!(keys[0] & 0x10));
+        input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_TWO],
+                                                        !!(keys[1] & 0x01));
+        input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_ONE],
+                                                        !!(keys[1] & 0x02));
+        input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_B],
+                                                        !!(keys[1] & 0x04));
+        input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_A],
+                                                        !!(keys[1] & 0x08));
+        input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_MINUS],
+                                                        !!(keys[1] & 0x10));
+        input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_HOME],
+                                                        !!(keys[1] & 0x80));
+        input_sync(wdata->input);
+}
+
+static int wiimod_keys_probe(const struct wiimod_ops *ops,
+                             struct wiimote_data *wdata)
+{
+        unsigned int i;
+
+        set_bit(EV_KEY, wdata->input->evbit);
+        for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
+                set_bit(wiimod_keys_map[i], wdata->input->keybit);
+
+        return 0;
+}
+
+static const struct wiimod_ops wiimod_keys = {
+        .flags = WIIMOD_FLAG_INPUT,
+        .arg = 0,
+        .probe = wiimod_keys_probe,
+        .remove = NULL,
+        .in_keys = wiimod_keys_in_keys,
+};
+
+/*
+ * Rumble
+ * Nearly all devices provide a rumble feature. A small motor for
+ * force-feedback effects. We provide an FF_RUMBLE memless ff device on the
+ * shared input device if this module is loaded.
+ * The rumble motor is controlled via a flag on almost every output report so
+ * the wiimote core handles the rumble flag. But if a device doesn't provide
+ * the rumble motor, this flag shouldn't be set.
+ */
+
+static int wiimod_rumble_play(struct input_dev *dev, void *data,
+                              struct ff_effect *eff)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        __u8 value;
+        unsigned long flags;
+
+        /*
+         * The wiimote supports only a single rumble motor so if any magnitude
+         * is set to non-zero then we start the rumble motor. If both are set to
+         * zero, we stop the rumble motor.
+         */
+
+        if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)
+                value = 1;
+        else
+                value = 0;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wiiproto_req_rumble(wdata, value);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        return 0;
+}
+
+static int wiimod_rumble_probe(const struct wiimod_ops *ops,
+                               struct wiimote_data *wdata)
+{
+        set_bit(FF_RUMBLE, wdata->input->ffbit);
+        if (input_ff_create_memless(wdata->input, NULL, wiimod_rumble_play))
+                return -ENOMEM;
+
+        return 0;
+}
+
+static void wiimod_rumble_remove(const struct wiimod_ops *ops,
+                                 struct wiimote_data *wdata)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wiiproto_req_rumble(wdata, 0);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+}
+
+static const struct wiimod_ops wiimod_rumble = {
+        .flags = WIIMOD_FLAG_INPUT,
+        .arg = 0,
+        .probe = wiimod_rumble_probe,
+        .remove = wiimod_rumble_remove,
+};
+
+/*
+ * Battery
+ * 1 byte of battery capacity information is sent along every protocol status
+ * report. The wiimote core caches it but we try to update it on every
+ * user-space request.
+ * This is supported by nearly every device so it's almost always enabled.
+ */
+
+static enum power_supply_property wiimod_battery_props[] = {
+        POWER_SUPPLY_PROP_CAPACITY,
+        POWER_SUPPLY_PROP_SCOPE,
+};
+
+static int wiimod_battery_get_property(struct power_supply *psy,
+                                       enum power_supply_property psp,
+                                       union power_supply_propval *val)
+{
+        struct wiimote_data *wdata = container_of(psy, struct wiimote_data,
+                                                  battery);
+        int ret = 0, state;
+        unsigned long flags;
+
+        if (psp == POWER_SUPPLY_PROP_SCOPE) {
+                val->intval = POWER_SUPPLY_SCOPE_DEVICE;
+                return 0;
+        } else if (psp != POWER_SUPPLY_PROP_CAPACITY) {
+                return -EINVAL;
+        }
+
+        ret = wiimote_cmd_acquire(wdata);
+        if (ret)
+                return ret;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
+        wiiproto_req_status(wdata);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        wiimote_cmd_wait(wdata);
+        wiimote_cmd_release(wdata);
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        state = wdata->state.cmd_battery;
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        val->intval = state * 100 / 255;
+        return ret;
+}
+
+static int wiimod_battery_probe(const struct wiimod_ops *ops,
+                                struct wiimote_data *wdata)
+{
+        int ret;
+
+        wdata->battery.properties = wiimod_battery_props;
+        wdata->battery.num_properties = ARRAY_SIZE(wiimod_battery_props);
+        wdata->battery.get_property = wiimod_battery_get_property;
+        wdata->battery.type = POWER_SUPPLY_TYPE_BATTERY;
+        wdata->battery.use_for_apm = 0;
+        wdata->battery.name = kasprintf(GFP_KERNEL, "wiimote_battery_%s",
+                                        wdata->hdev->uniq);
+        if (!wdata->battery.name)
+                return -ENOMEM;
+
+        ret = power_supply_register(&wdata->hdev->dev, &wdata->battery);
+        if (ret) {
+                hid_err(wdata->hdev, "cannot register battery device\n");
+                goto err_free;
+        }
+
+        power_supply_powers(&wdata->battery, &wdata->hdev->dev);
+        return 0;
+
+err_free:
+        kfree(wdata->battery.name);
+        wdata->battery.name = NULL;
+        return ret;
+}
+
+static void wiimod_battery_remove(const struct wiimod_ops *ops,
+                                  struct wiimote_data *wdata)
+{
+        if (!wdata->battery.name)
+                return;
+
+        power_supply_unregister(&wdata->battery);
+        kfree(wdata->battery.name);
+        wdata->battery.name = NULL;
+}
+
+static const struct wiimod_ops wiimod_battery = {
+        .flags = 0,
+        .arg = 0,
+        .probe = wiimod_battery_probe,
+        .remove = wiimod_battery_remove,
+};
+
+/*
+ * LED
+ * 0 to 4 player LEDs are supported by devices. The "arg" field of the
+ * wiimod_ops structure specifies which LED this module controls. This allows
+ * to register a limited number of LEDs.
+ * State is managed by wiimote core.
+ */
+
+static enum led_brightness wiimod_led_get(struct led_classdev *led_dev)
+{
+        struct wiimote_data *wdata;
+        struct device *dev = led_dev->dev->parent;
+        int i;
+        unsigned long flags;
+        bool value = false;
+
+        wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
+
+        for (i = 0; i < 4; ++i) {
+                if (wdata->leds[i] == led_dev) {
+                        spin_lock_irqsave(&wdata->state.lock, flags);
+                        value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
+                        spin_unlock_irqrestore(&wdata->state.lock, flags);
+                        break;
+                }
+        }
+
+        return value ? LED_FULL : LED_OFF;
+}
+
+static void wiimod_led_set(struct led_classdev *led_dev,
+                           enum led_brightness value)
+{
+        struct wiimote_data *wdata;
+        struct device *dev = led_dev->dev->parent;
+        int i;
+        unsigned long flags;
+        __u8 state, flag;
+
+        wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
+
+        for (i = 0; i < 4; ++i) {
+                if (wdata->leds[i] == led_dev) {
+                        flag = WIIPROTO_FLAG_LED(i + 1);
+                        spin_lock_irqsave(&wdata->state.lock, flags);
+                        state = wdata->state.flags;
+                        if (value == LED_OFF)
+                                wiiproto_req_leds(wdata, state & ~flag);
+                        else
+                                wiiproto_req_leds(wdata, state | flag);
+                        spin_unlock_irqrestore(&wdata->state.lock, flags);
+                        break;
+                }
+        }
+}
+
+static int wiimod_led_probe(const struct wiimod_ops *ops,
+                            struct wiimote_data *wdata)
+{
+        struct device *dev = &wdata->hdev->dev;
+        size_t namesz = strlen(dev_name(dev)) + 9;
+        struct led_classdev *led;
+        unsigned long flags;
+        char *name;
+        int ret;
+
+        led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
+        if (!led)
+                return -ENOMEM;
+
+        name = (void*)&led[1];
+        snprintf(name, namesz, "%s:blue:p%lu", dev_name(dev), ops->arg);
+        led->name = name;
+        led->brightness = 0;
+        led->max_brightness = 1;
+        led->brightness_get = wiimod_led_get;
+        led->brightness_set = wiimod_led_set;
+
+        wdata->leds[ops->arg] = led;
+        ret = led_classdev_register(dev, led);
+        if (ret)
+                goto err_free;
+
+        /* enable LED1 to stop initial LED-blinking */
+        if (ops->arg == 0) {
+                spin_lock_irqsave(&wdata->state.lock, flags);
+                wiiproto_req_leds(wdata, WIIPROTO_FLAG_LED1);
+                spin_unlock_irqrestore(&wdata->state.lock, flags);
+        }
+
+        return 0;
+
+err_free:
+        wdata->leds[ops->arg] = NULL;
+        kfree(led);
+        return ret;
+}
+
+static void wiimod_led_remove(const struct wiimod_ops *ops,
+                              struct wiimote_data *wdata)
+{
+        if (!wdata->leds[ops->arg])
+                return;
+
+        led_classdev_unregister(wdata->leds[ops->arg]);
+        kfree(wdata->leds[ops->arg]);
+        wdata->leds[ops->arg] = NULL;
+}
+
+static const struct wiimod_ops wiimod_leds[4] = {
+        {
+                .flags = 0,
+                .arg = 0,
+                .probe = wiimod_led_probe,
+                .remove = wiimod_led_remove,
+        },
+        {
+                .flags = 0,
+                .arg = 1,
+                .probe = wiimod_led_probe,
+                .remove = wiimod_led_remove,
+        },
+        {
+                .flags = 0,
+                .arg = 2,
+                .probe = wiimod_led_probe,
+                .remove = wiimod_led_remove,
+        },
+        {
+                .flags = 0,
+                .arg = 3,
+                .probe = wiimod_led_probe,
+                .remove = wiimod_led_remove,
+        },
+};
+
+/*
+ * Accelerometer
+ * 3 axis accelerometer data is part of nearly all DRMs. If not supported by a
+ * device, it's mostly cleared to 0. This module parses this data and provides
+ * it via a separate input device.
+ */
+
+static void wiimod_accel_in_accel(struct wiimote_data *wdata,
+                                  const __u8 *accel)
+{
+        __u16 x, y, z;
+
+        if (!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
+                return;
+
+        /*
+         * payload is: BB BB XX YY ZZ
+         * Accelerometer data is encoded into 3 10bit values. XX, YY and ZZ
+         * contain the upper 8 bits of each value. The lower 2 bits are
+         * contained in the buttons data BB BB.
+         * Bits 6 and 7 of the first buttons byte BB is the lower 2 bits of the
+         * X accel value. Bit 5 of the second buttons byte is the 2nd bit of Y
+         * accel value and bit 6 is the second bit of the Z value.
+         * The first bit of Y and Z values is not available and always set to 0.
+         * 0x200 is returned on no movement.
+         */
+
+        x = accel[2] << 2;
+        y = accel[3] << 2;
+        z = accel[4] << 2;
+
+        x |= (accel[0] >> 5) & 0x3;
+        y |= (accel[1] >> 4) & 0x2;
+        z |= (accel[1] >> 5) & 0x2;
+
+        input_report_abs(wdata->accel, ABS_RX, x - 0x200);
+        input_report_abs(wdata->accel, ABS_RY, y - 0x200);
+        input_report_abs(wdata->accel, ABS_RZ, z - 0x200);
+        input_sync(wdata->accel);
+}
+
+static int wiimod_accel_open(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wiiproto_req_accel(wdata, true);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        return 0;
+}
+
+static void wiimod_accel_close(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wiiproto_req_accel(wdata, false);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+}
+
+static int wiimod_accel_probe(const struct wiimod_ops *ops,
+                              struct wiimote_data *wdata)
+{
+        int ret;
+
+        wdata->accel = input_allocate_device();
+        if (!wdata->accel)
+                return -ENOMEM;
+
+        input_set_drvdata(wdata->accel, wdata);
+        wdata->accel->open = wiimod_accel_open;
+        wdata->accel->close = wiimod_accel_close;
+        wdata->accel->dev.parent = &wdata->hdev->dev;
+        wdata->accel->id.bustype = wdata->hdev->bus;
+        wdata->accel->id.vendor = wdata->hdev->vendor;
+        wdata->accel->id.product = wdata->hdev->product;
+        wdata->accel->id.version = wdata->hdev->version;
+        wdata->accel->name = WIIMOTE_NAME " Accelerometer";
+
+        set_bit(EV_ABS, wdata->accel->evbit);
+        set_bit(ABS_RX, wdata->accel->absbit);
+        set_bit(ABS_RY, wdata->accel->absbit);
+        set_bit(ABS_RZ, wdata->accel->absbit);
+        input_set_abs_params(wdata->accel, ABS_RX, -500, 500, 2, 4);
+        input_set_abs_params(wdata->accel, ABS_RY, -500, 500, 2, 4);
+        input_set_abs_params(wdata->accel, ABS_RZ, -500, 500, 2, 4);
+
+        ret = input_register_device(wdata->accel);
+        if (ret) {
+                hid_err(wdata->hdev, "cannot register input device\n");
+                goto err_free;
+        }
+
+        return 0;
+
+err_free:
+        input_free_device(wdata->accel);
+        wdata->accel = NULL;
+        return ret;
+}
+
+static void wiimod_accel_remove(const struct wiimod_ops *ops,
+                                struct wiimote_data *wdata)
+{
+        if (!wdata->accel)
+                return;
+
+        input_unregister_device(wdata->accel);
+        wdata->accel = NULL;
+}
+
+static const struct wiimod_ops wiimod_accel = {
+        .flags = 0,
+        .arg = 0,
+        .probe = wiimod_accel_probe,
+        .remove = wiimod_accel_remove,
+        .in_accel = wiimod_accel_in_accel,
+};
+
+/*
+ * IR Cam
+ * Up to 4 IR sources can be tracked by a normal Wii Remote. The IR cam needs
+ * to be initialized with a fairly complex procedure and consumes a lot of
+ * power. Therefore, as long as no application uses the IR input device, it is
+ * kept offline.
+ * Nearly no other device than the normal Wii Remotes supports the IR cam so
+ * you can disable this module for these devices.
+ */
+
+static void wiimod_ir_in_ir(struct wiimote_data *wdata, const __u8 *ir,
+                            bool packed, unsigned int id)
+{
+        __u16 x, y;
+        __u8 xid, yid;
+        bool sync = false;
+
+        if (!(wdata->state.flags & WIIPROTO_FLAGS_IR))
+                return;
+
+        switch (id) {
+        case 0:
+                xid = ABS_HAT0X;
+                yid = ABS_HAT0Y;
+                break;
+        case 1:
+                xid = ABS_HAT1X;
+                yid = ABS_HAT1Y;
+                break;
+        case 2:
+                xid = ABS_HAT2X;
+                yid = ABS_HAT2Y;
+                break;
+        case 3:
+                xid = ABS_HAT3X;
+                yid = ABS_HAT3Y;
+                sync = true;
+                break;
+        default:
+                return;
+        }
+
+        /*
+         * Basic IR data is encoded into 3 bytes. The first two bytes are the
+         * lower 8 bit of the X/Y data, the 3rd byte contains the upper 2 bits
+         * of both.
+         * If data is packed, then the 3rd byte is put first and slightly
+         * reordered. This allows to interleave packed and non-packed data to
+         * have two IR sets in 5 bytes instead of 6.
+         * The resulting 10bit X/Y values are passed to the ABS_HAT? input dev.
+         */
+
+        if (packed) {
+                x = ir[1] | ((ir[0] & 0x03) << 8);
+                y = ir[2] | ((ir[0] & 0x0c) << 6);
+        } else {
+                x = ir[0] | ((ir[2] & 0x30) << 4);
+                y = ir[1] | ((ir[2] & 0xc0) << 2);
+        }
+
+        input_report_abs(wdata->ir, xid, x);
+        input_report_abs(wdata->ir, yid, y);
+
+        if (sync)
+                input_sync(wdata->ir);
+}
+
+static int wiimod_ir_change(struct wiimote_data *wdata, __u16 mode)
+{
+        int ret;
+        unsigned long flags;
+        __u8 format = 0;
+        static const __u8 data_enable[] = { 0x01 };
+        static const __u8 data_sens1[] = { 0x02, 0x00, 0x00, 0x71, 0x01,
+                                                0x00, 0xaa, 0x00, 0x64 };
+        static const __u8 data_sens2[] = { 0x63, 0x03 };
+        static const __u8 data_fin[] = { 0x08 };
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+
+        if (mode == (wdata->state.flags & WIIPROTO_FLAGS_IR)) {
+                spin_unlock_irqrestore(&wdata->state.lock, flags);
+                return 0;
+        }
+
+        if (mode == 0) {
+                wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
+                wiiproto_req_ir1(wdata, 0);
+                wiiproto_req_ir2(wdata, 0);
+                wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+                spin_unlock_irqrestore(&wdata->state.lock, flags);
+                return 0;
+        }
+
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        ret = wiimote_cmd_acquire(wdata);
+        if (ret)
+                return ret;
+
+        /* send PIXEL CLOCK ENABLE cmd first */
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wiimote_cmd_set(wdata, WIIPROTO_REQ_IR1, 0);
+        wiiproto_req_ir1(wdata, 0x06);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        ret = wiimote_cmd_wait(wdata);
+        if (ret)
+                goto unlock;
+        if (wdata->state.cmd_err) {
+                ret = -EIO;
+                goto unlock;
+        }
+
+        /* enable IR LOGIC */
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wiimote_cmd_set(wdata, WIIPROTO_REQ_IR2, 0);
+        wiiproto_req_ir2(wdata, 0x06);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        ret = wiimote_cmd_wait(wdata);
+        if (ret)
+                goto unlock;
+        if (wdata->state.cmd_err) {
+                ret = -EIO;
+                goto unlock;
+        }
+
+        /* enable IR cam but do not make it send data, yet */
+        ret = wiimote_cmd_write(wdata, 0xb00030, data_enable,
+                                                        sizeof(data_enable));
+        if (ret)
+                goto unlock;
+
+        /* write first sensitivity block */
+        ret = wiimote_cmd_write(wdata, 0xb00000, data_sens1,
+                                                        sizeof(data_sens1));
+        if (ret)
+                goto unlock;
+
+        /* write second sensitivity block */
+        ret = wiimote_cmd_write(wdata, 0xb0001a, data_sens2,
+                                                        sizeof(data_sens2));
+        if (ret)
+                goto unlock;
+
+        /* put IR cam into desired state */
+        switch (mode) {
+                case WIIPROTO_FLAG_IR_FULL:
+                        format = 5;
+                        break;
+                case WIIPROTO_FLAG_IR_EXT:
+                        format = 3;
+                        break;
+                case WIIPROTO_FLAG_IR_BASIC:
+                        format = 1;
+                        break;
+        }
+        ret = wiimote_cmd_write(wdata, 0xb00033, &format, sizeof(format));
+        if (ret)
+                goto unlock;
+
+        /* make IR cam send data */
+        ret = wiimote_cmd_write(wdata, 0xb00030, data_fin, sizeof(data_fin));
+        if (ret)
+                goto unlock;
+
+        /* request new DRM mode compatible to IR mode */
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
+        wdata->state.flags |= mode & WIIPROTO_FLAGS_IR;
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+unlock:
+        wiimote_cmd_release(wdata);
+        return ret;
+}
+
+static int wiimod_ir_open(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+
+        return wiimod_ir_change(wdata, WIIPROTO_FLAG_IR_BASIC);
+}
+
+static void wiimod_ir_close(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+
+        wiimod_ir_change(wdata, 0);
+}
+
+static int wiimod_ir_probe(const struct wiimod_ops *ops,
+                           struct wiimote_data *wdata)
+{
+        int ret;
+
+        wdata->ir = input_allocate_device();
+        if (!wdata->ir)
+                return -ENOMEM;
+
+        input_set_drvdata(wdata->ir, wdata);
+        wdata->ir->open = wiimod_ir_open;
+        wdata->ir->close = wiimod_ir_close;
+        wdata->ir->dev.parent = &wdata->hdev->dev;
+        wdata->ir->id.bustype = wdata->hdev->bus;
+        wdata->ir->id.vendor = wdata->hdev->vendor;
+        wdata->ir->id.product = wdata->hdev->product;
+        wdata->ir->id.version = wdata->hdev->version;
+        wdata->ir->name = WIIMOTE_NAME " IR";
+
+        set_bit(EV_ABS, wdata->ir->evbit);
+        set_bit(ABS_HAT0X, wdata->ir->absbit);
+        set_bit(ABS_HAT0Y, wdata->ir->absbit);
+        set_bit(ABS_HAT1X, wdata->ir->absbit);
+        set_bit(ABS_HAT1Y, wdata->ir->absbit);
+        set_bit(ABS_HAT2X, wdata->ir->absbit);
+        set_bit(ABS_HAT2Y, wdata->ir->absbit);
+        set_bit(ABS_HAT3X, wdata->ir->absbit);
+        set_bit(ABS_HAT3Y, wdata->ir->absbit);
+        input_set_abs_params(wdata->ir, ABS_HAT0X, 0, 1023, 2, 4);
+        input_set_abs_params(wdata->ir, ABS_HAT0Y, 0, 767, 2, 4);
+        input_set_abs_params(wdata->ir, ABS_HAT1X, 0, 1023, 2, 4);
+        input_set_abs_params(wdata->ir, ABS_HAT1Y, 0, 767, 2, 4);
+        input_set_abs_params(wdata->ir, ABS_HAT2X, 0, 1023, 2, 4);
+        input_set_abs_params(wdata->ir, ABS_HAT2Y, 0, 767, 2, 4);
+        input_set_abs_params(wdata->ir, ABS_HAT3X, 0, 1023, 2, 4);
+        input_set_abs_params(wdata->ir, ABS_HAT3Y, 0, 767, 2, 4);
+
+        ret = input_register_device(wdata->ir);
+        if (ret) {
+                hid_err(wdata->hdev, "cannot register input device\n");
+                goto err_free;
+        }
+
+        return 0;
+
+err_free:
+        input_free_device(wdata->ir);
+        wdata->ir = NULL;
+        return ret;
+}
+
+static void wiimod_ir_remove(const struct wiimod_ops *ops,
+                             struct wiimote_data *wdata)
+{
+        if (!wdata->ir)
+                return;
+
+        input_unregister_device(wdata->ir);
+        wdata->ir = NULL;
+}
+
+static const struct wiimod_ops wiimod_ir = {
+        .flags = 0,
+        .arg = 0,
+        .probe = wiimod_ir_probe,
+        .remove = wiimod_ir_remove,
+        .in_ir = wiimod_ir_in_ir,
+};
+
+/*
+ * Nunchuk Extension
+ * The Nintendo Wii Nunchuk was the first official extension published by
+ * Nintendo. It provides two additional keys and a separate accelerometer. It
+ * can be hotplugged to standard Wii Remotes.
+ */
+
+enum wiimod_nunchuk_keys {
+        WIIMOD_NUNCHUK_KEY_C,
+        WIIMOD_NUNCHUK_KEY_Z,
+        WIIMOD_NUNCHUK_KEY_NUM,
+};
+
+static const __u16 wiimod_nunchuk_map[] = {
+        BTN_C,          /* WIIMOD_NUNCHUK_KEY_C */
+        BTN_Z,          /* WIIMOD_NUNCHUK_KEY_Z */
+};
+
+static void wiimod_nunchuk_in_ext(struct wiimote_data *wdata, const __u8 *ext)
+{
+        __s16 x, y, z, bx, by;
+
+        /*   Byte |   8    7 |  6    5 |  4    3 |  2 |  1  |
+         *   -----+----------+---------+---------+----+-----+
+         *    1   |              Button X <7:0>             |
+         *    2   |              Button Y <7:0>             |
+         *   -----+----------+---------+---------+----+-----+
+         *    3   |               Speed X <9:2>             |
+         *    4   |               Speed Y <9:2>             |
+         *    5   |               Speed Z <9:2>             |
+         *   -----+----------+---------+---------+----+-----+
+         *    6   | Z <1:0>  | Y <1:0> | X <1:0> | BC | BZ  |
+         *   -----+----------+---------+---------+----+-----+
+         * Button X/Y is the analog stick. Speed X, Y and Z are the
+         * accelerometer data in the same format as the wiimote's accelerometer.
+         * The 6th byte contains the LSBs of the accelerometer data.
+         * BC and BZ are the C and Z buttons: 0 means pressed
+         *
+         * If reported interleaved with motionp, then the layout changes. The
+         * 5th and 6th byte changes to:
+         *   -----+-----------------------------------+-----+
+         *    5   |            Speed Z <9:3>          | EXT |
+         *   -----+--------+-----+-----+----+----+----+-----+
+         *    6   |Z <2:1> |Y <1>|X <1>| BC | BZ | 0  |  0  |
+         *   -----+--------+-----+-----+----+----+----+-----+
+         * All three accelerometer values lose their LSB. The other data is
+         * still available but slightly moved.
+         *
+         * Center data for button values is 128. Center value for accelerometer
+         * values it 512 / 0x200
+         */
+
+        bx = ext[0];
+        by = ext[1];
+        bx -= 128;
+        by -= 128;
+
+        x = ext[2] << 2;
+        y = ext[3] << 2;
+        z = ext[4] << 2;
+
+        if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
+                x |= (ext[5] >> 3) & 0x02;
+                y |= (ext[5] >> 4) & 0x02;
+                z &= ~0x4;
+                z |= (ext[5] >> 5) & 0x06;
+        } else {
+                x |= (ext[5] >> 2) & 0x03;
+                y |= (ext[5] >> 4) & 0x03;
+                z |= (ext[5] >> 6) & 0x03;
+        }
+
+        x -= 0x200;
+        y -= 0x200;
+        z -= 0x200;
+
+        input_report_abs(wdata->extension.input, ABS_HAT0X, bx);
+        input_report_abs(wdata->extension.input, ABS_HAT0Y, by);
+
+        input_report_abs(wdata->extension.input, ABS_RX, x);
+        input_report_abs(wdata->extension.input, ABS_RY, y);
+        input_report_abs(wdata->extension.input, ABS_RZ, z);
+
+        if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
+                input_report_key(wdata->extension.input,
+                        wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_Z],
+                        !(ext[5] & 0x04));
+                input_report_key(wdata->extension.input,
+                        wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_C],
+                        !(ext[5] & 0x08));
+        } else {
+                input_report_key(wdata->extension.input,
+                        wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_Z],
+                        !(ext[5] & 0x01));
+                input_report_key(wdata->extension.input,
+                        wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_C],
+                        !(ext[5] & 0x02));
+        }
+
+        input_sync(wdata->extension.input);
+}
+
+static int wiimod_nunchuk_open(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        return 0;
+}
+
+static void wiimod_nunchuk_close(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+}
+
+static int wiimod_nunchuk_probe(const struct wiimod_ops *ops,
+                                struct wiimote_data *wdata)
+{
+        int ret, i;
+
+        wdata->extension.input = input_allocate_device();
+        if (!wdata->extension.input)
+                return -ENOMEM;
+
+        input_set_drvdata(wdata->extension.input, wdata);
+        wdata->extension.input->open = wiimod_nunchuk_open;
+        wdata->extension.input->close = wiimod_nunchuk_close;
+        wdata->extension.input->dev.parent = &wdata->hdev->dev;
+        wdata->extension.input->id.bustype = wdata->hdev->bus;
+        wdata->extension.input->id.vendor = wdata->hdev->vendor;
+        wdata->extension.input->id.product = wdata->hdev->product;
+        wdata->extension.input->id.version = wdata->hdev->version;
+        wdata->extension.input->name = WIIMOTE_NAME " Nunchuk";
+
+        set_bit(EV_KEY, wdata->extension.input->evbit);
+        for (i = 0; i < WIIMOD_NUNCHUK_KEY_NUM; ++i)
+                set_bit(wiimod_nunchuk_map[i],
+                        wdata->extension.input->keybit);
+
+        set_bit(EV_ABS, wdata->extension.input->evbit);
+        set_bit(ABS_HAT0X, wdata->extension.input->absbit);
+        set_bit(ABS_HAT0Y, wdata->extension.input->absbit);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT0X, -120, 120, 2, 4);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT0Y, -120, 120, 2, 4);
+        set_bit(ABS_RX, wdata->extension.input->absbit);
+        set_bit(ABS_RY, wdata->extension.input->absbit);
+        set_bit(ABS_RZ, wdata->extension.input->absbit);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_RX, -500, 500, 2, 4);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_RY, -500, 500, 2, 4);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_RZ, -500, 500, 2, 4);
+
+        ret = input_register_device(wdata->extension.input);
+        if (ret)
+                goto err_free;
+
+        return 0;
+
+err_free:
+        input_free_device(wdata->extension.input);
+        wdata->extension.input = NULL;
+        return ret;
+}
+
+static void wiimod_nunchuk_remove(const struct wiimod_ops *ops,
+                                  struct wiimote_data *wdata)
+{
+        if (!wdata->extension.input)
+                return;
+
+        input_unregister_device(wdata->extension.input);
+        wdata->extension.input = NULL;
+}
+
+static const struct wiimod_ops wiimod_nunchuk = {
+        .flags = 0,
+        .arg = 0,
+        .probe = wiimod_nunchuk_probe,
+        .remove = wiimod_nunchuk_remove,
+        .in_ext = wiimod_nunchuk_in_ext,
+};
+
+/*
+ * Classic Controller
+ * Another official extension from Nintendo. It provides a classic
+ * gamecube-like controller that can be hotplugged on the Wii Remote.
+ * It has several hardware buttons and switches that are all reported via
+ * a normal extension device.
+ */
+
+enum wiimod_classic_keys {
+        WIIMOD_CLASSIC_KEY_A,
+        WIIMOD_CLASSIC_KEY_B,
+        WIIMOD_CLASSIC_KEY_X,
+        WIIMOD_CLASSIC_KEY_Y,
+        WIIMOD_CLASSIC_KEY_ZL,
+        WIIMOD_CLASSIC_KEY_ZR,
+        WIIMOD_CLASSIC_KEY_PLUS,
+        WIIMOD_CLASSIC_KEY_MINUS,
+        WIIMOD_CLASSIC_KEY_HOME,
+        WIIMOD_CLASSIC_KEY_LEFT,
+        WIIMOD_CLASSIC_KEY_RIGHT,
+        WIIMOD_CLASSIC_KEY_UP,
+        WIIMOD_CLASSIC_KEY_DOWN,
+        WIIMOD_CLASSIC_KEY_LT,
+        WIIMOD_CLASSIC_KEY_RT,
+        WIIMOD_CLASSIC_KEY_NUM,
+};
+
+static const __u16 wiimod_classic_map[] = {
+        BTN_A,          /* WIIMOD_CLASSIC_KEY_A */
+        BTN_B,          /* WIIMOD_CLASSIC_KEY_B */
+        BTN_X,          /* WIIMOD_CLASSIC_KEY_X */
+        BTN_Y,          /* WIIMOD_CLASSIC_KEY_Y */
+        BTN_TL2,        /* WIIMOD_CLASSIC_KEY_ZL */
+        BTN_TR2,        /* WIIMOD_CLASSIC_KEY_ZR */
+        KEY_NEXT,       /* WIIMOD_CLASSIC_KEY_PLUS */
+        KEY_PREVIOUS,   /* WIIMOD_CLASSIC_KEY_MINUS */
+        BTN_MODE,       /* WIIMOD_CLASSIC_KEY_HOME */
+        KEY_LEFT,       /* WIIMOD_CLASSIC_KEY_LEFT */
+        KEY_RIGHT,      /* WIIMOD_CLASSIC_KEY_RIGHT */
+        KEY_UP,         /* WIIMOD_CLASSIC_KEY_UP */
+        KEY_DOWN,       /* WIIMOD_CLASSIC_KEY_DOWN */
+        BTN_TL,         /* WIIMOD_CLASSIC_KEY_LT */
+        BTN_TR,         /* WIIMOD_CLASSIC_KEY_RT */
+};
+
+static void wiimod_classic_in_ext(struct wiimote_data *wdata, const __u8 *ext)
+{
+        __s8 rx, ry, lx, ly, lt, rt;
+
+        /*   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         *    1   | RX <5:4>  |              LX <5:0>             |
+         *    2   | RX <3:2>  |              LY <5:0>             |
+         *   -----+-----+-----+-----+-----------------------------+
+         *    3   |RX<1>| LT <5:4>  |         RY <5:1>            |
+         *   -----+-----+-----------+-----------------------------+
+         *    4   |     LT <3:1>    |         RT <5:1>            |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         *    5   | BDR | BDD | BLT | B-  | BH  | B+  | BRT |  1  |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         *    6   | BZL | BB  | BY  | BA  | BX  | BZR | BDL | BDU |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         * All buttons are 0 if pressed
+         * RX and RY are right analog stick
+         * LX and LY are left analog stick
+         * LT is left trigger, RT is right trigger
+         * BLT is 0 if left trigger is fully pressed
+         * BRT is 0 if right trigger is fully pressed
+         * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons
+         * BZL is left Z button and BZR is right Z button
+         * B-, BH, B+ are +, HOME and - buttons
+         * BB, BY, BA, BX are A, B, X, Y buttons
+         * LSB of RX, RY, LT, and RT are not transmitted and always 0.
+         *
+         * With motionp enabled it changes slightly to this:
+         *   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         *    1   | RX <5:4>  |          LX <5:1>           | BDU |
+         *    2   | RX <3:2>  |          LY <5:1>           | BDL |
+         *   -----+-----+-----+-----+-----------------------+-----+
+         *    3   |RX<1>| LT <5:4>  |         RY <5:1>            |
+         *   -----+-----+-----------+-----------------------------+
+         *    4   |     LT <3:1>    |         RT <5:1>            |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         *    5   | BDR | BDD | BLT | B-  | BH  | B+  | BRT | EXT |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         *    6   | BZL | BB  | BY  | BA  | BX  | BZR |  0  |  0  |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         * Only the LSBs of LX and LY are lost. BDU and BDL are moved, the rest
+         * is the same as before.
+         */
+
+        if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
+                lx = ext[0] & 0x3e;
+                ly = ext[1] & 0x3e;
+        } else {
+                lx = ext[0] & 0x3f;
+                ly = ext[1] & 0x3f;
+        }
+
+        rx = (ext[0] >> 3) & 0x18;
+        rx |= (ext[1] >> 5) & 0x06;
+        rx |= (ext[2] >> 7) & 0x01;
+        ry = ext[2] & 0x1f;
+
+        rt = ext[3] & 0x1f;
+        lt = (ext[2] >> 2) & 0x18;
+        lt |= (ext[3] >> 5) & 0x07;
+
+        rx <<= 1;
+        ry <<= 1;
+        rt <<= 1;
+        lt <<= 1;
+
+        input_report_abs(wdata->extension.input, ABS_HAT1X, lx - 0x20);
+        input_report_abs(wdata->extension.input, ABS_HAT1Y, ly - 0x20);
+        input_report_abs(wdata->extension.input, ABS_HAT2X, rx - 0x20);
+        input_report_abs(wdata->extension.input, ABS_HAT2Y, ry - 0x20);
+        input_report_abs(wdata->extension.input, ABS_HAT3X, rt);
+        input_report_abs(wdata->extension.input, ABS_HAT3Y, lt);
+
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_RIGHT],
+                         !(ext[4] & 0x80));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_DOWN],
+                         !(ext[4] & 0x40));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_LT],
+                         !(ext[4] & 0x20));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_MINUS],
+                         !(ext[4] & 0x10));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_HOME],
+                         !(ext[4] & 0x08));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_PLUS],
+                         !(ext[4] & 0x04));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_RT],
+                         !(ext[4] & 0x02));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_ZL],
+                         !(ext[5] & 0x80));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_B],
+                         !(ext[5] & 0x40));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_Y],
+                         !(ext[5] & 0x20));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_A],
+                         !(ext[5] & 0x10));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_X],
+                         !(ext[5] & 0x08));
+        input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_ZR],
+                         !(ext[5] & 0x04));
+
+        if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
+                input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_LEFT],
+                         !(ext[1] & 0x01));
+                input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_UP],
+                         !(ext[0] & 0x01));
+        } else {
+                input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_LEFT],
+                         !(ext[5] & 0x02));
+                input_report_key(wdata->extension.input,
+                         wiimod_classic_map[WIIMOD_CLASSIC_KEY_UP],
+                         !(ext[5] & 0x01));
+        }
+
+        input_sync(wdata->extension.input);
+}
+
+static int wiimod_classic_open(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        return 0;
+}
+
+static void wiimod_classic_close(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+}
+
+static int wiimod_classic_probe(const struct wiimod_ops *ops,
+                                struct wiimote_data *wdata)
+{
+        int ret, i;
+
+        wdata->extension.input = input_allocate_device();
+        if (!wdata->extension.input)
+                return -ENOMEM;
+
+        input_set_drvdata(wdata->extension.input, wdata);
+        wdata->extension.input->open = wiimod_classic_open;
+        wdata->extension.input->close = wiimod_classic_close;
+        wdata->extension.input->dev.parent = &wdata->hdev->dev;
+        wdata->extension.input->id.bustype = wdata->hdev->bus;
+        wdata->extension.input->id.vendor = wdata->hdev->vendor;
+        wdata->extension.input->id.product = wdata->hdev->product;
+        wdata->extension.input->id.version = wdata->hdev->version;
+        wdata->extension.input->name = WIIMOTE_NAME " Classic Controller";
+
+        set_bit(EV_KEY, wdata->extension.input->evbit);
+        for (i = 0; i < WIIMOD_CLASSIC_KEY_NUM; ++i)
+                set_bit(wiimod_classic_map[i],
+                        wdata->extension.input->keybit);
+
+        set_bit(EV_ABS, wdata->extension.input->evbit);
+        set_bit(ABS_HAT1X, wdata->extension.input->absbit);
+        set_bit(ABS_HAT1Y, wdata->extension.input->absbit);
+        set_bit(ABS_HAT2X, wdata->extension.input->absbit);
+        set_bit(ABS_HAT2Y, wdata->extension.input->absbit);
+        set_bit(ABS_HAT3X, wdata->extension.input->absbit);
+        set_bit(ABS_HAT3Y, wdata->extension.input->absbit);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT1X, -30, 30, 1, 1);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT1Y, -30, 30, 1, 1);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT2X, -30, 30, 1, 1);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT2Y, -30, 30, 1, 1);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT3X, -30, 30, 1, 1);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT3Y, -30, 30, 1, 1);
+
+        ret = input_register_device(wdata->extension.input);
+        if (ret)
+                goto err_free;
+
+        return 0;
+
+err_free:
+        input_free_device(wdata->extension.input);
+        wdata->extension.input = NULL;
+        return ret;
+}
+
+static void wiimod_classic_remove(const struct wiimod_ops *ops,
+                                  struct wiimote_data *wdata)
+{
+        if (!wdata->extension.input)
+                return;
+
+        input_unregister_device(wdata->extension.input);
+        wdata->extension.input = NULL;
+}
+
+static const struct wiimod_ops wiimod_classic = {
+        .flags = 0,
+        .arg = 0,
+        .probe = wiimod_classic_probe,
+        .remove = wiimod_classic_remove,
+        .in_ext = wiimod_classic_in_ext,
+};
+
+/*
+ * Balance Board Extension
+ * The Nintendo Wii Balance Board provides four hardware weight sensor plus a
+ * single push button. No other peripherals are available. However, the
+ * balance-board data is sent via a standard Wii Remote extension. All other
+ * data for non-present hardware is zeroed out.
+ * Some 3rd party devices react allergic if we try to access normal Wii Remote
+ * hardware, so this extension module should be the only module that is loaded
+ * on balance boards.
+ * The balance board needs 8 bytes extension data instead of basic 6 bytes so
+ * it needs the WIIMOD_FLAG_EXT8 flag.
+ */
+
+static void wiimod_bboard_in_keys(struct wiimote_data *wdata, const __u8 *keys)
+{
+        input_report_key(wdata->extension.input, BTN_A,
+                         !!(keys[1] & 0x08));
+        input_sync(wdata->extension.input);
+}
+
+static void wiimod_bboard_in_ext(struct wiimote_data *wdata,
+                                 const __u8 *ext)
+{
+        __s32 val[4], tmp, div;
+        unsigned int i;
+        struct wiimote_state *s = &wdata->state;
+
+        /*
+         * Balance board data layout:
+         *
+         *   Byte |  8  7  6  5  4  3  2  1  |
+         *   -----+--------------------------+
+         *    1   |    Top Right <15:8>      |
+         *    2   |    Top Right  <7:0>      |
+         *   -----+--------------------------+
+         *    3   | Bottom Right <15:8>      |
+         *    4   | Bottom Right  <7:0>      |
+         *   -----+--------------------------+
+         *    5   |     Top Left <15:8>      |
+         *    6   |     Top Left  <7:0>      |
+         *   -----+--------------------------+
+         *    7   |  Bottom Left <15:8>      |
+         *    8   |  Bottom Left  <7:0>      |
+         *   -----+--------------------------+
+         *
+         * These values represent the weight-measurements of the Wii-balance
+         * board with 16bit precision.
+         *
+         * The balance-board is never reported interleaved with motionp.
+         */
+
+        val[0] = ext[0];
+        val[0] <<= 8;
+        val[0] |= ext[1];
+
+        val[1] = ext[2];
+        val[1] <<= 8;
+        val[1] |= ext[3];
+
+        val[2] = ext[4];
+        val[2] <<= 8;
+        val[2] |= ext[5];
+
+        val[3] = ext[6];
+        val[3] <<= 8;
+        val[3] |= ext[7];
+
+        /* apply calibration data */
+        for (i = 0; i < 4; i++) {
+                if (val[i] <= s->calib_bboard[i][0]) {
+                        tmp = 0;
+                } else if (val[i] < s->calib_bboard[i][1]) {
+                        tmp = val[i] - s->calib_bboard[i][0];
+                        tmp *= 1700;
+                        div = s->calib_bboard[i][1] - s->calib_bboard[i][0];
+                        tmp /= div ? div : 1;
+                } else {
+                        tmp = val[i] - s->calib_bboard[i][1];
+                        tmp *= 1700;
+                        div = s->calib_bboard[i][2] - s->calib_bboard[i][1];
+                        tmp /= div ? div : 1;
+                        tmp += 1700;
+                }
+                val[i] = tmp;
+        }
+
+        input_report_abs(wdata->extension.input, ABS_HAT0X, val[0]);
+        input_report_abs(wdata->extension.input, ABS_HAT0Y, val[1]);
+        input_report_abs(wdata->extension.input, ABS_HAT1X, val[2]);
+        input_report_abs(wdata->extension.input, ABS_HAT1Y, val[3]);
+        input_sync(wdata->extension.input);
+}
+
+static int wiimod_bboard_open(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        return 0;
+}
+
+static void wiimod_bboard_close(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+}
+
+static ssize_t wiimod_bboard_calib_show(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *out)
+{
+        struct wiimote_data *wdata = dev_to_wii(dev);
+        int i, j, ret;
+        __u16 val;
+        __u8 buf[24], offs;
+
+        ret = wiimote_cmd_acquire(wdata);
+        if (ret)
+                return ret;
+
+        ret = wiimote_cmd_read(wdata, 0xa40024, buf, 12);
+        if (ret != 12) {
+                wiimote_cmd_release(wdata);
+                return ret < 0 ? ret : -EIO;
+        }
+        ret = wiimote_cmd_read(wdata, 0xa40024 + 12, buf + 12, 12);
+        if (ret != 12) {
+                wiimote_cmd_release(wdata);
+                return ret < 0 ? ret : -EIO;
+        }
+
+        wiimote_cmd_release(wdata);
+
+        spin_lock_irq(&wdata->state.lock);
+        offs = 0;
+        for (i = 0; i < 3; ++i) {
+                for (j = 0; j < 4; ++j) {
+                        wdata->state.calib_bboard[j][i] = buf[offs];
+                        wdata->state.calib_bboard[j][i] <<= 8;
+                        wdata->state.calib_bboard[j][i] |= buf[offs + 1];
+                        offs += 2;
+                }
+        }
+        spin_unlock_irq(&wdata->state.lock);
+
+        ret = 0;
+        for (i = 0; i < 3; ++i) {
+                for (j = 0; j < 4; ++j) {
+                        val = wdata->state.calib_bboard[j][i];
+                        if (i == 2 && j == 3)
+                                ret += sprintf(&out[ret], "%04x\n", val);
+                        else
+                                ret += sprintf(&out[ret], "%04x:", val);
+                }
+        }
+
+        return ret;
+}
+
+static DEVICE_ATTR(bboard_calib, S_IRUGO, wiimod_bboard_calib_show, NULL);
+
+static int wiimod_bboard_probe(const struct wiimod_ops *ops,
+                               struct wiimote_data *wdata)
+{
+        int ret, i, j;
+        __u8 buf[24], offs;
+
+        wiimote_cmd_acquire_noint(wdata);
+
+        ret = wiimote_cmd_read(wdata, 0xa40024, buf, 12);
+        if (ret != 12) {
+                wiimote_cmd_release(wdata);
+                return ret < 0 ? ret : -EIO;
+        }
+        ret = wiimote_cmd_read(wdata, 0xa40024 + 12, buf + 12, 12);
+        if (ret != 12) {
+                wiimote_cmd_release(wdata);
+                return ret < 0 ? ret : -EIO;
+        }
+
+        wiimote_cmd_release(wdata);
+
+        offs = 0;
+        for (i = 0; i < 3; ++i) {
+                for (j = 0; j < 4; ++j) {
+                        wdata->state.calib_bboard[j][i] = buf[offs];
+                        wdata->state.calib_bboard[j][i] <<= 8;
+                        wdata->state.calib_bboard[j][i] |= buf[offs + 1];
+                        offs += 2;
+                }
+        }
+
+        wdata->extension.input = input_allocate_device();
+        if (!wdata->extension.input)
+                return -ENOMEM;
+
+        ret = device_create_file(&wdata->hdev->dev,
+                                 &dev_attr_bboard_calib);
+        if (ret) {
+                hid_err(wdata->hdev, "cannot create sysfs attribute\n");
+                goto err_free;
+        }
+
+        input_set_drvdata(wdata->extension.input, wdata);
+        wdata->extension.input->open = wiimod_bboard_open;
+        wdata->extension.input->close = wiimod_bboard_close;
+        wdata->extension.input->dev.parent = &wdata->hdev->dev;
+        wdata->extension.input->id.bustype = wdata->hdev->bus;
+        wdata->extension.input->id.vendor = wdata->hdev->vendor;
+        wdata->extension.input->id.product = wdata->hdev->product;
+        wdata->extension.input->id.version = wdata->hdev->version;
+        wdata->extension.input->name = WIIMOTE_NAME " Balance Board";
+
+        set_bit(EV_KEY, wdata->extension.input->evbit);
+        set_bit(BTN_A, wdata->extension.input->keybit);
+
+        set_bit(EV_ABS, wdata->extension.input->evbit);
+        set_bit(ABS_HAT0X, wdata->extension.input->absbit);
+        set_bit(ABS_HAT0Y, wdata->extension.input->absbit);
+        set_bit(ABS_HAT1X, wdata->extension.input->absbit);
+        set_bit(ABS_HAT1Y, wdata->extension.input->absbit);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT0X, 0, 65535, 2, 4);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT0Y, 0, 65535, 2, 4);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT1X, 0, 65535, 2, 4);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_HAT1Y, 0, 65535, 2, 4);
+
+        ret = input_register_device(wdata->extension.input);
+        if (ret)
+                goto err_file;
+
+        return 0;
+
+err_file:
+        device_remove_file(&wdata->hdev->dev,
+                           &dev_attr_bboard_calib);
+err_free:
+        input_free_device(wdata->extension.input);
+        wdata->extension.input = NULL;
+        return ret;
+}
+
+static void wiimod_bboard_remove(const struct wiimod_ops *ops,
+                                 struct wiimote_data *wdata)
+{
+        if (!wdata->extension.input)
+                return;
+
+        input_unregister_device(wdata->extension.input);
+        wdata->extension.input = NULL;
+        device_remove_file(&wdata->hdev->dev,
+                           &dev_attr_bboard_calib);
+}
+
+static const struct wiimod_ops wiimod_bboard = {
+        .flags = WIIMOD_FLAG_EXT8,
+        .arg = 0,
+        .probe = wiimod_bboard_probe,
+        .remove = wiimod_bboard_remove,
+        .in_keys = wiimod_bboard_in_keys,
+        .in_ext = wiimod_bboard_in_ext,
+};
+
+/*
+ * Pro Controller
+ * Released with the Wii U was the Nintendo Wii U Pro Controller. It does not
+ * work together with the classic Wii, but only with the new Wii U. However, it
+ * uses the same protocol and provides a builtin "classic controller pro"
+ * extension, few standard buttons, a rumble motor, 4 LEDs and a battery.
+ * We provide all these via a standard extension device as the device doesn't
+ * feature an extension port.
+ */
+
+enum wiimod_pro_keys {
+        WIIMOD_PRO_KEY_A,
+        WIIMOD_PRO_KEY_B,
+        WIIMOD_PRO_KEY_X,
+        WIIMOD_PRO_KEY_Y,
+        WIIMOD_PRO_KEY_PLUS,
+        WIIMOD_PRO_KEY_MINUS,
+        WIIMOD_PRO_KEY_HOME,
+        WIIMOD_PRO_KEY_LEFT,
+        WIIMOD_PRO_KEY_RIGHT,
+        WIIMOD_PRO_KEY_UP,
+        WIIMOD_PRO_KEY_DOWN,
+        WIIMOD_PRO_KEY_TL,
+        WIIMOD_PRO_KEY_TR,
+        WIIMOD_PRO_KEY_ZL,
+        WIIMOD_PRO_KEY_ZR,
+        WIIMOD_PRO_KEY_THUMBL,
+        WIIMOD_PRO_KEY_THUMBR,
+        WIIMOD_PRO_KEY_NUM,
+};
+
+static const __u16 wiimod_pro_map[] = {
+        BTN_EAST,       /* WIIMOD_PRO_KEY_A */
+        BTN_SOUTH,      /* WIIMOD_PRO_KEY_B */
+        BTN_NORTH,      /* WIIMOD_PRO_KEY_X */
+        BTN_WEST,       /* WIIMOD_PRO_KEY_Y */
+        BTN_START,      /* WIIMOD_PRO_KEY_PLUS */
+        BTN_SELECT,     /* WIIMOD_PRO_KEY_MINUS */
+        BTN_MODE,       /* WIIMOD_PRO_KEY_HOME */
+        BTN_DPAD_LEFT,  /* WIIMOD_PRO_KEY_LEFT */
+        BTN_DPAD_RIGHT, /* WIIMOD_PRO_KEY_RIGHT */
+        BTN_DPAD_UP,    /* WIIMOD_PRO_KEY_UP */
+        BTN_DPAD_DOWN,  /* WIIMOD_PRO_KEY_DOWN */
+        BTN_TL,         /* WIIMOD_PRO_KEY_TL */
+        BTN_TR,         /* WIIMOD_PRO_KEY_TR */
+        BTN_TL2,        /* WIIMOD_PRO_KEY_ZL */
+        BTN_TR2,        /* WIIMOD_PRO_KEY_ZR */
+        BTN_THUMBL,     /* WIIMOD_PRO_KEY_THUMBL */
+        BTN_THUMBR,     /* WIIMOD_PRO_KEY_THUMBR */
+};
+
+static void wiimod_pro_in_ext(struct wiimote_data *wdata, const __u8 *ext)
+{
+        __s16 rx, ry, lx, ly;
+
+        /*   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         *    1   |                   LX <7:0>                    |
+         *   -----+-----------------------+-----------------------+
+         *    2   |  0     0     0     0  |       LX <11:8>       |
+         *   -----+-----------------------+-----------------------+
+         *    3   |                   RX <7:0>                    |
+         *   -----+-----------------------+-----------------------+
+         *    4   |  0     0     0     0  |       RX <11:8>       |
+         *   -----+-----------------------+-----------------------+
+         *    5   |                   LY <7:0>                    |
+         *   -----+-----------------------+-----------------------+
+         *    6   |  0     0     0     0  |       LY <11:8>       |
+         *   -----+-----------------------+-----------------------+
+         *    7   |                   RY <7:0>                    |
+         *   -----+-----------------------+-----------------------+
+         *    8   |  0     0     0     0  |       RY <11:8>       |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         *    9   | BDR | BDD | BLT | B-  | BH  | B+  | BRT |  1  |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         *   10   | BZL | BB  | BY  | BA  | BX  | BZR | BDL | BDU |
+         *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
+         *   11   |  1  |     BATTERY     | USB |CHARG|LTHUM|RTHUM|
+         *   -----+-----+-----------------+-----------+-----+-----+
+         * All buttons are low-active (0 if pressed)
+         * RX and RY are right analog stick
+         * LX and LY are left analog stick
+         * BLT is left trigger, BRT is right trigger.
+         * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons
+         * BZL is left Z button and BZR is right Z button
+         * B-, BH, B+ are +, HOME and - buttons
+         * BB, BY, BA, BX are A, B, X, Y buttons
+         *
+         * Bits marked as 0/1 are unknown and never changed during tests.
+         *
+         * Not entirely verified:
+         *   CHARG: 1 if uncharging, 0 if charging
+         *   USB: 1 if not connected, 0 if connected
+         *   BATTERY: battery capacity from 000 (empty) to 100 (full)
+         */
+
+        lx = (ext[0] & 0xff) | ((ext[1] & 0x0f) << 8);
+        rx = (ext[2] & 0xff) | ((ext[3] & 0x0f) << 8);
+        ly = (ext[4] & 0xff) | ((ext[5] & 0x0f) << 8);
+        ry = (ext[6] & 0xff) | ((ext[7] & 0x0f) << 8);
+
+        input_report_abs(wdata->extension.input, ABS_X, lx - 0x800);
+        input_report_abs(wdata->extension.input, ABS_Y, ly - 0x800);
+        input_report_abs(wdata->extension.input, ABS_RX, rx - 0x800);
+        input_report_abs(wdata->extension.input, ABS_RY, ry - 0x800);
+
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_RIGHT],
+                         !(ext[8] & 0x80));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_DOWN],
+                         !(ext[8] & 0x40));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_TL],
+                         !(ext[8] & 0x20));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_MINUS],
+                         !(ext[8] & 0x10));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_HOME],
+                         !(ext[8] & 0x08));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_PLUS],
+                         !(ext[8] & 0x04));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_TR],
+                         !(ext[8] & 0x02));
+
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_ZL],
+                         !(ext[9] & 0x80));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_B],
+                         !(ext[9] & 0x40));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_Y],
+                         !(ext[9] & 0x20));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_A],
+                         !(ext[9] & 0x10));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_X],
+                         !(ext[9] & 0x08));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_ZR],
+                         !(ext[9] & 0x04));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_LEFT],
+                         !(ext[9] & 0x02));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_UP],
+                         !(ext[9] & 0x01));
+
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_THUMBL],
+                         !(ext[10] & 0x02));
+        input_report_key(wdata->extension.input,
+                         wiimod_pro_map[WIIMOD_PRO_KEY_THUMBR],
+                         !(ext[10] & 0x01));
+
+        input_sync(wdata->extension.input);
+}
+
+static int wiimod_pro_open(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        return 0;
+}
+
+static void wiimod_pro_close(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+}
+
+static int wiimod_pro_play(struct input_dev *dev, void *data,
+                           struct ff_effect *eff)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        __u8 value;
+        unsigned long flags;
+
+        /*
+         * The wiimote supports only a single rumble motor so if any magnitude
+         * is set to non-zero then we start the rumble motor. If both are set to
+         * zero, we stop the rumble motor.
+         */
+
+        if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)
+                value = 1;
+        else
+                value = 0;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wiiproto_req_rumble(wdata, value);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        return 0;
+}
+
+static int wiimod_pro_probe(const struct wiimod_ops *ops,
+                            struct wiimote_data *wdata)
+{
+        int ret, i;
+
+        wdata->extension.input = input_allocate_device();
+        if (!wdata->extension.input)
+                return -ENOMEM;
+
+        set_bit(FF_RUMBLE, wdata->extension.input->ffbit);
+        input_set_drvdata(wdata->extension.input, wdata);
+
+        if (input_ff_create_memless(wdata->extension.input, NULL,
+                                    wiimod_pro_play)) {
+                ret = -ENOMEM;
+                goto err_free;
+        }
+
+        wdata->extension.input->open = wiimod_pro_open;
+        wdata->extension.input->close = wiimod_pro_close;
+        wdata->extension.input->dev.parent = &wdata->hdev->dev;
+        wdata->extension.input->id.bustype = wdata->hdev->bus;
+        wdata->extension.input->id.vendor = wdata->hdev->vendor;
+        wdata->extension.input->id.product = wdata->hdev->product;
+        wdata->extension.input->id.version = wdata->hdev->version;
+        wdata->extension.input->name = WIIMOTE_NAME " Pro Controller";
+
+        set_bit(EV_KEY, wdata->extension.input->evbit);
+        for (i = 0; i < WIIMOD_PRO_KEY_NUM; ++i)
+                set_bit(wiimod_pro_map[i],
+                        wdata->extension.input->keybit);
+
+        set_bit(EV_ABS, wdata->extension.input->evbit);
+        set_bit(ABS_X, wdata->extension.input->absbit);
+        set_bit(ABS_Y, wdata->extension.input->absbit);
+        set_bit(ABS_RX, wdata->extension.input->absbit);
+        set_bit(ABS_RY, wdata->extension.input->absbit);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_X, -0x800, 0x800, 2, 4);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_Y, -0x800, 0x800, 2, 4);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_RX, -0x800, 0x800, 2, 4);
+        input_set_abs_params(wdata->extension.input,
+                             ABS_RY, -0x800, 0x800, 2, 4);
+
+        ret = input_register_device(wdata->extension.input);
+        if (ret)
+                goto err_free;
+
+        return 0;
+
+err_free:
+        input_free_device(wdata->extension.input);
+        wdata->extension.input = NULL;
+        return ret;
+}
+
+static void wiimod_pro_remove(const struct wiimod_ops *ops,
+                              struct wiimote_data *wdata)
+{
+        unsigned long flags;
+
+        if (!wdata->extension.input)
+                return;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wiiproto_req_rumble(wdata, 0);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        input_unregister_device(wdata->extension.input);
+        wdata->extension.input = NULL;
+}
+
+static const struct wiimod_ops wiimod_pro = {
+        .flags = WIIMOD_FLAG_EXT16,
+        .arg = 0,
+        .probe = wiimod_pro_probe,
+        .remove = wiimod_pro_remove,
+        .in_ext = wiimod_pro_in_ext,
+};
+
+/*
+ * Builtin Motion Plus
+ * This module simply sets the WIIPROTO_FLAG_BUILTIN_MP protocol flag which
+ * disables polling for Motion-Plus. This should be set only for devices which
+ * don't allow MP hotplugging.
+ */
+
+static int wiimod_builtin_mp_probe(const struct wiimod_ops *ops,
+                                   struct wiimote_data *wdata)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP;
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        return 0;
+}
+
+static void wiimod_builtin_mp_remove(const struct wiimod_ops *ops,
+                                     struct wiimote_data *wdata)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP;
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+}
+
+static const struct wiimod_ops wiimod_builtin_mp = {
+        .flags = 0,
+        .arg = 0,
+        .probe = wiimod_builtin_mp_probe,
+        .remove = wiimod_builtin_mp_remove,
+};
+
+/*
+ * No Motion Plus
+ * This module simply sets the WIIPROTO_FLAG_NO_MP protocol flag which
+ * disables motion-plus. This is needed for devices that advertise this but we
+ * don't know how to use it (or whether it is actually present).
+ */
+
+static int wiimod_no_mp_probe(const struct wiimod_ops *ops,
+                              struct wiimote_data *wdata)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags |= WIIPROTO_FLAG_NO_MP;
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        return 0;
+}
+
+static void wiimod_no_mp_remove(const struct wiimod_ops *ops,
+                                struct wiimote_data *wdata)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags |= WIIPROTO_FLAG_NO_MP;
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+}
+
+static const struct wiimod_ops wiimod_no_mp = {
+        .flags = 0,
+        .arg = 0,
+        .probe = wiimod_no_mp_probe,
+        .remove = wiimod_no_mp_remove,
+};
+
+/*
+ * Motion Plus
+ * The Motion Plus extension provides rotation sensors (gyro) as a small
+ * extension device for Wii Remotes. Many devices have them built-in so
+ * you cannot see them from the outside.
+ * Motion Plus extensions are special because they are on a separate extension
+ * port and allow other extensions to be used simultaneously. This is all
+ * handled by the Wiimote Core so we don't have to deal with it.
+ */
+
+static void wiimod_mp_in_mp(struct wiimote_data *wdata, const __u8 *ext)
+{
+        __s32 x, y, z;
+
+        /*        |   8    7    6    5    4    3 |  2  |  1  |
+         *   -----+------------------------------+-----+-----+
+         *    1   |               Yaw Speed <7:0>            |
+         *    2   |              Roll Speed <7:0>            |
+         *    3   |             Pitch Speed <7:0>            |
+         *   -----+------------------------------+-----+-----+
+         *    4   |       Yaw Speed <13:8>       | Yaw |Pitch|
+         *   -----+------------------------------+-----+-----+
+         *    5   |      Roll Speed <13:8>       |Roll | Ext |
+         *   -----+------------------------------+-----+-----+
+         *    6   |     Pitch Speed <13:8>       |  1  |  0  |
+         *   -----+------------------------------+-----+-----+
+         * The single bits Yaw, Roll, Pitch in the lower right corner specify
+         * whether the wiimote is rotating fast (0) or slow (1). Speed for slow
+         * roation is 440 deg/s and for fast rotation 2000 deg/s. To get a
+         * linear scale we multiply by 2000/440 = ~4.5454 which is 18 for fast
+         * and 9 for slow.
+         * If the wiimote is not rotating the sensor reports 2^13 = 8192.
+         * Ext specifies whether an extension is connected to the motionp.
+         * which is parsed by wiimote-core.
+         */
+
+        x = ext[0];
+        y = ext[1];
+        z = ext[2];
+
+        x |= (((__u16)ext[3]) << 6) & 0xff00;
+        y |= (((__u16)ext[4]) << 6) & 0xff00;
+        z |= (((__u16)ext[5]) << 6) & 0xff00;
+
+        x -= 8192;
+        y -= 8192;
+        z -= 8192;
+
+        if (!(ext[3] & 0x02))
+                x *= 18;
+        else
+                x *= 9;
+        if (!(ext[4] & 0x02))
+                y *= 18;
+        else
+                y *= 9;
+        if (!(ext[3] & 0x01))
+                z *= 18;
+        else
+                z *= 9;
+
+        input_report_abs(wdata->mp, ABS_RX, x);
+        input_report_abs(wdata->mp, ABS_RY, y);
+        input_report_abs(wdata->mp, ABS_RZ, z);
+        input_sync(wdata->mp);
+}
+
+static int wiimod_mp_open(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags |= WIIPROTO_FLAG_MP_USED;
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        __wiimote_schedule(wdata);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+
+        return 0;
+}
+
+static void wiimod_mp_close(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdata->state.lock, flags);
+        wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED;
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+        __wiimote_schedule(wdata);
+        spin_unlock_irqrestore(&wdata->state.lock, flags);
+}
+
+static int wiimod_mp_probe(const struct wiimod_ops *ops,
+                           struct wiimote_data *wdata)
+{
+        int ret;
+
+        wdata->mp = input_allocate_device();
+        if (!wdata->mp)
+                return -ENOMEM;
+
+        input_set_drvdata(wdata->mp, wdata);
+        wdata->mp->open = wiimod_mp_open;
+        wdata->mp->close = wiimod_mp_close;
+        wdata->mp->dev.parent = &wdata->hdev->dev;
+        wdata->mp->id.bustype = wdata->hdev->bus;
+        wdata->mp->id.vendor = wdata->hdev->vendor;
+        wdata->mp->id.product = wdata->hdev->product;
+        wdata->mp->id.version = wdata->hdev->version;
+        wdata->mp->name = WIIMOTE_NAME " Motion Plus";
+
+        set_bit(EV_ABS, wdata->mp->evbit);
+        set_bit(ABS_RX, wdata->mp->absbit);
+        set_bit(ABS_RY, wdata->mp->absbit);
+        set_bit(ABS_RZ, wdata->mp->absbit);
+        input_set_abs_params(wdata->mp,
+                             ABS_RX, -16000, 16000, 4, 8);
+        input_set_abs_params(wdata->mp,
+                             ABS_RY, -16000, 16000, 4, 8);
+        input_set_abs_params(wdata->mp,
+                             ABS_RZ, -16000, 16000, 4, 8);
+
+        ret = input_register_device(wdata->mp);
+        if (ret)
+                goto err_free;
+
+        return 0;
+
+err_free:
+        input_free_device(wdata->mp);
+        wdata->mp = NULL;
+        return ret;
+}
+
+static void wiimod_mp_remove(const struct wiimod_ops *ops,
+                             struct wiimote_data *wdata)
+{
+        if (!wdata->mp)
+                return;
+
+        input_unregister_device(wdata->mp);
+        wdata->mp = NULL;
+}
+
+const struct wiimod_ops wiimod_mp = {
+        .flags = 0,
+        .arg = 0,
+        .probe = wiimod_mp_probe,
+        .remove = wiimod_mp_remove,
+        .in_mp = wiimod_mp_in_mp,
+};
+
+/* module table */
+
+static const struct wiimod_ops wiimod_dummy;
+
+const struct wiimod_ops *wiimod_table[WIIMOD_NUM] = {
+        [WIIMOD_KEYS] = &wiimod_keys,
+        [WIIMOD_RUMBLE] = &wiimod_rumble,
+        [WIIMOD_BATTERY] = &wiimod_battery,
+        [WIIMOD_LED1] = &wiimod_leds[0],
+        [WIIMOD_LED2] = &wiimod_leds[1],
+        [WIIMOD_LED3] = &wiimod_leds[2],
+        [WIIMOD_LED4] = &wiimod_leds[3],
+        [WIIMOD_ACCEL] = &wiimod_accel,
+        [WIIMOD_IR] = &wiimod_ir,
+        [WIIMOD_BUILTIN_MP] = &wiimod_builtin_mp,
+        [WIIMOD_NO_MP] = &wiimod_no_mp,
+};
+
+const struct wiimod_ops *wiimod_ext_table[WIIMOTE_EXT_NUM] = {
+        [WIIMOTE_EXT_NONE] = &wiimod_dummy,
+        [WIIMOTE_EXT_UNKNOWN] = &wiimod_dummy,
+        [WIIMOTE_EXT_NUNCHUK] = &wiimod_nunchuk,
+        [WIIMOTE_EXT_CLASSIC_CONTROLLER] = &wiimod_classic,
+        [WIIMOTE_EXT_BALANCE_BOARD] = &wiimod_bboard,
+        [WIIMOTE_EXT_PRO_CONTROLLER] = &wiimod_pro,
+};
diff --git a/drivers/hid/hid-wiimote.h b/drivers/hid/hid-wiimote.h
index c81dbeb086c5..f1474f372c0b 100644
--- a/drivers/hid/hid-wiimote.h
+++ b/drivers/hid/hid-wiimote.h
@@ -2,8 +2,8 @@
 #define __HID_WIIMOTE_H
 
 /*
- * HID driver for Nintendo Wiimote devices
- * Copyright (c) 2011 David Herrmann
+ * HID driver for Nintendo Wii / Wii U peripherals
+ * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
  */
 
 /*
@@ -22,6 +22,7 @@
 #include <linux/mutex.h>
 #include <linux/power_supply.h>
 #include <linux/spinlock.h>
+#include <linux/timer.h>
 
 #define WIIMOTE_NAME "Nintendo Wii Remote"
 #define WIIMOTE_BUFSIZE 32
@@ -35,6 +36,17 @@
 #define WIIPROTO_FLAG_IR_BASIC          0x40
 #define WIIPROTO_FLAG_IR_EXT            0x80
 #define WIIPROTO_FLAG_IR_FULL           0xc0 /* IR_BASIC | IR_EXT */
+#define WIIPROTO_FLAG_EXT_PLUGGED       0x0100
+#define WIIPROTO_FLAG_EXT_USED          0x0200
+#define WIIPROTO_FLAG_EXT_ACTIVE        0x0400
+#define WIIPROTO_FLAG_MP_PLUGGED        0x0800
+#define WIIPROTO_FLAG_MP_USED           0x1000
+#define WIIPROTO_FLAG_MP_ACTIVE         0x2000
+#define WIIPROTO_FLAG_EXITING           0x4000
+#define WIIPROTO_FLAG_DRM_LOCKED        0x8000
+#define WIIPROTO_FLAG_BUILTIN_MP        0x010000
+#define WIIPROTO_FLAG_NO_MP             0x020000
+
 #define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 | WIIPROTO_FLAG_LED2 | \
                                         WIIPROTO_FLAG_LED3 | WIIPROTO_FLAG_LED4)
 #define WIIPROTO_FLAGS_IR (WIIPROTO_FLAG_IR_BASIC | WIIPROTO_FLAG_IR_EXT | \
@@ -43,16 +55,71 @@
 /* return flag for led \num */
 #define WIIPROTO_FLAG_LED(num) (WIIPROTO_FLAG_LED1 << (num - 1))
 
+enum wiiproto_keys {
+        WIIPROTO_KEY_LEFT,
+        WIIPROTO_KEY_RIGHT,
+        WIIPROTO_KEY_UP,
+        WIIPROTO_KEY_DOWN,
+        WIIPROTO_KEY_PLUS,
+        WIIPROTO_KEY_MINUS,
+        WIIPROTO_KEY_ONE,
+        WIIPROTO_KEY_TWO,
+        WIIPROTO_KEY_A,
+        WIIPROTO_KEY_B,
+        WIIPROTO_KEY_HOME,
+        WIIPROTO_KEY_COUNT
+};
+
+enum wiimote_devtype {
+        WIIMOTE_DEV_PENDING,
+        WIIMOTE_DEV_UNKNOWN,
+        WIIMOTE_DEV_GENERIC,
+        WIIMOTE_DEV_GEN10,
+        WIIMOTE_DEV_GEN20,
+        WIIMOTE_DEV_BALANCE_BOARD,
+        WIIMOTE_DEV_PRO_CONTROLLER,
+        WIIMOTE_DEV_NUM,
+};
+
+enum wiimote_exttype {
+        WIIMOTE_EXT_NONE,
+        WIIMOTE_EXT_UNKNOWN,
+        WIIMOTE_EXT_NUNCHUK,
+        WIIMOTE_EXT_CLASSIC_CONTROLLER,
+        WIIMOTE_EXT_BALANCE_BOARD,
+        WIIMOTE_EXT_PRO_CONTROLLER,
+        WIIMOTE_EXT_NUM,
+};
+
+enum wiimote_mptype {
+        WIIMOTE_MP_NONE,
+        WIIMOTE_MP_UNKNOWN,
+        WIIMOTE_MP_SINGLE,
+        WIIMOTE_MP_PASSTHROUGH_NUNCHUK,
+        WIIMOTE_MP_PASSTHROUGH_CLASSIC,
+};
+
 struct wiimote_buf {
         __u8 data[HID_MAX_BUFFER_SIZE];
         size_t size;
 };
 
+struct wiimote_queue {
+        spinlock_t lock;
+        struct work_struct worker;
+        __u8 head;
+        __u8 tail;
+        struct wiimote_buf outq[WIIMOTE_BUFSIZE];
+};
+
 struct wiimote_state {
         spinlock_t lock;
-        __u8 flags;
+        __u32 flags;
         __u8 accel_split[2];
         __u8 drm;
+        __u8 devtype;
+        __u8 exttype;
+        __u8 mp;
 
         /* synchronous cmd requests */
         struct mutex sync;
@@ -65,6 +132,9 @@ struct wiimote_state {
         __u8 cmd_err;
         __u8 *cmd_read_buf;
         __u8 cmd_read_size;
+
+        /* calibration data */
+        __u16 calib_bboard[4][3];
 };
 
 struct wiimote_data {
@@ -74,18 +144,63 @@ struct wiimote_data {
         struct input_dev *accel;
         struct input_dev *ir;
         struct power_supply battery;
-        struct wiimote_ext *ext;
+        struct input_dev *mp;
+        struct timer_list timer;
         struct wiimote_debug *debug;
 
-        spinlock_t qlock;
-        __u8 head;
-        __u8 tail;
-        struct wiimote_buf outq[WIIMOTE_BUFSIZE];
-        struct work_struct worker;
+        union {
+                struct input_dev *input;
+        } extension;
 
+        struct wiimote_queue queue;
         struct wiimote_state state;
+        struct work_struct init_worker;
+};
+
+/* wiimote modules */
+
+enum wiimod_module {
+        WIIMOD_KEYS,
+        WIIMOD_RUMBLE,
+        WIIMOD_BATTERY,
+        WIIMOD_LED1,
+        WIIMOD_LED2,
+        WIIMOD_LED3,
+        WIIMOD_LED4,
+        WIIMOD_ACCEL,
+        WIIMOD_IR,
+        WIIMOD_BUILTIN_MP,
+        WIIMOD_NO_MP,
+        WIIMOD_NUM,
+        WIIMOD_NULL = WIIMOD_NUM,
+};
+
+#define WIIMOD_FLAG_INPUT               0x0001
+#define WIIMOD_FLAG_EXT8                0x0002
+#define WIIMOD_FLAG_EXT16               0x0004
+
+struct wiimod_ops {
+        __u16 flags;
+        unsigned long arg;
+        int (*probe) (const struct wiimod_ops *ops,
+                      struct wiimote_data *wdata);
+        void (*remove) (const struct wiimod_ops *ops,
+                        struct wiimote_data *wdata);
+
+        void (*in_keys) (struct wiimote_data *wdata, const __u8 *keys);
+        void (*in_accel) (struct wiimote_data *wdata, const __u8 *accel);
+        void (*in_ir) (struct wiimote_data *wdata, const __u8 *ir, bool packed,
+                       unsigned int id);
+        void (*in_mp) (struct wiimote_data *wdata, const __u8 *mp);
+        void (*in_ext) (struct wiimote_data *wdata, const __u8 *ext);
 };
 
+extern const struct wiimod_ops *wiimod_table[WIIMOD_NUM];
+extern const struct wiimod_ops *wiimod_ext_table[WIIMOTE_EXT_NUM];
+extern const struct wiimod_ops wiimod_mp;
+
+/* wiimote requests */
+
 enum wiiproto_reqs {
         WIIPROTO_REQ_NULL = 0x0,
         WIIPROTO_REQ_RUMBLE = 0x10,
@@ -99,24 +214,55 @@ enum wiiproto_reqs {
         WIIPROTO_REQ_STATUS = 0x20,
         WIIPROTO_REQ_DATA = 0x21,
         WIIPROTO_REQ_RETURN = 0x22,
+
+        /* DRM_K: BB*2 */
         WIIPROTO_REQ_DRM_K = 0x30,
+
+        /* DRM_KA: BB*2 AA*3 */
         WIIPROTO_REQ_DRM_KA = 0x31,
+
+        /* DRM_KE: BB*2 EE*8 */
         WIIPROTO_REQ_DRM_KE = 0x32,
+
+        /* DRM_KAI: BB*2 AA*3 II*12 */
         WIIPROTO_REQ_DRM_KAI = 0x33,
+
+        /* DRM_KEE: BB*2 EE*19 */
         WIIPROTO_REQ_DRM_KEE = 0x34,
+
+        /* DRM_KAE: BB*2 AA*3 EE*16 */
         WIIPROTO_REQ_DRM_KAE = 0x35,
+
+        /* DRM_KIE: BB*2 II*10 EE*9 */
         WIIPROTO_REQ_DRM_KIE = 0x36,
+
+        /* DRM_KAIE: BB*2 AA*3 II*10 EE*6 */
         WIIPROTO_REQ_DRM_KAIE = 0x37,
+
+        /* DRM_E: EE*21 */
         WIIPROTO_REQ_DRM_E = 0x3d,
+
+        /* DRM_SKAI1: BB*2 AA*1 II*18 */
         WIIPROTO_REQ_DRM_SKAI1 = 0x3e,
+
+        /* DRM_SKAI2: BB*2 AA*1 II*18 */
         WIIPROTO_REQ_DRM_SKAI2 = 0x3f,
+
         WIIPROTO_REQ_MAX
 };
 
 #define dev_to_wii(pdev) hid_get_drvdata(container_of(pdev, struct hid_device, \
                                                                         dev))
 
+void __wiimote_schedule(struct wiimote_data *wdata);
+
 extern void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm);
+extern void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble);
+extern void wiiproto_req_leds(struct wiimote_data *wdata, int leds);
+extern void wiiproto_req_status(struct wiimote_data *wdata);
+extern void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel);
+extern void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags);
+extern void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags);
 extern int wiimote_cmd_write(struct wiimote_data *wdata, __u32 offset,
                                                 const __u8 *wmem, __u8 size);
 extern ssize_t wiimote_cmd_read(struct wiimote_data *wdata, __u32 offset,
@@ -129,24 +275,6 @@ extern ssize_t wiimote_cmd_read(struct wiimote_data *wdata, __u32 offset,
 extern void wiiproto_req_rmem(struct wiimote_data *wdata, bool eeprom,
                                                 __u32 offset, __u16 size);
 
-#ifdef CONFIG_HID_WIIMOTE_EXT
-
-extern int wiiext_init(struct wiimote_data *wdata);
-extern void wiiext_deinit(struct wiimote_data *wdata);
-extern void wiiext_event(struct wiimote_data *wdata, bool plugged);
-extern bool wiiext_active(struct wiimote_data *wdata);
-extern void wiiext_handle(struct wiimote_data *wdata, const __u8 *payload);
-
-#else
-
-static inline int wiiext_init(void *u) { return 0; }
-static inline void wiiext_deinit(void *u) { }
-static inline void wiiext_event(void *u, bool p) { }
-static inline bool wiiext_active(void *u) { return false; }
-static inline void wiiext_handle(void *u, const __u8 *p) { }
-
-#endif
-
 #ifdef CONFIG_DEBUG_FS
 
 extern int wiidebug_init(struct wiimote_data *wdata);
@@ -173,11 +301,26 @@ static inline void wiimote_cmd_complete(struct wiimote_data *wdata)
         complete(&wdata->state.ready);
 }
 
+/* requires the state.lock spinlock to be held */
+static inline void wiimote_cmd_abort(struct wiimote_data *wdata)
+{
+        /* Abort synchronous request by waking up the sleeping caller. But
+         * reset the state.cmd field to an invalid value so no further event
+         * handlers will work with it. */
+        wdata->state.cmd = WIIPROTO_REQ_MAX;
+        complete(&wdata->state.ready);
+}
+
 static inline int wiimote_cmd_acquire(struct wiimote_data *wdata)
 {
         return mutex_lock_interruptible(&wdata->state.sync) ? -ERESTARTSYS : 0;
 }
 
+static inline void wiimote_cmd_acquire_noint(struct wiimote_data *wdata)
+{
+        mutex_lock(&wdata->state.sync);
+}
+
 /* requires the state.lock spinlock to be held */
 static inline void wiimote_cmd_set(struct wiimote_data *wdata, int cmd,
                                                                 __u32 opt)
@@ -196,11 +339,31 @@ static inline int wiimote_cmd_wait(struct wiimote_data *wdata)
 {
         int ret;
 
+        /* The completion acts as implicit memory barrier so we can safely
+         * assume that state.cmd is set on success/failure and isn't accessed
+         * by any other thread, anymore. */
+
         ret = wait_for_completion_interruptible_timeout(&wdata->state.ready, HZ);
         if (ret < 0)
                 return -ERESTARTSYS;
         else if (ret == 0)
                 return -EIO;
+        else if (wdata->state.cmd != WIIPROTO_REQ_NULL)
+                return -EIO;
+        else
+                return 0;
+}
+
+static inline int wiimote_cmd_wait_noint(struct wiimote_data *wdata)
+{
+        unsigned long ret;
+
+        /* no locking needed; see wiimote_cmd_wait() */
+        ret = wait_for_completion_timeout(&wdata->state.ready, HZ);
+        if (!ret)
+                return -EIO;
+        else if (wdata->state.cmd != WIIPROTO_REQ_NULL)
+                return -EIO;
         else
                 return 0;
 }
diff --git a/drivers/hid/i2c-hid/i2c-hid.c b/drivers/hid/i2c-hid/i2c-hid.c
index 2b1799a3b212..879b0ed701a3 100644
--- a/drivers/hid/i2c-hid/i2c-hid.c
+++ b/drivers/hid/i2c-hid/i2c-hid.c
@@ -108,6 +108,7 @@ static const struct i2c_hid_cmd hid_reset_cmd =		{ I2C_HID_CMD(0x01),
 static const struct i2c_hid_cmd hid_get_report_cmd =    { I2C_HID_CMD(0x02) };
 static const struct i2c_hid_cmd hid_set_report_cmd =    { I2C_HID_CMD(0x03) };
 static const struct i2c_hid_cmd hid_set_power_cmd =     { I2C_HID_CMD(0x08) };
+static const struct i2c_hid_cmd hid_no_cmd =            { .length = 0 };
 
 /*
  * These definitions are not used here, but are defined by the spec.
@@ -259,8 +260,11 @@ static int i2c_hid_set_report(struct i2c_client *client, u8 reportType,
 {
         struct i2c_hid *ihid = i2c_get_clientdata(client);
         u8 *args = ihid->argsbuf;
+        const struct i2c_hid_cmd * hidcmd = &hid_set_report_cmd;
         int ret;
         u16 dataRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
+        u16 outputRegister = le16_to_cpu(ihid->hdesc.wOutputRegister);
+        u16 maxOutputLength = le16_to_cpu(ihid->hdesc.wMaxOutputLength);
 
         /* hidraw already checked that data_len < HID_MAX_BUFFER_SIZE */
         u16 size =      2                       /* size */ +
@@ -278,8 +282,18 @@ static int i2c_hid_set_report(struct i2c_client *client, u8 reportType,
                 reportID = 0x0F;
         }
 
-        args[index++] = dataRegister & 0xFF;
-        args[index++] = dataRegister >> 8;
+        /*
+         * use the data register for feature reports or if the device does not
+         * support the output register
+         */
+        if (reportType == 0x03 || maxOutputLength == 0) {
+                args[index++] = dataRegister & 0xFF;
+                args[index++] = dataRegister >> 8;
+        } else {
+                args[index++] = outputRegister & 0xFF;
+                args[index++] = outputRegister >> 8;
+                hidcmd = &hid_no_cmd;
+        }
 
         args[index++] = size & 0xFF;
         args[index++] = size >> 8;
@@ -289,7 +303,7 @@ static int i2c_hid_set_report(struct i2c_client *client, u8 reportType,
 
         memcpy(&args[index], buf, data_len);
 
-        ret = __i2c_hid_command(client, &hid_set_report_cmd, reportID,
+        ret = __i2c_hid_command(client, hidcmd, reportID,
                 reportType, args, args_len, NULL, 0);
         if (ret) {
                 dev_err(&client->dev, "failed to set a report to device.\n");