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

This reverts commit 162fc497346b6e0e30a5505685e1200f6b9fc2e6.

Change-Id: I4854ab5f343b452085037b95501fb8ef60aeda7e

9 files changed, 613 insertions, 3553 deletions

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;
 }