Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/usb-2.6

This is the very first release of a driver for X-Box gamepads.

Basically, this was hacked away in just a few hours, so don't expect

miracles.

In particular, there is currently NO support for the rumble pack.

You won't find many ff-aware linux applications anyway.

0. Status

---------

0. Notes

--------

Driver updated for kernel 2.6.17.11. (Based on a patch for 2.6.11.4.)

For now, this driver has only been tested on just one Linux-Box.

This one is running a 2.4.18 kernel with usb-uhci on an amd athlon 600.

The number of buttons/axes reported varies based on 3 things:

- if you are using a known controller

- if you are using a known dance pad

- if using an unknown device (one not listed below), what you set in the

  module configuration for "Map D-PAD to buttons rather than axes for unknown

  pads" (module option dpad_to_buttons)

The jstest-program from joystick-1.2.15 (jstest-version 2.1.0) reports

8 axes and 10 buttons.

If you set dpad_to_buttons to 0 and you are using an unknown device (one

not listed below), the driver will map the directional pad to axes (X/Y),

if you said N it will map the d-pad to buttons, which is needed for dance

style games to function correctly.  The default is Y.

dpad_to_buttons has no effect for known pads.

0.1 Normal Controllers

----------------------

With a normal controller, the directional pad is mapped to its own X/Y axes.

The jstest-program from joystick-1.2.15 (jstest-version 2.1.0) will report 8

axes and 10 buttons.

Alls 8 axes work, though they all have the same range (-32768..32767)

All 8 axes work, though they all have the same range (-32768..32767)

and the zero-setting is not correct for the triggers (I don't know if that

is some limitation of jstest, since the input device setup should be fine. I

didn't have a look at jstest itself yet).

play first person shooters with a pad. Your mileage may vary.

0.2 Xbox Dance Pads

-------------------

When using a known dance pad, jstest will report 6 axes and 14 buttons.

For dance style pads (like the redoctane pad) several changes

have been made.  The old driver would map the d-pad to axes, resulting

in the driver being unable to report when the user was pressing both

left+right or up+down, making DDR style games unplayable.

Known dance pads automatically map the d-pad to buttons and will work

correctly out of the box.

If your dance pad is recognized by the driver but is using axes instead

of buttons, see section 0.3 - Unknown Controllers

I've tested this with Stepmania, and it works quite well.

0.3 Unkown Controllers

----------------------

If you have an unkown xbox controller, it should work just fine with

the default settings.

HOWEVER if you have an unknown dance pad not listed below, it will not

work UNLESS you set "dpad_to_buttons" to 1 in the module configuration.

PLEASE if you have an unkown controller, email Dom <binary1230@yahoo.com> with

a dump from /proc/bus/usb and a description of the pad (manufacturer, country,

whether it is a dance pad or normal controller) so that we can add your pad

to the list of supported devices, ensuring that it will work out of the

box in the future.

1. USB adapter

--------------

Before you can actually use the driver, you need to get yourself an

adapter cable to connect the X-Box controller to your Linux-Box.

adapter cable to connect the X-Box controller to your Linux-Box. You

can buy these online fairly cheap, or build your own.

Such a cable is pretty easy to build. The Controller itself is a USB compound

device (a hub with three ports for two expansion slots and the controller

device) with the only difference in a nonstandard connector (5 pins vs. 4 on

standard USB connector).

Such a cable is pretty easy to build. The Controller itself is a USB

compound device (a hub with three ports for two expansion slots and

the controller device) with the only difference in a nonstandard connector

(5 pins vs. 4 on standard USB connector).

You just need to solder a USB connector onto the cable and keep the

yellow wire unconnected. The other pins have the same order on both

you can still use the controller with your X-Box, if you have one ;)

2. driver installation

2. Driver Installation

----------------------

Once you have the adapter cable and the controller is connected, you need

to load your USB subsystem and should cat /proc/bus/usb/devices.

There should be an entry like the one at the end [4].

Currently (as of version 0.0.4), the following three devices are included:

Currently (as of version 0.0.6), the following devices are included:

 original Microsoft XBOX controller (US), vendor=0x045e, product=0x0202

 smaller  Microsoft XBOX controller (US), vendor=0x045e, product=0x0289

 original Microsoft XBOX controller (Japan), vendor=0x045e, product=0x0285

 InterAct PowerPad Pro (Germany), vendor=0x05fd, product=0x107a

 RedOctane Xbox Dance Pad (US), vendor=0x0c12, product=0x8809

If you have another controller that is not listed above and is not recognized

by the driver, please drop me a line with the appropriate info (that is, include

the name, vendor and product ID, as well as the country where you bought it;

sending the whole dump out of /proc/bus/usb/devices along would be even better).

The driver should work with xbox pads not listed above as well, however

you will need to do something extra for dance pads to work.

In theory, the driver should work with other controllers than mine

(InterAct PowerPad pro, bought in Germany) just fine, but I cannot test this

for I only have this one controller.

If you have a controller not listed above, see 0.3 - Unknown Controllers

If you compiled and installed the driver, test the functionality:

> modprobe xpad

> modprobe joydev

> jstest /dev/js0

There should be a single line showing 18 inputs (8 axes, 10 buttons), and

it's values should change if you move the sticks and push the buttons.

If you're using a normal controller, there should be a single line showing

18 inputs (8 axes, 10 buttons), and its values should change if you move

the sticks and push the buttons.  If you're using a dance pad, it should

show 20 inputs (6 axes, 14 buttons).

It works? Voila, your done ;)

It works? Voila, you're done ;)

3. Thanks

E:  Ad=81(I) Atr=03(Int.) MxPS=  32 Ivl= 10ms

E:  Ad=02(O) Atr=03(Int.) MxPS=  32 Ivl= 10ms

5. /proc/bus/usb/devices - dump from Redoctane Xbox Dance Pad (US):

T:  Bus=01 Lev=02 Prnt=09 Port=00 Cnt=01 Dev#= 10 Spd=12  MxCh= 0

D:  Ver= 1.10 Cls=00(>ifc ) Sub=00 Prot=00 MxPS= 8 #Cfgs=  1

P:  Vendor=0c12 ProdID=8809 Rev= 0.01

S:  Product=XBOX DDR

C:* #Ifs= 1 Cfg#= 1 Atr=80 MxPwr=100mA

I:  If#= 0 Alt= 0 #EPs= 2 Cls=58(unk. ) Sub=42 Prot=00 Driver=xpad

E:  Ad=82(I) Atr=03(Int.) MxPS=  32 Ivl=4ms

E:  Ad=02(O) Atr=03(Int.) MxPS=  32 Ivl=4ms

-- 

Marko Friedemann <mfr@bmx-chemnitz.de>

2002-07-16

 - original doc

Dominic Cerquetti <binary1230@yahoo.com>

2005-03-19

 - added stuff for dance pads, new d-pad->axes mappings

obj-$(CONFIG_USB_MOUSE)		+= input/

obj-$(CONFIG_USB_MTOUCH)	+= input/

obj-$(CONFIG_USB_POWERMATE)	+= input/

obj-$(CONFIG_USB_TRANCEVIBRATOR)+= input/

obj-$(CONFIG_USB_WACOM)		+= input/

obj-$(CONFIG_USB_XPAD)		+= input/

obj-$(CONFIG_USB_RIO500)	+= misc/

obj-$(CONFIG_USB_SISUSBVGA)	+= misc/

obj-$(CONFIG_USB_TEST)		+= misc/

obj-$(CONFIG_USB_TRANCEVIBRATOR)+= misc/

obj-$(CONFIG_USB_USS720)	+= misc/

obj-$(CONFIG_USB_ATM)		+= atm/

	{ /* V = Conexant			P = ADSL modem				*/

		USB_DEVICE(0x0572, 0xcb06),	.driver_info = (unsigned long) &cxacru_cb00

	},

	{ /* V = Conexant			P = ADSL modem (ZTE ZXDSL 852)		*/

		USB_DEVICE(0x0572, 0xcb07),	.driver_info = (unsigned long) &cxacru_cb00

	},

	{ /* V = Olitec				P = ADSL modem version 2		*/

		USB_DEVICE(0x08e3, 0x0100),	.driver_info = (unsigned long) &cxacru_cafe

	},

#define OFFSET_d	9		/* size 4 */

#define OFFSET_e	13		/* size 1 */

#define OFFSET_f	14		/* size 1 */

#define TOTAL		15

#define SIZE_7		1

#define SIZE_b		8

static int enable_isoc = DEFAULT_ENABLE_ISOC;

static int sw_buffering = DEFAULT_SW_BUFFERING;

#define DEFAULT_B_MAX_DSL	8128

#define DEFAULT_MODEM_MODE	11

#define MODEM_OPTION_LENGTH	16

static const unsigned char DEFAULT_MODEM_OPTION[MODEM_OPTION_LENGTH] = {

	0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

};

static unsigned int BMaxDSL = DEFAULT_B_MAX_DSL;

static unsigned char ModemMode = DEFAULT_MODEM_MODE;

static unsigned char ModemOption[MODEM_OPTION_LENGTH];

static int num_ModemOption;

module_param(altsetting, uint, S_IRUGO | S_IWUSR);

MODULE_PARM_DESC(altsetting,

		"Alternative setting for data interface (bulk_default: "

		 "Enable software buffering (default: "

		 __MODULE_STRING(DEFAULT_SW_BUFFERING) ")");

module_param(BMaxDSL, uint, S_IRUGO | S_IWUSR);

MODULE_PARM_DESC(BMaxDSL,

		"default: " __MODULE_STRING(DEFAULT_B_MAX_DSL));

module_param(ModemMode, byte, S_IRUGO | S_IWUSR);

MODULE_PARM_DESC(ModemMode,

		"default: " __MODULE_STRING(DEFAULT_MODEM_MODE));

module_param_array(ModemOption, byte, &num_ModemOption, S_IRUGO);

MODULE_PARM_DESC(ModemOption, "default: 0x10,0x00,0x00,0x00,0x20");

#define INTERFACE_DATA		1

#define ENDPOINT_INT		0x81

#define ENDPOINT_BULK_DATA	0x07

#define hex2int(c) ( (c >= '0') && (c <= '9') ? (c - '0') : ((c & 0xf) + 9) )

struct speedtch_params {

	unsigned int altsetting;

	unsigned int BMaxDSL;

	unsigned char ModemMode;

	unsigned char ModemOption[MODEM_OPTION_LENGTH];

};

struct speedtch_instance_data {

	struct usbatm_data *usbatm;

	unsigned int altsetting;

	struct speedtch_params params; /* set in probe, constant afterwards */

	struct work_struct status_checker;

	struct urb *int_urb;

	unsigned char int_data[16];

	unsigned char scratch_buffer[TOTAL];

	unsigned char scratch_buffer[16];

};

/***************

			      0x01, 0x40, 0x04, 0x00, buf, 3, CTRL_TIMEOUT);

	if (ret < 0)

		usb_warn(usbatm, "%s failed on URB150: %d\n", __func__, ret);

	/* Extra initialisation in recent drivers - gives higher speeds */

	/* URBext1 */

	buf[0] = instance->params.ModemMode;

	ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),

			      0x01, 0x40, 0x11, 0x00, buf, 1, CTRL_TIMEOUT);

	if (ret < 0)

		usb_warn(usbatm, "%s failed on URBext1: %d\n", __func__, ret);

	/* URBext2 */

	/* This seems to be the one which actually triggers the higher sync

	   rate -- it does require the new firmware too, although it works OK

	   with older firmware */

	ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),

			      0x01, 0x40, 0x14, 0x00,

			      instance->params.ModemOption,

			      MODEM_OPTION_LENGTH, CTRL_TIMEOUT);

	if (ret < 0)

		usb_warn(usbatm, "%s failed on URBext2: %d\n", __func__, ret);

	/* URBext3 */

	buf[0] = instance->params.BMaxDSL & 0xff;

	buf[1] = instance->params.BMaxDSL >> 8;

	ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),

			      0x01, 0x40, 0x12, 0x00, buf, 2, CTRL_TIMEOUT);

	if (ret < 0)

		usb_warn(usbatm, "%s failed on URBext3: %d\n", __func__, ret);

}

static int speedtch_upload_firmware(struct speedtch_instance_data *instance,

	   because we're in our own kernel thread anyway. */

	msleep_interruptible(1000);

	if ((ret = usb_set_interface(usb_dev, INTERFACE_DATA, instance->altsetting)) < 0) {

		usb_err(usbatm, "%s: setting interface to %d failed (%d)!\n", __func__, instance->altsetting, ret);

	if ((ret = usb_set_interface(usb_dev, INTERFACE_DATA, instance->params.altsetting)) < 0) {

		usb_err(usbatm, "%s: setting interface to %d failed (%d)!\n", __func__, instance->params.altsetting, ret);

		goto out_free;

	}

	unsigned char *buf = instance->scratch_buffer;

	int ret;

	memset(buf, 0, TOTAL);

	memset(buf, 0, 16);

	ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),

			      0x12, 0xc0, 0x07, 0x00, buf + OFFSET_7, SIZE_7,

	instance->usbatm = usbatm;

	/* altsetting and enable_isoc may change at any moment, so take a snapshot */

	instance->altsetting = altsetting;

	/* module parameters may change at any moment, so take a snapshot */

	instance->params.altsetting = altsetting;

	instance->params.BMaxDSL = BMaxDSL;

	instance->params.ModemMode = ModemMode;

	memcpy(instance->params.ModemOption, DEFAULT_MODEM_OPTION, MODEM_OPTION_LENGTH);

	memcpy(instance->params.ModemOption, ModemOption, num_ModemOption);

	use_isoc = enable_isoc;

	if (instance->altsetting)

		if ((ret = usb_set_interface(usb_dev, INTERFACE_DATA, instance->altsetting)) < 0) {

			usb_err(usbatm, "%s: setting interface to %2d failed (%d)!\n", __func__, instance->altsetting, ret);

			instance->altsetting = 0; /* fall back to default */

	if (instance->params.altsetting)

		if ((ret = usb_set_interface(usb_dev, INTERFACE_DATA, instance->params.altsetting)) < 0) {

			usb_err(usbatm, "%s: setting interface to %2d failed (%d)!\n", __func__, instance->params.altsetting, ret);

			instance->params.altsetting = 0; /* fall back to default */

		}

	if (!instance->altsetting && use_isoc)

	if (!instance->params.altsetting && use_isoc)

		if ((ret = usb_set_interface(usb_dev, INTERFACE_DATA, DEFAULT_ISOC_ALTSETTING)) < 0) {

			usb_dbg(usbatm, "%s: setting interface to %2d failed (%d)!\n", __func__, DEFAULT_ISOC_ALTSETTING, ret);

			use_isoc = 0; /* fall back to bulk */

			usb_info(usbatm, "isochronous transfer not supported - using bulk\n");

	}

	if (!use_isoc && !instance->altsetting)

	if (!use_isoc && !instance->params.altsetting)

		if ((ret = usb_set_interface(usb_dev, INTERFACE_DATA, DEFAULT_BULK_ALTSETTING)) < 0) {

			usb_err(usbatm, "%s: setting interface to %2d failed (%d)!\n", __func__, DEFAULT_BULK_ALTSETTING, ret);

			goto fail_free;

		}

	if (!instance->altsetting)

		instance->altsetting = use_isoc ? DEFAULT_ISOC_ALTSETTING : DEFAULT_BULK_ALTSETTING;

	if (!instance->params.altsetting)

		instance->params.altsetting = use_isoc ? DEFAULT_ISOC_ALTSETTING : DEFAULT_BULK_ALTSETTING;

	usbatm->flags |= (use_isoc ? UDSL_USE_ISOC : 0);

#include "usbatm.h"

#define EAGLEUSBVERSION "ueagle 1.3"

#define EAGLEUSBVERSION "ueagle 1.4"

/*

#define UEA_CHIP_VERSION(x) \

	((x)->driver_info & 0xf)

#define IS_ISDN(sc) \

	(le16_to_cpu(sc->usb_dev->descriptor.bcdDevice) & 0x80)

#define IS_ISDN(usb_dev) \

	(le16_to_cpu((usb_dev)->descriptor.bcdDevice) & 0x80)

#define INS_TO_USBDEV(ins) ins->usb_dev

	char *dsp_name;

	if (UEA_CHIP_VERSION(sc) == ADI930) {

		if (IS_ISDN(sc))

		if (IS_ISDN(sc->usb_dev))

			dsp_name = FW_DIR "DSP9i.bin";

		else

			dsp_name = FW_DIR "DSP9p.bin";

	} else {

		if (IS_ISDN(sc))

		if (IS_ISDN(sc->usb_dev))

			dsp_name = FW_DIR "DSPei.bin";

		else

			dsp_name = FW_DIR "DSPep.bin";

static inline int wait_cmv_ack(struct uea_softc *sc)

{

	int ret = wait_event_timeout(sc->cmv_ack_wait,

	int ret = wait_event_interruptible_timeout(sc->cmv_ack_wait,

						   sc->cmv_ack, ACK_TIMEOUT);

	sc->cmv_ack = 0;

		break;

	case 3:		/* fail ... */

		uea_info(INS_TO_USBDEV(sc), "modem synchronization failed\n");

		uea_info(INS_TO_USBDEV(sc), "modem synchronization failed"

				" (may be try other cmv/dsp)\n");

		return -EAGAIN;

	case 4 ... 6:	/* test state */

			release_firmware(sc->dsp_firm);

			sc->dsp_firm = NULL;

		}

		ret = uea_read_cmv(sc, SA_INFO, 10, &sc->stats.phy.firmid);

		if (ret < 0)

			return ret;

		uea_info(INS_TO_USBDEV(sc), "ATU-R firmware version : %x\n",

				sc->stats.phy.firmid);

	}

	/* always update it as atm layer could not be init when we switch to

	if (cmv_file[sc->modem_index] == NULL) {

		if (UEA_CHIP_VERSION(sc) == ADI930)

			file = (IS_ISDN(sc)) ? "CMV9i.bin" : "CMV9p.bin";

			file = (IS_ISDN(sc->usb_dev)) ? "CMV9i.bin" : "CMV9p.bin";

		else

			file = (IS_ISDN(sc)) ? "CMVei.bin" : "CMVep.bin";

			file = (IS_ISDN(sc->usb_dev)) ? "CMVei.bin" : "CMVep.bin";

	} else

		file = cmv_file[sc->modem_index];

	if (ret < 0)

		return ret;

	/* Dump firmware version */

	ret = uea_read_cmv(sc, SA_INFO, 10, &sc->stats.phy.firmid);

	if (ret < 0)

		return ret;

	uea_info(INS_TO_USBDEV(sc), "ATU-R firmware version : %x\n",

			sc->stats.phy.firmid);

	/* get options */

 	ret = len = request_cmvs(sc, &cmvs, &cmvs_fw);

	if (ret < 0)

	/* Enter in R-ACT-REQ */

	ret = uea_write_cmv(sc, SA_CNTL, 0, 2);

	uea_vdbg(INS_TO_USBDEV(sc), "Entering in R-ACT-REQ state\n");

	uea_info(INS_TO_USBDEV(sc), "Modem started, "

		"waiting synchronization\n");

out:

	release_firmware(cmvs_fw);

	sc->reset = 0;

		if (!ret)

			ret = uea_stat(sc);

		if (ret != -EAGAIN)

			msleep(1000);

			msleep_interruptible(1000);

 		if (try_to_freeze())

			uea_err(INS_TO_USBDEV(sc), "suspend/resume not supported, "

				"please unplug/replug your modem\n");

	}

	uea_leaves(INS_TO_USBDEV(sc));

	return ret;

UEA_ATTR(dscorr, 0);

UEA_ATTR(usunc, 0);

UEA_ATTR(dsunc, 0);

UEA_ATTR(firmid, 0);

/* Retrieve the device End System Identifier (MAC) */

{

	struct uea_softc *sc = usbatm->driver_data;

	wait_event(sc->sync_q, IS_OPERATIONAL(sc));

	wait_event_interruptible(sc->sync_q, IS_OPERATIONAL(sc));

	return 0;

	&dev_attr_stat_dscorr.attr,

	&dev_attr_stat_usunc.attr,

	&dev_attr_stat_dsunc.attr,

	&dev_attr_stat_firmid.attr,

	NULL,

};

static struct attribute_group attr_grp = {

	.attrs = attrs,

};

static int create_fs_entries(struct usb_interface *intf)

{

	return sysfs_create_group(&intf->dev.kobj, &attr_grp);

}

static int uea_bind(struct usbatm_data *usbatm, struct usb_interface *intf,

		   const struct usb_device_id *id)

{

		}

	}

	ret = sysfs_create_group(&intf->dev.kobj, &attr_grp);

	if (ret < 0)

		goto error;

	ret = uea_boot(sc);

	if (ret < 0) {

		kfree(sc);

		return ret;

	}

	if (ret < 0)

		goto error;

	ret = create_fs_entries(intf);

	if (ret) {

		uea_stop(sc);

	return 0;

error:

	kfree(sc);

	return ret;

}

	return 0;

}

static void destroy_fs_entries(struct usb_interface *intf)

{

	sysfs_remove_group(&intf->dev.kobj, &attr_grp);

}

static void uea_unbind(struct usbatm_data *usbatm, struct usb_interface *intf)

{

	struct uea_softc *sc = usbatm->driver_data;

	destroy_fs_entries(intf);

	sysfs_remove_group(&intf->dev.kobj, &attr_grp);

	uea_stop(sc);

	kfree(sc);

}

	struct usb_device *usb = interface_to_usbdev(intf);

	uea_enters(usb);

	uea_info(usb, "ADSL device founded vid (%#X) pid (%#X) : %s\n",

	uea_info(usb, "ADSL device founded vid (%#X) pid (%#X) : %s %s\n",

	       le16_to_cpu(usb->descriptor.idVendor),

	       le16_to_cpu(usb->descriptor.idProduct),

	       chip_name[UEA_CHIP_VERSION(id)]);

	       chip_name[UEA_CHIP_VERSION(id)], IS_ISDN(usb)?"isdn":"pots");

	usb_reset_device(usb);