Revert "google_msm: Wiimote changes from msm8960 kernel"lp5.0

This reverts commit 162fc497346b6e0e30a5505685e1200f6b9fc2e6.

Change-Id: I4854ab5f343b452085037b95501fb8ef60aeda7e

11 files changed, 614 insertions, 3618 deletions

diff --git a/Documentation/ABI/testing/sysfs-driver-hid-wiimote b/Documentation/ABI/testing/sysfs-driver-hid-wiimote
index 39dfa5cb1cc..3d98009f447 100644
--- a/Documentation/ABI/testing/sysfs-driver-hid-wiimote
+++ b/Documentation/ABI/testing/sysfs-driver-hid-wiimote
@@ -12,7 +12,7 @@ Description:	Make it possible to set/get current led state. Reading from it
 What:		/sys/bus/hid/drivers/wiimote/<dev>/extension
 Date:		August 2011
 KernelVersion:	3.2
-Contact:	David Herrmann <dh.herrmann@gmail.com>
+Contact:	David Herrmann <dh.herrmann@googlemail.com>
 Description:	This file contains the currently connected and initialized
 		extensions. It can be one of: none, motionp, nunchuck, classic,
 		motionp+nunchuck, motionp+classic
@@ -20,58 +20,3 @@ Description:	This file contains the currently connected and initialized
 		the official Nintendo Nunchuck extension and classic is the
 		Nintendo Classic Controller extension. The motionp extension can
 		be combined with the other two.
-		Starting with kernel-version 3.11 Motion Plus hotplugging is
-		supported and if detected, it's no longer reported as static
-		extension. You will get uevent notifications for the motion-plus
-		device then.
-
-What:		/sys/bus/hid/drivers/wiimote/<dev>/devtype
-Date:		May 2013
-KernelVersion:	3.11
-Contact:	David Herrmann <dh.herrmann@gmail.com>
-Description:	While a device is initialized by the wiimote driver, we perform
-		a device detection and signal a "change" uevent after it is
-		done. This file shows the detected device type. "pending" means
-		that the detection is still ongoing, "unknown" means, that the
-		device couldn't be detected or loaded. "generic" means, that the
-		device couldn't be detected but supports basic Wii Remote
-		features and can be used.
-		Other strings for each device-type are available and may be
-		added if new device-specific detections are added.
-		Currently supported are:
-			gen10: First Wii Remote generation
-			gen20: Second Wii Remote Plus generation (builtin MP)
-			balanceboard: Wii Balance Board
-
-What:		/sys/bus/hid/drivers/wiimote/<dev>/bboard_calib
-Date:		May 2013
-KernelVersion:	3.11
-Contact:	David Herrmann <dh.herrmann@gmail.com>
-Description:	This attribute is only provided if the device was detected as a
-		balance board. It provides a single line with 3 calibration
-		values for all 4 sensors. The values are separated by colons and
-		are each 2 bytes long (encoded as 4 digit hexadecimal value).
-		First, 0kg values for all 4 sensors are written, followed by the
-		17kg values for all 4 sensors and last the 34kg values for all 4
-		sensors.
-		Calibration data is already applied by the kernel to all input
-		values but may be used by user-space to perform other
-		transformations.
-
-What:		/sys/bus/hid/drivers/wiimote/<dev>/pro_calib
-Date:		October 2013
-KernelVersion:	3.13
-Contact:	David Herrmann <dh.herrmann@gmail.com>
-Description:	This attribute is only provided if the device was detected as a
-		pro-controller. It provides a single line with 4 calibration
-		values for all 4 analog sticks. Format is: "x1:y1 x2:y2". Data
-		is prefixed with a +/-. Each value is a signed 16bit number.
-		Data is encoded as decimal numbers and specifies the offsets of
-		the analog sticks of the pro-controller.
-		Calibration data is already applied by the kernel to all input
-		values but may be used by user-space to perform other
-		transformations.
-		Calibration data is detected by the kernel during device setup.
-		You can write "scan\n" into this file to re-trigger calibration.
-		You can also write data directly in the form "x1:y1 x2:y2" to
-		set the calibration values manually.
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 4061abba4f7..1283fa3b20a 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -628,29 +628,22 @@ config HID_WACOM_POWER_SUPPLY
 	  Wacom Bluetooth devices.
 
 config HID_WIIMOTE
-	tristate "Nintendo Wii / Wii U peripherals"
+	tristate "Nintendo Wii Remote support"
 	depends on BT_HIDP
 	depends on LEDS_CLASS
 	select POWER_SUPPLY
 	select INPUT_FF_MEMLESS
 	---help---
-	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.
+	Support for the Nintendo Wii Remote bluetooth device.
 
-	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_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.
 
 config HID_ZEROPLUS
 	tristate "Zeroplus based game controller support"
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index c0e2e540517..9dca84592cc 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -26,7 +26,10 @@ ifdef CONFIG_LOGIWHEELS_FF
 	hid-logitech-y	+= hid-lg4ff.o
 endif
 
-hid-wiimote-y		:= hid-wiimote-core.o hid-wiimote-modules.o
+hid-wiimote-y		:= hid-wiimote-core.o
+ifdef CONFIG_HID_WIIMOTE_EXT
+	hid-wiimote-y	+= hid-wiimote-ext.o
+endif
 ifdef CONFIG_DEBUG_FS
 	hid-wiimote-y	+= hid-wiimote-debug.o
 endif
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 0dba38eb5ee..4da66b4b977 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1595,7 +1595,6 @@ static const struct hid_device_id hid_have_special_driver[] = {
 
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE) },
-	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
 	{ }
 };
 
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 21e2f93a14d..e39aecb1f9f 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -557,7 +557,6 @@
 
 #define USB_VENDOR_ID_NINTENDO		0x057e
 #define USB_DEVICE_ID_NINTENDO_WIIMOTE	0x0306
-#define USB_DEVICE_ID_NINTENDO_WIIMOTE2	0x0330
 
 #define USB_VENDOR_ID_NTRIG		0x1b96
 #define USB_DEVICE_ID_NTRIG_TOUCH_SCREEN   0x0001
diff --git a/drivers/hid/hid-wiimote-core.c b/drivers/hid/hid-wiimote-core.c
index 04332313267..cac3589b1ed 100644
--- a/drivers/hid/hid-wiimote-core.c
+++ b/drivers/hid/hid-wiimote-core.c
@@ -1,6 +1,6 @@
 /*
- * HID driver for Nintendo Wii / Wii U peripherals
- * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
+ * HID driver for Nintendo Wiimote devices
+ * Copyright (c) 2011 David Herrmann
  */
 
 /*
@@ -14,19 +14,53 @@
 #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"
 
-/* output queue handling */
+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 */
+};
 
-static int wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
-			    size_t count)
+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)
 {
 	__u8 *buf;
-	int ret;
+	ssize_t ret;
 
 	if (!hdev->hid_output_raw_report)
 		return -ENODEV;
@@ -41,33 +75,24 @@ static int wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
 	return ret;
 }
 
-static void wiimote_queue_worker(struct work_struct *work)
+static void wiimote_worker(struct work_struct *work)
 {
-	struct wiimote_queue *queue = container_of(work, struct wiimote_queue,
-						   worker);
-	struct wiimote_data *wdata = container_of(queue, struct wiimote_data,
-						  queue);
+	struct wiimote_data *wdata = container_of(work, struct wiimote_data,
+									worker);
 	unsigned long flags;
-	int ret;
 
-	spin_lock_irqsave(&wdata->queue.lock, flags);
+	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);
+	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);
 
-		wdata->queue.tail = (wdata->queue.tail + 1) % WIIMOTE_BUFSIZE;
+		wdata->tail = (wdata->tail + 1) % WIIMOTE_BUFSIZE;
 	}
 
-	spin_unlock_irqrestore(&wdata->queue.lock, flags);
+	spin_unlock_irqrestore(&wdata->qlock, flags);
 }
 
 static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
@@ -78,9 +103,7 @@ 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");
-
-		spin_lock_irqsave(&wdata->queue.lock, flags);
-		goto out_error;
+		return;
 	}
 
 	/*
@@ -93,28 +116,22 @@ static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
 	 * will reschedule itself until the queue is empty.
 	 */
 
-	spin_lock_irqsave(&wdata->queue.lock, flags);
+	spin_lock_irqsave(&wdata->qlock, flags);
 
-	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;
+	memcpy(wdata->outq[wdata->head].data, buffer, count);
+	wdata->outq[wdata->head].size = count;
+	newhead = (wdata->head + 1) % WIIMOTE_BUFSIZE;
 
-	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;
+	if (wdata->head == wdata->tail) {
+		wdata->head = newhead;
+		schedule_work(&wdata->worker);
+	} else if (newhead != wdata->tail) {
+		wdata->head = newhead;
 	} else {
 		hid_warn(wdata->hdev, "Output queue is full");
-		goto out_error;
 	}
 
-	goto out_unlock;
-
-out_error:
-	wiimote_cmd_abort(wdata);
-out_unlock:
-	spin_unlock_irqrestore(&wdata->queue.lock, flags);
+	spin_unlock_irqrestore(&wdata->qlock, flags);
 }
 
 /*
@@ -130,7 +147,7 @@ static inline void wiiproto_keep_rumble(struct wiimote_data *wdata, __u8 *cmd1)
 		*cmd1 |= 0x01;
 }
 
-void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
+static void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
 {
 	__u8 cmd[2];
 
@@ -150,7 +167,7 @@ void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
 	wiimote_queue(wdata, cmd, sizeof(cmd));
 }
 
-void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
+static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
 {
 	__u8 cmd[2];
 
@@ -179,48 +196,17 @@ 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;
-
-	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;
-	}
+	bool ext = wiiext_active(wdata);
 
 	if (ir == WIIPROTO_FLAG_IR_BASIC) {
-		if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) {
-			/* GEN10 and ealier devices bind IR formats to DRMs.
-			 * Hence, we cannot use DRM_KAI here as it might be
-			 * bound to IR_EXT. Use DRM_KAIE unconditionally so we
-			 * work with all devices and our parsers can use the
-			 * fixed formats, too. */
+		if (wdata->state.flags & WIIPROTO_FLAG_ACCEL)
 			return WIIPROTO_REQ_DRM_KAIE;
-		} else {
+		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) {
@@ -233,7 +219,7 @@ static __u8 select_drm(struct wiimote_data *wdata)
 				return WIIPROTO_REQ_DRM_KA;
 		} else {
 			if (ext)
-				return WIIPROTO_REQ_DRM_KEE;
+				return WIIPROTO_REQ_DRM_KE;
 			else
 				return WIIPROTO_REQ_DRM_K;
 		}
@@ -244,9 +230,7 @@ void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
 {
 	__u8 cmd[3];
 
-	if (wdata->state.flags & WIIPROTO_FLAG_DRM_LOCKED)
-		drm = wdata->state.drm;
-	else if (drm == WIIPROTO_REQ_NULL)
+	if (drm == WIIPROTO_REQ_NULL)
 		drm = select_drm(wdata);
 
 	cmd[0] = WIIPROTO_REQ_DRM;
@@ -258,7 +242,7 @@ void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
 	wiimote_queue(wdata, cmd, sizeof(cmd));
 }
 
-void wiiproto_req_status(struct wiimote_data *wdata)
+static void wiiproto_req_status(struct wiimote_data *wdata)
 {
 	__u8 cmd[2];
 
@@ -269,7 +253,7 @@ void wiiproto_req_status(struct wiimote_data *wdata)
 	wiimote_queue(wdata, cmd, sizeof(cmd));
 }
 
-void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
+static void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
 {
 	accel = !!accel;
 	if (accel == !!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
@@ -283,7 +267,7 @@ void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
 }
 
-void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
+static void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
 {
 	__u8 cmd[2];
 
@@ -294,7 +278,7 @@ void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
 	wiimote_queue(wdata, cmd, sizeof(cmd));
 }
 
-void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags)
+static void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags)
 {
 	__u8 cmd[2];
 
@@ -410,1042 +394,420 @@ ssize_t wiimote_cmd_read(struct wiimote_data *wdata, __u32 offset, __u8 *rmem,
 	return ret;
 }
 
-/* requires the cmd-mutex to be held */
-static int wiimote_cmd_init_ext(struct wiimote_data *wdata)
+static int wiimote_battery_get_property(struct power_supply *psy,
+						enum power_supply_property psp,
+						union power_supply_propval *val)
 {
-	__u8 wmem;
-	int ret;
+	struct wiimote_data *wdata = container_of(psy,
+						struct wiimote_data, battery);
+	int ret = 0, state;
+	unsigned long flags;
 
-	/* initialize extension */
-	wmem = 0x55;
-	ret = wiimote_cmd_write(wdata, 0xa400f0, &wmem, sizeof(wmem));
-	if (ret)
-		return ret;
+	if (psp == POWER_SUPPLY_PROP_SCOPE) {
+		val->intval = POWER_SUPPLY_SCOPE_DEVICE;
+		return 0;
+	}
 
-	/* disable default encryption */
-	wmem = 0x0;
-	ret = wiimote_cmd_write(wdata, 0xa400fb, &wmem, sizeof(wmem));
+	ret = wiimote_cmd_acquire(wdata);
 	if (ret)
 		return ret;
 
-	return 0;
-}
-
-/* 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;
+	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);
 
-	/* initialize MP */
-	wmem = 0x55;
-	ret = wiimote_cmd_write(wdata, 0xa600f0, &wmem, sizeof(wmem));
-	if (ret)
-		return ret;
+	ret = wiimote_cmd_wait(wdata);
+	state = wdata->state.cmd_battery;
+	wiimote_cmd_release(wdata);
 
-	/* 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;
+	switch (psp) {
+		case POWER_SUPPLY_PROP_CAPACITY:
+			val->intval = state * 100 / 255;
+			break;
+		default:
+			ret = -EINVAL;
+			break;
 	}
 
-	return wiimote_cmd_write(wdata, 0xa600fe, &wmem, sizeof(wmem));
-}
-
-/* requires the cmd-mutex to be held */
-static bool wiimote_cmd_read_mp(struct wiimote_data *wdata, __u8 *rmem)
-{
-	int ret;
-
-	/* read motion plus ID */
-	ret = wiimote_cmd_read(wdata, 0xa600fa, rmem, 6);
-	if (ret != 6)
-		return false;
-
-	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 (rmem[5] == 0x05)
-		return true;
-
-	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]);
-
-	return false;
-}
-
-/* requires the cmd-mutex to be held */
-static __u8 wiimote_cmd_read_mp_mapped(struct wiimote_data *wdata)
-{
-	int ret;
-	__u8 rmem[6];
-
-	/* 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;
+	return ret;
 }
 
-/* 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)
+static int wiimote_init_ir(struct wiimote_data *wdata, __u16 mode)
 {
-	bool need_input = false;
-	const __u8 *mods, *iter;
-	const struct wiimod_ops *ops;
 	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 };
 
-	mods = wiimote_devtype_mods[devtype];
-
-	for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
-		if (wiimod_table[*iter]->flags & WIIMOD_FLAG_INPUT) {
-			need_input = true;
-			break;
-		}
-	}
-
-	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;
-	}
-
-	for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
-		ops = wiimod_table[*iter];
-		if (!ops->probe)
-			continue;
-
-		ret = ops->probe(ops, wdata);
-		if (ret)
-			goto error;
-	}
-
-	if (wdata->input) {
-		ret = input_register_device(wdata->input);
-		if (ret)
-			goto error;
-	}
-
-	spin_lock_irq(&wdata->state.lock);
-	wdata->state.devtype = devtype;
-	spin_unlock_irq(&wdata->state.lock);
-	return;
+	spin_lock_irqsave(&wdata->state.lock, flags);
 
-error:
-	for ( ; iter-- != mods; ) {
-		ops = wiimod_table[*iter];
-		if (ops->remove)
-			ops->remove(ops, wdata);
+	if (mode == (wdata->state.flags & WIIPROTO_FLAGS_IR)) {
+		spin_unlock_irqrestore(&wdata->state.lock, flags);
+		return 0;
 	}
 
-	if (wdata->input) {
-		input_free_device(wdata->input);
-		wdata->input = NULL;
+	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;
 	}
-}
 
-static void wiimote_modules_unload(struct wiimote_data *wdata)
-{
-	const __u8 *mods, *iter;
-	const struct wiimod_ops *ops;
-	unsigned long flags;
+	spin_unlock_irqrestore(&wdata->state.lock, flags);
 
-	mods = wiimote_devtype_mods[wdata->state.devtype];
+	ret = wiimote_cmd_acquire(wdata);
+	if (ret)
+		return ret;
 
+	/* send PIXEL CLOCK ENABLE cmd first */
 	spin_lock_irqsave(&wdata->state.lock, flags);
-	wdata->state.devtype = WIIMOTE_DEV_UNKNOWN;
+	wiimote_cmd_set(wdata, WIIPROTO_REQ_IR1, 0);
+	wiiproto_req_ir1(wdata, 0x06);
 	spin_unlock_irqrestore(&wdata->state.lock, flags);
 
-	/* 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);
+	ret = wiimote_cmd_wait(wdata);
+	if (ret)
+		goto unlock;
+	if (wdata->state.cmd_err) {
+		ret = -EIO;
+		goto unlock;
 	}
 
-	for ( ; iter-- != mods; ) {
-		ops = wiimod_table[*iter];
-		if (ops->remove)
-			ops->remove(ops, wdata);
-	}
+	/* 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 (wdata->input) {
-		input_put_device(wdata->input);
-		wdata->input = NULL;
+	ret = wiimote_cmd_wait(wdata);
+	if (ret)
+		goto unlock;
+	if (wdata->state.cmd_err) {
+		ret = -EIO;
+		goto unlock;
 	}
-}
 
-/* device extension handling */
+	/* 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;
 
-static void wiimote_ext_load(struct wiimote_data *wdata, unsigned int ext)
-{
-	unsigned long flags;
-	const struct wiimod_ops *ops;
-	int ret;
+	/* write first sensitivity block */
+	ret = wiimote_cmd_write(wdata, 0xb00000, data_sens1,
+							sizeof(data_sens1));
+	if (ret)
+		goto unlock;
 
-	ops = wiimod_ext_table[ext];
+	/* write second sensitivity block */
+	ret = wiimote_cmd_write(wdata, 0xb0001a, data_sens2,
+							sizeof(data_sens2));
+	if (ret)
+		goto unlock;
 
-	if (ops->probe) {
-		ret = ops->probe(ops, wdata);
-		if (ret)
-			ext = WIIMOTE_EXT_UNKNOWN;
+	/* 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.exttype = ext;
+	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 void wiimote_ext_unload(struct wiimote_data *wdata)
+static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
 {
+	struct wiimote_data *wdata;
+	struct device *dev = led_dev->dev->parent;
+	int i;
 	unsigned long flags;
-	const struct wiimod_ops *ops;
+	bool value = false;
 
-	ops = wiimod_ext_table[wdata->state.exttype];
+	wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
 
-	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);
+	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->remove)
-		ops->remove(ops, wdata);
+	return value ? LED_FULL : LED_OFF;
 }
 
-static void wiimote_mp_load(struct wiimote_data *wdata)
+static void wiimote_leds_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;
-	const struct wiimod_ops *ops;
-	int ret;
-	__u8 mode = 2;
+	__u8 state, flag;
 
-	ops = &wiimod_mp;
-	if (ops->probe) {
-		ret = ops->probe(ops, wdata);
-		if (ret)
-			mode = 1;
-	}
+	wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
 
-	spin_lock_irqsave(&wdata->state.lock, flags);
-	wdata->state.mp = mode;
-	spin_unlock_irqrestore(&wdata->state.lock, flags);
+	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 void wiimote_mp_unload(struct wiimote_data *wdata)
+static int wiimote_ff_play(struct input_dev *dev, void *data,
+							struct ff_effect *eff)
 {
+	struct wiimote_data *wdata = input_get_drvdata(dev);
+	__u8 value;
 	unsigned long flags;
-	const struct wiimod_ops *ops;
 
-	if (wdata->state.mp < 2)
-		return;
+	/*
+	 * 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.
+	 */
 
-	ops = &wiimod_mp;
+	if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)
+		value = 1;
+	else
+		value = 0;
 
 	spin_lock_irqsave(&wdata->state.lock, flags);
-	wdata->state.mp = 0;
-	wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED;
+	wiiproto_req_rumble(wdata, value);
 	spin_unlock_irqrestore(&wdata->state.lock, flags);
 
-	if (ops->remove)
-		ops->remove(ops, wdata);
+	return 0;
 }
 
-/* device (re-)initialization and detection */
-
-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",
-};
-
-/* 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)
+static int wiimote_input_open(struct input_dev *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;
-	}
-
-	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;
-	}
+	struct wiimote_data *wdata = input_get_drvdata(dev);
 
-	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);
+	return hid_hw_open(wdata->hdev);
 }
 
-static void wiimote_init_detect(struct wiimote_data *wdata)
+static void wiimote_input_close(struct input_dev *dev)
 {
-	__u8 exttype = WIIMOTE_EXT_NONE, extdata[6];
-	bool ext;
-	int ret;
-
-	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)
-		goto out_release;
+	struct wiimote_data *wdata = input_get_drvdata(dev);
 
-	spin_lock_irq(&wdata->state.lock);
-	ext = wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED;
-	spin_unlock_irq(&wdata->state.lock);
-
-	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);
+	hid_hw_close(wdata->hdev);
 }
 
-/*
- * 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)
+static int wiimote_accel_open(struct input_dev *dev)
 {
-	bool mp;
-	__u8 mpdata[6];
+	struct wiimote_data *wdata = input_get_drvdata(dev);
+	int ret;
+	unsigned long flags;
 
-	wiimote_cmd_acquire_noint(wdata);
-	wiimote_cmd_init_mp(wdata);
-	mp = wiimote_cmd_read_mp(wdata, mpdata);
-	wiimote_cmd_release(wdata);
+	ret = hid_hw_open(wdata->hdev);
+	if (ret)
+		return ret;
 
-	/* 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);
-	}
+	spin_lock_irqsave(&wdata->state.lock, flags);
+	wiiproto_req_accel(wdata, true);
+	spin_unlock_irqrestore(&wdata->state.lock, flags);
 
-	mod_timer(&wdata->timer, jiffies + HZ * 4);
+	return 0;
 }
 
-/*
- * 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)
+static void wiimote_accel_close(struct input_dev *dev)
 {
-	__u32 flags;
-	__u8 type, data[6];
-	bool ret, poll_mp = false;
-
-	spin_lock_irq(&wdata->state.lock);
-	flags = wdata->state.flags;
-	spin_unlock_irq(&wdata->state.lock);
-
-	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;
-	}
-
-	/* 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);
+	struct wiimote_data *wdata = input_get_drvdata(dev);
+	unsigned long flags;
 
-	/* 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);
+	spin_lock_irqsave(&wdata->state.lock, flags);
+	wiiproto_req_accel(wdata, false);
+	spin_unlock_irqrestore(&wdata->state.lock, flags);
 
-	return ret;
+	hid_hw_close(wdata->hdev);
 }
 
-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)
+static int wiimote_ir_open(struct input_dev *dev)
 {
-	__u8 exttype, extdata[6], mpdata[6];
-	__u32 flags;
-	bool mp;
-
-	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);
-}
+	struct wiimote_data *wdata = input_get_drvdata(dev);
+	int ret;
 
-static void wiimote_init_worker(struct work_struct *work)
-{
-	struct wiimote_data *wdata = container_of(work, struct wiimote_data,
-						  init_worker);
-	bool changed = false;
+	ret = hid_hw_open(wdata->hdev);
+	if (ret)
+		return ret;
 
-	if (wdata->state.devtype == WIIMOTE_DEV_PENDING) {
-		wiimote_init_detect(wdata);
-		changed = true;
+	ret = wiimote_init_ir(wdata, WIIPROTO_FLAG_IR_BASIC);
+	if (ret) {
+		hid_hw_close(wdata->hdev);
+		return ret;
 	}
 
-	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)
-{
-	if (!(wdata->state.flags & WIIPROTO_FLAG_EXITING))
-		schedule_work(&wdata->init_worker);
-}
-
-static void wiimote_schedule(struct wiimote_data *wdata)
-{
-	unsigned long flags;
-
-	spin_lock_irqsave(&wdata->state.lock, flags);
-	__wiimote_schedule(wdata);
-	spin_unlock_irqrestore(&wdata->state.lock, flags);
+	return 0;
 }
 
-static void wiimote_init_timeout(unsigned long arg)
+static void wiimote_ir_close(struct input_dev *dev)
 {
-	struct wiimote_data *wdata = (void*)arg;
+	struct wiimote_data *wdata = input_get_drvdata(dev);
 
-	wiimote_schedule(wdata);
+	wiimote_init_ir(wdata, 0);
+	hid_hw_close(wdata->hdev);
 }
 
-/* protocol handlers */
-
 static void handler_keys(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_keys) {
-		ops->in_keys(wdata, payload);
-		return;
-	}
-
-	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;
-		}
-	}
+	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);
 }
 
 static void handler_accel(struct wiimote_data *wdata, const __u8 *payload)
 {
-	const __u8 *iter, *mods;
-	const struct wiimod_ops *ops;
+	__u16 x, y, z;
 
-	ops = wiimod_ext_table[wdata->state.exttype];
-	if (ops->in_accel) {
-		ops->in_accel(wdata, payload);
+	if (!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
 		return;
-	}
-
-	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)
-{
-	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;
-}
+	/*
+	 * 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 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;
+	x = payload[2] << 2;
+	y = payload[3] << 2;
+	z = payload[4] << 2;
 
-	/* 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);
-			}
-		}
+	x |= (payload[0] >> 5) & 0x3;
+	y |= (payload[1] >> 4) & 0x2;
+	z |= (payload[1] >> 5) & 0x2;
 
-		/* detect MP data that is sent interleaved with EXT data */
-		is_mp = payload[5] & 0x02;
-	} else {
-		is_mp = false;
-	}
+	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);
+}
 
-	/* ignore EXT events if no extension is active */
-	if (!(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE) && !is_mp)
-		return;
+#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)
 
-	/* 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;
-	}
+static void __ir_to_input(struct wiimote_data *wdata, const __u8 *ir,
+						bool packed, __u8 xid, __u8 yid)
+{
+	__u16 x, y;
 
-	/* try forwarding to MP handler */
-	ops = &wiimod_mp;
-	if (is_mp && ops->in_mp) {
-		ops->in_mp(wdata, payload);
+	if (!(wdata->state.flags & WIIPROTO_FLAGS_IR))
 		return;
-	} else if (!is_mp && valid_ext_handler(ops, len)) {
-		ops->in_ext(wdata, payload);
-		return;
-	}
 
-	/* 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;
-		}
-	}
-}
+	/*
+	 * Basic IR data is encoded into 3 bytes. The first two bytes are the
+	 * upper 8 bit of the X/Y data, the 3rd byte contains the lower 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.
+	 */
 
-#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)
+	if (packed) {
+		x = ir[1] << 2;
+		y = ir[2] << 2;
 
-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;
+		x |= ir[0] & 0x3;
+		y |= (ir[0] >> 2) & 0x3;
+	} else {
+		x = ir[0] << 2;
+		y = ir[1] << 2;
 
-	ops = wiimod_ext_table[wdata->state.exttype];
-	if (ops->in_ir) {
-		ops->in_ir(wdata, payload, packed, id);
-		return;
+		x |= (ir[2] >> 4) & 0x3;
+		y |= (ir[2] >> 6) & 0x3;
 	}
 
-	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;
-		}
-	}
+	input_report_abs(wdata->ir, xid, x);
+	input_report_abs(wdata->ir, yid, y);
 }
 
-/* reduced status report with "BB BB" key data only */
-static void handler_status_K(struct wiimote_data *wdata,
-			     const __u8 *payload)
+static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
 {
 	handler_keys(wdata, payload);
 
 	/* on status reports the drm is reset so we need to resend the drm */
 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
-}
 
-/* extended status report with "BB BB LF 00 00 VV" data */
-static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
-{
-	handler_status_K(wdata, payload);
-
-	/* 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);
-		}
-	}
+	wiiext_event(wdata, payload[2] & 0x02);
 
-	wdata->state.cmd_battery = payload[5];
-	if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_SREQ, 0))
+	if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_SREQ, 0)) {
+		wdata->state.cmd_battery = payload[5];
 		wiimote_cmd_complete(wdata);
-}
-
-/* reduced generic report with "BB BB" key data only */
-static void handler_generic_K(struct wiimote_data *wdata, const __u8 *payload)
-{
-	handler_keys(wdata, payload);
+	}
 }
 
 static void handler_data(struct wiimote_data *wdata, const __u8 *payload)
@@ -1494,7 +856,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);
-	handler_ext(wdata, &payload[2], 8);
+	wiiext_handle(wdata, &payload[2]);
 }
 
 static void handler_drm_KAI(struct wiimote_data *wdata, const __u8 *payload)
@@ -1505,12 +867,13 @@ 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);
-	handler_ext(wdata, &payload[2], 19);
+	wiiext_handle(wdata, &payload[2]);
 }
 
 static void handler_drm_KIE(struct wiimote_data *wdata, const __u8 *payload)
@@ -1520,14 +883,15 @@ 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);
-	handler_ext(wdata, &payload[12], 9);
+	input_sync(wdata->ir);
+	wiiext_handle(wdata, &payload[12]);
 }
 
 static void handler_drm_KAE(struct wiimote_data *wdata, const __u8 *payload)
 {
 	handler_keys(wdata, payload);
 	handler_accel(wdata, payload);
-	handler_ext(wdata, &payload[5], 16);
+	wiiext_handle(wdata, &payload[5]);
 }
 
 static void handler_drm_KAIE(struct wiimote_data *wdata, const __u8 *payload)
@@ -1538,12 +902,13 @@ 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);
-	handler_ext(wdata, &payload[15], 6);
+	input_sync(wdata->ir);
+	wiiext_handle(wdata, &payload[15]);
 }
 
 static void handler_drm_E(struct wiimote_data *wdata, const __u8 *payload)
 {
-	handler_ext(wdata, payload, 21);
+	wiiext_handle(wdata, payload);
 }
 
 static void handler_drm_SKAI1(struct wiimote_data *wdata, const __u8 *payload)
@@ -1556,6 +921,7 @@ 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)
@@ -1576,6 +942,7 @@ 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 {
@@ -1586,26 +953,16 @@ struct wiiproto_handler {
 
 static struct wiiproto_handler handlers[] = {
 	{ .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
-	{ .id = WIIPROTO_REQ_STATUS, .size = 2, .func = handler_status_K },
 	{ .id = WIIPROTO_REQ_DATA, .size = 21, .func = handler_data },
-	{ .id = WIIPROTO_REQ_DATA, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
-	{ .id = WIIPROTO_REQ_RETURN, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
 	{ .id = WIIPROTO_REQ_DRM_KA, .size = 5, .func = handler_drm_KA },
-	{ .id = WIIPROTO_REQ_DRM_KA, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KE, .size = 10, .func = handler_drm_KE },
-	{ .id = WIIPROTO_REQ_DRM_KE, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KAI, .size = 17, .func = handler_drm_KAI },
-	{ .id = WIIPROTO_REQ_DRM_KAI, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KEE, .size = 21, .func = handler_drm_KEE },
-	{ .id = WIIPROTO_REQ_DRM_KEE, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KAE, .size = 21, .func = handler_drm_KAE },
-	{ .id = WIIPROTO_REQ_DRM_KAE, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KIE, .size = 21, .func = handler_drm_KIE },
-	{ .id = WIIPROTO_REQ_DRM_KIE, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_KAIE, .size = 21, .func = handler_drm_KAIE },
-	{ .id = WIIPROTO_REQ_DRM_KAIE, .size = 2, .func = handler_generic_K },
 	{ .id = WIIPROTO_REQ_DRM_E, .size = 21, .func = handler_drm_E },
 	{ .id = WIIPROTO_REQ_DRM_SKAI1, .size = 21, .func = handler_drm_SKAI1 },
 	{ .id = WIIPROTO_REQ_DRM_SKAI2, .size = 21, .func = handler_drm_SKAI2 },
@@ -1619,6 +976,7 @@ static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
 	struct wiiproto_handler *h;
 	int i;
 	unsigned long flags;
+	bool handled = false;
 
 	if (size < 1)
 		return -EINVAL;
@@ -1629,11 +987,11 @@ static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
 		h = &handlers[i];
 		if (h->id == raw_data[0] && h->size < size) {
 			h->func(wdata, &raw_data[1]);
-			break;
+			handled = true;
 		}
 	}
 
-	if (!handlers[i].id)
+	if (!handled)
 		hid_warn(hdev, "Unhandled report %hhu size %d\n", raw_data[0],
 									size);
 
@@ -1642,136 +1000,176 @@ static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
 	return 0;
 }
 
-static ssize_t wiimote_ext_show(struct device *dev,
-				struct device_attribute *attr,
-				char *buf)
+static void wiimote_leds_destroy(struct wiimote_data *wdata)
 {
-	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");
+	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);
+		}
 	}
 }
 
-static ssize_t wiimote_ext_store(struct device *dev,
-				 struct device_attribute *attr,
-				 const char *buf, size_t count)
+static int wiimote_leds_create(struct wiimote_data *wdata)
 {
-	struct wiimote_data *wdata = dev_to_wii(dev);
+	int i, ret;
+	struct device *dev = &wdata->hdev->dev;
+	size_t namesz = strlen(dev_name(dev)) + 9;
+	struct led_classdev *led;
+	char *name;
 
-	if (!strcmp(buf, "scan")) {
-		wiimote_schedule(wdata);
-	} else {
-		return -EINVAL;
+	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;
 	}
 
-	return strnlen(buf, PAGE_SIZE);
-}
-
-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);
+	return 0;
 
-	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");
-	}
+err:
+	wiimote_leds_destroy(wdata);
+	return ret;
 }
 
-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);
 
-	spin_lock_init(&wdata->queue.lock);
-	INIT_WORK(&wdata->queue.worker, wiimote_queue_worker);
+	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->state.lock);
 	init_completion(&wdata->state.ready);
 	mutex_init(&wdata->state.sync);
 	wdata->state.drm = WIIPROTO_REQ_DRM_K;
-	wdata->state.cmd_battery = 0xff;
-
-	INIT_WORK(&wdata->init_worker, wiimote_init_worker);
-	setup_timer(&wdata->timer, wiimote_init_timeout, (long)wdata);
 
 	return wdata;
+
+err_ir:
+	input_free_device(wdata->accel);
+err_input:
+	input_free_device(wdata->input);
+err:
+	kfree(wdata);
+	return NULL;
 }
 
 static void wiimote_destroy(struct wiimote_data *wdata)
 {
-	unsigned long flags;
-
 	wiidebug_deinit(wdata);
-
-	/* 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);
+	wiiext_deinit(wdata);
+	wiimote_leds_destroy(wdata);
+
+	power_supply_unregister(&wdata->battery);
+	input_unregister_device(wdata->accel);
+	input_unregister_device(wdata->ir);
+	input_unregister_device(wdata->input);
+	cancel_work_sync(&wdata->worker);
 	hid_hw_stop(wdata->hdev);
 
 	kfree(wdata);
@@ -1803,32 +1201,57 @@ static int wiimote_hid_probe(struct hid_device *hdev,
 		goto err;
 	}
 
-	ret = hid_hw_open(hdev);
+	ret = input_register_device(wdata->accel);
 	if (ret) {
-		hid_err(hdev, "cannot start hardware I/O\n");
+		hid_err(hdev, "Cannot register input device\n");
 		goto err_stop;
 	}
 
-	ret = device_create_file(&hdev->dev, &dev_attr_extension);
+	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);
 	if (ret) {
-		hid_err(hdev, "cannot create sysfs attribute\n");
-		goto err_close;
+		hid_err(hdev, "Cannot register input device\n");
+		goto err_input;
 	}
 
-	ret = device_create_file(&hdev->dev, &dev_attr_devtype);
+	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.name = "wiimote_battery";
+	wdata->battery.type = POWER_SUPPLY_TYPE_BATTERY;
+	wdata->battery.use_for_apm = 0;
+
+	ret = power_supply_register(&wdata->hdev->dev, &wdata->battery);
 	if (ret) {
-		hid_err(hdev, "cannot create sysfs attribute\n");
-		goto err_ext;
+		hid_err(hdev, "Cannot register battery device\n");
+		goto err_battery;
 	}
 
+	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");
 
-	/* schedule device detection */
-	wiimote_schedule(wdata);
+	/* 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);
 
 	return 0;
 
@@ -1836,15 +1259,21 @@ err_free:
 	wiimote_destroy(wdata);
 	return ret;
 
-err_ext:
-	device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
-err_close:
-	hid_hw_close(hdev);
+err_battery:
+	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_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;
 }
@@ -1860,8 +1289,6 @@ static void wiimote_hid_remove(struct hid_device *hdev)
 static const struct hid_device_id wiimote_hid_devices[] = {
 	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
 				USB_DEVICE_ID_NINTENDO_WIIMOTE) },
-	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
-				USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
 	{ }
 };
 MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
@@ -1894,4 +1321,4 @@ module_init(wiimote_init);
 module_exit(wiimote_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
-MODULE_DESCRIPTION("Driver for Nintendo Wii / Wii U peripherals");
+MODULE_DESCRIPTION(WIIMOTE_NAME " Device Driver");
diff --git a/drivers/hid/hid-wiimote-debug.c b/drivers/hid/hid-wiimote-debug.c
index e5fcedcf763..90124ffaa2a 100644
--- a/drivers/hid/hid-wiimote-debug.c
+++ b/drivers/hid/hid-wiimote-debug.c
@@ -1,6 +1,6 @@
 /*
- * Debug support for HID Nintendo Wii / Wii U peripherals
- * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
+ * Debug support for HID Nintendo Wiimote devices
+ * Copyright (c) 2011 David Herrmann
  */
 
 /*
@@ -153,10 +153,7 @@ static ssize_t wiidebug_drm_write(struct file *f, const char __user *u,
 		i = simple_strtoul(buf, NULL, 10);
 
 	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
index 8ddabb7944a..aa958706c0e 100644
--- a/drivers/hid/hid-wiimote-ext.c
+++ b/drivers/hid/hid-wiimote-ext.c
@@ -1,6 +1,6 @@
 /*
- * HID driver for Nintendo Wii / Wii U peripheral extensions
- * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
+ * HID driver for Nintendo Wiimote extension devices
+ * Copyright (c) 2011 David Herrmann
  */
 
 /*
@@ -564,6 +564,11 @@ 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);
@@ -577,11 +582,17 @@ static void wiiext_input_close(struct input_dev *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);
@@ -595,6 +606,7 @@ static void wiiext_mp_close(struct input_dev *dev)
 
 	atomic_dec(&ext->mp_opened);
 	wiiext_schedule(ext);
+	hid_hw_close(ext->wdata->hdev);
 }
 
 /* Initializes the extension driver of a wiimote */
diff --git a/drivers/hid/hid-wiimote-modules.c b/drivers/hid/hid-wiimote-modules.c
deleted file mode 100644
index 0964310d108..00000000000
--- a/drivers/hid/hid-wiimote-modules.c
+++ /dev/null
@@ -1,2203 +0,0 @@
-/*
- * 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.
- */
-
-/* used by wiimod_rumble and wiipro_rumble */
-static void wiimod_rumble_worker(struct work_struct *work)
-{
-	struct wiimote_data *wdata = container_of(work, struct wiimote_data,
-						  rumble_worker);
-
-	spin_lock_irq(&wdata->state.lock);
-	wiiproto_req_rumble(wdata, wdata->state.cache_rumble);
-	spin_unlock_irq(&wdata->state.lock);
-}
-
-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;
-
-	/*
-	 * 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;
-
-	/* Locking state.lock here might deadlock with input_event() calls.
-	 * schedule_work acts as barrier. Merging multiple changes is fine. */
-	wdata->state.cache_rumble = value;
-	schedule_work(&wdata->rumble_worker);
-
-	return 0;
-}
-
-static int wiimod_rumble_probe(const struct wiimod_ops *ops,
-			       struct wiimote_data *wdata)
-{
-	INIT_WORK(&wdata->rumble_worker, wiimod_rumble_worker);
-
-	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;
-
-	cancel_work_sync(&wdata->rumble_worker);
-
-	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 <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 (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
-		lx = ext[0] & 0x3e;
-		ly = ext[0] & 0x3e;
-	} else {
-		lx = ext[0] & 0x3f;
-		ly = ext[0] & 0x3f;
-	}
-
-	rx = (ext[0] >> 3) & 0x14;
-	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 - 0x20);
-	input_report_abs(wdata->extension.input, ABS_HAT3Y, lt - 0x20);
-
-	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);
-
-	/* zero-point offsets */
-	lx -= 0x800;
-	ly = 0x800 - ly;
-	rx -= 0x800;
-	ry = 0x800 - ry;
-
-	/* Trivial automatic calibration. We don't know any calibration data
-	 * in the EEPROM so we must use the first report to calibrate the
-	 * null-position of the analog sticks. Users can retrigger calibration
-	 * via sysfs, or set it explicitly. If data is off more than abs(500),
-	 * we skip calibration as the sticks are likely to be moved already. */
-	if (!(wdata->state.flags & WIIPROTO_FLAG_PRO_CALIB_DONE)) {
-		wdata->state.flags |= WIIPROTO_FLAG_PRO_CALIB_DONE;
-		if (abs(lx) < 500)
-			wdata->state.calib_pro_sticks[0] = -lx;
-		if (abs(ly) < 500)
-			wdata->state.calib_pro_sticks[1] = -ly;
-		if (abs(rx) < 500)
-			wdata->state.calib_pro_sticks[2] = -rx;
-		if (abs(ry) < 500)
-			wdata->state.calib_pro_sticks[3] = -ry;
-	}
-
-	/* apply calibration data */
-	lx += wdata->state.calib_pro_sticks[0];
-	ly += wdata->state.calib_pro_sticks[1];
-	rx += wdata->state.calib_pro_sticks[2];
-	ry += wdata->state.calib_pro_sticks[3];
-
-	input_report_abs(wdata->extension.input, ABS_X, lx);
-	input_report_abs(wdata->extension.input, ABS_Y, ly);
-	input_report_abs(wdata->extension.input, ABS_RX, rx);
-	input_report_abs(wdata->extension.input, ABS_RY, ry);
-
-	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;
-
-	/*
-	 * 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;
-
-	/* Locking state.lock here might deadlock with input_event() calls.
-	 * schedule_work acts as barrier. Merging multiple changes is fine. */
-	wdata->state.cache_rumble = value;
-	schedule_work(&wdata->rumble_worker);
-
-	return 0;
-}
-
-static ssize_t wiimod_pro_calib_show(struct device *dev,
-				     struct device_attribute *attr,
-				     char *out)
-{
-	struct wiimote_data *wdata = dev_to_wii(dev);
-	int r;
-
-	r = 0;
-	r += sprintf(&out[r], "%+06hd:", wdata->state.calib_pro_sticks[0]);
-	r += sprintf(&out[r], "%+06hd ", wdata->state.calib_pro_sticks[1]);
-	r += sprintf(&out[r], "%+06hd:", wdata->state.calib_pro_sticks[2]);
-	r += sprintf(&out[r], "%+06hd\n", wdata->state.calib_pro_sticks[3]);
-
-	return r;
-}
-
-static ssize_t wiimod_pro_calib_store(struct device *dev,
-				      struct device_attribute *attr,
-				      const char *buf, size_t count)
-{
-	struct wiimote_data *wdata = dev_to_wii(dev);
-	int r;
-	s16 x1, y1, x2, y2;
-
-	if (!strncmp(buf, "scan\n", 5)) {
-		spin_lock_irq(&wdata->state.lock);
-		wdata->state.flags &= ~WIIPROTO_FLAG_PRO_CALIB_DONE;
-		spin_unlock_irq(&wdata->state.lock);
-	} else {
-		r = sscanf(buf, "%hd:%hd %hd:%hd", &x1, &y1, &x2, &y2);
-		if (r != 4)
-			return -EINVAL;
-
-		spin_lock_irq(&wdata->state.lock);
-		wdata->state.flags |= WIIPROTO_FLAG_PRO_CALIB_DONE;
-		spin_unlock_irq(&wdata->state.lock);
-
-		wdata->state.calib_pro_sticks[0] = x1;
-		wdata->state.calib_pro_sticks[1] = y1;
-		wdata->state.calib_pro_sticks[2] = x2;
-		wdata->state.calib_pro_sticks[3] = y2;
-	}
-
-	return strnlen(buf, PAGE_SIZE);
-}
-
-static DEVICE_ATTR(pro_calib, S_IRUGO|S_IWUSR|S_IWGRP, wiimod_pro_calib_show,
-		   wiimod_pro_calib_store);
-
-static int wiimod_pro_probe(const struct wiimod_ops *ops,
-			    struct wiimote_data *wdata)
-{
-	int ret, i;
-	unsigned long flags;
-
-	INIT_WORK(&wdata->rumble_worker, wiimod_rumble_worker);
-	wdata->state.calib_pro_sticks[0] = 0;
-	wdata->state.calib_pro_sticks[1] = 0;
-	wdata->state.calib_pro_sticks[2] = 0;
-	wdata->state.calib_pro_sticks[3] = 0;
-
-	spin_lock_irqsave(&wdata->state.lock, flags);
-	wdata->state.flags &= ~WIIPROTO_FLAG_PRO_CALIB_DONE;
-	spin_unlock_irqrestore(&wdata->state.lock, flags);
-
-	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;
-	}
-
-	ret = device_create_file(&wdata->hdev->dev,
-				 &dev_attr_pro_calib);
-	if (ret) {
-		hid_err(wdata->hdev, "cannot create sysfs attribute\n");
-		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, -0x400, 0x400, 4, 100);
-	input_set_abs_params(wdata->extension.input,
-			     ABS_Y, -0x400, 0x400, 4, 100);
-	input_set_abs_params(wdata->extension.input,
-			     ABS_RX, -0x400, 0x400, 4, 100);
-	input_set_abs_params(wdata->extension.input,
-			     ABS_RY, -0x400, 0x400, 4, 100);
-
-	ret = input_register_device(wdata->extension.input);
-	if (ret)
-		goto err_file;
-
-	return 0;
-
-err_file:
-	device_remove_file(&wdata->hdev->dev,
-			   &dev_attr_pro_calib);
-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;
-
-	input_unregister_device(wdata->extension.input);
-	wdata->extension.input = NULL;
-	cancel_work_sync(&wdata->rumble_worker);
-	device_remove_file(&wdata->hdev->dev,
-			   &dev_attr_pro_calib);
-
-	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_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 03065f1917f..c81dbeb086c 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 Wii / Wii U peripherals
- * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
+ * HID driver for Nintendo Wiimote devices
+ * Copyright (c) 2011 David Herrmann
  */
 
 /*
@@ -22,7 +22,6 @@
 #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
@@ -36,18 +35,6 @@
 #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_FLAG_PRO_CALIB_DONE	0x040000
-
 #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 | \
@@ -56,71 +43,16 @@
 /* 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;
-	__u32 flags;
+	__u8 flags;
 	__u8 accel_split[2];
 	__u8 drm;
-	__u8 devtype;
-	__u8 exttype;
-	__u8 mp;
 
 	/* synchronous cmd requests */
 	struct mutex sync;
@@ -133,78 +65,27 @@ struct wiimote_state {
 	__u8 cmd_err;
 	__u8 *cmd_read_buf;
 	__u8 cmd_read_size;
-
-	/* calibration/cache data */
-	__u16 calib_bboard[4][3];
-	__s16 calib_pro_sticks[4];
-	__u8 cache_rumble;
 };
 
 struct wiimote_data {
 	struct hid_device *hdev;
 	struct input_dev *input;
-	struct work_struct rumble_worker;
 	struct led_classdev *leds[4];
 	struct input_dev *accel;
 	struct input_dev *ir;
 	struct power_supply battery;
-	struct input_dev *mp;
-	struct timer_list timer;
+	struct wiimote_ext *ext;
 	struct wiimote_debug *debug;
 
-	union {
-		struct input_dev *input;
-	} extension;
+	spinlock_t qlock;
+	__u8 head;
+	__u8 tail;
+	struct wiimote_buf outq[WIIMOTE_BUFSIZE];
+	struct work_struct worker;
 
-	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,
@@ -218,55 +99,24 @@ 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,
@@ -279,6 +129,24 @@ 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);
@@ -305,26 +173,11 @@ 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)
@@ -343,31 +196,11 @@ 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/include/linux/input.h b/include/linux/input.h
index 9bea2ffd8b1..d4cdb02c9de 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -511,14 +511,10 @@ struct input_keymap_entry {
 
 #define BTN_GAMEPAD		0x130
 #define BTN_A			0x130
-#define BTN_SOUTH		0x130
 #define BTN_B			0x131
-#define BTN_EAST		0x131
 #define BTN_C			0x132
 #define BTN_X			0x133
-#define BTN_NORTH		0x133
 #define BTN_Y			0x134
-#define BTN_WEST		0x134
 #define BTN_Z			0x135
 #define BTN_TL			0x136
 #define BTN_TR			0x137
@@ -710,11 +706,6 @@ struct input_keymap_entry {
 #define KEY_CAMERA_LEFT		0x219
 #define KEY_CAMERA_RIGHT	0x21a
 
-#define BTN_DPAD_UP		0x220
-#define BTN_DPAD_DOWN		0x221
-#define BTN_DPAD_LEFT		0x222
-#define BTN_DPAD_RIGHT		0x223
-
 #define BTN_TRIGGER_HAPPY		0x2c0
 #define BTN_TRIGGER_HAPPY1		0x2c0
 #define BTN_TRIGGER_HAPPY2		0x2c1