Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us