Re: [PATCH] (revision 1) input: xpad.c - Xbox 360 wireless and sysfs support

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Sun, Feb 22, 2009 at 12:31:27AM -0500, Mike Murphy wrote:
> Greetings,
> 
> Attached is a revised version of my previous patch to
> drivers/input/joystick/xpad.c, which should apply without issues to
> the current stable tree (2.6.28.7 at the time of this writing). I have
> made a number of major changes since the original:
> 
> 1. Removed kobject and used input device's existing kobject for sysfs
> via DEVICE_ATTR. All attributes are part of a game_device group, which
> I will document once this patch has been reviewed. Thanks to Greg K-H
> for his help with the sysfs interface and helpful feedback. Return
> values for sscanf are also now checked, and the ugly strcmp code has
> been replaced by a cleaner solution (thanks Oliver Neukum). Wireless
> 360 controllers now produce an online/offline uevent when
> connecting/disconnecting, for later userspace use. Additionally, the
> whole sysfs interface is now dependent upon CONFIG_SYSFS (the driver
> should continue to work without it).
> 
> 2. urb submissions while holding mutexes have been reverted to
> GFP_KERNEL, and fixes have been made to the shared workqueue code to
> account for possible adverse events (such as removal of the device
> before the work gets done). Thanks to Oliver Neukum for his feedback.
> 
> 3. Re-factored the code a bit and split it into two pieces (xpad.h and
> xpad.c). The division of the main data structures into a header file
> makes development on the main body much easier.
> 
> 4. After extensive testing and debugging with a popular fighting game
> in an emulator (with 3-4 concurrent players on wireless 360
> controllers), I changed the original square axis algorithm to an axis
> limiting and scaling algorithm that works on a per-stick basis. This
> new algorithm is substantially less jumpy when using a square axis,
> and it permits the size of the inscribed square to be adjusted on a
> per-controller basis. The nominal value to use to achieve the largest
> possible inscribed square on "perfect" hardware is 23170, but
> manufacturing variations in the controllers might require a smaller
> number.
> 
> Comments and feedback on this revision are greatly appreciated, and I
> plan to test all the supported hardware I can get my hands on (need to
> borrow some wired classic and 360 devices) to be sure the new code
> doesn't break support for older devices. I will also document the
> userspace interface by submitting a Documentation/ABI/testing patch
> with the "final" version of the driver, once it has been nailed down.
> 
> Thanks,
> Mike
> -- 
> Mike Murphy
> Ph.D. Candidate and NSF Graduate Research Fellow
> Clemson University School of Computing
> 120 McAdams Hall
> Clemson, SC 29634-0974 USA
> Tel: +1 864.656.2838   Fax: +1 864.656.0145
> http://cirg.cs.clemson.edu/~mamurph

> diff -uNr origdrv/drivers/input/joystick/xpad.c newdrv/drivers/input/joystick/xpad.c
> --- origdrv/drivers/input/joystick/xpad.c	2009-02-14 22:39:20.000000000 -0500
> +++ newdrv/drivers/input/joystick/xpad.c	2009-02-21 23:58:21.000000000 -0500
> @@ -1,5 +1,8 @@
>  /*
> - * X-Box gamepad driver
> + * Xbox gamepad driver with Xbox 360 wired/wireless support
> + *
> + * Last Modified:	21 February 2009
> + *			Mike Murphy <mamurph@xxxxxxxxxxxxxx>
>   *
>   * Copyright (c) 2002 Marko Friedemann <mfr@xxxxxxxxxxxxxxx>
>   *               2004 Oliver Schwartz <Oliver.Schwartz@xxxxxx>,
> @@ -9,6 +12,8 @@
>   *               2005 Dominic Cerquetti <binary1230@xxxxxxxxx>
>   *               2006 Adam Buchbinder <adam.buchbinder@xxxxxxxxx>
>   *               2007 Jan Kratochvil <honza@xxxxxxxx>
> + *               2009 Clemson University
> + *		      (contact: Mike Murphy <mamurph@xxxxxxxxxxxxxx>)
>   *
>   * This program is free software; you can redistribute it and/or
>   * modify it under the terms of the GNU General Public License as
> @@ -24,224 +29,305 @@
>   * along with this program; if not, write to the Free Software
>   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
>   *
> + * Please see xbox.h for the ChangeLog.
> + */
> +
> +
> +
> +#include "xpad.h"
> +
> +
> +/* The dead zone and stick limit both affect the behavior of the corresponding
> + * analog stick, since the output values reported for the stick inputs will
> + * be scaled onto [0,32767]. It is thus necessary to ensure that the dead zone
> + * is never larger than the stick limit. In fact, a minimal amount of stick
> + * travel space (1024) is maintained between the two values. In practice,
> + * however, the stick limit should always be much greater than the dead zone.
> + */
> +
> +static void set_dead_zone(unsigned int new_size, unsigned int *dz, unsigned int stick_limit)
> +{
> +	if ((new_size + 1024) >= stick_limit)
> +		new_size = (stick_limit > 1024) ? stick_limit - 1024 : 0;
> +	*dz = new_size;
> +}
> +
> +static void set_stick_limit(unsigned int new_size, unsigned int *sl, unsigned int dead_zone)
> +{
> +	if (new_size < (dead_zone + 1024))
> +		new_size = dead_zone + 1024;
> +	if (new_size > 32767)
> +		new_size = 32767;
> +	*sl = new_size;
> +}
> +
> +
> +/****************************************************************************/
> +/*
> + * SysFs interface functions
>   *
> - * 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
> - *
> - * 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
> - *
> - * 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/init.h>
> -#include <linux/slab.h>
> -#include <linux/stat.h>
> -#include <linux/module.h>
> -#include <linux/usb/input.h>
> -
> -#define DRIVER_AUTHOR "Marko Friedemann <mfr@xxxxxxxxxxxxxxx>"
> -#define DRIVER_DESC "X-Box pad driver"
> -
> -#define XPAD_PKT_LEN 32
> -
> -/* xbox d-pads should map to buttons, as is required for DDR pads
> -   but we map them to axes when possible to simplify things */
> -#define MAP_DPAD_TO_BUTTONS    0
> -#define MAP_DPAD_TO_AXES       1
> -#define MAP_DPAD_UNKNOWN       2
> -
> -#define XTYPE_XBOX        0
> -#define XTYPE_XBOX360     1
> -#define XTYPE_XBOX360W    2
> -#define XTYPE_UNKNOWN     3
> -
> -static int 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");
> -
> -static const struct xpad_device {
> -	u16 idVendor;
> -	u16 idProduct;
> -	char *name;
> -	u8 dpad_mapping;
> -	u8 xtype;
> -} xpad_device[] = {
> -	{ 0x045e, 0x0202, "Microsoft X-Box pad v1 (US)", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x045e, 0x0285, "Microsoft X-Box pad (Japan)", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x045e, 0x0287, "Microsoft Xbox Controller S", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x045e, 0x0719, "Xbox 360 Wireless Receiver", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
> -	{ 0x0c12, 0x8809, "RedOctane Xbox Dance Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
> -	{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x046d, 0xc242, "Logitech Chillstream Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
> -	{ 0x046d, 0xca84, "Logitech Xbox Cordless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x046d, 0xca88, "Logitech Compact Controller for Xbox", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x05fd, 0x1007, "Mad Catz Controller (unverified)", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x05fd, 0x107a, "InterAct 'PowerPad Pro' X-Box pad (Germany)", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0738, 0x4516, "Mad Catz Control Pad", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0738, 0x4522, "Mad Catz LumiCON", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0738, 0x4526, "Mad Catz Control Pad Pro", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0738, 0x4536, "Mad Catz MicroCON", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0738, 0x4540, "Mad Catz Beat Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
> -	{ 0x0738, 0x4556, "Mad Catz Lynx Wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
> -	{ 0x0738, 0x6040, "Mad Catz Beat Pad Pro", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
> -	{ 0x0c12, 0x8802, "Zeroplus Xbox Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0c12, 0x880a, "Pelican Eclipse PL-2023", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0c12, 0x8810, "Zeroplus Xbox Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0e4c, 0x1097, "Radica Gamester Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0e4c, 0x2390, "Radica Games Jtech Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0e6f, 0x0003, "Logic3 Freebird wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0e6f, 0x0005, "Eclipse wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0e6f, 0x0006, "Edge wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0e6f, 0x0006, "Pelican 'TSZ' Wired Xbox 360 Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
> -	{ 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0f30, 0x0202, "Joytech Advanced Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0f30, 0x8888, "BigBen XBMiniPad Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x102c, 0xff0c, "Joytech Wireless Advanced Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x12ab, 0x8809, "Xbox DDR dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
> -	{ 0x1430, 0x4748, "RedOctane Guitar Hero X-plorer", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
> -	{ 0x1430, 0x8888, "TX6500+ Dance Pad (first generation)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
> -	{ 0x045e, 0x028e, "Microsoft X-Box 360 pad", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
> -	{ 0xffff, 0xffff, "Chinese-made Xbox Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
> -	{ 0x0000, 0x0000, "Generic X-Box pad", MAP_DPAD_UNKNOWN, XTYPE_UNKNOWN }
> -};
> -
> -/* buttons shared with xbox and xbox360 */
> -static const signed short xpad_common_btn[] = {
> -	BTN_A, BTN_B, BTN_X, BTN_Y,			/* "analog" buttons */
> -	BTN_START, BTN_BACK, BTN_THUMBL, BTN_THUMBR,	/* start/back/sticks */
> -	-1						/* terminating entry */
> -};
> -
> -/* original xbox controllers only */
> -static const signed short xpad_btn[] = {
> -	BTN_C, BTN_Z,		/* "analog" buttons */
> -	-1			/* terminating entry */
> -};
> -
> -/* only used if MAP_DPAD_TO_BUTTONS */
> -static const signed short xpad_btn_pad[] = {
> -	BTN_LEFT, BTN_RIGHT,		/* d-pad left, right */
> -	BTN_0, BTN_1,			/* d-pad up, down (XXX names??) */
> -	-1				/* terminating entry */
> -};
> -
> -static const signed short xpad360_btn[] = {  /* buttons for x360 controller */
> -	BTN_TL, BTN_TR,		/* Button LB/RB */
> -	BTN_MODE,		/* The big X button */
> -	-1
> -};
> -
> -static const signed short xpad_abs[] = {
> -	ABS_X, ABS_Y,		/* left stick */
> -	ABS_RX, ABS_RY,		/* right stick */
> -	ABS_Z, ABS_RZ,		/* triggers left/right */
> -	-1			/* terminating entry */
> -};
> -
> -/* only used if MAP_DPAD_TO_AXES */
> -static const signed short xpad_abs_pad[] = {
> -	ABS_HAT0X, ABS_HAT0Y,	/* d-pad axes */
> -	-1			/* terminating entry */
> -};
> -
> -/* 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. */
> -#define XPAD_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)
> -#define XPAD_XBOX360_VENDOR(vend) \
> -	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,1) }, \
> -	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,129) }
> -
> -static struct usb_device_id xpad_table [] = {
> -	{ USB_INTERFACE_INFO('X', 'B', 0) },	/* X-Box USB-IF not approved class */
> -	XPAD_XBOX360_VENDOR(0x045e),		/* Microsoft X-Box 360 controllers */
> -	XPAD_XBOX360_VENDOR(0x046d),		/* Logitech X-Box 360 style controllers */
> -	XPAD_XBOX360_VENDOR(0x0738),		/* Mad Catz X-Box 360 controllers */
> -	XPAD_XBOX360_VENDOR(0x0e6f),		/* 0x0e6f X-Box 360 controllers */
> -	XPAD_XBOX360_VENDOR(0x1430),		/* RedOctane X-Box 360 controllers */
> -	{ }
> -};
> -
> -MODULE_DEVICE_TABLE (usb, xpad_table);
> -
> -struct usb_xpad {
> -	struct input_dev *dev;		/* input device interface */
> -	struct usb_device *udev;	/* usb device */
> -
> -	int pad_present;
> -
> -	struct urb *irq_in;		/* urb for interrupt in report */
> -	unsigned char *idata;		/* input data */
> -	dma_addr_t idata_dma;
> + * We use common functions, where possible, to implement the show/store
> + * routines. This design saves on code and reduces the burden of adding to or
> + * changing the interface.
> + */
> + 
> +#if defined(CONFIG_SYSFS)
>  
> -	struct urb *bulk_out;
> -	unsigned char *bdata;
> +static ssize_t xpad_show_uint(struct device *dev, struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct usb_xpad *xpad = to_xpad(dev);
> +	unsigned int value;
> +	if (attr == &dev_attr_left_dead_zone)
> +		value = xpad->left_dead_zone;
> +	else if (attr == &dev_attr_right_dead_zone)
> +		value = xpad->right_dead_zone;
> +	else if (attr == &dev_attr_left_stick_limit)
> +		value = xpad->left_stick_limit;
> +	else if (attr == &dev_attr_right_stick_limit)
> +		value = xpad->right_stick_limit;
> +	else
> +		return -EIO;
> +	return snprintf(buf, PAGE_SIZE, "%u\n", value);
> +}
>  
> -#if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
> -	struct urb *irq_out;		/* urb for interrupt out report */
> -	unsigned char *odata;		/* output data */
> -	dma_addr_t odata_dma;
> -	struct mutex odata_mutex;
> -#endif
>  
> -#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
> -	struct xpad_led *led;
> +static ssize_t xpad_store_uint(struct device *dev,
> +		struct device_attribute *attr, const char *buf, size_t count)
> +{
> +	struct usb_xpad *xpad = to_xpad(dev);
> +	unsigned int new_value;
> +	if (1 != sscanf(buf, "%u", &new_value)) {
> +		return -EIO;
> +	}
> +	if (attr == &dev_attr_left_dead_zone)
> +		set_dead_zone(new_value, &xpad->left_dead_zone, xpad->left_stick_limit);
> +	else if (attr == &dev_attr_right_dead_zone)
> +		set_dead_zone(new_value, &xpad->right_dead_zone, xpad->right_stick_limit);
> +	else if (attr == &dev_attr_left_stick_limit)
> +		set_stick_limit(new_value, &xpad->left_stick_limit, xpad->left_dead_zone);
> +	else if (attr == &dev_attr_right_stick_limit)
> +		set_stick_limit(new_value, &xpad->right_stick_limit, xpad->right_dead_zone);
> +	else
> +		return -EIO;
> +	return strnlen(buf, PAGE_SIZE);
> +}
> +
> +
> +static ssize_t xpad_store_rumble_enable(struct device *dev,
> +		struct device_attribute *attr, const char *buf, size_t count)
> +{
> +	struct usb_xpad *xpad = to_xpad(dev);
> +	int newrumble = xpad->rumble_enable;
> +	if (1 == sscanf(buf, "%d", &newrumble))


Oh, that's not wrong but it looks weird, usually, a code reader would
expect to see if (sscanf(...) == 1)


> +		xpad->rumble_enable = (newrumble) ? 1 : 0;
> +	return count;
> +}
> +
> +
> +/* read-only attributes share a common store function that returns an error */
> +static ssize_t xpad_store_ro(struct device *dev, struct device_attribute *attr,
> +		const char *buf, size_t count)
> +{
> +	return -EIO;
> +}
> +
> +
> +static ssize_t xpad_show_int(struct device *dev, struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct usb_xpad *xpad = to_xpad(dev);
> +	int value;
> +	if (attr == &dev_attr_rumble_enable)
> +		value = xpad->rumble_enable;
> +	else if (attr == &dev_attr_controller_number)
> +		value = xpad->controller_number;
> +	else if (attr == &dev_attr_controller_present)
> +		value = xpad->controller_present;
> +	else if (attr == &dev_attr_controller_type)
> +		value = xpad->controller_type;
> +	else
> +		return -EIO;
> +	return snprintf(buf, PAGE_SIZE, "%d\n", value);
> +}
> +
> +
> +static ssize_t xpad_show_id(struct device *dev,
> +		struct device_attribute *attr, char *buf)
> +{
> +	struct usb_xpad *xpad = to_xpad(dev);
> +	return snprintf(buf, PAGE_SIZE, "%s\n", xpad->controller_unique_id);
> +}
> +
>  #endif
> +/* end of sysfs interface */
> +/*****************************************************************************/
> +
> +/* Input section */
> +
> +/*	xpad_init_controller
> + *
> + *	Performs controller setup based on controller type.
> + *
> + *	NOTE: xpad->controller_data->controller_type needs to be set BEFORE
> + *	calling this function!
> + */
> + 
> +static void xpad_init_controller(struct usb_xpad *xpad)
> +{
> +	set_stick_limit(XSTICK_LIMIT_DEFAULT, &xpad->left_stick_limit, xpad->left_dead_zone);
> +	set_stick_limit(XSTICK_LIMIT_DEFAULT, &xpad->right_stick_limit, xpad->right_dead_zone);
> +	set_dead_zone(XDEAD_ZONE_DEFAULT, &xpad->left_dead_zone, xpad->left_stick_limit);
> +	set_dead_zone(XDEAD_ZONE_DEFAULT, &xpad->right_dead_zone, xpad->right_stick_limit);
> +	
> +	if (xpad->controller_type == XCONTROLLER_TYPE_GUITAR) {
> +		xpad->rumble_enable = 0;
> +	}
> +	else if (xpad->controller_type == XCONTROLLER_TYPE_DANCE_PAD) {
> +		xpad->rumble_enable = 0;
> +	}
> +	else {
> +		xpad->rumble_enable = 1;
> +	}


The brackets are not needed in these checks, may be you should run
scripts/checkpatch.pl to check obvious coding styles issues.


> +}
> +
>  
> -	char phys[64];			/* physical device path */
> +/*
> + *	xpad_work_controller
> + *
> + *	Submits command to set pad number on LED display of wireless 360
> + *	controllers. The shared workqueue is used for this purpose, so that
> + *	the interrupt handler is kept short.
> + */
> + 
> +static void xpad_work_controller(struct work_struct *w)
> +{
> +   struct usb_xpad * xpad = container_of(w, struct usb_xpad, work);
> +   xpad_send_led_command(xpad, xpad->controller_number + 1);
> +   xpad->work_pending = 0;
> +}
> +
> +
> +/*
> + *	xpad_process_sticks
> + *
> + *	Handles stick input, accounting for dead zones and square axes. Based
> + *	on the original handlers for the Xbox and Xbox 360 in
> + *	xpad_process_packet and xpad360_process_packet, but unified to avoid
> + *	duplication.
> + *
> + *	Whenever a dead zone is used, each axis is scaled so that moving the
> + *	stick slightly out of the dead zone range results in a low axis
> + *	value in jstest(1), while moving the stick to the maximum position
> + *	along any axis still results in 32767.
> + *
> + *	In order to provide the ability to map inputs to a square axis (used
> + *	by older games), the left_stick_limit and right_stick_limit can be
> + *	set. These limits specify at what point in the raw input coordinates
> + *	an axis is reported to be at maximum value (32767 or -32767).
> + *
> + *	Both the dead zone and stick limit algorithms are implemented
> + *	together as a coordinate transformation from "effective coordinates"
> + *	onto the output coordinates (which have absolute values from 0 to
> + *	32767 and are positive or negative based on direction). Effective
> + *	coordinates are defined as those input values that are greater than
> + *	the dead zone but less than the stick limit on the axis in question.
> + *
> + *	DANGER: All denominator values in division operations MUST be checked
> + *	for non-zero condition. Dividing by zero inside the kernel can cause
> + *	a system deadlock.
> + */
> +
> +static void xpad_process_sticks(struct usb_xpad *xpad, unsigned char *data)
> +{
> +	struct input_dev *dev = xpad->dev;
> +	int coords[4];    /* x, y, rx, ry */
> +	int x_offset, y_offset, rx_offset, ry_offset;
> +	int c;
> +	int range;
> +	int abs_magnitude, adjusted_magnitude, difference, scale_fraction;
> +	int dead_zone[2], stick_limit[2];
> +	
> +	dead_zone[0] = xpad->left_dead_zone;
> +	dead_zone[1] = xpad->right_dead_zone;
> +	stick_limit[0] = xpad->left_stick_limit;
> +	stick_limit[1] = xpad->right_stick_limit;
> +	
> +	if (xpad->xtype == XTYPE_XBOX) {
> +		x_offset = 12;
> +		y_offset = 14;
> +		rx_offset = 16;
> +		ry_offset = 18;
> +	}
> +	else {
> +		x_offset = 6;
> +		y_offset = 8;
> +		rx_offset = 10;
> +		ry_offset = 12;
> +	}
> +	
> +	coords[0] = (__s16) le16_to_cpup((__le16 *)(data + x_offset));
> +	coords[1] = ~(__s16) le16_to_cpup((__le16 *)(data + y_offset));
> +	coords[2] = (__s16) le16_to_cpup((__le16 *)(data + rx_offset));
> +	coords[3] = ~(__s16) le16_to_cpup((__le16 *)(data + ry_offset));
> +	
> +	/* Adjustment for dead zone and square axis */
> +	for (c = 0; c < 4; c++) {
> +		abs_magnitude = (int) coords[c];
> +		if (abs_magnitude < 0)
> +			abs_magnitude = -abs_magnitude;
> +		adjusted_magnitude = abs_magnitude;
> +		
> +		range = (stick_limit[c/2] - dead_zone[c/2]);
> +		
> +		if (abs_magnitude >= stick_limit[c/2]) {
> +			adjusted_magnitude = 32767;
> +		}
> +		else if (abs_magnitude <= dead_zone[c/2]) {
> +			adjusted_magnitude = 0;
> +		}
> +		else if (range > 0) {
> +			difference = 32767 - range;
> +			if (difference) {
> +				/* DIVISION: difference non-zero */
> +				scale_fraction = range / difference;
> +				adjusted_magnitude = abs_magnitude - dead_zone[c/2];
> +				
> +				/* Approximate floating-point division with a
> +				 * "catch-up" scaling algorithm that adds back
> +				 * to the adjusted_magnitude based on distance
> +				 * from the origin (0 in adjusted coordinates).
> +				 * If the range / difference is at least 1,
> +				 * then 1 needs to be added to the adjusted
> +				 * magnitude for every scale_fraction units
> +				 * from the origin. If the range / difference
> +				 * is less than 1 (0 in integer division),
> +				 * then divide the difference by the range to
> +				 * obtain the number of units to add per unit
> +				 * from the adjusted origin.
> +				 */
> +				if (scale_fraction) {
> +					/* DIVISION: scale_fraction non-zero */
> +					adjusted_magnitude += adjusted_magnitude / scale_fraction;
> +				}
> +				else {
> +					/* DIVISION: range non-zero */
> +					scale_fraction = difference / range;
> +					adjusted_magnitude += adjusted_magnitude * scale_fraction;
> +				}
> +				if (adjusted_magnitude > 32767)
> +					adjusted_magnitude = 32767;
> +			}
> +		}
> +		coords[c] = (coords[c] < 0) ? -adjusted_magnitude : adjusted_magnitude;
> +	}
> +	
> +	input_report_abs(dev, ABS_X, (__s16) coords[0]);
> +	input_report_abs(dev, ABS_Y, (__s16) coords[1]);
> +	input_report_abs(dev, ABS_RX, (__s16) coords[2]);
> +	input_report_abs(dev, ABS_RY, (__s16) coords[3]);
> +}
>  
> -	int dpad_mapping;		/* map d-pad to buttons or to axes */
> -	int xtype;			/* type of xbox device */
> -};
>  
>  /*
>   *	xpad_process_packet
> @@ -256,18 +342,9 @@
>  static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
>  {
>  	struct input_dev *dev = xpad->dev;
> -
> -	/* 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)));
> +	
> +	/* left and right sticks */
> +	xpad_process_sticks(xpad, data);
>  
>  	/* triggers left/right */
>  	input_report_abs(dev, ABS_Z, data[10]);
> @@ -305,6 +382,7 @@
>  	input_sync(dev);
>  }
>  
> +
>  /*
>   *	xpad360_process_packet
>   *
> @@ -350,18 +428,9 @@
>  	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);
> -
> -	/* 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)));
> +	
> +	/* left and right sticks */
> +	xpad_process_sticks(xpad, data);
>  
>  	/* triggers left/right */
>  	input_report_abs(dev, ABS_Z, data[4]);
> @@ -370,6 +439,33 @@
>  	input_sync(dev);
>  }
>  
> +
> +static void xpad360w_identify_controller(struct usb_xpad *xpad, unsigned char *data)
> +{
> +	u32 id;
> +	int i;
> +	
> +	snprintf(xpad->controller_unique_id, 17,
> +		"%02x%02x%02x%02x%02x%02x%02x%02x",
> +		data[8], data[9], data[10], data[11], data[12], data[13],
> +		data[14], data[15]);
> +			
> +	/* Identify controller type */
> +	id = (u32) *(data + 22);
> +	xpad->controller_type = XCONTROLLER_TYPE_OTHER;
> +	for (i = 0; w360_id[i].id_bytes; i++) {
> +		if (id == w360_id[i].id_bytes) {
> +			xpad->controller_type =
> +				w360_id[i].controller_type;
> +			break;
> +		}
> +	}
> +	
> +	if (id == XCONTROLLER_TYPE_OTHER)
> +		printk(KERN_INFO "xpad: unknown wireless controller type: %08x\n", id);
> +}
> +
> +
>  /*
>   * xpad360w_process_packet
>   *
> @@ -379,6 +475,7 @@
>   * Byte.Bit
>   * 00.1 - Status change: The controller or headset has connected/disconnected
>   *                       Bits 01.7 and 01.6 are valid
> + * 01.f - Some kind of unique identifier message (see above)
>   * 01.7 - Controller present
>   * 01.6 - Headset present
>   * 01.1 - Pad state (Bytes 4+) valid
> @@ -387,22 +484,53 @@
>  
>  static void xpad360w_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data)
>  {
> -	/* Presence change */
> +	int padnum = 0;
> +
> +	/* Presence change */	
>  	if (data[0] & 0x08) {
> +		padnum = xpad->controller_number;
>  		if (data[1] & 0x80) {
> -			xpad->pad_present = 1;
> -			usb_submit_urb(xpad->bulk_out, GFP_ATOMIC);
> -		} else
> -			xpad->pad_present = 0;
> +			/* ignore duplicates */
> +			if (!xpad->controller_present) {
> +				xpad->controller_present = 1;
> +				
> +				if (xpad->work_pending)
> +					PREPARE_WORK(&xpad->work, &xpad_work_controller);
> +				else
> +					INIT_WORK(&xpad->work, &xpad_work_controller);
> +				xpad->work_pending = 1;
> +				schedule_work(&xpad->work);
> +				kobject_uevent(&xpad->dev->dev.kobj, KOBJ_ONLINE);
> +			}
> +		}
> +		else {
> +			kobject_uevent(&xpad->dev->dev.kobj, KOBJ_OFFLINE);
> +			xpad->controller_present = 0;
> +			xpad->controller_unique_id[0] = '\0';
> +			xpad->controller_type = XCONTROLLER_TYPE_NONE;
> +			/* We do NOT flush the shared workqueue here, because
> +			 * this function is called from an interrupt handler.
> +			 * If the controller has disconnected from the receiver,
> +			 * the worst that will happen from the work task running
> +			 * is that a packet will be transmitted from the
> +			 * receiver to a non-listening controller
> +			 */
> +		}
>  	}
>  
> -	/* Valid pad data */
> -	if (!(data[1] & 0x1))
> -		return;
> -
> -	xpad360_process_packet(xpad, cmd, &data[4]);
> +	/* Process packets according to type */
> +	if (data[1] == 0x0f) {
> +		if (! xpad->controller_unique_id[0]) {
> +			xpad360w_identify_controller(xpad, data);
> +			xpad_init_controller(xpad);
> +		}
> +	}
> +	else if (data[1] & 0x1) {
> +		xpad360_process_packet(xpad, cmd, &data[4]);
> +	}
>  }
>  
> +
>  static void xpad_irq_in(struct urb *urb)
>  {
>  	struct usb_xpad *xpad = urb->context;
> @@ -445,24 +573,16 @@
>  		     __func__, retval);
>  }
>  
> -static void xpad_bulk_out(struct urb *urb)
> -{
> -	switch (urb->status) {
> -	case 0:
> -		/* success */
> -		break;
> -	case -ECONNRESET:
> -	case -ENOENT:
> -	case -ESHUTDOWN:
> -		/* this urb is terminated, clean up */
> -		dbg("%s - urb shutting down with status: %d", __func__, urb->status);
> -		break;
> -	default:
> -		dbg("%s - nonzero urb status received: %d", __func__, urb->status);
> -	}
> -}
>  
> +/* end input section */
> +
> +/*****************************************************************************/
> +/* IRQ output section: present in object code only if the force feedback or
> + * LED interface is enabled.
> + */
> + 
>  #if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
> +
>  static void xpad_irq_out(struct urb *urb)
>  {
>  	int retval, status;
> @@ -493,12 +613,13 @@
>  		    __func__, retval);
>  }
>  
> +
>  static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
>  {
>  	struct usb_endpoint_descriptor *ep_irq_out;
>  	int error = -ENOMEM;
>  
> -	if (xpad->xtype != XTYPE_XBOX360)
> +	if ((xpad->xtype != XTYPE_XBOX360) && (xpad->xtype != XTYPE_XBOX360W))
>  		return 0;
>  
>  	xpad->odata = usb_buffer_alloc(xpad->udev, XPAD_PKT_LEN,
> @@ -526,45 +647,82 @@
>   fail1:	return error;
>  }
>  
> +
>  static void xpad_stop_output(struct usb_xpad *xpad)
>  {
> -	if (xpad->xtype == XTYPE_XBOX360)
> +	if ((xpad->xtype == XTYPE_XBOX360) || (xpad->xtype == XTYPE_XBOX360W))
>  		usb_kill_urb(xpad->irq_out);
>  }
>  
> +
>  static void xpad_deinit_output(struct usb_xpad *xpad)
>  {
> -	if (xpad->xtype == XTYPE_XBOX360) {
> +	if ((xpad->xtype == XTYPE_XBOX360) || (xpad->xtype == XTYPE_XBOX360W)) {
>  		usb_free_urb(xpad->irq_out);
>  		usb_buffer_free(xpad->udev, XPAD_PKT_LEN,
>  				xpad->odata, xpad->odata_dma);
>  	}
>  }
> +
>  #else
> +/* Dummy implementations for xpad_probe and xpad_disconnect */
>  static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad) { return 0; }
>  static void xpad_deinit_output(struct usb_xpad *xpad) {}
>  static void xpad_stop_output(struct usb_xpad *xpad) {}
>  #endif
>  
> -#ifdef CONFIG_JOYSTICK_XPAD_FF
> +/* end output section */
> +
> +/*****************************************************************************/
> +
> +/* Force feedback (rumble effect) section, depends on CONFIG_JOYSTICK_XPAD_FF */
> +
> +#if defined(CONFIG_JOYSTICK_XPAD_FF)
> +
> +/* Rumble support for wireless controllers follows protocol description
> + * from xboxdrv userspace driver:
> + *       http://pingus.seul.org/~grumbel/xboxdrv/
> + */
>  static int xpad_play_effect(struct input_dev *dev, void *data,
>  			    struct ff_effect *effect)
>  {
>  	struct usb_xpad *xpad = input_get_drvdata(dev);
> +	
> +	if (! xpad->rumble_enable)
> +		return 0;
>  
>  	if (effect->type == FF_RUMBLE) {
>  		__u16 strong = effect->u.rumble.strong_magnitude;
>  		__u16 weak = effect->u.rumble.weak_magnitude;
> -		xpad->odata[0] = 0x00;
> -		xpad->odata[1] = 0x08;
> -		xpad->odata[2] = 0x00;
> -		xpad->odata[3] = strong / 256;
> -		xpad->odata[4] = weak / 256;
> -		xpad->odata[5] = 0x00;
> -		xpad->odata[6] = 0x00;
> -		xpad->odata[7] = 0x00;
> -		xpad->irq_out->transfer_buffer_length = 8;
> +		mutex_lock(&xpad->odata_mutex);
> +		if (xpad->xtype == XTYPE_XBOX360W) {
> +			xpad->odata[0] = 0x00;
> +			xpad->odata[1] = 0x01;
> +			xpad->odata[2] = 0x0f;
> +			xpad->odata[3] = 0xc0;
> +			xpad->odata[4] = 0x00;
> +			xpad->odata[5] = strong / 256;
> +			xpad->odata[6] = weak / 256;
> +			xpad->odata[7] = 0x00;
> +			xpad->odata[8] = 0x00;
> +			xpad->odata[9] = 0x00;
> +			xpad->odata[10] = 0x00;
> +			xpad->odata[11] = 0x00;
> +			xpad->irq_out->transfer_buffer_length = 12;
> +		}
> +		else {
> +			xpad->odata[0] = 0x00;
> +			xpad->odata[1] = 0x08;
> +			xpad->odata[2] = 0x00;
> +			xpad->odata[3] = strong / 256;
> +			xpad->odata[4] = weak / 256;
> +			xpad->odata[5] = 0x00;
> +			xpad->odata[6] = 0x00;
> +			xpad->odata[7] = 0x00;
> +			xpad->irq_out->transfer_buffer_length = 8;
> +		}
>  		usb_submit_urb(xpad->irq_out, GFP_KERNEL);
> +		mutex_unlock(&xpad->odata_mutex);
>  	}
>  
>  	return 0;
> @@ -572,7 +730,7 @@
>  
>  static int xpad_init_ff(struct usb_xpad *xpad)
>  {
> -	if (xpad->xtype != XTYPE_XBOX360)
> +	if ((xpad->xtype != XTYPE_XBOX360) && (xpad->xtype != XTYPE_XBOX360W))
>  		return 0;
>  
>  	input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);
> @@ -581,26 +739,50 @@
>  }
>  
>  #else
> +/* dummy implementation for xpad_probe */
>  static int xpad_init_ff(struct usb_xpad *xpad) { return 0; }
>  #endif
>  
> +
> +/* end force feedback section */
> +
> +/*****************************************************************************/
> +
> +/* LED handling section: provides support for the ring of LEDs on the 360
> + * controllers. */
> +
>  #if defined(CONFIG_JOYSTICK_XPAD_LEDS)
> -#include <linux/leds.h>
>  
> -struct xpad_led {
> -	char name[16];
> -	struct led_classdev led_cdev;
> -	struct usb_xpad *xpad;
> -};
>  
> +/* XBox 360 wireless controller follows protocol from xboxdrv userspace
> + * driver:
> + *    http://pingus.seul.org/~grumbel/xboxdrv/
> + */
>  static void xpad_send_led_command(struct usb_xpad *xpad, int command)
>  {
>  	if (command >= 0 && command < 14) {
>  		mutex_lock(&xpad->odata_mutex);
> -		xpad->odata[0] = 0x01;
> -		xpad->odata[1] = 0x03;
> -		xpad->odata[2] = command;
> -		xpad->irq_out->transfer_buffer_length = 3;
> +		if (xpad->xtype == XTYPE_XBOX360W) {
> +			xpad->odata[0] = 0x00;
> +			xpad->odata[1] = 0x00;
> +			xpad->odata[2] = 0x08;
> +			xpad->odata[3] = 0x40 + (command % 0x0e);
> +			xpad->odata[4] = 0x00;
> +			xpad->odata[5] = 0x00;
> +			xpad->odata[6] = 0x00;
> +			xpad->odata[7] = 0x00;
> +			xpad->odata[8] = 0x00;
> +			xpad->odata[9] = 0x00;
> +			xpad->odata[10] = 0x00;
> +			xpad->odata[11] = 0x00;
> +			xpad->irq_out->transfer_buffer_length = 12;
> +		}
> +		else {
> +			xpad->odata[0] = 0x01;
> +			xpad->odata[1] = 0x03;
> +			xpad->odata[2] = command;
> +			xpad->irq_out->transfer_buffer_length = 3;
> +		}
>  		usb_submit_urb(xpad->irq_out, GFP_KERNEL);
>  		mutex_unlock(&xpad->odata_mutex);
>  	}
> @@ -615,6 +797,7 @@
>  	xpad_send_led_command(xpad_led->xpad, value);
>  }
>  
> +
>  static int xpad_led_probe(struct usb_xpad *xpad)
>  {
>  	static atomic_t led_seq	= ATOMIC_INIT(0);
> @@ -623,7 +806,7 @@
>  	struct led_classdev *led_cdev;
>  	int error;
>  
> -	if (xpad->xtype != XTYPE_XBOX360)
> +	if ((xpad->xtype != XTYPE_XBOX360) && (xpad->xtype != XTYPE_XBOX360W))
>  		return 0;
>  
>  	xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
> @@ -664,10 +847,16 @@
>  	}
>  }
>  #else
> +/* dummies for xpad_probe and xpad_disconnect */
>  static int xpad_led_probe(struct usb_xpad *xpad) { return 0; }
>  static void xpad_led_disconnect(struct usb_xpad *xpad) { }
>  #endif
>  
> +/* end LED section */
> +
> +/*****************************************************************************/
> +
> +/* Module and device functions */
>  
>  static int xpad_open(struct input_dev *dev)
>  {
> @@ -721,6 +910,7 @@
>  	struct usb_xpad *xpad;
>  	struct input_dev *input_dev;
>  	struct usb_endpoint_descriptor *ep_irq_in;
> +	int controller_type;
>  	int i;
>  	int error = -ENOMEM;
>  
> @@ -747,6 +937,7 @@
>  	xpad->udev = udev;
>  	xpad->dpad_mapping = xpad_device[i].dpad_mapping;
>  	xpad->xtype = xpad_device[i].xtype;
> +	controller_type = xpad_device[i].controller_type;
>  	if (xpad->dpad_mapping == MAP_DPAD_UNKNOWN)
>  		xpad->dpad_mapping = !dpad_to_buttons;
>  	if (xpad->xtype == XTYPE_UNKNOWN) {
> @@ -819,6 +1010,10 @@
>  		goto fail4;
>  
>  	usb_set_intfdata(intf, xpad);
> +	
> +	xpad->controller_type = controller_type;
> +	if (controller_type != XCONTROLLER_TYPE_NONE)
> +		xpad_init_controller(xpad);
>  
>  	/*
>  	 * Submit the int URB immediatly rather than waiting for open
> @@ -828,48 +1023,38 @@
>  	 * we're waiting for.
>  	 */
>  	if (xpad->xtype == XTYPE_XBOX360W) {
> +		xpad->controller_present = 0;
> +		xpad->controller_unique_id[0] = '\0';
> +		xpad->controller_number =
> +			(intf->cur_altsetting->desc.bInterfaceNumber / 2) + 1;
>  		xpad->irq_in->dev = xpad->udev;
>  		error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);
>  		if (error)
> -			goto fail4;
> -
> -		/*
> -		 * Setup the message to set the LEDs on the
> -		 * controller when it shows up
> -		 */
> -		xpad->bulk_out = usb_alloc_urb(0, GFP_KERNEL);
> -		if(!xpad->bulk_out)
>  			goto fail5;
> -
> -		xpad->bdata = kzalloc(XPAD_PKT_LEN, GFP_KERNEL);
> -		if(!xpad->bdata)
> -			goto fail6;
> -
> -		xpad->bdata[2] = 0x08;
> -		switch (intf->cur_altsetting->desc.bInterfaceNumber) {
> -		case 0:
> -			xpad->bdata[3] = 0x42;
> -			break;
> -		case 2:
> -			xpad->bdata[3] = 0x43;
> -			break;
> -		case 4:
> -			xpad->bdata[3] = 0x44;
> -			break;
> -		case 6:
> -			xpad->bdata[3] = 0x45;
> -		}
> -
> -		ep_irq_in = &intf->cur_altsetting->endpoint[1].desc;
> -		usb_fill_bulk_urb(xpad->bulk_out, udev,
> -				usb_sndbulkpipe(udev, ep_irq_in->bEndpointAddress),
> -				xpad->bdata, XPAD_PKT_LEN, xpad_bulk_out, xpad);
>  	}
> +	else {
> +		xpad->controller_present = 1;
> +		strncpy(xpad->controller_unique_id, "wired", 17);
> +		xpad->controller_number = 0;
> +	}
> +	
> +	/* Set up device attributes */
> +#ifdef CONFIG_SYSFS
> +	xpad->sysfs_ok = 1;
> +	error = sysfs_create_group(&input_dev->dev.kobj, &xpad_default_attr_group);
> +	if (error) {
> +		/* Driver will work without the sysfs interface, but parameters
> +		 * will not be adjustable, so this failure is a warning. */
> +		printk(KERN_WARNING "xpad: sysfs_create_group failed with error %d\n", error);
> +		xpad->sysfs_ok = 0;
> +	}
> +#endif


No need to check for CONFIG_SYSFS, sysfs_create_group will be a no-op which returns 0
if not built.


>  
>  	return 0;
>  
> - fail6:	usb_free_urb(xpad->bulk_out);
> - fail5:	usb_kill_urb(xpad->irq_in);
> + fail5: usb_set_intfdata(intf, NULL);
> + 	input_unregister_device(xpad->dev);
> + 	xpad_led_disconnect(xpad);
>   fail4:	usb_free_urb(xpad->irq_in);
>   fail3:	xpad_deinit_output(xpad);
>   fail2:	usb_buffer_free(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
> @@ -885,12 +1070,19 @@
>  
>  	usb_set_intfdata(intf, NULL);
>  	if (xpad) {
> +		/* If a work task remains, get rid of it by flushing the
> +		 * shared work queue.
> +		 */
> +		if (xpad->work_pending)
> +			flush_scheduled_work();
> +#ifdef CONFIG_SYSFS
> +		if (xpad->sysfs_ok)
> +			sysfs_remove_group(&xpad->dev->dev.kobj, &xpad_default_attr_group);
> +#endif


Ditto.


>  		xpad_led_disconnect(xpad);
>  		input_unregister_device(xpad->dev);
>  		xpad_deinit_output(xpad);
>  		if (xpad->xtype == XTYPE_XBOX360W) {
> -			usb_kill_urb(xpad->bulk_out);
> -			usb_free_urb(xpad->bulk_out);
>  			usb_kill_urb(xpad->irq_in);
>  		}
>  		usb_free_urb(xpad->irq_in);
> @@ -900,12 +1092,7 @@
>  	}
>  }
>  
> -static struct usb_driver xpad_driver = {
> -	.name		= "xpad",
> -	.probe		= xpad_probe,
> -	.disconnect	= xpad_disconnect,
> -	.id_table	= xpad_table,
> -};
> +
>  
>  static int __init usb_xpad_init(void)
>  {
> @@ -920,9 +1107,4 @@
>  	usb_deregister(&xpad_driver);
>  }
>  
> -module_init(usb_xpad_init);
> -module_exit(usb_xpad_exit);
>  
> -MODULE_AUTHOR(DRIVER_AUTHOR);
> -MODULE_DESCRIPTION(DRIVER_DESC);
> -MODULE_LICENSE("GPL");
> diff -uNr origdrv/drivers/input/joystick/xpad.h newdrv/drivers/input/joystick/xpad.h
> --- origdrv/drivers/input/joystick/xpad.h	1969-12-31 19:00:00.000000000 -0500
> +++ newdrv/drivers/input/joystick/xpad.h	2009-02-21 23:49:36.000000000 -0500
> @@ -0,0 +1,578 @@
> +/*
> + * Xbox gamepad driver with Xbox 360 wired/wireless support
> + *
> + * Last Modified:	21 February 2009
> + *			Mike Murphy <mamurph@xxxxxxxxxxxxxx>
> + *
> + * Copyright (c) 2002 Marko Friedemann <mfr@xxxxxxxxxxxxxxx>
> + *               2004 Oliver Schwartz <Oliver.Schwartz@xxxxxx>,
> + *                    Steven Toth <steve@xxxxxxxxxxxxxxxx>,
> + *                    Franz Lehner <franz@xxxxxxx>,
> + *                    Ivan Hawkes <blackhawk@xxxxxxxxxxxxxx>
> + *               2005 Dominic Cerquetti <binary1230@xxxxxxxxx>
> + *               2006 Adam Buchbinder <adam.buchbinder@xxxxxxxxx>
> + *               2007 Jan Kratochvil <honza@xxxxxxxx>
> + *               2009 Clemson University
> + *		      (contact: Mike Murphy <mamurph@xxxxxxxxxxxxxx>)
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License as
> + * published by the Free Software Foundation; either version 2 of
> + * the License, or (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
> + *
> + *
> + * This driver is based on:
> + *  - information from     http://euc.jp/periphs/xbox-controller.ja.html
> + *  - the iForce driver    drivers/char/joystick/iforce.c
> + *  - the skeleton-driver  drivers/usb/usb-skeleton.c
> + *  - Xbox 360 information http://www.free60.org/wiki/Gamepad
> + *  - xboxdrv docs         http://pingus.seul.org/~grumbel/xboxdrv/
> + *
> + * 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
> + *
> + * TODO:
> + *  - fix "analog" buttons (reported as digital now)
> + *  - need USB IDs for other dance pads
> + *
> + * Driver history is located at the bottom of this file.
> + */
> +
> +#ifndef _XPAD_H
> +#define _XPAD_H
> +
> +#include <linux/kernel.h>
> +#include <linux/init.h>
> +#include <linux/slab.h>
> +#include <linux/stat.h>
> +#include <linux/module.h>
> +#include <linux/usb/input.h>
> +#include <linux/workqueue.h>
> +
> +#if defined(CONFIG_SYSFS)
> +#include <linux/kobject.h>
> +#include <linux/sysfs.h>
> +#include <linux/string.h>
> +#endif


Same here, conditionally including these files is not necessary.


> +
> +#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
> +#include <linux/leds.h>
> +
> +struct xpad_led {
> +	char name[16];
> +	struct led_classdev led_cdev;
> +	struct usb_xpad *xpad;
> +};
> +#endif
> +


Ditto. Actually it's useful for data which consume memory,
or fields inside structures, but not for types themselves.

But well, these parts are a removing, not new code.

Anyway, looks like a nice work.


Frederic.


> +#define DRIVER_AUTHOR "Marko Friedemann <mfr@xxxxxxxxxxxxxxx>"
> +#define DRIVER_DESC "Xbox/360 pad driver"
> +
> +#define XPAD_PKT_LEN 32
> +
> +
> +/* xbox d-pads should map to buttons, as is required for DDR pads
> +   but we map them to axes when possible to simplify things */
> +#define MAP_DPAD_TO_BUTTONS    0
> +#define MAP_DPAD_TO_AXES       1
> +#define MAP_DPAD_UNKNOWN       2
> +
> +/* Type of controller *interface* (original, wired 360, wireless 360) */
> +#define XTYPE_XBOX        0
> +#define XTYPE_XBOX360     1
> +#define XTYPE_XBOX360W    2
> +#define XTYPE_UNKNOWN     3
> +
> +/* Type of controller (e.g. pad, guitar, other input device) */
> +#define XCONTROLLER_TYPE_NONE		0
> +#define XCONTROLLER_TYPE_PAD		1
> +#define XCONTROLLER_TYPE_GUITAR		2
> +#define XCONTROLLER_TYPE_DANCE_PAD	3
> +#define XCONTROLLER_TYPE_OTHER		255
> +
> +
> +/* The Xbox 360 controllers have sensitive sticks that often do not center
> + * exactly. A dead zone causes stick events below a certain threshhold to be
> + * reported as zero.
> + *
> + * The default dead zone size is 8192, which was obtained by testing a
> + * wireless 360 controller with jstest(1) and consulting gaming forums for
> + * a recommended dead zone for this controller. The consensus opinion was
> + * 0.25 (on a scale from 0 to 1), which corresponds to 8192 (out of 32767).
> + */
> +#define XDEAD_ZONE_DEFAULT   8192
> +
> +/* Default limit for the sticks is the maximum axis value (32767), which will
> + * cause the sticks to have a radial axis as designed in the hardware. To
> + * enable square axis support, set the stick limits to 23170 or lower at run
> + * time via the sysfs interface. */
> +#define XSTICK_LIMIT_DEFAULT 32767
> +
> +/* Rumble normally enabled */
> +#define XRUMBLE_DEFAULT		1
> +
> +
> +/* This module parameter is something of a relic, but it remains for
> + * compatibility. Importantly, the option to map the D-PAD buttons applies
> + * only to controller *interfaces* (i.e. vendor and product codes) not
> + * explicitly present in xpad_device[]. */
> +static int dpad_to_buttons = 0;
> +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");
> +
> +
> +/* Table of various device interfaces recognized by this driver. Each supported
> + * device has a directional pad mapping, interface type, and controller type.
> + * Note that wireless 360 devices have XCONTROLLER_TYPE_NONE, as the actual
> + * type of the gaming controller is not known until the controller binds
> + * wirelessly with the receiver
> + */
> +static const struct xpad_device {
> +	u16 idVendor;
> +	u16 idProduct;
> +	char *name;
> +	u8 dpad_mapping;
> +	u8 xtype;
> +	u8 controller_type;
> +} xpad_device[] = {
> +	{ 0x045e, 0x0202, "Microsoft X-Box pad v1 (US)", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x045e, 0x0285, "Microsoft X-Box pad (Japan)", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x045e, 0x0287, "Microsoft Xbox Controller S", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x045e, 0x0719, "Xbox 360 Wireless Receiver", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W,
> +		XCONTROLLER_TYPE_NONE },
> +	{ 0x0c12, 0x8809, "RedOctane Xbox Dance Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_DANCE_PAD },
> +	{ 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x046d, 0xc242, "Logitech Chillstream Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX360,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x046d, 0xca84, "Logitech Xbox Cordless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x046d, 0xca88, "Logitech Compact Controller for Xbox", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x05fd, 0x1007, "Mad Catz Controller (unverified)", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x05fd, 0x107a, "InterAct 'PowerPad Pro' X-Box pad (Germany)", MAP_DPAD_TO_AXES,
> +		XTYPE_XBOX, XCONTROLLER_TYPE_PAD },
> +	{ 0x0738, 0x4516, "Mad Catz Control Pad", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0738, 0x4522, "Mad Catz LumiCON", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0738, 0x4526, "Mad Catz Control Pad Pro", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0738, 0x4536, "Mad Catz MicroCON", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0738, 0x4540, "Mad Catz Beat Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_DANCE_PAD },
> +	{ 0x0738, 0x4556, "Mad Catz Lynx Wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX360,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0738, 0x6040, "Mad Catz Beat Pad Pro", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_DANCE_PAD },
> +	{ 0x0c12, 0x8802, "Zeroplus Xbox Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0c12, 0x880a, "Pelican Eclipse PL-2023", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0c12, 0x8810, "Zeroplus Xbox Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0e4c, 0x1097, "Radica Gamester Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0e4c, 0x2390, "Radica Games Jtech Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0e6f, 0x0003, "Logic3 Freebird wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0e6f, 0x0005, "Eclipse wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0e6f, 0x0006, "Edge wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0e6f, 0x0006, "Pelican 'TSZ' Wired Xbox 360 Controller", MAP_DPAD_TO_AXES,
> +		XTYPE_XBOX360, XCONTROLLER_TYPE_PAD },
> +	{ 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0f30, 0x0202, "Joytech Advanced Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0f30, 0x8888, "BigBen XBMiniPad Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x102c, 0xff0c, "Joytech Wireless Advanced Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x12ab, 0x8809, "Xbox DDR dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_DANCE_PAD },
> +	{ 0x1430, 0x4748, "RedOctane Guitar Hero X-plorer", MAP_DPAD_TO_AXES, XTYPE_XBOX360,
> +		XCONTROLLER_TYPE_GUITAR },
> +	{ 0x1430, 0x8888, "TX6500+ Dance Pad (first generation)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_DANCE_PAD },
> +	{ 0x045e, 0x028e, "Microsoft X-Box 360 pad", MAP_DPAD_TO_AXES, XTYPE_XBOX360,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0xffff, 0xffff, "Chinese-made Xbox Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX,
> +		XCONTROLLER_TYPE_PAD },
> +	{ 0x0000, 0x0000, "Generic X-Box pad", MAP_DPAD_UNKNOWN, XTYPE_UNKNOWN,
> +		XCONTROLLER_TYPE_PAD }
> +};
> +
> +
> +/* buttons shared with xbox and xbox360 */
> +static const signed short xpad_common_btn[] = {
> +	BTN_A, BTN_B, BTN_X, BTN_Y,			/* "analog" buttons */
> +	BTN_START, BTN_BACK, BTN_THUMBL, BTN_THUMBR,	/* start/back/sticks */
> +	-1						/* terminating entry */
> +};
> +
> +/* original xbox controllers only */
> +static const signed short xpad_btn[] = {
> +	BTN_C, BTN_Z,		/* "analog" buttons */
> +	-1			/* terminating entry */
> +};
> +
> +/* only used if MAP_DPAD_TO_BUTTONS */
> +static const signed short xpad_btn_pad[] = {
> +	BTN_LEFT, BTN_RIGHT,		/* d-pad left, right */
> +	BTN_0, BTN_1,			/* d-pad up, down (XXX names??) */
> +	-1				/* terminating entry */
> +};
> +
> +/* buttons for x360 controller */
> +static const signed short xpad360_btn[] = {
> +	BTN_TL, BTN_TR,		/* Button LB/RB */
> +	BTN_MODE,		/* The big X button */
> +	-1
> +};
> +
> +/* sticks and triggers common to all devices */
> +static const signed short xpad_abs[] = {
> +	ABS_X, ABS_Y,		/* left stick */
> +	ABS_RX, ABS_RY,		/* right stick */
> +	ABS_Z, ABS_RZ,		/* triggers left/right */
> +	-1			/* terminating entry */
> +};
> +
> +/* only used if MAP_DPAD_TO_AXES */
> +static const signed short xpad_abs_pad[] = {
> +	ABS_HAT0X, ABS_HAT0Y,	/* d-pad axes */
> +	-1			/* terminating entry */
> +};
> +
> +
> +/* 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. */
> +#define XPAD_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)
> +#define XPAD_XBOX360_VENDOR(vend) \
> +	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,1) }, \
> +	{ XPAD_XBOX360_VENDOR_PROTOCOL(vend,129) }
> +
> +static struct usb_device_id xpad_table [] = {
> +	{ USB_INTERFACE_INFO('X', 'B', 0) },	/* X-Box USB-IF not approved class */
> +	XPAD_XBOX360_VENDOR(0x045e),		/* Microsoft X-Box 360 controllers */
> +	XPAD_XBOX360_VENDOR(0x046d),		/* Logitech X-Box 360 style controllers */
> +	XPAD_XBOX360_VENDOR(0x0738),		/* Mad Catz X-Box 360 controllers */
> +	XPAD_XBOX360_VENDOR(0x0e6f),		/* 0x0e6f X-Box 360 controllers */
> +	XPAD_XBOX360_VENDOR(0x1430),		/* RedOctane X-Box 360 controllers */
> +	{ }
> +};
> +
> +MODULE_DEVICE_TABLE (usb, xpad_table);
> +
> +
> +/* Wireless 360 device identification.
> + *
> + * When a wireless controller connects, the 2nd packet it sends SEEMS to
> + * be some kind of unique controller identification message. Using usbmon
> + * (see Documentation/usb/usbmon.txt), I tried 4 gamepads and a guitar, and
> + * I collected the following 5 ID packets from the 5 devices:
> + *
> + * 000f00f0 00ccfd27 0060e226 63700010 13e3201d 30034001 5001ffff ff
> + * 000f00f0 f0ccfd27 0060d8c4 e9600009 13e7201d 30034001 5001ffff ff
> + * 000f00f0 00ccfd27 0060578b 82f00010 13e3201d 30034001 5001ffff ff
> + * 000f00f0 f0ccfd27 0060da1c b1500009 13e7201d 30034001 5001ffff ff
> + * 000f00f0 f0ccfd27 006002d1 71d10000 13e3201d 30034430 5107ffff ff
> + *
> + * From this trace data, I concocted the following (potentially incorrect)
> + * scheme for detecting type and unique ID:
> + *
> + * ******** xx****xx xxxxxxxx xxxx**xx **xx**** ****tttt tttt**** **
> + *                |  unique id |                    |  type |
> + *
> + * It appears that some of the bytes in the first half of the message, noted
> + * above as "unique id" are some sort of serial number, though I cannot work
> + * out any correspondence between these bytes and the serial number printed
> + * under the battery pack. Many of the bytes in this possibly unique field
> + * are not unique across my controllers, and may not in fact be part of the
> + * controller's unique identification, but I figured it was better to have
> + * extra bytes on either end of the unique byte string instead of the
> + * alternative. In addition, the packet appears to indicate the type of
> + * the controller toward the end: the pads all send 4001 5001, while the
> + * guitar sends 4430 5107.
> + *
> + * Further testing over a wider variety of devices is probably needed to
> + * determine if changes need to be made to this scheme.
> + */
> +static const struct w360_id {
> +	u32 id_bytes;
> +	u8 controller_type;
> +} w360_id[] = {
> +	{ 0x40015001, XCONTROLLER_TYPE_PAD },
> +	{ 0x44305107, XCONTROLLER_TYPE_GUITAR },
> +	{ 0x00000000, XCONTROLLER_TYPE_NONE }
> +};
> +
> +
> +/* Some of the fields in the following structure are for later use with
> + * userspace applications to recognize individual controllers. The dead zones
> + * and axis limits can be changed "on the fly" and are effective immediately.
> + *
> + * The fields labeled "ro" and "rw" are intended to be read-only and
> + * read-write, respectively, when exposed in sysfs. Most of the read-only
> + * fields are to support *wireless* 360 controllers. The controller_number
> + * is used to set the LED, while controller_present tracks whether the
> + * controller is connected to the wireless receiver. Controller type applies
> + * to all models (wired and wireless), and tracks whether the device is a pad,
> + * guitar, etc. for later userspace use. See the comment above regarding
> + * type and unique ID detection on wireless 360 receivers.
> + */
> +struct usb_xpad {
> +	struct input_dev *dev;		/* input device interface */
> +	struct usb_device *udev;	/* usb device */
> +
> +	struct urb *irq_in;		/* urb for interrupt in report */
> +	unsigned char *idata;		/* input data */
> +	dma_addr_t idata_dma;
> +
> +#if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
> +	struct urb *irq_out;		/* urb for interrupt out report */
> +	unsigned char *odata;		/* output data */
> +	dma_addr_t odata_dma;
> +	struct mutex odata_mutex;
> +#endif
> +
> +#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
> +	struct xpad_led *led;
> +#endif
> +
> +	char phys[64];			/* physical device path */
> +
> +	int dpad_mapping;		/* map d-pad to buttons or to axes */
> +	int xtype;			/* type of xbox device */
> +	
> +	/* Work structure for moving the call to xpad_send_led_command
> +	 * outside the interrupt handler for packet processing */
> +	struct work_struct work;
> +	int work_pending;
> +	
> +	int controller_number;		/* controller number (1-4) for 360w. ro */
> +	int controller_present;         /* 360w controller presence detection. ro */
> +	int controller_type;            /* controller type. ro */
> +	char controller_unique_id[17];  /* unique ID of controller (360w). ro */
> +	unsigned int left_dead_zone;    /* dead zone for left stick. rw */
> +	unsigned int right_dead_zone;   /* dead zone for right stick. rw */
> +	unsigned int left_stick_limit;  /* stick axis limit for left stick. rw */
> +	unsigned int right_stick_limit; /* stick axis limit for right stick. rw */
> +	int rumble_enable;              /* enable/disable rumble. rw */
> +	
> +#if defined(CONFIG_SYSFS)
> +	int sysfs_ok;                   /* sysfs interface OK */
> +#endif
> +};
> +#define to_xpad(d) input_get_drvdata(to_input_dev(d))
> +
> +
> +/* Function prototypes for non-sysfs interface functions */
> +static void set_dead_zone(unsigned int new_size, unsigned int *dz, unsigned int stick_limit);
> +static void set_stick_limit(unsigned int new_size, unsigned int *sl, unsigned int dead_zone);
> +static void xpad_init_controller(struct usb_xpad *xpad);
> +static void xpad_send_led_command(struct usb_xpad *xpad, int command);
> +static void xpad_work_controller(struct work_struct *w);
> +static void xpad_process_sticks(struct usb_xpad *xpad, unsigned char *data);
> +static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data);
> +static void xpad360_process_packet(struct usb_xpad *xpad,
> +				   u16 cmd, unsigned char *data);
> +static void xpad360w_identify_controller(struct usb_xpad *xpad, unsigned char *data);
> +static void xpad360w_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *data);
> +static void xpad_irq_in(struct urb *urb);
> +static void xpad_irq_out(struct urb *urb);
> +static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad);
> +static void xpad_stop_output(struct usb_xpad *xpad);
> +static void xpad_stop_output(struct usb_xpad *xpad);
> +static int xpad_play_effect(struct input_dev *dev, void *data,
> +			    struct ff_effect *effect);
> +static int xpad_init_ff(struct usb_xpad *xpad);
> +static void xpad_send_led_command(struct usb_xpad *xpad, int command);
> +static void xpad_led_set(struct led_classdev *led_cdev, enum led_brightness value);
> +static int xpad_led_probe(struct usb_xpad *xpad);
> +static void xpad_led_disconnect(struct usb_xpad *xpad);
> +static int xpad_open(struct input_dev *dev);
> +static void xpad_close(struct input_dev *dev);
> +static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs);
> +static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id);
> +static void xpad_disconnect(struct usb_interface *intf);
> +static int __init usb_xpad_init(void);
> +static void __exit usb_xpad_exit(void);
> +
> +
> +/* sysfs interface */
> +#if defined(CONFIG_SYSFS)
> +static ssize_t xpad_show_uint(struct device *dev, struct device_attribute *attr,
> +		char *buf);
> +static ssize_t xpad_store_uint(struct device *dev,
> +		struct device_attribute *attr, const char *buf, size_t count);
> +static ssize_t xpad_store_rumble_enable(struct device *dev,
> +		struct device_attribute *attr, const char *buf, size_t count);
> +static ssize_t xpad_store_ro(struct device *dev, struct device_attribute *attr,
> +		const char *buf, size_t count);
> +static ssize_t xpad_show_int(struct device *dev, struct device_attribute *attr,
> +		char *buf);
> +static ssize_t xpad_show_id(struct device *dev,
> +		struct device_attribute *attr, char *buf);
> +
> +	
> +
> +/* Device attributes */
> +static DEVICE_ATTR(left_dead_zone, 0666, xpad_show_uint, xpad_store_uint);
> +static DEVICE_ATTR(right_dead_zone, 0666, xpad_show_uint, xpad_store_uint);
> +static DEVICE_ATTR(left_stick_limit, 0666, xpad_show_uint, xpad_store_uint);
> +static DEVICE_ATTR(right_stick_limit, 0666, xpad_show_uint, xpad_store_uint);
> +static DEVICE_ATTR(rumble_enable, 0666, xpad_show_int, xpad_store_rumble_enable);
> +static DEVICE_ATTR(controller_number, 0444, xpad_show_int, xpad_store_ro);
> +static DEVICE_ATTR(controller_present, 0444, xpad_show_int, xpad_store_ro);
> +static DEVICE_ATTR(controller_type, 0444, xpad_show_int, xpad_store_ro);
> +static DEVICE_ATTR(id, 0444, xpad_show_id, xpad_store_ro);
> +
> +static struct attribute *xpad_default_attrs[] = {
> +	&dev_attr_left_dead_zone.attr,
> +	&dev_attr_right_dead_zone.attr,
> +	&dev_attr_left_stick_limit.attr,
> +	&dev_attr_right_stick_limit.attr,
> +	&dev_attr_rumble_enable.attr,
> +	&dev_attr_controller_number.attr,
> +	&dev_attr_controller_present.attr,
> +	&dev_attr_controller_type.attr,
> +	&dev_attr_id.attr,
> +	NULL
> +};
> +
> +static struct attribute_group xpad_default_attr_group = {
> +	.attrs = xpad_default_attrs,
> +	.name = "game_device",
> +};
> +#endif
> +
> +
> +static struct usb_driver xpad_driver = {
> +	.name		= "xpad",
> +	.probe		= xpad_probe,
> +	.disconnect	= xpad_disconnect,
> +	.id_table	= xpad_table,
> +};
> +
> +module_init(usb_xpad_init);
> +module_exit(usb_xpad_exit);
> +
> +MODULE_AUTHOR(DRIVER_AUTHOR);
> +MODULE_DESCRIPTION(DRIVER_DESC);
> +MODULE_LICENSE("GPL");
> +
> +#endif
> +
> +/* Driver History:
> + *
> + * 2009-02-21 : Refactored and changed stick handling
> + *  - split code into two pieces (xpad.h and xpad.c)
> + *  - cleaned up sysfs interface
> + *  - changed square axis algorithm to an axis limit algorithm, which allows
> + *    size of inscribed square to be adjusted; available for both sticks
> + *  - dead zones now per-stick
> + *
> + * 2009-02-18 : Changes per mailing list (and some additions)
> + *  - revised sysfs interface (thanks Greg K-H)
> + *  - check return values of sscanf (thanks Oliver Neukum)
> + *  - urb submission while holding mutex now once again GFP_KERNEL (thanks Oliver Neukum)
> + *  - work structure fixes (thanks Oliver Neukum)
> + *  - uevents generated for wireless controller online/offline
> + *  - sysfs interface only if CONFIG_SYSFS is set
> + *
> + * 2009-02-15 : Minor adjustments
> + *  - added KOBJ_ONLINE/KOBJ_OFFLINE events when controllers are connected to
> + *    or disconnected from the wireless 360 receiver
> + *  - ignore duplicate connect messages on the same connection
> + *  - added option to enable/disable rumble on a per-controller basis
> + *  - rumble events are not sent to guitar or dance pad devices
> + *
> + * 2009-02-14 : Added sysfs interface
> + *  - dead zones and square axis settings can now be made per-controller
> + *  - removed dead_zone and square_axis module parameters (use sysfs)
> + *  - new square axis algorithm
> + *
> + * 2009-02-13 : Disable square axis for right stick
> + *  - square axis applies to left stick only
> + *
> + * 2009-02-12 : Scaling for dead zone and square axis support
> + *  - axes now scale from 0 to 32767 starting at edge of dead zone
> + *  - increased default dead zone to 8192
> + *  - initial square axis support (reliable only with left stick)
> + *
> + * 2009-02-07 : More wireless 360 controller fixes
> + *  - removed bulk urb completely
> + *  - use xpad_send_led_command to set controller number on LED display
> + *    (wireless 360 controller)
> + *  - dead_zone is now an adjustable module parameter
> + *
> + * 2009-02-06 : Axis handling improvements
> + *  - unified handler for left and right sticks
> + *  - initial support for dead zones
> + *
> + * 2009-02-02 : Wireless 360 controller fixes
> + *  - followed PROTOCOL description from xboxdrv userspace driver
> + *  - LED and rumble support added for wireless 360 controller (protocol
> + *    is different from wired!)
> + *
> + * 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
> + *
> + * 2002-07-17 - 0.0.5 : simplified d-pad handling
> + *
> + * 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-14 - 0.0.3 : rework by Vojtech Pavlik
> + *  - indentation fixes
> + *  - usb + input init sequence fixes
> + *
> + * 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-06-27 - 0.0.1 : first version, just said "XBOX HID controller"
> + *
> + */


--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html

[Index of Archives]     [Linux Media]     [Linux Input]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [Old Linux USB Devel Archive]

  Powered by Linux