xpad.c 48 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
 * X-Box gamepad driver
Linus Torvalds's avatar
Linus Torvalds committed
3 4
 *
 * Copyright (c) 2002 Marko Friedemann <mfr@bmx-chemnitz.de>
5 6 7 8
 *               2004 Oliver Schwartz <Oliver.Schwartz@gmx.de>,
 *                    Steven Toth <steve@toth.demon.co.uk>,
 *                    Franz Lehner <franz@caos.at>,
 *                    Ivan Hawkes <blackhawk@ivanhawkes.com>
9 10
 *               2005 Dominic Cerquetti <binary1230@yahoo.com>
 *               2006 Adam Buchbinder <adam.buchbinder@gmail.com>
11
 *               2007 Jan Kratochvil <honza@jikos.cz>
12
 *               2010 Christoph Fritz <chf.fritz@googlemail.com>
Linus Torvalds's avatar
Linus Torvalds committed
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
 *
 * 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
33
 *  - Xbox 360 information http://www.free60.org/wiki/Gamepad
34
 *  - Xbox One information https://github.com/quantus/xbox-one-controller-protocol
Linus Torvalds's avatar
Linus Torvalds committed
35 36 37 38 39
 *
 * Thanks to:
 *  - ITO Takayuki for providing essential xpad information on his website
 *  - Vojtech Pavlik     - iforce driver / input subsystem
 *  - Greg Kroah-Hartman - usb-skeleton driver
40
 *  - XBOX Linux project - extra USB id's
41
 *  - Pekka Pöyry (quantus) - Xbox One controller reverse engineering
Linus Torvalds's avatar
Linus Torvalds committed
42 43
 *
 * TODO:
44
 *  - fine tune axes (especially trigger axes)
Linus Torvalds's avatar
Linus Torvalds committed
45 46
 *  - fix "analog" buttons (reported as digital now)
 *  - get rumble working
47
 *  - need USB IDs for other dance pads
Linus Torvalds's avatar
Linus Torvalds committed
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
 *
 * 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
67 68 69 70 71 72 73
 *
 * 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
74 75
 *
 * Later changes can be tracked in SCM.
Linus Torvalds's avatar
Linus Torvalds committed
76 77 78
 */

#include <linux/kernel.h>
79 80
#include <linux/input.h>
#include <linux/rcupdate.h>
Linus Torvalds's avatar
Linus Torvalds committed
81
#include <linux/slab.h>
82
#include <linux/stat.h>
Linus Torvalds's avatar
Linus Torvalds committed
83
#include <linux/module.h>
84
#include <linux/usb/input.h>
85
#include <linux/usb/quirks.h>
Linus Torvalds's avatar
Linus Torvalds committed
86 87 88 89 90 91

#define DRIVER_AUTHOR "Marko Friedemann <mfr@bmx-chemnitz.de>"
#define DRIVER_DESC "X-Box pad driver"

#define XPAD_PKT_LEN 32

92 93
/* xbox d-pads should map to buttons, as is required for DDR pads
   but we map them to axes when possible to simplify things */
94 95
#define MAP_DPAD_TO_BUTTONS		(1 << 0)
#define MAP_TRIGGERS_TO_BUTTONS		(1 << 1)
96 97 98
#define MAP_STICKS_TO_NULL		(1 << 2)
#define DANCEPAD_MAP_CONFIG	(MAP_DPAD_TO_BUTTONS |			\
				MAP_TRIGGERS_TO_BUTTONS | MAP_STICKS_TO_NULL)
99

100 101
#define XTYPE_XBOX        0
#define XTYPE_XBOX360     1
102
#define XTYPE_XBOX360W    2
103 104
#define XTYPE_XBOXONE     3
#define XTYPE_UNKNOWN     4
105

106
static bool dpad_to_buttons;
107 108 109
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");

110
static bool triggers_to_buttons;
111 112 113
module_param(triggers_to_buttons, bool, S_IRUGO);
MODULE_PARM_DESC(triggers_to_buttons, "Map triggers to buttons rather than axes for unknown pads");

114
static bool sticks_to_null;
115 116 117
module_param(sticks_to_null, bool, S_IRUGO);
MODULE_PARM_DESC(sticks_to_null, "Do not map sticks at all for unknown pads");

118
static const struct xpad_device {
Linus Torvalds's avatar
Linus Torvalds committed
119 120 121
	u16 idVendor;
	u16 idProduct;
	char *name;
122
	u8 mapping;
123
	u8 xtype;
Linus Torvalds's avatar
Linus Torvalds committed
124
} xpad_device[] = {
125 126 127
	{ 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 },
128 129
	{ 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", 0, XTYPE_XBOX },
	{ 0x045e, 0x028e, "Microsoft X-Box 360 pad", 0, XTYPE_XBOX360 },
130
	{ 0x045e, 0x02d1, "Microsoft X-Box One pad", 0, XTYPE_XBOXONE },
131
	{ 0x045e, 0x02dd, "Microsoft X-Box One pad (Firmware 2015)", 0, XTYPE_XBOXONE },
132
	{ 0x045e, 0x0291, "Xbox 360 Wireless Receiver (XBOX)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
133
	{ 0x045e, 0x0719, "Xbox 360 Wireless Receiver", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
134
	{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },
135
	{ 0x044f, 0xb326, "Thrustmaster Gamepad GP XID", 0, XTYPE_XBOX360 },
136
	{ 0x046d, 0xc21d, "Logitech Gamepad F310", 0, XTYPE_XBOX360 },
137
	{ 0x046d, 0xc21e, "Logitech Gamepad F510", 0, XTYPE_XBOX360 },
138
	{ 0x046d, 0xc21f, "Logitech Gamepad F710", 0, XTYPE_XBOX360 },
139 140 141 142 143 144 145 146 147
	{ 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 },
148
	{ 0x0738, 0x4540, "Mad Catz Beat Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
149 150
	{ 0x0738, 0x4556, "Mad Catz Lynx Wireless Controller", 0, XTYPE_XBOX },
	{ 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
151 152
	{ 0x0738, 0x4718, "Mad Catz Street Fighter IV FightStick SE", 0, XTYPE_XBOX360 },
	{ 0x0738, 0x4726, "Mad Catz Xbox 360 Controller", 0, XTYPE_XBOX360 },
153
	{ 0x0738, 0x4728, "Mad Catz Street Fighter IV FightPad", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
154
	{ 0x0738, 0x4738, "Mad Catz Wired Xbox 360 Controller (SFIV)", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
155
	{ 0x0738, 0x4740, "Mad Catz Beat Pad", 0, XTYPE_XBOX360 },
156
	{ 0x0738, 0x4a01, "Mad Catz FightStick TE 2", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOXONE },
157
	{ 0x0738, 0x6040, "Mad Catz Beat Pad Pro", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
158
	{ 0x0738, 0xb726, "Mad Catz Xbox controller - MW2", 0, XTYPE_XBOX360 },
159
	{ 0x0738, 0xbeef, "Mad Catz JOYTECH NEO SE Advanced GamePad", XTYPE_XBOX360 },
160 161 162
	{ 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 },
163
	{ 0x0c12, 0x8802, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
164
	{ 0x0c12, 0x8809, "RedOctane Xbox Dance Pad", DANCEPAD_MAP_CONFIG, XTYPE_XBOX },
165 166 167
	{ 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 },
168
	{ 0x0d2f, 0x0002, "Andamiro Pump It Up pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
169 170 171 172 173
	{ 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 },
174
	{ 0x0e6f, 0x0105, "HSM3 Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
175
	{ 0x0e6f, 0x0113, "Afterglow AX.1 Gamepad for Xbox 360", 0, XTYPE_XBOX360 },
176
	{ 0x0e6f, 0x0201, "Pelican PL-3601 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
177
	{ 0x0e6f, 0x0213, "Afterglow Gamepad for Xbox 360", 0, XTYPE_XBOX360 },
178 179 180
	{ 0x0e6f, 0x021f, "Rock Candy Gamepad for Xbox 360", 0, XTYPE_XBOX360 },
	{ 0x0e6f, 0x0301, "Logic3 Controller", 0, XTYPE_XBOX360 },
	{ 0x0e6f, 0x0401, "Logic3 Controller", 0, XTYPE_XBOX360 },
181
	{ 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", 0, XTYPE_XBOX },
182 183
	{ 0x0e8f, 0x3008, "Generic xbox control (dealextreme)", 0, XTYPE_XBOX },
	{ 0x0f0d, 0x000a, "Hori Co. DOA4 FightStick", 0, XTYPE_XBOX360 },
184 185
	{ 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 },
186 187 188
	{ 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 },
189
	{ 0x12ab, 0x0004, "Honey Bee Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
190
	{ 0x12ab, 0x0301, "PDP AFTERGLOW AX.1", 0, XTYPE_XBOX360 },
191
	{ 0x12ab, 0x8809, "Xbox DDR dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
192
	{ 0x1430, 0x4748, "RedOctane Guitar Hero X-plorer", 0, XTYPE_XBOX360 },
193
	{ 0x1430, 0x8888, "TX6500+ Dance Pad (first generation)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
194
	{ 0x146b, 0x0601, "BigBen Interactive XBOX 360 Controller", 0, XTYPE_XBOX360 },
195
	{ 0x1532, 0x0037, "Razer Sabertooth", 0, XTYPE_XBOX360 },
196
	{ 0x1532, 0x0a03, "Razer Wildcat", 0, XTYPE_XBOXONE },
197 198 199 200
	{ 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 },
201 202
	{ 0x1689, 0xfd00, "Razer Onza Tournament Edition", 0, XTYPE_XBOX360 },
	{ 0x1689, 0xfd01, "Razer Onza Classic Edition", 0, XTYPE_XBOX360 },
203
	{ 0x24c6, 0x5d04, "Razer Sabertooth", 0, XTYPE_XBOX360 },
204
	{ 0x1bad, 0x0002, "Harmonix Rock Band Guitar", 0, XTYPE_XBOX360 },
205
	{ 0x1bad, 0x0003, "Harmonix Rock Band Drumkit", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
206
	{ 0x1bad, 0xf016, "Mad Catz Xbox 360 Controller", 0, XTYPE_XBOX360 },
207
	{ 0x1bad, 0xf023, "MLG Pro Circuit Controller (Xbox)", 0, XTYPE_XBOX360 },
208
	{ 0x1bad, 0xf028, "Street Fighter IV FightPad", 0, XTYPE_XBOX360 },
209 210
	{ 0x1bad, 0xf038, "Street Fighter IV FightStick TE", 0, XTYPE_XBOX360 },
	{ 0x1bad, 0xf900, "Harmonix Xbox 360 Controller", 0, XTYPE_XBOX360 },
211 212
	{ 0x1bad, 0xf901, "Gamestop Xbox 360 Controller", 0, XTYPE_XBOX360 },
	{ 0x1bad, 0xf903, "Tron Xbox 360 controller", 0, XTYPE_XBOX360 },
213
	{ 0x24c6, 0x5000, "Razer Atrox Arcade Stick", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
214
	{ 0x24c6, 0x5300, "PowerA MINI PROEX Controller", 0, XTYPE_XBOX360 },
215 216 217 218 219
	{ 0x24c6, 0x5303, "Xbox Airflo wired controller", 0, XTYPE_XBOX360 },
	{ 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 },
220
	{ 0x24c6, 0x5b03, "Thrustmaster Ferrari 458 Racing Wheel", 0, XTYPE_XBOX360 },
221 222
	{ 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX },
	{ 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN }
Linus Torvalds's avatar
Linus Torvalds committed
223 224
};

225 226 227
/* buttons shared with xbox and xbox360 */
static const signed short xpad_common_btn[] = {
	BTN_A, BTN_B, BTN_X, BTN_Y,			/* "analog" buttons */
228
	BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR,	/* start/back/sticks */
Linus Torvalds's avatar
Linus Torvalds committed
229 230 231
	-1						/* terminating entry */
};

232 233 234 235 236 237
/* original xbox controllers only */
static const signed short xpad_btn[] = {
	BTN_C, BTN_Z,		/* "analog" buttons */
	-1			/* terminating entry */
};

238
/* used when dpad is mapped to buttons */
239
static const signed short xpad_btn_pad[] = {
240 241
	BTN_TRIGGER_HAPPY1, BTN_TRIGGER_HAPPY2,		/* d-pad left, right */
	BTN_TRIGGER_HAPPY3, BTN_TRIGGER_HAPPY4,		/* d-pad up, down */
242 243 244
	-1				/* terminating entry */
};

245 246 247 248 249 250
/* used when triggers are mapped to buttons */
static const signed short xpad_btn_triggers[] = {
	BTN_TL2, BTN_TR2,		/* triggers left/right */
	-1
};

251 252 253 254 255 256
static const signed short xpad360_btn[] = {  /* buttons for x360 controller */
	BTN_TL, BTN_TR,		/* Button LB/RB */
	BTN_MODE,		/* The big X button */
	-1
};

257
static const signed short xpad_abs[] = {
Linus Torvalds's avatar
Linus Torvalds committed
258 259
	ABS_X, ABS_Y,		/* left stick */
	ABS_RX, ABS_RY,		/* right stick */
260 261 262
	-1			/* terminating entry */
};

263
/* used when dpad is mapped to axes */
264 265
static const signed short xpad_abs_pad[] = {
	ABS_HAT0X, ABS_HAT0Y,	/* d-pad axes */
Linus Torvalds's avatar
Linus Torvalds committed
266 267 268
	-1			/* terminating entry */
};

269 270 271 272 273 274
/* used when triggers are mapped to axes */
static const signed short xpad_abs_triggers[] = {
	ABS_Z, ABS_RZ,		/* triggers left/right */
	-1
};

275 276
/*
 * Xbox 360 has a vendor-specific class, so we cannot match it with only
277
 * USB_INTERFACE_INFO (also specifically refused by USB subsystem), so we
278
 * match against vendor id as well. Wired Xbox 360 devices have protocol 1,
279 280
 * wireless controllers have protocol 129.
 */
281
#define XPAD_XBOX360_VENDOR_PROTOCOL(vend,pr) \
282 283 284 285
	.match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO, \
	.idVendor = (vend), \
	.bInterfaceClass = USB_CLASS_VENDOR_SPEC, \
	.bInterfaceSubClass = 93, \
286 287 288 289
	.bInterfaceProtocol = (pr)
#define XPAD_XBOX360_VENDOR(vend) \
	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,1) }, \
	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,129) }
290

291 292 293 294 295 296 297 298 299 300
/* 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) }

301
static struct usb_device_id xpad_table[] = {
Linus Torvalds's avatar
Linus Torvalds committed
302
	{ USB_INTERFACE_INFO('X', 'B', 0) },	/* X-Box USB-IF not approved class */
303
	XPAD_XBOX360_VENDOR(0x044f),		/* Thrustmaster X-Box 360 controllers */
304
	XPAD_XBOX360_VENDOR(0x045e),		/* Microsoft X-Box 360 controllers */
305
	XPAD_XBOXONE_VENDOR(0x045e),		/* Microsoft X-Box One controllers */
306 307
	XPAD_XBOX360_VENDOR(0x046d),		/* Logitech X-Box 360 style controllers */
	XPAD_XBOX360_VENDOR(0x0738),		/* Mad Catz X-Box 360 controllers */
308
	{ USB_DEVICE(0x0738, 0x4540) },		/* Mad Catz Beat Pad */
309
	XPAD_XBOXONE_VENDOR(0x0738),		/* Mad Catz FightStick TE 2 */
310
	XPAD_XBOX360_VENDOR(0x0e6f),		/* 0x0e6f X-Box 360 controllers */
311
	XPAD_XBOX360_VENDOR(0x12ab),		/* X-Box 360 dance pads */
312
	XPAD_XBOX360_VENDOR(0x1430),		/* RedOctane X-Box 360 controllers */
313
	XPAD_XBOX360_VENDOR(0x146b),		/* BigBen Interactive Controllers */
314
	XPAD_XBOX360_VENDOR(0x1bad),		/* Harminix Rock Band Guitar and Drums */
315 316
	XPAD_XBOX360_VENDOR(0x0f0d),		/* Hori Controllers */
	XPAD_XBOX360_VENDOR(0x1689),		/* Razer Onza */
317
	XPAD_XBOX360_VENDOR(0x24c6),		/* PowerA Controllers */
318
	XPAD_XBOX360_VENDOR(0x1532),		/* Razer Sabertooth */
319
	XPAD_XBOXONE_VENDOR(0x1532),		/* Razer Wildcat */
320 321
	XPAD_XBOX360_VENDOR(0x15e4),		/* Numark X-Box 360 controllers */
	XPAD_XBOX360_VENDOR(0x162e),		/* Joytech X-Box 360 controllers */
Linus Torvalds's avatar
Linus Torvalds committed
322 323 324
	{ }
};

325
MODULE_DEVICE_TABLE(usb, xpad_table);
Linus Torvalds's avatar
Linus Torvalds committed
326

327 328 329 330 331 332 333 334 335 336 337 338 339
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))

Linus Torvalds's avatar
Linus Torvalds committed
340
struct usb_xpad {
341
	struct input_dev *dev;		/* input device interface */
342
	struct input_dev __rcu *x360w_dev;
343
	struct usb_device *udev;	/* usb device */
344
	struct usb_interface *intf;	/* usb interface */
345

346 347
	bool pad_present;
	bool input_created;
348

349 350
	struct urb *irq_in;		/* urb for interrupt in report */
	unsigned char *idata;		/* input data */
Linus Torvalds's avatar
Linus Torvalds committed
351
	dma_addr_t idata_dma;
352

353
	struct urb *irq_out;		/* urb for interrupt out report */
354
	struct usb_anchor irq_out_anchor;
355
	bool irq_out_active;		/* we must not use an active URB */
356
	u8 odata_serial;		/* serial number for xbox one protocol */
357
	unsigned char *odata;		/* output data */
358
	dma_addr_t odata_dma;
359 360 361 362
	spinlock_t odata_lock;

	struct xpad_output_packet out_packets[XPAD_NUM_OUT_PACKETS];
	int last_out_packet;
363 364 365

#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
	struct xpad_led *led;
366 367
#endif

368
	char phys[64];			/* physical device path */
369

370
	int mapping;			/* map d-pad to buttons or to axes */
371
	int xtype;			/* type of xbox device */
372
	int pad_nr;			/* the order x360 pads were attached */
373
	const char *name;		/* name of the device */
374
	struct work_struct work;	/* init/remove device from callback */
Linus Torvalds's avatar
Linus Torvalds committed
375 376
};

377 378 379
static int xpad_init_input(struct usb_xpad *xpad);
static void xpad_deinit_input(struct usb_xpad *xpad);

Linus Torvalds's avatar
Linus Torvalds committed
380 381 382 383 384 385 386 387 388
/*
 *	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
 */
389
static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
Linus Torvalds's avatar
Linus Torvalds committed
390
{
391
	struct input_dev *dev = xpad->dev;
Linus Torvalds's avatar
Linus Torvalds committed
392

393 394 395 396 397 398 399 400 401 402 403 404 405
	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)));
	}
406

Linus Torvalds's avatar
Linus Torvalds committed
407
	/* triggers left/right */
408 409 410 411 412 413 414
	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]);
	}
415

Linus Torvalds's avatar
Linus Torvalds committed
416
	/* digital pad */
417
	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
418 419 420 421 422
		/* 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);
423 424 425 426 427
	} 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));
428
	}
429

Linus Torvalds's avatar
Linus Torvalds committed
430
	/* start/back buttons and stick press left/right */
431
	input_report_key(dev, BTN_START,  data[2] & 0x10);
432
	input_report_key(dev, BTN_SELECT, data[2] & 0x20);
433 434
	input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
	input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
435

Linus Torvalds's avatar
Linus Torvalds committed
436 437 438 439 440
	/* "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]);
441

Linus Torvalds's avatar
Linus Torvalds committed
442 443 444 445 446 447 448
	/* "analog" buttons black, white */
	input_report_key(dev, BTN_C, data[8]);
	input_report_key(dev, BTN_Z, data[9]);

	input_sync(dev);
}

449 450 451 452 453 454 455 456 457 458
/*
 *	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
 */

459
static void xpad360_process_packet(struct usb_xpad *xpad, struct input_dev *dev,
460
				   u16 cmd, unsigned char *data)
461
{
462 463 464 465
	/* valid pad data */
	if (data[0] != 0x00)
		return;

466
	/* digital pad */
467
	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
468 469 470 471 472
		/* 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);
473 474 475 476 477 478 479 480 481 482
	}

	/*
	 * 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) {
483 484 485 486
		input_report_abs(dev, ABS_HAT0X,
				 !!(data[2] & 0x08) - !!(data[2] & 0x04));
		input_report_abs(dev, ABS_HAT0Y,
				 !!(data[2] & 0x02) - !!(data[2] & 0x01));
487 488 489
	}

	/* start/back buttons */
490
	input_report_key(dev, BTN_START,  data[2] & 0x10);
491
	input_report_key(dev, BTN_SELECT, data[2] & 0x20);
492 493 494 495 496 497

	/* 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 */
498 499 500 501 502 503 504
	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);
505

506 507 508 509 510 511 512 513 514 515 516 517 518
	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)));
	}
519 520

	/* triggers left/right */
521 522 523 524 525 526 527
	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]);
	}
528 529 530 531

	input_sync(dev);
}

532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
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);
	}
}
556

557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
/*
 * 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)
{
573 574 575
	struct input_dev *dev;
	bool present;

576 577
	/* Presence change */
	if (data[0] & 0x08) {
578 579 580 581 582 583
		present = (data[1] & 0x80) != 0;

		if (xpad->pad_present != present) {
			xpad->pad_present = present;
			schedule_work(&xpad->work);
		}
584 585 586
	}

	/* Valid pad data */
587
	if (data[1] != 0x1)
588 589
		return;

590 591 592 593 594
	rcu_read_lock();
	dev = rcu_dereference(xpad->x360w_dev);
	if (dev)
		xpad360_process_packet(xpad, dev, cmd, &data[4]);
	rcu_read_unlock();
595 596
}

597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695
/*
 *	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;
	}
}

696
static void xpad_irq_in(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
697 698
{
	struct usb_xpad *xpad = urb->context;
699
	struct device *dev = &xpad->intf->dev;
700
	int retval, status;
701

702 703 704
	status = urb->status;

	switch (status) {
Linus Torvalds's avatar
Linus Torvalds committed
705 706 707 708 709 710 711
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
712
		dev_dbg(dev, "%s - urb shutting down with status: %d\n",
713
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
714 715
		return;
	default:
716
		dev_dbg(dev, "%s - nonzero urb status received: %d\n",
717
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
718 719
		goto exit;
	}
720

721 722
	switch (xpad->xtype) {
	case XTYPE_XBOX360:
723
		xpad360_process_packet(xpad, xpad->dev, 0, xpad->idata);
724 725 726 727
		break;
	case XTYPE_XBOX360W:
		xpad360w_process_packet(xpad, 0, xpad->idata);
		break;
728 729 730
	case XTYPE_XBOXONE:
		xpadone_process_packet(xpad, 0, xpad->idata);
		break;
731
	default:
732
		xpad_process_packet(xpad, 0, xpad->idata);
733
	}
Linus Torvalds's avatar
Linus Torvalds committed
734 735

exit:
736
	retval = usb_submit_urb(urb, GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
737
	if (retval)
738
		dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
739
			__func__, retval);
Linus Torvalds's avatar
Linus Torvalds committed
740 741
}

742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
/* 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;
765
		packet->pending = false;
766 767 768 769 770 771 772 773 774 775 776 777
		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)) {
778
		usb_anchor_urb(xpad->irq_out, &xpad->irq_out_anchor);
779 780 781 782 783
		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);
784
			usb_unanchor_urb(xpad->irq_out);
785 786 787 788 789 790 791 792 793
			return -EIO;
		}

		xpad->irq_out_active = true;
	}

	return 0;
}

794 795
static void xpad_irq_out(struct urb *urb)
{
796
	struct usb_xpad *xpad = urb->context;
797
	struct device *dev = &xpad->intf->dev;
798 799 800
	int status = urb->status;
	int error;
	unsigned long flags;
801

802
	spin_lock_irqsave(&xpad->odata_lock, flags);
803

804
	switch (status) {
805
	case 0:
806
		/* success */
807 808
		xpad->irq_out_active = xpad_prepare_next_out_packet(xpad);
		break;
809 810 811 812 813

	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
814 815
		dev_dbg(dev, "%s - urb shutting down with status: %d\n",
			__func__, status);
816 817
		xpad->irq_out_active = false;
		break;
818 819

	default:
820 821
		dev_dbg(dev, "%s - nonzero urb status received: %d\n",
			__func__, status);
822
		break;
823 824
	}

825
	if (xpad->irq_out_active) {
826
		usb_anchor_urb(urb, &xpad->irq_out_anchor);
827 828 829 830 831
		error = usb_submit_urb(urb, GFP_ATOMIC);
		if (error) {
			dev_err(dev,
				"%s - usb_submit_urb failed with result %d\n",
				__func__, error);
832
			usb_unanchor_urb(urb);
833 834 835 836 837
			xpad->irq_out_active = false;
		}
	}

	spin_unlock_irqrestore(&xpad->odata_lock, flags);
838 839
}

840
static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
841 842
{
	struct usb_endpoint_descriptor *ep_irq_out;
843
	int ep_irq_out_idx;
844
	int error;
845

846
	if (xpad->xtype == XTYPE_UNKNOWN)
847 848
		return 0;

849 850
	init_usb_anchor(&xpad->irq_out_anchor);

851 852
	xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,
					 GFP_KERNEL, &xpad->odata_dma);
853 854
	if (!xpad->odata) {
		error = -ENOMEM;
855
		goto fail1;
856
	}
857

858
	spin_lock_init(&xpad->odata_lock);
859

860
	xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
861 862
	if (!xpad->irq_out) {
		error = -ENOMEM;
863
		goto fail2;
864
	}
865

866 867 868 869
	/* 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;

870 871 872 873 874 875 876 877 878
	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;

879
 fail2:	usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
880 881 882
 fail1:	return error;
}

883
static void xpad_stop_output(struct usb_xpad *xpad)
884
{
885 886 887 888 889 890 891 892
	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);
		}
	}
893 894
}

895
static void xpad_deinit_output(struct usb_xpad *xpad)
896
{
897
	if (xpad->xtype != XTYPE_UNKNOWN) {
898
		usb_free_urb(xpad->irq_out);
899
		usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
900 901 902
				xpad->odata, xpad->odata_dma);
	}
}
903

904 905
static int xpad_inquiry_pad_presence(struct usb_xpad *xpad)
{
906 907 908
	struct xpad_output_packet *packet =
			&xpad->out_packets[XPAD_OUT_CMD_IDX];
	unsigned long flags;
909 910
	int retval;

911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932
	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);
933

934 935
	return retval;
}
936

937 938 939 940 941 942 943 944 945 946 947 948
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;
949 950 951 952
	packet->data[2] = xpad->odata_serial++; /* packet serial */
	packet->data[3] = 0x01; /* rumble bit enable?  */
	packet->data[4] = 0x00;
	packet->len = 5;
953
	packet->pending = true;
954

955 956 957 958 959
	/* 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);
960 961 962 963

	return retval;
}

964
#ifdef CONFIG_JOYSTICK_XPAD_FF
965
static int xpad_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
966 967
{
	struct usb_xpad *xpad = input_get_drvdata(dev);
968
	struct xpad_output_packet *packet = &xpad->out_packets[XPAD_OUT_FF_IDX];
969 970
	__u16 strong;
	__u16 weak;
971 972
	int retval;
	unsigned long flags;
973

974 975 976 977 978 979
	if (effect->type != FF_RUMBLE)
		return 0;

	strong = effect->u.rumble.strong_magnitude;
	weak = effect->u.rumble.weak_magnitude;

980 981
	spin_lock_irqsave(&xpad->odata_lock, flags);

982 983
	switch (xpad->xtype) {
	case XTYPE_XBOX:
984 985 986 987 988 989 990 991
		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;
992 993 994
		break;

	case XTYPE_XBOX360:
995 996 997 998 999 1000 1001 1002 1003 1004
		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;
1005 1006 1007
		break;

	case XTYPE_XBOX360W:
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
		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;
1022 1023 1024
		break;

	case XTYPE_XBOXONE:
1025 1026
		packet->data[0] = 0x09; /* activate rumble */
		packet->data[1] = 0x08;
1027
		packet->data[2] = xpad->odata_serial++;
1028 1029 1030 1031 1032
		packet->data[3] = 0x08; /* continuous effect */
		packet->data[4] = 0x00; /* simple rumble mode */
		packet->data[5] = 0x03; /* L and R actuator only */
		packet->data[6] = 0x00; /* TODO: LT actuator */
		packet->data[7] = 0x00; /* TODO: RT actuator */
1033 1034
		packet->data[8] = strong / 512;	/* left actuator */
		packet->data[9] = weak / 512;	/* right actuator */
1035 1036
		packet->data[10] = 0x80;	/* length of pulse */
		packet->data[11] = 0x00;	/* stop period of pulse */
1037 1038
		packet->data[12] = 0x00;
		packet->len = 13;
1039
		packet->pending = true;
1040 1041 1042 1043 1044 1045
		break;

	default:
		dev_dbg(&xpad->dev->dev,
			"%s - rumble command sent to unsupported xpad type: %d\n",
			__func__, xpad->xtype);
1046 1047
		retval = -EINVAL;
		goto out;
1048 1049
	}

1050 1051 1052 1053 1054
	retval = xpad_try_sending_next_out_packet(xpad);

out:
	spin_unlock_irqrestore(&xpad->odata_lock, flags);
	return retval;
1055 1056 1057 1058
}

static int xpad_init_ff(struct usb_xpad *xpad)
{
1059
	if (xpad->xtype == XTYPE_UNKNOWN)
1060 1061
		return 0;

1062 1063