Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid
Pull HID updates from Jiri Kosina: - HID battery handling cleanup by David Herrmann - ELO 4000/4500 driver, which has been finally ported to be proper HID driver by Jiri Slaby - ps3remote driver functionality is now provided by generic sony driver, by Jiri Kosina - PS2/3 Buzz controllers support, by Colin Leitner - rework of wiimote driver including full extensions hotpluggin support, sub-device modularization and speaker support by David Herrmann * 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid: (55 commits) HID: wacom: Intuos4 battery charging changes HID: i2c-hid: support sending HID output reports using the output register HID: kye: Add report fixup for Genius Gila Gaming mouse HID: wiimote: support Nintendo Wii U Pro Controller Input: make gamepad API keycodes more clear input: document gamepad API and add extra keycodes HID: explain out-of-range check better HID: fix false positive out of range values HID: wiimote: fix coccinelle warnings HID: roccat: check cdev_add return value HID: fold ps3remote driver into generic Sony driver HID: hyperv: convert alloc+memcpy to memdup HID: core: fix reporting of raw events HID: wiimote: discard invalid EXT data reports HID: wiimote: fix classic controller parsing HID: wiimote: init EXT/MP during device detection HID: wiimote: fix DRM debug-attr to correctly parse input HID: wiimote: add MP quirks HID: wiimote: remove old static extension support HID: wiimote: add "bboard_calib" attribute ...
This commit is contained in:
Linus Torvalds
commit
3366dd9fa8
@ -12,7 +12,7 @@ Description: Make it possible to set/get current led state. Reading from it
|
||||
What: /sys/bus/hid/drivers/wiimote/<dev>/extension
|
||||
Date: August 2011
|
||||
KernelVersion: 3.2
|
||||
Contact: David Herrmann <dh.herrmann@googlemail.com>
|
||||
Contact: David Herrmann <dh.herrmann@gmail.com>
|
||||
Description: This file contains the currently connected and initialized
|
||||
extensions. It can be one of: none, motionp, nunchuck, classic,
|
||||
motionp+nunchuck, motionp+classic
|
||||
@ -20,3 +20,40 @@ Description: This file contains the currently connected and initialized
|
||||
the official Nintendo Nunchuck extension and classic is the
|
||||
Nintendo Classic Controller extension. The motionp extension can
|
||||
be combined with the other two.
|
||||
Starting with kernel-version 3.11 Motion Plus hotplugging is
|
||||
supported and if detected, it's no longer reported as static
|
||||
extension. You will get uevent notifications for the motion-plus
|
||||
device then.
|
||||
|
||||
What: /sys/bus/hid/drivers/wiimote/<dev>/devtype
|
||||
Date: May 2013
|
||||
KernelVersion: 3.11
|
||||
Contact: David Herrmann <dh.herrmann@gmail.com>
|
||||
Description: While a device is initialized by the wiimote driver, we perform
|
||||
a device detection and signal a "change" uevent after it is
|
||||
done. This file shows the detected device type. "pending" means
|
||||
that the detection is still ongoing, "unknown" means, that the
|
||||
device couldn't be detected or loaded. "generic" means, that the
|
||||
device couldn't be detected but supports basic Wii Remote
|
||||
features and can be used.
|
||||
Other strings for each device-type are available and may be
|
||||
added if new device-specific detections are added.
|
||||
Currently supported are:
|
||||
gen10: First Wii Remote generation
|
||||
gen20: Second Wii Remote Plus generation (builtin MP)
|
||||
balanceboard: Wii Balance Board
|
||||
|
||||
What: /sys/bus/hid/drivers/wiimote/<dev>/bboard_calib
|
||||
Date: May 2013
|
||||
KernelVersion: 3.11
|
||||
Contact: David Herrmann <dh.herrmann@gmail.com>
|
||||
Description: This attribute is only provided if the device was detected as a
|
||||
balance board. It provides a single line with 3 calibration
|
||||
values for all 4 sensors. The values are separated by colons and
|
||||
are each 2 bytes long (encoded as 4 digit hexadecimal value).
|
||||
First, 0kg values for all 4 sensors are written, followed by the
|
||||
17kg values for all 4 sensors and last the 34kg values for all 4
|
||||
sensors.
|
||||
Calibration data is already applied by the kernel to all input
|
||||
values but may be used by user-space to perform other
|
||||
transformations.
|
||||
|
||||
@ -217,6 +217,13 @@ config HID_ELECOM
|
||||
---help---
|
||||
Support for the ELECOM BM084 (bluetooth mouse).
|
||||
|
||||
config HID_ELO
|
||||
tristate "ELO USB 4000/4500 touchscreen"
|
||||
depends on USB_HID
|
||||
---help---
|
||||
Support for the ELO USB 4000/4500 touchscreens. Note that this is for
|
||||
different devices than those handled by CONFIG_TOUCHSCREEN_USB_ELO.
|
||||
|
||||
config HID_EZKEY
|
||||
tristate "Ezkey BTC 8193 keyboard" if EXPERT
|
||||
depends on HID
|
||||
@ -231,6 +238,9 @@ config HID_HOLTEK
|
||||
Support for Holtek based devices:
|
||||
- Holtek On Line Grip based game controller
|
||||
- Trust GXT 18 Gaming Keyboard
|
||||
- Sharkoon Drakonia / Perixx MX-2000 gaming mice
|
||||
- Tracer Sniper TRM-503 / NOVA Gaming Slider X200 /
|
||||
Zalman ZM-GM1
|
||||
|
||||
config HOLTEK_FF
|
||||
bool "Holtek On Line Grip force feedback support"
|
||||
@ -240,6 +250,12 @@ config HOLTEK_FF
|
||||
Say Y here if you have a Holtek On Line Grip based game controller
|
||||
and want to have force feedback support for it.
|
||||
|
||||
config HID_HUION
|
||||
tristate "Huion tablets"
|
||||
depends on USB_HID
|
||||
---help---
|
||||
Support for Huion 580 tablet.
|
||||
|
||||
config HID_KEYTOUCH
|
||||
tristate "Keytouch HID devices"
|
||||
depends on HID
|
||||
@ -561,15 +577,6 @@ config HID_PRIMAX
|
||||
Support for Primax devices that are not fully compliant with the
|
||||
HID standard.
|
||||
|
||||
config HID_PS3REMOTE
|
||||
tristate "Sony PS3 BD Remote Control"
|
||||
depends on HID
|
||||
---help---
|
||||
Support for the Sony PS3 Blue-ray Disk Remote Control and Logitech
|
||||
Harmony Adapter for PS3, which connect over Bluetooth.
|
||||
|
||||
Support for the 6-axis controllers is provided by HID_SONY.
|
||||
|
||||
config HID_ROCCAT
|
||||
tristate "Roccat device support"
|
||||
depends on USB_HID
|
||||
@ -594,12 +601,17 @@ config HID_SAMSUNG
|
||||
Support for Samsung InfraRed remote control or keyboards.
|
||||
|
||||
config HID_SONY
|
||||
tristate "Sony PS3 controller"
|
||||
tristate "Sony PS2/3 accessories"
|
||||
depends on USB_HID
|
||||
depends on NEW_LEDS
|
||||
depends on LEDS_CLASS
|
||||
---help---
|
||||
Support for Sony PS3 6-axis controllers.
|
||||
Support for
|
||||
|
||||
Support for the Sony PS3 BD Remote is provided by HID_PS3REMOTE.
|
||||
* Sony PS3 6-axis controllers
|
||||
* Buzz controllers
|
||||
* Sony PS3 Blue-ray Disk Remote Control (Bluetooth)
|
||||
* Logitech Harmony adapter for Sony Playstation 3 (Bluetooth)
|
||||
|
||||
config HID_SPEEDLINK
|
||||
tristate "Speedlink VAD Cezanne mouse support"
|
||||
@ -707,22 +719,29 @@ config HID_WACOM
|
||||
Support for Wacom Graphire Bluetooth and Intuos4 WL tablets.
|
||||
|
||||
config HID_WIIMOTE
|
||||
tristate "Nintendo Wii Remote support"
|
||||
tristate "Nintendo Wii / Wii U peripherals"
|
||||
depends on HID
|
||||
depends on LEDS_CLASS
|
||||
select POWER_SUPPLY
|
||||
select INPUT_FF_MEMLESS
|
||||
---help---
|
||||
Support for the Nintendo Wii Remote bluetooth device.
|
||||
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.
|
||||
|
||||
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.
|
||||
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_ZEROPLUS
|
||||
tristate "Zeroplus based game controller support"
|
||||
|
||||
@ -28,10 +28,7 @@ ifdef CONFIG_LOGIWHEELS_FF
|
||||
hid-logitech-y += hid-lg4ff.o
|
||||
endif
|
||||
|
||||
hid-wiimote-y := hid-wiimote-core.o
|
||||
ifdef CONFIG_HID_WIIMOTE_EXT
|
||||
hid-wiimote-y += hid-wiimote-ext.o
|
||||
endif
|
||||
hid-wiimote-y := hid-wiimote-core.o hid-wiimote-modules.o
|
||||
ifdef CONFIG_DEBUG_FS
|
||||
hid-wiimote-y += hid-wiimote-debug.o
|
||||
endif
|
||||
@ -48,10 +45,13 @@ obj-$(CONFIG_HID_CYPRESS) += hid-cypress.o
|
||||
obj-$(CONFIG_HID_DRAGONRISE) += hid-dr.o
|
||||
obj-$(CONFIG_HID_EMS_FF) += hid-emsff.o
|
||||
obj-$(CONFIG_HID_ELECOM) += hid-elecom.o
|
||||
obj-$(CONFIG_HID_ELO) += hid-elo.o
|
||||
obj-$(CONFIG_HID_EZKEY) += hid-ezkey.o
|
||||
obj-$(CONFIG_HID_GYRATION) += hid-gyration.o
|
||||
obj-$(CONFIG_HID_HOLTEK) += hid-holtek-kbd.o
|
||||
obj-$(CONFIG_HID_HOLTEK) += hid-holtek-mouse.o
|
||||
obj-$(CONFIG_HID_HOLTEK) += hid-holtekff.o
|
||||
obj-$(CONFIG_HID_HUION) += hid-huion.o
|
||||
obj-$(CONFIG_HID_HYPERV_MOUSE) += hid-hyperv.o
|
||||
obj-$(CONFIG_HID_ICADE) += hid-icade.o
|
||||
obj-$(CONFIG_HID_KENSINGTON) += hid-kensington.o
|
||||
@ -92,7 +92,6 @@ hid-picolcd-y += hid-picolcd_debugfs.o
|
||||
endif
|
||||
|
||||
obj-$(CONFIG_HID_PRIMAX) += hid-primax.o
|
||||
obj-$(CONFIG_HID_PS3REMOTE) += hid-ps3remote.o
|
||||
obj-$(CONFIG_HID_ROCCAT) += hid-roccat.o hid-roccat-common.o \
|
||||
hid-roccat-arvo.o hid-roccat-isku.o hid-roccat-kone.o \
|
||||
hid-roccat-koneplus.o hid-roccat-konepure.o hid-roccat-kovaplus.o \
|
||||
|
||||
@ -1293,7 +1293,7 @@ int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int i
|
||||
|
||||
if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
|
||||
ret = hdrv->raw_event(hid, report, data, size);
|
||||
if (ret != 0) {
|
||||
if (ret < 0) {
|
||||
ret = ret < 0 ? ret : 0;
|
||||
goto unlock;
|
||||
}
|
||||
@ -1573,6 +1573,8 @@ static const struct hid_device_id hid_have_special_driver[] = {
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },
|
||||
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
|
||||
@ -1584,10 +1586,14 @@ static const struct hid_device_id hid_have_special_driver[] = {
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_HUION, USB_DEVICE_ID_HUION_580) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_JESS2, USB_DEVICE_ID_JESS2_COLOR_RUMBLE_PAD) },
|
||||
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_I405X) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },
|
||||
@ -1680,6 +1686,8 @@ static const struct hid_device_id hid_have_special_driver[] = {
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER) },
|
||||
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER) },
|
||||
@ -2042,6 +2050,8 @@ static const struct hid_device_id hid_ignore_list[] = {
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1007) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_SPEAK_410) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_SPEAK_510) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_KWORLD, USB_DEVICE_ID_KWORLD_RADIO_FM700) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },
|
||||
|
||||
273
drivers/hid/hid-elo.c
Normal file
273
drivers/hid/hid-elo.c
Normal file
@ -0,0 +1,273 @@
|
||||
/*
|
||||
* HID driver for ELO usb touchscreen 4000/4500
|
||||
*
|
||||
* Copyright (c) 2013 Jiri Slaby
|
||||
*
|
||||
* Data parsing taken from elousb driver by Vojtech Pavlik.
|
||||
*
|
||||
* This driver is licensed under the terms of GPLv2.
|
||||
*/
|
||||
|
||||
#include <linux/hid.h>
|
||||
#include <linux/input.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/usb.h>
|
||||
#include <linux/workqueue.h>
|
||||
|
||||
#include "hid-ids.h"
|
||||
|
||||
#define ELO_PERIODIC_READ_INTERVAL HZ
|
||||
#define ELO_SMARTSET_CMD_TIMEOUT 2000 /* msec */
|
||||
|
||||
/* Elo SmartSet commands */
|
||||
#define ELO_FLUSH_SMARTSET_RESPONSES 0x02 /* Flush all pending smartset responses */
|
||||
#define ELO_SEND_SMARTSET_COMMAND 0x05 /* Send a smartset command */
|
||||
#define ELO_GET_SMARTSET_RESPONSE 0x06 /* Get a smartset response */
|
||||
#define ELO_DIAG 0x64 /* Diagnostics command */
|
||||
#define ELO_SMARTSET_PACKET_SIZE 8
|
||||
|
||||
struct elo_priv {
|
||||
struct usb_device *usbdev;
|
||||
struct delayed_work work;
|
||||
unsigned char buffer[ELO_SMARTSET_PACKET_SIZE];
|
||||
};
|
||||
|
||||
static struct workqueue_struct *wq;
|
||||
static bool use_fw_quirk = true;
|
||||
module_param(use_fw_quirk, bool, S_IRUGO);
|
||||
MODULE_PARM_DESC(use_fw_quirk, "Do periodic pokes for broken M firmwares (default = true)");
|
||||
|
||||
static void elo_input_configured(struct hid_device *hdev,
|
||||
struct hid_input *hidinput)
|
||||
{
|
||||
struct input_dev *input = hidinput->input;
|
||||
|
||||
set_bit(BTN_TOUCH, input->keybit);
|
||||
set_bit(ABS_PRESSURE, input->absbit);
|
||||
input_set_abs_params(input, ABS_PRESSURE, 0, 256, 0, 0);
|
||||
}
|
||||
|
||||
static void elo_process_data(struct input_dev *input, const u8 *data, int size)
|
||||
{
|
||||
int press;
|
||||
|
||||
input_report_abs(input, ABS_X, (data[3] << 8) | data[2]);
|
||||
input_report_abs(input, ABS_Y, (data[5] << 8) | data[4]);
|
||||
|
||||
press = 0;
|
||||
if (data[1] & 0x80)
|
||||
press = (data[7] << 8) | data[6];
|
||||
input_report_abs(input, ABS_PRESSURE, press);
|
||||
|
||||
if (data[1] & 0x03) {
|
||||
input_report_key(input, BTN_TOUCH, 1);
|
||||
input_sync(input);
|
||||
}
|
||||
|
||||
if (data[1] & 0x04)
|
||||
input_report_key(input, BTN_TOUCH, 0);
|
||||
|
||||
input_sync(input);
|
||||
}
|
||||
|
||||
static int elo_raw_event(struct hid_device *hdev, struct hid_report *report,
|
||||
u8 *data, int size)
|
||||
{
|
||||
struct hid_input *hidinput;
|
||||
|
||||
if (!(hdev->claimed & HID_CLAIMED_INPUT) || list_empty(&hdev->inputs))
|
||||
return 0;
|
||||
|
||||
hidinput = list_first_entry(&hdev->inputs, struct hid_input, list);
|
||||
|
||||
switch (report->id) {
|
||||
case 0:
|
||||
if (data[0] == 'T') { /* Mandatory ELO packet marker */
|
||||
elo_process_data(hidinput->input, data, size);
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
default: /* unknown report */
|
||||
/* Unknown report type; pass upstream */
|
||||
hid_info(hdev, "unknown report type %d\n", report->id);
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int elo_smartset_send_get(struct usb_device *dev, u8 command,
|
||||
void *data)
|
||||
{
|
||||
unsigned int pipe;
|
||||
u8 dir;
|
||||
|
||||
if (command == ELO_SEND_SMARTSET_COMMAND) {
|
||||
pipe = usb_sndctrlpipe(dev, 0);
|
||||
dir = USB_DIR_OUT;
|
||||
} else if (command == ELO_GET_SMARTSET_RESPONSE) {
|
||||
pipe = usb_rcvctrlpipe(dev, 0);
|
||||
dir = USB_DIR_IN;
|
||||
} else
|
||||
return -EINVAL;
|
||||
|
||||
return usb_control_msg(dev, pipe, command,
|
||||
dir | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
|
||||
0, 0, data, ELO_SMARTSET_PACKET_SIZE,
|
||||
ELO_SMARTSET_CMD_TIMEOUT);
|
||||
}
|
||||
|
||||
static int elo_flush_smartset_responses(struct usb_device *dev)
|
||||
{
|
||||
return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
|
||||
ELO_FLUSH_SMARTSET_RESPONSES,
|
||||
USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
|
||||
0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
|
||||
}
|
||||
|
||||
static void elo_work(struct work_struct *work)
|
||||
{
|
||||
struct elo_priv *priv = container_of(work, struct elo_priv, work.work);
|
||||
struct usb_device *dev = priv->usbdev;
|
||||
unsigned char *buffer = priv->buffer;
|
||||
int ret;
|
||||
|
||||
ret = elo_flush_smartset_responses(dev);
|
||||
if (ret < 0) {
|
||||
dev_err(&dev->dev, "initial FLUSH_SMARTSET_RESPONSES failed, error %d\n",
|
||||
ret);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
/* send Diagnostics command */
|
||||
*buffer = ELO_DIAG;
|
||||
ret = elo_smartset_send_get(dev, ELO_SEND_SMARTSET_COMMAND, buffer);
|
||||
if (ret < 0) {
|
||||
dev_err(&dev->dev, "send Diagnostics Command failed, error %d\n",
|
||||
ret);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
/* get the result */
|
||||
ret = elo_smartset_send_get(dev, ELO_GET_SMARTSET_RESPONSE, buffer);
|
||||
if (ret < 0) {
|
||||
dev_err(&dev->dev, "get Diagnostics Command response failed, error %d\n",
|
||||
ret);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
/* read the ack */
|
||||
if (*buffer != 'A') {
|
||||
ret = elo_smartset_send_get(dev, ELO_GET_SMARTSET_RESPONSE,
|
||||
buffer);
|
||||
if (ret < 0) {
|
||||
dev_err(&dev->dev, "get acknowledge response failed, error %d\n",
|
||||
ret);
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
fail:
|
||||
ret = elo_flush_smartset_responses(dev);
|
||||
if (ret < 0)
|
||||
dev_err(&dev->dev, "final FLUSH_SMARTSET_RESPONSES failed, error %d\n",
|
||||
ret);
|
||||
queue_delayed_work(wq, &priv->work, ELO_PERIODIC_READ_INTERVAL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Not all Elo devices need the periodic HID descriptor reads.
|
||||
* Only firmware version M needs this.
|
||||
*/
|
||||
static bool elo_broken_firmware(struct usb_device *dev)
|
||||
{
|
||||
return use_fw_quirk && le16_to_cpu(dev->descriptor.bcdDevice) == 0x10d;
|
||||
}
|
||||
|
||||
static int elo_probe(struct hid_device *hdev, const struct hid_device_id *id)
|
||||
{
|
||||
struct elo_priv *priv;
|
||||
int ret;
|
||||
|
||||
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
||||
if (!priv)
|
||||
return -ENOMEM;
|
||||
|
||||
INIT_DELAYED_WORK(&priv->work, elo_work);
|
||||
priv->usbdev = interface_to_usbdev(to_usb_interface(hdev->dev.parent));
|
||||
|
||||
hid_set_drvdata(hdev, priv);
|
||||
|
||||
ret = hid_parse(hdev);
|
||||
if (ret) {
|
||||
hid_err(hdev, "parse failed\n");
|
||||
goto err_free;
|
||||
}
|
||||
|
||||
ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
|
||||
if (ret) {
|
||||
hid_err(hdev, "hw start failed\n");
|
||||
goto err_free;
|
||||
}
|
||||
|
||||
if (elo_broken_firmware(priv->usbdev)) {
|
||||
hid_info(hdev, "broken firmware found, installing workaround\n");
|
||||
queue_delayed_work(wq, &priv->work, ELO_PERIODIC_READ_INTERVAL);
|
||||
}
|
||||
|
||||
return 0;
|
||||
err_free:
|
||||
kfree(priv);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void elo_remove(struct hid_device *hdev)
|
||||
{
|
||||
struct elo_priv *priv = hid_get_drvdata(hdev);
|
||||
|
||||
hid_hw_stop(hdev);
|
||||
flush_workqueue(wq);
|
||||
kfree(priv);
|
||||
}
|
||||
|
||||
static const struct hid_device_id elo_devices[] = {
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009), },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030), },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(hid, elo_devices);
|
||||
|
||||
static struct hid_driver elo_driver = {
|
||||
.name = "elo",
|
||||
.id_table = elo_devices,
|
||||
.probe = elo_probe,
|
||||
.remove = elo_remove,
|
||||
.raw_event = elo_raw_event,
|
||||
.input_configured = elo_input_configured,
|
||||
};
|
||||
|
||||
static int __init elo_driver_init(void)
|
||||
{
|
||||
int ret;
|
||||
|
||||
wq = create_singlethread_workqueue("elousb");
|
||||
if (!wq)
|
||||
return -ENOMEM;
|
||||
|
||||
ret = hid_register_driver(&elo_driver);
|
||||
if (ret)
|
||||
destroy_workqueue(wq);
|
||||
|
||||
return ret;
|
||||
}
|
||||
module_init(elo_driver_init);
|
||||
|
||||
static void __exit elo_driver_exit(void)
|
||||
{
|
||||
hid_unregister_driver(&elo_driver);
|
||||
destroy_workqueue(wq);
|
||||
}
|
||||
module_exit(elo_driver_exit);
|
||||
|
||||
MODULE_AUTHOR("Jiri Slaby <jslaby@suse.cz>");
|
||||
MODULE_LICENSE("GPL");
|
||||
77
drivers/hid/hid-holtek-mouse.c
Normal file
77
drivers/hid/hid-holtek-mouse.c
Normal file
@ -0,0 +1,77 @@
|
||||
/*
|
||||
* HID driver for Holtek gaming mice
|
||||
* Copyright (c) 2013 Christian Ohm
|
||||
* Heavily inspired by various other HID drivers that adjust the report
|
||||
* descriptor.
|
||||
*/
|
||||
|
||||
/*
|
||||
* 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/hid.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/usb.h>
|
||||
|
||||
#include "hid-ids.h"
|
||||
|
||||
/*
|
||||
* The report descriptor of some Holtek based gaming mice specifies an
|
||||
* excessively large number of consumer usages (2^15), which is more than
|
||||
* HID_MAX_USAGES. This prevents proper parsing of the report descriptor.
|
||||
*
|
||||
* This driver fixes the report descriptor for:
|
||||
* - USB ID 04d9:a067, sold as Sharkoon Drakonia and Perixx MX-2000
|
||||
* - USB ID 04d9:a04a, sold as Tracer Sniper TRM-503, NOVA Gaming Slider X200
|
||||
* and Zalman ZM-GM1
|
||||
*/
|
||||
|
||||
static __u8 *holtek_mouse_report_fixup(struct hid_device *hdev, __u8 *rdesc,
|
||||
unsigned int *rsize)
|
||||
{
|
||||
struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
|
||||
|
||||
if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
|
||||
/* Change usage maximum and logical maximum from 0x7fff to
|
||||
* 0x2fff, so they don't exceed HID_MAX_USAGES */
|
||||
switch (hdev->product) {
|
||||
case USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067:
|
||||
if (*rsize >= 122 && rdesc[115] == 0xff && rdesc[116] == 0x7f
|
||||
&& rdesc[120] == 0xff && rdesc[121] == 0x7f) {
|
||||
hid_info(hdev, "Fixing up report descriptor\n");
|
||||
rdesc[116] = rdesc[121] = 0x2f;
|
||||
}
|
||||
break;
|
||||
case USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A:
|
||||
if (*rsize >= 113 && rdesc[106] == 0xff && rdesc[107] == 0x7f
|
||||
&& rdesc[111] == 0xff && rdesc[112] == 0x7f) {
|
||||
hid_info(hdev, "Fixing up report descriptor\n");
|
||||
rdesc[107] = rdesc[112] = 0x2f;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
return rdesc;
|
||||
}
|
||||
|
||||
static const struct hid_device_id holtek_mouse_devices[] = {
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT,
|
||||
USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT,
|
||||
USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A) },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(hid, holtek_mouse_devices);
|
||||
|
||||
static struct hid_driver holtek_mouse_driver = {
|
||||
.name = "holtek_mouse",
|
||||
.id_table = holtek_mouse_devices,
|
||||
.report_fixup = holtek_mouse_report_fixup,
|
||||
};
|
||||
|
||||
module_hid_driver(holtek_mouse_driver);
|
||||
MODULE_LICENSE("GPL");
|
||||
177
drivers/hid/hid-huion.c
Normal file
177
drivers/hid/hid-huion.c
Normal file
@ -0,0 +1,177 @@
|
||||
/*
|
||||
* HID driver for Huion devices not fully compliant with HID standard
|
||||
*
|
||||
* Copyright (c) 2013 Martin Rusko
|
||||
*/
|
||||
|
||||
/*
|
||||
* 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/device.h>
|
||||
#include <linux/hid.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/usb.h>
|
||||
#include "usbhid/usbhid.h"
|
||||
|
||||
#include "hid-ids.h"
|
||||
|
||||
/* Original Huion 580 report descriptor size */
|
||||
#define HUION_580_RDESC_ORIG_SIZE 177
|
||||
|
||||
/* Fixed Huion 580 report descriptor */
|
||||
static __u8 huion_580_rdesc_fixed[] = {
|
||||
0x05, 0x0D, /* Usage Page (Digitizer), */
|
||||
0x09, 0x02, /* Usage (Pen), */
|
||||
0xA1, 0x01, /* Collection (Application), */
|
||||
0x85, 0x07, /* Report ID (7), */
|
||||
0x09, 0x20, /* Usage (Stylus), */
|
||||
0xA0, /* Collection (Physical), */
|
||||
0x14, /* Logical Minimum (0), */
|
||||
0x25, 0x01, /* Logical Maximum (1), */
|
||||
0x75, 0x01, /* Report Size (1), */
|
||||
0x09, 0x42, /* Usage (Tip Switch), */
|
||||
0x09, 0x44, /* Usage (Barrel Switch), */
|
||||
0x09, 0x46, /* Usage (Tablet Pick), */
|
||||
0x95, 0x03, /* Report Count (3), */
|
||||
0x81, 0x02, /* Input (Variable), */
|
||||
0x95, 0x03, /* Report Count (3), */
|
||||
0x81, 0x03, /* Input (Constant, Variable), */
|
||||
0x09, 0x32, /* Usage (In Range), */
|
||||
0x95, 0x01, /* Report Count (1), */
|
||||
0x81, 0x02, /* Input (Variable), */
|
||||
0x95, 0x01, /* Report Count (1), */
|
||||
0x81, 0x03, /* Input (Constant, Variable), */
|
||||
0x75, 0x10, /* Report Size (16), */
|
||||
0x95, 0x01, /* Report Count (1), */
|
||||
0xA4, /* Push, */
|
||||
0x05, 0x01, /* Usage Page (Desktop), */
|
||||
0x65, 0x13, /* Unit (Inch), */
|
||||
0x55, 0xFD, /* Unit Exponent (-3), */
|
||||
0x34, /* Physical Minimum (0), */
|
||||
0x09, 0x30, /* Usage (X), */
|
||||
0x46, 0x40, 0x1F, /* Physical Maximum (8000), */
|
||||
0x26, 0x00, 0x7D, /* Logical Maximum (32000), */
|
||||
0x81, 0x02, /* Input (Variable), */
|
||||
0x09, 0x31, /* Usage (Y), */
|
||||
0x46, 0x88, 0x13, /* Physical Maximum (5000), */
|
||||
0x26, 0x20, 0x4E, /* Logical Maximum (20000), */
|
||||
0x81, 0x02, /* Input (Variable), */
|
||||
0xB4, /* Pop, */
|
||||
0x09, 0x30, /* Usage (Tip Pressure), */
|
||||
0x26, 0xFF, 0x07, /* Logical Maximum (2047), */
|
||||
0x81, 0x02, /* Input (Variable), */
|
||||
0xC0, /* End Collection, */
|
||||
0xC0 /* End Collection */
|
||||
};
|
||||
|
||||
static __u8 *huion_report_fixup(struct hid_device *hdev, __u8 *rdesc,
|
||||
unsigned int *rsize)
|
||||
{
|
||||
switch (hdev->product) {
|
||||
case USB_DEVICE_ID_HUION_580:
|
||||
if (*rsize == HUION_580_RDESC_ORIG_SIZE) {
|
||||
rdesc = huion_580_rdesc_fixed;
|
||||
*rsize = sizeof(huion_580_rdesc_fixed);
|
||||
}
|
||||
break;
|
||||
}
|
||||
return rdesc;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enable fully-functional tablet mode by reading special string
|
||||
* descriptor.
|
||||
*
|
||||
* @hdev: HID device
|
||||
*
|
||||
* The specific string descriptor and data were discovered by sniffing
|
||||
* the Windows driver traffic.
|
||||
*/
|
||||
static int huion_tablet_enable(struct hid_device *hdev)
|
||||
{
|
||||
int rc;
|
||||
char buf[22];
|
||||
|
||||
rc = usb_string(hid_to_usb_dev(hdev), 0x64, buf, sizeof(buf));
|
||||
if (rc < 0)
|
||||
return rc;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int huion_probe(struct hid_device *hdev, const struct hid_device_id *id)
|
||||
{
|
||||
int ret;
|
||||
struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
|
||||
|
||||
/* Ignore interfaces 1 (mouse) and 2 (keyboard) for Huion 580 tablet,
|
||||
* as they are not used
|
||||
*/
|
||||
switch (id->product) {
|
||||
case USB_DEVICE_ID_HUION_580:
|
||||
if (intf->cur_altsetting->desc.bInterfaceNumber != 0x00)
|
||||
return -ENODEV;
|
||||
break;
|
||||
}
|
||||
|
||||
ret = hid_parse(hdev);
|
||||
if (ret) {
|
||||
hid_err(hdev, "parse failed\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
|
||||
if (ret) {
|
||||
hid_err(hdev, "hw start failed\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
switch (id->product) {
|
||||
case USB_DEVICE_ID_HUION_580:
|
||||
ret = huion_tablet_enable(hdev);
|
||||
if (ret) {
|
||||
hid_err(hdev, "tablet enabling failed\n");
|
||||
goto enabling_err;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
enabling_err:
|
||||
hid_hw_stop(hdev);
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int huion_raw_event(struct hid_device *hdev, struct hid_report *report,
|
||||
u8 *data, int size)
|
||||
{
|
||||
/* If this is a pen input report then invert the in-range bit */
|
||||
if (report->type == HID_INPUT_REPORT && report->id == 0x07 && size >= 2)
|
||||
data[1] ^= 0x40;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct hid_device_id huion_devices[] = {
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_HUION, USB_DEVICE_ID_HUION_580) },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(hid, huion_devices);
|
||||
|
||||
static struct hid_driver huion_driver = {
|
||||
.name = "huion",
|
||||
.id_table = huion_devices,
|
||||
.probe = huion_probe,
|
||||
.report_fixup = huion_report_fixup,
|
||||
.raw_event = huion_raw_event,
|
||||
};
|
||||
module_hid_driver(huion_driver);
|
||||
|
||||
MODULE_AUTHOR("Martin Rusko");
|
||||
MODULE_DESCRIPTION("Huion HID driver");
|
||||
MODULE_LICENSE("GPL");
|
||||
@ -199,13 +199,11 @@ static void mousevsc_on_receive_device_info(struct mousevsc_dev *input_device,
|
||||
if (desc->bLength == 0)
|
||||
goto cleanup;
|
||||
|
||||
input_device->hid_desc = kzalloc(desc->bLength, GFP_ATOMIC);
|
||||
input_device->hid_desc = kmemdup(desc, desc->bLength, GFP_ATOMIC);
|
||||
|
||||
if (!input_device->hid_desc)
|
||||
goto cleanup;
|
||||
|
||||
memcpy(input_device->hid_desc, desc, desc->bLength);
|
||||
|
||||
input_device->report_desc_size = desc->desc[0].wDescriptorLength;
|
||||
if (input_device->report_desc_size == 0) {
|
||||
input_device->dev_info_status = -EINVAL;
|
||||
|
||||
@ -248,6 +248,9 @@
|
||||
#define USB_DEVICE_ID_CYPRESS_BARCODE_4 0xed81
|
||||
#define USB_DEVICE_ID_CYPRESS_TRUETOUCH 0xc001
|
||||
|
||||
#define USB_VENDOR_ID_DATA_MODUL 0x7374
|
||||
#define USB_VENDOR_ID_DATA_MODUL_EASYMAXTOUCH 0x1201
|
||||
|
||||
#define USB_VENDOR_ID_DEALEXTREAME 0x10c5
|
||||
#define USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701 0x819a
|
||||
|
||||
@ -272,16 +275,15 @@
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E 0x725e
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262 0x7262
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B 0x726b
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA 0x72aa
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1 0x72a1
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA 0x72aa
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4 0x72c4
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0 0x72d0
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA 0x72fa
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302 0x7302
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7349 0x7349
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_73F7 0x73f7
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001 0xa001
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224 0x7224
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0 0x72d0
|
||||
#define USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4 0x72c4
|
||||
|
||||
#define USB_VENDOR_ID_ELECOM 0x056e
|
||||
#define USB_DEVICE_ID_ELECOM_BM084 0x0061
|
||||
@ -425,6 +427,9 @@
|
||||
#define USB_DEVICE_ID_UGCI_FLYING 0x0020
|
||||
#define USB_DEVICE_ID_UGCI_FIGHTING 0x0030
|
||||
|
||||
#define USB_VENDOR_ID_HUION 0x256c
|
||||
#define USB_DEVICE_ID_HUION_580 0x006e
|
||||
|
||||
#define USB_VENDOR_ID_IDEACOM 0x1cb6
|
||||
#define USB_DEVICE_ID_IDEACOM_IDC6650 0x6650
|
||||
#define USB_DEVICE_ID_IDEACOM_IDC6651 0x6651
|
||||
@ -440,6 +445,8 @@
|
||||
|
||||
#define USB_VENDOR_ID_HOLTEK_ALT 0x04d9
|
||||
#define USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD 0xa055
|
||||
#define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067 0xa067
|
||||
#define USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A 0xa04a
|
||||
|
||||
#define USB_VENDOR_ID_IMATION 0x0718
|
||||
#define USB_DEVICE_ID_DISC_STAKKA 0xd000
|
||||
@ -447,6 +454,10 @@
|
||||
#define USB_VENDOR_ID_IRTOUCHSYSTEMS 0x6615
|
||||
#define USB_DEVICE_ID_IRTOUCH_INFRARED_USB 0x0070
|
||||
|
||||
#define USB_VENDOR_ID_JABRA 0x0b0e
|
||||
#define USB_DEVICE_ID_JABRA_SPEAK_410 0x0412
|
||||
#define USB_DEVICE_ID_JABRA_SPEAK_510 0x0420
|
||||
|
||||
#define USB_VENDOR_ID_JESS 0x0c45
|
||||
#define USB_DEVICE_ID_JESS_YUREX 0x1010
|
||||
|
||||
@ -467,6 +478,7 @@
|
||||
|
||||
#define USB_VENDOR_ID_KYE 0x0458
|
||||
#define USB_DEVICE_ID_KYE_ERGO_525V 0x0087
|
||||
#define USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE 0x0138
|
||||
#define USB_DEVICE_ID_KYE_GPEN_560 0x5003
|
||||
#define USB_DEVICE_ID_KYE_EASYPEN_I405X 0x5010
|
||||
#define USB_DEVICE_ID_KYE_MOUSEPEN_I608X 0x5011
|
||||
@ -734,6 +746,8 @@
|
||||
#define USB_DEVICE_ID_SONY_PS3_BDREMOTE 0x0306
|
||||
#define USB_DEVICE_ID_SONY_PS3_CONTROLLER 0x0268
|
||||
#define USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER 0x042f
|
||||
#define USB_DEVICE_ID_SONY_BUZZ_CONTROLLER 0x0002
|
||||
#define USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER 0x1000
|
||||
|
||||
#define USB_VENDOR_ID_SOUNDGRAPH 0x15c2
|
||||
#define USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST 0x0034
|
||||
|
||||
@ -354,10 +354,10 @@ static int hidinput_get_battery_property(struct power_supply *psy,
|
||||
dev->battery_report_type);
|
||||
|
||||
if (ret != 2) {
|
||||
if (ret >= 0)
|
||||
ret = -EINVAL;
|
||||
ret = -ENODATA;
|
||||
break;
|
||||
}
|
||||
ret = 0;
|
||||
|
||||
if (dev->battery_min < dev->battery_max &&
|
||||
buf[1] >= dev->battery_min &&
|
||||
@ -1042,9 +1042,14 @@ void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct
|
||||
|
||||
/*
|
||||
* Ignore out-of-range values as per HID specification,
|
||||
* section 5.10 and 6.2.25
|
||||
* section 5.10 and 6.2.25.
|
||||
*
|
||||
* The logical_minimum < logical_maximum check is done so that we
|
||||
* don't unintentionally discard values sent by devices which
|
||||
* don't specify logical min and max.
|
||||
*/
|
||||
if ((field->flags & HID_MAIN_ITEM_VARIABLE) &&
|
||||
(field->logical_minimum < field->logical_maximum) &&
|
||||
(value < field->logical_minimum ||
|
||||
value > field->logical_maximum)) {
|
||||
dbg_hid("Ignoring out-of-range value %x\n", value);
|
||||
|
||||
@ -314,6 +314,25 @@ static __u8 *kye_report_fixup(struct hid_device *hdev, __u8 *rdesc,
|
||||
*rsize = sizeof(easypen_m610x_rdesc_fixed);
|
||||
}
|
||||
break;
|
||||
case USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE:
|
||||
/*
|
||||
* the fixup that need to be done:
|
||||
* - change Usage Maximum in the Comsumer Control
|
||||
* (report ID 3) to a reasonable value
|
||||
*/
|
||||
if (*rsize >= 135 &&
|
||||
/* Usage Page (Consumer Devices) */
|
||||
rdesc[104] == 0x05 && rdesc[105] == 0x0c &&
|
||||
/* Usage (Consumer Control) */
|
||||
rdesc[106] == 0x09 && rdesc[107] == 0x01 &&
|
||||
/* Usage Maximum > 12287 */
|
||||
rdesc[114] == 0x2a && rdesc[116] > 0x2f) {
|
||||
hid_info(hdev,
|
||||
"fixing up Genius Gila Gaming Mouse "
|
||||
"report descriptor\n");
|
||||
rdesc[116] = 0x2f;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return rdesc;
|
||||
}
|
||||
@ -407,6 +426,8 @@ static const struct hid_device_id kye_devices[] = {
|
||||
USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE,
|
||||
USB_DEVICE_ID_KYE_EASYPEN_M610X) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_KYE,
|
||||
USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE) },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(hid, kye_devices);
|
||||
|
||||
@ -1111,6 +1111,11 @@ static const struct hid_device_id mt_devices[] = {
|
||||
HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
|
||||
USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
|
||||
|
||||
/* Data Modul easyMaxTouch */
|
||||
{ .driver_data = MT_CLS_DEFAULT,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DATA_MODUL,
|
||||
USB_VENDOR_ID_DATA_MODUL_EASYMAXTOUCH) },
|
||||
|
||||
/* eGalax devices (resistive) */
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
@ -1120,33 +1125,39 @@ static const struct hid_device_id mt_devices[] = {
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
|
||||
|
||||
/* eGalax devices (capacitive) */
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
|
||||
{ .driver_data = MT_CLS_EGALAX_SERIAL,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7207) },
|
||||
{ .driver_data = MT_CLS_EGALAX_SERIAL,
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
|
||||
{ .driver_data = MT_CLS_EGALAX_SERIAL,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
|
||||
{ .driver_data = MT_CLS_EGALAX_SERIAL,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_722A) },
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
{ .driver_data = MT_CLS_EGALAX_SERIAL,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
|
||||
{ .driver_data = MT_CLS_EGALAX_SERIAL,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7262) },
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
|
||||
{ .driver_data = MT_CLS_EGALAX_SERIAL,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72AA) },
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) },
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) },
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72FA) },
|
||||
@ -1162,15 +1173,6 @@ static const struct hid_device_id mt_devices[] = {
|
||||
{ .driver_data = MT_CLS_EGALAX_SERIAL,
|
||||
MT_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72D0) },
|
||||
{ .driver_data = MT_CLS_EGALAX,
|
||||
HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
|
||||
USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72C4) },
|
||||
|
||||
/* Elo TouchSystems IntelliTouch Plus panel */
|
||||
{ .driver_data = MT_CLS_DUAL_CONTACT_ID,
|
||||
|
||||
@ -1,204 +0,0 @@
|
||||
/*
|
||||
* HID driver for Sony PS3 BD Remote Control
|
||||
*
|
||||
* Copyright (c) 2012 David Dillow <dave@thedillows.org>
|
||||
* Based on a blend of the bluez fakehid user-space code by Marcel Holtmann
|
||||
* and other kernel HID drivers.
|
||||
*/
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/* NOTE: in order for the Sony PS3 BD Remote Control to be found by
|
||||
* a Bluetooth host, the key combination Start+Enter has to be kept pressed
|
||||
* for about 7 seconds with the Bluetooth Host Controller in discovering mode.
|
||||
*
|
||||
* There will be no PIN request from the device.
|
||||
*/
|
||||
|
||||
#include <linux/device.h>
|
||||
#include <linux/hid.h>
|
||||
#include <linux/module.h>
|
||||
|
||||
#include "hid-ids.h"
|
||||
|
||||
static __u8 ps3remote_rdesc[] = {
|
||||
0x05, 0x01, /* GUsagePage Generic Desktop */
|
||||
0x09, 0x05, /* LUsage 0x05 [Game Pad] */
|
||||
0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
|
||||
|
||||
/* Use collection 1 for joypad buttons */
|
||||
0xA1, 0x02, /* MCollection Logical (interrelated data) */
|
||||
|
||||
/* Ignore the 1st byte, maybe it is used for a controller
|
||||
* number but it's not needed for correct operation */
|
||||
0x75, 0x08, /* GReportSize 0x08 [8] */
|
||||
0x95, 0x01, /* GReportCount 0x01 [1] */
|
||||
0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
|
||||
|
||||
/* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
|
||||
* buttons multiple keypresses are allowed */
|
||||
0x05, 0x09, /* GUsagePage Button */
|
||||
0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
|
||||
0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
|
||||
0x14, /* GLogicalMinimum [0] */
|
||||
0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
|
||||
0x75, 0x01, /* GReportSize 0x01 [1] */
|
||||
0x95, 0x18, /* GReportCount 0x18 [24] */
|
||||
0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
|
||||
|
||||
0xC0, /* MEndCollection */
|
||||
|
||||
/* Use collection 2 for remote control buttons */
|
||||
0xA1, 0x02, /* MCollection Logical (interrelated data) */
|
||||
|
||||
/* 5th byte is used for remote control buttons */
|
||||
0x05, 0x09, /* GUsagePage Button */
|
||||
0x18, /* LUsageMinimum [No button pressed] */
|
||||
0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
|
||||
0x14, /* GLogicalMinimum [0] */
|
||||
0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
|
||||
0x75, 0x08, /* GReportSize 0x08 [8] */
|
||||
0x95, 0x01, /* GReportCount 0x01 [1] */
|
||||
0x80, /* MInput */
|
||||
|
||||
/* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
|
||||
* 0xff and 11th is for press indication */
|
||||
0x75, 0x08, /* GReportSize 0x08 [8] */
|
||||
0x95, 0x06, /* GReportCount 0x06 [6] */
|
||||
0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
|
||||
|
||||
/* 12th byte is for battery strength */
|
||||
0x05, 0x06, /* GUsagePage Generic Device Controls */
|
||||
0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
|
||||
0x14, /* GLogicalMinimum [0] */
|
||||
0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
|
||||
0x75, 0x08, /* GReportSize 0x08 [8] */
|
||||
0x95, 0x01, /* GReportCount 0x01 [1] */
|
||||
0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
|
||||
|
||||
0xC0, /* MEndCollection */
|
||||
|
||||
0xC0 /* MEndCollection [Game Pad] */
|
||||
};
|
||||
|
||||
static const unsigned int ps3remote_keymap_joypad_buttons[] = {
|
||||
[0x01] = KEY_SELECT,
|
||||
[0x02] = BTN_THUMBL, /* L3 */
|
||||
[0x03] = BTN_THUMBR, /* R3 */
|
||||
[0x04] = BTN_START,
|
||||
[0x05] = KEY_UP,
|
||||
[0x06] = KEY_RIGHT,
|
||||
[0x07] = KEY_DOWN,
|
||||
[0x08] = KEY_LEFT,
|
||||
[0x09] = BTN_TL2, /* L2 */
|
||||
[0x0a] = BTN_TR2, /* R2 */
|
||||
[0x0b] = BTN_TL, /* L1 */
|
||||
[0x0c] = BTN_TR, /* R1 */
|
||||
[0x0d] = KEY_OPTION, /* options/triangle */
|
||||
[0x0e] = KEY_BACK, /* back/circle */
|
||||
[0x0f] = BTN_0, /* cross */
|
||||
[0x10] = KEY_SCREEN, /* view/square */
|
||||
[0x11] = KEY_HOMEPAGE, /* PS button */
|
||||
[0x14] = KEY_ENTER,
|
||||
};
|
||||
static const unsigned int ps3remote_keymap_remote_buttons[] = {
|
||||
[0x00] = KEY_1,
|
||||
[0x01] = KEY_2,
|
||||
[0x02] = KEY_3,
|
||||
[0x03] = KEY_4,
|
||||
[0x04] = KEY_5,
|
||||
[0x05] = KEY_6,
|
||||
[0x06] = KEY_7,
|
||||
[0x07] = KEY_8,
|
||||
[0x08] = KEY_9,
|
||||
[0x09] = KEY_0,
|
||||
[0x0e] = KEY_ESC, /* return */
|
||||
[0x0f] = KEY_CLEAR,
|
||||
[0x16] = KEY_EJECTCD,
|
||||
[0x1a] = KEY_MENU, /* top menu */
|
||||
[0x28] = KEY_TIME,
|
||||
[0x30] = KEY_PREVIOUS,
|
||||
[0x31] = KEY_NEXT,
|
||||
[0x32] = KEY_PLAY,
|
||||
[0x33] = KEY_REWIND, /* scan back */
|
||||
[0x34] = KEY_FORWARD, /* scan forward */
|
||||
[0x38] = KEY_STOP,
|
||||
[0x39] = KEY_PAUSE,
|
||||
[0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
|
||||
[0x60] = KEY_FRAMEBACK, /* slow/step back */
|
||||
[0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
|
||||
[0x63] = KEY_SUBTITLE,
|
||||
[0x64] = KEY_AUDIO,
|
||||
[0x65] = KEY_ANGLE,
|
||||
[0x70] = KEY_INFO, /* display */
|
||||
[0x80] = KEY_BLUE,
|
||||
[0x81] = KEY_RED,
|
||||
[0x82] = KEY_GREEN,
|
||||
[0x83] = KEY_YELLOW,
|
||||
};
|
||||
|
||||
static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
|
||||
unsigned int *rsize)
|
||||
{
|
||||
*rsize = sizeof(ps3remote_rdesc);
|
||||
return ps3remote_rdesc;
|
||||
}
|
||||
|
||||
static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
|
||||
struct hid_field *field, struct hid_usage *usage,
|
||||
unsigned long **bit, int *max)
|
||||
{
|
||||
unsigned int key = usage->hid & HID_USAGE;
|
||||
|
||||
if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
|
||||
return -1;
|
||||
|
||||
switch (usage->collection_index) {
|
||||
case 1:
|
||||
if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
|
||||
return -1;
|
||||
|
||||
key = ps3remote_keymap_joypad_buttons[key];
|
||||
if (!key)
|
||||
return -1;
|
||||
break;
|
||||
case 2:
|
||||
if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
|
||||
return -1;
|
||||
|
||||
key = ps3remote_keymap_remote_buttons[key];
|
||||
if (!key)
|
||||
return -1;
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
|
||||
hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static const struct hid_device_id ps3remote_devices[] = {
|
||||
/* PS3 BD Remote Control */
|
||||
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE) },
|
||||
/* Logitech Harmony Adapter for PS3 */
|
||||
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3) },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(hid, ps3remote_devices);
|
||||
|
||||
static struct hid_driver ps3remote_driver = {
|
||||
.name = "ps3_remote",
|
||||
.id_table = ps3remote_devices,
|
||||
.report_fixup = ps3remote_fixup,
|
||||
.input_mapping = ps3remote_mapping,
|
||||
};
|
||||
module_hid_driver(ps3remote_driver);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("David Dillow <dave@thedillows.org>, Antonio Ospite <ospite@studenti.unina.it>");
|
||||
@ -366,7 +366,7 @@ void roccat_disconnect(int minor)
|
||||
mutex_lock(&devices_lock);
|
||||
devices[minor] = NULL;
|
||||
mutex_unlock(&devices_lock);
|
||||
|
||||
|
||||
if (device->open) {
|
||||
hid_hw_close(device->hid);
|
||||
wake_up_interruptible(&device->wait);
|
||||
@ -426,13 +426,23 @@ static int __init roccat_init(void)
|
||||
|
||||
if (retval < 0) {
|
||||
pr_warn("can't get major number\n");
|
||||
return retval;
|
||||
goto error;
|
||||
}
|
||||
|
||||
cdev_init(&roccat_cdev, &roccat_ops);
|
||||
cdev_add(&roccat_cdev, dev_id, ROCCAT_MAX_DEVICES);
|
||||
retval = cdev_add(&roccat_cdev, dev_id, ROCCAT_MAX_DEVICES);
|
||||
|
||||
if (retval < 0) {
|
||||
pr_warn("cannot add cdev\n");
|
||||
goto cleanup_alloc_chrdev_region;
|
||||
}
|
||||
return 0;
|
||||
|
||||
|
||||
cleanup_alloc_chrdev_region:
|
||||
unregister_chrdev_region(dev_id, ROCCAT_MAX_DEVICES);
|
||||
error:
|
||||
return retval;
|
||||
}
|
||||
|
||||
static void __exit roccat_exit(void)
|
||||
|
||||
@ -1,11 +1,13 @@
|
||||
/*
|
||||
* HID driver for some sony "special" devices
|
||||
* HID driver for Sony / PS2 / PS3 BD devices.
|
||||
*
|
||||
* Copyright (c) 1999 Andreas Gal
|
||||
* Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
|
||||
* Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
|
||||
* Copyright (c) 2008 Jiri Slaby
|
||||
* Copyright (c) 2006-2008 Jiri Kosina
|
||||
* Copyright (c) 2012 David Dillow <dave@thedillows.org>
|
||||
* Copyright (c) 2006-2013 Jiri Kosina
|
||||
* Copyright (c) 2013 Colin Leitner <colin.leitner@gmail.com>
|
||||
*/
|
||||
|
||||
/*
|
||||
@ -15,17 +17,27 @@
|
||||
* any later version.
|
||||
*/
|
||||
|
||||
/* NOTE: in order for the Sony PS3 BD Remote Control to be found by
|
||||
* a Bluetooth host, the key combination Start+Enter has to be kept pressed
|
||||
* for about 7 seconds with the Bluetooth Host Controller in discovering mode.
|
||||
*
|
||||
* There will be no PIN request from the device.
|
||||
*/
|
||||
|
||||
#include <linux/device.h>
|
||||
#include <linux/hid.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/usb.h>
|
||||
#include <linux/leds.h>
|
||||
|
||||
#include "hid-ids.h"
|
||||
|
||||
#define VAIO_RDESC_CONSTANT (1 << 0)
|
||||
#define SIXAXIS_CONTROLLER_USB (1 << 1)
|
||||
#define SIXAXIS_CONTROLLER_BT (1 << 2)
|
||||
#define BUZZ_CONTROLLER (1 << 3)
|
||||
#define PS3REMOTE (1 << 4)
|
||||
|
||||
static const u8 sixaxis_rdesc_fixup[] = {
|
||||
0x95, 0x13, 0x09, 0x01, 0x81, 0x02, 0x95, 0x0C,
|
||||
@ -55,10 +67,214 @@ static const u8 sixaxis_rdesc_fixup2[] = {
|
||||
0xb1, 0x02, 0xc0, 0xc0,
|
||||
};
|
||||
|
||||
static __u8 ps3remote_rdesc[] = {
|
||||
0x05, 0x01, /* GUsagePage Generic Desktop */
|
||||
0x09, 0x05, /* LUsage 0x05 [Game Pad] */
|
||||
0xA1, 0x01, /* MCollection Application (mouse, keyboard) */
|
||||
|
||||
/* Use collection 1 for joypad buttons */
|
||||
0xA1, 0x02, /* MCollection Logical (interrelated data) */
|
||||
|
||||
/* Ignore the 1st byte, maybe it is used for a controller
|
||||
* number but it's not needed for correct operation */
|
||||
0x75, 0x08, /* GReportSize 0x08 [8] */
|
||||
0x95, 0x01, /* GReportCount 0x01 [1] */
|
||||
0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
|
||||
|
||||
/* Bytes from 2nd to 4th are a bitmap for joypad buttons, for these
|
||||
* buttons multiple keypresses are allowed */
|
||||
0x05, 0x09, /* GUsagePage Button */
|
||||
0x19, 0x01, /* LUsageMinimum 0x01 [Button 1 (primary/trigger)] */
|
||||
0x29, 0x18, /* LUsageMaximum 0x18 [Button 24] */
|
||||
0x14, /* GLogicalMinimum [0] */
|
||||
0x25, 0x01, /* GLogicalMaximum 0x01 [1] */
|
||||
0x75, 0x01, /* GReportSize 0x01 [1] */
|
||||
0x95, 0x18, /* GReportCount 0x18 [24] */
|
||||
0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
|
||||
|
||||
0xC0, /* MEndCollection */
|
||||
|
||||
/* Use collection 2 for remote control buttons */
|
||||
0xA1, 0x02, /* MCollection Logical (interrelated data) */
|
||||
|
||||
/* 5th byte is used for remote control buttons */
|
||||
0x05, 0x09, /* GUsagePage Button */
|
||||
0x18, /* LUsageMinimum [No button pressed] */
|
||||
0x29, 0xFE, /* LUsageMaximum 0xFE [Button 254] */
|
||||
0x14, /* GLogicalMinimum [0] */
|
||||
0x26, 0xFE, 0x00, /* GLogicalMaximum 0x00FE [254] */
|
||||
0x75, 0x08, /* GReportSize 0x08 [8] */
|
||||
0x95, 0x01, /* GReportCount 0x01 [1] */
|
||||
0x80, /* MInput */
|
||||
|
||||
/* Ignore bytes from 6th to 11th, 6th to 10th are always constant at
|
||||
* 0xff and 11th is for press indication */
|
||||
0x75, 0x08, /* GReportSize 0x08 [8] */
|
||||
0x95, 0x06, /* GReportCount 0x06 [6] */
|
||||
0x81, 0x01, /* MInput 0x01 (Const[0] Arr[1] Abs[2]) */
|
||||
|
||||
/* 12th byte is for battery strength */
|
||||
0x05, 0x06, /* GUsagePage Generic Device Controls */
|
||||
0x09, 0x20, /* LUsage 0x20 [Battery Strength] */
|
||||
0x14, /* GLogicalMinimum [0] */
|
||||
0x25, 0x05, /* GLogicalMaximum 0x05 [5] */
|
||||
0x75, 0x08, /* GReportSize 0x08 [8] */
|
||||
0x95, 0x01, /* GReportCount 0x01 [1] */
|
||||
0x81, 0x02, /* MInput 0x02 (Data[0] Var[1] Abs[2]) */
|
||||
|
||||
0xC0, /* MEndCollection */
|
||||
|
||||
0xC0 /* MEndCollection [Game Pad] */
|
||||
};
|
||||
|
||||
static const unsigned int ps3remote_keymap_joypad_buttons[] = {
|
||||
[0x01] = KEY_SELECT,
|
||||
[0x02] = BTN_THUMBL, /* L3 */
|
||||
[0x03] = BTN_THUMBR, /* R3 */
|
||||
[0x04] = BTN_START,
|
||||
[0x05] = KEY_UP,
|
||||
[0x06] = KEY_RIGHT,
|
||||
[0x07] = KEY_DOWN,
|
||||
[0x08] = KEY_LEFT,
|
||||
[0x09] = BTN_TL2, /* L2 */
|
||||
[0x0a] = BTN_TR2, /* R2 */
|
||||
[0x0b] = BTN_TL, /* L1 */
|
||||
[0x0c] = BTN_TR, /* R1 */
|
||||
[0x0d] = KEY_OPTION, /* options/triangle */
|
||||
[0x0e] = KEY_BACK, /* back/circle */
|
||||
[0x0f] = BTN_0, /* cross */
|
||||
[0x10] = KEY_SCREEN, /* view/square */
|
||||
[0x11] = KEY_HOMEPAGE, /* PS button */
|
||||
[0x14] = KEY_ENTER,
|
||||
};
|
||||
static const unsigned int ps3remote_keymap_remote_buttons[] = {
|
||||
[0x00] = KEY_1,
|
||||
[0x01] = KEY_2,
|
||||
[0x02] = KEY_3,
|
||||
[0x03] = KEY_4,
|
||||
[0x04] = KEY_5,
|
||||
[0x05] = KEY_6,
|
||||
[0x06] = KEY_7,
|
||||
[0x07] = KEY_8,
|
||||
[0x08] = KEY_9,
|
||||
[0x09] = KEY_0,
|
||||
[0x0e] = KEY_ESC, /* return */
|
||||
[0x0f] = KEY_CLEAR,
|
||||
[0x16] = KEY_EJECTCD,
|
||||
[0x1a] = KEY_MENU, /* top menu */
|
||||
[0x28] = KEY_TIME,
|
||||
[0x30] = KEY_PREVIOUS,
|
||||
[0x31] = KEY_NEXT,
|
||||
[0x32] = KEY_PLAY,
|
||||
[0x33] = KEY_REWIND, /* scan back */
|
||||
[0x34] = KEY_FORWARD, /* scan forward */
|
||||
[0x38] = KEY_STOP,
|
||||
[0x39] = KEY_PAUSE,
|
||||
[0x40] = KEY_CONTEXT_MENU, /* pop up/menu */
|
||||
[0x60] = KEY_FRAMEBACK, /* slow/step back */
|
||||
[0x61] = KEY_FRAMEFORWARD, /* slow/step forward */
|
||||
[0x63] = KEY_SUBTITLE,
|
||||
[0x64] = KEY_AUDIO,
|
||||
[0x65] = KEY_ANGLE,
|
||||
[0x70] = KEY_INFO, /* display */
|
||||
[0x80] = KEY_BLUE,
|
||||
[0x81] = KEY_RED,
|
||||
[0x82] = KEY_GREEN,
|
||||
[0x83] = KEY_YELLOW,
|
||||
};
|
||||
|
||||
static const unsigned int buzz_keymap[] = {
|
||||
/* The controller has 4 remote buzzers, each with one LED and 5
|
||||
* buttons.
|
||||
*
|
||||
* We use the mapping chosen by the controller, which is:
|
||||
*
|
||||
* Key Offset
|
||||
* -------------------
|
||||
* Buzz 1
|
||||
* Blue 5
|
||||
* Orange 4
|
||||
* Green 3
|
||||
* Yellow 2
|
||||
*
|
||||
* So, for example, the orange button on the third buzzer is mapped to
|
||||
* BTN_TRIGGER_HAPPY14
|
||||
*/
|
||||
[ 1] = BTN_TRIGGER_HAPPY1,
|
||||
[ 2] = BTN_TRIGGER_HAPPY2,
|
||||
[ 3] = BTN_TRIGGER_HAPPY3,
|
||||
[ 4] = BTN_TRIGGER_HAPPY4,
|
||||
[ 5] = BTN_TRIGGER_HAPPY5,
|
||||
[ 6] = BTN_TRIGGER_HAPPY6,
|
||||
[ 7] = BTN_TRIGGER_HAPPY7,
|
||||
[ 8] = BTN_TRIGGER_HAPPY8,
|
||||
[ 9] = BTN_TRIGGER_HAPPY9,
|
||||
[10] = BTN_TRIGGER_HAPPY10,
|
||||
[11] = BTN_TRIGGER_HAPPY11,
|
||||
[12] = BTN_TRIGGER_HAPPY12,
|
||||
[13] = BTN_TRIGGER_HAPPY13,
|
||||
[14] = BTN_TRIGGER_HAPPY14,
|
||||
[15] = BTN_TRIGGER_HAPPY15,
|
||||
[16] = BTN_TRIGGER_HAPPY16,
|
||||
[17] = BTN_TRIGGER_HAPPY17,
|
||||
[18] = BTN_TRIGGER_HAPPY18,
|
||||
[19] = BTN_TRIGGER_HAPPY19,
|
||||
[20] = BTN_TRIGGER_HAPPY20,
|
||||
};
|
||||
|
||||
struct sony_sc {
|
||||
unsigned long quirks;
|
||||
|
||||
void *extra;
|
||||
};
|
||||
|
||||
struct buzz_extra {
|
||||
int led_state;
|
||||
struct led_classdev *leds[4];
|
||||
};
|
||||
|
||||
static __u8 *ps3remote_fixup(struct hid_device *hdev, __u8 *rdesc,
|
||||
unsigned int *rsize)
|
||||
{
|
||||
*rsize = sizeof(ps3remote_rdesc);
|
||||
return ps3remote_rdesc;
|
||||
}
|
||||
|
||||
static int ps3remote_mapping(struct hid_device *hdev, struct hid_input *hi,
|
||||
struct hid_field *field, struct hid_usage *usage,
|
||||
unsigned long **bit, int *max)
|
||||
{
|
||||
unsigned int key = usage->hid & HID_USAGE;
|
||||
|
||||
if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
|
||||
return -1;
|
||||
|
||||
switch (usage->collection_index) {
|
||||
case 1:
|
||||
if (key >= ARRAY_SIZE(ps3remote_keymap_joypad_buttons))
|
||||
return -1;
|
||||
|
||||
key = ps3remote_keymap_joypad_buttons[key];
|
||||
if (!key)
|
||||
return -1;
|
||||
break;
|
||||
case 2:
|
||||
if (key >= ARRAY_SIZE(ps3remote_keymap_remote_buttons))
|
||||
return -1;
|
||||
|
||||
key = ps3remote_keymap_remote_buttons[key];
|
||||
if (!key)
|
||||
return -1;
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
|
||||
hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/* Sony Vaio VGX has wrongly mouse pointer declared as constant */
|
||||
static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
|
||||
unsigned int *rsize)
|
||||
@ -95,6 +311,10 @@ static __u8 *sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
|
||||
*rsize = sizeof(sixaxis_rdesc_fixup2);
|
||||
memcpy(rdesc, &sixaxis_rdesc_fixup2, *rsize);
|
||||
}
|
||||
|
||||
if (sc->quirks & PS3REMOTE)
|
||||
return ps3remote_fixup(hdev, rdesc, rsize);
|
||||
|
||||
return rdesc;
|
||||
}
|
||||
|
||||
@ -117,6 +337,41 @@ static int sony_raw_event(struct hid_device *hdev, struct hid_report *report,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sony_mapping(struct hid_device *hdev, struct hid_input *hi,
|
||||
struct hid_field *field, struct hid_usage *usage,
|
||||
unsigned long **bit, int *max)
|
||||
{
|
||||
struct sony_sc *sc = hid_get_drvdata(hdev);
|
||||
|
||||
if (sc->quirks & BUZZ_CONTROLLER) {
|
||||
unsigned int key = usage->hid & HID_USAGE;
|
||||
|
||||
if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
|
||||
return -1;
|
||||
|
||||
switch (usage->collection_index) {
|
||||
case 1:
|
||||
if (key >= ARRAY_SIZE(buzz_keymap))
|
||||
return -1;
|
||||
|
||||
key = buzz_keymap[key];
|
||||
if (!key)
|
||||
return -1;
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
|
||||
hid_map_usage_clear(hi, usage, bit, max, EV_KEY, key);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (sc->quirks & PS3REMOTE)
|
||||
return ps3remote_mapping(hdev, hi, field, usage, bit, max);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* The Sony Sixaxis does not handle HID Output Reports on the Interrupt EP
|
||||
* like it should according to usbhid/hid-core.c::usbhid_output_raw_report()
|
||||
@ -192,11 +447,181 @@ static int sixaxis_set_operational_bt(struct hid_device *hdev)
|
||||
return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
|
||||
}
|
||||
|
||||
static void buzz_set_leds(struct hid_device *hdev, int leds)
|
||||
{
|
||||
struct list_head *report_list =
|
||||
&hdev->report_enum[HID_OUTPUT_REPORT].report_list;
|
||||
struct hid_report *report = list_entry(report_list->next,
|
||||
struct hid_report, list);
|
||||
__s32 *value = report->field[0]->value;
|
||||
|
||||
value[0] = 0x00;
|
||||
value[1] = (leds & 1) ? 0xff : 0x00;
|
||||
value[2] = (leds & 2) ? 0xff : 0x00;
|
||||
value[3] = (leds & 4) ? 0xff : 0x00;
|
||||
value[4] = (leds & 8) ? 0xff : 0x00;
|
||||
value[5] = 0x00;
|
||||
value[6] = 0x00;
|
||||
hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
|
||||
}
|
||||
|
||||
static void buzz_led_set_brightness(struct led_classdev *led,
|
||||
enum led_brightness value)
|
||||
{
|
||||
struct device *dev = led->dev->parent;
|
||||
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
||||
struct sony_sc *drv_data;
|
||||
struct buzz_extra *buzz;
|
||||
|
||||
int n;
|
||||
|
||||
drv_data = hid_get_drvdata(hdev);
|
||||
if (!drv_data || !drv_data->extra) {
|
||||
hid_err(hdev, "No device data\n");
|
||||
return;
|
||||
}
|
||||
buzz = drv_data->extra;
|
||||
|
||||
for (n = 0; n < 4; n++) {
|
||||
if (led == buzz->leds[n]) {
|
||||
int on = !! (buzz->led_state & (1 << n));
|
||||
if (value == LED_OFF && on) {
|
||||
buzz->led_state &= ~(1 << n);
|
||||
buzz_set_leds(hdev, buzz->led_state);
|
||||
} else if (value != LED_OFF && !on) {
|
||||
buzz->led_state |= (1 << n);
|
||||
buzz_set_leds(hdev, buzz->led_state);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static enum led_brightness buzz_led_get_brightness(struct led_classdev *led)
|
||||
{
|
||||
struct device *dev = led->dev->parent;
|
||||
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
||||
struct sony_sc *drv_data;
|
||||
struct buzz_extra *buzz;
|
||||
|
||||
int n;
|
||||
int on = 0;
|
||||
|
||||
drv_data = hid_get_drvdata(hdev);
|
||||
if (!drv_data || !drv_data->extra) {
|
||||
hid_err(hdev, "No device data\n");
|
||||
return LED_OFF;
|
||||
}
|
||||
buzz = drv_data->extra;
|
||||
|
||||
for (n = 0; n < 4; n++) {
|
||||
if (led == buzz->leds[n]) {
|
||||
on = !! (buzz->led_state & (1 << n));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return on ? LED_FULL : LED_OFF;
|
||||
}
|
||||
|
||||
static int buzz_init(struct hid_device *hdev)
|
||||
{
|
||||
struct sony_sc *drv_data;
|
||||
struct buzz_extra *buzz;
|
||||
int n, ret = 0;
|
||||
struct led_classdev *led;
|
||||
size_t name_sz;
|
||||
char *name;
|
||||
|
||||
drv_data = hid_get_drvdata(hdev);
|
||||
BUG_ON(!(drv_data->quirks & BUZZ_CONTROLLER));
|
||||
|
||||
buzz = kzalloc(sizeof(*buzz), GFP_KERNEL);
|
||||
if (!buzz) {
|
||||
hid_err(hdev, "Insufficient memory, cannot allocate driver data\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
drv_data->extra = buzz;
|
||||
|
||||
/* Clear LEDs as we have no way of reading their initial state. This is
|
||||
* only relevant if the driver is loaded after somebody actively set the
|
||||
* LEDs to on */
|
||||
buzz_set_leds(hdev, 0x00);
|
||||
|
||||
name_sz = strlen(dev_name(&hdev->dev)) + strlen("::buzz#") + 1;
|
||||
|
||||
for (n = 0; n < 4; n++) {
|
||||
led = kzalloc(sizeof(struct led_classdev) + name_sz, GFP_KERNEL);
|
||||
if (!led) {
|
||||
hid_err(hdev, "Couldn't allocate memory for LED %d\n", n);
|
||||
goto error_leds;
|
||||
}
|
||||
|
||||
name = (void *)(&led[1]);
|
||||
snprintf(name, name_sz, "%s::buzz%d", dev_name(&hdev->dev), n + 1);
|
||||
led->name = name;
|
||||
led->brightness = 0;
|
||||
led->max_brightness = 1;
|
||||
led->brightness_get = buzz_led_get_brightness;
|
||||
led->brightness_set = buzz_led_set_brightness;
|
||||
|
||||
if (led_classdev_register(&hdev->dev, led)) {
|
||||
hid_err(hdev, "Failed to register LED %d\n", n);
|
||||
kfree(led);
|
||||
goto error_leds;
|
||||
}
|
||||
|
||||
buzz->leds[n] = led;
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
||||
error_leds:
|
||||
for (n = 0; n < 4; n++) {
|
||||
led = buzz->leds[n];
|
||||
buzz->leds[n] = NULL;
|
||||
if (!led)
|
||||
continue;
|
||||
led_classdev_unregister(led);
|
||||
kfree(led);
|
||||
}
|
||||
|
||||
kfree(drv_data->extra);
|
||||
drv_data->extra = NULL;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void buzz_remove(struct hid_device *hdev)
|
||||
{
|
||||
struct sony_sc *drv_data;
|
||||
struct buzz_extra *buzz;
|
||||
struct led_classdev *led;
|
||||
int n;
|
||||
|
||||
drv_data = hid_get_drvdata(hdev);
|
||||
BUG_ON(!(drv_data->quirks & BUZZ_CONTROLLER));
|
||||
|
||||
buzz = drv_data->extra;
|
||||
|
||||
for (n = 0; n < 4; n++) {
|
||||
led = buzz->leds[n];
|
||||
buzz->leds[n] = NULL;
|
||||
if (!led)
|
||||
continue;
|
||||
led_classdev_unregister(led);
|
||||
kfree(led);
|
||||
}
|
||||
|
||||
kfree(drv_data->extra);
|
||||
drv_data->extra = NULL;
|
||||
}
|
||||
|
||||
static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
|
||||
{
|
||||
int ret;
|
||||
unsigned long quirks = id->driver_data;
|
||||
struct sony_sc *sc;
|
||||
unsigned int connect_mask = HID_CONNECT_DEFAULT;
|
||||
|
||||
sc = kzalloc(sizeof(*sc), GFP_KERNEL);
|
||||
if (sc == NULL) {
|
||||
@ -213,8 +638,14 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
|
||||
goto err_free;
|
||||
}
|
||||
|
||||
ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT |
|
||||
HID_CONNECT_HIDDEV_FORCE);
|
||||
if (sc->quirks & VAIO_RDESC_CONSTANT)
|
||||
connect_mask |= HID_CONNECT_HIDDEV_FORCE;
|
||||
else if (sc->quirks & SIXAXIS_CONTROLLER_USB)
|
||||
connect_mask |= HID_CONNECT_HIDDEV_FORCE;
|
||||
else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
|
||||
connect_mask |= HID_CONNECT_HIDDEV_FORCE;
|
||||
|
||||
ret = hid_hw_start(hdev, connect_mask);
|
||||
if (ret) {
|
||||
hid_err(hdev, "hw start failed\n");
|
||||
goto err_free;
|
||||
@ -226,6 +657,8 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
|
||||
}
|
||||
else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
|
||||
ret = sixaxis_set_operational_bt(hdev);
|
||||
else if (sc->quirks & BUZZ_CONTROLLER)
|
||||
ret = buzz_init(hdev);
|
||||
else
|
||||
ret = 0;
|
||||
|
||||
@ -242,8 +675,13 @@ err_free:
|
||||
|
||||
static void sony_remove(struct hid_device *hdev)
|
||||
{
|
||||
struct sony_sc *sc = hid_get_drvdata(hdev);
|
||||
|
||||
if (sc->quirks & BUZZ_CONTROLLER)
|
||||
buzz_remove(hdev);
|
||||
|
||||
hid_hw_stop(hdev);
|
||||
kfree(hid_get_drvdata(hdev));
|
||||
kfree(sc);
|
||||
}
|
||||
|
||||
static const struct hid_device_id sony_devices[] = {
|
||||
@ -257,17 +695,30 @@ static const struct hid_device_id sony_devices[] = {
|
||||
.driver_data = VAIO_RDESC_CONSTANT },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE),
|
||||
.driver_data = VAIO_RDESC_CONSTANT },
|
||||
/* Wired Buzz Controller. Reported as Sony Hub from its USB ID and as
|
||||
* Logitech joystick from the device descriptor. */
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER),
|
||||
.driver_data = BUZZ_CONTROLLER },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER),
|
||||
.driver_data = BUZZ_CONTROLLER },
|
||||
/* PS3 BD Remote Control */
|
||||
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE),
|
||||
.driver_data = PS3REMOTE },
|
||||
/* Logitech Harmony Adapter for PS3 */
|
||||
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3),
|
||||
.driver_data = PS3REMOTE },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(hid, sony_devices);
|
||||
|
||||
static struct hid_driver sony_driver = {
|
||||
.name = "sony",
|
||||
.id_table = sony_devices,
|
||||
.probe = sony_probe,
|
||||
.remove = sony_remove,
|
||||
.report_fixup = sony_report_fixup,
|
||||
.raw_event = sony_raw_event
|
||||
.name = "sony",
|
||||
.id_table = sony_devices,
|
||||
.input_mapping = sony_mapping,
|
||||
.probe = sony_probe,
|
||||
.remove = sony_remove,
|
||||
.report_fixup = sony_report_fixup,
|
||||
.raw_event = sony_raw_event
|
||||
};
|
||||
module_hid_driver(sony_driver);
|
||||
|
||||
|
||||
@ -46,6 +46,7 @@ struct wacom_data {
|
||||
__u8 battery_capacity;
|
||||
__u8 power_raw;
|
||||
__u8 ps_connected;
|
||||
__u8 bat_charging;
|
||||
struct power_supply battery;
|
||||
struct power_supply ac;
|
||||
__u8 led_selector;
|
||||
@ -62,6 +63,7 @@ static enum power_supply_property wacom_battery_props[] = {
|
||||
POWER_SUPPLY_PROP_PRESENT,
|
||||
POWER_SUPPLY_PROP_CAPACITY,
|
||||
POWER_SUPPLY_PROP_SCOPE,
|
||||
POWER_SUPPLY_PROP_STATUS,
|
||||
};
|
||||
|
||||
static enum power_supply_property wacom_ac_props[] = {
|
||||
@ -287,6 +289,15 @@ static int wacom_battery_get_property(struct power_supply *psy,
|
||||
case POWER_SUPPLY_PROP_CAPACITY:
|
||||
val->intval = wdata->battery_capacity;
|
||||
break;
|
||||
case POWER_SUPPLY_PROP_STATUS:
|
||||
if (wdata->bat_charging)
|
||||
val->intval = POWER_SUPPLY_STATUS_CHARGING;
|
||||
else
|
||||
if (wdata->battery_capacity == 100 && wdata->ps_connected)
|
||||
val->intval = POWER_SUPPLY_STATUS_FULL;
|
||||
else
|
||||
val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
|
||||
break;
|
||||
default:
|
||||
ret = -EINVAL;
|
||||
break;
|
||||
@ -727,7 +738,8 @@ static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
|
||||
if (power_raw != wdata->power_raw) {
|
||||
wdata->power_raw = power_raw;
|
||||
wdata->battery_capacity = batcap_i4[power_raw & 0x07];
|
||||
wdata->ps_connected = power_raw & 0x08;
|
||||
wdata->bat_charging = (power_raw & 0x08) ? 1 : 0;
|
||||
wdata->ps_connected = (power_raw & 0x10) ? 1 : 0;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Debug support for HID Nintendo Wiimote devices
|
||||
* Copyright (c) 2011 David Herrmann
|
||||
* Debug support for HID Nintendo Wii / Wii U peripherals
|
||||
* Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
|
||||
*/
|
||||
|
||||
/*
|
||||
@ -127,7 +127,8 @@ static int wiidebug_drm_open(struct inode *i, struct file *f)
|
||||
static ssize_t wiidebug_drm_write(struct file *f, const char __user *u,
|
||||
size_t s, loff_t *off)
|
||||
{
|
||||
struct wiimote_debug *dbg = f->private_data;
|
||||
struct seq_file *sf = f->private_data;
|
||||
struct wiimote_debug *dbg = sf->private;
|
||||
unsigned long flags;
|
||||
char buf[16];
|
||||
ssize_t len;
|
||||
@ -140,7 +141,7 @@ static ssize_t wiidebug_drm_write(struct file *f, const char __user *u,
|
||||
if (copy_from_user(buf, u, len))
|
||||
return -EFAULT;
|
||||
|
||||
buf[15] = 0;
|
||||
buf[len] = 0;
|
||||
|
||||
for (i = 0; i < WIIPROTO_REQ_MAX; ++i) {
|
||||
if (!wiidebug_drmmap[i])
|
||||
@ -150,10 +151,13 @@ static ssize_t wiidebug_drm_write(struct file *f, const char __user *u,
|
||||
}
|
||||
|
||||
if (i == WIIPROTO_REQ_MAX)
|
||||
i = simple_strtoul(buf, NULL, 10);
|
||||
i = simple_strtoul(buf, NULL, 16);
|
||||
|
||||
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;
|
||||
|
||||
@ -1,849 +0,0 @@
|
||||
/*
|
||||
* 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);
|
||||
}
|
||||
2086
drivers/hid/hid-wiimote-modules.c
Normal file
2086
drivers/hid/hid-wiimote-modules.c
Normal file
File diff suppressed because it is too large
Load Diff
@ -2,8 +2,8 @@
|
||||
#define __HID_WIIMOTE_H
|
||||
|
||||
/*
|
||||
* HID driver for Nintendo Wiimote devices
|
||||
* Copyright (c) 2011 David Herrmann
|
||||
* HID driver for Nintendo Wii / Wii U peripherals
|
||||
* Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
|
||||
*/
|
||||
|
||||
/*
|
||||
@ -22,6 +22,7 @@
|
||||
#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
|
||||
@ -35,6 +36,17 @@
|
||||
#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_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 | \
|
||||
@ -43,16 +55,71 @@
|
||||
/* 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;
|
||||
__u8 flags;
|
||||
__u32 flags;
|
||||
__u8 accel_split[2];
|
||||
__u8 drm;
|
||||
__u8 devtype;
|
||||
__u8 exttype;
|
||||
__u8 mp;
|
||||
|
||||
/* synchronous cmd requests */
|
||||
struct mutex sync;
|
||||
@ -65,6 +132,9 @@ struct wiimote_state {
|
||||
__u8 cmd_err;
|
||||
__u8 *cmd_read_buf;
|
||||
__u8 cmd_read_size;
|
||||
|
||||
/* calibration data */
|
||||
__u16 calib_bboard[4][3];
|
||||
};
|
||||
|
||||
struct wiimote_data {
|
||||
@ -74,18 +144,63 @@ struct wiimote_data {
|
||||
struct input_dev *accel;
|
||||
struct input_dev *ir;
|
||||
struct power_supply battery;
|
||||
struct wiimote_ext *ext;
|
||||
struct input_dev *mp;
|
||||
struct timer_list timer;
|
||||
struct wiimote_debug *debug;
|
||||
|
||||
spinlock_t qlock;
|
||||
__u8 head;
|
||||
__u8 tail;
|
||||
struct wiimote_buf outq[WIIMOTE_BUFSIZE];
|
||||
struct work_struct worker;
|
||||
union {
|
||||
struct input_dev *input;
|
||||
} extension;
|
||||
|
||||
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,
|
||||
@ -99,24 +214,55 @@ 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,
|
||||
@ -129,24 +275,6 @@ 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);
|
||||
@ -173,11 +301,26 @@ 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)
|
||||
@ -196,11 +339,31 @@ 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;
|
||||
}
|
||||
|
||||
@ -108,6 +108,7 @@ static const struct i2c_hid_cmd hid_reset_cmd = { I2C_HID_CMD(0x01),
|
||||
static const struct i2c_hid_cmd hid_get_report_cmd = { I2C_HID_CMD(0x02) };
|
||||
static const struct i2c_hid_cmd hid_set_report_cmd = { I2C_HID_CMD(0x03) };
|
||||
static const struct i2c_hid_cmd hid_set_power_cmd = { I2C_HID_CMD(0x08) };
|
||||
static const struct i2c_hid_cmd hid_no_cmd = { .length = 0 };
|
||||
|
||||
/*
|
||||
* These definitions are not used here, but are defined by the spec.
|
||||
@ -259,8 +260,11 @@ static int i2c_hid_set_report(struct i2c_client *client, u8 reportType,
|
||||
{
|
||||
struct i2c_hid *ihid = i2c_get_clientdata(client);
|
||||
u8 *args = ihid->argsbuf;
|
||||
const struct i2c_hid_cmd * hidcmd = &hid_set_report_cmd;
|
||||
int ret;
|
||||
u16 dataRegister = le16_to_cpu(ihid->hdesc.wDataRegister);
|
||||
u16 outputRegister = le16_to_cpu(ihid->hdesc.wOutputRegister);
|
||||
u16 maxOutputLength = le16_to_cpu(ihid->hdesc.wMaxOutputLength);
|
||||
|
||||
/* hidraw already checked that data_len < HID_MAX_BUFFER_SIZE */
|
||||
u16 size = 2 /* size */ +
|
||||
@ -278,8 +282,18 @@ static int i2c_hid_set_report(struct i2c_client *client, u8 reportType,
|
||||
reportID = 0x0F;
|
||||
}
|
||||
|
||||
args[index++] = dataRegister & 0xFF;
|
||||
args[index++] = dataRegister >> 8;
|
||||
/*
|
||||
* use the data register for feature reports or if the device does not
|
||||
* support the output register
|
||||
*/
|
||||
if (reportType == 0x03 || maxOutputLength == 0) {
|
||||
args[index++] = dataRegister & 0xFF;
|
||||
args[index++] = dataRegister >> 8;
|
||||
} else {
|
||||
args[index++] = outputRegister & 0xFF;
|
||||
args[index++] = outputRegister >> 8;
|
||||
hidcmd = &hid_no_cmd;
|
||||
}
|
||||
|
||||
args[index++] = size & 0xFF;
|
||||
args[index++] = size >> 8;
|
||||
@ -289,7 +303,7 @@ static int i2c_hid_set_report(struct i2c_client *client, u8 reportType,
|
||||
|
||||
memcpy(&args[index], buf, data_len);
|
||||
|
||||
ret = __i2c_hid_command(client, &hid_set_report_cmd, reportID,
|
||||
ret = __i2c_hid_command(client, hidcmd, reportID,
|
||||
reportType, args, args_len, NULL, 0);
|
||||
if (ret) {
|
||||
dev_err(&client->dev, "failed to set a report to device.\n");
|
||||
|
||||
@ -506,11 +506,15 @@ struct input_keymap_entry {
|
||||
#define BTN_DEAD 0x12f
|
||||
|
||||
#define BTN_GAMEPAD 0x130
|
||||
#define BTN_A 0x130
|
||||
#define BTN_B 0x131
|
||||
#define BTN_SOUTH 0x130
|
||||
#define BTN_A BTN_SOUTH
|
||||
#define BTN_EAST 0x131
|
||||
#define BTN_B BTN_EAST
|
||||
#define BTN_C 0x132
|
||||
#define BTN_X 0x133
|
||||
#define BTN_Y 0x134
|
||||
#define BTN_NORTH 0x133
|
||||
#define BTN_X BTN_NORTH
|
||||
#define BTN_WEST 0x134
|
||||
#define BTN_Y BTN_WEST
|
||||
#define BTN_Z 0x135
|
||||
#define BTN_TL 0x136
|
||||
#define BTN_TR 0x137
|
||||
@ -707,6 +711,11 @@ struct input_keymap_entry {
|
||||
#define KEY_ATTENDANT_TOGGLE 0x21d /* Attendant call on or off */
|
||||
#define KEY_LIGHTS_TOGGLE 0x21e /* Reading light on or off */
|
||||
|
||||
#define BTN_DPAD_UP 0x220
|
||||
#define BTN_DPAD_DOWN 0x221
|
||||
#define BTN_DPAD_LEFT 0x222
|
||||
#define BTN_DPAD_RIGHT 0x223
|
||||
|
||||
#define BTN_TRIGGER_HAPPY 0x2c0
|
||||
#define BTN_TRIGGER_HAPPY1 0x2c0
|
||||
#define BTN_TRIGGER_HAPPY2 0x2c1
|
||||
|
||||
@ -850,6 +850,29 @@ static void hidp_session_dev_del(struct hidp_session *session)
|
||||
input_unregister_device(session->input);
|
||||
}
|
||||
|
||||
/*
|
||||
* Asynchronous device registration
|
||||
* HID device drivers might want to perform I/O during initialization to
|
||||
* detect device types. Therefore, call device registration in a separate
|
||||
* worker so the HIDP thread can schedule I/O operations.
|
||||
* Note that this must be called after the worker thread was initialized
|
||||
* successfully. This will then add the devices and increase session state
|
||||
* on success, otherwise it will terminate the session thread.
|
||||
*/
|
||||
static void hidp_session_dev_work(struct work_struct *work)
|
||||
{
|
||||
struct hidp_session *session = container_of(work,
|
||||
struct hidp_session,
|
||||
dev_init);
|
||||
int ret;
|
||||
|
||||
ret = hidp_session_dev_add(session);
|
||||
if (!ret)
|
||||
atomic_inc(&session->state);
|
||||
else
|
||||
hidp_session_terminate(session);
|
||||
}
|
||||
|
||||
/*
|
||||
* Create new session object
|
||||
* Allocate session object, initialize static fields, copy input data into the
|
||||
@ -897,6 +920,7 @@ static int hidp_session_new(struct hidp_session **out, const bdaddr_t *bdaddr,
|
||||
session->idle_to = req->idle_to;
|
||||
|
||||
/* device management */
|
||||
INIT_WORK(&session->dev_init, hidp_session_dev_work);
|
||||
setup_timer(&session->timer, hidp_idle_timeout,
|
||||
(unsigned long)session);
|
||||
|
||||
@ -1035,8 +1059,8 @@ static void hidp_session_terminate(struct hidp_session *session)
|
||||
* Probe HIDP session
|
||||
* This is called from the l2cap_conn core when our l2cap_user object is bound
|
||||
* to the hci-connection. We get the session via the \user object and can now
|
||||
* start the session thread, register the HID/input devices and link it into
|
||||
* the global session list.
|
||||
* start the session thread, link it into the global session list and
|
||||
* schedule HID/input device registration.
|
||||
* The global session-list owns its own reference to the session object so you
|
||||
* can drop your own reference after registering the l2cap_user object.
|
||||
*/
|
||||
@ -1058,21 +1082,30 @@ static int hidp_session_probe(struct l2cap_conn *conn,
|
||||
goto out_unlock;
|
||||
}
|
||||
|
||||
if (session->input) {
|
||||
ret = hidp_session_dev_add(session);
|
||||
if (ret)
|
||||
goto out_unlock;
|
||||
}
|
||||
|
||||
ret = hidp_session_start_sync(session);
|
||||
if (ret)
|
||||
goto out_unlock;
|
||||
goto out_del;
|
||||
|
||||
ret = hidp_session_dev_add(session);
|
||||
if (ret)
|
||||
goto out_stop;
|
||||
/* HID device registration is async to allow I/O during probe */
|
||||
if (session->input)
|
||||
atomic_inc(&session->state);
|
||||
else
|
||||
schedule_work(&session->dev_init);
|
||||
|
||||
hidp_session_get(session);
|
||||
list_add(&session->list, &hidp_session_list);
|
||||
ret = 0;
|
||||
goto out_unlock;
|
||||
|
||||
out_stop:
|
||||
hidp_session_terminate(session);
|
||||
out_del:
|
||||
if (session->input)
|
||||
hidp_session_dev_del(session);
|
||||
out_unlock:
|
||||
up_write(&hidp_session_sem);
|
||||
return ret;
|
||||
@ -1102,7 +1135,12 @@ static void hidp_session_remove(struct l2cap_conn *conn,
|
||||
down_write(&hidp_session_sem);
|
||||
|
||||
hidp_session_terminate(session);
|
||||
hidp_session_dev_del(session);
|
||||
|
||||
cancel_work_sync(&session->dev_init);
|
||||
if (session->input ||
|
||||
atomic_read(&session->state) > HIDP_SESSION_PREPARING)
|
||||
hidp_session_dev_del(session);
|
||||
|
||||
list_del(&session->list);
|
||||
|
||||
up_write(&hidp_session_sem);
|
||||
|
||||
@ -128,6 +128,7 @@ int hidp_get_conninfo(struct hidp_conninfo *ci);
|
||||
|
||||
enum hidp_session_state {
|
||||
HIDP_SESSION_IDLING,
|
||||
HIDP_SESSION_PREPARING,
|
||||
HIDP_SESSION_RUNNING,
|
||||
};
|
||||
|
||||
@ -156,6 +157,7 @@ struct hidp_session {
|
||||
unsigned long idle_to;
|
||||
|
||||
/* device management */
|
||||
struct work_struct dev_init;
|
||||
struct input_dev *input;
|
||||
struct hid_device *hid;
|
||||
struct timer_list timer;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user