xpad.c 30.3 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 78
 */

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

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

#define XPAD_PKT_LEN 32

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

96 97
#define XTYPE_XBOX        0
#define XTYPE_XBOX360     1
98 99
#define XTYPE_XBOX360W    2
#define XTYPE_UNKNOWN     3
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 123
	{ 0x045e, 0x0202, "Microsoft X-Box pad v1 (US)", 0, XTYPE_XBOX },
	{ 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", 0, XTYPE_XBOX },
	{ 0x045e, 0x0285, "Microsoft X-Box pad (Japan)", 0, XTYPE_XBOX },
	{ 0x045e, 0x0287, "Microsoft Xbox Controller S", 0, XTYPE_XBOX },
124
	{ 0x045e, 0x0719, "Xbox 360 Wireless Receiver", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
125
	{ 0x0c12, 0x8809, "RedOctane Xbox Dance Pad", DANCEPAD_MAP_CONFIG, XTYPE_XBOX },
126 127 128 129 130 131 132 133 134 135
	{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },
	{ 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 },
136
	{ 0x0738, 0x4540, "Mad Catz Beat Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
137 138 139
	{ 0x0738, 0x4556, "Mad Catz Lynx Wireless Controller", 0, XTYPE_XBOX },
	{ 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
	{ 0x0738, 0x4738, "Mad Catz Wired Xbox 360 Controller (SFIV)", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
140
	{ 0x0738, 0x6040, "Mad Catz Beat Pad Pro", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
141 142 143 144 145 146 147 148 149 150
	{ 0x0c12, 0x8802, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
	{ 0x0c12, 0x880a, "Pelican Eclipse PL-2023", 0, XTYPE_XBOX },
	{ 0x0c12, 0x8810, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
	{ 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", 0, XTYPE_XBOX },
	{ 0x0e4c, 0x1097, "Radica Gamester Controller", 0, XTYPE_XBOX },
	{ 0x0e4c, 0x2390, "Radica Games Jtech Controller", 0, XTYPE_XBOX },
	{ 0x0e6f, 0x0003, "Logic3 Freebird wireless Controller", 0, XTYPE_XBOX },
	{ 0x0e6f, 0x0005, "Eclipse wireless Controller", 0, XTYPE_XBOX },
	{ 0x0e6f, 0x0006, "Edge wireless Controller", 0, XTYPE_XBOX },
	{ 0x0e6f, 0x0006, "Pelican 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
151
	{ 0x0e6f, 0x0201, "Pelican PL-3601 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
152 153 154 155
	{ 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", 0, XTYPE_XBOX },
	{ 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 },
156
	{ 0x12ab, 0x8809, "Xbox DDR dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
157 158
	{ 0x12ab, 0x0004, "Honey Bee Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
	{ 0x0e6f, 0x0105, "HSM3 Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
159
	{ 0x1430, 0x4748, "RedOctane Guitar Hero X-plorer", 0, XTYPE_XBOX360 },
160
	{ 0x1430, 0x8888, "TX6500+ Dance Pad (first generation)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
161 162
	{ 0x146b, 0x0601, "BigBen Interactive XBOX 360 Controller", 0, XTYPE_XBOX360 },
	{ 0x045e, 0x028e, "Microsoft X-Box 360 pad", 0, XTYPE_XBOX360 },
163
	{ 0x1bad, 0x0002, "Harmonix Rock Band Guitar", 0, XTYPE_XBOX360 },
164
	{ 0x1bad, 0x0003, "Harmonix Rock Band Drumkit", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
165
	{ 0x0f0d, 0x0016, "Hori Real Arcade Pro.EX", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
166
	{ 0x0f0d, 0x000d, "Hori Fighting Stick EX2", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
167 168
	{ 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX },
	{ 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN }
L
Linus Torvalds 已提交
169 170
};

171 172 173
/* buttons shared with xbox and xbox360 */
static const signed short xpad_common_btn[] = {
	BTN_A, BTN_B, BTN_X, BTN_Y,			/* "analog" buttons */
174
	BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR,	/* start/back/sticks */
L
Linus Torvalds 已提交
175 176 177
	-1						/* terminating entry */
};

178 179 180 181 182 183
/* original xbox controllers only */
static const signed short xpad_btn[] = {
	BTN_C, BTN_Z,		/* "analog" buttons */
	-1			/* terminating entry */
};

184
/* used when dpad is mapped to buttons */
D
Dominic Cerquetti 已提交
185
static const signed short xpad_btn_pad[] = {
186 187
	BTN_TRIGGER_HAPPY1, BTN_TRIGGER_HAPPY2,		/* d-pad left, right */
	BTN_TRIGGER_HAPPY3, BTN_TRIGGER_HAPPY4,		/* d-pad up, down */
D
Dominic Cerquetti 已提交
188 189 190
	-1				/* terminating entry */
};

191 192 193 194 195 196 197
/* used when triggers are mapped to buttons */
static const signed short xpad_btn_triggers[] = {
	BTN_TL2, BTN_TR2,		/* triggers left/right */
	-1
};


198 199 200 201 202 203
static const signed short xpad360_btn[] = {  /* buttons for x360 controller */
	BTN_TL, BTN_TR,		/* Button LB/RB */
	BTN_MODE,		/* The big X button */
	-1
};

204
static const signed short xpad_abs[] = {
L
Linus Torvalds 已提交
205 206
	ABS_X, ABS_Y,		/* left stick */
	ABS_RX, ABS_RY,		/* right stick */
D
Dominic Cerquetti 已提交
207 208 209
	-1			/* terminating entry */
};

210
/* used when dpad is mapped to axes */
D
Dominic Cerquetti 已提交
211 212
static const signed short xpad_abs_pad[] = {
	ABS_HAT0X, ABS_HAT0Y,	/* d-pad axes */
L
Linus Torvalds 已提交
213 214 215
	-1			/* terminating entry */
};

216 217 218 219 220 221
/* used when triggers are mapped to axes */
static const signed short xpad_abs_triggers[] = {
	ABS_Z, ABS_RZ,		/* triggers left/right */
	-1
};

222 223
/* Xbox 360 has a vendor-specific class, so we cannot match it with only
 * USB_INTERFACE_INFO (also specifically refused by USB subsystem), so we
224 225 226
 * match against vendor id as well. Wired Xbox 360 devices have protocol 1,
 * wireless controllers have protocol 129. */
#define XPAD_XBOX360_VENDOR_PROTOCOL(vend,pr) \
227 228 229 230
	.match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO, \
	.idVendor = (vend), \
	.bInterfaceClass = USB_CLASS_VENDOR_SPEC, \
	.bInterfaceSubClass = 93, \
231 232 233 234
	.bInterfaceProtocol = (pr)
#define XPAD_XBOX360_VENDOR(vend) \
	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,1) }, \
	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,129) }
235

L
Linus Torvalds 已提交
236 237
static struct usb_device_id xpad_table [] = {
	{ USB_INTERFACE_INFO('X', 'B', 0) },	/* X-Box USB-IF not approved class */
238 239 240 241
	XPAD_XBOX360_VENDOR(0x045e),		/* Microsoft X-Box 360 controllers */
	XPAD_XBOX360_VENDOR(0x046d),		/* Logitech X-Box 360 style controllers */
	XPAD_XBOX360_VENDOR(0x0738),		/* Mad Catz X-Box 360 controllers */
	XPAD_XBOX360_VENDOR(0x0e6f),		/* 0x0e6f X-Box 360 controllers */
242
	XPAD_XBOX360_VENDOR(0x12ab),		/* X-Box 360 dance pads */
243
	XPAD_XBOX360_VENDOR(0x1430),		/* RedOctane X-Box 360 controllers */
244
	XPAD_XBOX360_VENDOR(0x146b),		/* BigBen Interactive Controllers */
245
	XPAD_XBOX360_VENDOR(0x1bad),		/* Harminix Rock Band Guitar and Drums */
246
	XPAD_XBOX360_VENDOR(0x0f0d),            /* Hori Controllers */
L
Linus Torvalds 已提交
247 248 249 250 251 252
	{ }
};

MODULE_DEVICE_TABLE (usb, xpad_table);

struct usb_xpad {
D
Dominic Cerquetti 已提交
253 254
	struct input_dev *dev;		/* input device interface */
	struct usb_device *udev;	/* usb device */
255

256 257
	int pad_present;

D
Dominic Cerquetti 已提交
258 259
	struct urb *irq_in;		/* urb for interrupt in report */
	unsigned char *idata;		/* input data */
L
Linus Torvalds 已提交
260
	dma_addr_t idata_dma;
261

262 263 264
	struct urb *bulk_out;
	unsigned char *bdata;

265
#if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
266 267 268
	struct urb *irq_out;		/* urb for interrupt out report */
	unsigned char *odata;		/* output data */
	dma_addr_t odata_dma;
269 270 271 272 273
	struct mutex odata_mutex;
#endif

#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
	struct xpad_led *led;
274 275
#endif

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

278
	int mapping;			/* map d-pad to buttons or to axes */
279
	int xtype;			/* type of xbox device */
L
Linus Torvalds 已提交
280 281 282 283 284 285 286 287 288 289 290 291
};

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

292
static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
L
Linus Torvalds 已提交
293
{
294
	struct input_dev *dev = xpad->dev;
L
Linus Torvalds 已提交
295

296 297 298 299 300 301 302 303 304 305 306 307 308
	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)));
	}
309

L
Linus Torvalds 已提交
310
	/* triggers left/right */
311 312 313 314 315 316 317
	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]);
	}
318

L
Linus Torvalds 已提交
319
	/* digital pad */
320
	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
321 322 323 324 325
		/* 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);
326 327 328 329 330
	} 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 已提交
331
	}
332

L
Linus Torvalds 已提交
333
	/* start/back buttons and stick press left/right */
D
Dominic Cerquetti 已提交
334
	input_report_key(dev, BTN_START,  data[2] & 0x10);
335
	input_report_key(dev, BTN_SELECT, data[2] & 0x20);
D
Dominic Cerquetti 已提交
336 337
	input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
	input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
338

L
Linus Torvalds 已提交
339 340 341 342 343
	/* "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]);
344

L
Linus Torvalds 已提交
345 346 347 348 349 350 351
	/* "analog" buttons black, white */
	input_report_key(dev, BTN_C, data[8]);
	input_report_key(dev, BTN_Z, data[9]);

	input_sync(dev);
}

352 353 354 355 356 357 358 359 360 361
/*
 *	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
 */

362 363
static void xpad360_process_packet(struct usb_xpad *xpad,
				   u16 cmd, unsigned char *data)
364 365 366 367
{
	struct input_dev *dev = xpad->dev;

	/* digital pad */
368
	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
369 370 371 372 373
		/* 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);
374 375 376 377 378
	} 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));
379 380 381
	}

	/* start/back buttons */
382
	input_report_key(dev, BTN_START,  data[2] & 0x10);
383
	input_report_key(dev, BTN_SELECT, data[2] & 0x20);
384 385 386 387 388 389

	/* 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 */
390 391 392 393 394 395 396
	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);
397

398 399 400 401 402 403 404 405 406 407 408 409 410
	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)));
	}
411 412

	/* triggers left/right */
413 414 415 416 417 418 419
	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]);
	}
420 421 422 423

	input_sync(dev);
}

424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
/*
 * 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]);
}

457
static void xpad_irq_in(struct urb *urb)
L
Linus Torvalds 已提交
458 459
{
	struct usb_xpad *xpad = urb->context;
460
	int retval, status;
461

462 463 464
	status = urb->status;

	switch (status) {
L
Linus Torvalds 已提交
465 466 467 468 469 470 471
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
472
		dbg("%s - urb shutting down with status: %d",
473
			__func__, status);
L
Linus Torvalds 已提交
474 475
		return;
	default:
476
		dbg("%s - nonzero urb status received: %d",
477
			__func__, status);
L
Linus Torvalds 已提交
478 479
		goto exit;
	}
480

481 482
	switch (xpad->xtype) {
	case XTYPE_XBOX360:
483
		xpad360_process_packet(xpad, 0, xpad->idata);
484 485 486 487 488
		break;
	case XTYPE_XBOX360W:
		xpad360w_process_packet(xpad, 0, xpad->idata);
		break;
	default:
489
		xpad_process_packet(xpad, 0, xpad->idata);
490
	}
L
Linus Torvalds 已提交
491 492

exit:
493
	retval = usb_submit_urb(urb, GFP_ATOMIC);
L
Linus Torvalds 已提交
494 495
	if (retval)
		err ("%s - usb_submit_urb failed with result %d",
496
		     __func__, retval);
L
Linus Torvalds 已提交
497 498
}

499 500 501 502 503 504 505 506 507 508
static void xpad_bulk_out(struct urb *urb)
{
	switch (urb->status) {
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
509
		dbg("%s - urb shutting down with status: %d", __func__, urb->status);
510 511
		break;
	default:
512
		dbg("%s - nonzero urb status received: %d", __func__, urb->status);
513 514 515
	}
}

516
#if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
517 518
static void xpad_irq_out(struct urb *urb)
{
519 520 521
	int retval, status;

	status = urb->status;
522

523
	switch (status) {
524
	case 0:
525
		/* success */
526 527 528 529 530 531 532 533 534 535 536 537
		return;

	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
		dbg("%s - urb shutting down with status: %d", __func__, status);
		return;

	default:
		dbg("%s - nonzero urb status received: %d", __func__, status);
		goto exit;
538 539 540 541 542 543
	}

exit:
	retval = usb_submit_urb(urb, GFP_ATOMIC);
	if (retval)
		err("%s - usb_submit_urb failed with result %d",
544
		    __func__, retval);
545 546
}

547
static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
548 549
{
	struct usb_endpoint_descriptor *ep_irq_out;
550
	int error;
551

552
	if (xpad->xtype == XTYPE_UNKNOWN)
553 554
		return 0;

555 556
	xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,
					 GFP_KERNEL, &xpad->odata_dma);
557 558
	if (!xpad->odata) {
		error = -ENOMEM;
559
		goto fail1;
560
	}
561

562 563
	mutex_init(&xpad->odata_mutex);

564
	xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
565 566
	if (!xpad->irq_out) {
		error = -ENOMEM;
567
		goto fail2;
568
	}
569 570 571 572 573 574 575 576 577 578 579

	ep_irq_out = &intf->cur_altsetting->endpoint[1].desc;
	usb_fill_int_urb(xpad->irq_out, xpad->udev,
			 usb_sndintpipe(xpad->udev, ep_irq_out->bEndpointAddress),
			 xpad->odata, XPAD_PKT_LEN,
			 xpad_irq_out, xpad, ep_irq_out->bInterval);
	xpad->irq_out->transfer_dma = xpad->odata_dma;
	xpad->irq_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

	return 0;

580
 fail2:	usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
581 582 583
 fail1:	return error;
}

584
static void xpad_stop_output(struct usb_xpad *xpad)
585
{
586
	if (xpad->xtype != XTYPE_UNKNOWN)
587 588 589
		usb_kill_urb(xpad->irq_out);
}

590
static void xpad_deinit_output(struct usb_xpad *xpad)
591
{
592
	if (xpad->xtype != XTYPE_UNKNOWN) {
593
		usb_free_urb(xpad->irq_out);
594
		usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
595 596 597
				xpad->odata, xpad->odata_dma);
	}
}
598 599 600 601 602 603 604
#else
static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad) { return 0; }
static void xpad_deinit_output(struct usb_xpad *xpad) {}
static void xpad_stop_output(struct usb_xpad *xpad) {}
#endif

#ifdef CONFIG_JOYSTICK_XPAD_FF
605
static int xpad_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
606 607
{
	struct usb_xpad *xpad = input_get_drvdata(dev);
608

609 610 611
	if (effect->type == FF_RUMBLE) {
		__u16 strong = effect->u.rumble.strong_magnitude;
		__u16 weak = effect->u.rumble.weak_magnitude;
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638

		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);

639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
		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);

656 657 658 659 660
		default:
			dbg("%s - rumble command sent to unsupported xpad type: %d",
				__func__, xpad->xtype);
			return -1;
		}
661 662 663 664 665 666 667
	}

	return 0;
}

static int xpad_init_ff(struct usb_xpad *xpad)
{
668
	if (xpad->xtype == XTYPE_UNKNOWN)
669 670
		return 0;

671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695
	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;
696
		xpad->irq_out->transfer_buffer_length = 3;
697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
		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 已提交
756
		kfree(xpad_led);
757 758
	}
}
759
#else
760 761
static int xpad_led_probe(struct usb_xpad *xpad) { return 0; }
static void xpad_led_disconnect(struct usb_xpad *xpad) { }
762 763
#endif

764

765
static int xpad_open(struct input_dev *dev)
L
Linus Torvalds 已提交
766
{
767
	struct usb_xpad *xpad = input_get_drvdata(dev);
768

769 770 771 772
	/* URB was submitted in probe */
	if(xpad->xtype == XTYPE_XBOX360W)
		return 0;

L
Linus Torvalds 已提交
773
	xpad->irq_in->dev = xpad->udev;
774
	if (usb_submit_urb(xpad->irq_in, GFP_KERNEL))
L
Linus Torvalds 已提交
775
		return -EIO;
776

L
Linus Torvalds 已提交
777 778 779
	return 0;
}

780
static void xpad_close(struct input_dev *dev)
L
Linus Torvalds 已提交
781
{
782
	struct usb_xpad *xpad = input_get_drvdata(dev);
783

784
	if (xpad->xtype != XTYPE_XBOX360W)
785
		usb_kill_urb(xpad->irq_in);
786

787
	xpad_stop_output(xpad);
L
Linus Torvalds 已提交
788 789
}

D
Dominic Cerquetti 已提交
790 791 792 793 794 795 796 797 798 799 800 801
static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs)
{
	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:
802
	case ABS_RZ:	/* the triggers (if mapped to axes) */
D
Dominic Cerquetti 已提交
803 804 805
		input_set_abs_params(input_dev, abs, 0, 255, 0, 0);
		break;
	case ABS_HAT0X:
806
	case ABS_HAT0Y:	/* the d-pad (only if dpad is mapped to axes */
D
Dominic Cerquetti 已提交
807 808 809 810 811
		input_set_abs_params(input_dev, abs, -1, 1, 0, 0);
		break;
	}
}

L
Linus Torvalds 已提交
812 813
static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
814
	struct usb_device *udev = interface_to_usbdev(intf);
815 816
	struct usb_xpad *xpad;
	struct input_dev *input_dev;
L
Linus Torvalds 已提交
817
	struct usb_endpoint_descriptor *ep_irq_in;
818
	int i, error;
819

L
Linus Torvalds 已提交
820 821 822 823 824
	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;
	}
825

826 827
	xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);
	input_dev = input_allocate_device();
828 829
	if (!xpad || !input_dev) {
		error = -ENOMEM;
830
		goto fail1;
831
	}
832

833 834
	xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN,
					 GFP_KERNEL, &xpad->idata_dma);
835 836
	if (!xpad->idata) {
		error = -ENOMEM;
837
		goto fail1;
838
	}
L
Linus Torvalds 已提交
839 840

	xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);
841 842
	if (!xpad->irq_in) {
		error = -ENOMEM;
843
		goto fail2;
844
	}
845

L
Linus Torvalds 已提交
846
	xpad->udev = udev;
847
	xpad->mapping = xpad_device[i].mapping;
848
	xpad->xtype = xpad_device[i].xtype;
849

850 851 852 853 854 855 856 857
	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;
858 859 860 861 862

		if (dpad_to_buttons)
			xpad->mapping |= MAP_DPAD_TO_BUTTONS;
		if (triggers_to_buttons)
			xpad->mapping |= MAP_TRIGGERS_TO_BUTTONS;
863 864
		if (sticks_to_null)
			xpad->mapping |= MAP_STICKS_TO_NULL;
865
	}
866

867 868 869
	xpad->dev = input_dev;
	usb_make_path(udev, xpad->phys, sizeof(xpad->phys));
	strlcat(xpad->phys, "/input0", sizeof(xpad->phys));
870

871 872 873
	input_dev->name = xpad_device[i].name;
	input_dev->phys = xpad->phys;
	usb_to_input_id(udev, &input_dev->id);
874
	input_dev->dev.parent = &intf->dev;
875 876 877

	input_set_drvdata(input_dev, xpad);

878 879
	input_dev->open = xpad_open;
	input_dev->close = xpad_close;
880

881 882 883 884 885 886 887 888
	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]);
	}
889

890
	/* set up standard buttons */
891
	for (i = 0; xpad_common_btn[i] >= 0; i++)
892
		__set_bit(xpad_common_btn[i], input_dev->keybit);
893

894
	/* set up model-specific ones */
895 896 897 898 899 900 901 902 903 904 905 906
	if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX360W) {
		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 已提交
907 908
		for (i = 0; xpad_abs_pad[i] >= 0; i++)
		    xpad_set_up_abs(input_dev, xpad_abs_pad[i]);
909 910 911 912 913 914 915 916 917
	}

	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]);
	}
918

919
	error = xpad_init_output(intf, xpad);
920
	if (error)
921
		goto fail3;
922

923 924
	error = xpad_init_ff(xpad);
	if (error)
925
		goto fail4;
926 927 928

	error = xpad_led_probe(xpad);
	if (error)
929
		goto fail5;
930

931 932 933 934 935 936 937
	ep_irq_in = &intf->cur_altsetting->endpoint[0].desc;
	usb_fill_int_urb(xpad->irq_in, udev,
			 usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),
			 xpad->idata, XPAD_PKT_LEN, xpad_irq_in,
			 xpad, ep_irq_in->bInterval);
	xpad->irq_in->transfer_dma = xpad->idata_dma;
	xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
938

939 940
	error = input_register_device(xpad->dev);
	if (error)
941
		goto fail6;
942

L
Linus Torvalds 已提交
943
	usb_set_intfdata(intf, xpad);
944 945 946 947 948 949 950

	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);
951 952
		if (!xpad->bulk_out) {
			error = -ENOMEM;
953
			goto fail7;
954
		}
955 956

		xpad->bdata = kzalloc(XPAD_PKT_LEN, GFP_KERNEL);
957 958
		if (!xpad->bdata) {
			error = -ENOMEM;
959
			goto fail8;
960
		}
961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980

		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);
981 982 983 984 985 986 987 988 989 990 991 992

		/*
		 * 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;
993 994
	}

L
Linus Torvalds 已提交
995
	return 0;
996

997 998
 fail9:	kfree(xpad->bdata);
 fail8:	usb_free_urb(xpad->bulk_out);
999 1000 1001 1002 1003 1004 1005
 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);
1006
 fail2:	usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
1007
 fail1:	input_free_device(input_dev);
1008
	kfree(xpad);
1009
	return error;
1010

L
Linus Torvalds 已提交
1011 1012 1013 1014 1015
}

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

1017 1018 1019 1020 1021 1022 1023 1024
	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 已提交
1025
	}
1026 1027 1028 1029 1030 1031 1032 1033 1034

	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 已提交
1035 1036 1037 1038 1039 1040 1041 1042 1043
}

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

1044
module_usb_driver(xpad_driver);
L
Linus Torvalds 已提交
1045 1046 1047 1048

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