xpad.c 35.8 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * X-Box gamepad driver
L
Linus Torvalds 已提交
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>
D
Dominic Cerquetti 已提交
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>
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
34 35 36 37 38
 *
 * Thanks to:
 *  - ITO Takayuki for providing essential xpad information on his website
 *  - Vojtech Pavlik     - iforce driver / input subsystem
 *  - Greg Kroah-Hartman - usb-skeleton driver
39
 *  - XBOX Linux project - extra USB id's
L
Linus Torvalds 已提交
40 41
 *
 * TODO:
D
Dominic Cerquetti 已提交
42
 *  - fine tune axes (especially trigger axes)
L
Linus Torvalds 已提交
43 44
 *  - fix "analog" buttons (reported as digital now)
 *  - get rumble working
D
Dominic Cerquetti 已提交
45
 *  - need USB IDs for other dance pads
L
Linus Torvalds 已提交
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
 *
 * 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
65 66 67 68 69 70 71
 *
 * 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
72 73
 *
 * Later changes can be tracked in SCM.
L
Linus Torvalds 已提交
74 75 76 77
 */

#include <linux/kernel.h>
#include <linux/slab.h>
D
Dominic Cerquetti 已提交
78
#include <linux/stat.h>
L
Linus Torvalds 已提交
79
#include <linux/module.h>
80
#include <linux/usb/input.h>
L
Linus Torvalds 已提交
81 82 83 84 85 86

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

#define XPAD_PKT_LEN 32

D
Dominic Cerquetti 已提交
87 88
/* xbox d-pads should map to buttons, as is required for DDR pads
   but we map them to axes when possible to simplify things */
89 90
#define MAP_DPAD_TO_BUTTONS		(1 << 0)
#define MAP_TRIGGERS_TO_BUTTONS		(1 << 1)
91 92 93
#define MAP_STICKS_TO_NULL		(1 << 2)
#define DANCEPAD_MAP_CONFIG	(MAP_DPAD_TO_BUTTONS |			\
				MAP_TRIGGERS_TO_BUTTONS | MAP_STICKS_TO_NULL)
D
Dominic Cerquetti 已提交
94

95 96
#define XTYPE_XBOX        0
#define XTYPE_XBOX360     1
97
#define XTYPE_XBOX360W    2
98 99
#define XTYPE_XBOXONE     3
#define XTYPE_UNKNOWN     4
100

101
static bool dpad_to_buttons;
D
Dominic Cerquetti 已提交
102 103 104
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");

105
static bool triggers_to_buttons;
106 107 108
module_param(triggers_to_buttons, bool, S_IRUGO);
MODULE_PARM_DESC(triggers_to_buttons, "Map triggers to buttons rather than axes for unknown pads");

109
static bool sticks_to_null;
110 111 112
module_param(sticks_to_null, bool, S_IRUGO);
MODULE_PARM_DESC(sticks_to_null, "Do not map sticks at all for unknown pads");

113
static const struct xpad_device {
L
Linus Torvalds 已提交
114 115 116
	u16 idVendor;
	u16 idProduct;
	char *name;
117
	u8 mapping;
118
	u8 xtype;
L
Linus Torvalds 已提交
119
} xpad_device[] = {
120 121 122
	{ 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 },
123 124
	{ 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", 0, XTYPE_XBOX },
	{ 0x045e, 0x028e, "Microsoft X-Box 360 pad", 0, XTYPE_XBOX360 },
125
	{ 0x045e, 0x02d1, "Microsoft X-Box One pad", 0, XTYPE_XBOXONE },
126
	{ 0x045e, 0x0291, "Xbox 360 Wireless Receiver (XBOX)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
127
	{ 0x045e, 0x0719, "Xbox 360 Wireless Receiver", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
128
	{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },
129 130
	{ 0x046d, 0xc21d, "Logitech Gamepad F310", 0, XTYPE_XBOX360 },
	{ 0x046d, 0xc21f, "Logitech Gamepad F710", 0, XTYPE_XBOX360 },
131 132 133 134 135 136 137 138 139
	{ 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 },
140
	{ 0x0738, 0x4540, "Mad Catz Beat Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
141 142
	{ 0x0738, 0x4556, "Mad Catz Lynx Wireless Controller", 0, XTYPE_XBOX },
	{ 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
143
	{ 0x0738, 0x4728, "Mad Catz Street Fighter IV FightPad", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
144
	{ 0x0738, 0x4738, "Mad Catz Wired Xbox 360 Controller (SFIV)", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
145
	{ 0x0738, 0x6040, "Mad Catz Beat Pad Pro", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
146
	{ 0x0738, 0xbeef, "Mad Catz JOYTECH NEO SE Advanced GamePad", XTYPE_XBOX360 },
147
	{ 0x0c12, 0x8802, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
148
	{ 0x0c12, 0x8809, "RedOctane Xbox Dance Pad", DANCEPAD_MAP_CONFIG, XTYPE_XBOX },
149 150 151
	{ 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 },
152
	{ 0x0d2f, 0x0002, "Andamiro Pump It Up pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
153 154 155 156 157
	{ 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 },
158
	{ 0x0e6f, 0x0105, "HSM3 Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
159
	{ 0x0e6f, 0x0201, "Pelican PL-3601 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
160
	{ 0x0e6f, 0x0213, "Afterglow Gamepad for Xbox 360", 0, XTYPE_XBOX360 },
161
	{ 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", 0, XTYPE_XBOX },
162 163
	{ 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 },
164 165 166
	{ 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 },
167
	{ 0x12ab, 0x0004, "Honey Bee Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
168
	{ 0x12ab, 0x8809, "Xbox DDR dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
169
	{ 0x1430, 0x4748, "RedOctane Guitar Hero X-plorer", 0, XTYPE_XBOX360 },
170
	{ 0x1430, 0x8888, "TX6500+ Dance Pad (first generation)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
171
	{ 0x146b, 0x0601, "BigBen Interactive XBOX 360 Controller", 0, XTYPE_XBOX360 },
172 173
	{ 0x1689, 0xfd00, "Razer Onza Tournament Edition", 0, XTYPE_XBOX360 },
	{ 0x1689, 0xfd01, "Razer Onza Classic Edition", 0, XTYPE_XBOX360 },
174
	{ 0x24c6, 0x5d04, "Razer Sabertooth", 0, XTYPE_XBOX360 },
175
	{ 0x1bad, 0x0002, "Harmonix Rock Band Guitar", 0, XTYPE_XBOX360 },
176
	{ 0x1bad, 0x0003, "Harmonix Rock Band Drumkit", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
177 178 179 180 181
	{ 0x1bad, 0xf016, "Mad Catz Xbox 360 Controller", 0, XTYPE_XBOX360 },
	{ 0x1bad, 0xf028, "Street Fighter IV FightPad", 0, XTYPE_XBOX360 },
	{ 0x1bad, 0xf901, "Gamestop Xbox 360 Controller", 0, XTYPE_XBOX360 },
	{ 0x1bad, 0xf903, "Tron Xbox 360 controller", 0, XTYPE_XBOX360 },
	{ 0x24c6, 0x5300, "PowerA MINI PROEX Controller", 0, XTYPE_XBOX360 },
182 183
	{ 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX },
	{ 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN }
L
Linus Torvalds 已提交
184 185
};

186 187 188
/* buttons shared with xbox and xbox360 */
static const signed short xpad_common_btn[] = {
	BTN_A, BTN_B, BTN_X, BTN_Y,			/* "analog" buttons */
189
	BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR,	/* start/back/sticks */
L
Linus Torvalds 已提交
190 191 192
	-1						/* terminating entry */
};

193 194 195 196 197 198
/* original xbox controllers only */
static const signed short xpad_btn[] = {
	BTN_C, BTN_Z,		/* "analog" buttons */
	-1			/* terminating entry */
};

199
/* used when dpad is mapped to buttons */
D
Dominic Cerquetti 已提交
200
static const signed short xpad_btn_pad[] = {
201 202
	BTN_TRIGGER_HAPPY1, BTN_TRIGGER_HAPPY2,		/* d-pad left, right */
	BTN_TRIGGER_HAPPY3, BTN_TRIGGER_HAPPY4,		/* d-pad up, down */
D
Dominic Cerquetti 已提交
203 204 205
	-1				/* terminating entry */
};

206 207 208 209 210 211 212
/* used when triggers are mapped to buttons */
static const signed short xpad_btn_triggers[] = {
	BTN_TL2, BTN_TR2,		/* triggers left/right */
	-1
};


213 214 215 216 217 218
static const signed short xpad360_btn[] = {  /* buttons for x360 controller */
	BTN_TL, BTN_TR,		/* Button LB/RB */
	BTN_MODE,		/* The big X button */
	-1
};

219
static const signed short xpad_abs[] = {
L
Linus Torvalds 已提交
220 221
	ABS_X, ABS_Y,		/* left stick */
	ABS_RX, ABS_RY,		/* right stick */
D
Dominic Cerquetti 已提交
222 223 224
	-1			/* terminating entry */
};

225
/* used when dpad is mapped to axes */
D
Dominic Cerquetti 已提交
226 227
static const signed short xpad_abs_pad[] = {
	ABS_HAT0X, ABS_HAT0Y,	/* d-pad axes */
L
Linus Torvalds 已提交
228 229 230
	-1			/* terminating entry */
};

231 232 233 234 235 236
/* used when triggers are mapped to axes */
static const signed short xpad_abs_triggers[] = {
	ABS_Z, ABS_RZ,		/* triggers left/right */
	-1
};

237 238
/*
 * Xbox 360 has a vendor-specific class, so we cannot match it with only
239
 * USB_INTERFACE_INFO (also specifically refused by USB subsystem), so we
240
 * match against vendor id as well. Wired Xbox 360 devices have protocol 1,
241 242
 * wireless controllers have protocol 129.
 */
243
#define XPAD_XBOX360_VENDOR_PROTOCOL(vend,pr) \
244 245 246 247
	.match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO, \
	.idVendor = (vend), \
	.bInterfaceClass = USB_CLASS_VENDOR_SPEC, \
	.bInterfaceSubClass = 93, \
248 249 250 251
	.bInterfaceProtocol = (pr)
#define XPAD_XBOX360_VENDOR(vend) \
	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,1) }, \
	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,129) }
252

253 254 255 256 257 258 259 260 261 262
/* 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) }

263
static struct usb_device_id xpad_table[] = {
L
Linus Torvalds 已提交
264
	{ USB_INTERFACE_INFO('X', 'B', 0) },	/* X-Box USB-IF not approved class */
265
	XPAD_XBOX360_VENDOR(0x045e),		/* Microsoft X-Box 360 controllers */
266
	XPAD_XBOXONE_VENDOR(0x045e),		/* Microsoft X-Box One controllers */
267 268
	XPAD_XBOX360_VENDOR(0x046d),		/* Logitech X-Box 360 style controllers */
	XPAD_XBOX360_VENDOR(0x0738),		/* Mad Catz X-Box 360 controllers */
269
	{ USB_DEVICE(0x0738, 0x4540) },		/* Mad Catz Beat Pad */
270
	XPAD_XBOX360_VENDOR(0x0e6f),		/* 0x0e6f X-Box 360 controllers */
271
	XPAD_XBOX360_VENDOR(0x12ab),		/* X-Box 360 dance pads */
272
	XPAD_XBOX360_VENDOR(0x1430),		/* RedOctane X-Box 360 controllers */
273
	XPAD_XBOX360_VENDOR(0x146b),		/* BigBen Interactive Controllers */
274
	XPAD_XBOX360_VENDOR(0x1bad),		/* Harminix Rock Band Guitar and Drums */
275 276
	XPAD_XBOX360_VENDOR(0x0f0d),		/* Hori Controllers */
	XPAD_XBOX360_VENDOR(0x1689),		/* Razer Onza */
277
	XPAD_XBOX360_VENDOR(0x24c6),		/* PowerA Controllers */
L
Linus Torvalds 已提交
278 279 280
	{ }
};

281
MODULE_DEVICE_TABLE(usb, xpad_table);
L
Linus Torvalds 已提交
282 283

struct usb_xpad {
D
Dominic Cerquetti 已提交
284 285
	struct input_dev *dev;		/* input device interface */
	struct usb_device *udev;	/* usb device */
286
	struct usb_interface *intf;	/* usb interface */
287

288 289
	int pad_present;

D
Dominic Cerquetti 已提交
290 291
	struct urb *irq_in;		/* urb for interrupt in report */
	unsigned char *idata;		/* input data */
L
Linus Torvalds 已提交
292
	dma_addr_t idata_dma;
293

294 295 296
	struct urb *bulk_out;
	unsigned char *bdata;

297 298 299
	struct urb *irq_out;		/* urb for interrupt out report */
	unsigned char *odata;		/* output data */
	dma_addr_t odata_dma;
300 301 302 303
	struct mutex odata_mutex;

#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
	struct xpad_led *led;
304 305
#endif

306
	char phys[64];			/* physical device path */
D
Dominic Cerquetti 已提交
307

308
	int mapping;			/* map d-pad to buttons or to axes */
309
	int xtype;			/* type of xbox device */
L
Linus Torvalds 已提交
310 311 312 313 314 315 316 317 318 319 320 321
};

/*
 *	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
 */

322
static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
L
Linus Torvalds 已提交
323
{
324
	struct input_dev *dev = xpad->dev;
L
Linus Torvalds 已提交
325

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

L
Linus Torvalds 已提交
340
	/* triggers left/right */
341 342 343 344 345 346 347
	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]);
	}
348

L
Linus Torvalds 已提交
349
	/* digital pad */
350
	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
351 352 353 354 355
		/* 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);
356 357 358 359 360
	} 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));
D
Dominic Cerquetti 已提交
361
	}
362

L
Linus Torvalds 已提交
363
	/* start/back buttons and stick press left/right */
D
Dominic Cerquetti 已提交
364
	input_report_key(dev, BTN_START,  data[2] & 0x10);
365
	input_report_key(dev, BTN_SELECT, data[2] & 0x20);
D
Dominic Cerquetti 已提交
366 367
	input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
	input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
368

L
Linus Torvalds 已提交
369 370 371 372 373
	/* "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]);
374

L
Linus Torvalds 已提交
375 376 377 378 379 380 381
	/* "analog" buttons black, white */
	input_report_key(dev, BTN_C, data[8]);
	input_report_key(dev, BTN_Z, data[9]);

	input_sync(dev);
}

382 383 384 385 386 387 388 389 390 391
/*
 *	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
 */

392 393
static void xpad360_process_packet(struct usb_xpad *xpad,
				   u16 cmd, unsigned char *data)
394 395 396 397
{
	struct input_dev *dev = xpad->dev;

	/* digital pad */
398
	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
399 400 401 402 403
		/* 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);
404 405 406 407 408
	} 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));
409 410 411
	}

	/* start/back buttons */
412
	input_report_key(dev, BTN_START,  data[2] & 0x10);
413
	input_report_key(dev, BTN_SELECT, data[2] & 0x20);
414 415 416 417 418 419

	/* 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 */
420 421 422 423 424 425 426
	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);
427

428 429 430 431 432 433 434 435 436 437 438 439 440
	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)));
	}
441 442

	/* triggers left/right */
443 444 445 446 447 448 449
	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]);
	}
450 451 452 453

	input_sync(dev);
}

454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
/*
 * 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)
{
	/* Presence change */
	if (data[0] & 0x08) {
		if (data[1] & 0x80) {
			xpad->pad_present = 1;
			usb_submit_urb(xpad->bulk_out, GFP_ATOMIC);
		} else
			xpad->pad_present = 0;
	}

	/* Valid pad data */
	if (!(data[1] & 0x1))
		return;

	xpad360_process_packet(xpad, cmd, &data[4]);
}

487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
/*
 *	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;
	}
}

586
static void xpad_irq_in(struct urb *urb)
L
Linus Torvalds 已提交
587 588
{
	struct usb_xpad *xpad = urb->context;
589
	struct device *dev = &xpad->intf->dev;
590
	int retval, status;
591

592 593 594
	status = urb->status;

	switch (status) {
L
Linus Torvalds 已提交
595 596 597 598 599 600 601
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
602
		dev_dbg(dev, "%s - urb shutting down with status: %d\n",
603
			__func__, status);
L
Linus Torvalds 已提交
604 605
		return;
	default:
606
		dev_dbg(dev, "%s - nonzero urb status received: %d\n",
607
			__func__, status);
L
Linus Torvalds 已提交
608 609
		goto exit;
	}
610

611 612
	switch (xpad->xtype) {
	case XTYPE_XBOX360:
613
		xpad360_process_packet(xpad, 0, xpad->idata);
614 615 616 617
		break;
	case XTYPE_XBOX360W:
		xpad360w_process_packet(xpad, 0, xpad->idata);
		break;
618 619 620
	case XTYPE_XBOXONE:
		xpadone_process_packet(xpad, 0, xpad->idata);
		break;
621
	default:
622
		xpad_process_packet(xpad, 0, xpad->idata);
623
	}
L
Linus Torvalds 已提交
624 625

exit:
626
	retval = usb_submit_urb(urb, GFP_ATOMIC);
L
Linus Torvalds 已提交
627
	if (retval)
628
		dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
629
			__func__, retval);
L
Linus Torvalds 已提交
630 631
}

632 633
static void xpad_bulk_out(struct urb *urb)
{
634
	struct usb_xpad *xpad = urb->context;
635
	struct device *dev = &xpad->intf->dev;
636

637 638 639 640 641 642 643 644
	switch (urb->status) {
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
645 646
		dev_dbg(dev, "%s - urb shutting down with status: %d\n",
			__func__, urb->status);
647 648
		break;
	default:
649 650
		dev_dbg(dev, "%s - nonzero urb status received: %d\n",
			__func__, urb->status);
651 652 653
	}
}

654 655
static void xpad_irq_out(struct urb *urb)
{
656
	struct usb_xpad *xpad = urb->context;
657
	struct device *dev = &xpad->intf->dev;
658 659 660
	int retval, status;

	status = urb->status;
661

662
	switch (status) {
663
	case 0:
664
		/* success */
665 666 667 668 669 670
		return;

	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
671 672
		dev_dbg(dev, "%s - urb shutting down with status: %d\n",
			__func__, status);
673 674 675
		return;

	default:
676 677
		dev_dbg(dev, "%s - nonzero urb status received: %d\n",
			__func__, status);
678
		goto exit;
679 680 681 682 683
	}

exit:
	retval = usb_submit_urb(urb, GFP_ATOMIC);
	if (retval)
684
		dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
685
			__func__, retval);
686 687
}

688
static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
689 690
{
	struct usb_endpoint_descriptor *ep_irq_out;
691
	int ep_irq_out_idx;
692
	int error;
693

694
	if (xpad->xtype == XTYPE_UNKNOWN)
695 696
		return 0;

697 698
	xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,
					 GFP_KERNEL, &xpad->odata_dma);
699 700
	if (!xpad->odata) {
		error = -ENOMEM;
701
		goto fail1;
702
	}
703

704 705
	mutex_init(&xpad->odata_mutex);

706
	xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
707 708
	if (!xpad->irq_out) {
		error = -ENOMEM;
709
		goto fail2;
710
	}
711

712 713 714 715
	/* 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;

716 717 718 719 720 721 722 723 724
	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;

725
 fail2:	usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
726 727 728
 fail1:	return error;
}

729
static void xpad_stop_output(struct usb_xpad *xpad)
730
{
731
	if (xpad->xtype != XTYPE_UNKNOWN)
732 733 734
		usb_kill_urb(xpad->irq_out);
}

735
static void xpad_deinit_output(struct usb_xpad *xpad)
736
{
737
	if (xpad->xtype != XTYPE_UNKNOWN) {
738
		usb_free_urb(xpad->irq_out);
739
		usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
740 741 742
				xpad->odata, xpad->odata_dma);
	}
}
743 744

#ifdef CONFIG_JOYSTICK_XPAD_FF
745
static int xpad_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
746 747
{
	struct usb_xpad *xpad = input_get_drvdata(dev);
748

749 750 751
	if (effect->type == FF_RUMBLE) {
		__u16 strong = effect->u.rumble.strong_magnitude;
		__u16 weak = effect->u.rumble.weak_magnitude;
752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778

		switch (xpad->xtype) {

		case XTYPE_XBOX:
			xpad->odata[0] = 0x00;
			xpad->odata[1] = 0x06;
			xpad->odata[2] = 0x00;
			xpad->odata[3] = strong / 256;	/* left actuator */
			xpad->odata[4] = 0x00;
			xpad->odata[5] = weak / 256;	/* right actuator */
			xpad->irq_out->transfer_buffer_length = 6;

			return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);

		case XTYPE_XBOX360:
			xpad->odata[0] = 0x00;
			xpad->odata[1] = 0x08;
			xpad->odata[2] = 0x00;
			xpad->odata[3] = strong / 256;  /* left actuator? */
			xpad->odata[4] = weak / 256;	/* right actuator? */
			xpad->odata[5] = 0x00;
			xpad->odata[6] = 0x00;
			xpad->odata[7] = 0x00;
			xpad->irq_out->transfer_buffer_length = 8;

			return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);

779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
		case XTYPE_XBOX360W:
			xpad->odata[0] = 0x00;
			xpad->odata[1] = 0x01;
			xpad->odata[2] = 0x0F;
			xpad->odata[3] = 0xC0;
			xpad->odata[4] = 0x00;
			xpad->odata[5] = strong / 256;
			xpad->odata[6] = weak / 256;
			xpad->odata[7] = 0x00;
			xpad->odata[8] = 0x00;
			xpad->odata[9] = 0x00;
			xpad->odata[10] = 0x00;
			xpad->odata[11] = 0x00;
			xpad->irq_out->transfer_buffer_length = 12;

			return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);

796
		default:
797 798
			dev_dbg(&xpad->dev->dev,
				"%s - rumble command sent to unsupported xpad type: %d\n",
799 800 801
				__func__, xpad->xtype);
			return -1;
		}
802 803 804 805 806 807 808
	}

	return 0;
}

static int xpad_init_ff(struct usb_xpad *xpad)
{
809
	if (xpad->xtype == XTYPE_UNKNOWN || xpad->xtype == XTYPE_XBOXONE)
810 811
		return 0;

812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
	input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);

	return input_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
}

#else
static int xpad_init_ff(struct usb_xpad *xpad) { return 0; }
#endif

#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
#include <linux/leds.h>

struct xpad_led {
	char name[16];
	struct led_classdev led_cdev;
	struct usb_xpad *xpad;
};

static void xpad_send_led_command(struct usb_xpad *xpad, int command)
{
	if (command >= 0 && command < 14) {
		mutex_lock(&xpad->odata_mutex);
		xpad->odata[0] = 0x01;
		xpad->odata[1] = 0x03;
		xpad->odata[2] = command;
837
		xpad->irq_out->transfer_buffer_length = 3;
838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896
		usb_submit_urb(xpad->irq_out, GFP_KERNEL);
		mutex_unlock(&xpad->odata_mutex);
	}
}

static void xpad_led_set(struct led_classdev *led_cdev,
			 enum led_brightness value)
{
	struct xpad_led *xpad_led = container_of(led_cdev,
						 struct xpad_led, led_cdev);

	xpad_send_led_command(xpad_led->xpad, value);
}

static int xpad_led_probe(struct usb_xpad *xpad)
{
	static atomic_t led_seq	= ATOMIC_INIT(0);
	long led_no;
	struct xpad_led *led;
	struct led_classdev *led_cdev;
	int error;

	if (xpad->xtype != XTYPE_XBOX360)
		return 0;

	xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
	if (!led)
		return -ENOMEM;

	led_no = (long)atomic_inc_return(&led_seq) - 1;

	snprintf(led->name, sizeof(led->name), "xpad%ld", led_no);
	led->xpad = xpad;

	led_cdev = &led->led_cdev;
	led_cdev->name = led->name;
	led_cdev->brightness_set = xpad_led_set;

	error = led_classdev_register(&xpad->udev->dev, led_cdev);
	if (error) {
		kfree(led);
		xpad->led = NULL;
		return error;
	}

	/*
	 * Light up the segment corresponding to controller number
	 */
	xpad_send_led_command(xpad, (led_no % 4) + 2);

	return 0;
}

static void xpad_led_disconnect(struct usb_xpad *xpad)
{
	struct xpad_led *xpad_led = xpad->led;

	if (xpad_led) {
		led_classdev_unregister(&xpad_led->led_cdev);
A
Axel Lin 已提交
897
		kfree(xpad_led);
898 899
	}
}
900
#else
901 902
static int xpad_led_probe(struct usb_xpad *xpad) { return 0; }
static void xpad_led_disconnect(struct usb_xpad *xpad) { }
903 904
#endif

905

906
static int xpad_open(struct input_dev *dev)
L
Linus Torvalds 已提交
907
{
908
	struct usb_xpad *xpad = input_get_drvdata(dev);
909

910
	/* URB was submitted in probe */
911
	if (xpad->xtype == XTYPE_XBOX360W)
912 913
		return 0;

L
Linus Torvalds 已提交
914
	xpad->irq_in->dev = xpad->udev;
915
	if (usb_submit_urb(xpad->irq_in, GFP_KERNEL))
L
Linus Torvalds 已提交
916
		return -EIO;
917

918 919 920 921 922 923 924 925
	if (xpad->xtype == XTYPE_XBOXONE) {
		/* Xbox one controller needs to be initialized. */
		xpad->odata[0] = 0x05;
		xpad->odata[1] = 0x20;
		xpad->irq_out->transfer_buffer_length = 2;
		return usb_submit_urb(xpad->irq_out, GFP_KERNEL);
	}

L
Linus Torvalds 已提交
926 927 928
	return 0;
}

929
static void xpad_close(struct input_dev *dev)
L
Linus Torvalds 已提交
930
{
931
	struct usb_xpad *xpad = input_get_drvdata(dev);
932

933
	if (xpad->xtype != XTYPE_XBOX360W)
934
		usb_kill_urb(xpad->irq_in);
935

936
	xpad_stop_output(xpad);
L
Linus Torvalds 已提交
937 938
}

D
Dominic Cerquetti 已提交
939 940
static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs)
{
941
	struct usb_xpad *xpad = input_get_drvdata(input_dev);
D
Dominic Cerquetti 已提交
942 943 944 945 946 947 948 949 950 951
	set_bit(abs, input_dev->absbit);

	switch (abs) {
	case ABS_X:
	case ABS_Y:
	case ABS_RX:
	case ABS_RY:	/* the two sticks */
		input_set_abs_params(input_dev, abs, -32768, 32767, 16, 128);
		break;
	case ABS_Z:
952
	case ABS_RZ:	/* the triggers (if mapped to axes) */
953 954 955 956
		if (xpad->xtype == XTYPE_XBOXONE)
			input_set_abs_params(input_dev, abs, 0, 1023, 0, 0);
		else
			input_set_abs_params(input_dev, abs, 0, 255, 0, 0);
D
Dominic Cerquetti 已提交
957 958
		break;
	case ABS_HAT0X:
959
	case ABS_HAT0Y:	/* the d-pad (only if dpad is mapped to axes */
D
Dominic Cerquetti 已提交
960 961 962 963 964
		input_set_abs_params(input_dev, abs, -1, 1, 0, 0);
		break;
	}
}

L
Linus Torvalds 已提交
965 966
static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
967
	struct usb_device *udev = interface_to_usbdev(intf);
968 969
	struct usb_xpad *xpad;
	struct input_dev *input_dev;
L
Linus Torvalds 已提交
970
	struct usb_endpoint_descriptor *ep_irq_in;
971
	int ep_irq_in_idx;
972
	int i, error;
973

L
Linus Torvalds 已提交
974 975 976 977 978
	for (i = 0; xpad_device[i].idVendor; i++) {
		if ((le16_to_cpu(udev->descriptor.idVendor) == xpad_device[i].idVendor) &&
		    (le16_to_cpu(udev->descriptor.idProduct) == xpad_device[i].idProduct))
			break;
	}
979

980 981 982 983 984 985 986 987 988 989
	if (xpad_device[i].xtype == XTYPE_XBOXONE &&
	    intf->cur_altsetting->desc.bInterfaceNumber != 0) {
		/*
		 * The Xbox One controller lists three interfaces all with the
		 * same interface class, subclass and protocol. Differentiate by
		 * interface number.
		 */
		return -ENODEV;
	}

990 991
	xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);
	input_dev = input_allocate_device();
992 993
	if (!xpad || !input_dev) {
		error = -ENOMEM;
994
		goto fail1;
995
	}
996

997 998
	xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN,
					 GFP_KERNEL, &xpad->idata_dma);
999 1000
	if (!xpad->idata) {
		error = -ENOMEM;
1001
		goto fail1;
1002
	}
L
Linus Torvalds 已提交
1003 1004

	xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);
1005 1006
	if (!xpad->irq_in) {
		error = -ENOMEM;
1007
		goto fail2;
1008
	}
1009

L
Linus Torvalds 已提交
1010
	xpad->udev = udev;
1011
	xpad->intf = intf;
1012
	xpad->mapping = xpad_device[i].mapping;
1013
	xpad->xtype = xpad_device[i].xtype;
1014

1015 1016 1017 1018 1019 1020 1021 1022
	if (xpad->xtype == XTYPE_UNKNOWN) {
		if (intf->cur_altsetting->desc.bInterfaceClass == USB_CLASS_VENDOR_SPEC) {
			if (intf->cur_altsetting->desc.bInterfaceProtocol == 129)
				xpad->xtype = XTYPE_XBOX360W;
			else
				xpad->xtype = XTYPE_XBOX360;
		} else
			xpad->xtype = XTYPE_XBOX;
1023 1024 1025 1026 1027

		if (dpad_to_buttons)
			xpad->mapping |= MAP_DPAD_TO_BUTTONS;
		if (triggers_to_buttons)
			xpad->mapping |= MAP_TRIGGERS_TO_BUTTONS;
1028 1029
		if (sticks_to_null)
			xpad->mapping |= MAP_STICKS_TO_NULL;
1030
	}
1031

1032 1033 1034
	xpad->dev = input_dev;
	usb_make_path(udev, xpad->phys, sizeof(xpad->phys));
	strlcat(xpad->phys, "/input0", sizeof(xpad->phys));
1035

1036 1037 1038
	input_dev->name = xpad_device[i].name;
	input_dev->phys = xpad->phys;
	usb_to_input_id(udev, &input_dev->id);
1039
	input_dev->dev.parent = &intf->dev;
1040 1041 1042

	input_set_drvdata(input_dev, xpad);

1043 1044
	input_dev->open = xpad_open;
	input_dev->close = xpad_close;
1045

1046 1047 1048 1049 1050 1051 1052 1053
	input_dev->evbit[0] = BIT_MASK(EV_KEY);

	if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
		input_dev->evbit[0] |= BIT_MASK(EV_ABS);
		/* set up axes */
		for (i = 0; xpad_abs[i] >= 0; i++)
			xpad_set_up_abs(input_dev, xpad_abs[i]);
	}
1054

1055
	/* set up standard buttons */
1056
	for (i = 0; xpad_common_btn[i] >= 0; i++)
1057
		__set_bit(xpad_common_btn[i], input_dev->keybit);
1058

1059
	/* set up model-specific ones */
1060 1061
	if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX360W ||
	    xpad->xtype == XTYPE_XBOXONE) {
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
		for (i = 0; xpad360_btn[i] >= 0; i++)
			__set_bit(xpad360_btn[i], input_dev->keybit);
	} else {
		for (i = 0; xpad_btn[i] >= 0; i++)
			__set_bit(xpad_btn[i], input_dev->keybit);
	}

	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
		for (i = 0; xpad_btn_pad[i] >= 0; i++)
			__set_bit(xpad_btn_pad[i], input_dev->keybit);
	} else {
D
Dominic Cerquetti 已提交
1073
		for (i = 0; xpad_abs_pad[i] >= 0; i++)
1074
			xpad_set_up_abs(input_dev, xpad_abs_pad[i]);
1075 1076 1077 1078 1079 1080 1081 1082 1083
	}

	if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
		for (i = 0; xpad_btn_triggers[i] >= 0; i++)
			__set_bit(xpad_btn_triggers[i], input_dev->keybit);
	} else {
		for (i = 0; xpad_abs_triggers[i] >= 0; i++)
			xpad_set_up_abs(input_dev, xpad_abs_triggers[i]);
	}
1084

1085
	error = xpad_init_output(intf, xpad);
1086
	if (error)
1087
		goto fail3;
1088

1089 1090
	error = xpad_init_ff(xpad);
	if (error)
1091
		goto fail4;
1092 1093 1094

	error = xpad_led_probe(xpad);
	if (error)
1095
		goto fail5;
1096

1097 1098 1099 1100
	/* Xbox One controller has in/out endpoints swapped. */
	ep_irq_in_idx = xpad->xtype == XTYPE_XBOXONE ? 1 : 0;
	ep_irq_in = &intf->cur_altsetting->endpoint[ep_irq_in_idx].desc;

1101 1102 1103 1104 1105 1106
	usb_fill_int_urb(xpad->irq_in, udev,
			 usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),
			 xpad->idata, XPAD_PKT_LEN, xpad_irq_in,
			 xpad, ep_irq_in->bInterval);
	xpad->irq_in->transfer_dma = xpad->idata_dma;
	xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1107

1108 1109
	error = input_register_device(xpad->dev);
	if (error)
1110
		goto fail6;
1111

L
Linus Torvalds 已提交
1112
	usb_set_intfdata(intf, xpad);
1113 1114 1115 1116 1117 1118 1119

	if (xpad->xtype == XTYPE_XBOX360W) {
		/*
		 * Setup the message to set the LEDs on the
		 * controller when it shows up
		 */
		xpad->bulk_out = usb_alloc_urb(0, GFP_KERNEL);
1120 1121
		if (!xpad->bulk_out) {
			error = -ENOMEM;
1122
			goto fail7;
1123
		}
1124 1125

		xpad->bdata = kzalloc(XPAD_PKT_LEN, GFP_KERNEL);
1126 1127
		if (!xpad->bdata) {
			error = -ENOMEM;
1128
			goto fail8;
1129
		}
1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149

		xpad->bdata[2] = 0x08;
		switch (intf->cur_altsetting->desc.bInterfaceNumber) {
		case 0:
			xpad->bdata[3] = 0x42;
			break;
		case 2:
			xpad->bdata[3] = 0x43;
			break;
		case 4:
			xpad->bdata[3] = 0x44;
			break;
		case 6:
			xpad->bdata[3] = 0x45;
		}

		ep_irq_in = &intf->cur_altsetting->endpoint[1].desc;
		usb_fill_bulk_urb(xpad->bulk_out, udev,
				usb_sndbulkpipe(udev, ep_irq_in->bEndpointAddress),
				xpad->bdata, XPAD_PKT_LEN, xpad_bulk_out, xpad);
1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161

		/*
		 * Submit the int URB immediately rather than waiting for open
		 * because we get status messages from the device whether
		 * or not any controllers are attached.  In fact, it's
		 * exactly the message that a controller has arrived that
		 * we're waiting for.
		 */
		xpad->irq_in->dev = xpad->udev;
		error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);
		if (error)
			goto fail9;
1162 1163
	}

L
Linus Torvalds 已提交
1164
	return 0;
1165

1166 1167
 fail9:	kfree(xpad->bdata);
 fail8:	usb_free_urb(xpad->bulk_out);
1168 1169 1170 1171 1172 1173 1174
 fail7:	input_unregister_device(input_dev);
	input_dev = NULL;
 fail6:	xpad_led_disconnect(xpad);
 fail5:	if (input_dev)
		input_ff_destroy(input_dev);
 fail4:	xpad_deinit_output(xpad);
 fail3:	usb_free_urb(xpad->irq_in);
1175
 fail2:	usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
1176
 fail1:	input_free_device(input_dev);
1177
	kfree(xpad);
1178
	return error;
1179

L
Linus Torvalds 已提交
1180 1181 1182 1183 1184
}

static void xpad_disconnect(struct usb_interface *intf)
{
	struct usb_xpad *xpad = usb_get_intfdata (intf);
1185

1186 1187 1188 1189 1190 1191 1192 1193
	xpad_led_disconnect(xpad);
	input_unregister_device(xpad->dev);
	xpad_deinit_output(xpad);

	if (xpad->xtype == XTYPE_XBOX360W) {
		usb_kill_urb(xpad->bulk_out);
		usb_free_urb(xpad->bulk_out);
		usb_kill_urb(xpad->irq_in);
L
Linus Torvalds 已提交
1194
	}
1195 1196 1197 1198 1199 1200 1201 1202 1203

	usb_free_urb(xpad->irq_in);
	usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
			xpad->idata, xpad->idata_dma);

	kfree(xpad->bdata);
	kfree(xpad);

	usb_set_intfdata(intf, NULL);
L
Linus Torvalds 已提交
1204 1205 1206 1207 1208 1209 1210 1211 1212
}

static struct usb_driver xpad_driver = {
	.name		= "xpad",
	.probe		= xpad_probe,
	.disconnect	= xpad_disconnect,
	.id_table	= xpad_table,
};

1213
module_usb_driver(xpad_driver);
L
Linus Torvalds 已提交
1214 1215 1216 1217

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");