HID: wiimote: remove old static extension support (45ec9fff) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/hid/Kconfig

+0 −9

Original line number	Original line	Diff line number	Diff line
	@@ -731,15 +731,6 @@ config HID_WIIMOTE
	To compile this driver as a module, choose M here: the		To compile this driver as a module, choose M here: the
	module will be called hid-wiimote.		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		config HID_ZEROPLUS
	tristate "Zeroplus based game controller support"		tristate "Zeroplus based game controller support"
	depends on HID		depends on HID

drivers/hid/Makefile

+0 −3

Original line number	Original line	Diff line number	Diff line
	@@ -29,9 +29,6 @@ ifdef CONFIG_LOGIWHEELS_FF
	endif		endif

	hid-wiimote-y := hid-wiimote-core.o hid-wiimote-modules.o		hid-wiimote-y := hid-wiimote-core.o hid-wiimote-modules.o
	ifdef CONFIG_HID_WIIMOTE_EXT
	hid-wiimote-y += hid-wiimote-ext.o
	endif
	ifdef CONFIG_DEBUG_FS		ifdef CONFIG_DEBUG_FS
	hid-wiimote-y += hid-wiimote-debug.o		hid-wiimote-y += hid-wiimote-debug.o
	endif		endif

drivers/hid/hid-wiimote-ext.c

deleted100644 → 0

+0 −837

Original line number	Original line	Diff line number	Diff line
	/*
	* HID driver for Nintendo Wii / Wii U peripheral extensions
	* 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.
	*/

	#include <linux/atomic.h>
	#include <linux/module.h>
	#include <linux/spinlock.h>
	#include <linux/workqueue.h>
	#include "hid-wiimote.h"

	struct wiimote_ext {
	struct wiimote_data *wdata;
	struct work_struct worker;
	struct input_dev *input;
	struct input_dev *mp_input;

	atomic_t opened;
	atomic_t mp_opened;
	bool plugged;
	bool mp_plugged;
	bool motionp;
	__u8 ext_type;
	__u16 calib[4][3];
	};

	enum wiiext_type {
	WIIEXT_NONE, /* placeholder */
	WIIEXT_CLASSIC, /* Nintendo classic controller */
	WIIEXT_NUNCHUCK, /* Nintendo nunchuck controller */
	WIIEXT_BALANCE_BOARD, /* Nintendo balance board controller */
	};

	enum wiiext_keys {
	WIIEXT_KEY_C,
	WIIEXT_KEY_Z,
	WIIEXT_KEY_A,
	WIIEXT_KEY_B,
	WIIEXT_KEY_X,
	WIIEXT_KEY_Y,
	WIIEXT_KEY_ZL,
	WIIEXT_KEY_ZR,
	WIIEXT_KEY_PLUS,
	WIIEXT_KEY_MINUS,
	WIIEXT_KEY_HOME,
	WIIEXT_KEY_LEFT,
	WIIEXT_KEY_RIGHT,
	WIIEXT_KEY_UP,
	WIIEXT_KEY_DOWN,
	WIIEXT_KEY_LT,
	WIIEXT_KEY_RT,
	WIIEXT_KEY_COUNT
	};

	static __u16 wiiext_keymap[] = {
	BTN_C, /* WIIEXT_KEY_C */
	BTN_Z, /* WIIEXT_KEY_Z */
	BTN_A, /* WIIEXT_KEY_A */
	BTN_B, /* WIIEXT_KEY_B */
	BTN_X, /* WIIEXT_KEY_X */
	BTN_Y, /* WIIEXT_KEY_Y */
	BTN_TL2, /* WIIEXT_KEY_ZL */
	BTN_TR2, /* WIIEXT_KEY_ZR */
	KEY_NEXT, /* WIIEXT_KEY_PLUS */
	KEY_PREVIOUS, /* WIIEXT_KEY_MINUS */
	BTN_MODE, /* WIIEXT_KEY_HOME */
	KEY_LEFT, /* WIIEXT_KEY_LEFT */
	KEY_RIGHT, /* WIIEXT_KEY_RIGHT */
	KEY_UP, /* WIIEXT_KEY_UP */
	KEY_DOWN, /* WIIEXT_KEY_DOWN */
	BTN_TL, /* WIIEXT_KEY_LT */
	BTN_TR, /* WIIEXT_KEY_RT */
	};

	/* disable all extensions */
	static void ext_disable(struct wiimote_ext *ext)
	{
	unsigned long flags;
	__u8 wmem = 0x55;

	if (!wiimote_cmd_acquire(ext->wdata)) {
	wiimote_cmd_write(ext->wdata, 0xa400f0, &wmem, sizeof(wmem));
	wiimote_cmd_release(ext->wdata);
	}

	spin_lock_irqsave(&ext->wdata->state.lock, flags);
	ext->motionp = false;
	ext->ext_type = WIIEXT_NONE;
	wiiproto_req_drm(ext->wdata, WIIPROTO_REQ_NULL);
	spin_unlock_irqrestore(&ext->wdata->state.lock, flags);
	}

	static bool motionp_read(struct wiimote_ext *ext)
	{
	__u8 rmem[2], wmem;
	ssize_t ret;
	bool avail = false;

	if (!atomic_read(&ext->mp_opened))
	return false;

	if (wiimote_cmd_acquire(ext->wdata))
	return false;

	/* initialize motion plus */
	wmem = 0x55;
	ret = wiimote_cmd_write(ext->wdata, 0xa600f0, &wmem, sizeof(wmem));
	if (ret)
	goto error;

	/* read motion plus ID */
	ret = wiimote_cmd_read(ext->wdata, 0xa600fe, rmem, 2);
	if (ret == 2 \|\| rmem[1] == 0x5)
	avail = true;

	error:
	wiimote_cmd_release(ext->wdata);
	return avail;
	}

	static __u8 ext_read(struct wiimote_ext *ext)
	{
	ssize_t ret;
	__u8 buf[24], i, j, offs = 0;
	__u8 rmem[2], wmem;
	__u8 type = WIIEXT_NONE;

	if (!ext->plugged \|\| !atomic_read(&ext->opened))
	return WIIEXT_NONE;

	if (wiimote_cmd_acquire(ext->wdata))
	return WIIEXT_NONE;

	/* initialize extension */
	wmem = 0x55;
	ret = wiimote_cmd_write(ext->wdata, 0xa400f0, &wmem, sizeof(wmem));
	if (!ret) {
	/* disable encryption */
	wmem = 0x0;
	wiimote_cmd_write(ext->wdata, 0xa400fb, &wmem, sizeof(wmem));
	}

	/* read extension ID */
	ret = wiimote_cmd_read(ext->wdata, 0xa400fe, rmem, 2);
	if (ret == 2) {
	if (rmem[0] == 0 && rmem[1] == 0)
	type = WIIEXT_NUNCHUCK;
	else if (rmem[0] == 0x01 && rmem[1] == 0x01)
	type = WIIEXT_CLASSIC;
	else if (rmem[0] == 0x04 && rmem[1] == 0x02)
	type = WIIEXT_BALANCE_BOARD;
	}

	/* get balance board calibration data */
	if (type == WIIEXT_BALANCE_BOARD) {
	ret = wiimote_cmd_read(ext->wdata, 0xa40024, buf, 12);
	ret += wiimote_cmd_read(ext->wdata, 0xa40024 + 12,
	buf + 12, 12);

	if (ret != 24) {
	type = WIIEXT_NONE;
	} else {
	for (i = 0; i < 3; i++) {
	for (j = 0; j < 4; j++) {
	ext->calib[j][i] = buf[offs];
	ext->calib[j][i] <<= 8;
	ext->calib[j][i] \|= buf[offs + 1];
	offs += 2;
	}
	}
	}
	}

	wiimote_cmd_release(ext->wdata);

	return type;
	}

	static void ext_enable(struct wiimote_ext *ext, bool motionp, __u8 ext_type)
	{
	unsigned long flags;
	__u8 wmem;
	int ret;

	if (motionp) {
	if (wiimote_cmd_acquire(ext->wdata))
	return;

	if (ext_type == WIIEXT_CLASSIC)
	wmem = 0x07;
	else if (ext_type == WIIEXT_NUNCHUCK)
	wmem = 0x05;
	else
	wmem = 0x04;

	ret = wiimote_cmd_write(ext->wdata, 0xa600fe, &wmem, sizeof(wmem));
	wiimote_cmd_release(ext->wdata);
	if (ret)
	return;
	}

	spin_lock_irqsave(&ext->wdata->state.lock, flags);
	ext->motionp = motionp;
	ext->ext_type = ext_type;
	wiiproto_req_drm(ext->wdata, WIIPROTO_REQ_NULL);
	spin_unlock_irqrestore(&ext->wdata->state.lock, flags);
	}

	static void wiiext_worker(struct work_struct *work)
	{
	struct wiimote_ext *ext = container_of(work, struct wiimote_ext,
	worker);
	bool motionp;
	__u8 ext_type;

	ext_disable(ext);
	motionp = motionp_read(ext);
	ext_type = ext_read(ext);
	ext_enable(ext, motionp, ext_type);
	}

	/* schedule work only once, otherwise mark for reschedule */
	static void wiiext_schedule(struct wiimote_ext *ext)
	{
	schedule_work(&ext->worker);
	}

	/*
	* Reacts on extension port events
	* Whenever the driver gets an event from the wiimote that an extension has been
	* plugged or unplugged, this funtion shall be called. It checks what extensions
	* are connected and initializes and activates them.
	* This can be called in atomic context. The initialization is done in a
	* separate worker thread. The state.lock spinlock must be held by the caller.
	*/
	void wiiext_event(struct wiimote_data *wdata, bool plugged)
	{
	if (!wdata->ext)
	return;

	if (wdata->ext->plugged == plugged)
	return;

	wdata->ext->plugged = plugged;

	if (!plugged)
	wdata->ext->mp_plugged = false;

	/*
	* We need to call wiiext_schedule(wdata->ext) here, however, the
	* extension initialization logic is not fully understood and so
	* automatic initialization is not supported, yet.
	*/
	}

	/*
	* Returns true if the current DRM mode should contain extension data and false
	* if there is no interest in extension data.
	* All supported extensions send 6 byte extension data so any DRM that contains
	* extension bytes is fine.
	* The caller must hold the state.lock spinlock.
	*/
	bool wiiext_active(struct wiimote_data *wdata)
	{
	if (!wdata->ext)
	return false;

	return wdata->ext->motionp \|\| wdata->ext->ext_type;
	}

	static void handler_motionp(struct wiimote_ext ext, const __u8 payload)
	{
	__s32 x, y, z;
	bool plugged;

	/* \| 8 7 6 5 4 3 \| 2 \| 1 \|
	* -----+------------------------------+-----+-----+
	* 1 \| Yaw Speed <7:0> \|
	* 2 \| Roll Speed <7:0> \|
	* 3 \| Pitch Speed <7:0> \|
	* -----+------------------------------+-----+-----+
	* 4 \| Yaw Speed <13:8> \| Yaw \|Pitch\|
	* -----+------------------------------+-----+-----+
	* 5 \| Roll Speed <13:8> \|Roll \| Ext \|
	* -----+------------------------------+-----+-----+
	* 6 \| Pitch Speed <13:8> \| 1 \| 0 \|
	* -----+------------------------------+-----+-----+
	* The single bits Yaw, Roll, Pitch in the lower right corner specify
	* whether the wiimote is rotating fast (0) or slow (1). Speed for slow
	* roation is 440 deg/s and for fast rotation 2000 deg/s. To get a
	* linear scale we multiply by 2000/440 = ~4.5454 which is 18 for fast
	* and 9 for slow.
	* If the wiimote is not rotating the sensor reports 2^13 = 8192.
	* Ext specifies whether an extension is connected to the motionp.
	*/

	x = payload[0];
	y = payload[1];
	z = payload[2];

	x \|= (((__u16)payload[3]) << 6) & 0xff00;
	y \|= (((__u16)payload[4]) << 6) & 0xff00;
	z \|= (((__u16)payload[5]) << 6) & 0xff00;

	x -= 8192;
	y -= 8192;
	z -= 8192;

	if (!(payload[3] & 0x02))
	x *= 18;
	else
	x *= 9;
	if (!(payload[4] & 0x02))
	y *= 18;
	else
	y *= 9;
	if (!(payload[3] & 0x01))
	z *= 18;
	else
	z *= 9;

	input_report_abs(ext->mp_input, ABS_RX, x);
	input_report_abs(ext->mp_input, ABS_RY, y);
	input_report_abs(ext->mp_input, ABS_RZ, z);
	input_sync(ext->mp_input);

	plugged = payload[5] & 0x01;
	if (plugged != ext->mp_plugged)
	ext->mp_plugged = plugged;
	}

	static void handler_nunchuck(struct wiimote_ext ext, const __u8 payload)
	{
	__s16 x, y, z, bx, by;

	/* Byte \| 8 7 \| 6 5 \| 4 3 \| 2 \| 1 \|
	* -----+----------+---------+---------+----+-----+
	* 1 \| Button X <7:0> \|
	* 2 \| Button Y <7:0> \|
	* -----+----------+---------+---------+----+-----+
	* 3 \| Speed X <9:2> \|
	* 4 \| Speed Y <9:2> \|
	* 5 \| Speed Z <9:2> \|
	* -----+----------+---------+---------+----+-----+
	* 6 \| Z <1:0> \| Y <1:0> \| X <1:0> \| BC \| BZ \|
	* -----+----------+---------+---------+----+-----+
	* Button X/Y is the analog stick. Speed X, Y and Z are the
	* accelerometer data in the same format as the wiimote's accelerometer.
	* The 6th byte contains the LSBs of the accelerometer data.
	* BC and BZ are the C and Z buttons: 0 means pressed
	*
	* If reported interleaved with motionp, then the layout changes. The
	* 5th and 6th byte changes to:
	* -----+-----------------------------------+-----+
	* 5 \| Speed Z <9:3> \| EXT \|
	* -----+--------+-----+-----+----+----+----+-----+
	* 6 \|Z <2:1> \|Y <1>\|X <1>\| BC \| BZ \| 0 \| 0 \|
	* -----+--------+-----+-----+----+----+----+-----+
	* All three accelerometer values lose their LSB. The other data is
	* still available but slightly moved.
	*
	* Center data for button values is 128. Center value for accelerometer
	* values it 512 / 0x200
	*/

	bx = payload[0];
	by = payload[1];
	bx -= 128;
	by -= 128;

	x = payload[2] << 2;
	y = payload[3] << 2;
	z = payload[4] << 2;

	if (ext->motionp) {
	x \|= (payload[5] >> 3) & 0x02;
	y \|= (payload[5] >> 4) & 0x02;
	z &= ~0x4;
	z \|= (payload[5] >> 5) & 0x06;
	} else {
	x \|= (payload[5] >> 2) & 0x03;
	y \|= (payload[5] >> 4) & 0x03;
	z \|= (payload[5] >> 6) & 0x03;
	}

	x -= 0x200;
	y -= 0x200;
	z -= 0x200;

	input_report_abs(ext->input, ABS_HAT0X, bx);
	input_report_abs(ext->input, ABS_HAT0Y, by);

	input_report_abs(ext->input, ABS_RX, x);
	input_report_abs(ext->input, ABS_RY, y);
	input_report_abs(ext->input, ABS_RZ, z);

	if (ext->motionp) {
	input_report_key(ext->input,
	wiiext_keymap[WIIEXT_KEY_Z], !(payload[5] & 0x04));
	input_report_key(ext->input,
	wiiext_keymap[WIIEXT_KEY_C], !(payload[5] & 0x08));
	} else {
	input_report_key(ext->input,
	wiiext_keymap[WIIEXT_KEY_Z], !(payload[5] & 0x01));
	input_report_key(ext->input,
	wiiext_keymap[WIIEXT_KEY_C], !(payload[5] & 0x02));
	}

	input_sync(ext->input);
	}

	static void handler_classic(struct wiimote_ext ext, const __u8 payload)
	{
	__s8 rx, ry, lx, ly, lt, rt;

	/* Byte \| 8 \| 7 \| 6 \| 5 \| 4 \| 3 \| 2 \| 1 \|
	* -----+-----+-----+-----+-----+-----+-----+-----+-----+
	* 1 \| RX <5:4> \| LX <5:0> \|
	* 2 \| RX <3:2> \| LY <5:0> \|
	* -----+-----+-----+-----+-----------------------------+
	* 3 \|RX<1>\| LT <5:4> \| RY <5:1> \|
	* -----+-----+-----------+-----------------------------+
	* 4 \| LT <3:1> \| RT <5:1> \|
	* -----+-----+-----+-----+-----+-----+-----+-----+-----+
	* 5 \| BDR \| BDD \| BLT \| B- \| BH \| B+ \| BRT \| 1 \|
	* -----+-----+-----+-----+-----+-----+-----+-----+-----+
	* 6 \| BZL \| BB \| BY \| BA \| BX \| BZR \| BDL \| BDU \|
	* -----+-----+-----+-----+-----+-----+-----+-----+-----+
	* All buttons are 0 if pressed
	* RX and RY are right analog stick
	* LX and LY are left analog stick
	* LT is left trigger, RT is right trigger
	* BLT is 0 if left trigger is fully pressed
	* BRT is 0 if right trigger is fully pressed
	* BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons
	* BZL is left Z button and BZR is right Z button
	* B-, BH, B+ are +, HOME and - buttons
	* BB, BY, BA, BX are A, B, X, Y buttons
	* LSB of RX, RY, LT, and RT are not transmitted and always 0.
	*
	* With motionp enabled it changes slightly to this:
	* Byte \| 8 \| 7 \| 6 \| 5 \| 4 \| 3 \| 2 \| 1 \|
	* -----+-----+-----+-----+-----+-----+-----+-----+-----+
	* 1 \| RX <4:3> \| LX <5:1> \| BDU \|
	* 2 \| RX <2:1> \| LY <5:1> \| BDL \|
	* -----+-----+-----+-----+-----------------------+-----+
	* 3 \|RX<0>\| LT <4:3> \| RY <4:0> \|
	* -----+-----+-----------+-----------------------------+
	* 4 \| LT <2:0> \| RT <4:0> \|
	* -----+-----+-----+-----+-----+-----+-----+-----+-----+
	* 5 \| BDR \| BDD \| BLT \| B- \| BH \| B+ \| BRT \| EXT \|
	* -----+-----+-----+-----+-----+-----+-----+-----+-----+
	* 6 \| BZL \| BB \| BY \| BA \| BX \| BZR \| 0 \| 0 \|
	* -----+-----+-----+-----+-----+-----+-----+-----+-----+
	* Only the LSBs of LX and LY are lost. BDU and BDL are moved, the rest
	* is the same as before.
	*/

	if (ext->motionp) {
	lx = payload[0] & 0x3e;
	ly = payload[0] & 0x3e;
	} else {
	lx = payload[0] & 0x3f;
	ly = payload[0] & 0x3f;
	}

	rx = (payload[0] >> 3) & 0x14;
	rx \|= (payload[1] >> 5) & 0x06;
	rx \|= (payload[2] >> 7) & 0x01;
	ry = payload[2] & 0x1f;

	rt = payload[3] & 0x1f;
	lt = (payload[2] >> 2) & 0x18;
	lt \|= (payload[3] >> 5) & 0x07;

	rx <<= 1;
	ry <<= 1;
	rt <<= 1;
	lt <<= 1;

	input_report_abs(ext->input, ABS_HAT1X, lx - 0x20);
	input_report_abs(ext->input, ABS_HAT1Y, ly - 0x20);
	input_report_abs(ext->input, ABS_HAT2X, rx - 0x20);
	input_report_abs(ext->input, ABS_HAT2Y, ry - 0x20);
	input_report_abs(ext->input, ABS_HAT3X, rt - 0x20);
	input_report_abs(ext->input, ABS_HAT3Y, lt - 0x20);

	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_RIGHT],
	!!(payload[4] & 0x80));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_DOWN],
	!!(payload[4] & 0x40));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LT],
	!!(payload[4] & 0x20));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_MINUS],
	!!(payload[4] & 0x10));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_HOME],
	!!(payload[4] & 0x08));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_PLUS],
	!!(payload[4] & 0x04));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_RT],
	!!(payload[4] & 0x02));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_ZL],
	!!(payload[5] & 0x80));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_B],
	!!(payload[5] & 0x40));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_Y],
	!!(payload[5] & 0x20));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_A],
	!!(payload[5] & 0x10));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_X],
	!!(payload[5] & 0x08));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_ZR],
	!!(payload[5] & 0x04));

	if (ext->motionp) {
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_UP],
	!!(payload[0] & 0x01));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LEFT],
	!!(payload[1] & 0x01));
	} else {
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_UP],
	!!(payload[5] & 0x01));
	input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LEFT],
	!!(payload[5] & 0x02));
	}

	input_sync(ext->input);
	}

	static void handler_balance_board(struct wiimote_ext ext, const __u8 payload)
	{
	__s32 val[4], tmp;
	unsigned int i;

	/* Byte \| 8 7 6 5 4 3 2 1 \|
	* -----+--------------------------+
	* 1 \| Top Right <15:8> \|
	* 2 \| Top Right <7:0> \|
	* -----+--------------------------+
	* 3 \| Bottom Right <15:8> \|
	* 4 \| Bottom Right <7:0> \|
	* -----+--------------------------+
	* 5 \| Top Left <15:8> \|
	* 6 \| Top Left <7:0> \|
	* -----+--------------------------+
	* 7 \| Bottom Left <15:8> \|
	* 8 \| Bottom Left <7:0> \|
	* -----+--------------------------+
	*
	* These values represent the weight-measurements of the Wii-balance
	* board with 16bit precision.
	*
	* The balance-board is never reported interleaved with motionp.
	*/

	val[0] = payload[0];
	val[0] <<= 8;
	val[0] \|= payload[1];

	val[1] = payload[2];
	val[1] <<= 8;
	val[1] \|= payload[3];

	val[2] = payload[4];
	val[2] <<= 8;
	val[2] \|= payload[5];

	val[3] = payload[6];
	val[3] <<= 8;
	val[3] \|= payload[7];

	/* apply calibration data */
	for (i = 0; i < 4; i++) {
	if (val[i] < ext->calib[i][1]) {
	tmp = val[i] - ext->calib[i][0];
	tmp *= 1700;
	tmp /= ext->calib[i][1] - ext->calib[i][0];
	} else {
	tmp = val[i] - ext->calib[i][1];
	tmp *= 1700;
	tmp /= ext->calib[i][2] - ext->calib[i][1];
	tmp += 1700;
	}
	val[i] = tmp;
	}

	input_report_abs(ext->input, ABS_HAT0X, val[0]);
	input_report_abs(ext->input, ABS_HAT0Y, val[1]);
	input_report_abs(ext->input, ABS_HAT1X, val[2]);
	input_report_abs(ext->input, ABS_HAT1Y, val[3]);

	input_sync(ext->input);
	}

	/* call this with state.lock spinlock held */
	void wiiext_handle(struct wiimote_data wdata, const __u8 payload)
	{
	struct wiimote_ext *ext = wdata->ext;

	if (!ext)
	return;

	if (ext->motionp && (payload[5] & 0x02)) {
	handler_motionp(ext, payload);
	} else if (ext->ext_type == WIIEXT_NUNCHUCK) {
	handler_nunchuck(ext, payload);
	} else if (ext->ext_type == WIIEXT_CLASSIC) {
	handler_classic(ext, payload);
	} else if (ext->ext_type == WIIEXT_BALANCE_BOARD) {
	handler_balance_board(ext, payload);
	}
	}

	static ssize_t wiiext_show(struct device dev, struct device_attribute attr,
	char *buf)
	{
	struct wiimote_data *wdata = dev_to_wii(dev);
	__u8 type = WIIEXT_NONE;
	bool motionp = false;
	unsigned long flags;

	spin_lock_irqsave(&wdata->state.lock, flags);
	if (wdata->ext) {
	motionp = wdata->ext->motionp;
	type = wdata->ext->ext_type;
	}
	spin_unlock_irqrestore(&wdata->state.lock, flags);

	if (type == WIIEXT_NUNCHUCK) {
	if (motionp)
	return sprintf(buf, "motionp+nunchuck\n");
	else
	return sprintf(buf, "nunchuck\n");
	} else if (type == WIIEXT_CLASSIC) {
	if (motionp)
	return sprintf(buf, "motionp+classic\n");
	else
	return sprintf(buf, "classic\n");
	} else if (type == WIIEXT_BALANCE_BOARD) {
	if (motionp)
	return sprintf(buf, "motionp+balanceboard\n");
	else
	return sprintf(buf, "balanceboard\n");
	} else {
	if (motionp)
	return sprintf(buf, "motionp\n");
	else
	return sprintf(buf, "none\n");
	}
	}

	static DEVICE_ATTR(extension, S_IRUGO, wiiext_show, NULL);

	static int wiiext_input_open(struct input_dev *dev)
	{
	struct wiimote_ext *ext = input_get_drvdata(dev);

	atomic_inc(&ext->opened);
	wiiext_schedule(ext);

	return 0;
	}

	static void wiiext_input_close(struct input_dev *dev)
	{
	struct wiimote_ext *ext = input_get_drvdata(dev);

	atomic_dec(&ext->opened);
	wiiext_schedule(ext);
	}

	static int wiiext_mp_open(struct input_dev *dev)
	{
	struct wiimote_ext *ext = input_get_drvdata(dev);

	atomic_inc(&ext->mp_opened);
	wiiext_schedule(ext);

	return 0;
	}

	static void wiiext_mp_close(struct input_dev *dev)
	{
	struct wiimote_ext *ext = input_get_drvdata(dev);

	atomic_dec(&ext->mp_opened);
	wiiext_schedule(ext);
	}

	/* Initializes the extension driver of a wiimote */
	int wiiext_init(struct wiimote_data *wdata)
	{
	struct wiimote_ext *ext;
	unsigned long flags;
	int ret, i;

	ext = kzalloc(sizeof(*ext), GFP_KERNEL);
	if (!ext)
	return -ENOMEM;

	ext->wdata = wdata;
	INIT_WORK(&ext->worker, wiiext_worker);

	ext->input = input_allocate_device();
	if (!ext->input) {
	ret = -ENOMEM;
	goto err_input;
	}

	input_set_drvdata(ext->input, ext);
	ext->input->open = wiiext_input_open;
	ext->input->close = wiiext_input_close;
	ext->input->dev.parent = &wdata->hdev->dev;
	ext->input->id.bustype = wdata->hdev->bus;
	ext->input->id.vendor = wdata->hdev->vendor;
	ext->input->id.product = wdata->hdev->product;
	ext->input->id.version = wdata->hdev->version;
	ext->input->name = WIIMOTE_NAME " Extension";

	set_bit(EV_KEY, ext->input->evbit);
	for (i = 0; i < WIIEXT_KEY_COUNT; ++i)
	set_bit(wiiext_keymap[i], ext->input->keybit);

	set_bit(EV_ABS, ext->input->evbit);
	set_bit(ABS_HAT0X, ext->input->absbit);
	set_bit(ABS_HAT0Y, ext->input->absbit);
	set_bit(ABS_HAT1X, ext->input->absbit);
	set_bit(ABS_HAT1Y, ext->input->absbit);
	set_bit(ABS_HAT2X, ext->input->absbit);
	set_bit(ABS_HAT2Y, ext->input->absbit);
	set_bit(ABS_HAT3X, ext->input->absbit);
	set_bit(ABS_HAT3Y, ext->input->absbit);
	input_set_abs_params(ext->input, ABS_HAT0X, -120, 120, 2, 4);
	input_set_abs_params(ext->input, ABS_HAT0Y, -120, 120, 2, 4);
	input_set_abs_params(ext->input, ABS_HAT1X, -30, 30, 1, 1);
	input_set_abs_params(ext->input, ABS_HAT1Y, -30, 30, 1, 1);
	input_set_abs_params(ext->input, ABS_HAT2X, -30, 30, 1, 1);
	input_set_abs_params(ext->input, ABS_HAT2Y, -30, 30, 1, 1);
	input_set_abs_params(ext->input, ABS_HAT3X, -30, 30, 1, 1);
	input_set_abs_params(ext->input, ABS_HAT3Y, -30, 30, 1, 1);
	set_bit(ABS_RX, ext->input->absbit);
	set_bit(ABS_RY, ext->input->absbit);
	set_bit(ABS_RZ, ext->input->absbit);
	input_set_abs_params(ext->input, ABS_RX, -500, 500, 2, 4);
	input_set_abs_params(ext->input, ABS_RY, -500, 500, 2, 4);
	input_set_abs_params(ext->input, ABS_RZ, -500, 500, 2, 4);

	ret = input_register_device(ext->input);
	if (ret) {
	input_free_device(ext->input);
	goto err_input;
	}

	ext->mp_input = input_allocate_device();
	if (!ext->mp_input) {
	ret = -ENOMEM;
	goto err_mp;
	}

	input_set_drvdata(ext->mp_input, ext);
	ext->mp_input->open = wiiext_mp_open;
	ext->mp_input->close = wiiext_mp_close;
	ext->mp_input->dev.parent = &wdata->hdev->dev;
	ext->mp_input->id.bustype = wdata->hdev->bus;
	ext->mp_input->id.vendor = wdata->hdev->vendor;
	ext->mp_input->id.product = wdata->hdev->product;
	ext->mp_input->id.version = wdata->hdev->version;
	ext->mp_input->name = WIIMOTE_NAME " Motion+";

	set_bit(EV_ABS, ext->mp_input->evbit);
	set_bit(ABS_RX, ext->mp_input->absbit);
	set_bit(ABS_RY, ext->mp_input->absbit);
	set_bit(ABS_RZ, ext->mp_input->absbit);
	input_set_abs_params(ext->mp_input, ABS_RX, -160000, 160000, 4, 8);
	input_set_abs_params(ext->mp_input, ABS_RY, -160000, 160000, 4, 8);
	input_set_abs_params(ext->mp_input, ABS_RZ, -160000, 160000, 4, 8);

	ret = input_register_device(ext->mp_input);
	if (ret) {
	input_free_device(ext->mp_input);
	goto err_mp;
	}

	ret = device_create_file(&wdata->hdev->dev, &dev_attr_extension);
	if (ret)
	goto err_dev;

	spin_lock_irqsave(&wdata->state.lock, flags);
	wdata->ext = ext;
	spin_unlock_irqrestore(&wdata->state.lock, flags);

	return 0;

	err_dev:
	input_unregister_device(ext->mp_input);
	err_mp:
	input_unregister_device(ext->input);
	err_input:
	kfree(ext);
	return ret;
	}

	/* Deinitializes the extension driver of a wiimote */
	void wiiext_deinit(struct wiimote_data *wdata)
	{
	struct wiimote_ext *ext = wdata->ext;
	unsigned long flags;

	if (!ext)
	return;

	/*
	* We first unset wdata->ext to avoid further input from the wiimote
	* core. The worker thread does not access this pointer so it is not
	* affected by this.
	* We kill the worker after this so it does not get respawned during
	* deinitialization.
	*/

	spin_lock_irqsave(&wdata->state.lock, flags);
	wdata->ext = NULL;
	spin_unlock_irqrestore(&wdata->state.lock, flags);

	device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
	input_unregister_device(ext->mp_input);
	input_unregister_device(ext->input);

	cancel_work_sync(&ext->worker);
	kfree(ext);
	}