- 根目录:
- drivers
- hid
- hid-wiimote-ext.c
/*
* HID driver for Nintendo Wiimote extension devices
* Copyright (c) 2011 David Herrmann
*/
/*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*/
#include <linux/atomic.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include "hid-wiimote.h"
struct wiimote_ext {
struct wiimote_data *wdata;
struct work_struct worker;
struct input_dev *input;
struct input_dev *mp_input;
atomic_t opened;
atomic_t mp_opened;
bool plugged;
bool mp_plugged;
bool motionp;
__u8 ext_type;
__u16 calib[4][3];
};
enum wiiext_type {
WIIEXT_NONE, /* placeholder */
WIIEXT_CLASSIC, /* Nintendo classic controller */
WIIEXT_NUNCHUCK, /* Nintendo nunchuck controller */
WIIEXT_BALANCE_BOARD, /* Nintendo balance board controller */
};
enum wiiext_keys {
WIIEXT_KEY_C,
WIIEXT_KEY_Z,
WIIEXT_KEY_A,
WIIEXT_KEY_B,
WIIEXT_KEY_X,
WIIEXT_KEY_Y,
WIIEXT_KEY_ZL,
WIIEXT_KEY_ZR,
WIIEXT_KEY_PLUS,
WIIEXT_KEY_MINUS,
WIIEXT_KEY_HOME,
WIIEXT_KEY_LEFT,
WIIEXT_KEY_RIGHT,
WIIEXT_KEY_UP,
WIIEXT_KEY_DOWN,
WIIEXT_KEY_LT,
WIIEXT_KEY_RT,
WIIEXT_KEY_COUNT
};
static __u16 wiiext_keymap[] = {
BTN_C, /* WIIEXT_KEY_C */
BTN_Z, /* WIIEXT_KEY_Z */
BTN_A, /* WIIEXT_KEY_A */
BTN_B, /* WIIEXT_KEY_B */
BTN_X, /* WIIEXT_KEY_X */
BTN_Y, /* WIIEXT_KEY_Y */
BTN_TL2, /* WIIEXT_KEY_ZL */
BTN_TR2, /* WIIEXT_KEY_ZR */
KEY_NEXT, /* WIIEXT_KEY_PLUS */
KEY_PREVIOUS, /* WIIEXT_KEY_MINUS */
BTN_MODE, /* WIIEXT_KEY_HOME */
KEY_LEFT, /* WIIEXT_KEY_LEFT */
KEY_RIGHT, /* WIIEXT_KEY_RIGHT */
KEY_UP, /* WIIEXT_KEY_UP */
KEY_DOWN, /* WIIEXT_KEY_DOWN */
BTN_TL, /* WIIEXT_KEY_LT */
BTN_TR, /* WIIEXT_KEY_RT */
};
/* disable all extensions */
static void ext_disable(struct wiimote_ext *ext)
{
unsigned long flags;
__u8 wmem = 0x55;
if (!wiimote_cmd_acquire(ext->wdata)) {
wiimote_cmd_write(ext->wdata, 0xa400f0, &wmem, sizeof(wmem));
wiimote_cmd_release(ext->wdata);
}
spin_lock_irqsave(&ext->wdata->state.lock, flags);
ext->motionp = false;
ext->ext_type = WIIEXT_NONE;
wiiproto_req_drm(ext->wdata, WIIPROTO_REQ_NULL);
spin_unlock_irqrestore(&ext->wdata->state.lock, flags);
}
static bool motionp_read(struct wiimote_ext *ext)
{
__u8 rmem[2], wmem;
ssize_t ret;
bool avail = false;
if (!atomic_read(&ext->mp_opened))
return false;
if (wiimote_cmd_acquire(ext->wdata))
return false;
/* initialize motion plus */
wmem = 0x55;
ret = wiimote_cmd_write(ext->wdata, 0xa600f0, &wmem, sizeof(wmem));
if (ret)
goto error;
/* read motion plus ID */
ret = wiimote_cmd_read(ext->wdata, 0xa600fe, rmem, 2);
if (ret == 2 || rmem[1] == 0x5)
avail = true;
error:
wiimote_cmd_release(ext->wdata);
return avail;
}
static __u8 ext_read(struct wiimote_ext *ext)
{
ssize_t ret;
__u8 buf[24], i, j, offs = 0;
__u8 rmem[2], wmem;
__u8 type = WIIEXT_NONE;
if (!ext->plugged || !atomic_read(&ext->opened))
return WIIEXT_NONE;
if (wiimote_cmd_acquire(ext->wdata))
return WIIEXT_NONE;
/* initialize extension */
wmem = 0x55;
ret = wiimote_cmd_write(ext->wdata, 0xa400f0, &wmem, sizeof(wmem));
if (!ret) {
/* disable encryption */
wmem = 0x0;
wiimote_cmd_write(ext->wdata, 0xa400fb, &wmem, sizeof(wmem));
}
/* read extension ID */
ret = wiimote_cmd_read(ext->wdata, 0xa400fe, rmem, 2);
if (ret == 2) {
if (rmem[0] == 0 && rmem[1] == 0)
type = WIIEXT_NUNCHUCK;
else if (rmem[0] == 0x01 && rmem[1] == 0x01)
type = WIIEXT_CLASSIC;
else if (rmem[0] == 0x04 && rmem[1] == 0x02)
type = WIIEXT_BALANCE_BOARD;
}
/* get balance board calibration data */
if (type == WIIEXT_BALANCE_BOARD) {
ret = wiimote_cmd_read(ext->wdata, 0xa40024, buf, 12);
ret += wiimote_cmd_read(ext->wdata, 0xa40024 + 12,
buf + 12, 12);
if (ret != 24) {
type = WIIEXT_NONE;
} else {
for (i = 0; i < 3; i++) {
for (j = 0; j < 4; j++) {
ext->calib[j][i] = buf[offs];
ext->calib[j][i] <<= 8;
ext->calib[j][i] |= buf[offs + 1];
offs += 2;
}
}
}
}
wiimote_cmd_release(ext->wdata);
return type;
}
static void ext_enable(struct wiimote_ext *ext, bool motionp, __u8 ext_type)
{
unsigned long flags;
__u8 wmem;
int ret;
if (motionp) {
if (wiimote_cmd_acquire(ext->wdata))
return;
if (ext_type == WIIEXT_CLASSIC)
wmem = 0x07;
else if (ext_type == WIIEXT_NUNCHUCK)
wmem = 0x05;
else
wmem = 0x04;
ret = wiimote_cmd_write(ext->wdata, 0xa600fe, &wmem, sizeof(wmem));
wiimote_cmd_release(ext->wdata);
if (ret)
return;
}
spin_lock_irqsave(&ext->wdata->state.lock, flags);
ext->motionp = motionp;
ext->ext_type = ext_type;
wiiproto_req_drm(ext->wdata, WIIPROTO_REQ_NULL);
spin_unlock_irqrestore(&ext->wdata->state.lock, flags);
}
static void wiiext_worker(struct work_struct *work)
{
struct wiimote_ext *ext = container_of(work, struct wiimote_ext,
worker);
bool motionp;
__u8 ext_type;
ext_disable(ext);
motionp = motionp_read(ext);
ext_type = ext_read(ext);
ext_enable(ext, motionp, ext_type);
}
/* schedule work only once, otherwise mark for reschedule */
static void wiiext_schedule(struct wiimote_ext *ext)
{
schedule_work(&ext->worker);
}
/*
* Reacts on extension port events
* Whenever the driver gets an event from the wiimote that an extension has been
* plugged or unplugged, this funtion shall be called. It checks what extensions
* are connected and initializes and activates them.
* This can be called in atomic context. The initialization is done in a
* separate worker thread. The state.lock spinlock must be held by the caller.
*/
void wiiext_event(struct wiimote_data *wdata, bool plugged)
{
if (!wdata->ext)
return;
if (wdata->ext->plugged == plugged)
return;
wdata->ext->plugged = plugged;
if (!plugged)
wdata->ext->mp_plugged = false;
/*
* We need to call wiiext_schedule(wdata->ext) here, however, the
* extension initialization logic is not fully understood and so
* automatic initialization is not supported, yet.
*/
}
/*
* Returns true if the current DRM mode should contain extension data and false
* if there is no interest in extension data.
* All supported extensions send 6 byte extension data so any DRM that contains
* extension bytes is fine.
* The caller must hold the state.lock spinlock.
*/
bool wiiext_active(struct wiimote_data *wdata)
{
if (!wdata->ext)
return false;
return wdata->ext->motionp || wdata->ext->ext_type;
}
static void handler_motionp(struct wiimote_ext *ext, const __u8 *payload)
{
__s32 x, y, z;
bool plugged;
/* | 8 7 6 5 4 3 | 2 | 1 |
* -----+------------------------------+-----+-----+
* 1 | Yaw Speed <7:0> |
* 2 | Roll Speed <7:0> |
* 3 | Pitch Speed <7:0> |
* -----+------------------------------+-----+-----+
* 4 | Yaw Speed <13:8> | Yaw |Pitch|
* -----+------------------------------+-----+-----+
* 5 | Roll Speed <13:8> |Roll | Ext |
* -----+------------------------------+-----+-----+
* 6 | Pitch Speed <13:8> | 1 | 0 |
* -----+------------------------------+-----+-----+
* The single bits Yaw, Roll, Pitch in the lower right corner specify
* whether the wiimote is rotating fast (0) or slow (1). Speed for slow
* roation is 440 deg/s and for fast rotation 2000 deg/s. To get a
* linear scale we multiply by 2000/440 = ~4.5454 which is 18 for fast
* and 9 for slow.
* If the wiimote is not rotating the sensor reports 2^13 = 8192.
* Ext specifies whether an extension is connected to the motionp.
*/
x = payload[0];
y = payload[1];
z = payload[2];
x |= (((__u16)payload[3]) << 6) & 0xff00;
y |= (((__u16)payload[4]) << 6) & 0xff00;
z |= (((__u16)payload[5]) << 6) & 0xff00;
x -= 8192;
y -= 8192;
z -= 8192;
if (!(payload[3] & 0x02))
x *= 18;
else
x *= 9;
if (!(payload[4] & 0x02))
y *= 18;
else
y *= 9;
if (!(payload[3] & 0x01))
z *= 18;
else
z *= 9;
input_report_abs(ext->mp_input, ABS_RX, x);
input_report_abs(ext->mp_input, ABS_RY, y);
input_report_abs(ext->mp_input, ABS_RZ, z);
input_sync(ext->mp_input);
plugged = payload[5] & 0x01;
if (plugged != ext->mp_plugged)
ext->mp_plugged = plugged;
}
static void handler_nunchuck(struct wiimote_ext *ext, const __u8 *payload)
{
__s16 x, y, z, bx, by;
/* Byte | 8 7 | 6 5 | 4 3 | 2 | 1 |
* -----+----------+---------+---------+----+-----+
* 1 | Button X <7:0> |
* 2 | Button Y <7:0> |
* -----+----------+---------+---------+----+-----+
* 3 | Speed X <9:2> |
* 4 | Speed Y <9:2> |
* 5 | Speed Z <9:2> |
* -----+----------+---------+---------+----+-----+
* 6 | Z <1:0> | Y <1:0> | X <1:0> | BC | BZ |
* -----+----------+---------+---------+----+-----+
* Button X/Y is the analog stick. Speed X, Y and Z are the
* accelerometer data in the same format as the wiimote's accelerometer.
* The 6th byte contains the LSBs of the accelerometer data.
* BC and BZ are the C and Z buttons: 0 means pressed
*
* If reported interleaved with motionp, then the layout changes. The
* 5th and 6th byte changes to:
* -----+-----------------------------------+-----+
* 5 | Speed Z <9:3> | EXT |
* -----+--------+-----+-----+----+----+----+-----+
* 6 |Z <2:1> |Y <1>|X <1>| BC | BZ | 0 | 0 |
* -----+--------+-----+-----+----+----+----+-----+
* All three accelerometer values lose their LSB. The other data is
* still available but slightly moved.
*
* Center data for button values is 128. Center value for accelerometer
* values it 512 / 0x200
*/
bx = payload[0];
by = payload[1];
bx -= 128;
by -= 128;
x = payload[2] << 2;
y = payload[3] << 2;
z = payload[4] << 2;
if (ext->motionp) {
x |= (payload[5] >> 3) & 0x02;
y |= (payload[5] >> 4) & 0x02;
z &= ~0x4;
z |= (payload[5] >> 5) & 0x06;
} else {
x |= (payload[5] >> 2) & 0x03;
y |= (payload[5] >> 4) & 0x03;
z |= (payload[5] >> 6) & 0x03;
}
x -= 0x200;
y -= 0x200;
z -= 0x200;
input_report_abs(ext->input, ABS_HAT0X, bx);
input_report_abs(ext->input, ABS_HAT0Y, by);
input_report_abs(ext->input, ABS_RX, x);
input_report_abs(ext->input, ABS_RY, y);
input_report_abs(ext->input, ABS_RZ, z);
if (ext->motionp) {
input_report_key(ext->input,
wiiext_keymap[WIIEXT_KEY_Z], !(payload[5] & 0x04));
input_report_key(ext->input,
wiiext_keymap[WIIEXT_KEY_C], !(payload[5] & 0x08));
} else {
input_report_key(ext->input,
wiiext_keymap[WIIEXT_KEY_Z], !(payload[5] & 0x01));
input_report_key(ext->input,
wiiext_keymap[WIIEXT_KEY_C], !(payload[5] & 0x02));
}
input_sync(ext->input);
}
static void handler_classic(struct wiimote_ext *ext, const __u8 *payload)
{
__s8 rx, ry, lx, ly, lt, rt;
/* Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 |
* -----+-----+-----+-----+-----+-----+-----+-----+-----+
* 1 | RX <5:4> | LX <5:0> |
* 2 | RX <3:2> | LY <5:0> |
* -----+-----+-----+-----+-----------------------------+
* 3 |RX<1>| LT <5:4> | RY <5:1> |
* -----+-----+-----------+-----------------------------+
* 4 | LT <3:1> | RT <5:1> |
* -----+-----+-----+-----+-----+-----+-----+-----+-----+
* 5 | BDR | BDD | BLT | B- | BH | B+ | BRT | 1 |
* -----+-----+-----+-----+-----+-----+-----+-----+-----+
* 6 | BZL | BB | BY | BA | BX | BZR | BDL | BDU |
* -----+-----+-----+-----+-----+-----+-----+-----+-----+
* All buttons are 0 if pressed
* RX and RY are right analog stick
* LX and LY are left analog stick
* LT is left trigger, RT is right trigger
* BLT is 0 if left trigger is fully pressed
* BRT is 0 if right trigger is fully pressed
* BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons
* BZL is left Z button and BZR is right Z button
* B-, BH, B+ are +, HOME and - buttons
* BB, BY, BA, BX are A, B, X, Y buttons
* LSB of RX, RY, LT, and RT are not transmitted and always 0.
*
* With motionp enabled it changes slightly to this:
* Byte | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 |
* -----+-----+-----+-----+-----+-----+-----+-----+-----+
* 1 | RX <4:3> | LX <5:1> | BDU |
* 2 | RX <2:1> | LY <5:1> | BDL |
* -----+-----+-----+-----+-----------------------+-----+
* 3 |RX<0>| LT <4:3> | RY <4:0> |
* -----+-----+-----------+-----------------------------+
* 4 | LT <2:0> | RT <4:0> |
* -----+-----+-----+-----+-----+-----+-----+-----+-----+
* 5 | BDR | BDD | BLT | B- | BH | B+ | BRT | EXT |
* -----+-----+-----+-----+-----+-----+-----+-----+-----+
* 6 | BZL | BB | BY | BA | BX | BZR | 0 | 0 |
* -----+-----+-----+-----+-----+-----+-----+-----+-----+
* Only the LSBs of LX and LY are lost. BDU and BDL are moved, the rest
* is the same as before.
*/
if (ext->motionp) {
lx = payload[0] & 0x3e;
ly = payload[0] & 0x3e;
} else {
lx = payload[0] & 0x3f;
ly = payload[0] & 0x3f;
}
rx = (payload[0] >> 3) & 0x14;
rx |= (payload[1] >> 5) & 0x06;
rx |= (payload[2] >> 7) & 0x01;
ry = payload[2] & 0x1f;
rt = payload[3] & 0x1f;
lt = (payload[2] >> 2) & 0x18;
lt |= (payload[3] >> 5) & 0x07;
rx <<= 1;
ry <<= 1;
rt <<= 1;
lt <<= 1;
input_report_abs(ext->input, ABS_HAT1X, lx - 0x20);
input_report_abs(ext->input, ABS_HAT1Y, ly - 0x20);
input_report_abs(ext->input, ABS_HAT2X, rx - 0x20);
input_report_abs(ext->input, ABS_HAT2Y, ry - 0x20);
input_report_abs(ext->input, ABS_HAT3X, rt - 0x20);
input_report_abs(ext->input, ABS_HAT3Y, lt - 0x20);
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_RIGHT],
!!(payload[4] & 0x80));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_DOWN],
!!(payload[4] & 0x40));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LT],
!!(payload[4] & 0x20));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_MINUS],
!!(payload[4] & 0x10));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_HOME],
!!(payload[4] & 0x08));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_PLUS],
!!(payload[4] & 0x04));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_RT],
!!(payload[4] & 0x02));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_ZL],
!!(payload[5] & 0x80));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_B],
!!(payload[5] & 0x40));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_Y],
!!(payload[5] & 0x20));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_A],
!!(payload[5] & 0x10));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_X],
!!(payload[5] & 0x08));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_ZR],
!!(payload[5] & 0x04));
if (ext->motionp) {
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_UP],
!!(payload[0] & 0x01));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LEFT],
!!(payload[1] & 0x01));
} else {
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_UP],
!!(payload[5] & 0x01));
input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LEFT],
!!(payload[5] & 0x02));
}
input_sync(ext->input);
}
static void handler_balance_board(struct wiimote_ext *ext, const __u8 *payload)
{
__s32 val[4], tmp;
unsigned int i;
/* Byte | 8 7 6 5 4 3 2 1 |
* -----+--------------------------+
* 1 | Top Right <15:8> |
* 2 | Top Right <7:0> |
* -----+--------------------------+
* 3 | Bottom Right <15:8> |
* 4 | Bottom Right <7:0> |
* -----+--------------------------+
* 5 | Top Left <15:8> |
* 6 | Top Left <7:0> |
* -----+--------------------------+
* 7 | Bottom Left <15:8> |
* 8 | Bottom Left <7:0> |
* -----+--------------------------+
*
* These values represent the weight-measurements of the Wii-balance
* board with 16bit precision.
*
* The balance-board is never reported interleaved with motionp.
*/
val[0] = payload[0];
val[0] <<= 8;
val[0] |= payload[1];
val[1] = payload[2];
val[1] <<= 8;
val[1] |= payload[3];
val[2] = payload[4];
val[2] <<= 8;
val[2] |= payload[5];
val[3] = payload[6];
val[3] <<= 8;
val[3] |= payload[7];
/* apply calibration data */
for (i = 0; i < 4; i++) {
if (val[i] < ext->calib[i][1]) {
tmp = val[i] - ext->calib[i][0];
tmp *= 1700;
tmp /= ext->calib[i][1] - ext->calib[i][0];
} else {
tmp = val[i] - ext->calib[i][1];
tmp *= 1700;
tmp /= ext->calib[i][2] - ext->calib[i][1];
tmp += 1700;
}
val[i] = tmp;
}
input_report_abs(ext->input, ABS_HAT0X, val[0]);
input_report_abs(ext->input, ABS_HAT0Y, val[1]);
input_report_abs(ext->input, ABS_HAT1X, val[2]);
input_report_abs(ext->input, ABS_HAT1Y, val[3]);
input_sync(ext->input);
}
/* call this with state.lock spinlock held */
void wiiext_handle(struct wiimote_data *wdata, const __u8 *payload)
{
struct wiimote_ext *ext = wdata->ext;
if (!ext)
return;
if (ext->motionp && (payload[5] & 0x02)) {
handler_motionp(ext, payload);
} else if (ext->ext_type == WIIEXT_NUNCHUCK) {
handler_nunchuck(ext, payload);
} else if (ext->ext_type == WIIEXT_CLASSIC) {
handler_classic(ext, payload);
} else if (ext->ext_type == WIIEXT_BALANCE_BOARD) {
handler_balance_board(ext, payload);
}
}
static ssize_t wiiext_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct wiimote_data *wdata = dev_to_wii(dev);
__u8 type = WIIEXT_NONE;
bool motionp = false;
unsigned long flags;
spin_lock_irqsave(&wdata->state.lock, flags);
if (wdata->ext) {
motionp = wdata->ext->motionp;
type = wdata->ext->ext_type;
}
spin_unlock_irqrestore(&wdata->state.lock, flags);
if (type == WIIEXT_NUNCHUCK) {
if (motionp)
return sprintf(buf, "motionp+nunchuck\n");
else
return sprintf(buf, "nunchuck\n");
} else if (type == WIIEXT_CLASSIC) {
if (motionp)
return sprintf(buf, "motionp+classic\n");
else
return sprintf(buf, "classic\n");
} else if (type == WIIEXT_BALANCE_BOARD) {
if (motionp)
return sprintf(buf, "motionp+balanceboard\n");
else
return sprintf(buf, "balanceboard\n");
} else {
if (motionp)
return sprintf(buf, "motionp\n");
else
return sprintf(buf, "none\n");
}
}
static DEVICE_ATTR(extension, S_IRUGO, wiiext_show, NULL);
static int wiiext_input_open(struct input_dev *dev)
{
struct wiimote_ext *ext = input_get_drvdata(dev);
int ret;
ret = hid_hw_open(ext->wdata->hdev);
if (ret)
return ret;
atomic_inc(&ext->opened);
wiiext_schedule(ext);
return 0;
}
static void wiiext_input_close(struct input_dev *dev)
{
struct wiimote_ext *ext = input_get_drvdata(dev);
atomic_dec(&ext->opened);
wiiext_schedule(ext);
hid_hw_close(ext->wdata->hdev);
}
static int wiiext_mp_open(struct input_dev *dev)
{
struct wiimote_ext *ext = input_get_drvdata(dev);
int ret;
ret = hid_hw_open(ext->wdata->hdev);
if (ret)
return ret;
atomic_inc(&ext->mp_opened);
wiiext_schedule(ext);
return 0;
}
static void wiiext_mp_close(struct input_dev *dev)
{
struct wiimote_ext *ext = input_get_drvdata(dev);
atomic_dec(&ext->mp_opened);
wiiext_schedule(ext);
hid_hw_close(ext->wdata->hdev);
}
/* Initializes the extension driver of a wiimote */
int wiiext_init(struct wiimote_data *wdata)
{
struct wiimote_ext *ext;
unsigned long flags;
int ret, i;
ext = kzalloc(sizeof(*ext), GFP_KERNEL);
if (!ext)
return -ENOMEM;
ext->wdata = wdata;
INIT_WORK(&ext->worker, wiiext_worker);
ext->input = input_allocate_device();
if (!ext->input) {
ret = -ENOMEM;
goto err_input;
}
input_set_drvdata(ext->input, ext);
ext->input->open = wiiext_input_open;
ext->input->close = wiiext_input_close;
ext->input->dev.parent = &wdata->hdev->dev;
ext->input->id.bustype = wdata->hdev->bus;
ext->input->id.vendor = wdata->hdev->vendor;
ext->input->id.product = wdata->hdev->product;
ext->input->id.version = wdata->hdev->version;
ext->input->name = WIIMOTE_NAME " Extension";
set_bit(EV_KEY, ext->input->evbit);
for (i = 0; i < WIIEXT_KEY_COUNT; ++i)
set_bit(wiiext_keymap[i], ext->input->keybit);
set_bit(EV_ABS, ext->input->evbit);
set_bit(ABS_HAT0X, ext->input->absbit);
set_bit(ABS_HAT0Y, ext->input->absbit);
set_bit(ABS_HAT1X, ext->input->absbit);
set_bit(ABS_HAT1Y, ext->input->absbit);
set_bit(ABS_HAT2X, ext->input->absbit);
set_bit(ABS_HAT2Y, ext->input->absbit);
set_bit(ABS_HAT3X, ext->input->absbit);
set_bit(ABS_HAT3Y, ext->input->absbit);
input_set_abs_params(ext->input, ABS_HAT0X, -120, 120, 2, 4);
input_set_abs_params(ext->input, ABS_HAT0Y, -120, 120, 2, 4);
input_set_abs_params(ext->input, ABS_HAT1X, -30, 30, 1, 1);
input_set_abs_params(ext->input, ABS_HAT1Y, -30, 30, 1, 1);
input_set_abs_params(ext->input, ABS_HAT2X, -30, 30, 1, 1);
input_set_abs_params(ext->input, ABS_HAT2Y, -30, 30, 1, 1);
input_set_abs_params(ext->input, ABS_HAT3X, -30, 30, 1, 1);
input_set_abs_params(ext->input, ABS_HAT3Y, -30, 30, 1, 1);
set_bit(ABS_RX, ext->input->absbit);
set_bit(ABS_RY, ext->input->absbit);
set_bit(ABS_RZ, ext->input->absbit);
input_set_abs_params(ext->input, ABS_RX, -500, 500, 2, 4);
input_set_abs_params(ext->input, ABS_RY, -500, 500, 2, 4);
input_set_abs_params(ext->input, ABS_RZ, -500, 500, 2, 4);
ret = input_register_device(ext->input);
if (ret) {
input_free_device(ext->input);
goto err_input;
}
ext->mp_input = input_allocate_device();
if (!ext->mp_input) {
ret = -ENOMEM;
goto err_mp;
}
input_set_drvdata(ext->mp_input, ext);
ext->mp_input->open = wiiext_mp_open;
ext->mp_input->close = wiiext_mp_close;
ext->mp_input->dev.parent = &wdata->hdev->dev;
ext->mp_input->id.bustype = wdata->hdev->bus;
ext->mp_input->id.vendor = wdata->hdev->vendor;
ext->mp_input->id.product = wdata->hdev->product;
ext->mp_input->id.version = wdata->hdev->version;
ext->mp_input->name = WIIMOTE_NAME " Motion+";
set_bit(EV_ABS, ext->mp_input->evbit);
set_bit(ABS_RX, ext->mp_input->absbit);
set_bit(ABS_RY, ext->mp_input->absbit);
set_bit(ABS_RZ, ext->mp_input->absbit);
input_set_abs_params(ext->mp_input, ABS_RX, -160000, 160000, 4, 8);
input_set_abs_params(ext->mp_input, ABS_RY, -160000, 160000, 4, 8);
input_set_abs_params(ext->mp_input, ABS_RZ, -160000, 160000, 4, 8);
ret = input_register_device(ext->mp_input);
if (ret) {
input_free_device(ext->mp_input);
goto err_mp;
}
ret = device_create_file(&wdata->hdev->dev, &dev_attr_extension);
if (ret)
goto err_dev;
spin_lock_irqsave(&wdata->state.lock, flags);
wdata->ext = ext;
spin_unlock_irqrestore(&wdata->state.lock, flags);
return 0;
err_dev:
input_unregister_device(ext->mp_input);
err_mp:
input_unregister_device(ext->input);
err_input:
kfree(ext);
return ret;
}
/* Deinitializes the extension driver of a wiimote */
void wiiext_deinit(struct wiimote_data *wdata)
{
struct wiimote_ext *ext = wdata->ext;
unsigned long flags;
if (!ext)
return;
/*
* We first unset wdata->ext to avoid further input from the wiimote
* core. The worker thread does not access this pointer so it is not
* affected by this.
* We kill the worker after this so it does not get respawned during
* deinitialization.
*/
spin_lock_irqsave(&wdata->state.lock, flags);
wdata->ext = NULL;
spin_unlock_irqrestore(&wdata->state.lock, flags);
device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
input_unregister_device(ext->mp_input);
input_unregister_device(ext->input);
cancel_work_sync(&ext->worker);
kfree(ext);
}