Pileus Git - ~andy/linux/blob - drivers/input/joystick/xpad.c

   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  *
  35  * Thanks to:
  36  *  - ITO Takayuki for providing essential xpad information on his website
  37  *  - Vojtech Pavlik     - iforce driver / input subsystem
  38  *  - Greg Kroah-Hartman - usb-skeleton driver
  39  *  - XBOX Linux project - extra USB id's
  40  *
  41  * TODO:
  42  *  - fine tune axes (especially trigger axes)
  43  *  - fix "analog" buttons (reported as digital now)
  44  *  - get rumble working
  45  *  - need USB IDs for other dance pads
  46  *
  47  * History:
  48  *
  49  * 2002-06-27 - 0.0.1 : first version, just said "XBOX HID controller"
  50  *
  51  * 2002-07-02 - 0.0.2 : basic working version
  52  *  - all axes and 9 of the 10 buttons work (german InterAct device)
  53  *  - the black button does not work
  54  *
  55  * 2002-07-14 - 0.0.3 : rework by Vojtech Pavlik
  56  *  - indentation fixes
  57  *  - usb + input init sequence fixes
  58  *
  59  * 2002-07-16 - 0.0.4 : minor changes, merge with Vojtech's v0.0.3
  60  *  - verified the lack of HID and report descriptors
  61  *  - verified that ALL buttons WORK
  62  *  - fixed d-pad to axes mapping
  63  *
  64  * 2002-07-17 - 0.0.5 : simplified d-pad handling
  65  *
  66  * 2004-10-02 - 0.0.6 : DDR pad support
  67  *  - borrowed from the XBOX linux kernel
  68  *  - USB id's for commonly used dance pads are present
  69  *  - dance pads will map D-PAD to buttons, not axes
  70  *  - pass the module paramater 'dpad_to_buttons' to force
  71  *    the D-PAD to map to buttons if your pad is not detected
  72  *
  73  * Later changes can be tracked in SCM.
  74  */
  75
  76 #include <linux/kernel.h>
  77 #include <linux/init.h>
  78 #include <linux/slab.h>
  79 #include <linux/stat.h>
  80 #include <linux/module.h>
  81 #include <linux/usb/input.h>
  82
  83 #define DRIVER_AUTHOR "Marko Friedemann <mfr@bmx-chemnitz.de>"
  84 #define DRIVER_DESC "X-Box pad driver"
  85
  86 #define XPAD_PKT_LEN 32
  87
  88 /* xbox d-pads should map to buttons, as is required for DDR pads
  89    but we map them to axes when possible to simplify things */
  90 #define MAP_DPAD_TO_BUTTONS             (1 << 0)
  91 #define MAP_TRIGGERS_TO_BUTTONS         (1 << 1)
  92 #define MAP_STICKS_TO_NULL              (1 << 2)
  93 #define DANCEPAD_MAP_CONFIG     (MAP_DPAD_TO_BUTTONS |                  \
  94                                 MAP_TRIGGERS_TO_BUTTONS | MAP_STICKS_TO_NULL)
  95
  96 #define XTYPE_XBOX        0
  97 #define XTYPE_XBOX360     1
  98 #define XTYPE_XBOX360W    2
  99 #define XTYPE_UNKNOWN     3
 100
 101 static bool dpad_to_buttons;
 102 module_param(dpad_to_buttons, bool, S_IRUGO);
 103 MODULE_PARM_DESC(dpad_to_buttons, "Map D-PAD to buttons rather than axes for unknown pads");
 104
 105 static bool triggers_to_buttons;
 106 module_param(triggers_to_buttons, bool, S_IRUGO);
 107 MODULE_PARM_DESC(triggers_to_buttons, "Map triggers to buttons rather than axes for unknown pads");
 108
 109 static bool sticks_to_null;
 110 module_param(sticks_to_null, bool, S_IRUGO);
 111 MODULE_PARM_DESC(sticks_to_null, "Do not map sticks at all for unknown pads");
 112
 113 static const struct xpad_device {
 114         u16 idVendor;
 115         u16 idProduct;
 116         char *name;
 117         u8 mapping;
 118         u8 xtype;
 119 } xpad_device[] = {
 120         { 0x045e, 0x0202, "Microsoft X-Box pad v1 (US)", 0, XTYPE_XBOX },
 121         { 0x045e, 0x0285, "Microsoft X-Box pad (Japan)", 0, XTYPE_XBOX },
 122         { 0x045e, 0x0287, "Microsoft Xbox Controller S", 0, XTYPE_XBOX },
 123         { 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", 0, XTYPE_XBOX },
 124         { 0x045e, 0x028e, "Microsoft X-Box 360 pad", 0, XTYPE_XBOX360 },
 125         { 0x045e, 0x0291, "Xbox 360 Wireless Receiver (XBOX)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
 126         { 0x045e, 0x0719, "Xbox 360 Wireless Receiver", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
 127         { 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },
 128         { 0x046d, 0xc242, "Logitech Chillstream Controller", 0, XTYPE_XBOX360 },
 129         { 0x046d, 0xca84, "Logitech Xbox Cordless Controller", 0, XTYPE_XBOX },
 130         { 0x046d, 0xca88, "Logitech Compact Controller for Xbox", 0, XTYPE_XBOX },
 131         { 0x05fd, 0x1007, "Mad Catz Controller (unverified)", 0, XTYPE_XBOX },
 132         { 0x05fd, 0x107a, "InterAct 'PowerPad Pro' X-Box pad (Germany)", 0, XTYPE_XBOX },
 133         { 0x0738, 0x4516, "Mad Catz Control Pad", 0, XTYPE_XBOX },
 134         { 0x0738, 0x4522, "Mad Catz LumiCON", 0, XTYPE_XBOX },
 135         { 0x0738, 0x4526, "Mad Catz Control Pad Pro", 0, XTYPE_XBOX },
 136         { 0x0738, 0x4536, "Mad Catz MicroCON", 0, XTYPE_XBOX },
 137         { 0x0738, 0x4540, "Mad Catz Beat Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
 138         { 0x0738, 0x4556, "Mad Catz Lynx Wireless Controller", 0, XTYPE_XBOX },
 139         { 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
 140         { 0x0738, 0x4728, "Mad Catz Street Fighter IV FightPad", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
 141         { 0x0738, 0x4738, "Mad Catz Wired Xbox 360 Controller (SFIV)", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
 142         { 0x0738, 0x6040, "Mad Catz Beat Pad Pro", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
 143         { 0x0738, 0xbeef, "Mad Catz JOYTECH NEO SE Advanced GamePad", XTYPE_XBOX360 },
 144         { 0x0c12, 0x8802, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
 145         { 0x0c12, 0x8809, "RedOctane Xbox Dance Pad", DANCEPAD_MAP_CONFIG, XTYPE_XBOX },
 146         { 0x0c12, 0x880a, "Pelican Eclipse PL-2023", 0, XTYPE_XBOX },
 147         { 0x0c12, 0x8810, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
 148         { 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", 0, XTYPE_XBOX },
 149         { 0x0d2f, 0x0002, "Andamiro Pump It Up pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
 150         { 0x0e4c, 0x1097, "Radica Gamester Controller", 0, XTYPE_XBOX },
 151         { 0x0e4c, 0x2390, "Radica Games Jtech Controller", 0, XTYPE_XBOX },
 152         { 0x0e6f, 0x0003, "Logic3 Freebird wireless Controller", 0, XTYPE_XBOX },
 153         { 0x0e6f, 0x0005, "Eclipse wireless Controller", 0, XTYPE_XBOX },
 154         { 0x0e6f, 0x0006, "Edge wireless Controller", 0, XTYPE_XBOX },
 155         { 0x0e6f, 0x0105, "HSM3 Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
 156         { 0x0e6f, 0x0201, "Pelican PL-3601 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
 157         { 0x0e6f, 0x0213, "Afterglow Gamepad for Xbox 360", 0, XTYPE_XBOX360 },
 158         { 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", 0, XTYPE_XBOX },
 159         { 0x0f0d, 0x000d, "Hori Fighting Stick EX2", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
 160         { 0x0f0d, 0x0016, "Hori Real Arcade Pro.EX", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
 161         { 0x0f30, 0x0202, "Joytech Advanced Controller", 0, XTYPE_XBOX },
 162         { 0x0f30, 0x8888, "BigBen XBMiniPad Controller", 0, XTYPE_XBOX },
 163         { 0x102c, 0xff0c, "Joytech Wireless Advanced Controller", 0, XTYPE_XBOX },
 164         { 0x12ab, 0x0004, "Honey Bee Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
 165         { 0x12ab, 0x8809, "Xbox DDR dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
 166         { 0x1430, 0x4748, "RedOctane Guitar Hero X-plorer", 0, XTYPE_XBOX360 },
 167         { 0x1430, 0x8888, "TX6500+ Dance Pad (first generation)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
 168         { 0x146b, 0x0601, "BigBen Interactive XBOX 360 Controller", 0, XTYPE_XBOX360 },
 169         { 0x1689, 0xfd00, "Razer Onza Tournament Edition", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
 170         { 0x1689, 0xfd01, "Razer Onza Classic Edition", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
 171         { 0x1bad, 0x0002, "Harmonix Rock Band Guitar", 0, XTYPE_XBOX360 },
 172         { 0x1bad, 0x0003, "Harmonix Rock Band Drumkit", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
 173         { 0x1bad, 0xf016, "Mad Catz Xbox 360 Controller", 0, XTYPE_XBOX360 },
 174         { 0x1bad, 0xf028, "Street Fighter IV FightPad", 0, XTYPE_XBOX360 },
 175         { 0x1bad, 0xf901, "Gamestop Xbox 360 Controller", 0, XTYPE_XBOX360 },
 176         { 0x1bad, 0xf903, "Tron Xbox 360 controller", 0, XTYPE_XBOX360 },
 177         { 0x24c6, 0x5300, "PowerA MINI PROEX Controller", 0, XTYPE_XBOX360 },
 178         { 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX },
 179         { 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN }
 180 };
 181
 182 /* buttons shared with xbox and xbox360 */
 183 static const signed short xpad_common_btn[] = {
 184         BTN_A, BTN_B, BTN_X, BTN_Y,                     /* "analog" buttons */
 185         BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR,  /* start/back/sticks */
 186         -1                                              /* terminating entry */
 187 };
 188
 189 /* original xbox controllers only */
 190 static const signed short xpad_btn[] = {
 191         BTN_C, BTN_Z,           /* "analog" buttons */
 192         -1                      /* terminating entry */
 193 };
 194
 195 /* used when dpad is mapped to buttons */
 196 static const signed short xpad_btn_pad[] = {
 197         BTN_TRIGGER_HAPPY1, BTN_TRIGGER_HAPPY2,         /* d-pad left, right */
 198         BTN_TRIGGER_HAPPY3, BTN_TRIGGER_HAPPY4,         /* d-pad up, down */
 199         -1                              /* terminating entry */
 200 };
 201
 202 /* used when triggers are mapped to buttons */
 203 static const signed short xpad_btn_triggers[] = {
 204         BTN_TL2, BTN_TR2,               /* triggers left/right */
 205         -1
 206 };
 207
 208
 209 static const signed short xpad360_btn[] = {  /* buttons for x360 controller */
 210         BTN_TL, BTN_TR,         /* Button LB/RB */
 211         BTN_MODE,               /* The big X button */
 212         -1
 213 };
 214
 215 static const signed short xpad_abs[] = {
 216         ABS_X, ABS_Y,           /* left stick */
 217         ABS_RX, ABS_RY,         /* right stick */
 218         -1                      /* terminating entry */
 219 };
 220
 221 /* used when dpad is mapped to axes */
 222 static const signed short xpad_abs_pad[] = {
 223         ABS_HAT0X, ABS_HAT0Y,   /* d-pad axes */
 224         -1                      /* terminating entry */
 225 };
 226
 227 /* used when triggers are mapped to axes */
 228 static const signed short xpad_abs_triggers[] = {
 229         ABS_Z, ABS_RZ,          /* triggers left/right */
 230         -1
 231 };
 232
 233 /* Xbox 360 has a vendor-specific class, so we cannot match it with only
 234  * USB_INTERFACE_INFO (also specifically refused by USB subsystem), so we
 235  * match against vendor id as well. Wired Xbox 360 devices have protocol 1,
 236  * wireless controllers have protocol 129. */
 237 #define XPAD_XBOX360_VENDOR_PROTOCOL(vend,pr) \
 238         .match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO, \
 239         .idVendor = (vend), \
 240         .bInterfaceClass = USB_CLASS_VENDOR_SPEC, \
 241         .bInterfaceSubClass = 93, \
 242         .bInterfaceProtocol = (pr)
 243 #define XPAD_XBOX360_VENDOR(vend) \
 244         { XPAD_XBOX360_VENDOR_PROTOCOL(vend,1) }, \
 245         { XPAD_XBOX360_VENDOR_PROTOCOL(vend,129) }
 246
 247 static struct usb_device_id xpad_table[] = {
 248         { USB_INTERFACE_INFO('X', 'B', 0) },    /* X-Box USB-IF not approved class */
 249         XPAD_XBOX360_VENDOR(0x045e),            /* Microsoft X-Box 360 controllers */
 250         XPAD_XBOX360_VENDOR(0x046d),            /* Logitech X-Box 360 style controllers */
 251         XPAD_XBOX360_VENDOR(0x0738),            /* Mad Catz X-Box 360 controllers */
 252         { USB_DEVICE(0x0738, 0x4540) },         /* Mad Catz Beat Pad */
 253         XPAD_XBOX360_VENDOR(0x0e6f),            /* 0x0e6f X-Box 360 controllers */
 254         XPAD_XBOX360_VENDOR(0x12ab),            /* X-Box 360 dance pads */
 255         XPAD_XBOX360_VENDOR(0x1430),            /* RedOctane X-Box 360 controllers */
 256         XPAD_XBOX360_VENDOR(0x146b),            /* BigBen Interactive Controllers */
 257         XPAD_XBOX360_VENDOR(0x1bad),            /* Harminix Rock Band Guitar and Drums */
 258         XPAD_XBOX360_VENDOR(0x0f0d),            /* Hori Controllers */
 259         XPAD_XBOX360_VENDOR(0x1689),            /* Razer Onza */
 260         XPAD_XBOX360_VENDOR(0x24c6),            /* PowerA Controllers */
 261         { }
 262 };
 263
 264 MODULE_DEVICE_TABLE(usb, xpad_table);
 265
 266 struct usb_xpad {
 267         struct input_dev *dev;          /* input device interface */
 268         struct usb_device *udev;        /* usb device */
 269         struct usb_interface *intf;     /* usb interface */
 270
 271         int pad_present;
 272
 273         struct urb *irq_in;             /* urb for interrupt in report */
 274         unsigned char *idata;           /* input data */
 275         dma_addr_t idata_dma;
 276
 277         struct urb *bulk_out;
 278         unsigned char *bdata;
 279
 280 #if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
 281         struct urb *irq_out;            /* urb for interrupt out report */
 282         unsigned char *odata;           /* output data */
 283         dma_addr_t odata_dma;
 284         struct mutex odata_mutex;
 285 #endif
 286
 287 #if defined(CONFIG_JOYSTICK_XPAD_LEDS)
 288         struct xpad_led *led;
 289 #endif
 290
 291         char phys[64];                  /* physical device path */
 292
 293         int mapping;                    /* map d-pad to buttons or to axes */
 294         int xtype;                      /* type of xbox device */
 295 };
 296
 297 /*
 298  *      xpad_process_packet
 299  *
 300  *      Completes a request by converting the data into events for the
 301  *      input subsystem.
 302  *
 303  *      The used report descriptor was taken from ITO Takayukis website:
 304  *       http://euc.jp/periphs/xbox-controller.ja.html
 305  */
 306
 307 static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
 308 {
 309         struct input_dev *dev = xpad->dev;
 310
 311         if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
 312                 /* left stick */
 313                 input_report_abs(dev, ABS_X,
 314                                  (__s16) le16_to_cpup((__le16 *)(data + 12)));
 315                 input_report_abs(dev, ABS_Y,
 316                                  ~(__s16) le16_to_cpup((__le16 *)(data + 14)));
 317
 318                 /* right stick */
 319                 input_report_abs(dev, ABS_RX,
 320                                  (__s16) le16_to_cpup((__le16 *)(data + 16)));
 321                 input_report_abs(dev, ABS_RY,
 322                                  ~(__s16) le16_to_cpup((__le16 *)(data + 18)));
 323         }
 324
 325         /* triggers left/right */
 326         if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
 327                 input_report_key(dev, BTN_TL2, data[10]);
 328                 input_report_key(dev, BTN_TR2, data[11]);
 329         } else {
 330                 input_report_abs(dev, ABS_Z, data[10]);
 331                 input_report_abs(dev, ABS_RZ, data[11]);
 332         }
 333
 334         /* digital pad */
 335         if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
 336                 /* dpad as buttons (left, right, up, down) */
 337                 input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
 338                 input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
 339                 input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
 340                 input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
 341         } else {
 342                 input_report_abs(dev, ABS_HAT0X,
 343                                  !!(data[2] & 0x08) - !!(data[2] & 0x04));
 344                 input_report_abs(dev, ABS_HAT0Y,
 345                                  !!(data[2] & 0x02) - !!(data[2] & 0x01));
 346         }
 347
 348         /* start/back buttons and stick press left/right */
 349         input_report_key(dev, BTN_START,  data[2] & 0x10);
 350         input_report_key(dev, BTN_SELECT, data[2] & 0x20);
 351         input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
 352         input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
 353
 354         /* "analog" buttons A, B, X, Y */
 355         input_report_key(dev, BTN_A, data[4]);
 356         input_report_key(dev, BTN_B, data[5]);
 357         input_report_key(dev, BTN_X, data[6]);
 358         input_report_key(dev, BTN_Y, data[7]);
 359
 360         /* "analog" buttons black, white */
 361         input_report_key(dev, BTN_C, data[8]);
 362         input_report_key(dev, BTN_Z, data[9]);
 363
 364         input_sync(dev);
 365 }
 366
 367 /*
 368  *      xpad360_process_packet
 369  *
 370  *      Completes a request by converting the data into events for the
 371  *      input subsystem. It is version for xbox 360 controller
 372  *
 373  *      The used report descriptor was taken from:
 374  *              http://www.free60.org/wiki/Gamepad
 375  */
 376
 377 static void xpad360_process_packet(struct usb_xpad *xpad,
 378                                    u16 cmd, unsigned char *data)
 379 {
 380         struct input_dev *dev = xpad->dev;
 381
 382         /* digital pad */
 383         if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
 384                 /* dpad as buttons (left, right, up, down) */
 385                 input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
 386                 input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
 387                 input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
 388                 input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
 389         } else {
 390                 input_report_abs(dev, ABS_HAT0X,
 391                                  !!(data[2] & 0x08) - !!(data[2] & 0x04));
 392                 input_report_abs(dev, ABS_HAT0Y,
 393                                  !!(data[2] & 0x02) - !!(data[2] & 0x01));
 394         }
 395
 396         /* start/back buttons */
 397         input_report_key(dev, BTN_START,  data[2] & 0x10);
 398         input_report_key(dev, BTN_SELECT, data[2] & 0x20);
 399
 400         /* stick press left/right */
 401         input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
 402         input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
 403
 404         /* buttons A,B,X,Y,TL,TR and MODE */
 405         input_report_key(dev, BTN_A,    data[3] & 0x10);
 406         input_report_key(dev, BTN_B,    data[3] & 0x20);
 407         input_report_key(dev, BTN_X,    data[3] & 0x40);
 408         input_report_key(dev, BTN_Y,    data[3] & 0x80);
 409         input_report_key(dev, BTN_TL,   data[3] & 0x01);
 410         input_report_key(dev, BTN_TR,   data[3] & 0x02);
 411         input_report_key(dev, BTN_MODE, data[3] & 0x04);
 412
 413         if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
 414                 /* left stick */
 415                 input_report_abs(dev, ABS_X,
 416                                  (__s16) le16_to_cpup((__le16 *)(data + 6)));
 417                 input_report_abs(dev, ABS_Y,
 418                                  ~(__s16) le16_to_cpup((__le16 *)(data + 8)));
 419
 420                 /* right stick */
 421                 input_report_abs(dev, ABS_RX,
 422                                  (__s16) le16_to_cpup((__le16 *)(data + 10)));
 423                 input_report_abs(dev, ABS_RY,
 424                                  ~(__s16) le16_to_cpup((__le16 *)(data + 12)));
 425         }
 426
 427         /* triggers left/right */
 428         if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
 429                 input_report_key(dev, BTN_TL2, data[4]);
 430                 input_report_key(dev, BTN_TR2, data[5]);
 431         } else {
 432                 input_report_abs(dev, ABS_Z, data[4]);
 433                 input_report_abs(dev, ABS_RZ, data[5]);
 434         }
 435
 436         input_sync(dev);
 437 }
 438
 439 /*
 440  * xpad360w_process_packet
 441  *
 442  * Completes a request by converting the data into events for the
 443  * input subsystem. It is version for xbox 360 wireless controller.
 444  *
 445  * Byte.Bit
 446  * 00.1 - Status change: The controller or headset has connected/disconnected
 447  *                       Bits 01.7 and 01.6 are valid
 448  * 01.7 - Controller present
 449  * 01.6 - Headset present
 450  * 01.1 - Pad state (Bytes 4+) valid
 451  *
 452  */
 453
 454 static void xpad360w_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
 455 {
 456         /* Presence change */
 457         if (data[0] & 0x08) {
 458                 if (data[1] & 0x80) {
 459                         xpad->pad_present = 1;
 460                         usb_submit_urb(xpad->bulk_out, GFP_ATOMIC);
 461                 } else
 462                         xpad->pad_present = 0;
 463         }
 464
 465         /* Valid pad data */
 466         if (!(data[1] & 0x1))
 467                 return;
 468
 469         xpad360_process_packet(xpad, cmd, &data[4]);
 470 }
 471
 472 static void xpad_irq_in(struct urb *urb)
 473 {
 474         struct usb_xpad *xpad = urb->context;
 475         struct device *dev = &xpad->intf->dev;
 476         int retval, status;
 477
 478         status = urb->status;
 479
 480         switch (status) {
 481         case 0:
 482                 /* success */
 483                 break;
 484         case -ECONNRESET:
 485         case -ENOENT:
 486         case -ESHUTDOWN:
 487                 /* this urb is terminated, clean up */
 488                 dev_dbg(dev, "%s - urb shutting down with status: %d\n",
 489                         __func__, status);
 490                 return;
 491         default:
 492                 dev_dbg(dev, "%s - nonzero urb status received: %d\n",
 493                         __func__, status);
 494                 goto exit;
 495         }
 496
 497         switch (xpad->xtype) {
 498         case XTYPE_XBOX360:
 499                 xpad360_process_packet(xpad, 0, xpad->idata);
 500                 break;
 501         case XTYPE_XBOX360W:
 502                 xpad360w_process_packet(xpad, 0, xpad->idata);
 503                 break;
 504         default:
 505                 xpad_process_packet(xpad, 0, xpad->idata);
 506         }
 507
 508 exit:
 509         retval = usb_submit_urb(urb, GFP_ATOMIC);
 510         if (retval)
 511                 dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
 512                         __func__, retval);
 513 }
 514
 515 static void xpad_bulk_out(struct urb *urb)
 516 {
 517         struct usb_xpad *xpad = urb->context;
 518         struct device *dev = &xpad->intf->dev;
 519
 520         switch (urb->status) {
 521         case 0:
 522                 /* success */
 523                 break;
 524         case -ECONNRESET:
 525         case -ENOENT:
 526         case -ESHUTDOWN:
 527                 /* this urb is terminated, clean up */
 528                 dev_dbg(dev, "%s - urb shutting down with status: %d\n",
 529                         __func__, urb->status);
 530                 break;
 531         default:
 532                 dev_dbg(dev, "%s - nonzero urb status received: %d\n",
 533                         __func__, urb->status);
 534         }
 535 }
 536
 537 #if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
 538 static void xpad_irq_out(struct urb *urb)
 539 {
 540         struct usb_xpad *xpad = urb->context;
 541         struct device *dev = &xpad->intf->dev;
 542         int retval, status;
 543
 544         status = urb->status;
 545
 546         switch (status) {
 547         case 0:
 548                 /* success */
 549                 return;
 550
 551         case -ECONNRESET:
 552         case -ENOENT:
 553         case -ESHUTDOWN:
 554                 /* this urb is terminated, clean up */
 555                 dev_dbg(dev, "%s - urb shutting down with status: %d\n",
 556                         __func__, status);
 557                 return;
 558
 559         default:
 560                 dev_dbg(dev, "%s - nonzero urb status received: %d\n",
 561                         __func__, status);
 562                 goto exit;
 563         }
 564
 565 exit:
 566         retval = usb_submit_urb(urb, GFP_ATOMIC);
 567         if (retval)
 568                 dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
 569                         __func__, retval);
 570 }
 571
 572 static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
 573 {
 574         struct usb_endpoint_descriptor *ep_irq_out;
 575         int error;
 576
 577         if (xpad->xtype == XTYPE_UNKNOWN)
 578                 return 0;
 579
 580         xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,
 581                                          GFP_KERNEL, &xpad->odata_dma);
 582         if (!xpad->odata) {
 583                 error = -ENOMEM;
 584                 goto fail1;
 585         }
 586
 587         mutex_init(&xpad->odata_mutex);
 588
 589         xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
 590         if (!xpad->irq_out) {
 591                 error = -ENOMEM;
 592                 goto fail2;
 593         }
 594
 595         ep_irq_out = &intf->cur_altsetting->endpoint[1].desc;
 596         usb_fill_int_urb(xpad->irq_out, xpad->udev,
 597                          usb_sndintpipe(xpad->udev, ep_irq_out->bEndpointAddress),
 598                          xpad->odata, XPAD_PKT_LEN,
 599                          xpad_irq_out, xpad, ep_irq_out->bInterval);
 600         xpad->irq_out->transfer_dma = xpad->odata_dma;
 601         xpad->irq_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 602
 603         return 0;
 604
 605  fail2: usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
 606  fail1: return error;
 607 }
 608
 609 static void xpad_stop_output(struct usb_xpad *xpad)
 610 {
 611         if (xpad->xtype != XTYPE_UNKNOWN)
 612                 usb_kill_urb(xpad->irq_out);
 613 }
 614
 615 static void xpad_deinit_output(struct usb_xpad *xpad)
 616 {
 617         if (xpad->xtype != XTYPE_UNKNOWN) {
 618                 usb_free_urb(xpad->irq_out);
 619                 usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
 620                                 xpad->odata, xpad->odata_dma);
 621         }
 622 }
 623 #else
 624 static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad) { return 0; }
 625 static void xpad_deinit_output(struct usb_xpad *xpad) {}
 626 static void xpad_stop_output(struct usb_xpad *xpad) {}
 627 #endif
 628
 629 #ifdef CONFIG_JOYSTICK_XPAD_FF
 630 static int xpad_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
 631 {
 632         struct usb_xpad *xpad = input_get_drvdata(dev);
 633
 634         if (effect->type == FF_RUMBLE) {
 635                 __u16 strong = effect->u.rumble.strong_magnitude;
 636                 __u16 weak = effect->u.rumble.weak_magnitude;
 637
 638                 switch (xpad->xtype) {
 639
 640                 case XTYPE_XBOX:
 641                         xpad->odata[0] = 0x00;
 642                         xpad->odata[1] = 0x06;
 643                         xpad->odata[2] = 0x00;
 644                         xpad->odata[3] = strong / 256;  /* left actuator */
 645                         xpad->odata[4] = 0x00;
 646                         xpad->odata[5] = weak / 256;    /* right actuator */
 647                         xpad->irq_out->transfer_buffer_length = 6;
 648
 649                         return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
 650
 651                 case XTYPE_XBOX360:
 652                         xpad->odata[0] = 0x00;
 653                         xpad->odata[1] = 0x08;
 654                         xpad->odata[2] = 0x00;
 655                         xpad->odata[3] = strong / 256;  /* left actuator? */
 656                         xpad->odata[4] = weak / 256;    /* right actuator? */
 657                         xpad->odata[5] = 0x00;
 658                         xpad->odata[6] = 0x00;
 659                         xpad->odata[7] = 0x00;
 660                         xpad->irq_out->transfer_buffer_length = 8;
 661
 662                         return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
 663
 664                 case XTYPE_XBOX360W:
 665                         xpad->odata[0] = 0x00;
 666                         xpad->odata[1] = 0x01;
 667                         xpad->odata[2] = 0x0F;
 668                         xpad->odata[3] = 0xC0;
 669                         xpad->odata[4] = 0x00;
 670                         xpad->odata[5] = strong / 256;
 671                         xpad->odata[6] = weak / 256;
 672                         xpad->odata[7] = 0x00;
 673                         xpad->odata[8] = 0x00;
 674                         xpad->odata[9] = 0x00;
 675                         xpad->odata[10] = 0x00;
 676                         xpad->odata[11] = 0x00;
 677                         xpad->irq_out->transfer_buffer_length = 12;
 678
 679                         return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
 680
 681                 default:
 682                         dev_dbg(&xpad->dev->dev,
 683                                 "%s - rumble command sent to unsupported xpad type: %d\n",
 684                                 __func__, xpad->xtype);
 685                         return -1;
 686                 }
 687         }
 688
 689         return 0;
 690 }
 691
 692 static int xpad_init_ff(struct usb_xpad *xpad)
 693 {
 694         if (xpad->xtype == XTYPE_UNKNOWN)
 695                 return 0;
 696
 697         input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);
 698
 699         return input_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
 700 }
 701
 702 #else
 703 static int xpad_init_ff(struct usb_xpad *xpad) { return 0; }
 704 #endif
 705
 706 #if defined(CONFIG_JOYSTICK_XPAD_LEDS)
 707 #include <linux/leds.h>
 708
 709 struct xpad_led {
 710         char name[16];
 711         struct led_classdev led_cdev;
 712         struct usb_xpad *xpad;
 713 };
 714
 715 static void xpad_send_led_command(struct usb_xpad *xpad, int command)
 716 {
 717         if (command >= 0 && command < 14) {
 718                 mutex_lock(&xpad->odata_mutex);
 719                 xpad->odata[0] = 0x01;
 720                 xpad->odata[1] = 0x03;
 721                 xpad->odata[2] = command;
 722                 xpad->irq_out->transfer_buffer_length = 3;
 723                 usb_submit_urb(xpad->irq_out, GFP_KERNEL);
 724                 mutex_unlock(&xpad->odata_mutex);
 725         }
 726 }
 727
 728 static void xpad_led_set(struct led_classdev *led_cdev,
 729                          enum led_brightness value)
 730 {
 731         struct xpad_led *xpad_led = container_of(led_cdev,
 732                                                  struct xpad_led, led_cdev);
 733
 734         xpad_send_led_command(xpad_led->xpad, value);
 735 }
 736
 737 static int xpad_led_probe(struct usb_xpad *xpad)
 738 {
 739         static atomic_t led_seq = ATOMIC_INIT(0);
 740         long led_no;
 741         struct xpad_led *led;
 742         struct led_classdev *led_cdev;
 743         int error;
 744
 745         if (xpad->xtype != XTYPE_XBOX360)
 746                 return 0;
 747
 748         xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
 749         if (!led)
 750                 return -ENOMEM;
 751
 752         led_no = (long)atomic_inc_return(&led_seq) - 1;
 753
 754         snprintf(led->name, sizeof(led->name), "xpad%ld", led_no);
 755         led->xpad = xpad;
 756
 757         led_cdev = &led->led_cdev;
 758         led_cdev->name = led->name;
 759         led_cdev->brightness_set = xpad_led_set;
 760
 761         error = led_classdev_register(&xpad->udev->dev, led_cdev);
 762         if (error) {
 763                 kfree(led);
 764                 xpad->led = NULL;
 765                 return error;
 766         }
 767
 768         /*
 769          * Light up the segment corresponding to controller number
 770          */
 771         xpad_send_led_command(xpad, (led_no % 4) + 2);
 772
 773         return 0;
 774 }
 775
 776 static void xpad_led_disconnect(struct usb_xpad *xpad)
 777 {
 778         struct xpad_led *xpad_led = xpad->led;
 779
 780         if (xpad_led) {
 781                 led_classdev_unregister(&xpad_led->led_cdev);
 782                 kfree(xpad_led);
 783         }
 784 }
 785 #else
 786 static int xpad_led_probe(struct usb_xpad *xpad) { return 0; }
 787 static void xpad_led_disconnect(struct usb_xpad *xpad) { }
 788 #endif
 789
 790
 791 static int xpad_open(struct input_dev *dev)
 792 {
 793         struct usb_xpad *xpad = input_get_drvdata(dev);
 794
 795         /* URB was submitted in probe */
 796         if (xpad->xtype == XTYPE_XBOX360W)
 797                 return 0;
 798
 799         xpad->irq_in->dev = xpad->udev;
 800         if (usb_submit_urb(xpad->irq_in, GFP_KERNEL))
 801                 return -EIO;
 802
 803         return 0;
 804 }
 805
 806 static void xpad_close(struct input_dev *dev)
 807 {
 808         struct usb_xpad *xpad = input_get_drvdata(dev);
 809
 810         if (xpad->xtype != XTYPE_XBOX360W)
 811                 usb_kill_urb(xpad->irq_in);
 812
 813         xpad_stop_output(xpad);
 814 }
 815
 816 static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs)
 817 {
 818         set_bit(abs, input_dev->absbit);
 819
 820         switch (abs) {
 821         case ABS_X:
 822         case ABS_Y:
 823         case ABS_RX:
 824         case ABS_RY:    /* the two sticks */
 825                 input_set_abs_params(input_dev, abs, -32768, 32767, 16, 128);
 826                 break;
 827         case ABS_Z:
 828         case ABS_RZ:    /* the triggers (if mapped to axes) */
 829                 input_set_abs_params(input_dev, abs, 0, 255, 0, 0);
 830                 break;
 831         case ABS_HAT0X:
 832         case ABS_HAT0Y: /* the d-pad (only if dpad is mapped to axes */
 833                 input_set_abs_params(input_dev, abs, -1, 1, 0, 0);
 834                 break;
 835         }
 836 }
 837
 838 static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id)
 839 {
 840         struct usb_device *udev = interface_to_usbdev(intf);
 841         struct usb_xpad *xpad;
 842         struct input_dev *input_dev;
 843         struct usb_endpoint_descriptor *ep_irq_in;
 844         int i, error;
 845
 846         for (i = 0; xpad_device[i].idVendor; i++) {
 847                 if ((le16_to_cpu(udev->descriptor.idVendor) == xpad_device[i].idVendor) &&
 848                     (le16_to_cpu(udev->descriptor.idProduct) == xpad_device[i].idProduct))
 849                         break;
 850         }
 851
 852         xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);
 853         input_dev = input_allocate_device();
 854         if (!xpad || !input_dev) {
 855                 error = -ENOMEM;
 856                 goto fail1;
 857         }
 858
 859         xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN,
 860                                          GFP_KERNEL, &xpad->idata_dma);
 861         if (!xpad->idata) {
 862                 error = -ENOMEM;
 863                 goto fail1;
 864         }
 865
 866         xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);
 867         if (!xpad->irq_in) {
 868                 error = -ENOMEM;
 869                 goto fail2;
 870         }
 871
 872         xpad->udev = udev;
 873         xpad->intf = intf;
 874         xpad->mapping = xpad_device[i].mapping;
 875         xpad->xtype = xpad_device[i].xtype;
 876
 877         if (xpad->xtype == XTYPE_UNKNOWN) {
 878                 if (intf->cur_altsetting->desc.bInterfaceClass == USB_CLASS_VENDOR_SPEC) {
 879                         if (intf->cur_altsetting->desc.bInterfaceProtocol == 129)
 880                                 xpad->xtype = XTYPE_XBOX360W;
 881                         else
 882                                 xpad->xtype = XTYPE_XBOX360;
 883                 } else
 884                         xpad->xtype = XTYPE_XBOX;
 885
 886                 if (dpad_to_buttons)
 887                         xpad->mapping |= MAP_DPAD_TO_BUTTONS;
 888                 if (triggers_to_buttons)
 889                         xpad->mapping |= MAP_TRIGGERS_TO_BUTTONS;
 890                 if (sticks_to_null)
 891                         xpad->mapping |= MAP_STICKS_TO_NULL;
 892         }
 893
 894         xpad->dev = input_dev;
 895         usb_make_path(udev, xpad->phys, sizeof(xpad->phys));
 896         strlcat(xpad->phys, "/input0", sizeof(xpad->phys));
 897
 898         input_dev->name = xpad_device[i].name;
 899         input_dev->phys = xpad->phys;
 900         usb_to_input_id(udev, &input_dev->id);
 901         input_dev->dev.parent = &intf->dev;
 902
 903         input_set_drvdata(input_dev, xpad);
 904
 905         input_dev->open = xpad_open;
 906         input_dev->close = xpad_close;
 907
 908         input_dev->evbit[0] = BIT_MASK(EV_KEY);
 909
 910         if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
 911                 input_dev->evbit[0] |= BIT_MASK(EV_ABS);
 912                 /* set up axes */
 913                 for (i = 0; xpad_abs[i] >= 0; i++)
 914                         xpad_set_up_abs(input_dev, xpad_abs[i]);
 915         }
 916
 917         /* set up standard buttons */
 918         for (i = 0; xpad_common_btn[i] >= 0; i++)
 919                 __set_bit(xpad_common_btn[i], input_dev->keybit);
 920
 921         /* set up model-specific ones */
 922         if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX360W) {
 923                 for (i = 0; xpad360_btn[i] >= 0; i++)
 924                         __set_bit(xpad360_btn[i], input_dev->keybit);
 925         } else {
 926                 for (i = 0; xpad_btn[i] >= 0; i++)
 927                         __set_bit(xpad_btn[i], input_dev->keybit);
 928         }
 929
 930         if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
 931                 for (i = 0; xpad_btn_pad[i] >= 0; i++)
 932                         __set_bit(xpad_btn_pad[i], input_dev->keybit);
 933         } else {
 934                 for (i = 0; xpad_abs_pad[i] >= 0; i++)
 935                     xpad_set_up_abs(input_dev, xpad_abs_pad[i]);
 936         }
 937
 938         if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
 939                 for (i = 0; xpad_btn_triggers[i] >= 0; i++)
 940                         __set_bit(xpad_btn_triggers[i], input_dev->keybit);
 941         } else {
 942                 for (i = 0; xpad_abs_triggers[i] >= 0; i++)
 943                         xpad_set_up_abs(input_dev, xpad_abs_triggers[i]);
 944         }
 945
 946         error = xpad_init_output(intf, xpad);
 947         if (error)
 948                 goto fail3;
 949
 950         error = xpad_init_ff(xpad);
 951         if (error)
 952                 goto fail4;
 953
 954         error = xpad_led_probe(xpad);
 955         if (error)
 956                 goto fail5;
 957
 958         ep_irq_in = &intf->cur_altsetting->endpoint[0].desc;
 959         usb_fill_int_urb(xpad->irq_in, udev,
 960                          usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),
 961                          xpad->idata, XPAD_PKT_LEN, xpad_irq_in,
 962                          xpad, ep_irq_in->bInterval);
 963         xpad->irq_in->transfer_dma = xpad->idata_dma;
 964         xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 965
 966         error = input_register_device(xpad->dev);
 967         if (error)
 968                 goto fail6;
 969
 970         usb_set_intfdata(intf, xpad);
 971
 972         if (xpad->xtype == XTYPE_XBOX360W) {
 973                 /*
 974                  * Setup the message to set the LEDs on the
 975                  * controller when it shows up
 976                  */
 977                 xpad->bulk_out = usb_alloc_urb(0, GFP_KERNEL);
 978                 if (!xpad->bulk_out) {
 979                         error = -ENOMEM;
 980                         goto fail7;
 981                 }
 982
 983                 xpad->bdata = kzalloc(XPAD_PKT_LEN, GFP_KERNEL);
 984                 if (!xpad->bdata) {
 985                         error = -ENOMEM;
 986                         goto fail8;
 987                 }
 988
 989                 xpad->bdata[2] = 0x08;
 990                 switch (intf->cur_altsetting->desc.bInterfaceNumber) {
 991                 case 0:
 992                         xpad->bdata[3] = 0x42;
 993                         break;
 994                 case 2:
 995                         xpad->bdata[3] = 0x43;
 996                         break;
 997                 case 4:
 998                         xpad->bdata[3] = 0x44;
 999                         break;
1000                 case 6:
1001                         xpad->bdata[3] = 0x45;
1002                 }
1003
1004                 ep_irq_in = &intf->cur_altsetting->endpoint[1].desc;
1005                 usb_fill_bulk_urb(xpad->bulk_out, udev,
1006                                 usb_sndbulkpipe(udev, ep_irq_in->bEndpointAddress),
1007                                 xpad->bdata, XPAD_PKT_LEN, xpad_bulk_out, xpad);
1008
1009                 /*
1010                  * Submit the int URB immediately rather than waiting for open
1011                  * because we get status messages from the device whether
1012                  * or not any controllers are attached.  In fact, it's
1013                  * exactly the message that a controller has arrived that
1014                  * we're waiting for.
1015                  */
1016                 xpad->irq_in->dev = xpad->udev;
1017                 error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);
1018                 if (error)
1019                         goto fail9;
1020         }
1021
1022         return 0;
1023
1024  fail9: kfree(xpad->bdata);
1025  fail8: usb_free_urb(xpad->bulk_out);
1026  fail7: input_unregister_device(input_dev);
1027         input_dev = NULL;
1028  fail6: xpad_led_disconnect(xpad);
1029  fail5: if (input_dev)
1030                 input_ff_destroy(input_dev);
1031  fail4: xpad_deinit_output(xpad);
1032  fail3: usb_free_urb(xpad->irq_in);
1033  fail2: usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
1034  fail1: input_free_device(input_dev);
1035         kfree(xpad);
1036         return error;
1037
1038 }
1039
1040 static void xpad_disconnect(struct usb_interface *intf)
1041 {
1042         struct usb_xpad *xpad = usb_get_intfdata (intf);
1043
1044         xpad_led_disconnect(xpad);
1045         input_unregister_device(xpad->dev);
1046         xpad_deinit_output(xpad);
1047
1048         if (xpad->xtype == XTYPE_XBOX360W) {
1049                 usb_kill_urb(xpad->bulk_out);
1050                 usb_free_urb(xpad->bulk_out);
1051                 usb_kill_urb(xpad->irq_in);
1052         }
1053
1054         usb_free_urb(xpad->irq_in);
1055         usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
1056                         xpad->idata, xpad->idata_dma);
1057
1058         kfree(xpad->bdata);
1059         kfree(xpad);
1060
1061         usb_set_intfdata(intf, NULL);
1062 }
1063
1064 static struct usb_driver xpad_driver = {
1065         .name           = "xpad",
1066         .probe          = xpad_probe,
1067         .disconnect     = xpad_disconnect,
1068         .id_table       = xpad_table,
1069 };
1070
1071 module_usb_driver(xpad_driver);
1072
1073 MODULE_AUTHOR(DRIVER_AUTHOR);
1074 MODULE_DESCRIPTION(DRIVER_DESC);
1075 MODULE_LICENSE("GPL");