1/*
   2 * X-Box gamepad driver
   3 *
   4 * Copyright (c) 2002 Marko Friedemann <mfr@bmx-chemnitz.de>
   5 *               2004 Oliver Schwartz <Oliver.Schwartz@gmx.de>,
   6 *                    Steven Toth <steve@toth.demon.co.uk>,
   7 *                    Franz Lehner <franz@caos.at>,
   8 *                    Ivan Hawkes <blackhawk@ivanhawkes.com>
   9 *               2005 Dominic Cerquetti <binary1230@yahoo.com>
  10 *               2006 Adam Buchbinder <adam.buchbinder@gmail.com>
  11 *               2007 Jan Kratochvil <honza@jikos.cz>
  12 *               2010 Christoph Fritz <chf.fritz@googlemail.com>
  13 *
  14 * This program is free software; you can redistribute it and/or
  15 * modify it under the terms of the GNU General Public License as
  16 * published by the Free Software Foundation; either version 2 of
  17 * the License, or (at your option) any later version.
  18 *
  19 * This program is distributed in the hope that it will be useful,
  20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 * GNU General Public License for more details.
  23 *
  24 * You should have received a copy of the GNU General Public License
  25 * along with this program; if not, write to the Free Software
  26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  27 *
  28 *
  29 * This driver is based on:
  30 *  - information from     http://euc.jp/periphs/xbox-controller.ja.html
  31 *  - the iForce driver    drivers/char/joystick/iforce.c
  32 *  - 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
  35 *
  36 * Thanks to:
  37 *  - ITO Takayuki for providing essential xpad information on his website
  38 *  - Vojtech Pavlik     - iforce driver / input subsystem
  39 *  - Greg Kroah-Hartman - usb-skeleton driver
  40 *  - XBOX Linux project - extra USB id's
  41 *  - Pekka Pöyry (quantus) - Xbox One controller reverse engineering
  42 *
  43 * TODO:
  44 *  - fine tune axes (especially trigger axes)
  45 *  - fix "analog" buttons (reported as digital now)
  46 *  - get rumble working
  47 *  - need USB IDs for other dance pads
  48 *
  49 * History:
  50 *
  51 * 2002-06-27 - 0.0.1 : first version, just said "XBOX HID controller"
  52 *
  53 * 2002-07-02 - 0.0.2 : basic working version
  54 *  - all axes and 9 of the 10 buttons work (german InterAct device)
  55 *  - the black button does not work
  56 *
  57 * 2002-07-14 - 0.0.3 : rework by Vojtech Pavlik
  58 *  - indentation fixes
  59 *  - usb + input init sequence fixes
  60 *
  61 * 2002-07-16 - 0.0.4 : minor changes, merge with Vojtech's v0.0.3
  62 *  - verified the lack of HID and report descriptors
  63 *  - verified that ALL buttons WORK
  64 *  - fixed d-pad to axes mapping
  65 *
  66 * 2002-07-17 - 0.0.5 : simplified d-pad handling
  67 *
  68 * 2004-10-02 - 0.0.6 : DDR pad support
  69 *  - borrowed from the XBOX linux kernel
  70 *  - USB id's for commonly used dance pads are present
  71 *  - dance pads will map D-PAD to buttons, not axes
  72 *  - pass the module paramater 'dpad_to_buttons' to force
  73 *    the D-PAD to map to buttons if your pad is not detected
  74 *
  75 * Later changes can be tracked in SCM.
  76 */
  77
  78#include <linux/kernel.h>
  79#include <linux/input.h>
  80#include <linux/rcupdate.h>
  81#include <linux/slab.h>
  82#include <linux/stat.h>
  83#include <linux/module.h>
  84#include <linux/usb/input.h>
  85#include <linux/usb/quirks.h>
  86
  87#define DRIVER_AUTHOR "Marko Friedemann <mfr@bmx-chemnitz.de>"
  88#define DRIVER_DESC "X-Box pad driver"
  89
  90#define XPAD_PKT_LEN 32
  91
  92/* xbox d-pads should map to buttons, as is required for DDR pads
  93   but we map them to axes when possible to simplify things */
  94#define MAP_DPAD_TO_BUTTONS		(1 << 0)
  95#define MAP_TRIGGERS_TO_BUTTONS		(1 << 1)
  96#define MAP_STICKS_TO_NULL		(1 << 2)
  97#define DANCEPAD_MAP_CONFIG	(MAP_DPAD_TO_BUTTONS |			\
  98				MAP_TRIGGERS_TO_BUTTONS | MAP_STICKS_TO_NULL)
  99
 100#define XTYPE_XBOX        0
 101#define XTYPE_XBOX360     1
 102#define XTYPE_XBOX360W    2
 103#define XTYPE_XBOXONE     3
 104#define XTYPE_UNKNOWN     4
 105
 106static bool dpad_to_buttons;
 107module_param(dpad_to_buttons, bool, S_IRUGO);
 108MODULE_PARM_DESC(dpad_to_buttons, "Map D-PAD to buttons rather than axes for unknown pads");
 109
 110static bool triggers_to_buttons;
 111module_param(triggers_to_buttons, bool, S_IRUGO);
 112MODULE_PARM_DESC(triggers_to_buttons, "Map triggers to buttons rather than axes for unknown pads");
 113
 114static bool sticks_to_null;
 115module_param(sticks_to_null, bool, S_IRUGO);
 116MODULE_PARM_DESC(sticks_to_null, "Do not map sticks at all for unknown pads");
 117
 118static const struct xpad_device {
 119	u16 idVendor;
 120	u16 idProduct;
 121	char *name;
 122	u8 mapping;
 123	u8 xtype;
 124} xpad_device[] = {
 125	{ 0x045e, 0x0202, "Microsoft X-Box pad v1 (US)", 0, XTYPE_XBOX },
 
 126	{ 0x045e, 0x0285, "Microsoft X-Box pad (Japan)", 0, XTYPE_XBOX },
 127	{ 0x045e, 0x0287, "Microsoft Xbox Controller S", 0, XTYPE_XBOX },
 128	{ 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", 0, XTYPE_XBOX },
 129	{ 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	{ 0x046d, 0xc242, "Logitech Chillstream Controller", 0, XTYPE_XBOX360 },
 140	{ 0x046d, 0xca84, "Logitech Xbox Cordless Controller", 0, XTYPE_XBOX },
 141	{ 0x046d, 0xca88, "Logitech Compact Controller for Xbox", 0, XTYPE_XBOX },
 142	{ 0x05fd, 0x1007, "Mad Catz Controller (unverified)", 0, XTYPE_XBOX },
 143	{ 0x05fd, 0x107a, "InterAct 'PowerPad Pro' X-Box pad (Germany)", 0, XTYPE_XBOX },
 144	{ 0x0738, 0x4516, "Mad Catz Control Pad", 0, XTYPE_XBOX },
 145	{ 0x0738, 0x4522, "Mad Catz LumiCON", 0, XTYPE_XBOX },
 146	{ 0x0738, 0x4526, "Mad Catz Control Pad Pro", 0, XTYPE_XBOX },
 147	{ 0x0738, 0x4536, "Mad Catz MicroCON", 0, XTYPE_XBOX },
 148	{ 0x0738, 0x4540, "Mad Catz Beat Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
 149	{ 0x0738, 0x4556, "Mad Catz Lynx Wireless Controller", 0, XTYPE_XBOX },
 150	{ 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
 151	{ 0x0738, 0x4718, "Mad Catz Street Fighter IV FightStick SE", 0, XTYPE_XBOX360 },
 152	{ 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	{ 0x0738, 0xcb02, "Saitek Cyborg Rumble Pad - PC/Xbox 360", 0, XTYPE_XBOX360 },
 161	{ 0x0738, 0xcb03, "Saitek P3200 Rumble Pad - PC/Xbox 360", 0, XTYPE_XBOX360 },
 162	{ 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	{ 0x0c12, 0x880a, "Pelican Eclipse PL-2023", 0, XTYPE_XBOX },
 166	{ 0x0c12, 0x8810, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
 167	{ 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", 0, XTYPE_XBOX },
 168	{ 0x0d2f, 0x0002, "Andamiro Pump It Up pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
 169	{ 0x0e4c, 0x1097, "Radica Gamester Controller", 0, XTYPE_XBOX },
 170	{ 0x0e4c, 0x2390, "Radica Games Jtech Controller", 0, XTYPE_XBOX },
 171	{ 0x0e6f, 0x0003, "Logic3 Freebird wireless Controller", 0, XTYPE_XBOX },
 172	{ 0x0e6f, 0x0005, "Eclipse wireless Controller", 0, XTYPE_XBOX },
 173	{ 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	{ 0x0e6f, 0x021f, "Rock Candy Gamepad for Xbox 360", 0, XTYPE_XBOX360 },
 179	{ 0x0e6f, 0x0301, "Logic3 Controller", 0, XTYPE_XBOX360 },
 180	{ 0x0e6f, 0x0401, "Logic3 Controller", 0, XTYPE_XBOX360 },
 181	{ 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", 0, XTYPE_XBOX },
 182	{ 0x0e8f, 0x3008, "Generic xbox control (dealextreme)", 0, XTYPE_XBOX },
 183	{ 0x0f0d, 0x000a, "Hori Co. DOA4 FightStick", 0, XTYPE_XBOX360 },
 184	{ 0x0f0d, 0x000d, "Hori Fighting Stick EX2", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
 185	{ 0x0f0d, 0x0016, "Hori Real Arcade Pro.EX", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
 186	{ 0x0f30, 0x0202, "Joytech Advanced Controller", 0, XTYPE_XBOX },
 187	{ 0x0f30, 0x8888, "BigBen XBMiniPad Controller", 0, XTYPE_XBOX },
 188	{ 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	{ 0x15e4, 0x3f00, "Power A Mini Pro Elite", 0, XTYPE_XBOX360 },
 197	{ 0x15e4, 0x3f0a, "Xbox Airflo wired controller", 0, XTYPE_XBOX360 },
 198	{ 0x15e4, 0x3f10, "Batarang Xbox 360 controller", 0, XTYPE_XBOX360 },
 199	{ 0x162e, 0xbeef, "Joytech Neo-Se Take2", 0, XTYPE_XBOX360 },
 200	{ 0x1689, 0xfd00, "Razer Onza Tournament Edition", 0, XTYPE_XBOX360 },
 201	{ 0x1689, 0xfd01, "Razer Onza Classic Edition", 0, XTYPE_XBOX360 },
 202	{ 0x24c6, 0x5d04, "Razer Sabertooth", 0, XTYPE_XBOX360 },
 203	{ 0x1bad, 0x0002, "Harmonix Rock Band Guitar", 0, XTYPE_XBOX360 },
 204	{ 0x1bad, 0x0003, "Harmonix Rock Band Drumkit", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
 205	{ 0x1bad, 0xf016, "Mad Catz Xbox 360 Controller", 0, XTYPE_XBOX360 },
 206	{ 0x1bad, 0xf023, "MLG Pro Circuit Controller (Xbox)", 0, XTYPE_XBOX360 },
 207	{ 0x1bad, 0xf028, "Street Fighter IV FightPad", 0, XTYPE_XBOX360 },
 208	{ 0x1bad, 0xf038, "Street Fighter IV FightStick TE", 0, XTYPE_XBOX360 },
 209	{ 0x1bad, 0xf900, "Harmonix Xbox 360 Controller", 0, XTYPE_XBOX360 },
 210	{ 0x1bad, 0xf901, "Gamestop Xbox 360 Controller", 0, XTYPE_XBOX360 },
 211	{ 0x1bad, 0xf903, "Tron Xbox 360 controller", 0, XTYPE_XBOX360 },
 212	{ 0x24c6, 0x5000, "Razer Atrox Arcade Stick", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
 213	{ 0x24c6, 0x5300, "PowerA MINI PROEX Controller", 0, XTYPE_XBOX360 },
 214	{ 0x24c6, 0x5303, "Xbox Airflo wired controller", 0, XTYPE_XBOX360 },
 215	{ 0x24c6, 0x5500, "Hori XBOX 360 EX 2 with Turbo", 0, XTYPE_XBOX360 },
 216	{ 0x24c6, 0x5501, "Hori Real Arcade Pro VX-SA", 0, XTYPE_XBOX360 },
 217	{ 0x24c6, 0x5506, "Hori SOULCALIBUR V Stick", 0, XTYPE_XBOX360 },
 218	{ 0x24c6, 0x5b02, "Thrustmaster, Inc. GPX Controller", 0, XTYPE_XBOX360 },
 219	{ 0x24c6, 0x5b03, "Thrustmaster Ferrari 458 Racing Wheel", 0, XTYPE_XBOX360 },
 220	{ 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX },
 221	{ 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN }
 222};
 223
 224/* buttons shared with xbox and xbox360 */
 225static const signed short xpad_common_btn[] = {
 226	BTN_A, BTN_B, BTN_X, BTN_Y,			/* "analog" buttons */
 227	BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR,	/* start/back/sticks */
 228	-1						/* terminating entry */
 229};
 230
 231/* original xbox controllers only */
 232static const signed short xpad_btn[] = {
 233	BTN_C, BTN_Z,		/* "analog" buttons */
 234	-1			/* terminating entry */
 235};
 236
 237/* used when dpad is mapped to buttons */
 238static const signed short xpad_btn_pad[] = {
 239	BTN_TRIGGER_HAPPY1, BTN_TRIGGER_HAPPY2,		/* d-pad left, right */
 240	BTN_TRIGGER_HAPPY3, BTN_TRIGGER_HAPPY4,		/* d-pad up, down */
 241	-1				/* terminating entry */
 242};
 243
 244/* used when triggers are mapped to buttons */
 245static const signed short xpad_btn_triggers[] = {
 246	BTN_TL2, BTN_TR2,		/* triggers left/right */
 247	-1
 248};
 249
 
 250static const signed short xpad360_btn[] = {  /* buttons for x360 controller */
 251	BTN_TL, BTN_TR,		/* Button LB/RB */
 252	BTN_MODE,		/* The big X button */
 253	-1
 254};
 255
 256static const signed short xpad_abs[] = {
 257	ABS_X, ABS_Y,		/* left stick */
 258	ABS_RX, ABS_RY,		/* right stick */
 259	-1			/* terminating entry */
 260};
 261
 262/* used when dpad is mapped to axes */
 263static const signed short xpad_abs_pad[] = {
 264	ABS_HAT0X, ABS_HAT0Y,	/* d-pad axes */
 265	-1			/* terminating entry */
 266};
 267
 268/* used when triggers are mapped to axes */
 269static const signed short xpad_abs_triggers[] = {
 270	ABS_Z, ABS_RZ,		/* triggers left/right */
 271	-1
 272};
 273
 274/*
 275 * Xbox 360 has a vendor-specific class, so we cannot match it with only
 276 * USB_INTERFACE_INFO (also specifically refused by USB subsystem), so we
 277 * match against vendor id as well. Wired Xbox 360 devices have protocol 1,
 278 * wireless controllers have protocol 129.
 279 */
 280#define XPAD_XBOX360_VENDOR_PROTOCOL(vend,pr) \
 281	.match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO, \
 282	.idVendor = (vend), \
 283	.bInterfaceClass = USB_CLASS_VENDOR_SPEC, \
 284	.bInterfaceSubClass = 93, \
 285	.bInterfaceProtocol = (pr)
 286#define XPAD_XBOX360_VENDOR(vend) \
 287	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,1) }, \
 288	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,129) }
 289
 290/* The Xbox One controller uses subclass 71 and protocol 208. */
 291#define XPAD_XBOXONE_VENDOR_PROTOCOL(vend, pr) \
 292	.match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO, \
 293	.idVendor = (vend), \
 294	.bInterfaceClass = USB_CLASS_VENDOR_SPEC, \
 295	.bInterfaceSubClass = 71, \
 296	.bInterfaceProtocol = (pr)
 297#define XPAD_XBOXONE_VENDOR(vend) \
 298	{ XPAD_XBOXONE_VENDOR_PROTOCOL(vend, 208) }
 299
 300static struct usb_device_id xpad_table[] = {
 301	{ USB_INTERFACE_INFO('X', 'B', 0) },	/* X-Box USB-IF not approved class */
 302	XPAD_XBOX360_VENDOR(0x044f),		/* Thrustmaster X-Box 360 controllers */
 303	XPAD_XBOX360_VENDOR(0x045e),		/* Microsoft X-Box 360 controllers */
 304	XPAD_XBOXONE_VENDOR(0x045e),		/* Microsoft X-Box One controllers */
 305	XPAD_XBOX360_VENDOR(0x046d),		/* Logitech X-Box 360 style controllers */
 306	XPAD_XBOX360_VENDOR(0x0738),		/* Mad Catz X-Box 360 controllers */
 307	{ USB_DEVICE(0x0738, 0x4540) },		/* Mad Catz Beat Pad */
 308	XPAD_XBOXONE_VENDOR(0x0738),		/* Mad Catz FightStick TE 2 */
 309	XPAD_XBOX360_VENDOR(0x0e6f),		/* 0x0e6f X-Box 360 controllers */
 310	XPAD_XBOX360_VENDOR(0x12ab),		/* X-Box 360 dance pads */
 311	XPAD_XBOX360_VENDOR(0x1430),		/* RedOctane X-Box 360 controllers */
 312	XPAD_XBOX360_VENDOR(0x146b),		/* BigBen Interactive Controllers */
 313	XPAD_XBOX360_VENDOR(0x1bad),		/* Harminix Rock Band Guitar and Drums */
 314	XPAD_XBOX360_VENDOR(0x0f0d),		/* Hori Controllers */
 315	XPAD_XBOX360_VENDOR(0x1689),		/* Razer Onza */
 316	XPAD_XBOX360_VENDOR(0x24c6),		/* PowerA Controllers */
 317	XPAD_XBOX360_VENDOR(0x1532),		/* Razer Sabertooth */
 318	XPAD_XBOX360_VENDOR(0x15e4),		/* Numark X-Box 360 controllers */
 319	XPAD_XBOX360_VENDOR(0x162e),		/* Joytech X-Box 360 controllers */
 320	{ }
 321};
 322
 323MODULE_DEVICE_TABLE(usb, xpad_table);
 324
 325struct xpad_output_packet {
 326	u8 data[XPAD_PKT_LEN];
 327	u8 len;
 328	bool pending;
 329};
 330
 331#define XPAD_OUT_CMD_IDX	0
 332#define XPAD_OUT_FF_IDX		1
 333#define XPAD_OUT_LED_IDX	(1 + IS_ENABLED(CONFIG_JOYSTICK_XPAD_FF))
 334#define XPAD_NUM_OUT_PACKETS	(1 + \
 335				 IS_ENABLED(CONFIG_JOYSTICK_XPAD_FF) + \
 336				 IS_ENABLED(CONFIG_JOYSTICK_XPAD_LEDS))
 337
 338struct usb_xpad {
 339	struct input_dev *dev;		/* input device interface */
 340	struct input_dev __rcu *x360w_dev;
 341	struct usb_device *udev;	/* usb device */
 342	struct usb_interface *intf;	/* usb interface */
 343
 344	bool pad_present;
 345	bool input_created;
 346
 347	struct urb *irq_in;		/* urb for interrupt in report */
 348	unsigned char *idata;		/* input data */
 349	dma_addr_t idata_dma;
 350
 
 
 
 
 351	struct urb *irq_out;		/* urb for interrupt out report */
 352	struct usb_anchor irq_out_anchor;
 353	bool irq_out_active;		/* we must not use an active URB */
 354	u8 odata_serial;		/* serial number for xbox one protocol */
 355	unsigned char *odata;		/* output data */
 356	dma_addr_t odata_dma;
 357	spinlock_t odata_lock;
 358
 359	struct xpad_output_packet out_packets[XPAD_NUM_OUT_PACKETS];
 360	int last_out_packet;
 361
 362#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
 363	struct xpad_led *led;
 364#endif
 365
 366	char phys[64];			/* physical device path */
 367
 368	int mapping;			/* map d-pad to buttons or to axes */
 369	int xtype;			/* type of xbox device */
 370	int pad_nr;			/* the order x360 pads were attached */
 371	const char *name;		/* name of the device */
 372	struct work_struct work;	/* init/remove device from callback */
 373};
 374
 375static int xpad_init_input(struct usb_xpad *xpad);
 376static void xpad_deinit_input(struct usb_xpad *xpad);
 377
 378/*
 379 *	xpad_process_packet
 380 *
 381 *	Completes a request by converting the data into events for the
 382 *	input subsystem.
 383 *
 384 *	The used report descriptor was taken from ITO Takayukis website:
 385 *	 http://euc.jp/periphs/xbox-controller.ja.html
 386 */
 
 387static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
 388{
 389	struct input_dev *dev = xpad->dev;
 390
 391	if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
 392		/* left stick */
 393		input_report_abs(dev, ABS_X,
 394				 (__s16) le16_to_cpup((__le16 *)(data + 12)));
 395		input_report_abs(dev, ABS_Y,
 396				 ~(__s16) le16_to_cpup((__le16 *)(data + 14)));
 397
 398		/* right stick */
 399		input_report_abs(dev, ABS_RX,
 400				 (__s16) le16_to_cpup((__le16 *)(data + 16)));
 401		input_report_abs(dev, ABS_RY,
 402				 ~(__s16) le16_to_cpup((__le16 *)(data + 18)));
 403	}
 404
 405	/* triggers left/right */
 406	if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
 407		input_report_key(dev, BTN_TL2, data[10]);
 408		input_report_key(dev, BTN_TR2, data[11]);
 409	} else {
 410		input_report_abs(dev, ABS_Z, data[10]);
 411		input_report_abs(dev, ABS_RZ, data[11]);
 412	}
 413
 414	/* digital pad */
 415	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
 416		/* dpad as buttons (left, right, up, down) */
 417		input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
 418		input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
 419		input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
 420		input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
 421	} else {
 422		input_report_abs(dev, ABS_HAT0X,
 423				 !!(data[2] & 0x08) - !!(data[2] & 0x04));
 424		input_report_abs(dev, ABS_HAT0Y,
 425				 !!(data[2] & 0x02) - !!(data[2] & 0x01));
 426	}
 427
 428	/* start/back buttons and stick press left/right */
 429	input_report_key(dev, BTN_START,  data[2] & 0x10);
 430	input_report_key(dev, BTN_SELECT, data[2] & 0x20);
 431	input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
 432	input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
 433
 434	/* "analog" buttons A, B, X, Y */
 435	input_report_key(dev, BTN_A, data[4]);
 436	input_report_key(dev, BTN_B, data[5]);
 437	input_report_key(dev, BTN_X, data[6]);
 438	input_report_key(dev, BTN_Y, data[7]);
 439
 440	/* "analog" buttons black, white */
 441	input_report_key(dev, BTN_C, data[8]);
 442	input_report_key(dev, BTN_Z, data[9]);
 443
 444	input_sync(dev);
 445}
 446
 447/*
 448 *	xpad360_process_packet
 449 *
 450 *	Completes a request by converting the data into events for the
 451 *	input subsystem. It is version for xbox 360 controller
 452 *
 453 *	The used report descriptor was taken from:
 454 *		http://www.free60.org/wiki/Gamepad
 455 */
 456
 457static void xpad360_process_packet(struct usb_xpad *xpad, struct input_dev *dev,
 458				   u16 cmd, unsigned char *data)
 459{
 
 
 460	/* digital pad */
 461	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
 462		/* dpad as buttons (left, right, up, down) */
 463		input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
 464		input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
 465		input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
 466		input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
 467	}
 468
 469	/*
 470	 * This should be a simple else block. However historically
 471	 * xbox360w has mapped DPAD to buttons while xbox360 did not. This
 472	 * made no sense, but now we can not just switch back and have to
 473	 * support both behaviors.
 474	 */
 475	if (!(xpad->mapping & MAP_DPAD_TO_BUTTONS) ||
 476	    xpad->xtype == XTYPE_XBOX360W) {
 477		input_report_abs(dev, ABS_HAT0X,
 478				 !!(data[2] & 0x08) - !!(data[2] & 0x04));
 479		input_report_abs(dev, ABS_HAT0Y,
 480				 !!(data[2] & 0x02) - !!(data[2] & 0x01));
 481	}
 482
 483	/* start/back buttons */
 484	input_report_key(dev, BTN_START,  data[2] & 0x10);
 485	input_report_key(dev, BTN_SELECT, data[2] & 0x20);
 486
 487	/* stick press left/right */
 488	input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
 489	input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
 490
 491	/* buttons A,B,X,Y,TL,TR and MODE */
 492	input_report_key(dev, BTN_A,	data[3] & 0x10);
 493	input_report_key(dev, BTN_B,	data[3] & 0x20);
 494	input_report_key(dev, BTN_X,	data[3] & 0x40);
 495	input_report_key(dev, BTN_Y,	data[3] & 0x80);
 496	input_report_key(dev, BTN_TL,	data[3] & 0x01);
 497	input_report_key(dev, BTN_TR,	data[3] & 0x02);
 498	input_report_key(dev, BTN_MODE,	data[3] & 0x04);
 499
 500	if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
 501		/* left stick */
 502		input_report_abs(dev, ABS_X,
 503				 (__s16) le16_to_cpup((__le16 *)(data + 6)));
 504		input_report_abs(dev, ABS_Y,
 505				 ~(__s16) le16_to_cpup((__le16 *)(data + 8)));
 506
 507		/* right stick */
 508		input_report_abs(dev, ABS_RX,
 509				 (__s16) le16_to_cpup((__le16 *)(data + 10)));
 510		input_report_abs(dev, ABS_RY,
 511				 ~(__s16) le16_to_cpup((__le16 *)(data + 12)));
 512	}
 513
 514	/* triggers left/right */
 515	if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
 516		input_report_key(dev, BTN_TL2, data[4]);
 517		input_report_key(dev, BTN_TR2, data[5]);
 518	} else {
 519		input_report_abs(dev, ABS_Z, data[4]);
 520		input_report_abs(dev, ABS_RZ, data[5]);
 521	}
 522
 523	input_sync(dev);
 524}
 525
 526static void xpad_presence_work(struct work_struct *work)
 527{
 528	struct usb_xpad *xpad = container_of(work, struct usb_xpad, work);
 529	int error;
 530
 531	if (xpad->pad_present) {
 532		error = xpad_init_input(xpad);
 533		if (error) {
 534			/* complain only, not much else we can do here */
 535			dev_err(&xpad->dev->dev,
 536				"unable to init device: %d\n", error);
 537		} else {
 538			rcu_assign_pointer(xpad->x360w_dev, xpad->dev);
 539		}
 540	} else {
 541		RCU_INIT_POINTER(xpad->x360w_dev, NULL);
 542		synchronize_rcu();
 543		/*
 544		 * Now that we are sure xpad360w_process_packet is not
 545		 * using input device we can get rid of it.
 546		 */
 547		xpad_deinit_input(xpad);
 548	}
 549}
 550
 551/*
 552 * xpad360w_process_packet
 553 *
 554 * Completes a request by converting the data into events for the
 555 * input subsystem. It is version for xbox 360 wireless controller.
 556 *
 557 * Byte.Bit
 558 * 00.1 - Status change: The controller or headset has connected/disconnected
 559 *                       Bits 01.7 and 01.6 are valid
 560 * 01.7 - Controller present
 561 * 01.6 - Headset present
 562 * 01.1 - Pad state (Bytes 4+) valid
 563 *
 564 */
 
 565static void xpad360w_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
 566{
 567	struct input_dev *dev;
 568	bool present;
 569
 570	/* Presence change */
 571	if (data[0] & 0x08) {
 572		present = (data[1] & 0x80) != 0;
 573
 574		if (xpad->pad_present != present) {
 575			xpad->pad_present = present;
 576			schedule_work(&xpad->work);
 577		}
 578	}
 579
 580	/* Valid pad data */
 581	if (data[1] != 0x1)
 582		return;
 583
 584	rcu_read_lock();
 585	dev = rcu_dereference(xpad->x360w_dev);
 586	if (dev)
 587		xpad360_process_packet(xpad, dev, cmd, &data[4]);
 588	rcu_read_unlock();
 589}
 590
 591/*
 592 *	xpadone_process_buttons
 593 *
 594 *	Process a button update packet from an Xbox one controller.
 595 */
 596static void xpadone_process_buttons(struct usb_xpad *xpad,
 597				struct input_dev *dev,
 598				unsigned char *data)
 599{
 600	/* menu/view buttons */
 601	input_report_key(dev, BTN_START,  data[4] & 0x04);
 602	input_report_key(dev, BTN_SELECT, data[4] & 0x08);
 603
 604	/* buttons A,B,X,Y */
 605	input_report_key(dev, BTN_A,	data[4] & 0x10);
 606	input_report_key(dev, BTN_B,	data[4] & 0x20);
 607	input_report_key(dev, BTN_X,	data[4] & 0x40);
 608	input_report_key(dev, BTN_Y,	data[4] & 0x80);
 609
 610	/* digital pad */
 611	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
 612		/* dpad as buttons (left, right, up, down) */
 613		input_report_key(dev, BTN_TRIGGER_HAPPY1, data[5] & 0x04);
 614		input_report_key(dev, BTN_TRIGGER_HAPPY2, data[5] & 0x08);
 615		input_report_key(dev, BTN_TRIGGER_HAPPY3, data[5] & 0x01);
 616		input_report_key(dev, BTN_TRIGGER_HAPPY4, data[5] & 0x02);
 617	} else {
 618		input_report_abs(dev, ABS_HAT0X,
 619				 !!(data[5] & 0x08) - !!(data[5] & 0x04));
 620		input_report_abs(dev, ABS_HAT0Y,
 621				 !!(data[5] & 0x02) - !!(data[5] & 0x01));
 622	}
 623
 624	/* TL/TR */
 625	input_report_key(dev, BTN_TL,	data[5] & 0x10);
 626	input_report_key(dev, BTN_TR,	data[5] & 0x20);
 627
 628	/* stick press left/right */
 629	input_report_key(dev, BTN_THUMBL, data[5] & 0x40);
 630	input_report_key(dev, BTN_THUMBR, data[5] & 0x80);
 631
 632	if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
 633		/* left stick */
 634		input_report_abs(dev, ABS_X,
 635				 (__s16) le16_to_cpup((__le16 *)(data + 10)));
 636		input_report_abs(dev, ABS_Y,
 637				 ~(__s16) le16_to_cpup((__le16 *)(data + 12)));
 638
 639		/* right stick */
 640		input_report_abs(dev, ABS_RX,
 641				 (__s16) le16_to_cpup((__le16 *)(data + 14)));
 642		input_report_abs(dev, ABS_RY,
 643				 ~(__s16) le16_to_cpup((__le16 *)(data + 16)));
 644	}
 645
 646	/* triggers left/right */
 647	if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
 648		input_report_key(dev, BTN_TL2,
 649				 (__u16) le16_to_cpup((__le16 *)(data + 6)));
 650		input_report_key(dev, BTN_TR2,
 651				 (__u16) le16_to_cpup((__le16 *)(data + 8)));
 652	} else {
 653		input_report_abs(dev, ABS_Z,
 654				 (__u16) le16_to_cpup((__le16 *)(data + 6)));
 655		input_report_abs(dev, ABS_RZ,
 656				 (__u16) le16_to_cpup((__le16 *)(data + 8)));
 657	}
 658
 659	input_sync(dev);
 660}
 661
 662/*
 663 *	xpadone_process_packet
 664 *
 665 *	Completes a request by converting the data into events for the
 666 *	input subsystem. This version is for the Xbox One controller.
 667 *
 668 *	The report format was gleaned from
 669 *	https://github.com/kylelemons/xbox/blob/master/xbox.go
 670 */
 671
 672static void xpadone_process_packet(struct usb_xpad *xpad,
 673				u16 cmd, unsigned char *data)
 674{
 675	struct input_dev *dev = xpad->dev;
 676
 677	switch (data[0]) {
 678	case 0x20:
 679		xpadone_process_buttons(xpad, dev, data);
 680		break;
 681
 682	case 0x07:
 683		/* the xbox button has its own special report */
 684		input_report_key(dev, BTN_MODE, data[4] & 0x01);
 685		input_sync(dev);
 686		break;
 687	}
 688}
 689
 690static void xpad_irq_in(struct urb *urb)
 691{
 692	struct usb_xpad *xpad = urb->context;
 693	struct device *dev = &xpad->intf->dev;
 694	int retval, status;
 695
 696	status = urb->status;
 697
 698	switch (status) {
 699	case 0:
 700		/* success */
 701		break;
 702	case -ECONNRESET:
 703	case -ENOENT:
 704	case -ESHUTDOWN:
 705		/* this urb is terminated, clean up */
 706		dev_dbg(dev, "%s - urb shutting down with status: %d\n",
 707			__func__, status);
 708		return;
 709	default:
 710		dev_dbg(dev, "%s - nonzero urb status received: %d\n",
 711			__func__, status);
 712		goto exit;
 713	}
 714
 715	switch (xpad->xtype) {
 716	case XTYPE_XBOX360:
 717		xpad360_process_packet(xpad, xpad->dev, 0, xpad->idata);
 718		break;
 719	case XTYPE_XBOX360W:
 720		xpad360w_process_packet(xpad, 0, xpad->idata);
 721		break;
 722	case XTYPE_XBOXONE:
 723		xpadone_process_packet(xpad, 0, xpad->idata);
 724		break;
 725	default:
 726		xpad_process_packet(xpad, 0, xpad->idata);
 727	}
 728
 729exit:
 730	retval = usb_submit_urb(urb, GFP_ATOMIC);
 731	if (retval)
 732		dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
 733			__func__, retval);
 734}
 735
 736/* Callers must hold xpad->odata_lock spinlock */
 737static bool xpad_prepare_next_out_packet(struct usb_xpad *xpad)
 738{
 739	struct xpad_output_packet *pkt, *packet = NULL;
 740	int i;
 741
 742	for (i = 0; i < XPAD_NUM_OUT_PACKETS; i++) {
 743		if (++xpad->last_out_packet >= XPAD_NUM_OUT_PACKETS)
 744			xpad->last_out_packet = 0;
 745
 746		pkt = &xpad->out_packets[xpad->last_out_packet];
 747		if (pkt->pending) {
 748			dev_dbg(&xpad->intf->dev,
 749				"%s - found pending output packet %d\n",
 750				__func__, xpad->last_out_packet);
 751			packet = pkt;
 752			break;
 753		}
 754	}
 755
 756	if (packet) {
 757		memcpy(xpad->odata, packet->data, packet->len);
 758		xpad->irq_out->transfer_buffer_length = packet->len;
 759		return true;
 760	}
 761
 762	return false;
 763}
 764
 765/* Callers must hold xpad->odata_lock spinlock */
 766static int xpad_try_sending_next_out_packet(struct usb_xpad *xpad)
 767{
 768	int error;
 769
 770	if (!xpad->irq_out_active && xpad_prepare_next_out_packet(xpad)) {
 771		usb_anchor_urb(xpad->irq_out, &xpad->irq_out_anchor);
 772		error = usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
 773		if (error) {
 774			dev_err(&xpad->intf->dev,
 775				"%s - usb_submit_urb failed with result %d\n",
 776				__func__, error);
 777			usb_unanchor_urb(xpad->irq_out);
 778			return -EIO;
 779		}
 780
 781		xpad->irq_out_active = true;
 
 
 
 
 
 
 
 
 
 
 
 
 
 782	}
 783
 784	return 0;
 785}
 786
 
 787static void xpad_irq_out(struct urb *urb)
 788{
 789	struct usb_xpad *xpad = urb->context;
 790	struct device *dev = &xpad->intf->dev;
 791	int status = urb->status;
 792	int error;
 793	unsigned long flags;
 794
 795	spin_lock_irqsave(&xpad->odata_lock, flags);
 796
 797	switch (status) {
 798	case 0:
 799		/* success */
 800		xpad->out_packets[xpad->last_out_packet].pending = false;
 801		xpad->irq_out_active = xpad_prepare_next_out_packet(xpad);
 802		break;
 803
 804	case -ECONNRESET:
 805	case -ENOENT:
 806	case -ESHUTDOWN:
 807		/* this urb is terminated, clean up */
 808		dev_dbg(dev, "%s - urb shutting down with status: %d\n",
 809			__func__, status);
 810		xpad->irq_out_active = false;
 811		break;
 812
 813	default:
 814		dev_dbg(dev, "%s - nonzero urb status received: %d\n",
 815			__func__, status);
 816		break;
 817	}
 818
 819	if (xpad->irq_out_active) {
 820		usb_anchor_urb(urb, &xpad->irq_out_anchor);
 821		error = usb_submit_urb(urb, GFP_ATOMIC);
 822		if (error) {
 823			dev_err(dev,
 824				"%s - usb_submit_urb failed with result %d\n",
 825				__func__, error);
 826			usb_unanchor_urb(urb);
 827			xpad->irq_out_active = false;
 828		}
 829	}
 830
 831	spin_unlock_irqrestore(&xpad->odata_lock, flags);
 
 
 
 
 832}
 833
 834static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
 835{
 836	struct usb_endpoint_descriptor *ep_irq_out;
 837	int ep_irq_out_idx;
 838	int error;
 839
 840	if (xpad->xtype == XTYPE_UNKNOWN)
 841		return 0;
 842
 843	init_usb_anchor(&xpad->irq_out_anchor);
 844
 845	xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,
 846					 GFP_KERNEL, &xpad->odata_dma);
 847	if (!xpad->odata) {
 848		error = -ENOMEM;
 849		goto fail1;
 850	}
 851
 852	spin_lock_init(&xpad->odata_lock);
 853
 854	xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
 855	if (!xpad->irq_out) {
 856		error = -ENOMEM;
 857		goto fail2;
 858	}
 859
 860	/* Xbox One controller has in/out endpoints swapped. */
 861	ep_irq_out_idx = xpad->xtype == XTYPE_XBOXONE ? 0 : 1;
 862	ep_irq_out = &intf->cur_altsetting->endpoint[ep_irq_out_idx].desc;
 863
 864	usb_fill_int_urb(xpad->irq_out, xpad->udev,
 865			 usb_sndintpipe(xpad->udev, ep_irq_out->bEndpointAddress),
 866			 xpad->odata, XPAD_PKT_LEN,
 867			 xpad_irq_out, xpad, ep_irq_out->bInterval);
 868	xpad->irq_out->transfer_dma = xpad->odata_dma;
 869	xpad->irq_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 870
 871	return 0;
 872
 873 fail2:	usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
 874 fail1:	return error;
 875}
 876
 877static void xpad_stop_output(struct usb_xpad *xpad)
 878{
 879	if (xpad->xtype != XTYPE_UNKNOWN) {
 880		if (!usb_wait_anchor_empty_timeout(&xpad->irq_out_anchor,
 881						   5000)) {
 882			dev_warn(&xpad->intf->dev,
 883				 "timed out waiting for output URB to complete, killing\n");
 884			usb_kill_anchored_urbs(&xpad->irq_out_anchor);
 885		}
 886	}
 887}
 888
 889static void xpad_deinit_output(struct usb_xpad *xpad)
 890{
 891	if (xpad->xtype != XTYPE_UNKNOWN) {
 892		usb_free_urb(xpad->irq_out);
 893		usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
 894				xpad->odata, xpad->odata_dma);
 895	}
 896}
 897
 898static int xpad_inquiry_pad_presence(struct usb_xpad *xpad)
 899{
 900	struct xpad_output_packet *packet =
 901			&xpad->out_packets[XPAD_OUT_CMD_IDX];
 902	unsigned long flags;
 903	int retval;
 904
 905	spin_lock_irqsave(&xpad->odata_lock, flags);
 906
 907	packet->data[0] = 0x08;
 908	packet->data[1] = 0x00;
 909	packet->data[2] = 0x0F;
 910	packet->data[3] = 0xC0;
 911	packet->data[4] = 0x00;
 912	packet->data[5] = 0x00;
 913	packet->data[6] = 0x00;
 914	packet->data[7] = 0x00;
 915	packet->data[8] = 0x00;
 916	packet->data[9] = 0x00;
 917	packet->data[10] = 0x00;
 918	packet->data[11] = 0x00;
 919	packet->len = 12;
 920	packet->pending = true;
 921
 922	/* Reset the sequence so we send out presence first */
 923	xpad->last_out_packet = -1;
 924	retval = xpad_try_sending_next_out_packet(xpad);
 925
 926	spin_unlock_irqrestore(&xpad->odata_lock, flags);
 927
 928	return retval;
 929}
 930
 931static int xpad_start_xbox_one(struct usb_xpad *xpad)
 932{
 933	struct xpad_output_packet *packet =
 934			&xpad->out_packets[XPAD_OUT_CMD_IDX];
 935	unsigned long flags;
 936	int retval;
 937
 938	spin_lock_irqsave(&xpad->odata_lock, flags);
 939
 940	/* Xbox one controller needs to be initialized. */
 941	packet->data[0] = 0x05;
 942	packet->data[1] = 0x20;
 943	packet->data[2] = xpad->odata_serial++; /* packet serial */
 944	packet->data[3] = 0x01; /* rumble bit enable?  */
 945	packet->data[4] = 0x00;
 946	packet->len = 5;
 947	packet->pending = true;
 948
 949	/* Reset the sequence so we send out start packet first */
 950	xpad->last_out_packet = -1;
 951	retval = xpad_try_sending_next_out_packet(xpad);
 952
 953	spin_unlock_irqrestore(&xpad->odata_lock, flags);
 954
 955	return retval;
 956}
 957
 958#ifdef CONFIG_JOYSTICK_XPAD_FF
 959static int xpad_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
 960{
 961	struct usb_xpad *xpad = input_get_drvdata(dev);
 962	struct xpad_output_packet *packet = &xpad->out_packets[XPAD_OUT_FF_IDX];
 963	__u16 strong;
 964	__u16 weak;
 965	int retval;
 966	unsigned long flags;
 967
 968	if (effect->type != FF_RUMBLE)
 969		return 0;
 970
 971	strong = effect->u.rumble.strong_magnitude;
 972	weak = effect->u.rumble.weak_magnitude;
 973
 974	spin_lock_irqsave(&xpad->odata_lock, flags);
 975
 976	switch (xpad->xtype) {
 977	case XTYPE_XBOX:
 978		packet->data[0] = 0x00;
 979		packet->data[1] = 0x06;
 980		packet->data[2] = 0x00;
 981		packet->data[3] = strong / 256;	/* left actuator */
 982		packet->data[4] = 0x00;
 983		packet->data[5] = weak / 256;	/* right actuator */
 984		packet->len = 6;
 985		packet->pending = true;
 986		break;
 987
 988	case XTYPE_XBOX360:
 989		packet->data[0] = 0x00;
 990		packet->data[1] = 0x08;
 991		packet->data[2] = 0x00;
 992		packet->data[3] = strong / 256;  /* left actuator? */
 993		packet->data[4] = weak / 256;	/* right actuator? */
 994		packet->data[5] = 0x00;
 995		packet->data[6] = 0x00;
 996		packet->data[7] = 0x00;
 997		packet->len = 8;
 998		packet->pending = true;
 999		break;
1000
1001	case XTYPE_XBOX360W:
1002		packet->data[0] = 0x00;
1003		packet->data[1] = 0x01;
1004		packet->data[2] = 0x0F;
1005		packet->data[3] = 0xC0;
1006		packet->data[4] = 0x00;
1007		packet->data[5] = strong / 256;
1008		packet->data[6] = weak / 256;
1009		packet->data[7] = 0x00;
1010		packet->data[8] = 0x00;
1011		packet->data[9] = 0x00;
1012		packet->data[10] = 0x00;
1013		packet->data[11] = 0x00;
1014		packet->len = 12;
1015		packet->pending = true;
1016		break;
1017
1018	case XTYPE_XBOXONE:
1019		packet->data[0] = 0x09; /* activate rumble */
1020		packet->data[1] = 0x08;
1021		packet->data[2] = xpad->odata_serial++;
1022		packet->data[3] = 0x08; /* continuous effect */
1023		packet->data[4] = 0x00; /* simple rumble mode */
1024		packet->data[5] = 0x03; /* L and R actuator only */
1025		packet->data[6] = 0x00; /* TODO: LT actuator */
1026		packet->data[7] = 0x00; /* TODO: RT actuator */
1027		packet->data[8] = strong / 512;	/* left actuator */
1028		packet->data[9] = weak / 512;	/* right actuator */
1029		packet->data[10] = 0x80;	/* length of pulse */
1030		packet->data[11] = 0x00;	/* stop period of pulse */
1031		packet->data[12] = 0x00;
1032		packet->len = 13;
1033		packet->pending = true;
1034		break;
1035
1036	default:
1037		dev_dbg(&xpad->dev->dev,
1038			"%s - rumble command sent to unsupported xpad type: %d\n",
1039			__func__, xpad->xtype);
1040		retval = -EINVAL;
1041		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1042	}
1043
1044	retval = xpad_try_sending_next_out_packet(xpad);
1045
1046out:
1047	spin_unlock_irqrestore(&xpad->odata_lock, flags);
1048	return retval;
1049}
1050
1051static int xpad_init_ff(struct usb_xpad *xpad)
1052{
1053	if (xpad->xtype == XTYPE_UNKNOWN)
1054		return 0;
1055
1056	input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);
1057
1058	return input_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
1059}
1060
1061#else
1062static int xpad_init_ff(struct usb_xpad *xpad) { return 0; }
1063#endif
1064
1065#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
1066#include <linux/leds.h>
1067#include <linux/idr.h>
1068
1069static DEFINE_IDA(xpad_pad_seq);
1070
1071struct xpad_led {
1072	char name[16];
1073	struct led_classdev led_cdev;
1074	struct usb_xpad *xpad;
1075};
1076
1077/**
1078 * set the LEDs on Xbox360 / Wireless Controllers
1079 * @param command
1080 *  0: off
1081 *  1: all blink, then previous setting
1082 *  2: 1/top-left blink, then on
1083 *  3: 2/top-right blink, then on
1084 *  4: 3/bottom-left blink, then on
1085 *  5: 4/bottom-right blink, then on
1086 *  6: 1/top-left on
1087 *  7: 2/top-right on
1088 *  8: 3/bottom-left on
1089 *  9: 4/bottom-right on
1090 * 10: rotate
1091 * 11: blink, based on previous setting
1092 * 12: slow blink, based on previous setting
1093 * 13: rotate with two lights
1094 * 14: persistent slow all blink
1095 * 15: blink once, then previous setting
1096 */
1097static void xpad_send_led_command(struct usb_xpad *xpad, int command)
1098{
1099	struct xpad_output_packet *packet =
1100			&xpad->out_packets[XPAD_OUT_LED_IDX];
1101	unsigned long flags;
1102
1103	command %= 16;
1104
1105	spin_lock_irqsave(&xpad->odata_lock, flags);
1106
1107	switch (xpad->xtype) {
1108	case XTYPE_XBOX360:
1109		packet->data[0] = 0x01;
1110		packet->data[1] = 0x03;
1111		packet->data[2] = command;
1112		packet->len = 3;
1113		packet->pending = true;
1114		break;
1115
1116	case XTYPE_XBOX360W:
1117		packet->data[0] = 0x00;
1118		packet->data[1] = 0x00;
1119		packet->data[2] = 0x08;
1120		packet->data[3] = 0x40 + command;
1121		packet->data[4] = 0x00;
1122		packet->data[5] = 0x00;
1123		packet->data[6] = 0x00;
1124		packet->data[7] = 0x00;
1125		packet->data[8] = 0x00;
1126		packet->data[9] = 0x00;
1127		packet->data[10] = 0x00;
1128		packet->data[11] = 0x00;
1129		packet->len = 12;
1130		packet->pending = true;
1131		break;
1132	}
1133
1134	xpad_try_sending_next_out_packet(xpad);
1135
1136	spin_unlock_irqrestore(&xpad->odata_lock, flags);
1137}
1138
1139/*
1140 * Light up the segment corresponding to the pad number on
1141 * Xbox 360 Controllers.
1142 */
1143static void xpad_identify_controller(struct usb_xpad *xpad)
1144{
1145	led_set_brightness(&xpad->led->led_cdev, (xpad->pad_nr % 4) + 2);
1146}
1147
1148static void xpad_led_set(struct led_classdev *led_cdev,
1149			 enum led_brightness value)
1150{
1151	struct xpad_led *xpad_led = container_of(led_cdev,
1152						 struct xpad_led, led_cdev);
1153
1154	xpad_send_led_command(xpad_led->xpad, value);
1155}
1156
1157static int xpad_led_probe(struct usb_xpad *xpad)
1158{
 
 
1159	struct xpad_led *led;
1160	struct led_classdev *led_cdev;
1161	int error;
1162
1163	if (xpad->xtype != XTYPE_XBOX360 && xpad->xtype != XTYPE_XBOX360W)
1164		return 0;
1165
1166	xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
1167	if (!led)
1168		return -ENOMEM;
1169
1170	xpad->pad_nr = ida_simple_get(&xpad_pad_seq, 0, 0, GFP_KERNEL);
1171	if (xpad->pad_nr < 0) {
1172		error = xpad->pad_nr;
1173		goto err_free_mem;
1174	}
1175
1176	snprintf(led->name, sizeof(led->name), "xpad%d", xpad->pad_nr);
1177	led->xpad = xpad;
1178
1179	led_cdev = &led->led_cdev;
1180	led_cdev->name = led->name;
1181	led_cdev->brightness_set = xpad_led_set;
1182
1183	error = led_classdev_register(&xpad->udev->dev, led_cdev);
1184	if (error)
1185		goto err_free_id;
 
 
 
1186
1187	xpad_identify_controller(xpad);
 
 
 
1188
1189	return 0;
1190
1191err_free_id:
1192	ida_simple_remove(&xpad_pad_seq, xpad->pad_nr);
1193err_free_mem:
1194	kfree(led);
1195	xpad->led = NULL;
1196	return error;
1197}
1198
1199static void xpad_led_disconnect(struct usb_xpad *xpad)
1200{
1201	struct xpad_led *xpad_led = xpad->led;
1202
1203	if (xpad_led) {
1204		led_classdev_unregister(&xpad_led->led_cdev);
1205		ida_simple_remove(&xpad_pad_seq, xpad->pad_nr);
1206		kfree(xpad_led);
1207	}
1208}
1209#else
1210static int xpad_led_probe(struct usb_xpad *xpad) { return 0; }
1211static void xpad_led_disconnect(struct usb_xpad *xpad) { }
1212#endif
1213
1214static int xpad_start_input(struct usb_xpad *xpad)
1215{
1216	int error;
1217
1218	if (usb_submit_urb(xpad->irq_in, GFP_KERNEL))
1219		return -EIO;
1220
1221	if (xpad->xtype == XTYPE_XBOXONE) {
1222		error = xpad_start_xbox_one(xpad);
1223		if (error) {
1224			usb_kill_urb(xpad->irq_in);
1225			return error;
1226		}
1227	}
1228
1229	return 0;
1230}
1231
1232static void xpad_stop_input(struct usb_xpad *xpad)
1233{
1234	usb_kill_urb(xpad->irq_in);
1235}
1236
1237static int xpad360w_start_input(struct usb_xpad *xpad)
1238{
1239	int error;
1240
1241	error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);
1242	if (error)
1243		return -EIO;
1244
1245	/*
1246	 * Send presence packet.
1247	 * This will force the controller to resend connection packets.
1248	 * This is useful in the case we activate the module after the
1249	 * adapter has been plugged in, as it won't automatically
1250	 * send us info about the controllers.
1251	 */
1252	error = xpad_inquiry_pad_presence(xpad);
1253	if (error) {
1254		usb_kill_urb(xpad->irq_in);
1255		return error;
1256	}
1257
1258	return 0;
1259}
1260
1261static void xpad360w_stop_input(struct usb_xpad *xpad)
1262{
1263	usb_kill_urb(xpad->irq_in);
1264
1265	/* Make sure we are done with presence work if it was scheduled */
1266	flush_work(&xpad->work);
1267}
1268
1269static int xpad_open(struct input_dev *dev)
1270{
1271	struct usb_xpad *xpad = input_get_drvdata(dev);
1272
1273	return xpad_start_input(xpad);
1274}
1275
1276static void xpad_close(struct input_dev *dev)
1277{
1278	struct usb_xpad *xpad = input_get_drvdata(dev);
1279
1280	xpad_stop_input(xpad);
 
 
 
1281}
1282
1283static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs)
1284{
1285	struct usb_xpad *xpad = input_get_drvdata(input_dev);
1286	set_bit(abs, input_dev->absbit);
1287
1288	switch (abs) {
1289	case ABS_X:
1290	case ABS_Y:
1291	case ABS_RX:
1292	case ABS_RY:	/* the two sticks */
1293		input_set_abs_params(input_dev, abs, -32768, 32767, 16, 128);
1294		break;
1295	case ABS_Z:
1296	case ABS_RZ:	/* the triggers (if mapped to axes) */
1297		if (xpad->xtype == XTYPE_XBOXONE)
1298			input_set_abs_params(input_dev, abs, 0, 1023, 0, 0);
1299		else
1300			input_set_abs_params(input_dev, abs, 0, 255, 0, 0);
1301		break;
1302	case ABS_HAT0X:
1303	case ABS_HAT0Y:	/* the d-pad (only if dpad is mapped to axes */
1304		input_set_abs_params(input_dev, abs, -1, 1, 0, 0);
1305		break;
1306	}
1307}
1308
1309static void xpad_deinit_input(struct usb_xpad *xpad)
1310{
1311	if (xpad->input_created) {
1312		xpad->input_created = false;
1313		xpad_led_disconnect(xpad);
1314		input_unregister_device(xpad->dev);
1315	}
1316}
1317
1318static int xpad_init_input(struct usb_xpad *xpad)
1319{
 
 
1320	struct input_dev *input_dev;
 
1321	int i, error;
1322
 
 
 
 
 
 
 
1323	input_dev = input_allocate_device();
1324	if (!input_dev)
1325		return -ENOMEM;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1326
1327	xpad->dev = input_dev;
1328	input_dev->name = xpad->name;
 
 
 
1329	input_dev->phys = xpad->phys;
1330	usb_to_input_id(xpad->udev, &input_dev->id);
1331	input_dev->dev.parent = &xpad->intf->dev;
1332
1333	input_set_drvdata(input_dev, xpad);
1334
1335	if (xpad->xtype != XTYPE_XBOX360W) {
1336		input_dev->open = xpad_open;
1337		input_dev->close = xpad_close;
1338	}
1339
1340	__set_bit(EV_KEY, input_dev->evbit);
1341
1342	if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
1343		__set_bit(EV_ABS, input_dev->evbit);
1344		/* set up axes */
1345		for (i = 0; xpad_abs[i] >= 0; i++)
1346			xpad_set_up_abs(input_dev, xpad_abs[i]);
1347	}
1348
1349	/* set up standard buttons */
1350	for (i = 0; xpad_common_btn[i] >= 0; i++)
1351		__set_bit(xpad_common_btn[i], input_dev->keybit);
1352
1353	/* set up model-specific ones */
1354	if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX360W ||
1355	    xpad->xtype == XTYPE_XBOXONE) {
1356		for (i = 0; xpad360_btn[i] >= 0; i++)
1357			__set_bit(xpad360_btn[i], input_dev->keybit);
1358	} else {
1359		for (i = 0; xpad_btn[i] >= 0; i++)
1360			__set_bit(xpad_btn[i], input_dev->keybit);
1361	}
1362
1363	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
1364		for (i = 0; xpad_btn_pad[i] >= 0; i++)
1365			__set_bit(xpad_btn_pad[i], input_dev->keybit);
1366	}
1367
1368	/*
1369	 * This should be a simple else block. However historically
1370	 * xbox360w has mapped DPAD to buttons while xbox360 did not. This
1371	 * made no sense, but now we can not just switch back and have to
1372	 * support both behaviors.
1373	 */
1374	if (!(xpad->mapping & MAP_DPAD_TO_BUTTONS) ||
1375	    xpad->xtype == XTYPE_XBOX360W) {
1376		for (i = 0; xpad_abs_pad[i] >= 0; i++)
1377			xpad_set_up_abs(input_dev, xpad_abs_pad[i]);
1378	}
1379
1380	if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
1381		for (i = 0; xpad_btn_triggers[i] >= 0; i++)
1382			__set_bit(xpad_btn_triggers[i], input_dev->keybit);
1383	} else {
1384		for (i = 0; xpad_abs_triggers[i] >= 0; i++)
1385			xpad_set_up_abs(input_dev, xpad_abs_triggers[i]);
1386	}
1387
 
 
 
 
1388	error = xpad_init_ff(xpad);
1389	if (error)
1390		goto err_free_input;
1391
1392	error = xpad_led_probe(xpad);
1393	if (error)
1394		goto err_destroy_ff;
 
 
 
 
 
 
 
 
1395
1396	error = input_register_device(xpad->dev);
1397	if (error)
1398		goto err_disconnect_led;
1399
1400	xpad->input_created = true;
1401	return 0;
1402
1403err_disconnect_led:
1404	xpad_led_disconnect(xpad);
1405err_destroy_ff:
1406	input_ff_destroy(input_dev);
1407err_free_input:
1408	input_free_device(input_dev);
1409	return error;
1410}
1411
1412static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id)
1413{
1414	struct usb_device *udev = interface_to_usbdev(intf);
1415	struct usb_xpad *xpad;
1416	struct usb_endpoint_descriptor *ep_irq_in;
1417	int ep_irq_in_idx;
1418	int i, error;
1419
1420	for (i = 0; xpad_device[i].idVendor; i++) {
1421		if ((le16_to_cpu(udev->descriptor.idVendor) == xpad_device[i].idVendor) &&
1422		    (le16_to_cpu(udev->descriptor.idProduct) == xpad_device[i].idProduct))
1423			break;
1424	}
1425
1426	if (xpad_device[i].xtype == XTYPE_XBOXONE &&
1427	    intf->cur_altsetting->desc.bInterfaceNumber != 0) {
1428		/*
1429		 * The Xbox One controller lists three interfaces all with the
1430		 * same interface class, subclass and protocol. Differentiate by
1431		 * interface number.
1432		 */
1433		return -ENODEV;
1434	}
1435
1436	xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);
1437	if (!xpad)
1438		return -ENOMEM;
1439
1440	usb_make_path(udev, xpad->phys, sizeof(xpad->phys));
1441	strlcat(xpad->phys, "/input0", sizeof(xpad->phys));
1442
1443	xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN,
1444					 GFP_KERNEL, &xpad->idata_dma);
1445	if (!xpad->idata) {
1446		error = -ENOMEM;
1447		goto err_free_mem;
1448	}
1449
1450	xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);
1451	if (!xpad->irq_in) {
1452		error = -ENOMEM;
1453		goto err_free_idata;
1454	}
1455
1456	xpad->udev = udev;
1457	xpad->intf = intf;
1458	xpad->mapping = xpad_device[i].mapping;
1459	xpad->xtype = xpad_device[i].xtype;
1460	xpad->name = xpad_device[i].name;
1461	INIT_WORK(&xpad->work, xpad_presence_work);
1462
1463	if (xpad->xtype == XTYPE_UNKNOWN) {
1464		if (intf->cur_altsetting->desc.bInterfaceClass == USB_CLASS_VENDOR_SPEC) {
1465			if (intf->cur_altsetting->desc.bInterfaceProtocol == 129)
1466				xpad->xtype = XTYPE_XBOX360W;
1467			else
1468				xpad->xtype = XTYPE_XBOX360;
1469		} else {
1470			xpad->xtype = XTYPE_XBOX;
1471		}
1472
1473		if (dpad_to_buttons)
1474			xpad->mapping |= MAP_DPAD_TO_BUTTONS;
1475		if (triggers_to_buttons)
1476			xpad->mapping |= MAP_TRIGGERS_TO_BUTTONS;
1477		if (sticks_to_null)
1478			xpad->mapping |= MAP_STICKS_TO_NULL;
1479	}
1480
1481	error = xpad_init_output(intf, xpad);
1482	if (error)
1483		goto err_free_in_urb;
1484
1485	/* Xbox One controller has in/out endpoints swapped. */
1486	ep_irq_in_idx = xpad->xtype == XTYPE_XBOXONE ? 1 : 0;
1487	ep_irq_in = &intf->cur_altsetting->endpoint[ep_irq_in_idx].desc;
1488
1489	usb_fill_int_urb(xpad->irq_in, udev,
1490			 usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),
1491			 xpad->idata, XPAD_PKT_LEN, xpad_irq_in,
1492			 xpad, ep_irq_in->bInterval);
1493	xpad->irq_in->transfer_dma = xpad->idata_dma;
1494	xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
 
 
 
 
 
 
 
1495
1496	usb_set_intfdata(intf, xpad);
 
 
 
1497
1498	if (xpad->xtype == XTYPE_XBOX360W) {
1499		/*
1500		 * Submit the int URB immediately rather than waiting for open
1501		 * because we get status messages from the device whether
1502		 * or not any controllers are attached.  In fact, it's
1503		 * exactly the message that a controller has arrived that
1504		 * we're waiting for.
1505		 */
1506		error = xpad360w_start_input(xpad);
 
1507		if (error)
1508			goto err_deinit_output;
1509		/*
1510		 * Wireless controllers require RESET_RESUME to work properly
1511		 * after suspend. Ideally this quirk should be in usb core
1512		 * quirk list, but we have too many vendors producing these
1513		 * controllers and we'd need to maintain 2 identical lists
1514		 * here in this driver and in usb core.
1515		 */
1516		udev->quirks |= USB_QUIRK_RESET_RESUME;
1517	} else {
1518		error = xpad_init_input(xpad);
1519		if (error)
1520			goto err_deinit_output;
1521	}
 
1522	return 0;
1523
1524err_deinit_output:
1525	xpad_deinit_output(xpad);
1526err_free_in_urb:
1527	usb_free_urb(xpad->irq_in);
1528err_free_idata:
1529	usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
1530err_free_mem:
 
 
 
 
1531	kfree(xpad);
1532	return error;
 
1533}
1534
1535static void xpad_disconnect(struct usb_interface *intf)
1536{
1537	struct usb_xpad *xpad = usb_get_intfdata(intf);
1538
1539	if (xpad->xtype == XTYPE_XBOX360W)
1540		xpad360w_stop_input(xpad);
1541
1542	xpad_deinit_input(xpad);
1543
1544	/*
1545	 * Now that both input device and LED device are gone we can
1546	 * stop output URB.
1547	 */
1548	xpad_stop_output(xpad);
1549
 
 
1550	xpad_deinit_output(xpad);
1551
 
 
 
 
 
 
1552	usb_free_urb(xpad->irq_in);
1553	usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
1554			xpad->idata, xpad->idata_dma);
1555
 
1556	kfree(xpad);
1557
1558	usb_set_intfdata(intf, NULL);
1559}
1560
1561static int xpad_suspend(struct usb_interface *intf, pm_message_t message)
1562{
1563	struct usb_xpad *xpad = usb_get_intfdata(intf);
1564	struct input_dev *input = xpad->dev;
1565
1566	if (xpad->xtype == XTYPE_XBOX360W) {
1567		/*
1568		 * Wireless controllers always listen to input so
1569		 * they are notified when controller shows up
1570		 * or goes away.
1571		 */
1572		xpad360w_stop_input(xpad);
1573	} else {
1574		mutex_lock(&input->mutex);
1575		if (input->users)
1576			xpad_stop_input(xpad);
1577		mutex_unlock(&input->mutex);
1578	}
1579
1580	xpad_stop_output(xpad);
1581
1582	return 0;
1583}
1584
1585static int xpad_resume(struct usb_interface *intf)
1586{
1587	struct usb_xpad *xpad = usb_get_intfdata(intf);
1588	struct input_dev *input = xpad->dev;
1589	int retval = 0;
1590
1591	if (xpad->xtype == XTYPE_XBOX360W) {
1592		retval = xpad360w_start_input(xpad);
1593	} else {
1594		mutex_lock(&input->mutex);
1595		if (input->users)
1596			retval = xpad_start_input(xpad);
1597		mutex_unlock(&input->mutex);
1598	}
1599
1600	return retval;
1601}
1602
1603static struct usb_driver xpad_driver = {
1604	.name		= "xpad",
1605	.probe		= xpad_probe,
1606	.disconnect	= xpad_disconnect,
1607	.suspend	= xpad_suspend,
1608	.resume		= xpad_resume,
1609	.reset_resume	= xpad_resume,
1610	.id_table	= xpad_table,
1611};
1612
1613module_usb_driver(xpad_driver);
1614
1615MODULE_AUTHOR(DRIVER_AUTHOR);
1616MODULE_DESCRIPTION(DRIVER_DESC);
1617MODULE_LICENSE("GPL");