본문 바로가기
카테고리 없음

Power A Batarang Controller Driver

mercarmetmo1971 2020. 12. 10. 19:24


Power A does just that with their Batarang Wireless Controller for the PS3. The Batarang Wireless Controller is a SIXAXIS-compatible PS3 wireless controller, with an awesome-looking design that says (in a gruff, hard-to-understand voice): 'I'm Batman!' The Batman: Arkham City game is getting its own official, LED-lit, batarang controllers.

Permalink

Join GitHub today

GitHub is home to over 36 million developers working together to host and review code, manage projects, and build software together.

Adobe Dreamweaver cc 2015 free download is the most beloved software for web designers, also web developers.Dreamweaver cc 2015 allows you to create websites, forums and also blogs. https://uljxkv.over-blog.com/2020/11/adobe-dreamweaver-cc-2015-download-for-mac.html. The monster among website and forums editor. Dreamweaver CC 2015 16.1.2, known also as adobe Dreamweaver cc.

Sign up
Find file Copy path
Thomas Gleixnertreewide: Replace GPLv2 boilerplate/reference with SPDX - rule 1561a59d1bMay 30, 2019
63 contributors
Power A Batarang Controller Driver
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* X-Box gamepad driver
*
* Copyright (c) 2002 Marko Friedemann <mfr@bmx-chemnitz.de>
* 2004 Oliver Schwartz <Oliver.Schwartz@gmx.de>,
* Steven Toth <steve@toth.demon.co.uk>,
* Franz Lehner <franz@caos.at>,
* Ivan Hawkes <blackhawk@ivanhawkes.com>
* 2005 Dominic Cerquetti <binary1230@yahoo.com>
* 2006 Adam Buchbinder <adam.buchbinder@gmail.com>
* 2007 Jan Kratochvil <honza@jikos.cz>
* 2010 Christoph Fritz <chf.fritz@googlemail.com>
*
* This driver is based on:
* - information from http://euc.jp/periphs/xbox-controller.ja.html
* - the iForce driver drivers/char/joystick/iforce.c
* - the skeleton-driver drivers/usb/usb-skeleton.c
* - Xbox 360 information http://www.free60.org/wiki/Gamepad
* - Xbox One information https://github.com/quantus/xbox-one-controller-protocol
*
* Thanks to:
* - ITO Takayuki for providing essential xpad information on his website
* - Vojtech Pavlik - iforce driver / input subsystem
* - Greg Kroah-Hartman - usb-skeleton driver
* - XBOX Linux project - extra USB id's
* - Pekka Pöyry (quantus) - Xbox One controller reverse engineering
*
* TODO:
* - fine tune axes (especially trigger axes)
* - fix 'analog' buttons (reported as digital now)
* - get rumble working
* - need USB IDs for other dance pads
*
* History:
*
* 2002-06-27 - 0.0.1 : first version, just said 'XBOX HID controller'
*
* 2002-07-02 - 0.0.2 : basic working version
* - all axes and 9 of the 10 buttons work (german InterAct device)
* - the black button does not work
*
* 2002-07-14 - 0.0.3 : rework by Vojtech Pavlik
* - indentation fixes
* - usb + input init sequence fixes
*
* 2002-07-16 - 0.0.4 : minor changes, merge with Vojtech's v0.0.3
* - verified the lack of HID and report descriptors
* - verified that ALL buttons WORK
* - fixed d-pad to axes mapping
*
* 2002-07-17 - 0.0.5 : simplified d-pad handling
*
* 2004-10-02 - 0.0.6 : DDR pad support
* - borrowed from the XBOX linux kernel
* - USB id's for commonly used dance pads are present
* - dance pads will map D-PAD to buttons, not axes
* - pass the module paramater 'dpad_to_buttons' to force
* the D-PAD to map to buttons if your pad is not detected
*
* Later changes can be tracked in SCM.
*/
#include<linux/kernel.h>
#include<linux/input.h>
#include<linux/rcupdate.h>
#include<linux/slab.h>
#include<linux/stat.h>
#include<linux/module.h>
#include<linux/usb/input.h>
#include<linux/usb/quirks.h>
#defineXPAD_PKT_LEN64
/*
* xbox d-pads should map to buttons, as is required for DDR pads
* but we map them to axes when possible to simplify things
*/
#defineMAP_DPAD_TO_BUTTONS (1 << 0)
#defineMAP_TRIGGERS_TO_BUTTONS (1 << 1)
#defineMAP_STICKS_TO_NULL (1 << 2)
#defineDANCEPAD_MAP_CONFIG (MAP_DPAD_TO_BUTTONS |
MAP_TRIGGERS_TO_BUTTONS | MAP_STICKS_TO_NULL)
#defineXTYPE_XBOX0
#defineXTYPE_XBOX3601
#defineXTYPE_XBOX360W2
#defineXTYPE_XBOXONE3
#defineXTYPE_UNKNOWN4
staticbool dpad_to_buttons;
module_param(dpad_to_buttons, bool, S_IRUGO);
MODULE_PARM_DESC(dpad_to_buttons, 'Map D-PAD to buttons rather than axes for unknown pads');
staticbool triggers_to_buttons;
module_param(triggers_to_buttons, bool, S_IRUGO);
MODULE_PARM_DESC(triggers_to_buttons, 'Map triggers to buttons rather than axes for unknown pads');
staticbool sticks_to_null;
module_param(sticks_to_null, bool, S_IRUGO);
MODULE_PARM_DESC(sticks_to_null, 'Do not map sticks at all for unknown pads');
staticbool auto_poweroff = true;
module_param(auto_poweroff, bool, S_IWUSR | S_IRUGO);
MODULE_PARM_DESC(auto_poweroff, 'Power off wireless controllers on suspend');
staticconststruct xpad_device {
u16 idVendor;
u16 idProduct;
char *name;
u8 mapping;
u8 xtype;
} xpad_device[] = {
{ 0x0079, 0x18d4, 'GPD Win 2 X-Box Controller', 0, XTYPE_XBOX360 },
{ 0x044f, 0x0f00, 'Thrustmaster Wheel', 0, XTYPE_XBOX },
{ 0x044f, 0x0f03, 'Thrustmaster Wheel', 0, XTYPE_XBOX },
{ 0x044f, 0x0f07, 'Thrustmaster, Inc. Controller', 0, XTYPE_XBOX },
{ 0x044f, 0x0f10, 'Thrustmaster Modena GT Wheel', 0, XTYPE_XBOX },
{ 0x044f, 0xb326, 'Thrustmaster Gamepad GP XID', 0, XTYPE_XBOX360 },
{ 0x045e, 0x0202, 'Microsoft X-Box pad v1 (US)', 0, XTYPE_XBOX },
{ 0x045e, 0x0285, 'Microsoft X-Box pad (Japan)', 0, XTYPE_XBOX },
{ 0x045e, 0x0287, 'Microsoft Xbox Controller S', 0, XTYPE_XBOX },
{ 0x045e, 0x0288, 'Microsoft Xbox Controller S v2', 0, XTYPE_XBOX },
{ 0x045e, 0x0289, 'Microsoft X-Box pad v2 (US)', 0, XTYPE_XBOX },
{ 0x045e, 0x028e, 'Microsoft X-Box 360 pad', 0, XTYPE_XBOX360 },
{ 0x045e, 0x028f, 'Microsoft X-Box 360 pad v2', 0, XTYPE_XBOX360 },
{ 0x045e, 0x0291, 'Xbox 360 Wireless Receiver (XBOX)', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
{ 0x045e, 0x02d1, 'Microsoft X-Box One pad', 0, XTYPE_XBOXONE },
{ 0x045e, 0x02dd, 'Microsoft X-Box One pad (Firmware 2015)', 0, XTYPE_XBOXONE },
{ 0x045e, 0x02e3, 'Microsoft X-Box One Elite pad', 0, XTYPE_XBOXONE },
{ 0x045e, 0x02ea, 'Microsoft X-Box One S pad', 0, XTYPE_XBOXONE },
{ 0x045e, 0x0719, 'Xbox 360 Wireless Receiver', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
{ 0x046d, 0xc21d, 'Logitech Gamepad F310', 0, XTYPE_XBOX360 },
{ 0x046d, 0xc21e, 'Logitech Gamepad F510', 0, XTYPE_XBOX360 },
{ 0x046d, 0xc21f, 'Logitech Gamepad F710', 0, XTYPE_XBOX360 },
{ 0x046d, 0xc242, 'Logitech Chillstream Controller', 0, XTYPE_XBOX360 },
{ 0x046d, 0xca84, 'Logitech Xbox Cordless Controller', 0, XTYPE_XBOX },
{ 0x046d, 0xca88, 'Logitech Compact Controller for Xbox', 0, XTYPE_XBOX },
{ 0x046d, 0xca8a, 'Logitech Precision Vibration Feedback Wheel', 0, XTYPE_XBOX },
{ 0x046d, 0xcaa3, 'Logitech DriveFx Racing Wheel', 0, XTYPE_XBOX360 },
{ 0x056e, 0x2004, 'Elecom JC-U3613M', 0, XTYPE_XBOX360 },
{ 0x05fd, 0x1007, 'Mad Catz Controller (unverified)', 0, XTYPE_XBOX },
{ 0x05fd, 0x107a, 'InterAct 'PowerPad Pro' X-Box pad (Germany)', 0, XTYPE_XBOX },
{ 0x05fe, 0x3030, 'Chic Controller', 0, XTYPE_XBOX },
{ 0x05fe, 0x3031, 'Chic Controller', 0, XTYPE_XBOX },
{ 0x062a, 0x0020, 'Logic3 Xbox GamePad', 0, XTYPE_XBOX },
{ 0x062a, 0x0033, 'Competition Pro Steering Wheel', 0, XTYPE_XBOX },
{ 0x06a3, 0x0200, 'Saitek Racing Wheel', 0, XTYPE_XBOX },
{ 0x06a3, 0x0201, 'Saitek Adrenalin', 0, XTYPE_XBOX },
{ 0x06a3, 0xf51a, 'Saitek P3600', 0, XTYPE_XBOX360 },
{ 0x0738, 0x4506, 'Mad Catz 4506 Wireless Controller', 0, XTYPE_XBOX },
{ 0x0738, 0x4516, 'Mad Catz Control Pad', 0, XTYPE_XBOX },
{ 0x0738, 0x4520, 'Mad Catz Control Pad Pro', 0, XTYPE_XBOX },
{ 0x0738, 0x4522, 'Mad Catz LumiCON', 0, XTYPE_XBOX },
{ 0x0738, 0x4526, 'Mad Catz Control Pad Pro', 0, XTYPE_XBOX },
{ 0x0738, 0x4530, 'Mad Catz Universal MC2 Racing Wheel and Pedals', 0, XTYPE_XBOX },
{ 0x0738, 0x4536, 'Mad Catz MicroCON', 0, XTYPE_XBOX },
{ 0x0738, 0x4540, 'Mad Catz Beat Pad', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
{ 0x0738, 0x4556, 'Mad Catz Lynx Wireless Controller', 0, XTYPE_XBOX },
{ 0x0738, 0x4586, 'Mad Catz MicroCon Wireless Controller', 0, XTYPE_XBOX },
{ 0x0738, 0x4588, 'Mad Catz Blaster', 0, XTYPE_XBOX },
{ 0x0738, 0x45ff, 'Mad Catz Beat Pad (w/ Handle)', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
{ 0x0738, 0x4716, 'Mad Catz Wired Xbox 360 Controller', 0, XTYPE_XBOX360 },
{ 0x0738, 0x4718, 'Mad Catz Street Fighter IV FightStick SE', 0, XTYPE_XBOX360 },
{ 0x0738, 0x4726, 'Mad Catz Xbox 360 Controller', 0, XTYPE_XBOX360 },
{ 0x0738, 0x4728, 'Mad Catz Street Fighter IV FightPad', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x0738, 0x4736, 'Mad Catz MicroCon Gamepad', 0, XTYPE_XBOX360 },
{ 0x0738, 0x4738, 'Mad Catz Wired Xbox 360 Controller (SFIV)', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x0738, 0x4740, 'Mad Catz Beat Pad', 0, XTYPE_XBOX360 },
{ 0x0738, 0x4743, 'Mad Catz Beat Pad Pro', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
{ 0x0738, 0x4758, 'Mad Catz Arcade Game Stick', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x0738, 0x4a01, 'Mad Catz FightStick TE 2', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOXONE },
{ 0x0738, 0x6040, 'Mad Catz Beat Pad Pro', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
{ 0x0738, 0x9871, 'Mad Catz Portable Drum', 0, XTYPE_XBOX360 },
{ 0x0738, 0xb726, 'Mad Catz Xbox controller - MW2', 0, XTYPE_XBOX360 },
{ 0x0738, 0xb738, 'Mad Catz MVC2TE Stick 2', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x0738, 0xbeef, 'Mad Catz JOYTECH NEO SE Advanced GamePad', XTYPE_XBOX360 },
{ 0x0738, 0xcb02, 'Saitek Cyborg Rumble Pad - PC/Xbox 360', 0, XTYPE_XBOX360 },
{ 0x0738, 0xcb03, 'Saitek P3200 Rumble Pad - PC/Xbox 360', 0, XTYPE_XBOX360 },
{ 0x0738, 0xcb29, 'Saitek Aviator Stick AV8R02', 0, XTYPE_XBOX360 },
{ 0x0738, 0xf738, 'Super SFIV FightStick TE S', 0, XTYPE_XBOX360 },
{ 0x07ff, 0xffff, 'Mad Catz GamePad', 0, XTYPE_XBOX360 },
{ 0x0c12, 0x0005, 'Intec wireless', 0, XTYPE_XBOX },
{ 0x0c12, 0x8801, 'Nyko Xbox Controller', 0, XTYPE_XBOX },
{ 0x0c12, 0x8802, 'Zeroplus Xbox Controller', 0, XTYPE_XBOX },
{ 0x0c12, 0x8809, 'RedOctane Xbox Dance Pad', DANCEPAD_MAP_CONFIG, XTYPE_XBOX },
{ 0x0c12, 0x880a, 'Pelican Eclipse PL-2023', 0, XTYPE_XBOX },
{ 0x0c12, 0x8810, 'Zeroplus Xbox Controller', 0, XTYPE_XBOX },
{ 0x0c12, 0x9902, 'HAMA VibraX - *FAULTY HARDWARE*', 0, XTYPE_XBOX },
{ 0x0d2f, 0x0002, 'Andamiro Pump It Up pad', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
{ 0x0e4c, 0x1097, 'Radica Gamester Controller', 0, XTYPE_XBOX },
{ 0x0e4c, 0x1103, 'Radica Gamester Reflex', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX },
{ 0x0e4c, 0x2390, 'Radica Games Jtech Controller', 0, XTYPE_XBOX },
{ 0x0e4c, 0x3510, 'Radica Gamester', 0, XTYPE_XBOX },
{ 0x0e6f, 0x0003, 'Logic3 Freebird wireless Controller', 0, XTYPE_XBOX },
{ 0x0e6f, 0x0005, 'Eclipse wireless Controller', 0, XTYPE_XBOX },
{ 0x0e6f, 0x0006, 'Edge wireless Controller', 0, XTYPE_XBOX },
{ 0x0e6f, 0x0008, 'After Glow Pro Controller', 0, XTYPE_XBOX },
{ 0x0e6f, 0x0105, 'HSM3 Xbox360 dancepad', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x0e6f, 0x0113, 'Afterglow AX.1 Gamepad for Xbox 360', 0, XTYPE_XBOX360 },
{ 0x0e6f, 0x011f, 'Rock Candy Gamepad Wired Controller', 0, XTYPE_XBOX360 },
{ 0x0e6f, 0x0131, 'PDP EA Sports Controller', 0, XTYPE_XBOX360 },
{ 0x0e6f, 0x0133, 'Xbox 360 Wired Controller', 0, XTYPE_XBOX360 },
{ 0x0e6f, 0x0139, 'Afterglow Prismatic Wired Controller', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x013a, 'PDP Xbox One Controller', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x0146, 'Rock Candy Wired Controller for Xbox One', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x0147, 'PDP Marvel Xbox One Controller', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x015c, 'PDP Xbox One Arcade Stick', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOXONE },
{ 0x0e6f, 0x0161, 'PDP Xbox One Controller', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x0162, 'PDP Xbox One Controller', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x0163, 'PDP Xbox One Controller', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x0164, 'PDP Battlefield One', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x0165, 'PDP Titanfall 2', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x0201, 'Pelican PL-3601 'TSZ' Wired Xbox 360 Controller', 0, XTYPE_XBOX360 },
{ 0x0e6f, 0x0213, 'Afterglow Gamepad for Xbox 360', 0, XTYPE_XBOX360 },
{ 0x0e6f, 0x021f, 'Rock Candy Gamepad for Xbox 360', 0, XTYPE_XBOX360 },
{ 0x0e6f, 0x0246, 'Rock Candy Gamepad for Xbox One 2015', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x02ab, 'PDP Controller for Xbox One', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x02a4, 'PDP Wired Controller for Xbox One - Stealth Series', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x02a6, 'PDP Wired Controller for Xbox One - Camo Series', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x0301, 'Logic3 Controller', 0, XTYPE_XBOX360 },
{ 0x0e6f, 0x0346, 'Rock Candy Gamepad for Xbox One 2016', 0, XTYPE_XBOXONE },
{ 0x0e6f, 0x0401, 'Logic3 Controller', 0, XTYPE_XBOX360 },
{ 0x0e6f, 0x0413, 'Afterglow AX.1 Gamepad for Xbox 360', 0, XTYPE_XBOX360 },
{ 0x0e6f, 0x0501, 'PDP Xbox 360 Controller', 0, XTYPE_XBOX360 },
{ 0x0e6f, 0xf900, 'PDP Afterglow AX.1', 0, XTYPE_XBOX360 },
{ 0x0e8f, 0x0201, 'SmartJoy Frag Xpad/PS2 adaptor', 0, XTYPE_XBOX },
{ 0x0e8f, 0x3008, 'Generic xbox control (dealextreme)', 0, XTYPE_XBOX },
{ 0x0f0d, 0x000a, 'Hori Co. DOA4 FightStick', 0, XTYPE_XBOX360 },
{ 0x0f0d, 0x000c, 'Hori PadEX Turbo', 0, XTYPE_XBOX360 },
{ 0x0f0d, 0x000d, 'Hori Fighting Stick EX2', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x0f0d, 0x0016, 'Hori Real Arcade Pro.EX', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x0f0d, 0x001b, 'Hori Real Arcade Pro VX', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x0f0d, 0x0063, 'Hori Real Arcade Pro Hayabusa (USA) Xbox One', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOXONE },
{ 0x0f0d, 0x0067, 'HORIPAD ONE', 0, XTYPE_XBOXONE },
{ 0x0f0d, 0x0078, 'Hori Real Arcade Pro V Kai Xbox One', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOXONE },
{ 0x0f30, 0x010b, 'Philips Recoil', 0, XTYPE_XBOX },
{ 0x0f30, 0x0202, 'Joytech Advanced Controller', 0, XTYPE_XBOX },
{ 0x0f30, 0x8888, 'BigBen XBMiniPad Controller', 0, XTYPE_XBOX },
{ 0x102c, 0xff0c, 'Joytech Wireless Advanced Controller', 0, XTYPE_XBOX },
{ 0x1038, 0x1430, 'SteelSeries Stratus Duo', 0, XTYPE_XBOX360 },
{ 0x1038, 0x1431, 'SteelSeries Stratus Duo', 0, XTYPE_XBOX360 },
{ 0x11c9, 0x55f0, 'Nacon GC-100XF', 0, XTYPE_XBOX360 },
{ 0x12ab, 0x0004, 'Honey Bee Xbox360 dancepad', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x12ab, 0x0301, 'PDP AFTERGLOW AX.1', 0, XTYPE_XBOX360 },
{ 0x12ab, 0x0303, 'Mortal Kombat Klassic FightStick', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x12ab, 0x8809, 'Xbox DDR dancepad', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
{ 0x1430, 0x4748, 'RedOctane Guitar Hero X-plorer', 0, XTYPE_XBOX360 },
{ 0x1430, 0x8888, 'TX6500+ Dance Pad (first generation)', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
{ 0x1430, 0xf801, 'RedOctane Controller', 0, XTYPE_XBOX360 },
{ 0x146b, 0x0601, 'BigBen Interactive XBOX 360 Controller', 0, XTYPE_XBOX360 },
{ 0x1532, 0x0037, 'Razer Sabertooth', 0, XTYPE_XBOX360 },
{ 0x1532, 0x0a00, 'Razer Atrox Arcade Stick', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOXONE },
{ 0x1532, 0x0a03, 'Razer Wildcat', 0, XTYPE_XBOXONE },
{ 0x15e4, 0x3f00, 'Power A Mini Pro Elite', 0, XTYPE_XBOX360 },
{ 0x15e4, 0x3f0a, 'Xbox Airflo wired controller', 0, XTYPE_XBOX360 },
{ 0x15e4, 0x3f10, 'Batarang Xbox 360 controller', 0, XTYPE_XBOX360 },
{ 0x162e, 0xbeef, 'Joytech Neo-Se Take2', 0, XTYPE_XBOX360 },
{ 0x1689, 0xfd00, 'Razer Onza Tournament Edition', 0, XTYPE_XBOX360 },
{ 0x1689, 0xfd01, 'Razer Onza Classic Edition', 0, XTYPE_XBOX360 },
{ 0x1689, 0xfe00, 'Razer Sabertooth', 0, XTYPE_XBOX360 },
{ 0x1bad, 0x0002, 'Harmonix Rock Band Guitar', 0, XTYPE_XBOX360 },
{ 0x1bad, 0x0003, 'Harmonix Rock Band Drumkit', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0x0130, 'Ion Drum Rocker', MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf016, 'Mad Catz Xbox 360 Controller', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf018, 'Mad Catz Street Fighter IV SE Fighting Stick', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf019, 'Mad Catz Brawlstick for Xbox 360', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf021, 'Mad Cats Ghost Recon FS GamePad', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf023, 'MLG Pro Circuit Controller (Xbox)', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf025, 'Mad Catz Call Of Duty', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf027, 'Mad Catz FPS Pro', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf028, 'Street Fighter IV FightPad', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf02e, 'Mad Catz Fightpad', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf030, 'Mad Catz Xbox 360 MC2 MicroCon Racing Wheel', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf036, 'Mad Catz MicroCon GamePad Pro', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf038, 'Street Fighter IV FightStick TE', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf039, 'Mad Catz MvC2 TE', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf03a, 'Mad Catz SFxT Fightstick Pro', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf03d, 'Street Fighter IV Arcade Stick TE - Chun Li', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf03e, 'Mad Catz MLG FightStick TE', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf03f, 'Mad Catz FightStick SoulCaliber', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf042, 'Mad Catz FightStick TES+', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf080, 'Mad Catz FightStick TE2', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf501, 'HoriPad EX2 Turbo', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf502, 'Hori Real Arcade Pro.VX SA', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf503, 'Hori Fighting Stick VX', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf504, 'Hori Real Arcade Pro. EX', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf505, 'Hori Fighting Stick EX2B', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xf506, 'Hori Real Arcade Pro.EX Premium VLX', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf900, 'Harmonix Xbox 360 Controller', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf901, 'Gamestop Xbox 360 Controller', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf903, 'Tron Xbox 360 controller', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf904, 'PDP Versus Fighting Pad', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xf906, 'MortalKombat FightStick', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x1bad, 0xfa01, 'MadCatz GamePad', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xfd00, 'Razer Onza TE', 0, XTYPE_XBOX360 },
{ 0x1bad, 0xfd01, 'Razer Onza', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x5000, 'Razer Atrox Arcade Stick', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x24c6, 0x5300, 'PowerA MINI PROEX Controller', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x5303, 'Xbox Airflo wired controller', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x530a, 'Xbox 360 Pro EX Controller', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x531a, 'PowerA Pro Ex', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x5397, 'FUS1ON Tournament Controller', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x541a, 'PowerA Xbox One Mini Wired Controller', 0, XTYPE_XBOXONE },
{ 0x24c6, 0x542a, 'Xbox ONE spectra', 0, XTYPE_XBOXONE },
{ 0x24c6, 0x543a, 'PowerA Xbox One wired controller', 0, XTYPE_XBOXONE },
{ 0x24c6, 0x5500, 'Hori XBOX 360 EX 2 with Turbo', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x5501, 'Hori Real Arcade Pro VX-SA', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x5502, 'Hori Fighting Stick VX Alt', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x24c6, 0x5503, 'Hori Fighting Edge', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x24c6, 0x5506, 'Hori SOULCALIBUR V Stick', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x550d, 'Hori GEM Xbox controller', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x550e, 'Hori Real Arcade Pro V Kai 360', MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
{ 0x24c6, 0x551a, 'PowerA FUSION Pro Controller', 0, XTYPE_XBOXONE },
{ 0x24c6, 0x561a, 'PowerA FUSION Controller', 0, XTYPE_XBOXONE },
{ 0x24c6, 0x5b00, 'ThrustMaster Ferrari 458 Racing Wheel', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x5b02, 'Thrustmaster, Inc. GPX Controller', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x5b03, 'Thrustmaster Ferrari 458 Racing Wheel', 0, XTYPE_XBOX360 },
{ 0x24c6, 0x5d04, 'Razer Sabertooth', 0, XTYPE_XBOX360 },
{ 0x24c6, 0xfafe, 'Rock Candy Gamepad for Xbox 360', 0, XTYPE_XBOX360 },
{ 0x3767, 0x0101, 'Fanatec Speedster 3 Forceshock Wheel', 0, XTYPE_XBOX },
{ 0xffff, 0xffff, 'Chinese-made Xbox Controller', 0, XTYPE_XBOX },
{ 0x0000, 0x0000, 'Generic X-Box pad', 0, XTYPE_UNKNOWN }
};
/* buttons shared with xbox and xbox360 */
staticconstsignedshort xpad_common_btn[] = {
BTN_A, BTN_B, BTN_X, BTN_Y, /* 'analog' buttons */
BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR, /* start/back/sticks */
-1/* terminating entry */
};
/* original xbox controllers only */
staticconstsignedshort xpad_btn[] = {
BTN_C, BTN_Z, /* 'analog' buttons */
-1/* terminating entry */
};
/* used when dpad is mapped to buttons */
staticconstsignedshort xpad_btn_pad[] = {
BTN_TRIGGER_HAPPY1, BTN_TRIGGER_HAPPY2, /* d-pad left, right */
BTN_TRIGGER_HAPPY3, BTN_TRIGGER_HAPPY4, /* d-pad up, down */
-1/* terminating entry */
};
/* used when triggers are mapped to buttons */
staticconstsignedshort xpad_btn_triggers[] = {
BTN_TL2, BTN_TR2, /* triggers left/right */
-1
};
staticconstsignedshort xpad360_btn[] = { /* buttons for x360 controller */
BTN_TL, BTN_TR, /* Button LB/RB */
BTN_MODE, /* The big X button */
-1
};
staticconstsignedshort xpad_abs[] = {
ABS_X, ABS_Y, /* left stick */
ABS_RX, ABS_RY, /* right stick */
-1/* terminating entry */
};
/* used when dpad is mapped to axes */
staticconstsignedshort xpad_abs_pad[] = {
ABS_HAT0X, ABS_HAT0Y, /* d-pad axes */
-1/* terminating entry */
};
/* used when triggers are mapped to axes */
staticconstsignedshort xpad_abs_triggers[] = {
ABS_Z, ABS_RZ, /* triggers left/right */
-1
};
/*
* Xbox 360 has a vendor-specific class, so we cannot match it with only
* USB_INTERFACE_INFO (also specifically refused by USB subsystem), so we
* match against vendor id as well. Wired Xbox 360 devices have protocol 1,
* wireless controllers have protocol 129.
*/
#defineXPAD_XBOX360_VENDOR_PROTOCOL(vend, pr)
.match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO,
.idVendor = (vend),
.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
.bInterfaceSubClass = 93,
.bInterfaceProtocol = (pr)
#defineXPAD_XBOX360_VENDOR(vend)
{ XPAD_XBOX360_VENDOR_PROTOCOL((vend), 1) },
{ XPAD_XBOX360_VENDOR_PROTOCOL((vend), 129) }
/* The Xbox One controller uses subclass 71 and protocol 208. */
#defineXPAD_XBOXONE_VENDOR_PROTOCOL(vend, pr)
.match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO,
.idVendor = (vend),
.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
.bInterfaceSubClass = 71,
.bInterfaceProtocol = (pr)
#defineXPAD_XBOXONE_VENDOR(vend)
{ XPAD_XBOXONE_VENDOR_PROTOCOL((vend), 208) }
staticconststruct usb_device_id xpad_table[] = {
{ USB_INTERFACE_INFO('X', 'B', 0) }, /* X-Box USB-IF not approved class */
XPAD_XBOX360_VENDOR(0x0079), /* GPD Win 2 Controller */
XPAD_XBOX360_VENDOR(0x044f), /* Thrustmaster X-Box 360 controllers */
XPAD_XBOX360_VENDOR(0x045e), /* Microsoft X-Box 360 controllers */
XPAD_XBOXONE_VENDOR(0x045e), /* Microsoft X-Box One controllers */
XPAD_XBOX360_VENDOR(0x046d), /* Logitech X-Box 360 style controllers */
XPAD_XBOX360_VENDOR(0x056e), /* Elecom JC-U3613M */
XPAD_XBOX360_VENDOR(0x06a3), /* Saitek P3600 */
XPAD_XBOX360_VENDOR(0x0738), /* Mad Catz X-Box 360 controllers */
{ USB_DEVICE(0x0738, 0x4540) }, /* Mad Catz Beat Pad */
XPAD_XBOXONE_VENDOR(0x0738), /* Mad Catz FightStick TE 2 */
XPAD_XBOX360_VENDOR(0x07ff), /* Mad Catz GamePad */
XPAD_XBOX360_VENDOR(0x0e6f), /* 0x0e6f X-Box 360 controllers */
XPAD_XBOXONE_VENDOR(0x0e6f), /* 0x0e6f X-Box One controllers */
XPAD_XBOX360_VENDOR(0x0f0d), /* Hori Controllers */
XPAD_XBOXONE_VENDOR(0x0f0d), /* Hori Controllers */
XPAD_XBOX360_VENDOR(0x1038), /* SteelSeries Controllers */
XPAD_XBOX360_VENDOR(0x11c9), /* Nacon GC100XF */
XPAD_XBOX360_VENDOR(0x12ab), /* X-Box 360 dance pads */
XPAD_XBOX360_VENDOR(0x1430), /* RedOctane X-Box 360 controllers */
XPAD_XBOX360_VENDOR(0x146b), /* BigBen Interactive Controllers */
XPAD_XBOX360_VENDOR(0x1532), /* Razer Sabertooth */
XPAD_XBOXONE_VENDOR(0x1532), /* Razer Wildcat */
XPAD_XBOX360_VENDOR(0x15e4), /* Numark X-Box 360 controllers */
XPAD_XBOX360_VENDOR(0x162e), /* Joytech X-Box 360 controllers */
XPAD_XBOX360_VENDOR(0x1689), /* Razer Onza */
XPAD_XBOX360_VENDOR(0x1bad), /* Harminix Rock Band Guitar and Drums */
XPAD_XBOX360_VENDOR(0x24c6), /* PowerA Controllers */
XPAD_XBOXONE_VENDOR(0x24c6), /* PowerA Controllers */
{ }
};
MODULE_DEVICE_TABLE(usb, xpad_table);
struct xboxone_init_packet {
u16 idVendor;
u16 idProduct;
const u8 *data;
u8 len;
};
#defineXBOXONE_INIT_PKT(_vid, _pid, _data)
{
.idVendor = (_vid),
.idProduct = (_pid),
.data = (_data),
.len = ARRAY_SIZE(_data),
}
/*
* This packet is required for all Xbox One pads with 2015
* or later firmware installed (or present from the factory).
*/
staticconst u8 xboxone_fw2015_init[] = {
0x05, 0x20, 0x00, 0x01, 0x00
};
/*
* This packet is required for the Titanfall 2 Xbox One pads
* (0x0e6f:0x0165) to finish initialization and for Hori pads
* (0x0f0d:0x0067) to make the analog sticks work.
*/
staticconst u8 xboxone_hori_init[] = {
0x01, 0x20, 0x00, 0x09, 0x00, 0x04, 0x20, 0x3a,
0x00, 0x00, 0x00, 0x80, 0x00
};
/*
* This packet is required for most (all?) of the PDP pads to start
* sending input reports. These pads include: (0x0e6f:0x02ab),
* (0x0e6f:0x02a4), (0x0e6f:0x02a6).
*/
staticconst u8 xboxone_pdp_init1[] = {
0x0a, 0x20, 0x00, 0x03, 0x00, 0x01, 0x14
};
/*
* This packet is required for most (all?) of the PDP pads to start
* sending input reports. These pads include: (0x0e6f:0x02ab),
* (0x0e6f:0x02a4), (0x0e6f:0x02a6).
*/
staticconst u8 xboxone_pdp_init2[] = {
0x06, 0x20, 0x00, 0x02, 0x01, 0x00
};
/*
* A specific rumble packet is required for some PowerA pads to start
* sending input reports. One of those pads is (0x24c6:0x543a).
*/
staticconst u8 xboxone_rumblebegin_init[] = {
0x09, 0x00, 0x00, 0x09, 0x00, 0x0F, 0x00, 0x00,
0x1D, 0x1D, 0xFF, 0x00, 0x00
};
/*
* A rumble packet with zero FF intensity will immediately
* terminate the rumbling required to init PowerA pads.
* This should happen fast enough that the motors don't
* spin up to enough speed to actually vibrate the gamepad.
*/
staticconst u8 xboxone_rumbleend_init[] = {
0x09, 0x00, 0x00, 0x09, 0x00, 0x0F, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00
};
/*
* This specifies the selection of init packets that a gamepad
* will be sent on init *and* the order in which they will be
* sent. The correct sequence number will be added when the
* packet is going to be sent.
*/
staticconststruct xboxone_init_packet xboxone_init_packets[] = {
XBOXONE_INIT_PKT(0x0e6f, 0x0165, xboxone_hori_init),
XBOXONE_INIT_PKT(0x0f0d, 0x0067, xboxone_hori_init),
XBOXONE_INIT_PKT(0x0000, 0x0000, xboxone_fw2015_init),
XBOXONE_INIT_PKT(0x0e6f, 0x0000, xboxone_pdp_init1),
XBOXONE_INIT_PKT(0x0e6f, 0x0000, xboxone_pdp_init2),
XBOXONE_INIT_PKT(0x24c6, 0x541a, xboxone_rumblebegin_init),
XBOXONE_INIT_PKT(0x24c6, 0x542a, xboxone_rumblebegin_init),
XBOXONE_INIT_PKT(0x24c6, 0x543a, xboxone_rumblebegin_init),
XBOXONE_INIT_PKT(0x24c6, 0x541a, xboxone_rumbleend_init),
XBOXONE_INIT_PKT(0x24c6, 0x542a, xboxone_rumbleend_init),
XBOXONE_INIT_PKT(0x24c6, 0x543a, xboxone_rumbleend_init),
};
struct xpad_output_packet {
u8 data[XPAD_PKT_LEN];
u8 len;
bool pending;
};
#defineXPAD_OUT_CMD_IDX0
#defineXPAD_OUT_FF_IDX1
#defineXPAD_OUT_LED_IDX (1 + IS_ENABLED(CONFIG_JOYSTICK_XPAD_FF))
#defineXPAD_NUM_OUT_PACKETS (1 +
IS_ENABLED(CONFIG_JOYSTICK_XPAD_FF) +
IS_ENABLED(CONFIG_JOYSTICK_XPAD_LEDS))
struct usb_xpad {
struct input_dev *dev; /* input device interface */
struct input_dev __rcu *x360w_dev;
struct usb_device *udev; /* usb device */
struct usb_interface *intf; /* usb interface */
bool pad_present;
bool input_created;
struct urb *irq_in; /* urb for interrupt in report */
unsignedchar *idata; /* input data */
dma_addr_t idata_dma;
struct urb *irq_out; /* urb for interrupt out report */
struct usb_anchor irq_out_anchor;
bool irq_out_active; /* we must not use an active URB */
u8 odata_serial; /* serial number for xbox one protocol */
unsignedchar *odata; /* output data */
dma_addr_t odata_dma;
spinlock_t odata_lock;
struct xpad_output_packet out_packets[XPAD_NUM_OUT_PACKETS];
int last_out_packet;
int init_seq;
#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
struct xpad_led *led;
#endif
char phys[64]; /* physical device path */
int mapping; /* map d-pad to buttons or to axes */
int xtype; /* type of xbox device */
int pad_nr; /* the order x360 pads were attached */
constchar *name; /* name of the device */
struct work_struct work; /* init/remove device from callback */
};
staticintxpad_init_input(struct usb_xpad *xpad);
staticvoidxpad_deinit_input(struct usb_xpad *xpad);
staticvoidxpadone_ack_mode_report(struct usb_xpad *xpad, u8 seq_num);
/*
* xpad_process_packet
*
* Completes a request by converting the data into events for the
* input subsystem.
*
* The used report descriptor was taken from ITO Takayukis website:
* http://euc.jp/periphs/xbox-controller.ja.html
*/
staticvoidxpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsignedchar *data)
{
struct input_dev *dev = xpad->dev;
if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
/* left stick */
input_report_abs(dev, ABS_X,
(__s16) le16_to_cpup((__le16 *)(data + 12)));
input_report_abs(dev, ABS_Y,
~(__s16) le16_to_cpup((__le16 *)(data + 14)));
/* right stick */
input_report_abs(dev, ABS_RX,
(__s16) le16_to_cpup((__le16 *)(data + 16)));
input_report_abs(dev, ABS_RY,
~(__s16) le16_to_cpup((__le16 *)(data + 18)));
}
/* triggers left/right */
if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
input_report_key(dev, BTN_TL2, data[10]);
input_report_key(dev, BTN_TR2, data[11]);
} else {
input_report_abs(dev, ABS_Z, data[10]);
input_report_abs(dev, ABS_RZ, data[11]);
}
/* digital pad */
if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
/* dpad as buttons (left, right, up, down) */
input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
} else {
input_report_abs(dev, ABS_HAT0X,
!!(data[2] & 0x08) - !!(data[2] & 0x04));
input_report_abs(dev, ABS_HAT0Y,
!!(data[2] & 0x02) - !!(data[2] & 0x01));
}
/* start/back buttons and stick press left/right */
input_report_key(dev, BTN_START, data[2] & 0x10);
input_report_key(dev, BTN_SELECT, data[2] & 0x20);
input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
/* 'analog' buttons A, B, X, Y */
input_report_key(dev, BTN_A, data[4]);
input_report_key(dev, BTN_B, data[5]);
input_report_key(dev, BTN_X, data[6]);
input_report_key(dev, BTN_Y, data[7]);
/* 'analog' buttons black, white */
input_report_key(dev, BTN_C, data[8]);
input_report_key(dev, BTN_Z, data[9]);
input_sync(dev);
}
/*
* xpad360_process_packet
*
* Completes a request by converting the data into events for the
* input subsystem. It is version for xbox 360 controller
*
* The used report descriptor was taken from:
* http://www.free60.org/wiki/Gamepad
*/
staticvoidxpad360_process_packet(struct usb_xpad *xpad, struct input_dev *dev,
u16 cmd, unsignedchar *data)
{
/* valid pad data */
if (data[0] != 0x00)
return;
/* digital pad */
if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
/* dpad as buttons (left, right, up, down) */
input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
}
/*
* This should be a simple else block. However historically
* xbox360w has mapped DPAD to buttons while xbox360 did not. This
* made no sense, but now we can not just switch back and have to
* support both behaviors.
*/
if (!(xpad->mapping & MAP_DPAD_TO_BUTTONS) ||
xpad->xtype XTYPE_XBOX360W) {
input_report_abs(dev, ABS_HAT0X,
!!(data[2] & 0x08) - !!(data[2] & 0x04));
input_report_abs(dev, ABS_HAT0Y,
!!(data[2] & 0x02) - !!(data[2] & 0x01));
}
/* start/back buttons */
input_report_key(dev, BTN_START, data[2] & 0x10);
input_report_key(dev, BTN_SELECT, data[2] & 0x20);
/* stick press left/right */
input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
/* buttons A,B,X,Y,TL,TR and MODE */
input_report_key(dev, BTN_A, data[3] & 0x10);
input_report_key(dev, BTN_B, data[3] & 0x20);
input_report_key(dev, BTN_X, data[3] & 0x40);
input_report_key(dev, BTN_Y, data[3] & 0x80);
input_report_key(dev, BTN_TL, data[3] & 0x01);
input_report_key(dev, BTN_TR, data[3] & 0x02);
input_report_key(dev, BTN_MODE, data[3] & 0x04);
if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
/* left stick */
input_report_abs(dev, ABS_X,
(__s16) le16_to_cpup((__le16 *)(data + 6)));
input_report_abs(dev, ABS_Y,
~(__s16) le16_to_cpup((__le16 *)(data + 8)));
/* right stick */
input_report_abs(dev, ABS_RX,
(__s16) le16_to_cpup((__le16 *)(data + 10)));
input_report_abs(dev, ABS_RY,
~(__s16) le16_to_cpup((__le16 *)(data + 12)));
}
/* triggers left/right */
if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
input_report_key(dev, BTN_TL2, data[4]);
input_report_key(dev, BTN_TR2, data[5]);
} else {
input_report_abs(dev, ABS_Z, data[4]);
input_report_abs(dev, ABS_RZ, data[5]);
}
input_sync(dev);
}
staticvoidxpad_presence_work(struct work_struct *work)
{
struct usb_xpad *xpad = container_of(work, struct usb_xpad, work);
int error;
if (xpad->pad_present) {
error = xpad_init_input(xpad);
if (error) {
/* complain only, not much else we can do here */
dev_err(&xpad->dev->dev,
'unable to init device: %dn', error);
} else {
rcu_assign_pointer(xpad->x360w_dev, xpad->dev);
}
} else {
RCU_INIT_POINTER(xpad->x360w_dev, NULL);
synchronize_rcu();
/*
* Now that we are sure xpad360w_process_packet is not
* using input device we can get rid of it.
*/
xpad_deinit_input(xpad);
}
}
/*
* xpad360w_process_packet
*
* Completes a request by converting the data into events for the
* input subsystem. It is version for xbox 360 wireless controller.
*
* Byte.Bit
* 00.1 - Status change: The controller or headset has connected/disconnected
* Bits 01.7 and 01.6 are valid
* 01.7 - Controller present
* 01.6 - Headset present
* 01.1 - Pad state (Bytes 4+) valid
*
*/
staticvoidxpad360w_process_packet(struct usb_xpad *xpad, u16 cmd, unsignedchar *data)
{
struct input_dev *dev;
bool present;
/* Presence change */
if (data[0] & 0x08) {
present = (data[1] & 0x80) != 0;
if (xpad->pad_present != present) {
xpad->pad_present = present;
schedule_work(&xpad->work);
}
}
/* Valid pad data */
if (data[1] != 0x1)
return;
rcu_read_lock();
dev = rcu_dereference(xpad->x360w_dev);
if (dev)
xpad360_process_packet(xpad, dev, cmd, &data[4]);
rcu_read_unlock();
}
/*
* xpadone_process_packet
*
* Completes a request by converting the data into events for the
* input subsystem. This version is for the Xbox One controller.
*
* The report format was gleaned from
* https://github.com/kylelemons/xbox/blob/master/xbox.go
*/
staticvoidxpadone_process_packet(struct usb_xpad *xpad, u16 cmd, unsignedchar *data)
{
struct input_dev *dev = xpad->dev;
/* the xbox button has its own special report */
if (data[0] 0X07) {
/*
* The Xbox One S controller requires these reports to be
* acked otherwise it continues sending them forever and
* won't report further mode button events.
*/
if (data[1] 0x30)
xpadone_ack_mode_report(xpad, data[2]);
input_report_key(dev, BTN_MODE, data[4] & 0x01);
input_sync(dev);
return;
}
/* check invalid packet */
elseif (data[0] != 0X20)
return;
/* menu/view buttons */
input_report_key(dev, BTN_START, data[4] & 0x04);
input_report_key(dev, BTN_SELECT, data[4] & 0x08);
/* buttons A,B,X,Y */
input_report_key(dev, BTN_A, data[4] & 0x10);
input_report_key(dev, BTN_B, data[4] & 0x20);
input_report_key(dev, BTN_X, data[4] & 0x40);
input_report_key(dev, BTN_Y, data[4] & 0x80);
/* digital pad */
if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
/* dpad as buttons (left, right, up, down) */
input_report_key(dev, BTN_TRIGGER_HAPPY1, data[5] & 0x04);
input_report_key(dev, BTN_TRIGGER_HAPPY2, data[5] & 0x08);
input_report_key(dev, BTN_TRIGGER_HAPPY3, data[5] & 0x01);
input_report_key(dev, BTN_TRIGGER_HAPPY4, data[5] & 0x02);
} else {
input_report_abs(dev, ABS_HAT0X,
!!(data[5] & 0x08) - !!(data[5] & 0x04));
input_report_abs(dev, ABS_HAT0Y,
!!(data[5] & 0x02) - !!(data[5] & 0x01));
}
/* TL/TR */
input_report_key(dev, BTN_TL, data[5] & 0x10);
input_report_key(dev, BTN_TR, data[5] & 0x20);
/* stick press left/right */
input_report_key(dev, BTN_THUMBL, data[5] & 0x40);
input_report_key(dev, BTN_THUMBR, data[5] & 0x80);
if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
/* left stick */
input_report_abs(dev, ABS_X,
(__s16) le16_to_cpup((__le16 *)(data + 10)));
input_report_abs(dev, ABS_Y,
~(__s16) le16_to_cpup((__le16 *)(data + 12)));
/* right stick */
input_report_abs(dev, ABS_RX,
(__s16) le16_to_cpup((__le16 *)(data + 14)));
input_report_abs(dev, ABS_RY,
~(__s16) le16_to_cpup((__le16 *)(data + 16)));
}
/* triggers left/right */
if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
input_report_key(dev, BTN_TL2,
(__u16) le16_to_cpup((__le16 *)(data + 6)));
input_report_key(dev, BTN_TR2,
(__u16) le16_to_cpup((__le16 *)(data + 8)));
} else {
input_report_abs(dev, ABS_Z,
(__u16) le16_to_cpup((__le16 *)(data + 6)));
input_report_abs(dev, ABS_RZ,
(__u16) le16_to_cpup((__le16 *)(data + 8)));
}
input_sync(dev);
}
staticvoidxpad_irq_in(struct urb *urb)
{
struct usb_xpad *xpad = urb->context;
struct device *dev = &xpad->intf->dev;
int retval, status;
status = urb->status;
switch (status) {
case0:
/* success */
break;
case -ECONNRESET:
case -ENOENT:
case -ESHUTDOWN:
/* this urb is terminated, clean up */
dev_dbg(dev, '%s - urb shutting down with status: %dn',
__func__, status);
return;
default:
dev_dbg(dev, '%s - nonzero urb status received: %dn',
__func__, status);
gotoexit;
}
switch (xpad->xtype) {
case XTYPE_XBOX360:
xpad360_process_packet(xpad, xpad->dev, 0, xpad->idata);
break;
case XTYPE_XBOX360W:
xpad360w_process_packet(xpad, 0, xpad->idata);
break;
case XTYPE_XBOXONE:
xpadone_process_packet(xpad, 0, xpad->idata);
break;
default:
xpad_process_packet(xpad, 0, xpad->idata);
}
exit:
retval = usb_submit_urb(urb, GFP_ATOMIC);
if (retval)
dev_err(dev, '%s - usb_submit_urb failed with result %dn',
__func__, retval);
}
/* Callers must hold xpad->odata_lock spinlock */
staticboolxpad_prepare_next_init_packet(struct usb_xpad *xpad)
{
conststruct xboxone_init_packet *init_packet;
if (xpad->xtype != XTYPE_XBOXONE)
returnfalse;
/* Perform initialization sequence for Xbox One pads that require it */
while (xpad->init_seq < ARRAY_SIZE(xboxone_init_packets)) {
init_packet = &xboxone_init_packets[xpad->init_seq++];
if (init_packet->idVendor != 0 &&
init_packet->idVendor != xpad->dev->id.vendor)
continue;
if (init_packet->idProduct != 0 &&
init_packet->idProduct != xpad->dev->id.product)
continue;
/* This packet applies to our device, so prepare to send it */
memcpy(xpad->odata, init_packet->data, init_packet->len);
xpad->irq_out->transfer_buffer_length = init_packet->len;
/* Update packet with current sequence number */
xpad->odata[2] = xpad->odata_serial++;
returntrue;
}
returnfalse;
}
/* Callers must hold xpad->odata_lock spinlock */
staticboolxpad_prepare_next_out_packet(struct usb_xpad *xpad)
{
struct xpad_output_packet *pkt, *packet = NULL;
int i;
/* We may have init packets to send before we can send user commands */
if (xpad_prepare_next_init_packet(xpad))
returntrue;
for (i = 0; i < XPAD_NUM_OUT_PACKETS; i++) {
if (++xpad->last_out_packet >= XPAD_NUM_OUT_PACKETS)
xpad->last_out_packet = 0;
pkt = &xpad->out_packets[xpad->last_out_packet];
if (pkt->pending) {
dev_dbg(&xpad->intf->dev,
'%s - found pending output packet %dn',
__func__, xpad->last_out_packet);
packet = pkt;
break;
}
}
if (packet) {
memcpy(xpad->odata, packet->data, packet->len);
xpad->irq_out->transfer_buffer_length = packet->len;
packet->pending = false;
returntrue;
}
returnfalse;
}
/* Callers must hold xpad->odata_lock spinlock */
staticintxpad_try_sending_next_out_packet(struct usb_xpad *xpad)
{
int error;
if (!xpad->irq_out_active && xpad_prepare_next_out_packet(xpad)) {
usb_anchor_urb(xpad->irq_out, &xpad->irq_out_anchor);
error = usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
if (error) {
dev_err(&xpad->intf->dev,
'%s - usb_submit_urb failed with result %dn',
__func__, error);
usb_unanchor_urb(xpad->irq_out);
return -EIO;
}
xpad->irq_out_active = true;
}
return0;
}
staticvoidxpad_irq_out(struct urb *urb)
{
struct usb_xpad *xpad = urb->context;
struct device *dev = &xpad->intf->dev;
int status = urb->status;
int error;
unsignedlong flags;
spin_lock_irqsave(&xpad->odata_lock, flags);
switch (status) {
case0:
/* success */
xpad->irq_out_active = xpad_prepare_next_out_packet(xpad);
break;
case -ECONNRESET:
case -ENOENT:
case -ESHUTDOWN:
/* this urb is terminated, clean up */
dev_dbg(dev, '%s - urb shutting down with status: %dn',
__func__, status);
xpad->irq_out_active = false;
break;
default:
dev_dbg(dev, '%s - nonzero urb status received: %dn',
__func__, status);
break;
}
if (xpad->irq_out_active) {
usb_anchor_urb(urb, &xpad->irq_out_anchor);
error = usb_submit_urb(urb, GFP_ATOMIC);
if (error) {
dev_err(dev,
'%s - usb_submit_urb failed with result %dn',
__func__, error);
usb_unanchor_urb(urb);
xpad->irq_out_active = false;
}
}
spin_unlock_irqrestore(&xpad->odata_lock, flags);
}
staticintxpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad,
struct usb_endpoint_descriptor *ep_irq_out)
{
int error;
if (xpad->xtype XTYPE_UNKNOWN)
return0;
init_usb_anchor(&xpad->irq_out_anchor);
xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,
GFP_KERNEL, &xpad->odata_dma);
if (!xpad->odata)
return -ENOMEM;
spin_lock_init(&xpad->odata_lock);
xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
if (!xpad->irq_out) {
error = -ENOMEM;
goto err_free_coherent;
}
usb_fill_int_urb(xpad->irq_out, xpad->udev,
usb_sndintpipe(xpad->udev, ep_irq_out->bEndpointAddress),
xpad->odata, XPAD_PKT_LEN,
xpad_irq_out, xpad, ep_irq_out->bInterval);
xpad->irq_out->transfer_dma = xpad->odata_dma;
xpad->irq_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
return0;
err_free_coherent:
usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
return error;
}
staticvoidxpad_stop_output(struct usb_xpad *xpad)
{
if (xpad->xtype != XTYPE_UNKNOWN) {
if (!usb_wait_anchor_empty_timeout(&xpad->irq_out_anchor,
5000)) {
dev_warn(&xpad->intf->dev,
'timed out waiting for output URB to complete, killingn');
usb_kill_anchored_urbs(&xpad->irq_out_anchor);
}
}
}
staticvoidxpad_deinit_output(struct usb_xpad *xpad)
{
if (xpad->xtype != XTYPE_UNKNOWN) {
usb_free_urb(xpad->irq_out);
usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
xpad->odata, xpad->odata_dma);
}
}
staticintxpad_inquiry_pad_presence(struct usb_xpad *xpad)
{
struct xpad_output_packet *packet =
&xpad->out_packets[XPAD_OUT_CMD_IDX];
unsignedlong flags;
int retval;
spin_lock_irqsave(&xpad->odata_lock, flags);
packet->data[0] = 0x08;
packet->data[1] = 0x00;
packet->data[2] = 0x0F;
packet->data[3] = 0xC0;
packet->data[4] = 0x00;
packet->data[5] = 0x00;
packet->data[6] = 0x00;
packet->data[7] = 0x00;
packet->data[8] = 0x00;
packet->data[9] = 0x00;
packet->data[10] = 0x00;
packet->data[11] = 0x00;
packet->len = 12;
packet->pending = true;
/* Reset the sequence so we send out presence first */
xpad->last_out_packet = -1;
retval = xpad_try_sending_next_out_packet(xpad);
spin_unlock_irqrestore(&xpad->odata_lock, flags);
return retval;
}
staticintxpad_start_xbox_one(struct usb_xpad *xpad)
{
unsignedlong flags;
int retval;
spin_lock_irqsave(&xpad->odata_lock, flags);
/*
* Begin the init sequence by attempting to send a packet.
* We will cycle through the init packet sequence before
* sending any packets from the output ring.
*/
xpad->init_seq = 0;
retval = xpad_try_sending_next_out_packet(xpad);
spin_unlock_irqrestore(&xpad->odata_lock, flags);
return retval;
}
staticvoidxpadone_ack_mode_report(struct usb_xpad *xpad, u8 seq_num)
{
unsignedlong flags;
struct xpad_output_packet *packet =
&xpad->out_packets[XPAD_OUT_CMD_IDX];
staticconst u8 mode_report_ack[] = {
0x01, 0x20, 0x00, 0x09, 0x00, 0x07, 0x20, 0x02,
0x00, 0x00, 0x00, 0x00, 0x00
};
spin_lock_irqsave(&xpad->odata_lock, flags);
packet->len = sizeof(mode_report_ack);
memcpy(packet->data, mode_report_ack, packet->len);
packet->data[2] = seq_num;
packet->pending = true;
/* Reset the sequence so we send out the ack now */
xpad->last_out_packet = -1;
xpad_try_sending_next_out_packet(xpad);
spin_unlock_irqrestore(&xpad->odata_lock, flags);
}
#ifdef CONFIG_JOYSTICK_XPAD_FF
staticintxpad_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
{
struct usb_xpad *xpad = input_get_drvdata(dev);
struct xpad_output_packet *packet = &xpad->out_packets[XPAD_OUT_FF_IDX];
__u16 strong;
__u16 weak;
int retval;
unsignedlong flags;
if (effect->type != FF_RUMBLE)
return0;
strong = effect->u.rumble.strong_magnitude;
weak = effect->u.rumble.weak_magnitude;
spin_lock_irqsave(&xpad->odata_lock, flags);
switch (xpad->xtype) {
case XTYPE_XBOX:
packet->data[0] = 0x00;
packet->data[1] = 0x06;
packet->data[2] = 0x00;
packet->data[3] = strong / 256; /* left actuator */
packet->data[4] = 0x00;
packet->data[5] = weak / 256; /* right actuator */
packet->len = 6;
packet->pending = true;
break;
case XTYPE_XBOX360:
packet->data[0] = 0x00;
packet->data[1] = 0x08;
packet->data[2] = 0x00;
packet->data[3] = strong / 256; /* left actuator? */
packet->data[4] = weak / 256; /* right actuator? */
packet->data[5] = 0x00;
packet->data[6] = 0x00;
packet->data[7] = 0x00;
packet->len = 8;
packet->pending = true;
break;
case XTYPE_XBOX360W:
packet->data[0] = 0x00;
packet->data[1] = 0x01;
packet->data[2] = 0x0F;
packet->data[3] = 0xC0;
packet->data[4] = 0x00;
packet->data[5] = strong / 256;
packet->data[6] = weak / 256;
packet->data[7] = 0x00;
packet->data[8] = 0x00;
packet->data[9] = 0x00;
packet->data[10] = 0x00;
packet->data[11] = 0x00;
packet->len = 12;
packet->pending = true;
break;
case XTYPE_XBOXONE:
packet->data[0] = 0x09; /* activate rumble */
packet->data[1] = 0x00;
packet->data[2] = xpad->odata_serial++;
packet->data[3] = 0x09;
packet->data[4] = 0x00;
packet->data[5] = 0x0F;
packet->data[6] = 0x00;
packet->data[7] = 0x00;
packet->data[8] = strong / 512; /* left actuator */
packet->data[9] = weak / 512; /* right actuator */
packet->data[10] = 0xFF; /* on period */
packet->data[11] = 0x00; /* off period */
packet->data[12] = 0xFF; /* repeat count */
packet->len = 13;
packet->pending = true;
break;
default:
dev_dbg(&xpad->dev->dev,
'%s - rumble command sent to unsupported xpad type: %dn',
__func__, xpad->xtype);
retval = -EINVAL;
goto out;
}
retval = xpad_try_sending_next_out_packet(xpad);
out:
spin_unlock_irqrestore(&xpad->odata_lock, flags);
return retval;
}
staticintxpad_init_ff(struct usb_xpad *xpad)
{
if (xpad->xtype XTYPE_UNKNOWN)
return0;
input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);
returninput_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
}
#else
staticintxpad_init_ff(struct usb_xpad *xpad) { return0; }
#endif
#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
#include<linux/leds.h>
#include<linux/idr.h>
staticDEFINE_IDA(xpad_pad_seq);
struct xpad_led {
char name[16];
struct led_classdev led_cdev;
struct usb_xpad *xpad;
};
/**
* set the LEDs on Xbox360 / Wireless Controllers
* @param command
* 0: off
* 1: all blink, then previous setting
* 2: 1/top-left blink, then on
* 3: 2/top-right blink, then on
* 4: 3/bottom-left blink, then on
* 5: 4/bottom-right blink, then on
* 6: 1/top-left on
* 7: 2/top-right on
* 8: 3/bottom-left on
* 9: 4/bottom-right on
* 10: rotate
* 11: blink, based on previous setting
* 12: slow blink, based on previous setting
* 13: rotate with two lights
* 14: persistent slow all blink
* 15: blink once, then previous setting
*/
staticvoidxpad_send_led_command(struct usb_xpad *xpad, int command)
{
struct xpad_output_packet *packet =
&xpad->out_packets[XPAD_OUT_LED_IDX];
unsignedlong flags;
command %= 16;
spin_lock_irqsave(&xpad->odata_lock, flags);
switch (xpad->xtype) {
case XTYPE_XBOX360:
packet->data[0] = 0x01;
packet->data[1] = 0x03;
packet->data[2] = command;
packet->len = 3;
packet->pending = true;
break;
case XTYPE_XBOX360W:
packet->data[0] = 0x00;
packet->data[1] = 0x00;
packet->data[2] = 0x08;
packet->data[3] = 0x40 + command;
packet->data[4] = 0x00;
packet->data[5] = 0x00;
packet->data[6] = 0x00;
packet->data[7] = 0x00;
packet->data[8] = 0x00;
packet->data[9] = 0x00;
packet->data[10] = 0x00;
packet->data[11] = 0x00;
packet->len = 12;
packet->pending = true;
break;
}
xpad_try_sending_next_out_packet(xpad);
spin_unlock_irqrestore(&xpad->odata_lock, flags);
}
/*
* Light up the segment corresponding to the pad number on
* Xbox 360 Controllers.
*/
staticvoidxpad_identify_controller(struct usb_xpad *xpad)
{
led_set_brightness(&xpad->led->led_cdev, (xpad->pad_nr % 4) + 2);
}
staticvoidxpad_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
struct xpad_led *xpad_led = container_of(led_cdev,
struct xpad_led, led_cdev);
xpad_send_led_command(xpad_led->xpad, value);
}
staticintxpad_led_probe(struct usb_xpad *xpad)
{
struct xpad_led *led;
struct led_classdev *led_cdev;
int error;
if (xpad->xtype != XTYPE_XBOX360 && xpad->xtype != XTYPE_XBOX360W)
return0;
xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
if (!led)
return -ENOMEM;
xpad->pad_nr = ida_simple_get(&xpad_pad_seq, 0, 0, GFP_KERNEL);
if (xpad->pad_nr < 0) {
error = xpad->pad_nr;
goto err_free_mem;
}
snprintf(led->name, sizeof(led->name), 'xpad%d', xpad->pad_nr);
led->xpad = xpad;
led_cdev = &led->led_cdev;
led_cdev->name = led->name;
led_cdev->brightness_set = xpad_led_set;
led_cdev->flags = LED_CORE_SUSPENDRESUME;
error = led_classdev_register(&xpad->udev->dev, led_cdev);
if (error)
goto err_free_id;
xpad_identify_controller(xpad);
return0;
err_free_id:
ida_simple_remove(&xpad_pad_seq, xpad->pad_nr);
err_free_mem:
kfree(led);
xpad->led = NULL;
return error;
}
staticvoidxpad_led_disconnect(struct usb_xpad *xpad)
{
struct xpad_led *xpad_led = xpad->led;
if (xpad_led) {
led_classdev_unregister(&xpad_led->led_cdev);
ida_simple_remove(&xpad_pad_seq, xpad->pad_nr);
kfree(xpad_led);
}
}
#else
staticintxpad_led_probe(struct usb_xpad *xpad) { return0; }
staticvoidxpad_led_disconnect(struct usb_xpad *xpad) { }
#endif
staticintxpad_start_input(struct usb_xpad *xpad)
{
int error;
if (usb_submit_urb(xpad->irq_in, GFP_KERNEL))
return -EIO;
if (xpad->xtype XTYPE_XBOXONE) {
error = xpad_start_xbox_one(xpad);
if (error) {
usb_kill_urb(xpad->irq_in);
return error;
}
}
return0;
}
staticvoidxpad_stop_input(struct usb_xpad *xpad)
{
usb_kill_urb(xpad->irq_in);
}
staticvoidxpad360w_poweroff_controller(struct usb_xpad *xpad)
{
unsignedlong flags;
struct xpad_output_packet *packet =
&xpad->out_packets[XPAD_OUT_CMD_IDX];
spin_lock_irqsave(&xpad->odata_lock, flags);
packet->data[0] = 0x00;
packet->data[1] = 0x00;
packet->data[2] = 0x08;
packet->data[3] = 0xC0;
packet->data[4] = 0x00;
packet->data[5] = 0x00;
packet->data[6] = 0x00;
packet->data[7] = 0x00;
packet->data[8] = 0x00;
packet->data[9] = 0x00;
packet->data[10] = 0x00;
packet->data[11] = 0x00;
packet->len = 12;
packet->pending = true;
/* Reset the sequence so we send out poweroff now */
xpad->last_out_packet = -1;
xpad_try_sending_next_out_packet(xpad);
spin_unlock_irqrestore(&xpad->odata_lock, flags);
}
staticintxpad360w_start_input(struct usb_xpad *xpad)
{
int error;
error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);
if (error)
return -EIO;
/*
* Send presence packet.
* This will force the controller to resend connection packets.
* This is useful in the case we activate the module after the
* adapter has been plugged in, as it won't automatically
* send us info about the controllers.
*/
error = xpad_inquiry_pad_presence(xpad);
if (error) {
usb_kill_urb(xpad->irq_in);
return error;
}
return0;
}
staticvoidxpad360w_stop_input(struct usb_xpad *xpad)
{
usb_kill_urb(xpad->irq_in);
/* Make sure we are done with presence work if it was scheduled */
flush_work(&xpad->work);
}
staticintxpad_open(struct input_dev *dev)
{
struct usb_xpad *xpad = input_get_drvdata(dev);
returnxpad_start_input(xpad);
}
staticvoidxpad_close(struct input_dev *dev)
{
struct usb_xpad *xpad = input_get_drvdata(dev);
xpad_stop_input(xpad);
}
staticvoidxpad_set_up_abs(struct input_dev *input_dev, signedshort abs)
{
struct usb_xpad *xpad = input_get_drvdata(input_dev);
switch (abs) {
case ABS_X:
case ABS_Y:
case ABS_RX:
case ABS_RY: /* the two sticks */
input_set_abs_params(input_dev, abs, -32768, 32767, 16, 128);
break;
case ABS_Z:
case ABS_RZ: /* the triggers (if mapped to axes) */
if (xpad->xtype XTYPE_XBOXONE)
input_set_abs_params(input_dev, abs, 0, 1023, 0, 0);
else
input_set_abs_params(input_dev, abs, 0, 255, 0, 0);
break;
case ABS_HAT0X:
case ABS_HAT0Y: /* the d-pad (only if dpad is mapped to axes */
input_set_abs_params(input_dev, abs, -1, 1, 0, 0);
break;
default:
input_set_abs_params(input_dev, abs, 0, 0, 0, 0);
break;
}
}
staticvoidxpad_deinit_input(struct usb_xpad *xpad)
{
if (xpad->input_created) {
xpad->input_created = false;
xpad_led_disconnect(xpad);
input_unregister_device(xpad->dev);
}
}
staticintxpad_init_input(struct usb_xpad *xpad)
{
struct input_dev *input_dev;
int i, error;
input_dev = input_allocate_device();
if (!input_dev)
return -ENOMEM;
xpad->dev = input_dev;
input_dev->name = xpad->name;
input_dev->phys = xpad->phys;
usb_to_input_id(xpad->udev, &input_dev->id);
if (xpad->xtype XTYPE_XBOX360W) {
/* x360w controllers and the receiver have different ids */
input_dev->id.product = 0x02a1;
}
input_dev->dev.parent = &xpad->intf->dev;
input_set_drvdata(input_dev, xpad);
if (xpad->xtype != XTYPE_XBOX360W) {
input_dev->open = xpad_open;
input_dev->close = xpad_close;
}
if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
/* set up axes */
for (i = 0; xpad_abs[i] >= 0; i++)
xpad_set_up_abs(input_dev, xpad_abs[i]);
}
/* set up standard buttons */
for (i = 0; xpad_common_btn[i] >= 0; i++)
input_set_capability(input_dev, EV_KEY, xpad_common_btn[i]);
/* set up model-specific ones */
if (xpad->xtype XTYPE_XBOX360 || xpad->xtype XTYPE_XBOX360W ||
xpad->xtype XTYPE_XBOXONE) {
for (i = 0; xpad360_btn[i] >= 0; i++)
input_set_capability(input_dev, EV_KEY, xpad360_btn[i]);
} else {
for (i = 0; xpad_btn[i] >= 0; i++)
input_set_capability(input_dev, EV_KEY, xpad_btn[i]);
}
if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
for (i = 0; xpad_btn_pad[i] >= 0; i++)
input_set_capability(input_dev, EV_KEY,
xpad_btn_pad[i]);
}
/*
* This should be a simple else block. However historically
* xbox360w has mapped DPAD to buttons while xbox360 did not. This
* made no sense, but now we can not just switch back and have to
* support both behaviors.
*/
if (!(xpad->mapping & MAP_DPAD_TO_BUTTONS) ||
xpad->xtype XTYPE_XBOX360W) {
for (i = 0; xpad_abs_pad[i] >= 0; i++)
xpad_set_up_abs(input_dev, xpad_abs_pad[i]);
}
if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
for (i = 0; xpad_btn_triggers[i] >= 0; i++)
input_set_capability(input_dev, EV_KEY,
xpad_btn_triggers[i]);
} else {
for (i = 0; xpad_abs_triggers[i] >= 0; i++)
xpad_set_up_abs(input_dev, xpad_abs_triggers[i]);
}
error = xpad_init_ff(xpad);
if (error)
goto err_free_input;
error = xpad_led_probe(xpad);
if (error)
goto err_destroy_ff;
error = input_register_device(xpad->dev);
if (error)
goto err_disconnect_led;
xpad->input_created = true;
return0;
err_disconnect_led:
xpad_led_disconnect(xpad);
err_destroy_ff:
input_ff_destroy(input_dev);
err_free_input:
input_free_device(input_dev);
return error;
}
staticintxpad_probe(struct usb_interface *intf, conststruct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev(intf);
struct usb_xpad *xpad;
struct usb_endpoint_descriptor *ep_irq_in, *ep_irq_out;
int i, error;
if (intf->cur_altsetting->desc.bNumEndpoints != 2)
return -ENODEV;
for (i = 0; xpad_device[i].idVendor; i++) {
if ((le16_to_cpu(udev->descriptor.idVendor) xpad_device[i].idVendor) &&
(le16_to_cpu(udev->descriptor.idProduct) xpad_device[i].idProduct))
break;
}
xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);
if (!xpad)
return -ENOMEM;
usb_make_path(udev, xpad->phys, sizeof(xpad->phys));
strlcat(xpad->phys, '/input0', sizeof(xpad->phys));
xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN,
GFP_KERNEL, &xpad->idata_dma);
if (!xpad->idata) {
error = -ENOMEM;
goto err_free_mem;
}
xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);
if (!xpad->irq_in) {
error = -ENOMEM;
goto err_free_idata;
}
xpad->udev = udev;
xpad->intf = intf;
xpad->mapping = xpad_device[i].mapping;
xpad->xtype = xpad_device[i].xtype;
xpad->name = xpad_device[i].name;
INIT_WORK(&xpad->work, xpad_presence_work);
if (xpad->xtype XTYPE_UNKNOWN) {
if (intf->cur_altsetting->desc.bInterfaceClass USB_CLASS_VENDOR_SPEC) {
if (intf->cur_altsetting->desc.bInterfaceProtocol129)
xpad->xtype = XTYPE_XBOX360W;
elseif (intf->cur_altsetting->desc.bInterfaceProtocol208)
xpad->xtype = XTYPE_XBOXONE;
else
xpad->xtype = XTYPE_XBOX360;
} else {
xpad->xtype = XTYPE_XBOX;
}
if (dpad_to_buttons)
xpad->mapping |= MAP_DPAD_TO_BUTTONS;
if (triggers_to_buttons)
xpad->mapping |= MAP_TRIGGERS_TO_BUTTONS;
if (sticks_to_null)
xpad->mapping |= MAP_STICKS_TO_NULL;
}
if (xpad->xtype XTYPE_XBOXONE &&
intf->cur_altsetting->desc.bInterfaceNumber != 0) {
/*
* The Xbox One controller lists three interfaces all with the
* same interface class, subclass and protocol. Differentiate by
* interface number.
*/
error = -ENODEV;
goto err_free_in_urb;
}
ep_irq_in = ep_irq_out = NULL;
for (i = 0; i < 2; i++) {
struct usb_endpoint_descriptor *ep =
&intf->cur_altsetting->endpoint[i].desc;
if (usb_endpoint_xfer_int(ep)) {
if (usb_endpoint_dir_in(ep))
ep_irq_in = ep;
else
ep_irq_out = ep;
}
}
if (!ep_irq_in || !ep_irq_out) {
error = -ENODEV;
goto err_free_in_urb;
}
error = xpad_init_output(intf, xpad, ep_irq_out);
if (error)
goto err_free_in_urb;
usb_fill_int_urb(xpad->irq_in, udev,
usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),
xpad->idata, XPAD_PKT_LEN, xpad_irq_in,
xpad, ep_irq_in->bInterval);
xpad->irq_in->transfer_dma = xpad->idata_dma;
xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
usb_set_intfdata(intf, xpad);
if (xpad->xtype XTYPE_XBOX360W) {
/*
* Submit the int URB immediately rather than waiting for open
* because we get status messages from the device whether
* or not any controllers are attached. In fact, it's
* exactly the message that a controller has arrived that
* we're waiting for.
*/
error = xpad360w_start_input(xpad);
if (error)
goto err_deinit_output;
/*
* Wireless controllers require RESET_RESUME to work properly
* after suspend. Ideally this quirk should be in usb core
* quirk list, but we have too many vendors producing these
* controllers and we'd need to maintain 2 identical lists
* here in this driver and in usb core.
*/
udev->quirks |= USB_QUIRK_RESET_RESUME;
} else {
error = xpad_init_input(xpad);
if (error)
goto err_deinit_output;
}
return0;
err_deinit_output:
xpad_deinit_output(xpad);
err_free_in_urb:
usb_free_urb(xpad->irq_in);
err_free_idata:
usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
err_free_mem:
kfree(xpad);
return error;
}
staticvoidxpad_disconnect(struct usb_interface *intf)
{
struct usb_xpad *xpad = usb_get_intfdata(intf);
if (xpad->xtype XTYPE_XBOX360W)
xpad360w_stop_input(xpad);
xpad_deinit_input(xpad);
/*
* Now that both input device and LED device are gone we can
* stop output URB.
*/
xpad_stop_output(xpad);
xpad_deinit_output(xpad);
usb_free_urb(xpad->irq_in);
usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
xpad->idata, xpad->idata_dma);
kfree(xpad);
usb_set_intfdata(intf, NULL);
}
staticintxpad_suspend(struct usb_interface *intf, pm_message_t message)
{
struct usb_xpad *xpad = usb_get_intfdata(intf);
struct input_dev *input = xpad->dev;
if (xpad->xtype XTYPE_XBOX360W) {
/*
* Wireless controllers always listen to input so
* they are notified when controller shows up
* or goes away.
*/
xpad360w_stop_input(xpad);
/*
* The wireless adapter is going off now, so the
* gamepads are going to become disconnected.
* Unless explicitly disabled, power them down
* so they don't just sit there flashing.
*/
if (auto_poweroff && xpad->pad_present)
xpad360w_poweroff_controller(xpad);
} else {
mutex_lock(&input->mutex);
if (input->users)
xpad_stop_input(xpad);
mutex_unlock(&input->mutex);
}
xpad_stop_output(xpad);
return0;
}
staticintxpad_resume(struct usb_interface *intf)
{
struct usb_xpad *xpad = usb_get_intfdata(intf);
struct input_dev *input = xpad->dev;
int retval = 0;
if (xpad->xtype XTYPE_XBOX360W) {
retval = xpad360w_start_input(xpad);
} else {
mutex_lock(&input->mutex);
if (input->users) {
retval = xpad_start_input(xpad);
} elseif (xpad->xtype XTYPE_XBOXONE) {
/*
* Even if there are no users, we'll send Xbox One pads
* the startup sequence so they don't sit there and
* blink until somebody opens the input device again.
*/
retval = xpad_start_xbox_one(xpad);
}
mutex_unlock(&input->mutex);
}
return retval;
}
staticstruct usb_driver xpad_driver = {
.name = 'xpad',
.probe = xpad_probe,
.disconnect = xpad_disconnect,
.suspend = xpad_suspend,
.resume = xpad_resume,
.reset_resume = xpad_resume,
.id_table = xpad_table,
};
module_usb_driver(xpad_driver);
MODULE_AUTHOR('Marko Friedemann <mfr@bmx-chemnitz.de>');
MODULE_DESCRIPTION('X-Box pad driver');
MODULE_LICENSE('GPL');
  • Copy lines
  • Copy permalink
June 5, 2014
xb1usb.11059.0.140526x64.msi
2.8 MB
Windows 7 / 8 64-bit
Input Devices
742,912

Note: Your Xbox One controller needs to be connected to your PC through the micro USB cable for PC gaming.

Downldoad free driver updates for JMB36X Standard Dual Channel PCIE IDE Controller also known as: GIGABYTE GBB36X Controller, JMicron JMB36X. Jmb36x standard dual channel pcie ide controller driver windows 7. Use the links on this page to download the latest version of JMB36X Standard Dual Channel PCIE IDE Controller drivers. All drivers available for download have.

Free spinning workouts to download youtube. Convert pdf to vector illustrator. The greatest gamepad – now even better

JixiPix PhotoArtista - Haiku 2.55 Artista Haiku will add spontaneity to your pictures. This creative media incorporates traditional techniques as well as the non-traditional such as digital photography, and vintage papers to create a unique painting filled with movement and meaning. JixiPix PhotoArtista Haiku 2.55 Haiku is a whimsical stylistic watercolor effect poetically brushed to aged or artistic paper then outlined in India ink. This creative media will add spontaneity to you pictures incorporating traditional techniques as well as the non-traditional; such as digital photography and vintage papers, to create a unique painting filled with movement and meaning. JixiPix PhotoArtista Haiku 2.55 File size: 96.8 MB Haiku is a whimsical stylistic watercolor effect poetically brushed to aged or artistic paper then outlined in India ink. This creative media will add spontaneity to you pictures incorporating traditional techniques as well as the non-traditional; such as digital photography and vintage papers, to create a unique painting filled with movement and meaning. JixiPix Artista Haiku 2.55 80.4 Mb Haiku is a whimsical stylistic watercolor effect poetically brushed to aged or artistic paper then outlined in India ink. This creative media will add spontaneity to you pictures incorporating traditional techniques as well as the non-traditional; such as. Download JixiPix PhotoArtista Haiku 2.55 or any other file from Applications category. HTTP download also available at fast speeds. Photoartista haiku 2.55.

The Xbox One Wireless Controller features over 40 improvements to the award-winning Xbox 360 Wireless Controller.

More immersive

Feel the action like never before with Impulse Triggers. New vibration motors in the triggers provide precise fingertip feedback bringing weapons, crashes, and jolts to life for a whole new level of gaming realism.

New expansion port with high speed data transfer enables clearer chat audio when using a compatible headset.**

Download dedrm_plugin.zip mac. More precise

Power a batarang controller driver download

Newly designed D-pad is responsive to both sweeping and directional movements.

Hp 8200 elite drivers. Thumbstick improvements enable better grip and accuracy.

Trigger and bumpers are designed for quicker access. Windows 8 pro product key generator online.

More comfortable

Grips and contours have been designed to fit a wider range of hand sizes comfortably.

Neuroanatomy through clinical cases 2nd edition pdf free download pc. Batteries fit inside the controller body, allowing your hands more room to naturally grip the controller.

- YouTube (157.75 KB) Pokemon Emerald Randomizer Source title: Pokemon emerald randomizer rar (6 MB) download from mediafire.com - FilesLace.com (13.64 MB) Pokemon Emerald Randomizer Source title: Resolved Question - Pokemon Emerald Randomizer| Part 45 (END)| CHAMPION OF HOENN! https://mertorvirti.tistory.com/12. Download cardrecovery v6 10 with crack free.

Additional features

  • Contents: Wireless Controller and AA Batteries (2).
  • Up to 30ft wireless range.
  • Connect up to 8 Wireless Controllers at once to your console.
  • Menu and View buttons for easy navigation.
  • Seamless profile and controller pairing. Infrared LEDs in the controller can be sensed by the Kinect sensor.
  • Expansion port for add-on devices like the Chat Headset.
  • Compatible with Xbox One Play and Charge Kit and Xbox One Chat Headset.
Here's other similar drivers that are different versions or releases for different operating systems:
    • September 21, 2015
    • Windows (all)
    • 66,630 downloads
    • 111 MB
    • September 18, 2015
    • Windows (all)
    • 5,052 downloads
    • 111 MB
    • June 5, 2014
    • Windows 7 / 8
    • 57,931 downloads
    • 2.3 MB
    • January 9, 2011
    • Windows 7 64-bit
    • 516,371 downloads
    • 7.5 MB
    • January 9, 2009
    • Windows 7
    • 21,837 downloads
    • 17.9 MB
    • December 7, 2012
    • Windows XP 64-bit
    • 6,148 downloads
    • 18.3 MB
    • October 24, 2012
    • Windows (all)
    • 6,076 downloads
    • 108.0 MB
    • January 9, 2011
    • Windows XP
    • 66,519 downloads
    • 7.1 MB
    • January 9, 2011
    • Windows 7
    • 69,773 downloads
    • 7.6 MB

Power A Batarang Controller Driver For Windows 10






티스토리툴바