forked from Minki/linux
c7f1429389
Xbox One controllers have multiple interfaces which all have the
same class, subclass, and protocol. One of the these interfaces
has only a single endpoint. When Xpad attempts to bind to this
interface, it causes an oops when trying initialize the output URB
by trying to access the second endpoint's descriptor.
This situation was avoided for known Xbox One devices by checking
the XTYPE constant associated with the VID and PID tuple. However,
this breaks when new or previously unknown Xbox One controllers
are attached to the system.
This change addresses the problem by deriving the XTYPE for Xbox
One controllers based on the interface protocol before checking
the interface number.
Fixes: 1a48ff81b3 ("Input: xpad - add support for Xbox One controllers")
Signed-off-by: Cameron Gutman <aicommander@gmail.com>
Cc: stable@vger.kernel.org
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
1635 lines
48 KiB
C
1635 lines
48 KiB
C
/*
|
|
* X-Box gamepad driver
|
|
*
|
|
* Copyright (c) 2002 Marko Friedemann <mfr@bmx-chemnitz.de>
|
|
* 2004 Oliver Schwartz <Oliver.Schwartz@gmx.de>,
|
|
* Steven Toth <steve@toth.demon.co.uk>,
|
|
* Franz Lehner <franz@caos.at>,
|
|
* Ivan Hawkes <blackhawk@ivanhawkes.com>
|
|
* 2005 Dominic Cerquetti <binary1230@yahoo.com>
|
|
* 2006 Adam Buchbinder <adam.buchbinder@gmail.com>
|
|
* 2007 Jan Kratochvil <honza@jikos.cz>
|
|
* 2010 Christoph Fritz <chf.fritz@googlemail.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*
|
|
* This driver is based on:
|
|
* - information from http://euc.jp/periphs/xbox-controller.ja.html
|
|
* - the iForce driver drivers/char/joystick/iforce.c
|
|
* - the skeleton-driver drivers/usb/usb-skeleton.c
|
|
* - Xbox 360 information http://www.free60.org/wiki/Gamepad
|
|
* - Xbox One information https://github.com/quantus/xbox-one-controller-protocol
|
|
*
|
|
* Thanks to:
|
|
* - ITO Takayuki for providing essential xpad information on his website
|
|
* - Vojtech Pavlik - iforce driver / input subsystem
|
|
* - Greg Kroah-Hartman - usb-skeleton driver
|
|
* - XBOX Linux project - extra USB id's
|
|
* - Pekka Pöyry (quantus) - Xbox One controller reverse engineering
|
|
*
|
|
* TODO:
|
|
* - fine tune axes (especially trigger axes)
|
|
* - fix "analog" buttons (reported as digital now)
|
|
* - get rumble working
|
|
* - need USB IDs for other dance pads
|
|
*
|
|
* History:
|
|
*
|
|
* 2002-06-27 - 0.0.1 : first version, just said "XBOX HID controller"
|
|
*
|
|
* 2002-07-02 - 0.0.2 : basic working version
|
|
* - all axes and 9 of the 10 buttons work (german InterAct device)
|
|
* - the black button does not work
|
|
*
|
|
* 2002-07-14 - 0.0.3 : rework by Vojtech Pavlik
|
|
* - indentation fixes
|
|
* - usb + input init sequence fixes
|
|
*
|
|
* 2002-07-16 - 0.0.4 : minor changes, merge with Vojtech's v0.0.3
|
|
* - verified the lack of HID and report descriptors
|
|
* - verified that ALL buttons WORK
|
|
* - fixed d-pad to axes mapping
|
|
*
|
|
* 2002-07-17 - 0.0.5 : simplified d-pad handling
|
|
*
|
|
* 2004-10-02 - 0.0.6 : DDR pad support
|
|
* - borrowed from the XBOX linux kernel
|
|
* - USB id's for commonly used dance pads are present
|
|
* - dance pads will map D-PAD to buttons, not axes
|
|
* - pass the module paramater 'dpad_to_buttons' to force
|
|
* the D-PAD to map to buttons if your pad is not detected
|
|
*
|
|
* Later changes can be tracked in SCM.
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/input.h>
|
|
#include <linux/rcupdate.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/stat.h>
|
|
#include <linux/module.h>
|
|
#include <linux/usb/input.h>
|
|
#include <linux/usb/quirks.h>
|
|
|
|
#define DRIVER_AUTHOR "Marko Friedemann <mfr@bmx-chemnitz.de>"
|
|
#define DRIVER_DESC "X-Box pad driver"
|
|
|
|
#define XPAD_PKT_LEN 64
|
|
|
|
/* xbox d-pads should map to buttons, as is required for DDR pads
|
|
but we map them to axes when possible to simplify things */
|
|
#define MAP_DPAD_TO_BUTTONS (1 << 0)
|
|
#define MAP_TRIGGERS_TO_BUTTONS (1 << 1)
|
|
#define MAP_STICKS_TO_NULL (1 << 2)
|
|
#define DANCEPAD_MAP_CONFIG (MAP_DPAD_TO_BUTTONS | \
|
|
MAP_TRIGGERS_TO_BUTTONS | MAP_STICKS_TO_NULL)
|
|
|
|
#define XTYPE_XBOX 0
|
|
#define XTYPE_XBOX360 1
|
|
#define XTYPE_XBOX360W 2
|
|
#define XTYPE_XBOXONE 3
|
|
#define XTYPE_UNKNOWN 4
|
|
|
|
static bool dpad_to_buttons;
|
|
module_param(dpad_to_buttons, bool, S_IRUGO);
|
|
MODULE_PARM_DESC(dpad_to_buttons, "Map D-PAD to buttons rather than axes for unknown pads");
|
|
|
|
static bool triggers_to_buttons;
|
|
module_param(triggers_to_buttons, bool, S_IRUGO);
|
|
MODULE_PARM_DESC(triggers_to_buttons, "Map triggers to buttons rather than axes for unknown pads");
|
|
|
|
static bool sticks_to_null;
|
|
module_param(sticks_to_null, bool, S_IRUGO);
|
|
MODULE_PARM_DESC(sticks_to_null, "Do not map sticks at all for unknown pads");
|
|
|
|
static const struct xpad_device {
|
|
u16 idVendor;
|
|
u16 idProduct;
|
|
char *name;
|
|
u8 mapping;
|
|
u8 xtype;
|
|
} xpad_device[] = {
|
|
{ 0x045e, 0x0202, "Microsoft X-Box pad v1 (US)", 0, XTYPE_XBOX },
|
|
{ 0x045e, 0x0285, "Microsoft X-Box pad (Japan)", 0, XTYPE_XBOX },
|
|
{ 0x045e, 0x0287, "Microsoft Xbox Controller S", 0, XTYPE_XBOX },
|
|
{ 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", 0, XTYPE_XBOX },
|
|
{ 0x045e, 0x028e, "Microsoft X-Box 360 pad", 0, XTYPE_XBOX360 },
|
|
{ 0x045e, 0x02d1, "Microsoft X-Box One pad", 0, XTYPE_XBOXONE },
|
|
{ 0x045e, 0x02dd, "Microsoft X-Box One pad (Firmware 2015)", 0, XTYPE_XBOXONE },
|
|
{ 0x045e, 0x02e3, "Microsoft X-Box One Elite pad", 0, XTYPE_XBOXONE },
|
|
{ 0x045e, 0x0291, "Xbox 360 Wireless Receiver (XBOX)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
|
|
{ 0x045e, 0x0719, "Xbox 360 Wireless Receiver", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
|
|
{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },
|
|
{ 0x044f, 0xb326, "Thrustmaster Gamepad GP XID", 0, XTYPE_XBOX360 },
|
|
{ 0x046d, 0xc21d, "Logitech Gamepad F310", 0, XTYPE_XBOX360 },
|
|
{ 0x046d, 0xc21e, "Logitech Gamepad F510", 0, XTYPE_XBOX360 },
|
|
{ 0x046d, 0xc21f, "Logitech Gamepad F710", 0, XTYPE_XBOX360 },
|
|
{ 0x046d, 0xc242, "Logitech Chillstream Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x046d, 0xca84, "Logitech Xbox Cordless Controller", 0, XTYPE_XBOX },
|
|
{ 0x046d, 0xca88, "Logitech Compact Controller for Xbox", 0, XTYPE_XBOX },
|
|
{ 0x05fd, 0x1007, "Mad Catz Controller (unverified)", 0, XTYPE_XBOX },
|
|
{ 0x05fd, 0x107a, "InterAct 'PowerPad Pro' X-Box pad (Germany)", 0, XTYPE_XBOX },
|
|
{ 0x0738, 0x4516, "Mad Catz Control Pad", 0, XTYPE_XBOX },
|
|
{ 0x0738, 0x4522, "Mad Catz LumiCON", 0, XTYPE_XBOX },
|
|
{ 0x0738, 0x4526, "Mad Catz Control Pad Pro", 0, XTYPE_XBOX },
|
|
{ 0x0738, 0x4536, "Mad Catz MicroCON", 0, XTYPE_XBOX },
|
|
{ 0x0738, 0x4540, "Mad Catz Beat Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
|
|
{ 0x0738, 0x4556, "Mad Catz Lynx Wireless Controller", 0, XTYPE_XBOX },
|
|
{ 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x0738, 0x4718, "Mad Catz Street Fighter IV FightStick SE", 0, XTYPE_XBOX360 },
|
|
{ 0x0738, 0x4726, "Mad Catz Xbox 360 Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x0738, 0x4728, "Mad Catz Street Fighter IV FightPad", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
|
|
{ 0x0738, 0x4738, "Mad Catz Wired Xbox 360 Controller (SFIV)", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
|
|
{ 0x0738, 0x4740, "Mad Catz Beat Pad", 0, XTYPE_XBOX360 },
|
|
{ 0x0738, 0x4a01, "Mad Catz FightStick TE 2", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOXONE },
|
|
{ 0x0738, 0x6040, "Mad Catz Beat Pad Pro", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
|
|
{ 0x0738, 0xb726, "Mad Catz Xbox controller - MW2", 0, XTYPE_XBOX360 },
|
|
{ 0x0738, 0xbeef, "Mad Catz JOYTECH NEO SE Advanced GamePad", XTYPE_XBOX360 },
|
|
{ 0x0738, 0xcb02, "Saitek Cyborg Rumble Pad - PC/Xbox 360", 0, XTYPE_XBOX360 },
|
|
{ 0x0738, 0xcb03, "Saitek P3200 Rumble Pad - PC/Xbox 360", 0, XTYPE_XBOX360 },
|
|
{ 0x0738, 0xf738, "Super SFIV FightStick TE S", 0, XTYPE_XBOX360 },
|
|
{ 0x0c12, 0x8802, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
|
|
{ 0x0c12, 0x8809, "RedOctane Xbox Dance Pad", DANCEPAD_MAP_CONFIG, XTYPE_XBOX },
|
|
{ 0x0c12, 0x880a, "Pelican Eclipse PL-2023", 0, XTYPE_XBOX },
|
|
{ 0x0c12, 0x8810, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
|
|
{ 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", 0, XTYPE_XBOX },
|
|
{ 0x0d2f, 0x0002, "Andamiro Pump It Up pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
|
|
{ 0x0e4c, 0x1097, "Radica Gamester Controller", 0, XTYPE_XBOX },
|
|
{ 0x0e4c, 0x2390, "Radica Games Jtech Controller", 0, XTYPE_XBOX },
|
|
{ 0x0e6f, 0x0003, "Logic3 Freebird wireless Controller", 0, XTYPE_XBOX },
|
|
{ 0x0e6f, 0x0005, "Eclipse wireless Controller", 0, XTYPE_XBOX },
|
|
{ 0x0e6f, 0x0006, "Edge wireless Controller", 0, XTYPE_XBOX },
|
|
{ 0x0e6f, 0x0105, "HSM3 Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
|
|
{ 0x0e6f, 0x0113, "Afterglow AX.1 Gamepad for Xbox 360", 0, XTYPE_XBOX360 },
|
|
{ 0x0e6f, 0x0139, "Afterglow Prismatic Wired Controller", 0, XTYPE_XBOXONE },
|
|
{ 0x0e6f, 0x0201, "Pelican PL-3601 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x0e6f, 0x0213, "Afterglow Gamepad for Xbox 360", 0, XTYPE_XBOX360 },
|
|
{ 0x0e6f, 0x021f, "Rock Candy Gamepad for Xbox 360", 0, XTYPE_XBOX360 },
|
|
{ 0x0e6f, 0x0146, "Rock Candy Wired Controller for Xbox One", 0, XTYPE_XBOXONE },
|
|
{ 0x0e6f, 0x0301, "Logic3 Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x0e6f, 0x0401, "Logic3 Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", 0, XTYPE_XBOX },
|
|
{ 0x0e8f, 0x3008, "Generic xbox control (dealextreme)", 0, XTYPE_XBOX },
|
|
{ 0x0f0d, 0x000a, "Hori Co. DOA4 FightStick", 0, XTYPE_XBOX360 },
|
|
{ 0x0f0d, 0x000d, "Hori Fighting Stick EX2", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
|
|
{ 0x0f0d, 0x0016, "Hori Real Arcade Pro.EX", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
|
|
{ 0x0f0d, 0x0067, "HORIPAD ONE", 0, XTYPE_XBOXONE },
|
|
{ 0x0f30, 0x0202, "Joytech Advanced Controller", 0, XTYPE_XBOX },
|
|
{ 0x0f30, 0x8888, "BigBen XBMiniPad Controller", 0, XTYPE_XBOX },
|
|
{ 0x102c, 0xff0c, "Joytech Wireless Advanced Controller", 0, XTYPE_XBOX },
|
|
{ 0x12ab, 0x0004, "Honey Bee Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
|
|
{ 0x12ab, 0x0301, "PDP AFTERGLOW AX.1", 0, XTYPE_XBOX360 },
|
|
{ 0x12ab, 0x8809, "Xbox DDR dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
|
|
{ 0x1430, 0x4748, "RedOctane Guitar Hero X-plorer", 0, XTYPE_XBOX360 },
|
|
{ 0x1430, 0x8888, "TX6500+ Dance Pad (first generation)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
|
|
{ 0x146b, 0x0601, "BigBen Interactive XBOX 360 Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x1532, 0x0037, "Razer Sabertooth", 0, XTYPE_XBOX360 },
|
|
{ 0x15e4, 0x3f00, "Power A Mini Pro Elite", 0, XTYPE_XBOX360 },
|
|
{ 0x15e4, 0x3f0a, "Xbox Airflo wired controller", 0, XTYPE_XBOX360 },
|
|
{ 0x15e4, 0x3f10, "Batarang Xbox 360 controller", 0, XTYPE_XBOX360 },
|
|
{ 0x162e, 0xbeef, "Joytech Neo-Se Take2", 0, XTYPE_XBOX360 },
|
|
{ 0x1689, 0xfd00, "Razer Onza Tournament Edition", 0, XTYPE_XBOX360 },
|
|
{ 0x1689, 0xfd01, "Razer Onza Classic Edition", 0, XTYPE_XBOX360 },
|
|
{ 0x24c6, 0x542a, "Xbox ONE spectra", 0, XTYPE_XBOXONE },
|
|
{ 0x24c6, 0x5d04, "Razer Sabertooth", 0, XTYPE_XBOX360 },
|
|
{ 0x1bad, 0x0002, "Harmonix Rock Band Guitar", 0, XTYPE_XBOX360 },
|
|
{ 0x1bad, 0x0003, "Harmonix Rock Band Drumkit", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
|
|
{ 0x1bad, 0xf016, "Mad Catz Xbox 360 Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x1bad, 0xf023, "MLG Pro Circuit Controller (Xbox)", 0, XTYPE_XBOX360 },
|
|
{ 0x1bad, 0xf028, "Street Fighter IV FightPad", 0, XTYPE_XBOX360 },
|
|
{ 0x1bad, 0xf038, "Street Fighter IV FightStick TE", 0, XTYPE_XBOX360 },
|
|
{ 0x1bad, 0xf900, "Harmonix Xbox 360 Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x1bad, 0xf901, "Gamestop Xbox 360 Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x1bad, 0xf903, "Tron Xbox 360 controller", 0, XTYPE_XBOX360 },
|
|
{ 0x24c6, 0x5000, "Razer Atrox Arcade Stick", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
|
|
{ 0x24c6, 0x5300, "PowerA MINI PROEX Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x24c6, 0x5303, "Xbox Airflo wired controller", 0, XTYPE_XBOX360 },
|
|
{ 0x24c6, 0x541a, "PowerA Xbox One Mini Wired Controller", 0, XTYPE_XBOXONE },
|
|
{ 0x24c6, 0x543a, "PowerA Xbox One wired controller", 0, XTYPE_XBOXONE },
|
|
{ 0x24c6, 0x5500, "Hori XBOX 360 EX 2 with Turbo", 0, XTYPE_XBOX360 },
|
|
{ 0x24c6, 0x5501, "Hori Real Arcade Pro VX-SA", 0, XTYPE_XBOX360 },
|
|
{ 0x24c6, 0x5506, "Hori SOULCALIBUR V Stick", 0, XTYPE_XBOX360 },
|
|
{ 0x24c6, 0x5b02, "Thrustmaster, Inc. GPX Controller", 0, XTYPE_XBOX360 },
|
|
{ 0x24c6, 0x5b03, "Thrustmaster Ferrari 458 Racing Wheel", 0, XTYPE_XBOX360 },
|
|
{ 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX },
|
|
{ 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN }
|
|
};
|
|
|
|
/* buttons shared with xbox and xbox360 */
|
|
static const signed short xpad_common_btn[] = {
|
|
BTN_A, BTN_B, BTN_X, BTN_Y, /* "analog" buttons */
|
|
BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR, /* start/back/sticks */
|
|
-1 /* terminating entry */
|
|
};
|
|
|
|
/* original xbox controllers only */
|
|
static const signed short xpad_btn[] = {
|
|
BTN_C, BTN_Z, /* "analog" buttons */
|
|
-1 /* terminating entry */
|
|
};
|
|
|
|
/* used when dpad is mapped to buttons */
|
|
static const signed short xpad_btn_pad[] = {
|
|
BTN_TRIGGER_HAPPY1, BTN_TRIGGER_HAPPY2, /* d-pad left, right */
|
|
BTN_TRIGGER_HAPPY3, BTN_TRIGGER_HAPPY4, /* d-pad up, down */
|
|
-1 /* terminating entry */
|
|
};
|
|
|
|
/* used when triggers are mapped to buttons */
|
|
static const signed short xpad_btn_triggers[] = {
|
|
BTN_TL2, BTN_TR2, /* triggers left/right */
|
|
-1
|
|
};
|
|
|
|
static const signed short xpad360_btn[] = { /* buttons for x360 controller */
|
|
BTN_TL, BTN_TR, /* Button LB/RB */
|
|
BTN_MODE, /* The big X button */
|
|
-1
|
|
};
|
|
|
|
static const signed short xpad_abs[] = {
|
|
ABS_X, ABS_Y, /* left stick */
|
|
ABS_RX, ABS_RY, /* right stick */
|
|
-1 /* terminating entry */
|
|
};
|
|
|
|
/* used when dpad is mapped to axes */
|
|
static const signed short xpad_abs_pad[] = {
|
|
ABS_HAT0X, ABS_HAT0Y, /* d-pad axes */
|
|
-1 /* terminating entry */
|
|
};
|
|
|
|
/* used when triggers are mapped to axes */
|
|
static const signed short xpad_abs_triggers[] = {
|
|
ABS_Z, ABS_RZ, /* triggers left/right */
|
|
-1
|
|
};
|
|
|
|
/*
|
|
* Xbox 360 has a vendor-specific class, so we cannot match it with only
|
|
* USB_INTERFACE_INFO (also specifically refused by USB subsystem), so we
|
|
* match against vendor id as well. Wired Xbox 360 devices have protocol 1,
|
|
* wireless controllers have protocol 129.
|
|
*/
|
|
#define XPAD_XBOX360_VENDOR_PROTOCOL(vend,pr) \
|
|
.match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO, \
|
|
.idVendor = (vend), \
|
|
.bInterfaceClass = USB_CLASS_VENDOR_SPEC, \
|
|
.bInterfaceSubClass = 93, \
|
|
.bInterfaceProtocol = (pr)
|
|
#define XPAD_XBOX360_VENDOR(vend) \
|
|
{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,1) }, \
|
|
{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,129) }
|
|
|
|
/* The Xbox One controller uses subclass 71 and protocol 208. */
|
|
#define XPAD_XBOXONE_VENDOR_PROTOCOL(vend, pr) \
|
|
.match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO, \
|
|
.idVendor = (vend), \
|
|
.bInterfaceClass = USB_CLASS_VENDOR_SPEC, \
|
|
.bInterfaceSubClass = 71, \
|
|
.bInterfaceProtocol = (pr)
|
|
#define XPAD_XBOXONE_VENDOR(vend) \
|
|
{ XPAD_XBOXONE_VENDOR_PROTOCOL(vend, 208) }
|
|
|
|
static struct usb_device_id xpad_table[] = {
|
|
{ USB_INTERFACE_INFO('X', 'B', 0) }, /* X-Box USB-IF not approved class */
|
|
XPAD_XBOX360_VENDOR(0x044f), /* Thrustmaster X-Box 360 controllers */
|
|
XPAD_XBOX360_VENDOR(0x045e), /* Microsoft X-Box 360 controllers */
|
|
XPAD_XBOXONE_VENDOR(0x045e), /* Microsoft X-Box One controllers */
|
|
XPAD_XBOX360_VENDOR(0x046d), /* Logitech X-Box 360 style controllers */
|
|
XPAD_XBOX360_VENDOR(0x0738), /* Mad Catz X-Box 360 controllers */
|
|
{ USB_DEVICE(0x0738, 0x4540) }, /* Mad Catz Beat Pad */
|
|
XPAD_XBOXONE_VENDOR(0x0738), /* Mad Catz FightStick TE 2 */
|
|
XPAD_XBOX360_VENDOR(0x0e6f), /* 0x0e6f X-Box 360 controllers */
|
|
XPAD_XBOXONE_VENDOR(0x0e6f), /* 0x0e6f X-Box One controllers */
|
|
XPAD_XBOX360_VENDOR(0x12ab), /* X-Box 360 dance pads */
|
|
XPAD_XBOX360_VENDOR(0x1430), /* RedOctane X-Box 360 controllers */
|
|
XPAD_XBOX360_VENDOR(0x146b), /* BigBen Interactive Controllers */
|
|
XPAD_XBOX360_VENDOR(0x1bad), /* Harminix Rock Band Guitar and Drums */
|
|
XPAD_XBOX360_VENDOR(0x0f0d), /* Hori Controllers */
|
|
XPAD_XBOXONE_VENDOR(0x0f0d), /* Hori Controllers */
|
|
XPAD_XBOX360_VENDOR(0x1689), /* Razer Onza */
|
|
XPAD_XBOX360_VENDOR(0x24c6), /* PowerA Controllers */
|
|
XPAD_XBOXONE_VENDOR(0x24c6), /* PowerA Controllers */
|
|
XPAD_XBOX360_VENDOR(0x1532), /* Razer Sabertooth */
|
|
XPAD_XBOX360_VENDOR(0x15e4), /* Numark X-Box 360 controllers */
|
|
XPAD_XBOX360_VENDOR(0x162e), /* Joytech X-Box 360 controllers */
|
|
{ }
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(usb, xpad_table);
|
|
|
|
struct xpad_output_packet {
|
|
u8 data[XPAD_PKT_LEN];
|
|
u8 len;
|
|
bool pending;
|
|
};
|
|
|
|
#define XPAD_OUT_CMD_IDX 0
|
|
#define XPAD_OUT_FF_IDX 1
|
|
#define XPAD_OUT_LED_IDX (1 + IS_ENABLED(CONFIG_JOYSTICK_XPAD_FF))
|
|
#define XPAD_NUM_OUT_PACKETS (1 + \
|
|
IS_ENABLED(CONFIG_JOYSTICK_XPAD_FF) + \
|
|
IS_ENABLED(CONFIG_JOYSTICK_XPAD_LEDS))
|
|
|
|
struct usb_xpad {
|
|
struct input_dev *dev; /* input device interface */
|
|
struct input_dev __rcu *x360w_dev;
|
|
struct usb_device *udev; /* usb device */
|
|
struct usb_interface *intf; /* usb interface */
|
|
|
|
bool pad_present;
|
|
bool input_created;
|
|
|
|
struct urb *irq_in; /* urb for interrupt in report */
|
|
unsigned char *idata; /* input data */
|
|
dma_addr_t idata_dma;
|
|
|
|
struct urb *irq_out; /* urb for interrupt out report */
|
|
struct usb_anchor irq_out_anchor;
|
|
bool irq_out_active; /* we must not use an active URB */
|
|
u8 odata_serial; /* serial number for xbox one protocol */
|
|
unsigned char *odata; /* output data */
|
|
dma_addr_t odata_dma;
|
|
spinlock_t odata_lock;
|
|
|
|
struct xpad_output_packet out_packets[XPAD_NUM_OUT_PACKETS];
|
|
int last_out_packet;
|
|
|
|
#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
|
|
struct xpad_led *led;
|
|
#endif
|
|
|
|
char phys[64]; /* physical device path */
|
|
|
|
int mapping; /* map d-pad to buttons or to axes */
|
|
int xtype; /* type of xbox device */
|
|
int pad_nr; /* the order x360 pads were attached */
|
|
const char *name; /* name of the device */
|
|
struct work_struct work; /* init/remove device from callback */
|
|
};
|
|
|
|
static int xpad_init_input(struct usb_xpad *xpad);
|
|
static void xpad_deinit_input(struct usb_xpad *xpad);
|
|
|
|
/*
|
|
* xpad_process_packet
|
|
*
|
|
* Completes a request by converting the data into events for the
|
|
* input subsystem.
|
|
*
|
|
* The used report descriptor was taken from ITO Takayukis website:
|
|
* http://euc.jp/periphs/xbox-controller.ja.html
|
|
*/
|
|
static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
|
|
{
|
|
struct input_dev *dev = xpad->dev;
|
|
|
|
if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
|
|
/* left stick */
|
|
input_report_abs(dev, ABS_X,
|
|
(__s16) le16_to_cpup((__le16 *)(data + 12)));
|
|
input_report_abs(dev, ABS_Y,
|
|
~(__s16) le16_to_cpup((__le16 *)(data + 14)));
|
|
|
|
/* right stick */
|
|
input_report_abs(dev, ABS_RX,
|
|
(__s16) le16_to_cpup((__le16 *)(data + 16)));
|
|
input_report_abs(dev, ABS_RY,
|
|
~(__s16) le16_to_cpup((__le16 *)(data + 18)));
|
|
}
|
|
|
|
/* triggers left/right */
|
|
if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
|
|
input_report_key(dev, BTN_TL2, data[10]);
|
|
input_report_key(dev, BTN_TR2, data[11]);
|
|
} else {
|
|
input_report_abs(dev, ABS_Z, data[10]);
|
|
input_report_abs(dev, ABS_RZ, data[11]);
|
|
}
|
|
|
|
/* digital pad */
|
|
if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
|
|
/* dpad as buttons (left, right, up, down) */
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
|
|
} else {
|
|
input_report_abs(dev, ABS_HAT0X,
|
|
!!(data[2] & 0x08) - !!(data[2] & 0x04));
|
|
input_report_abs(dev, ABS_HAT0Y,
|
|
!!(data[2] & 0x02) - !!(data[2] & 0x01));
|
|
}
|
|
|
|
/* start/back buttons and stick press left/right */
|
|
input_report_key(dev, BTN_START, data[2] & 0x10);
|
|
input_report_key(dev, BTN_SELECT, data[2] & 0x20);
|
|
input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
|
|
input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
|
|
|
|
/* "analog" buttons A, B, X, Y */
|
|
input_report_key(dev, BTN_A, data[4]);
|
|
input_report_key(dev, BTN_B, data[5]);
|
|
input_report_key(dev, BTN_X, data[6]);
|
|
input_report_key(dev, BTN_Y, data[7]);
|
|
|
|
/* "analog" buttons black, white */
|
|
input_report_key(dev, BTN_C, data[8]);
|
|
input_report_key(dev, BTN_Z, data[9]);
|
|
|
|
input_sync(dev);
|
|
}
|
|
|
|
/*
|
|
* xpad360_process_packet
|
|
*
|
|
* Completes a request by converting the data into events for the
|
|
* input subsystem. It is version for xbox 360 controller
|
|
*
|
|
* The used report descriptor was taken from:
|
|
* http://www.free60.org/wiki/Gamepad
|
|
*/
|
|
|
|
static void xpad360_process_packet(struct usb_xpad *xpad, struct input_dev *dev,
|
|
u16 cmd, unsigned char *data)
|
|
{
|
|
/* valid pad data */
|
|
if (data[0] != 0x00)
|
|
return;
|
|
|
|
/* digital pad */
|
|
if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
|
|
/* dpad as buttons (left, right, up, down) */
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
|
|
}
|
|
|
|
/*
|
|
* This should be a simple else block. However historically
|
|
* xbox360w has mapped DPAD to buttons while xbox360 did not. This
|
|
* made no sense, but now we can not just switch back and have to
|
|
* support both behaviors.
|
|
*/
|
|
if (!(xpad->mapping & MAP_DPAD_TO_BUTTONS) ||
|
|
xpad->xtype == XTYPE_XBOX360W) {
|
|
input_report_abs(dev, ABS_HAT0X,
|
|
!!(data[2] & 0x08) - !!(data[2] & 0x04));
|
|
input_report_abs(dev, ABS_HAT0Y,
|
|
!!(data[2] & 0x02) - !!(data[2] & 0x01));
|
|
}
|
|
|
|
/* start/back buttons */
|
|
input_report_key(dev, BTN_START, data[2] & 0x10);
|
|
input_report_key(dev, BTN_SELECT, data[2] & 0x20);
|
|
|
|
/* stick press left/right */
|
|
input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
|
|
input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
|
|
|
|
/* buttons A,B,X,Y,TL,TR and MODE */
|
|
input_report_key(dev, BTN_A, data[3] & 0x10);
|
|
input_report_key(dev, BTN_B, data[3] & 0x20);
|
|
input_report_key(dev, BTN_X, data[3] & 0x40);
|
|
input_report_key(dev, BTN_Y, data[3] & 0x80);
|
|
input_report_key(dev, BTN_TL, data[3] & 0x01);
|
|
input_report_key(dev, BTN_TR, data[3] & 0x02);
|
|
input_report_key(dev, BTN_MODE, data[3] & 0x04);
|
|
|
|
if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
|
|
/* left stick */
|
|
input_report_abs(dev, ABS_X,
|
|
(__s16) le16_to_cpup((__le16 *)(data + 6)));
|
|
input_report_abs(dev, ABS_Y,
|
|
~(__s16) le16_to_cpup((__le16 *)(data + 8)));
|
|
|
|
/* right stick */
|
|
input_report_abs(dev, ABS_RX,
|
|
(__s16) le16_to_cpup((__le16 *)(data + 10)));
|
|
input_report_abs(dev, ABS_RY,
|
|
~(__s16) le16_to_cpup((__le16 *)(data + 12)));
|
|
}
|
|
|
|
/* triggers left/right */
|
|
if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
|
|
input_report_key(dev, BTN_TL2, data[4]);
|
|
input_report_key(dev, BTN_TR2, data[5]);
|
|
} else {
|
|
input_report_abs(dev, ABS_Z, data[4]);
|
|
input_report_abs(dev, ABS_RZ, data[5]);
|
|
}
|
|
|
|
input_sync(dev);
|
|
}
|
|
|
|
static void xpad_presence_work(struct work_struct *work)
|
|
{
|
|
struct usb_xpad *xpad = container_of(work, struct usb_xpad, work);
|
|
int error;
|
|
|
|
if (xpad->pad_present) {
|
|
error = xpad_init_input(xpad);
|
|
if (error) {
|
|
/* complain only, not much else we can do here */
|
|
dev_err(&xpad->dev->dev,
|
|
"unable to init device: %d\n", error);
|
|
} else {
|
|
rcu_assign_pointer(xpad->x360w_dev, xpad->dev);
|
|
}
|
|
} else {
|
|
RCU_INIT_POINTER(xpad->x360w_dev, NULL);
|
|
synchronize_rcu();
|
|
/*
|
|
* Now that we are sure xpad360w_process_packet is not
|
|
* using input device we can get rid of it.
|
|
*/
|
|
xpad_deinit_input(xpad);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* xpad360w_process_packet
|
|
*
|
|
* Completes a request by converting the data into events for the
|
|
* input subsystem. It is version for xbox 360 wireless controller.
|
|
*
|
|
* Byte.Bit
|
|
* 00.1 - Status change: The controller or headset has connected/disconnected
|
|
* Bits 01.7 and 01.6 are valid
|
|
* 01.7 - Controller present
|
|
* 01.6 - Headset present
|
|
* 01.1 - Pad state (Bytes 4+) valid
|
|
*
|
|
*/
|
|
static void xpad360w_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
|
|
{
|
|
struct input_dev *dev;
|
|
bool present;
|
|
|
|
/* Presence change */
|
|
if (data[0] & 0x08) {
|
|
present = (data[1] & 0x80) != 0;
|
|
|
|
if (xpad->pad_present != present) {
|
|
xpad->pad_present = present;
|
|
schedule_work(&xpad->work);
|
|
}
|
|
}
|
|
|
|
/* Valid pad data */
|
|
if (data[1] != 0x1)
|
|
return;
|
|
|
|
rcu_read_lock();
|
|
dev = rcu_dereference(xpad->x360w_dev);
|
|
if (dev)
|
|
xpad360_process_packet(xpad, dev, cmd, &data[4]);
|
|
rcu_read_unlock();
|
|
}
|
|
|
|
/*
|
|
* xpadone_process_buttons
|
|
*
|
|
* Process a button update packet from an Xbox one controller.
|
|
*/
|
|
static void xpadone_process_buttons(struct usb_xpad *xpad,
|
|
struct input_dev *dev,
|
|
unsigned char *data)
|
|
{
|
|
/* menu/view buttons */
|
|
input_report_key(dev, BTN_START, data[4] & 0x04);
|
|
input_report_key(dev, BTN_SELECT, data[4] & 0x08);
|
|
|
|
/* buttons A,B,X,Y */
|
|
input_report_key(dev, BTN_A, data[4] & 0x10);
|
|
input_report_key(dev, BTN_B, data[4] & 0x20);
|
|
input_report_key(dev, BTN_X, data[4] & 0x40);
|
|
input_report_key(dev, BTN_Y, data[4] & 0x80);
|
|
|
|
/* digital pad */
|
|
if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
|
|
/* dpad as buttons (left, right, up, down) */
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY1, data[5] & 0x04);
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY2, data[5] & 0x08);
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY3, data[5] & 0x01);
|
|
input_report_key(dev, BTN_TRIGGER_HAPPY4, data[5] & 0x02);
|
|
} else {
|
|
input_report_abs(dev, ABS_HAT0X,
|
|
!!(data[5] & 0x08) - !!(data[5] & 0x04));
|
|
input_report_abs(dev, ABS_HAT0Y,
|
|
!!(data[5] & 0x02) - !!(data[5] & 0x01));
|
|
}
|
|
|
|
/* TL/TR */
|
|
input_report_key(dev, BTN_TL, data[5] & 0x10);
|
|
input_report_key(dev, BTN_TR, data[5] & 0x20);
|
|
|
|
/* stick press left/right */
|
|
input_report_key(dev, BTN_THUMBL, data[5] & 0x40);
|
|
input_report_key(dev, BTN_THUMBR, data[5] & 0x80);
|
|
|
|
if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
|
|
/* left stick */
|
|
input_report_abs(dev, ABS_X,
|
|
(__s16) le16_to_cpup((__le16 *)(data + 10)));
|
|
input_report_abs(dev, ABS_Y,
|
|
~(__s16) le16_to_cpup((__le16 *)(data + 12)));
|
|
|
|
/* right stick */
|
|
input_report_abs(dev, ABS_RX,
|
|
(__s16) le16_to_cpup((__le16 *)(data + 14)));
|
|
input_report_abs(dev, ABS_RY,
|
|
~(__s16) le16_to_cpup((__le16 *)(data + 16)));
|
|
}
|
|
|
|
/* triggers left/right */
|
|
if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
|
|
input_report_key(dev, BTN_TL2,
|
|
(__u16) le16_to_cpup((__le16 *)(data + 6)));
|
|
input_report_key(dev, BTN_TR2,
|
|
(__u16) le16_to_cpup((__le16 *)(data + 8)));
|
|
} else {
|
|
input_report_abs(dev, ABS_Z,
|
|
(__u16) le16_to_cpup((__le16 *)(data + 6)));
|
|
input_report_abs(dev, ABS_RZ,
|
|
(__u16) le16_to_cpup((__le16 *)(data + 8)));
|
|
}
|
|
|
|
input_sync(dev);
|
|
}
|
|
|
|
/*
|
|
* xpadone_process_packet
|
|
*
|
|
* Completes a request by converting the data into events for the
|
|
* input subsystem. This version is for the Xbox One controller.
|
|
*
|
|
* The report format was gleaned from
|
|
* https://github.com/kylelemons/xbox/blob/master/xbox.go
|
|
*/
|
|
|
|
static void xpadone_process_packet(struct usb_xpad *xpad,
|
|
u16 cmd, unsigned char *data)
|
|
{
|
|
struct input_dev *dev = xpad->dev;
|
|
|
|
switch (data[0]) {
|
|
case 0x20:
|
|
xpadone_process_buttons(xpad, dev, data);
|
|
break;
|
|
|
|
case 0x07:
|
|
/* the xbox button has its own special report */
|
|
input_report_key(dev, BTN_MODE, data[4] & 0x01);
|
|
input_sync(dev);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void xpad_irq_in(struct urb *urb)
|
|
{
|
|
struct usb_xpad *xpad = urb->context;
|
|
struct device *dev = &xpad->intf->dev;
|
|
int retval, status;
|
|
|
|
status = urb->status;
|
|
|
|
switch (status) {
|
|
case 0:
|
|
/* success */
|
|
break;
|
|
case -ECONNRESET:
|
|
case -ENOENT:
|
|
case -ESHUTDOWN:
|
|
/* this urb is terminated, clean up */
|
|
dev_dbg(dev, "%s - urb shutting down with status: %d\n",
|
|
__func__, status);
|
|
return;
|
|
default:
|
|
dev_dbg(dev, "%s - nonzero urb status received: %d\n",
|
|
__func__, status);
|
|
goto exit;
|
|
}
|
|
|
|
switch (xpad->xtype) {
|
|
case XTYPE_XBOX360:
|
|
xpad360_process_packet(xpad, xpad->dev, 0, xpad->idata);
|
|
break;
|
|
case XTYPE_XBOX360W:
|
|
xpad360w_process_packet(xpad, 0, xpad->idata);
|
|
break;
|
|
case XTYPE_XBOXONE:
|
|
xpadone_process_packet(xpad, 0, xpad->idata);
|
|
break;
|
|
default:
|
|
xpad_process_packet(xpad, 0, xpad->idata);
|
|
}
|
|
|
|
exit:
|
|
retval = usb_submit_urb(urb, GFP_ATOMIC);
|
|
if (retval)
|
|
dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
|
|
__func__, retval);
|
|
}
|
|
|
|
/* Callers must hold xpad->odata_lock spinlock */
|
|
static bool xpad_prepare_next_out_packet(struct usb_xpad *xpad)
|
|
{
|
|
struct xpad_output_packet *pkt, *packet = NULL;
|
|
int i;
|
|
|
|
for (i = 0; i < XPAD_NUM_OUT_PACKETS; i++) {
|
|
if (++xpad->last_out_packet >= XPAD_NUM_OUT_PACKETS)
|
|
xpad->last_out_packet = 0;
|
|
|
|
pkt = &xpad->out_packets[xpad->last_out_packet];
|
|
if (pkt->pending) {
|
|
dev_dbg(&xpad->intf->dev,
|
|
"%s - found pending output packet %d\n",
|
|
__func__, xpad->last_out_packet);
|
|
packet = pkt;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (packet) {
|
|
memcpy(xpad->odata, packet->data, packet->len);
|
|
xpad->irq_out->transfer_buffer_length = packet->len;
|
|
packet->pending = false;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/* Callers must hold xpad->odata_lock spinlock */
|
|
static int xpad_try_sending_next_out_packet(struct usb_xpad *xpad)
|
|
{
|
|
int error;
|
|
|
|
if (!xpad->irq_out_active && xpad_prepare_next_out_packet(xpad)) {
|
|
usb_anchor_urb(xpad->irq_out, &xpad->irq_out_anchor);
|
|
error = usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
|
|
if (error) {
|
|
dev_err(&xpad->intf->dev,
|
|
"%s - usb_submit_urb failed with result %d\n",
|
|
__func__, error);
|
|
usb_unanchor_urb(xpad->irq_out);
|
|
return -EIO;
|
|
}
|
|
|
|
xpad->irq_out_active = true;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void xpad_irq_out(struct urb *urb)
|
|
{
|
|
struct usb_xpad *xpad = urb->context;
|
|
struct device *dev = &xpad->intf->dev;
|
|
int status = urb->status;
|
|
int error;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&xpad->odata_lock, flags);
|
|
|
|
switch (status) {
|
|
case 0:
|
|
/* success */
|
|
xpad->irq_out_active = xpad_prepare_next_out_packet(xpad);
|
|
break;
|
|
|
|
case -ECONNRESET:
|
|
case -ENOENT:
|
|
case -ESHUTDOWN:
|
|
/* this urb is terminated, clean up */
|
|
dev_dbg(dev, "%s - urb shutting down with status: %d\n",
|
|
__func__, status);
|
|
xpad->irq_out_active = false;
|
|
break;
|
|
|
|
default:
|
|
dev_dbg(dev, "%s - nonzero urb status received: %d\n",
|
|
__func__, status);
|
|
break;
|
|
}
|
|
|
|
if (xpad->irq_out_active) {
|
|
usb_anchor_urb(urb, &xpad->irq_out_anchor);
|
|
error = usb_submit_urb(urb, GFP_ATOMIC);
|
|
if (error) {
|
|
dev_err(dev,
|
|
"%s - usb_submit_urb failed with result %d\n",
|
|
__func__, error);
|
|
usb_unanchor_urb(urb);
|
|
xpad->irq_out_active = false;
|
|
}
|
|
}
|
|
|
|
spin_unlock_irqrestore(&xpad->odata_lock, flags);
|
|
}
|
|
|
|
static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
|
|
{
|
|
struct usb_endpoint_descriptor *ep_irq_out;
|
|
int ep_irq_out_idx;
|
|
int error;
|
|
|
|
if (xpad->xtype == XTYPE_UNKNOWN)
|
|
return 0;
|
|
|
|
init_usb_anchor(&xpad->irq_out_anchor);
|
|
|
|
xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,
|
|
GFP_KERNEL, &xpad->odata_dma);
|
|
if (!xpad->odata) {
|
|
error = -ENOMEM;
|
|
goto fail1;
|
|
}
|
|
|
|
spin_lock_init(&xpad->odata_lock);
|
|
|
|
xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
|
|
if (!xpad->irq_out) {
|
|
error = -ENOMEM;
|
|
goto fail2;
|
|
}
|
|
|
|
/* Xbox One controller has in/out endpoints swapped. */
|
|
ep_irq_out_idx = xpad->xtype == XTYPE_XBOXONE ? 0 : 1;
|
|
ep_irq_out = &intf->cur_altsetting->endpoint[ep_irq_out_idx].desc;
|
|
|
|
usb_fill_int_urb(xpad->irq_out, xpad->udev,
|
|
usb_sndintpipe(xpad->udev, ep_irq_out->bEndpointAddress),
|
|
xpad->odata, XPAD_PKT_LEN,
|
|
xpad_irq_out, xpad, ep_irq_out->bInterval);
|
|
xpad->irq_out->transfer_dma = xpad->odata_dma;
|
|
xpad->irq_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
|
|
|
|
return 0;
|
|
|
|
fail2: usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
|
|
fail1: return error;
|
|
}
|
|
|
|
static void xpad_stop_output(struct usb_xpad *xpad)
|
|
{
|
|
if (xpad->xtype != XTYPE_UNKNOWN) {
|
|
if (!usb_wait_anchor_empty_timeout(&xpad->irq_out_anchor,
|
|
5000)) {
|
|
dev_warn(&xpad->intf->dev,
|
|
"timed out waiting for output URB to complete, killing\n");
|
|
usb_kill_anchored_urbs(&xpad->irq_out_anchor);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void xpad_deinit_output(struct usb_xpad *xpad)
|
|
{
|
|
if (xpad->xtype != XTYPE_UNKNOWN) {
|
|
usb_free_urb(xpad->irq_out);
|
|
usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
|
|
xpad->odata, xpad->odata_dma);
|
|
}
|
|
}
|
|
|
|
static int xpad_inquiry_pad_presence(struct usb_xpad *xpad)
|
|
{
|
|
struct xpad_output_packet *packet =
|
|
&xpad->out_packets[XPAD_OUT_CMD_IDX];
|
|
unsigned long flags;
|
|
int retval;
|
|
|
|
spin_lock_irqsave(&xpad->odata_lock, flags);
|
|
|
|
packet->data[0] = 0x08;
|
|
packet->data[1] = 0x00;
|
|
packet->data[2] = 0x0F;
|
|
packet->data[3] = 0xC0;
|
|
packet->data[4] = 0x00;
|
|
packet->data[5] = 0x00;
|
|
packet->data[6] = 0x00;
|
|
packet->data[7] = 0x00;
|
|
packet->data[8] = 0x00;
|
|
packet->data[9] = 0x00;
|
|
packet->data[10] = 0x00;
|
|
packet->data[11] = 0x00;
|
|
packet->len = 12;
|
|
packet->pending = true;
|
|
|
|
/* Reset the sequence so we send out presence first */
|
|
xpad->last_out_packet = -1;
|
|
retval = xpad_try_sending_next_out_packet(xpad);
|
|
|
|
spin_unlock_irqrestore(&xpad->odata_lock, flags);
|
|
|
|
return retval;
|
|
}
|
|
|
|
static int xpad_start_xbox_one(struct usb_xpad *xpad)
|
|
{
|
|
struct xpad_output_packet *packet =
|
|
&xpad->out_packets[XPAD_OUT_CMD_IDX];
|
|
unsigned long flags;
|
|
int retval;
|
|
|
|
spin_lock_irqsave(&xpad->odata_lock, flags);
|
|
|
|
/* Xbox one controller needs to be initialized. */
|
|
packet->data[0] = 0x05;
|
|
packet->data[1] = 0x20;
|
|
packet->data[2] = xpad->odata_serial++; /* packet serial */
|
|
packet->data[3] = 0x01; /* rumble bit enable? */
|
|
packet->data[4] = 0x00;
|
|
packet->len = 5;
|
|
packet->pending = true;
|
|
|
|
/* Reset the sequence so we send out start packet first */
|
|
xpad->last_out_packet = -1;
|
|
retval = xpad_try_sending_next_out_packet(xpad);
|
|
|
|
spin_unlock_irqrestore(&xpad->odata_lock, flags);
|
|
|
|
return retval;
|
|
}
|
|
|
|
#ifdef CONFIG_JOYSTICK_XPAD_FF
|
|
static int xpad_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
|
|
{
|
|
struct usb_xpad *xpad = input_get_drvdata(dev);
|
|
struct xpad_output_packet *packet = &xpad->out_packets[XPAD_OUT_FF_IDX];
|
|
__u16 strong;
|
|
__u16 weak;
|
|
int retval;
|
|
unsigned long flags;
|
|
|
|
if (effect->type != FF_RUMBLE)
|
|
return 0;
|
|
|
|
strong = effect->u.rumble.strong_magnitude;
|
|
weak = effect->u.rumble.weak_magnitude;
|
|
|
|
spin_lock_irqsave(&xpad->odata_lock, flags);
|
|
|
|
switch (xpad->xtype) {
|
|
case XTYPE_XBOX:
|
|
packet->data[0] = 0x00;
|
|
packet->data[1] = 0x06;
|
|
packet->data[2] = 0x00;
|
|
packet->data[3] = strong / 256; /* left actuator */
|
|
packet->data[4] = 0x00;
|
|
packet->data[5] = weak / 256; /* right actuator */
|
|
packet->len = 6;
|
|
packet->pending = true;
|
|
break;
|
|
|
|
case XTYPE_XBOX360:
|
|
packet->data[0] = 0x00;
|
|
packet->data[1] = 0x08;
|
|
packet->data[2] = 0x00;
|
|
packet->data[3] = strong / 256; /* left actuator? */
|
|
packet->data[4] = weak / 256; /* right actuator? */
|
|
packet->data[5] = 0x00;
|
|
packet->data[6] = 0x00;
|
|
packet->data[7] = 0x00;
|
|
packet->len = 8;
|
|
packet->pending = true;
|
|
break;
|
|
|
|
case XTYPE_XBOX360W:
|
|
packet->data[0] = 0x00;
|
|
packet->data[1] = 0x01;
|
|
packet->data[2] = 0x0F;
|
|
packet->data[3] = 0xC0;
|
|
packet->data[4] = 0x00;
|
|
packet->data[5] = strong / 256;
|
|
packet->data[6] = weak / 256;
|
|
packet->data[7] = 0x00;
|
|
packet->data[8] = 0x00;
|
|
packet->data[9] = 0x00;
|
|
packet->data[10] = 0x00;
|
|
packet->data[11] = 0x00;
|
|
packet->len = 12;
|
|
packet->pending = true;
|
|
break;
|
|
|
|
case XTYPE_XBOXONE:
|
|
packet->data[0] = 0x09; /* activate rumble */
|
|
packet->data[1] = 0x00;
|
|
packet->data[2] = xpad->odata_serial++;
|
|
packet->data[3] = 0x09;
|
|
packet->data[4] = 0x00;
|
|
packet->data[5] = 0x0F;
|
|
packet->data[6] = 0x00;
|
|
packet->data[7] = 0x00;
|
|
packet->data[8] = strong / 512; /* left actuator */
|
|
packet->data[9] = weak / 512; /* right actuator */
|
|
packet->data[10] = 0xFF;
|
|
packet->data[11] = 0x00;
|
|
packet->data[12] = 0x00;
|
|
packet->len = 13;
|
|
packet->pending = true;
|
|
break;
|
|
|
|
default:
|
|
dev_dbg(&xpad->dev->dev,
|
|
"%s - rumble command sent to unsupported xpad type: %d\n",
|
|
__func__, xpad->xtype);
|
|
retval = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
retval = xpad_try_sending_next_out_packet(xpad);
|
|
|
|
out:
|
|
spin_unlock_irqrestore(&xpad->odata_lock, flags);
|
|
return retval;
|
|
}
|
|
|
|
static int xpad_init_ff(struct usb_xpad *xpad)
|
|
{
|
|
if (xpad->xtype == XTYPE_UNKNOWN)
|
|
return 0;
|
|
|
|
input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);
|
|
|
|
return input_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
|
|
}
|
|
|
|
#else
|
|
static int xpad_init_ff(struct usb_xpad *xpad) { return 0; }
|
|
#endif
|
|
|
|
#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
|
|
#include <linux/leds.h>
|
|
#include <linux/idr.h>
|
|
|
|
static DEFINE_IDA(xpad_pad_seq);
|
|
|
|
struct xpad_led {
|
|
char name[16];
|
|
struct led_classdev led_cdev;
|
|
struct usb_xpad *xpad;
|
|
};
|
|
|
|
/**
|
|
* set the LEDs on Xbox360 / Wireless Controllers
|
|
* @param command
|
|
* 0: off
|
|
* 1: all blink, then previous setting
|
|
* 2: 1/top-left blink, then on
|
|
* 3: 2/top-right blink, then on
|
|
* 4: 3/bottom-left blink, then on
|
|
* 5: 4/bottom-right blink, then on
|
|
* 6: 1/top-left on
|
|
* 7: 2/top-right on
|
|
* 8: 3/bottom-left on
|
|
* 9: 4/bottom-right on
|
|
* 10: rotate
|
|
* 11: blink, based on previous setting
|
|
* 12: slow blink, based on previous setting
|
|
* 13: rotate with two lights
|
|
* 14: persistent slow all blink
|
|
* 15: blink once, then previous setting
|
|
*/
|
|
static void xpad_send_led_command(struct usb_xpad *xpad, int command)
|
|
{
|
|
struct xpad_output_packet *packet =
|
|
&xpad->out_packets[XPAD_OUT_LED_IDX];
|
|
unsigned long flags;
|
|
|
|
command %= 16;
|
|
|
|
spin_lock_irqsave(&xpad->odata_lock, flags);
|
|
|
|
switch (xpad->xtype) {
|
|
case XTYPE_XBOX360:
|
|
packet->data[0] = 0x01;
|
|
packet->data[1] = 0x03;
|
|
packet->data[2] = command;
|
|
packet->len = 3;
|
|
packet->pending = true;
|
|
break;
|
|
|
|
case XTYPE_XBOX360W:
|
|
packet->data[0] = 0x00;
|
|
packet->data[1] = 0x00;
|
|
packet->data[2] = 0x08;
|
|
packet->data[3] = 0x40 + command;
|
|
packet->data[4] = 0x00;
|
|
packet->data[5] = 0x00;
|
|
packet->data[6] = 0x00;
|
|
packet->data[7] = 0x00;
|
|
packet->data[8] = 0x00;
|
|
packet->data[9] = 0x00;
|
|
packet->data[10] = 0x00;
|
|
packet->data[11] = 0x00;
|
|
packet->len = 12;
|
|
packet->pending = true;
|
|
break;
|
|
}
|
|
|
|
xpad_try_sending_next_out_packet(xpad);
|
|
|
|
spin_unlock_irqrestore(&xpad->odata_lock, flags);
|
|
}
|
|
|
|
/*
|
|
* Light up the segment corresponding to the pad number on
|
|
* Xbox 360 Controllers.
|
|
*/
|
|
static void xpad_identify_controller(struct usb_xpad *xpad)
|
|
{
|
|
led_set_brightness(&xpad->led->led_cdev, (xpad->pad_nr % 4) + 2);
|
|
}
|
|
|
|
static void xpad_led_set(struct led_classdev *led_cdev,
|
|
enum led_brightness value)
|
|
{
|
|
struct xpad_led *xpad_led = container_of(led_cdev,
|
|
struct xpad_led, led_cdev);
|
|
|
|
xpad_send_led_command(xpad_led->xpad, value);
|
|
}
|
|
|
|
static int xpad_led_probe(struct usb_xpad *xpad)
|
|
{
|
|
struct xpad_led *led;
|
|
struct led_classdev *led_cdev;
|
|
int error;
|
|
|
|
if (xpad->xtype != XTYPE_XBOX360 && xpad->xtype != XTYPE_XBOX360W)
|
|
return 0;
|
|
|
|
xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
|
|
if (!led)
|
|
return -ENOMEM;
|
|
|
|
xpad->pad_nr = ida_simple_get(&xpad_pad_seq, 0, 0, GFP_KERNEL);
|
|
if (xpad->pad_nr < 0) {
|
|
error = xpad->pad_nr;
|
|
goto err_free_mem;
|
|
}
|
|
|
|
snprintf(led->name, sizeof(led->name), "xpad%d", xpad->pad_nr);
|
|
led->xpad = xpad;
|
|
|
|
led_cdev = &led->led_cdev;
|
|
led_cdev->name = led->name;
|
|
led_cdev->brightness_set = xpad_led_set;
|
|
|
|
error = led_classdev_register(&xpad->udev->dev, led_cdev);
|
|
if (error)
|
|
goto err_free_id;
|
|
|
|
xpad_identify_controller(xpad);
|
|
|
|
return 0;
|
|
|
|
err_free_id:
|
|
ida_simple_remove(&xpad_pad_seq, xpad->pad_nr);
|
|
err_free_mem:
|
|
kfree(led);
|
|
xpad->led = NULL;
|
|
return error;
|
|
}
|
|
|
|
static void xpad_led_disconnect(struct usb_xpad *xpad)
|
|
{
|
|
struct xpad_led *xpad_led = xpad->led;
|
|
|
|
if (xpad_led) {
|
|
led_classdev_unregister(&xpad_led->led_cdev);
|
|
ida_simple_remove(&xpad_pad_seq, xpad->pad_nr);
|
|
kfree(xpad_led);
|
|
}
|
|
}
|
|
#else
|
|
static int xpad_led_probe(struct usb_xpad *xpad) { return 0; }
|
|
static void xpad_led_disconnect(struct usb_xpad *xpad) { }
|
|
#endif
|
|
|
|
static int xpad_start_input(struct usb_xpad *xpad)
|
|
{
|
|
int error;
|
|
|
|
if (usb_submit_urb(xpad->irq_in, GFP_KERNEL))
|
|
return -EIO;
|
|
|
|
if (xpad->xtype == XTYPE_XBOXONE) {
|
|
error = xpad_start_xbox_one(xpad);
|
|
if (error) {
|
|
usb_kill_urb(xpad->irq_in);
|
|
return error;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void xpad_stop_input(struct usb_xpad *xpad)
|
|
{
|
|
usb_kill_urb(xpad->irq_in);
|
|
}
|
|
|
|
static int xpad360w_start_input(struct usb_xpad *xpad)
|
|
{
|
|
int error;
|
|
|
|
error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);
|
|
if (error)
|
|
return -EIO;
|
|
|
|
/*
|
|
* Send presence packet.
|
|
* This will force the controller to resend connection packets.
|
|
* This is useful in the case we activate the module after the
|
|
* adapter has been plugged in, as it won't automatically
|
|
* send us info about the controllers.
|
|
*/
|
|
error = xpad_inquiry_pad_presence(xpad);
|
|
if (error) {
|
|
usb_kill_urb(xpad->irq_in);
|
|
return error;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void xpad360w_stop_input(struct usb_xpad *xpad)
|
|
{
|
|
usb_kill_urb(xpad->irq_in);
|
|
|
|
/* Make sure we are done with presence work if it was scheduled */
|
|
flush_work(&xpad->work);
|
|
}
|
|
|
|
static int xpad_open(struct input_dev *dev)
|
|
{
|
|
struct usb_xpad *xpad = input_get_drvdata(dev);
|
|
|
|
return xpad_start_input(xpad);
|
|
}
|
|
|
|
static void xpad_close(struct input_dev *dev)
|
|
{
|
|
struct usb_xpad *xpad = input_get_drvdata(dev);
|
|
|
|
xpad_stop_input(xpad);
|
|
}
|
|
|
|
static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs)
|
|
{
|
|
struct usb_xpad *xpad = input_get_drvdata(input_dev);
|
|
set_bit(abs, input_dev->absbit);
|
|
|
|
switch (abs) {
|
|
case ABS_X:
|
|
case ABS_Y:
|
|
case ABS_RX:
|
|
case ABS_RY: /* the two sticks */
|
|
input_set_abs_params(input_dev, abs, -32768, 32767, 16, 128);
|
|
break;
|
|
case ABS_Z:
|
|
case ABS_RZ: /* the triggers (if mapped to axes) */
|
|
if (xpad->xtype == XTYPE_XBOXONE)
|
|
input_set_abs_params(input_dev, abs, 0, 1023, 0, 0);
|
|
else
|
|
input_set_abs_params(input_dev, abs, 0, 255, 0, 0);
|
|
break;
|
|
case ABS_HAT0X:
|
|
case ABS_HAT0Y: /* the d-pad (only if dpad is mapped to axes */
|
|
input_set_abs_params(input_dev, abs, -1, 1, 0, 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void xpad_deinit_input(struct usb_xpad *xpad)
|
|
{
|
|
if (xpad->input_created) {
|
|
xpad->input_created = false;
|
|
xpad_led_disconnect(xpad);
|
|
input_unregister_device(xpad->dev);
|
|
}
|
|
}
|
|
|
|
static int xpad_init_input(struct usb_xpad *xpad)
|
|
{
|
|
struct input_dev *input_dev;
|
|
int i, error;
|
|
|
|
input_dev = input_allocate_device();
|
|
if (!input_dev)
|
|
return -ENOMEM;
|
|
|
|
xpad->dev = input_dev;
|
|
input_dev->name = xpad->name;
|
|
input_dev->phys = xpad->phys;
|
|
usb_to_input_id(xpad->udev, &input_dev->id);
|
|
input_dev->dev.parent = &xpad->intf->dev;
|
|
|
|
input_set_drvdata(input_dev, xpad);
|
|
|
|
if (xpad->xtype != XTYPE_XBOX360W) {
|
|
input_dev->open = xpad_open;
|
|
input_dev->close = xpad_close;
|
|
}
|
|
|
|
__set_bit(EV_KEY, input_dev->evbit);
|
|
|
|
if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
|
|
__set_bit(EV_ABS, input_dev->evbit);
|
|
/* set up axes */
|
|
for (i = 0; xpad_abs[i] >= 0; i++)
|
|
xpad_set_up_abs(input_dev, xpad_abs[i]);
|
|
}
|
|
|
|
/* set up standard buttons */
|
|
for (i = 0; xpad_common_btn[i] >= 0; i++)
|
|
__set_bit(xpad_common_btn[i], input_dev->keybit);
|
|
|
|
/* set up model-specific ones */
|
|
if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX360W ||
|
|
xpad->xtype == XTYPE_XBOXONE) {
|
|
for (i = 0; xpad360_btn[i] >= 0; i++)
|
|
__set_bit(xpad360_btn[i], input_dev->keybit);
|
|
} else {
|
|
for (i = 0; xpad_btn[i] >= 0; i++)
|
|
__set_bit(xpad_btn[i], input_dev->keybit);
|
|
}
|
|
|
|
if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
|
|
for (i = 0; xpad_btn_pad[i] >= 0; i++)
|
|
__set_bit(xpad_btn_pad[i], input_dev->keybit);
|
|
}
|
|
|
|
/*
|
|
* This should be a simple else block. However historically
|
|
* xbox360w has mapped DPAD to buttons while xbox360 did not. This
|
|
* made no sense, but now we can not just switch back and have to
|
|
* support both behaviors.
|
|
*/
|
|
if (!(xpad->mapping & MAP_DPAD_TO_BUTTONS) ||
|
|
xpad->xtype == XTYPE_XBOX360W) {
|
|
for (i = 0; xpad_abs_pad[i] >= 0; i++)
|
|
xpad_set_up_abs(input_dev, xpad_abs_pad[i]);
|
|
}
|
|
|
|
if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
|
|
for (i = 0; xpad_btn_triggers[i] >= 0; i++)
|
|
__set_bit(xpad_btn_triggers[i], input_dev->keybit);
|
|
} else {
|
|
for (i = 0; xpad_abs_triggers[i] >= 0; i++)
|
|
xpad_set_up_abs(input_dev, xpad_abs_triggers[i]);
|
|
}
|
|
|
|
error = xpad_init_ff(xpad);
|
|
if (error)
|
|
goto err_free_input;
|
|
|
|
error = xpad_led_probe(xpad);
|
|
if (error)
|
|
goto err_destroy_ff;
|
|
|
|
error = input_register_device(xpad->dev);
|
|
if (error)
|
|
goto err_disconnect_led;
|
|
|
|
xpad->input_created = true;
|
|
return 0;
|
|
|
|
err_disconnect_led:
|
|
xpad_led_disconnect(xpad);
|
|
err_destroy_ff:
|
|
input_ff_destroy(input_dev);
|
|
err_free_input:
|
|
input_free_device(input_dev);
|
|
return error;
|
|
}
|
|
|
|
static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id)
|
|
{
|
|
struct usb_device *udev = interface_to_usbdev(intf);
|
|
struct usb_xpad *xpad;
|
|
struct usb_endpoint_descriptor *ep_irq_in;
|
|
int ep_irq_in_idx;
|
|
int i, error;
|
|
|
|
for (i = 0; xpad_device[i].idVendor; i++) {
|
|
if ((le16_to_cpu(udev->descriptor.idVendor) == xpad_device[i].idVendor) &&
|
|
(le16_to_cpu(udev->descriptor.idProduct) == xpad_device[i].idProduct))
|
|
break;
|
|
}
|
|
|
|
xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);
|
|
if (!xpad)
|
|
return -ENOMEM;
|
|
|
|
usb_make_path(udev, xpad->phys, sizeof(xpad->phys));
|
|
strlcat(xpad->phys, "/input0", sizeof(xpad->phys));
|
|
|
|
xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN,
|
|
GFP_KERNEL, &xpad->idata_dma);
|
|
if (!xpad->idata) {
|
|
error = -ENOMEM;
|
|
goto err_free_mem;
|
|
}
|
|
|
|
xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);
|
|
if (!xpad->irq_in) {
|
|
error = -ENOMEM;
|
|
goto err_free_idata;
|
|
}
|
|
|
|
xpad->udev = udev;
|
|
xpad->intf = intf;
|
|
xpad->mapping = xpad_device[i].mapping;
|
|
xpad->xtype = xpad_device[i].xtype;
|
|
xpad->name = xpad_device[i].name;
|
|
INIT_WORK(&xpad->work, xpad_presence_work);
|
|
|
|
if (xpad->xtype == XTYPE_UNKNOWN) {
|
|
if (intf->cur_altsetting->desc.bInterfaceClass == USB_CLASS_VENDOR_SPEC) {
|
|
if (intf->cur_altsetting->desc.bInterfaceProtocol == 129)
|
|
xpad->xtype = XTYPE_XBOX360W;
|
|
else if (intf->cur_altsetting->desc.bInterfaceProtocol == 208)
|
|
xpad->xtype = XTYPE_XBOXONE;
|
|
else
|
|
xpad->xtype = XTYPE_XBOX360;
|
|
} else {
|
|
xpad->xtype = XTYPE_XBOX;
|
|
}
|
|
|
|
if (dpad_to_buttons)
|
|
xpad->mapping |= MAP_DPAD_TO_BUTTONS;
|
|
if (triggers_to_buttons)
|
|
xpad->mapping |= MAP_TRIGGERS_TO_BUTTONS;
|
|
if (sticks_to_null)
|
|
xpad->mapping |= MAP_STICKS_TO_NULL;
|
|
}
|
|
|
|
if (xpad->xtype == XTYPE_XBOXONE &&
|
|
intf->cur_altsetting->desc.bInterfaceNumber != 0) {
|
|
/*
|
|
* The Xbox One controller lists three interfaces all with the
|
|
* same interface class, subclass and protocol. Differentiate by
|
|
* interface number.
|
|
*/
|
|
error = -ENODEV;
|
|
goto err_free_in_urb;
|
|
}
|
|
|
|
error = xpad_init_output(intf, xpad);
|
|
if (error)
|
|
goto err_free_in_urb;
|
|
|
|
/* Xbox One controller has in/out endpoints swapped. */
|
|
ep_irq_in_idx = xpad->xtype == XTYPE_XBOXONE ? 1 : 0;
|
|
ep_irq_in = &intf->cur_altsetting->endpoint[ep_irq_in_idx].desc;
|
|
|
|
usb_fill_int_urb(xpad->irq_in, udev,
|
|
usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),
|
|
xpad->idata, XPAD_PKT_LEN, xpad_irq_in,
|
|
xpad, ep_irq_in->bInterval);
|
|
xpad->irq_in->transfer_dma = xpad->idata_dma;
|
|
xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
|
|
|
|
usb_set_intfdata(intf, xpad);
|
|
|
|
if (xpad->xtype == XTYPE_XBOX360W) {
|
|
/*
|
|
* Submit the int URB immediately rather than waiting for open
|
|
* because we get status messages from the device whether
|
|
* or not any controllers are attached. In fact, it's
|
|
* exactly the message that a controller has arrived that
|
|
* we're waiting for.
|
|
*/
|
|
error = xpad360w_start_input(xpad);
|
|
if (error)
|
|
goto err_deinit_output;
|
|
/*
|
|
* Wireless controllers require RESET_RESUME to work properly
|
|
* after suspend. Ideally this quirk should be in usb core
|
|
* quirk list, but we have too many vendors producing these
|
|
* controllers and we'd need to maintain 2 identical lists
|
|
* here in this driver and in usb core.
|
|
*/
|
|
udev->quirks |= USB_QUIRK_RESET_RESUME;
|
|
} else {
|
|
error = xpad_init_input(xpad);
|
|
if (error)
|
|
goto err_deinit_output;
|
|
}
|
|
return 0;
|
|
|
|
err_deinit_output:
|
|
xpad_deinit_output(xpad);
|
|
err_free_in_urb:
|
|
usb_free_urb(xpad->irq_in);
|
|
err_free_idata:
|
|
usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
|
|
err_free_mem:
|
|
kfree(xpad);
|
|
return error;
|
|
}
|
|
|
|
static void xpad_disconnect(struct usb_interface *intf)
|
|
{
|
|
struct usb_xpad *xpad = usb_get_intfdata(intf);
|
|
|
|
if (xpad->xtype == XTYPE_XBOX360W)
|
|
xpad360w_stop_input(xpad);
|
|
|
|
xpad_deinit_input(xpad);
|
|
|
|
/*
|
|
* Now that both input device and LED device are gone we can
|
|
* stop output URB.
|
|
*/
|
|
xpad_stop_output(xpad);
|
|
|
|
xpad_deinit_output(xpad);
|
|
|
|
usb_free_urb(xpad->irq_in);
|
|
usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
|
|
xpad->idata, xpad->idata_dma);
|
|
|
|
kfree(xpad);
|
|
|
|
usb_set_intfdata(intf, NULL);
|
|
}
|
|
|
|
static int xpad_suspend(struct usb_interface *intf, pm_message_t message)
|
|
{
|
|
struct usb_xpad *xpad = usb_get_intfdata(intf);
|
|
struct input_dev *input = xpad->dev;
|
|
|
|
if (xpad->xtype == XTYPE_XBOX360W) {
|
|
/*
|
|
* Wireless controllers always listen to input so
|
|
* they are notified when controller shows up
|
|
* or goes away.
|
|
*/
|
|
xpad360w_stop_input(xpad);
|
|
} else {
|
|
mutex_lock(&input->mutex);
|
|
if (input->users)
|
|
xpad_stop_input(xpad);
|
|
mutex_unlock(&input->mutex);
|
|
}
|
|
|
|
xpad_stop_output(xpad);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int xpad_resume(struct usb_interface *intf)
|
|
{
|
|
struct usb_xpad *xpad = usb_get_intfdata(intf);
|
|
struct input_dev *input = xpad->dev;
|
|
int retval = 0;
|
|
|
|
if (xpad->xtype == XTYPE_XBOX360W) {
|
|
retval = xpad360w_start_input(xpad);
|
|
} else {
|
|
mutex_lock(&input->mutex);
|
|
if (input->users)
|
|
retval = xpad_start_input(xpad);
|
|
mutex_unlock(&input->mutex);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
static struct usb_driver xpad_driver = {
|
|
.name = "xpad",
|
|
.probe = xpad_probe,
|
|
.disconnect = xpad_disconnect,
|
|
.suspend = xpad_suspend,
|
|
.resume = xpad_resume,
|
|
.reset_resume = xpad_resume,
|
|
.id_table = xpad_table,
|
|
};
|
|
|
|
module_usb_driver(xpad_driver);
|
|
|
|
MODULE_AUTHOR(DRIVER_AUTHOR);
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
|
MODULE_LICENSE("GPL");
|