API tools faq
paste
Advertisement
Guest User

Untitled

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