Commit 45ec9fff authored by David Herrmann's avatar David Herrmann Committed by Jiri Kosina
Browse files

HID: wiimote: remove old static extension support 



We now have dynamic hotplug support so the old static extensions are no
longer needed nor used. Remove it along CONFIG_HID_WIIMOTE_EXT.

Signed-off-by: default avatarDavid Herrmann <dh.herrmann@gmail.com>
Signed-off-by: default avatarJiri Kosina <jkosina@suse.cz>
parent 8b1fded7

drivers/hid/Kconfig

+0 −9
Original line number Diff line number Diff line
@@ -731,15 +731,6 @@ config HID_WIIMOTE 
	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"

	depends on HID

drivers/hid/Makefile

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



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

	hid-wiimote-y	+= hid-wiimote-debug.o

endif

drivers/hid/hid-wiimote-ext.c

deleted100644 → 0
+0 −837
Original line number 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);

}

drivers/hid/hid-wiimote.h

+0 −19

File changed.

Preview size limit exceeded, changes collapsed.